--- layout: post title: A taste of what's coming in Rails 2.1 categories: - documentation author: David published: true date: 2008-04-01 23:28:00.000000000 +01:00 ---
Rails 2.1 is not far off the horizon and we’ve been adding a ton of extra deliciously nice goodies in preparation of its release lately. As always, the good Ryan Daigle has been keeping a watchful eye on the changelog and has been documenting some of the new features. The latest stars are:


This notification includes the data that is updated from the specific service.
Convenience init for all parameters.
- (nonnull instancetype)initWithServiceData:
(nonnull SDLAppServiceData *)serviceData;
init(serviceData: SDLAppServiceData)
The updated app service data
A SDLOnAppServiceData object
The updated app service data.
SDLAppServiceData, Required
@property (nonatomic, strong) SDLAppServiceData *_Nonnull serviceData;
var serviceData: SDLAppServiceData { get set }


{% extends "riddle.html" %} {% block title %}Sequence{% endblock %} {% block subtitle %}Mathematics is fun!{% endblock %} {% block riddle %}
Let's play with simple mathematics.
There is a sequence defined:
What is the value of the 5-th element of the sequence?
{% endblock %}


The Best New Deals + Exclusive Offers from RetailMeNot!
$10 Off $100+ During the Spring Black Friday Sale! Hurry, Ends 4/10!
More top offers include:
jcpenney: 20% Off + Free Shipping on $75
Restaurant.com: $25 Gift Certificates for $4
Overstock: 12% Off Sitewide for New Customers
Macy’s: 30% Off 3+ Pairs of Shoes + Free Shipping on $99
& many more at www.retailmenot.com
Copyright 2013 WhaleShark Media. 301 Congress Avenue, Suite 700, Austin, Texas 78701
To opt-out please reply to this email with UNSUBSCRIBE in the subject line.


--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/can.20you.20help.20me.20make.20it.20clear.html ---
I read the book about lean prover. There is some code like this:
def nat.dvd (m n: ℕ ): Prop := ∃ k, n = m * k instance : has_dvd nat := ⟨nat.dvd ⟩ theorem nat.dvd_refl (n: ℕ ) : n ∣ n := ⟨1, by simp ⟩
I don't know why this theorem can be proved by <1, simp>. What does number 1 mean?
Thank you for making it clear,
You see the k
on the first line?
To prove n | n
, you have to provide a k
. And this proof provides 1
.
Afterwards, you have to prove n = m * k
.
The proof is then by simp
.
Ok, thanks. I see it is trivial now.
By the way, is there any other way. I mean how can we write the code clearer.
Yes. This is called tactic mode.
def nat.dvd (m n: ℕ ): Prop := ∃ k, n = m * k instance : has_dvd nat := ⟨nat.dvd ⟩ theorem nat.dvd_refl (n: ℕ ) : n ∣ n := begin existsi 1, simp end
Oh, ok. How can we unfold the definition of "|", to make it appear like:
\exists k, n = m * k
I mean, to make it look like this:
example (n: ℕ ): ∃ k, n = n * k := _
Do you mean you want to change what the goal looks like, inside the tactic block?
Oh, yes
Two ways. One is that you can use change
to change the goal to something definitionally equivalent, like
change ∃ k, n = n * k,
Of course, that depends on knowing what the unfolded form should be
WHat is the second way
The other way is to use unfold
or dsimp
or related tactics to unfold the ∣
operation, but because it is notation in this case, you need to know the actual name of the operator, which is has_dvd.dvd
Then has_dvd
is a class, so you also need to unfold the actual instance for nat
. If you start with
unfold has_dvd.dvd,
then you'll see what the actual operation is in the goal window -- it's nat.dvd
I tried this:
theorem nat.dvd_refl (n: ℕ ) : n ∣ n := begin unfold nat.dvd, end
But, I got error
So then you can unfold both at once with
unfold has_dvd.dvd nat.dvd,
Yep, because you have to unfold has_dvd.dvd
first.
If you write set_option pp.notation false
before your theorem, you can see what the notation really represents.
Oh, I made it works now.
It run fine
theorem nat.dvd_refl (n: ℕ ) : n ∣ n := begin unfold has_dvd.dvd nat.dvd, end
you can write dsimp [(∣)]
too
Last updated: Apr 24 2020 at 19:02 UTC


Eazy-T
Welcome!
To properly use this app & all of it's features you must register at
torn.com
for your free account.
Login w/ API
Register @ torn.com


{% extends "house/base.html" %} {% load static %} {% load humanize %} {% block content %}
Limited Visibility
High Visibility
High Visibility Featured tag
Highest Visibility Featured tag


Challenge
Define a template based preprocessing mechanism to be used to generate source files in a wizard (mainly C/C++).
Requirements
- interfere as little as possible with the native file source language
- do not interfere with other tools, like Doxygen
- be as simple as possible to process
- syntax must be as standard as possible
Embed metadata inside comments
The natural implementation for the first requirement is similar to that used by Doxygen, i.e. insert the preprocessing metadata as standard comments.
The direct consequence is that the template files are regular source files, they do not introduce a new syntax.
This has two major advantages:
- the template files can be edited with current editors, and do not interfere with syntax colouring;
- the template files can be reformatted with existing formatters.
Inspiration
Although there are many other similar solutions, none that I know meets the above requirements.
Jekyll
The Jekyll static web generator uses the Liquid metadata, which comes in two types: tags (for flow control) and object/filters (for inserting content).
{% if user %}
hello("{{ user.name }}!");
{% endif %}
url="{{ url | append: ".html" }}";
Embedding this metadata into C/C++ comments would look like this:
//@XCDL {% if user %}
hello("{{ user.name }}!");
//@XCDL {% endif %}
url="{{ url | append: ".html" }}";
The syntax remains relatively easy to read, but the Liquid tags still introduce a new language, that needs to be parsed and processed.
Jinja2
The default syntax of Jinja2 matches Django syntax in many ways, and it also very similar to the syntax of Liquid metadata, so it will not be repeated here.
ST CubeMX
CubeMX uses .ftl
files with a complex script syntax, somehow inspired by xml; tags may come in pairs ([if]
, [/if]
), and substitutions are encoded like macros (${argument.name}
).
[#ftl]
[#-- macro generateConfigModelCode --]
[#macro generateConfigModelCode configModel inst nTab index]
[#if configModel.methods??] [#-- if the pin configuration contains a list of LibMethods--]
[#assign methodList = configModel.methods]
[#else]
[#if configModel.methods??]
[#assign methodList = configModel.libMethod]
[/#if]
[/#if]
[#assign writeConfigComments=false]
[#if methodList?? ]
[#list methodList as method]
[#if method.status=="OK"][#assign writeConfigComments=true][/#if]
[/#list]
[#if writeConfigComments]
[#if configModel.comments??] #t#t/**${configModel.comments?replace("#t","#t#t")} #n#t#t*/[/#if]
[/#if]
... ${argument.name} ...
The syntax controls the details of the expansion to the latest details, including generating tabs and new lines (#t
, #n
), so the template s are not really source files, and embedding the metadata as comments doesn’t make much sense.
(The files are in the db/templates
folder; on macOS this is located below STM32CubeMX.app/Contents/Resources
).
Infineon DAVE
In DAVE 4 templates are stored as .tmpl
files and use full Groovy scripts (which look very familiar to Java programmers).
package Model.Common;
out.print("""
/*******************************************************************************
Copyright (c) 2014, Infineon Technologies AG **
All rights reserved. **
*******************************************************************************/
/*******************************************************************************
* @brief This function initializes the Apps Init Functions.
*
* @param[in] None
*
* @return DAVE_STATUS_t

*
* Reentrant: No

*
******************************************************************************/
DAVE_STATUS_t DAVE_Init(void)
{
DAVE_STATUS_t init_status;
init_status = DAVE_STATUS_SUCCESS;
""");
def appsList = daveEnv.project.getTopLevelApps();
def apps = [];
def appName
def instanceLabel
for (def app : appsList ) {
if(app.initProvider) {
apps.add(app);
}
}
out.print("""
/** @Initialization of Apps Init Functions */
""");
for (def app : apps ) {
appName = app.getClass().getSimpleName()
instanceLabel = app.getInstanceLabel()
out.print("""
if (init_status == DAVE_STATUS_SUCCESS)
{
/** Initialization of ${appName} App instance ${instanceLabel} */
init_status = (DAVE_STATUS_t)${appName}_Init(&${instanceLabel});
}
""");
}
out.print("""
return init_status;
} /** End of function DAVE_Init */
""");
The actual content is included with triple quote strings and substitutions are performed on the way, using the ${appName}
syntax.
By using a fully fledged script language, the template engine is very powerful.
However, embedding the C/C++ code as strings in Groovy is quite hard to read.
Templates can be found in Infineon\D_LibraryStore_4.1\DeviceFeatures\pack\2.0.0\CE_Templates\TLE
Freescale Processor Expert
The late Processor Expert is probably the grand-dad of all component code-generating solutions. It was designed as the ultimate solution, and indeed it provides lots of features, but at the cost of a very high complexity. (for an overview, please read this article).
There are many XML file with lots of definitions.
The templates are .drv
files, and the syntax looks like:
%-
%INTERFACE
%define! Settings Common\FAT_FileSystemSettings.Inc
%define! Abstract Common\FAT_FileSystemAbstract.Inc
%include Common\Header.h
#ifndef __%'ModuleName'_H
#define __%'ModuleName'_H
/* MODULE %ModuleName. */
/* Wrappers to FatFS types and constants */
#define %'ModuleName'%.FATFS FATFS
#define %'ModuleName'%.DIR DIR
#define %'ModuleName'%.FIL FIL
#define %'ModuleName'%.FILINFO FILINFO
#define %'ModuleName'%.FS_READONLY _FS_READONLY
#define %'ModuleName'%.USE_LFN _USE_LFN
#define %'ModuleName'%.MAX_LFN _MAX_LFN
#define %'ModuleName'%.FS_REENTRANT _FS_REENTRANT
#define %'ModuleName'%.MAX_SS _MAX_SS
#define %'ModuleName'%.FS_RPATH _FS_RPATH
#define %'ModuleName'%.FRESULT FRESULT
#define %'ModuleName'%.DRESULT DRESULT
%ifdef SharedModules
/* Include shared modules, which are used for whole project */
%for var from IncludeSharedModules
#include "%'var'.h"
%endfor
%endif
/* Include inherited beans */
%ifdef InhrSymbolList
%for var from InhrSymbolList
#include "%<EMAIL_ADDRESS>%endfor
%endif
...
%-************************************************************************************************************
%-BW_METHOD_BEGIN RenameFile
%ifdef RenameFile
%define! ParsrcFileName
%define! PardstFileName
%define! Pario
%define! RetVal
%include Common\FAT_FileSystemRenameFile.Inc
/*!
* \brief Renames a file
* \param[in] srcFileName Source/existing file name
* \param[in] dstFileName Destination/new file name
* \param[in] io IO handler for output
* \return Error code, ERR_OK for success.
*/
uint8_t %'ModuleName'%.%RenameFile(const uint8_t *srcFileName, const uint8_t *dstFileName, const %<EMAIL_ADDRESS>*io)
{
%'ModuleName'%.FRESULT fres;
if (%'ModuleName'%.isWriteProtected((uint8_t*)"")) {
%@Shell@'ModuleName'%.SendStr((unsigned char*)"disk is write protected!\r\n", io->stdErr);
return ERR_FAILED;
}
fres = %'ModuleName'%.rename((char*)srcFileName, (char*)dstFileName);
if(fres!=FR_OK) {
FatFsFResultMsg((unsigned char*)"rename failed", fres, io);
return ERR_FAILED;
}
return ERR_OK;
}
%endif %- RenameFile
%-BW_METHOD_END RenameFile
%-************************************************************************************************************
As far as I can tell, Processor Expert implements some kind of objects, named components, described by a template. This template can be instantiated for specific devices, like USART1, USART2, etc. People I respect consider that once the components are written, using them is quite convenient. The real challenge is to write these components, and this process can be done only with Processor Expert.
The syntax is quite complex, with commands similar to the C preprocessor (%ifdef name
), but also with complex substitutions, like %@Shell@'ModuleName'%.name(...)
.
The components can be found in the C:\ProgramData\Processor Expert\PEXDRV_PE5_3
folder.
AC6 System Workbench
The STM32 System Workbench currently does not use templates.
Eclipse CDT template wizard
The Eclipse CDT template mechanism uses several processes, mainly to copy files and to change the project configuration (add symbol definitions, folders, etc).
Like most other things in Eclipse, the definitions reside in a very verbose xml file. Preprocessing is basic, only macro substitutions. Conditional execution is limited to one level, and the implementation is not very fortunate.
Apache FreeMarker
FreeMarker is another nice Apache Java project.
The templates are written in FTL (FreeMarket Template Language), which has an XML-like syntax, for example:
<#if animals.python.protected>
Pythons are protected animals!
</#if>
Substitutions are encoded as ${...}
and the data comes from a data-model which is a collection of Java objects.
The language has a large number of tags, but it cannot compete with a true scripting language.
Although it probably can handle any format, most examples in the FreeMarker documentation refer to generating HTML or XML output, which might be an indication of its intended audience.
Scripting proposal
It looks like using some kind of scripting language is inevitable. Defining a custom one, even inspired by an existing solution, is possible, but implementing it requires significant efforts.
With the omnipresent JavaScript, a simpler solution might be to implement the scripting part in JavaScript.
The DAVE idea to have the entire template as a script is interesting, but an even better option might be to generate this script.
So, the current proposal to be used by the XCDL preprocessor is to convert the entire template file into JavaScript, and to execute it.
JavaScript implementations
Executing JavaScript inside another program might be a problem, but mature JavaScript implementations are now available for most platforms and languages, for example:
Possible syntax solutions
Assuming the tags will be encoded as comments, the simplest solution would be to prefix the lines with a specific comment:
//@XCDL
To simplify things even further, there should be no other non-spaces before this separator.
JavaScript
With the choice for JavaScript and this simple syntax, the process to convert the templates to JavaScript is relatively straightforward: process line by line, identify //@XCDL
, pass the tags as-is, and encode all other source line in an output call.
For example:
//@XCDL if (variable==="value") {
... C/C++ lines ...
//@XCDL }
translates into:
if (variable==="value") {
o("... C/C++ lines ...\n");
}
where o(str)
is a function that outputs the string to the destination file.
Substitutions are can be identified and processed by the JavaScript, or can be optimised by generating a JavaScript code that converts the values to strings and outputs them.
#define VARIABLE ($(value+1))
can be translated to:
o("#define VARIABLE (");o(String(value+1));o(")\n");
Examples
With these conventions, the first sample would look like:
//@XCDL if (defined('user')) {
hello ("$(user.name)!");
//@XCDL }
url = "$(url+'.html'))";
As expected, this is perfectly legal C syntax. The JavaScript code uses a function defined()
that checks if an object is defined, and, if so, expands the name
attribute of this object.
A more complex example would generate the main.c
/main.cpp
files in the STM32F4 template:
//
// This file is part of the GNU ARM Eclipse distribution.
// Copyright (c) 2016 Liviu Ionescu.
//
// ----------------------------------------------------------------------------
#include <stdio.h>
#include "diag/trace.h"
//@XCDL if (content==="blinky") {
//@XCDL if (fileExtension==="c") {
#include "timer.h"
#include "blink_led.h"
//@XCDL } else if (fileExtension==="cpp") {
#include "timer.h"
#include "blink_led.h"
//@XCDL } // fileExtension
//@XCDL } // content
// ----------------------------------------------------------------------------
//
//@XCDL if (content==="blinky") {
//@XCDL if (syscalls==="none") {
// Standalone $(shortChipFamily) led blink sample (trace via $(trace)).
// In debug configurations, demonstrate how to print a greeting message
// on the trace device. In release configurations the message is
// simply discarded.
//
// Then demonstrates how to blink a led with 1 Hz, using a
// continuous loop and SysTick delays.
//@XCDL } else if (syscalls==="retarget") {
// $(shortChipFamily) led blink sample (trace via $(trace)).
// In debug configurations, demonstrate how to print a greeting message
// on the trace device. In release configurations the message is
// simply discarded.
//
// To demonstrate POSIX retargetting, reroute the STDOUT and STDERR to the
// trace device and display messages on both of them.
//
// Then demonstrates how to blink a led with 1 Hz, using a
// continuous loop and SysTick delays.
//
// On DEBUG, the uptime in seconds is also displayed on the trace device.
//@XCDL } else if (syscalls==="semihosting") {
// Semihosting $(shortChipFamily) led blink sample (trace via $(trace)).
// In debug configurations, demonstrate how to print a greeting message
// on the trace device. In release configurations the message is
// simply discarded.
//
// To demonstrate semihosting, display a message on the standard output
// and another message on the standard error.
//
// Then demonstrates how to blink a led with 1 Hz, using a
// continuous loop and SysTick delays.
//
// On DEBUG, the uptime in seconds is also displayed on the trace device.
//@XCDL } // syscalls
//@XCDL } else if (content==="empty") {
//@XCDL if (syscalls==="none") {
// Standalone $(shortChipFamily) empty sample (trace via $(trace)).
//@XCDL } else if (syscalls==="retarget") {
// $(shortChipFamily) empty sample (trace via $(trace)).
//@XCDL } else if (syscalls==="semihosting") {
// Semihosting $(shortChipFamily) empty sample (trace via $(trace)).
//@XCDL } // syscalls
//@XCDL } // content
//
// Trace support is enabled by adding the TRACE macro definition.
// By default the trace messages are forwarded to the $(trace) output,
// but can be rerouted to any device or completely suppressed, by
// changing the definitions required in system/src/diag/trace_impl.c
// (currently OS_USE_TRACE_ITM, OS_USE_TRACE_SEMIHOSTING_DEBUG/_STDOUT).
//
//@XCDL if "$(content==="blinky") {
// The external clock frequency is specified as a preprocessor definition
// passed to the compiler via a command line option (see the 'C/C++ General' ->
// 'Paths and Symbols' -> the 'Symbols' tab, if you want to change it).
// The value selected during project creation was HSE_VALUE=$(hseValue).
//
// Note: The default clock settings take the user defined HSE_VALUE and try
// to reach the maximum possible system clock. For the default 8 MHz input
// the result is guaranteed, but for other values it might not be possible,
// so please adjust the PLL settings in system/src/cmsis/system_$(CMSIS_name).c
//
//@XCDL if (fileExtension==="c") {
// ----- Timing definitions ---------------------------------------------------
// Keep the LED on for 2/3 of a second.
#define BLINK_1S_TICKS (TIMER_FREQUENCY_HZ)
#define BLINK_ON_TICKS (TIMER_FREQUENCY_HZ * 2 / 3)
#define BLINK_OFF_TICKS (TIMER_FREQUENCY_HZ - BLINK_ON_TICKS)
//@XCDL } else if (fileExtension==="cpp") { */
// Definitions visible only within this translation unit.
//@XCDL // This hack is required to avoid confusing the formatter.
$("namespace")
{
// ----- Timing definitions -----------------------------------------------
// Keep the LED on for 2/3 of a second.
constexpr timer::ticks_t BLINK_1S_TICKS = timer::FREQUENCY_HZ;
constexpr timer::ticks_t BLINK_ON_TICKS = timer::FREQUENCY_HZ * 2 / 3;
constexpr timer::ticks_t BLINK_OFF_TICKS = timer::FREQUENCY_HZ - BLINK_ON_TICKS;
}
//@XCDL } // fileExtension
//@XCDL } // content
// ----- main() ---------------------------------------------------------------
// Sample pragmas to cope with warnings. Please note the related line at
// the end of this function, used to pop the compiler diagnostics status.
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wmissing-declarations"
#pragma GCC diagnostic ignored "-Wreturn-type"
int
main (int argc, char* argv[])
{
//@XCDL if (content==="blinky") {
//@XCDL if (syscalls==="retarget") {
// By customising __initialize_args() it is possible to pass arguments,
// for example when running tests with semihosting you can pass various
// options to the test.
// trace_dump_args(argc, argv);
//@XCDL } else if (syscalls==="semihosting") {
// Show the program parameters (passed via semihosting).
// Output is via the semihosting output channel.
trace_dump_args (argc, argv);
//@XCDL } // syscalls
// Send a greeting to the trace device (skipped on Release).
trace_puts ("Hello ARM World!");
//@XCDL if (syscalls==="retarget") {
// The standard output and the standard error should be forwarded to
// the trace device. For this to work, a redirection in _write.c is
// required.
// Send a message to the standard output.
puts ("Standard output message.");
// Send a message to the standard error.
fprintf (stderr, "Standard error message.\n");
//@XCDL } else if (syscalls==="semihosting") {
// Send a message to the standard output.
puts ("Standard output message.");
// Send a message to the standard error.
fprintf (stderr, "Standard error message.\n");
//@XCDL } // syscalls
// At this stage the system clock should have already been configured
// at high speed.
trace_printf ("System clock: %u Hz\n", SystemCoreClock);
//@XCDL if (fileExtension==="c") {
timer_start ();
blink_led_init ();
uint32_t seconds = 0;
// Infinite loop
for (int i = 0;; i++)
{
blink_led_on ();
timer_sleep (i == 0 ? BLINK_1S_TICKS : BLINK_ON_TICKS);
blink_led_off ();
timer_sleep (BLINK_OFF_TICKS);
++seconds;
// Count seconds on the trace device.
trace_printf ("Second %u\n", seconds);
}
//@XCDL } else if (fileExtension==="cpp") {
timer tm;
tm.start ();
blink_led led;
// Perform all necessary initialisations for the LED.
led.powerUp ();
uint32_t seconds = 0;
// Infinite loop
for (int i = 0;; i++)
{
led.turnOn ();
timer_sleep (i == 0 ? BLINK_1S_TICKS : BLINK_ON_TICKS);
led.turnOff ();
tm.sleep (BLINK_OFF_TICKS);
++seconds;
// Count seconds on the trace device.
trace::printf ("Second %u\n", seconds);
}
//@XCDL } // fileExtension
// Infinite loop, never return.
//@XCDL } else if (content==="empty") {
// At this stage the system clock should have already been configured
// at high speed.
// Infinite loop
while (1)
{
// Add your code here.
}
//@XCDL } // content */
}
#pragma GCC diagnostic pop
// ----------------------------------------------------------------------------


Martin Lewis shares his mantra with shoppers ahead of Black Friday sales
Martin Lewis has warned shoppers ahead of what is fast becoming the biggest shopping day of the year
by James RodgersMartin Lewis , the Money Saving Expert, has shared his shopping mantra to help bargain hunters stay out of financial trouble.
The MSE founder and financial guru spoke out on ITV daytime favourite Good Morning Britain today.
Each year, scams surface around Black Friday - and Brits could find themselves paying over the odds for goods - and losing out on money entirely.
He told Susanna Reid and Ben Shephard, who were presenting the show: "So here is my mantra;
"Ask yourself, 'do I need it?', 'is it worth it?' and 'have I checked if I can get it cheaper elsewhere?'
"If the answer to any of them is 'no', don't buy it."
Mr Lewis is a regular feature on a string of daytime ITV1 shows - including GMB, This Morning and Lorraine.
This year, Black Friday falls on November 29 with Cyber Monday continuing the shopping frenzy on December 2.
A huge array of retailers are already offering discounted products meaning you can start bargain hunting now.


Taking the Coursera Machine Learning course. Will post condensed notes every week as part of the review process. All material originates from the free Coursera course, taught by Andrew Ng.
Assumes you have knowledge of Week 10.
Table of Contents
- Lecture notes:
Application Example: Photo OCR
Photo OCR
Problem Description and Pipeline
Photo OCR (Object Character Recognition) is the task of trying to recognize objects, characters (words and digits) given an image. This can be done as a type of machine learning pipeline where the different stages of the image recognition algorithm are broken out into various learning algorithm steps.
For example, a pipeline could be:
- Detect bounding boxes of text in an image
- Perform character segmentation within the bounding box of text
- Classify the individual character into some ASCII value
- Perform spelling correction on the cummulative classified word
Sliding Windows
Example problem; pedestrial detection in an image.
Given an image, create a small window (for instace, your image is 800x300, and you use a window size of 80x30). Starting at the top left corner of the image, run that patch through your classifier to determine if the object is human or not. Then, move the window to the right by some step size (stride) and run that patch through the classifier again. When the window reaches the right of the screen, start again from the left side of the screen with the window moved slightly lower than before.
Once the whole image is completed, perform the same thing with a larger image patch. eg. 100x40
Getting Lots of Data and Artificial Data
How do you get a lot of data to train your OCR algorithm?
For text recognition, you can generate input data by using a variety of fonts and backgrounds. Create an application that outputs many images with text, random backgrounds, random fonts. Another way would be to use existing images of text and apply distortions (blur, warping).
For something like audio, you could modify your original audio clip to have some background noises (beeps, noisy crowds) in order to create more input data.
The distortions you use should be similar to some examples you want to classify. If you have random distortions that are not relevant to your classification, it would be meaningless noise and would be less likely to be useful.
- Make sure you have a low bias classifier before expanding your data set. Keep increasing the number of features/number of hidden units in your neural network until you have a low bias classifier.
- Ask: “How much work would it be to get 10x the amount of data as we currently have?”
- artificial data synthesis
- distort existing examples
- collect data, label it yourself
- crowd source (eg. “Amazon Mechanical Turk”)
Ceiling Analysis: What Part of the Pipeline to Work on Next
What part of the pipeline should we work on improving?
At each part of the pipeline, take that individual step and maximize that portion of the pipeline manually. See how much the overall performance of the system improves. This can give insight into which portion of the pipeline can give the highest improvement.
Coursera Machine Learning course finished.


Copyright © 2017 ESIP, ESIP liability, trademark and document use rules apply.
The Semantic Sensor Network Ontology (commonly known as "SSN" or sometimes "SSNO") is an OWL-2 DL ontology for describing sensors and the observations they make of the physical world. SSN is published in a modular architecture that supports the judicious use of "just enough" ontology for diverse applications, including satellite imagery, large scale scientific monitoring, industrial and household infrastructure, citizen observers, and Web of Things. SSN is described and examples of its use are given.
The namespace for SSN terms is http://www.w3.org/ns/ssn/
The suggested prefix for the SSN namespace is ssn
The SSN ontology itself is available here.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
This is the first published version of the SSN since its original publication by the SSN-XG, the Semantic Sensor Network Incubator Group of the W3C. This is a very incomplete draft to indicate the scope and style of changes proposed to be made to the original SSN. This document is both incomplete and inconsistent, but is being published at this stage to solicit comment from the community of SSN users and would-be users.
For OGC This is a Public Draft of a document prepared by the Spatial Data on the Web Working Group (SDWWG) — a joint W3C-OGC project (see charter). The document is prepared following W3C conventions. The document is released at this time to solicit public comment.
This document was published by the Spatial Data on the Web Working Group as a First Public Working Draft. This document is intended to become a W3C Recommendation. If you wish to make comments regarding this document, please send them to<EMAIL_ADDRESS>(subscribe, archives). All comments are welcome.
Publication as a First Public Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.
This document is governed by the 1 September 2015 W3C Process Document.
This section is non-normative.
Sensor observations are a major source of data published on the Web. Yet, publishing, searching, reusing, and integrating this data requires more than just the observation values. Of equal importance is information about the studied feature of interest, such as a river, the observed property, such as flow velocity, and the sampling strategy. The sampling location, instrumentation, and information about the deployment of the instruments on a sensor platform may also be required for proper interpretation. OGC's Sensor Web Enablement standards [SWE] provide a means to annotate sensors and their observations. However, these standards are not yet integrated and aligned with paradigms such as Linked Data and W3C Semantic Web technologies more generally, that are believed to be a key driver for creating and maintaining a global and densely interconnected graph of data. The W3C Semantic Sensor Network Incubator Group (SSN) addressed these issues by developing an ontology that spans over multiple OGC standards and other specifications to support the semantic lifting of observations together with data about the sensors and their capabilities, deployment information, and so forth. Based on this initial work, the following document specifies a revised, modularized, and extended version of the SSN [SSNO].
This section is non-normative.
Justify why we are changing SSN at all
The DOLCE ultralite ontology [DUL] was previously imported into SSN and many SSN terms inherited from DUL terms. This has been redesigned into two separate ontology modules so that SSN can be used quite independently of DUL if desired. Those parts of SSN that use DUL terms have been separated into the SSN Alignment with DUL ontology.
This DUL alignment does not yet reflect the recent change to the namespace of DUL itself.
Please see section 3. Modularisation for more information.
The movement of Sensor to become a direct subclass of dul:Object has been discussed but postponed by the Working Group
A thorough check on annotation properties is yet to be made.
This section is non-normative.
One of the major issues practitioners raised with the Semantic Sensor Network Ontology as defined in the XG is its complexity, partly due to the layering underneath the DOLCE UltraLite Upperlevel ontology. This section explains the rationale and method for modularisation of the SSN.
Ontology modularisation is a common method investigated in ontology engineering to segment an ontology into smaller parts. In general, ontology modularization aims at providing users of ontologies with the knowledge they require, reducing the scope as much as possible to what is strictly necessary in a given use case. Two main categories of ontology modularization can be distinguished.
The first category comprises of approaches that focus on the composition of existing ontologies by means of integrating and mapping ontologies, most commonly through owl:import
statements. OWL import has a direction from a source ontology to a target ontology, and although it is transitive, it only supports knowledge propagation in one direction, i.e. the importing ontology captures all the meaning of the imported terms used, i.e., it includes all axioms relevant to the meaning of these terms, however, the imported ontology may not capture any of the semantics of the importing ontology.
The second category comprises of mapping approaches that aim to partition and extract parts of ontologies as modules. These mapping approaches are not necessarily directional, but most approaches of ontology extraction rely on directionality of the imported modules. In fact in [Cuenca Grau et al 2009] it has been proven that in OWL DL, which is a syntactical variant of the Description Logic SHOIN, checking whether an ontology is in fact a module of an ontology given a vocabulary is an undecidable problem. However, the main feature of an ontology module under the second category is that it is self-contained, i.e., the module captures the meaning of the imported terms used by including all axioms relevant to the meaning of these terms. This means, that the result of certain reasoning tasks such as subsumption or query answering within a single module should be possible and result in the same answers without the need to access other modules of the ontology.
In order to ensure this property, a solution has to be found for concepts in the ontology module that inherit object properties from concepts that are not in the module. One solution proposed by [Cuenca Grau et al] is to include the bottom concept for all such missing concepts. Another solution is to change the domain and range of an object property. Our modularisation approach uses two different methods depending on the directionality of the segmentation.
Figure 1 gives an overview of the modules of the SSN ontology. The layering of the rings represents two methods of segmentation we distinguish, horizontal and vertical segmentation, as follows:
Vertical modules are built upon each other, i.e. they directionally owl:import lower level modules. If a higher level module is used without importing its lower levels it may lead to inconsistencies or at least it will lead to different answers when reasoning over the module compared to reasoning over its complete stack of vertical ontology modules. However, lower level modules are independent of their higher level modules and logically consistent. Note that higher level here is not to be confused with upper level ontologies. Upper level ontologies are general knowledge ontologies that can be directionally imported in many domains, whereas our definition of higher level ontologies here refers to an ontology that extends one or several ontology modules to capture a larger part of a knowledge domain and/or combine knowledge domains.
Modules that are horizontally layered do not depend on each other, i.e. they do not rely on the import of another horizontal module to lead to the same answers when reasoning over the module itself as opposed to reasoning over an imported horizontal module. If a concept in a module is connected to a concept in another horizontally layered module through a directional property such as a subClassOf relation or any asymmetric property, the range concept of such a relation has to be included in the module using the URI of the concept as it is defined in the other module.
This presentation on modularisation is incomplete. For example, we may have that the SSN core is an RDFS-only vocabulary with modular extensions supporting both expanded terms and expanded expressiveness in the ontology language.
Documentation in this section has been adapted from that generated by LODE from the current version of the SSN ontology (but separated from DUL). The document will be changed to reflect the developments outlined in the work plan of the SSN working group. Similarly, the diagram included here shows the current version of the ontology and will be replaced as the ontology changes.
This section is non-normative.
http://www.w3.org/ns/ssn/Accuracy
The closeness of agreement between the value of an observation and the true value of the observed quality.
http://www.w3.org/ns/ssn/BatteryLifetime
Total useful life of a battery.
http://www.w3.org/ns/ssn/Condition
Used to specify ranges for qualities that act as conditions on a system/sensor's operation. For example, wind speed of 10-60m/s is expressed as a condition linking a quality, wind speed, a unit of measurement, metres per second, and a set of values, 10-60, and may be used as the condition on a MeasurementProperty, for example, to state that a sensor has a particular accuracy in that condition.
http://www.w3.org/ns/ssn/Deployment
The ongoing Process of Entities (for the purposes of this ontology, mainly sensors) deployed for a particular purpose. For example, a particular Sensor deployed on a Platform, or a whole network of Sensors deployed for an observation campaign. The deployment may have sub processes, such as installation, maintenance, addition, and decomissioning and removal.
http://www.w3.org/ns/ssn/DeploymentRelatedProcess
Place to group all the various Processes related to Deployment. For example, as well as Deployment, installation, maintenance, deployment of further sensors and the like would all be classified under DeploymentRelatedProcess.
http://www.w3.org/ns/ssn/DetectionLimit
An observed value for which the probability of falsely claiming the absence of a component in a material is beta, given a probability alpha of falsely claiming its presence.
http://www.w3.org/ns/ssn/Device
A device is a physical piece of technology - a system in a box. Devices may of course be built of smaller devices and software components (i.e. systems have components).
http://www.w3.org/ns/ssn/Drift
A, continuous or incremental, change in the reported values of observations over time for an unchanging quality.
http://www.w3.org/ns/ssn/FeatureOfInterest
A feature is an abstraction of real world phenomena (thing, person, event, etc).
http://www.w3.org/ns/ssn/MaintenanceSchedule
Schedule of maintenance for a system/sensor in the specified conditions.
http://www.w3.org/ns/ssn/MeasurementCapability
Collects together measurement properties (accuracy, range, precision, etc) and the environmental conditions in which those properties hold, representing a specification of a sensor's capability in those conditions. The conditions specified here are those that affect the measurement properties, while those in OperatingRange represent the sensor's standard operating conditions, including conditions that don't affect the observations.
http://www.w3.org/ns/ssn/MeasurementProperty
An identifiable and observable characteristic of a sensor's observations or ability to make observations.
http://www.w3.org/ns/ssn/MeasurementRange
The set of values that the sensor can return as the result of an observation under the defined conditions with the defined measurement properties. (If no conditions are specified or the conditions do not specify a range for the observed qualities, the measurement range is to be taken as the condition for the observed qualities.)
http://www.w3.org/ns/ssn/MeasurementFrequency
The smallest possible time between one observation and the next.
http://www.w3.org/ns/ssn/MeasurementLatency
The time between a request for an observation and the sensor producing a result (not including network latency to retrieve the result, just time from request to measurement.).
http://www.w3.org/ns/ssn/Observation
An Observation is a Situation in which a Sensing method has been used to estimate or calculate a value of a Property of a FeatureOfInterest. Links to Sensing and Sensor describe what made the Observation and how; links to Property and Feature detail what was sensed; the result is the output of a Sensor; other metadata details times etc.
http://www.w3.org/ns/ssn/ObservationValue
The value of the result of an Observation. An Observation has a result which is the output of some sensor, the result is an information object that encodes some value for a Feature.
http://www.w3.org/ns/ssn/OperatingPowerRange
Power range in which system/sensor is expected to operate.
http://www.w3.org/ns/ssn/OperatingProperty
An identifiable characteristic of the environmental and other conditions in which the sensor is intended to operate. May include power ranges, power sources, standard configurations, attachments and the like.
http://www.w3.org/ns/ssn/OperatingRange
The environmental conditions and characteristics of a system/sensor's normal operating environment. Can be used to specify for example the standard environmental conditions in which the sensor is expected to operate (a Condition with no OperatingProperty), or how the environmental and other operating properties relate: i.e., that the maintenance schedule or power requirements differ according to the conditions.
http://www.w3.org/ns/ssn/Platform
An Entity to which other Entities can be attached - particularly Sensors and other Platforms. For example, a post might act as the Platform, a buoy might act as a Platform, or a fish might act as a Platform for an attached sensor.
http://www.w3.org/ns/ssn/Precision
The closeness of agreement between replicate observations on an unchanged or similar quality value: i.e., a measure of a sensor's ability to consitently reproduce an observation.
http://www.w3.org/ns/ssn/Property
An observable Quality of an Event or Object. That is, not a quality of an abstract entity as is also allowed by DUL's Quality, but rather an aspect of an entity that is intrinsic to and cannot exist without the entity and is observable by a sensor.
http://www.w3.org/ns/ssn/Resolution
The smallest difference in the value of a quality being observed that would result in perceptably different values of observation results.
http://www.w3.org/ns/ssn/ResponseTime
The time between a (step) change inthe value of an observed quality and a sensor (possibly with specified error) 'settling' on an observed value.
http://www.w3.org/ns/ssn/Selectivity
Selectivity is a property of a sensor whereby it provides observed values for one or more qualities such that the values of each quality are independent of other qualities in the phenomenon, body, or substance being investigated.
http://www.w3.org/ns/ssn/Sensing
The description of a process (i.e. describes the temporal and dataflow dependencies and relationships amongst its parts) that results in the estimation, or calculation, of the value of a phenomenon.
http://www.w3.org/ns/ssn/SensingDevice
A sensing device is a device that implements sensing.
http://www.w3.org/ns/ssn/Sensitivity
Sensitivity is the quotient of the change in a result of sensor and the corresponding change in a value of a quality being observed.
http://www.w3.org/ns/ssn/Sensor
A sensor can do (implements) sensing: that is, a sensor is any entity that can follow a sensing method and thus observe some Property of a FeatureOfInterest. Sensors may be physical devices, computational methods, a laboratory setup with a person following a method, or any other thing that can follow a Sensing Method to observe a Property.
http://www.w3.org/ns/ssn/SensorDataSheet
A data sheet records properties of a sensor. A data sheet might describe for example the accuracy in various conditions, the power use, the types of connectors that the sensor has, etc. Generally a sensor's properties are recorded directly (with hasMeasurementCapability, for example), but the data sheet can be used for example to record the manufacturers specifications verses observed capabilites, or if more is known than the manufacturer specifies, etc. The data sheet is an information object about the sensor's properties, rather than a direct link to the actual properties themselves.
http://www.w3.org/ns/ssn/SensorOutput
A sensor outputs a piece of information (an observed value), the value itself being represented by an ObservationValue.
http://www.w3.org/ns/ssn/Stimulus
An Event in the real world that 'triggers' the sensor. The properties associated to the stimulus may be different to eventual observed property. It is the event, not the object that triggers the sensor.
http://www.w3.org/ns/ssn/SurvivalProperty
An identifiable characteristic that represents the extent of the sensors useful life. Might include for example total battery life or number of recharges, or, for sensors that are used only a fixed number of times, the number of observations that can be made before the sensing capability is depleted.
http://www.w3.org/ns/ssn/SurvivalRange
The conditions a sensor can be exposed to without damage: i.e., the sensor continues to operate as defined using MeasurementCapability. If, however, the SurvivalRange is exceeded, the sensor is 'damaged' and MeasurementCapability specifications may no longer hold.
http://www.w3.org/ns/ssn/System
System is a unit of abstraction for pieces of infrastructure (and we largely care that they are) for sensing. A system has components, its subsystems, which are other systems.
http://www.w3.org/ns/ssn/SystemLifetime
Total useful life of a sensor/system (expressed as total life since manufacture, time in use, number of operations, etc.).
http://www.w3.org/ns/ssn/attachedSystem
Relation between a Platform and any Systems (e.g., Sensors) that are attached to the Platform.
http://www.w3.org/ns/ssn/deployedOnPlatform
Relation between a deployment and the platform on which the system was deployed.
http://www.w3.org/ns/ssn/deployedSystem
Relation between a deployment and the deployed system.
http://www.w3.org/ns/ssn/deploymentProcessPart
Has part relation between a deployment process and its constituent processes.
http://www.w3.org/ns/ssn/detects
A relation from a sensor to the Stimulus that the sensor can detect. The Stimulus itself will be serving as a proxy for (see isProxyOf) some observable property.
http://www.w3.org/ns/ssn/featureInObservation
http://www.w3.org/ns/ssn/featureOfInterest
A relation between an observation and the entity whose quality was observed. For example, in an observation of the weight of a person, the feature of interest is the person and the quality is weight.
http://www.w3.org/ns/ssn/forProperty
A relation between some aspect of a sensing entity and a property. For example, from a sensor to the properties it can observe, or from a deployment to the properties it was installed to observe. Also from a measurement capability to the property the capability is described for. (Used in conjunction with ofFeature).
http://www.w3.org/ns/ssn/hasDeployment
Relation between a System and a Deployment, recording that the System/Sensor was deployed in that Deployment.
http://www.w3.org/ns/ssn/hasMeasurementCapability
Relation from a Sensor to a MeasurementCapability describing the measurement properties of the sensor.
http://www.w3.org/ns/ssn/hasMeasurementProperty
Relation from a MeasurementCapability to a MeasurementProperty. For example, to an accuracy (see notes at MeasurementCapability).
http://www.w3.org/ns/ssn/hasOperatingProperty
Relation from an OperatingRange to a Property. For example, to a battery lifetime.
http://www.w3.org/ns/ssn/hasOperatingRange
Relation from a System to an OperatingRange describing the normal operating environment of the System.
http://www.w3.org/ns/ssn/hasProperty
The chain here ensures that the observed property of an observation is a property of the feature of interest. This restriction is written in O&M; here we can enforce it formally. The more obvious formulation: featureOfInterest o hasProperty SubPropertyOf observedProperty can't be used, because (by the OWL2 decidability restrictions) that would mean cardinality restrictions couldn't be applied to observedProperty (see definition of Observation).
http://www.w3.org/ns/ssn/hasSubSystem
Haspart relation between a system and its parts.
http://www.w3.org/ns/ssn/hasSurvivalProperty
Relation from a SurvivalRange to a Property describing the survial range of a system. For example, to the temperature extreme that a system can withstand before being considered damaged.
http://www.w3.org/ns/ssn/hasSurvivalRange
A Relation from a System to a SurvivalRange.
http://www.w3.org/ns/ssn/hasValue
http://www.w3.org/ns/ssn/implementedBy
A relation between the description of an algorithm, procedure or method and an entity that implements that method in some executable way. For example, between a scientific measuring method and a sensor the senses via that method.
http://www.w3.org/ns/ssn/implements
A relation between an entity that implements a method in some executable way and the description of an algorithm, procedure or method. For example, between a Sensor and the scientific measuring method that the Sensor uses to observe a Property.
http://www.w3.org/ns/ssn/inCondition
Describes the prevailing environmental conditions for MeasurementCapabilites, OperatingConditions and SurvivalRanges. Used for example to say that a sensor has a particular accuracy in particular conditions. (see also MeasurementCapability)
http://www.w3.org/ns/ssn/inDeployment
Relation between a Platform and a Deployment, recording that the object was used as a platform for a system/sensor for a particular deployment: as in this PhysicalObject is acting as a Platform inDeployment Deployment.
http://www.w3.org/ns/ssn/isProducedBy
Relation between a producer and a produced entity: for example, between a sensor and the produced output.
http://www.w3.org/ns/ssn/isPropertyOf
Relation between a FeatureOfInterest and a Property (a Quality observable by a sensor) of that feature.
http://www.w3.org/ns/ssn/isValueOf
http://www.w3.org/ns/ssn/isProxyFor
A relation from a Stimulus to the Property that the Stimulus is serving as a proxy for. For example, the expansion of the quicksilver is a stimulus that serves as a proxy for temperature, or an increase or decrease in the spinning of cups on a wind sensor is serving as a proxy for wind speed.
http://www.w3.org/ns/ssn/madeObservation
Relation between a Sensor and Observations it has made.
http://www.w3.org/ns/ssn/observationResult
Relation linking an Observation (i.e. a description of the context, the Situation, in which the observatioin was made) and a Result, which contains a value representing the value associated with the observed Property.
http://www.w3.org/ns/ssn/observationResultTime
The result time shall describe the time when the result became available, typically when the procedure associated with the observation was completed For some observations this is identical to the phenomenonTime. However, there are important cases where they differ.[O&M]
http://www.w3.org/ns/ssn/observationSamplingTime
Rebadged as phenomenon time in [O&M]. The phenomenon time shall describe the time that the result applies to the property of the feature-of-interest. This is often the time of interaction by a sampling procedure or observation procedure with a real-world feature.
http://www.w3.org/ns/ssn/observedProperty
Relation linking an Observation to the Property that was observed. The observedProperty should be a Property (hasProperty) of the FeatureOfInterest (linked by featureOfInterest) of this observation.
http://www.w3.org/ns/ssn/observes
http://www.w3.org/ns/ssn/ofFeature
A relation between some aspect of a sensing entity and a feature. For example, from a sensor to the features it can observe properties of, or from a deployment to the features it was installed to observe. Also from a measurement capability to the feature the capability is described for. (Used in conjunction with forProperty).
http://www.w3.org/ns/ssn/onPlatform
Relation between a System (e.g., a Sensor) and a Platform. The relation locates the sensor relative to other described entities entities: i.e., the Sensor s1's location is Platform p1. More precise locations for sensors in space (relative to other entities, where attached to another entity, or in 3D space) are made using DOLCE's Regions (SpaceRegion).
http://www.w3.org/ns/ssn/produces
The chain here means that if a sensor made an observation and that observation has a result, then the result is the one produced by the sensor. Just ensures that the sensor and the resulting observation agree on the result.
http://www.w3.org/ns/ssn/qualityOfObservation
Relation linking an Observation to the adjudged quality of the result. This is of course complimentary to the MeasurementCapability information recorded for the Sensor that made the Observation.
http://www.w3.org/ns/ssn/sensingMethodUsed
A (measurement) procedure is a detailed description of a measurement according to one or more measurement principles and to a given measurement method, based on a measurement model and including any calculation to obtain a measurement result [VIM 2.6]
This section is non-normative.
http://www.w3.org/2000/01/rdf-schema#comment
http://purl.org/dc/terms/created
http://purl.org/dc/elements/1.1/creator
http://purl.org/dc/elements/1.1/date
http://purl.org/dc/elements/1.1/identifier
http://www.w3.org/2000/01/rdf-schema#isDefinedBy
http://www.w3.org/2000/01/rdf-schema#label
http://creativecommons.org/ns#license
http://purl.org/dc/terms/modified
http://purl.org/dc/elements/1.1/rights
http://www.w3.org/2000/01/rdf-schema#seeAlso
http://purl.org/dc/elements/1.1/source
http://purl.org/dc/elements/1.1/title
This section is non-normative.
This section is non-normative.
This section identifies work that is planned to be done in the next iteration of the document. Comment on these topics and their priority is invited.
Check and reconsider or redesign modularisation of SSN. See proposal in charter: noting the work to split the ontology into smaller sections to offer simplified access
Modularisation of SSN might work like some of the following suggestions under discussion
How do we replace those components of dul that seem to be core to ssn if dul is not being used?
What goes in SSN and what should be just a recommended profile/extract/extension? These could include e.g. WoT? Iot-lite? satellite sensors? samples? human sensors? Or do we just advise how to do this in general?
Given the distinction between records and events, ssn:Observation is not the same concept as om:Observation. This arises also in alignment with PROV-O
Align SSN with PROV-O
Two such alignments have already been published in the literature. One proposal functions mostly rather like the alignment to DUL as described above in form, but some rather useful SWRL is also used.
Is it ok to use SWRL, too, for this? Or would it be better to make some bigger changes to SSN to align with PROV-O?
Is the provenance requirement in scope?
Align SSN with RDF datacube
SSN for IoT devices
In this context actuation is a clear need and should be considered.
The user should be able to understand the network resource cost of proposed instructions (for example, power required per measurement, current battery life, latency before instructions can be executed). These qualities could be interpreted by the scientist user directly, or by an automated agent aiming to optimize network efficiency through resource scheduling and optimisation algorithms.
Align SSN with the ontology developed for the coverage deliverable
Extend SSN to cover requirements identified in our UCR
Align SSN to implement Best Practices as defined in our BP deliverable.
Extend SSN to to cover requirements identified in our wish List. These requirements have not been discussed in the group and are subject to prioritisation and resources.
Review annotation properties, including multilingual. Fix typos and spelling.
Extend SSN to cover these things https://www.w3.org/2015/spatial/wiki/Working_Use_Cases#Various_Sensor_Use_Cases_.28SSN.29 (Action-25)
This section is non-normative.
This is a note of some proposed documentation, resources permitting.
The Editors recognize the major contribution of the members of the W3C Semantic Sensor Networks Incubator Group.


--- layout: default title: Web services ---
The web service infrastructure is divided in two sites: Resolution Service and Central Registry.
The Resolution Service is the main function in Identifiers.org. It takes a Compact Identifier and resolves it to a URL. There are two different ways to utilize it:
The following section details the user interface in the Identifers.org web service.
All the features of the old advanced search have been merged into the main Identifiers.org search bar at the resolver homepage. As you can see in the usage example below, the old Retrieval Service and Validation Service are now performed as you write, and you get insights about the Compact Identifier in real time.
The Central Registry provides the necessary information to allow users to generate unique, persistent and unambiguous identifiers for scientific data. Selecting a namespace will take you to a detailed view of all the information related to it, including its maintainer and different providers.
The Registry search bar features the same prediction and hints-as-you-type as the Resolver.


module File: BatFile
let lines_of : string => BatEnum.t string
line_of name
reads the contents of file name
as an enumeration of lines.
The file is automatically closed once the last line has been reached or the
enumeration is garbage-collected.let write_lines : string => BatEnum.t string => unit
write_lines name lines
writes strings given by lines
to file name
with newline character appended to each line.let size_of : string => int
size_of name
returns the size of file name
in bytes.let size_of_big : string => Int64.t
size_of_big name
returns the size of file name
in bytes, as a 64-bit integer.
This function is provided as the size of a file larger than 1 Gb cannot
be represented with an int
on a 32-bit machine.
File permissions are used when creating a file to allow controlling which users
may read, write or open that file. To use a permission, create a value of type
BatFile.permission
and pass it as argument to BatFile.open_in
, BatFile.open_out
, BatFile.with_file_in
or
BatFile.with_file_out
.
type permission
let default_permission : permission
let user_read : permission
let user_write : permission
let user_exec : permission
let group_read : permission
let group_write : permission
let group_exec : permission
let other_read : permission
let other_write : permission
let other_exec : permission
let perm : list permission => permission
let unix_perm : int => permission
chmod
for more details.Invalid_argument
if given number outside the [0, 0o777]
rangelet set_permissions : string => permission => unit
let chmod : string => permission => unit
type open_in_flag=
[ `create | `excl | `mmap | `nonblock | `text ]
let open_in : mode::list open_in_flag? =>
perm::permission? => string => BatInnerIO.input
open_in file_name
opens the file named file_name
for reading.
Note You will need to close the file manually, with
BatIO.close_in
. An alternative is to call with_file_in
instead
of open_in
.
Naming conventions for files are platform-dependent.
let with_file_in : mode::list open_in_flag? =>
perm::permission? => string => (BatInnerIO.input => 'a) => 'a
with_file_in file_name f
opens the file named file_name
for reading,
invokes f
to process the contents of that file then, once f
has returned
or triggered an exception, closes the file before proceeding.type open_out_flag=
[ `append | `create | `excl | `nonblock | `text | `trunc ]
open()
call. The default flags are
[`create; `trunc]
.let open_out : mode::list open_out_flag? =>
perm::permission? => string => BatInnerIO.output unit
open_out file_name
opens the file named file_name
for writing.
Note You will need to close the file manually, with
BatIO.close_out
. An alternative is to call with_file_out
instead of open_out
.
Naming conventions for files are platform-dependent.
let with_file_out : mode::list open_out_flag? =>
perm::permission? => string => (BatInnerIO.output unit => 'a) => 'a
with_file_out file_name f
opens the file named file_name
for writing,
invokes f
to write onto that file then, once f
has returned or triggered
an exception, closes the file before proceeding.type open_temporary_out_flag=
[ `append | `create | `delete_on_exit | `excl | `nonblock | `text | `trunc ]
let open_temporary_out : mode::list open_temporary_out_flag? =>
prefix::string? =>
suffix::string? =>
temp_dir::string? => unit => (BatInnerIO.output unit, string)
open_temporary_out ()
opens a new temporary file for writing.output
for writing in it.
Note You will need to close the file manually. An alternative is
to call with_temporary_out
instead of open_out
.
Naming conventions for files are platform-dependent.
prefix
: a string which should appear at the start of your temporary file name
(by default "ocaml"
)suffix
: a string which should appear at the end of your temporary file name
(by default "tmp"
)temp_dir
: indicates what temp dir to uselet with_temporary_out : mode::list open_temporary_out_flag? =>
prefix::string? =>
suffix::string? =>
temp_dir::string? => (BatInnerIO.output unit => string => 'a) => 'a
with_temporary_out f
opens a new temporary file for writing, invokes f
with
to write onto that file then, once f
has returned or triggered an exception,
closes the file before proceeding.output
for writing in it.
Naming conventions for files are platform-dependent.
prefix
: a string which should appear at the start of your temporary file name
(by default "ocaml"
)suffix
: a string which should appear at the end of your temporary file name
(by default "tmp"
)temp_dir
: indicates what temp dir to use


Actual Damage
Actual damage is the real damage that happens to your URI.
It is computed by list all embedded resources (image, css,
javascript, and multimedia), identify which of them are missing,
find their importance, and add the importance value together to
get the actual damage.
Potential Damage
Potential damage is the damage that could happen if all embedded
resources are missing. It is calculated by exactly the same way
as actual damage.
Total Damage
Total damage is the ratio between actual damage and potential
damage. It ranges from 0
- 1
.
The value of 1
means your URI is 100%
damaged.
Total damage is computed by using this formula:
$Total Damage=\frac{Actual Damage}{Potential Damage}$
What constitute the damage value?
There are 5 components which are considered when computing damage:
- Image
- Css
- Javascript
- Multimedia
- Text
We added together the important values from the embedded resources
to get the value of damaged.


ListBoxOption component
ListBoxOption component is connected
selected property getter
ListBox component
Empty ListBox is connected
ListBox with some options but no default value is connected
ListBox with some options and default value is connected
updating the selected index property should update the component
click an option should select it
arrow key down should select the next option
arrow key down should keep the last option in case it is already selected
arrow key up should select the last option if none is selected
arrow key up should select the previous option
arrow key up should keep the first option selected if it is already selected
listbox should emit "change" event when selected option changes
TabPanel Component
TabPanel is connected
active getter should follow the hidden attribute
hidden
TabSet Component
TabSet is connected: it should select the first tab if none has the selected attribute
selected
TabSet is connected: it should select the tab with the selected attribute
click should select the new tab
keyboard navigation with follow-focus attribute
follow-focus
RightArrow navigation
LeftArrow navigation
keyboard navigation without follow-focus attribute
select tab on Enter keydown
select tab on Space keydown
selecting a new tab should trigger a change event
change event
Tab Component
Tab is connected
selected getter should follow aria-selected attribute


As you may have guessed, my name is Hamza Khan. I am a Computer Science student interested in technology. My degree may say B.S. in Computer Science, but I love anything and everything to do with technology from the basic Arduino, to the mind blowing Oculus Rift.
I enjoy learning about new innovations and ideas, but more than that, I enjoy working with others who share my passion. One of my favorite pastimes is going to Hackathons where i can group up with random people, start with a simple idea, and create something in 24 hours. That's the best part about being a programmer. Being able to create an image in my mind, and then sitting down for hours on end, never losing focus, and drumming out a quality program. That is my drive.
My first venture into the vast world of Virtual Reality gaming. It was made at CodeRed, Houston's Premier Hackathon.
Made in Unity, Rift Rampage is a multiplayer first person shooter incorporating the Oculus Rift Virtual Reality headset and the LeapMotion Hand Controller.
The basic idea was that two players would face each other in a 3D virtual environment, where they would shoot at each other aiming to defeat the other. The players would hold out their hands over the LeapMotion device, and it would display their virtual hands on the screen. The player makes a tapping gesture with his thumb, and a bullet would shoot from his index finger.
Android app created in Android Studio
Geofencing app that allows users to take self-guided tours or allow emergency services to notify people of events easily.
A Geofence is a point on a map with a circle around it. When a user enters the circle, they get a notification that gives details of that particular spot.
Possible uses:
o Self-guided tours
o During a fire or car accident, a geofence can be placed to notify anyone nearby
o Find locations near a user, that they never knew existed
My senior projects that is being made in collaboration with George Erfesoglou
A multiplayer FPS game made in Unity and uses Photon networking for the online multiplayer.
For my part, I will be integrating the Oculus Rift and the LeapMotion devices for gameplay. We have devised a complex method of gameplay where the Oculus will only control the direction a player looks in. It will not control the direction of the weapon. That part will be handed off to the Leap, as will navigation
With your left hand, you will control your movement, and with your right, you will control the direction of your weapon.
You will effectively be able to "peak" around a corner, before bringing your gun around to shoot.
The game will also be cross-peripheral, so that those who do not own a Rift or a Leap can still play with a keyboard, mouse, monitor, or gamepad.
So far, the game is up and running. Oculus integration is the easy part. Will start working on Leap integration during Summer 2015.


insert(part, body, onBehalfOfContentOwner=None)
Post a channel bulletin.
Browse the YouTube channel activity collection.
list_next(previous_request, previous_response)
Retrieves the next page of results.
insert(part, body, onBehalfOfContentOwner=None)
Post a channel bulletin. Args: part: string, One or more parts to return on the current request. (required) body: object, The request body. (required) The object takes the form of: { # An activity resource contains information about an action that a channel has taken on YouTube. "snippet": { # Basic details about an activity, including title, description, thumbnails, activity type and group. # Basic details about the activity: title, description, thumbnails. "thumbnails": { # Activity thumbnails. "a_key": { # A thumbnail is an image representing a YouTube resource. # A map of thumbnails by their name. "url": "A String", # The URL for the thumbnail. }, }, "title": "A String", # Title of the activity. "channelId": "A String", # Channel publishing the activity. "publishedAt": "A String", # Date and time the activity was published at. "type": "A String", # Type of the activity. "groupId": "A String", # Id of the group that this activity is part of. "description": "A String", # Description of the activity. }, "contentDetails": { # Details about the content of an activity: the video that was shared, the channel that was subscribed to, etc. # Type specific information about the activity. "comment": { # Only present if the type is "comment". "resourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the commented resource. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, }, "playlistItem": { # Only present if the type is "playlistItem". "resourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the resource added to the playlist. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, "playlistId": "A String", # ID of the playlist the resource was added to. }, "like": { # Only present if the type is "like". "resourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the rated resource. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, }, "social": { # Only present if the type is "social". "resourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the resource this social activity is about. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, "imageUrl": "A String", # Image of the post author. "type": "A String", # Type of the social network. "referenceUrl": "A String", # Url of the social post. "author": "A String", # Author of the post. }, "favorite": { # Only present if the type is "favorite". "resourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the favorited resource. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, }, "upload": { # Only present if the type is "upload". "videoId": "A String", # ID of the uploaded video. }, "recommendation": { # Only set if the type is "recommendation". "resourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the recommended resource. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, "reason": "A String", # Reason for which the video was recommended. "seedResourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the video that caused this recommendation. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, }, "bulletin": { # Only present if the type is "bulletin". "resourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the resource this bulletin is about. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, }, "subscription": { # Only present if the type is "subscription". "resourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the resource subscribed to. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, }, }, "kind": "youtube#activity", # The type of this API response. "etag": "A String", # The eTag of the activity. "id": "A String", # The unique ID of the activity. } onBehalfOfContentOwner: string, The authenticated user acts on behalf of this content owner. Returns: An object of the form: { # An activity resource contains information about an action that a channel has taken on YouTube. "snippet": { # Basic details about an activity, including title, description, thumbnails, activity type and group. # Basic details about the activity: title, description, thumbnails. "thumbnails": { # Activity thumbnails. "a_key": { # A thumbnail is an image representing a YouTube resource. # A map of thumbnails by their name. "url": "A String", # The URL for the thumbnail. }, }, "title": "A String", # Title of the activity. "channelId": "A String", # Channel publishing the activity. "publishedAt": "A String", # Date and time the activity was published at. "type": "A String", # Type of the activity. "groupId": "A String", # Id of the group that this activity is part of. "description": "A String", # Description of the activity. }, "contentDetails": { # Details about the content of an activity: the video that was shared, the channel that was subscribed to, etc. # Type specific information about the activity. "comment": { # Only present if the type is "comment". "resourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the commented resource. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, }, "playlistItem": { # Only present if the type is "playlistItem". "resourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the resource added to the playlist. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, "playlistId": "A String", # ID of the playlist the resource was added to. }, "like": { # Only present if the type is "like". "resourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the rated resource. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, }, "social": { # Only present if the type is "social". "resourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the resource this social activity is about. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, "imageUrl": "A String", # Image of the post author. "type": "A String", # Type of the social network. "referenceUrl": "A String", # Url of the social post. "author": "A String", # Author of the post. }, "favorite": { # Only present if the type is "favorite". "resourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the favorited resource. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, }, "upload": { # Only present if the type is "upload". "videoId": "A String", # ID of the uploaded video. }, "recommendation": { # Only set if the type is "recommendation". "resourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the recommended resource. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, "reason": "A String", # Reason for which the video was recommended. "seedResourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the video that caused this recommendation. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, }, "bulletin": { # Only present if the type is "bulletin". "resourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the resource this bulletin is about. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, }, "subscription": { # Only present if the type is "subscription". "resourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the resource subscribed to. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, }, }, "kind": "youtube#activity", # The type of this API response. "etag": "A String", # The eTag of the activity. "id": "A String", # The unique ID of the activity. }
list(part, onBehalfOfContentOwner=None, pageToken=None, publishedBefore=None, channelId=None, mine=None, maxResults=None, home=None, publishedAfter=None)
Browse the YouTube channel activity collection. Args: part: string, Activity parts to include in the returned response. Valid values are: id, snippet and contentDetails. (required) onBehalfOfContentOwner: string, The authenticated user acts on behalf of this content owner. pageToken: string, Token for the page selection. publishedBefore: string, Only return activities published before given date (exclusive). channelId: string, YouTube ID of the channel. mine: string, Flag indicating to return user's activities. maxResults: integer, Maximum number of results to return home: string, Flag indicating to return user's homepage feed. publishedAfter: string, Only return activities published after given date (inclusive). Returns: An object of the form: { # A paginated list of activities returned as a response to youtube.activities.list calls. "nextPageToken": "A String", # Token to the next page. "kind": "youtube#activityListResponse", # The type of this API response. "items": [ # List of activities matching the request criteria. { # An activity resource contains information about an action that a channel has taken on YouTube. "snippet": { # Basic details about an activity, including title, description, thumbnails, activity type and group. # Basic details about the activity: title, description, thumbnails. "thumbnails": { # Activity thumbnails. "a_key": { # A thumbnail is an image representing a YouTube resource. # A map of thumbnails by their name. "url": "A String", # The URL for the thumbnail. }, }, "title": "A String", # Title of the activity. "channelId": "A String", # Channel publishing the activity. "publishedAt": "A String", # Date and time the activity was published at. "type": "A String", # Type of the activity. "groupId": "A String", # Id of the group that this activity is part of. "description": "A String", # Description of the activity. }, "contentDetails": { # Details about the content of an activity: the video that was shared, the channel that was subscribed to, etc. # Type specific information about the activity. "comment": { # Only present if the type is "comment". "resourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the commented resource. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, }, "playlistItem": { # Only present if the type is "playlistItem". "resourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the resource added to the playlist. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, "playlistId": "A String", # ID of the playlist the resource was added to. }, "like": { # Only present if the type is "like". "resourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the rated resource. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, }, "social": { # Only present if the type is "social". "resourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the resource this social activity is about. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, "imageUrl": "A String", # Image of the post author. "type": "A String", # Type of the social network. "referenceUrl": "A String", # Url of the social post. "author": "A String", # Author of the post. }, "favorite": { # Only present if the type is "favorite". "resourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the favorited resource. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, }, "upload": { # Only present if the type is "upload". "videoId": "A String", # ID of the uploaded video. }, "recommendation": { # Only set if the type is "recommendation". "resourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the recommended resource. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, "reason": "A String", # Reason for which the video was recommended. "seedResourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the video that caused this recommendation. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, }, "bulletin": { # Only present if the type is "bulletin". "resourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the resource this bulletin is about. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, }, "subscription": { # Only present if the type is "subscription". "resourceId": { # A resource id is a generic reference that points to another YouTube resource. # ID of the resource subscribed to. "kind": "A String", # The kind of the referred resource. "channelId": "A String", # ID of the referred channel. Present only when type is "CHANNEL". "playlistId": "A String", # ID of the referred playlist. Present only when type is "PLAYLIST". "videoId": "A String", # ID of the referred video. Present only when type is "VIDEO". }, }, }, "kind": "youtube#activity", # The type of this API response. "etag": "A String", # The eTag of the activity. "id": "A String", # The unique ID of the activity. }, ], "etag": "A String", # The eTag of the response. "prevPageToken": "A String", # Token to the previous page. "pageInfo": { # Paging details for lists of resources, including total number of items available and number of resources returned in a single page. # Paging information for the list result. "totalResults": 42, # The total number of results. "resultsPerPage": 42, # The number of results to display for each page. }, }
list_next(previous_request, previous_response)
Retrieves the next page of results. Args: previous_request: The request for the previous page. (required) previous_response: The response from the request for the previous page. (required) Returns: A request object that you can call 'execute()' on to request the next page. Returns None if there are no more items in the collection.


Mushrooms - P. cubensis (Ecuadorean)
One day while walking through my house I stumbled upon a few small mushrooms growing up through the floor. My first thought was to remove the unwelcome fungi, but upon closer inspection I noticed that they were of the species Psilocybe cubensis, the Ecuadorian strain to be exact. An estimated 15 grams wet, I put them into a blender with some OJ and drank this magical concoction.
I found my brother and told him of my happy little encounter, and asked if I could hang with him for a while I shroomed. I wouldn't say that he was delighted, but he agreed to it.
In a surprisingly short amount of time I felt a definite change in my perception (I always begin to feel my mushrooms within the first ten minutes. Of course I also always take them in the manner described above, or in a tea). The world was beautiful! I was incredibly happy. While the visual aspect wasn't exactly apparent, I could see tiny details within the world around me. While gazing out the window I saw a little yellowjacket hanging on to the screen. I got up close and stared in amazement at this creation. It wasn't moving, and I was sure that it had passed on. I sat and mourned for the pest until it finally flew away. Once I realized it wasn't dead I was overjoyed and cried tears of joy for the bug's new chance at life.
My brother laughed at me, then began to play Zelda on the Nintendo 64. What a boring game. How could my brother be interested in this stupid game when there was so much to explore in the world around us? I got a bag of tortilla chips and ate them. I wasn't particularly hungry, I just felt like experiencing the act of eating. It was incredible. I could feel the chips begin to break down within my salivating mouth. Swallowing was particularly enjoyable. I was reveling in my body and the amazing feat of eating. I thought it incredible that we obtained our energy in such a disgusting manner. I loved being human. I also told my brother than I loved him several times. He seemed more annoyed than touched, but he always repeated it back to me which kept me content.
For some odd reason I decided to look at my chips up close. Oh my god! There were tiny universes within each one of them! I had already eaten an innumerable amount of innocent souls! I was filled with remorse and guilt, or perhaps maybe I had just become full.
I grew bored with video games, and tortilla chips and so I went into my room and called a few people. I told them all that I loved them. They thought I was crazy. I told them that I thought I was crazy. They hung up the phone on me. I love them, every one of them.
All in all an enjoyable day.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


This is a web version of the iOS app SF Live Bus, which shows all of SF MUNI approximately in real-time. This version was directly inspired by the London Underground version that made the rounds a few weeks ago.
The NextBus API is hit to fetch the data and populate a Firebase endpoint — making it really easy to consume on the web in real-time. The Firebase related code is about 50 lines of JavaScript on the front end.


Learner
Log In
Email
password
message
error
Sign In
Not a member? Sign up now!
Continue without registration
login
|
login
Forgot your password?