Plugin Component Specification
The HyperPersonalized Intelligent Tutor (HPIT) is a schemaless, event driven system which specializes in the communication between distributed intelligent tutoring systems and specialized, machine learning algorithms, which we call plugins. HPIT is a next generation system built on the backbone of open source web technologies.
Currently our tech stack consists of the following:
At the most fundamental layer HPIT is a collection of RESTful web services that assist in the routing of messages between tutors and plugins. On top of this web services layer we have built a client side library in the Python programming language to assist in the creation of tutors and plugins and their communication with HPIT.
HPIT is a publish and subscribe framework using event-driven methodologies. Tutors interact with the system by sending messages which consist of a named event and a data payload. Plugins can listen to these events, perform an action, then submit a response back to HPIT, which will ultimately be routed to the tutor that made the original request.

HPIT - HPIT consists of several modules and is sort of an all encompassing term for the entire system of modules.
Tutor - A tutor is an entity that interacts with students and uses the HPIT system to gather and analyze intelligent information about student performance. A tutor could be a game, or a web application, a Flash game, or some other system that interacts with students in an effort to educate or train.
Plugin - An HPIT Plugin is a module that specializes in a very specific and narrow band of responsibility. A plugin may exist inside of HPIT itself(at TutorGen) or on a network or system outside of HPIT. Regardless of where the plugin sits it must communicate with the central HPIT router/server.
Entity - A generic term for either a Plugin or Tutor.
HPIT Manager - The manager is used to load the HPIT router, and a set of plugins and tutors. It is used primarily for testing and development.
HPIT Router/Server - This is the central server that routes messages and transactions between tutors and plugins.
HPIT Message - This is a event_name and payload pair, both of which are defined by the developer for their plugin.
HPIT Transaction - A transaction is a message specifically for PSLC DataShop transactions.
In order to install and run HPIT, you'll need the following system: Operating systems * Windows 7 or Windows 8.1 * Ubuntu 12.04 LTS or Ubuntu 14.04 LTS * OSX Mountain Lion or above Architecture * 64-bit processor * 32-bit processors will work in a limited fashion, but it is not recommended or supported * Memory and Storage * Minimum 4 GB ram, 8 GB recommended * Minimum 2 GB hard disk, can scale up very quickly depending on your data volume * Solid state hard drives recommended
HPIT was designed to run on a Unix-like system, and Windows support is solely for development purposes. Windows should not be used as an HPIT production server.
First, to install HPIT, you'll need to install Microsoft Visual Studio. The latest version should be fine; you can find it at http://www.visualstudio.com/en-us/products/visual-studio-express-vs.aspx.
Next, you'll need the GCC, most easily installed with MinGW. You can get it from here: http://mingw.org/.
Make sure to add C:\MinGW\bin and C:\MinGW\msys\1.0\bin to your PATH environment variable.
To install Python 3.3.5, download the binary from https://www.python.org/downloads/ and run.
To install Pip, go to http://pip.readthedocs.org/en/latest/installing.html , download the get-pip.py script, and run with
python get-pip.py
.
Verify you have the proper versions of Python and Pip:
python --version
pip --version
Next, install virtualenv using:
pip install virtualenv
Add C:\Python33\Scripts to your PATH so that pip and virtualenv are available commands.
HPIT uses four different database managers; MongoDB, SQLite, PostgreSQL, Neo4j.
Binaries available at http://www.mongodb.org/downloads. Download and run. You will need to create the directory C:\data\db to run MongoDB.
Go to http://www.sqlite.org/download.html and download sqlite-shell-win32-*.zip and sqlite-dll-win32-*.zip.
Create the directory C:\sqlite.
Extract the contents of the .zip files to C:\sqlite. There should be three files: sqlite3.def sqlite3.dll * sqlite3.exe
Add C:\sqlite to your PATH environment variable.
Go to http://neo4j.com/download/ and download the Community edition binary and install.
Because PostgreSQL is just a production replacement of SQLite, and Windows should never be used as a production environment, this step is optional. However, if you want to install PostgreSQL anyway, there are binaries available at http://www.postgresql.org/download/windows/.
To install the psycopg2 library on Windows, there are instructions located at http://www.stickpeople.com/projects/python/win-psycopg/ and are summarized here:
Download the 3.4 release for 64-bit processors.

You'll need to add the bin directory of your PostgreSQL installation to PATH, so that pg_config
is available to call.
HPIT uses CoffeeScript and LESS for its front end, which requires NodeJS.
Binaries are available at http://nodejs.org/download/.
Now we can install HPIT. First, you will need the git command line tools. They can be downloaded from http://git-scm.com/download/win.
After git is installed, open up the Git Bash program, cd to your working directory (I used ~/Documents/HPIT) and run:
git clone https://github.com/tutorgen/hpit_services
Now it is time to create your virtual environment.  It is important that you are using the correct Python binary when creating the virtual environment. In our case, we used the command
virtualenv -p C:\Python33\python.exe env
Where virtualenv is the binary for the compatible version of virtualenv, C:\Python33\python.exe is your Python 3.3.5 binary, and env is the directory that the virtual environment will live in.
Next, activate the environment with the command env\Scripts\activate.bat
. Your command prompt
should now be prefixed with (env).
Now, find the directory env\Lib\distutils. Add a file distutils.cfg
with the contents:
[build]
compiler=mingw32
This tells Pip to use the MinGW compilers, which are required for some packages.
Now, install the Python dependencies using pip. The command will be:
pip install -r requirements-win.txt
First, make sure that MongoDB, and Neo4j are running. HPIT is configured to use SQLite for development, so PostgreSQL does not need to be started. The databases can be controlled by these commands:
MongoDB: mongod
. This will run in a terminal window until it is killed.
Neo4J: Run C:\Program Files\Newo4j Community\bin\neo4j-community.exe. You can start and stop it by clicking a button.
Next, set up the server settings. Instructions are located in the section Server Settings
Now, seed the database with this command:
python manage.py syncdb
Optionally index the MongoDB for faster performance with this command:
python manage.py indexdb
And run the tests:
python manage.py test
Assuming everything passed, you should then run:
python manage.py debug
And browse to http://<IP_ADDRESS>:8000 , where you should see a welcome page.
If you run into problems, check the section Common Hangups
ruby -e "$(curl -fsSL https://raw.github.com/Homebrew/homebrew/go/install)"
brew install git
python3 --version
. brew install python3
HPIT uses sqlite3 locally by default and for running it's test suite. If you are installing in production we recommend that you confiqure HPIT to use postgreSQL over sqlite3.
brew install mongodb sqlite
Install the libpq headers, using: sudo apt-get install libpq-dev
. Try running pg_config --version
to ensure it installed correctly.
psycopg2 will be installed later with Pip.
HPIT's administrative frontend relies heavily on CoffeeScript and LESScss. CoffeeScript and LESScss are NodeJS packages and so you will need to download and install node version 0.10.3 to be able to run the HPIT server. Luckily on Max OSX this is a relatively trivial task.
brew install node
npm install coffeescript-compiler less
If you plan on using the Hint Factory you will also need to have installed the Neo4J graph database. The best way to do so is again, through Homebrew.
brew install neo4j
neo4j start
git clone https://github.com/tutorgen/hpit_services hpit
cd hpit
export PY3_PATH=$(which python3)
virtualenv -p $PY3_PATH env
source env/bin/activate
pip3 install -r requirements.txt
.python3 manage.py syncdb
python3 manage.py mongo
python3 manage.py indexdb
python3 manage.py mongo
python3 manage.py test
To start the HPIT server type: python3 manage.py debug
and open your browser
to http://<IP_ADDRESS>:8000.
HPIT supports the Ubuntu 12.04 LTS release. However, if possible, it is highly recommended to upgrade to the 14.04 LTS release.
The first thing you'll need to do is update and upgrade your apt repositories:
sudo apt-get update
sudo apt-get upgrade
Next, install the C compiler and other build utilities:
sudo apt-get install build-essential
HPIT requires Python 3.4 or higher. Ubuntu 12.04 does not include Python 3.4 in its repositories by default, so you must install it from the fkrull/deadsnakes PPA:
sudo add-apt-repository ppa:fkrull/deadsnakes
sudo apt-get update
sudo apt-get install python3.4
You can verify you have the correct version of Python by typing:
python3.4 --version
Next, to install the numerous Python packages HPIT requires, you'll need Pip, which needs to be compatible with Python 3.4. The easiest way to do this is to use the command:
python3.4 -m ensurepip --upgrade
We highly recommend using virtualenv when running HPIT. If you are unfamiliar with virtualenv, you can read about it at http://virtualenv.readthedocs.org/en/latest/. Install virtualenv from pip, with the command:
pip3 install virtualenv
HPIT uses four different database managers; MongoDB, SQLite, PostgreSQL, and Neo4j.
Installing SQLite and MongoDB are easy to install, simply use apt-get:
sudo apt-get install sqlite mongodb
To install PostgreSQL, use the commands:
sudo apt-get install postgresql postgresql-contrib
In order for Python to interact with PostgreSQL, we'll need the dependencies for the psycopg2 library. Install instructions are found at http://initd.org/psycopg/docs/install.html#install-from-source , and summarized here:
Install the Python 3.4 headers, using: sudo apt-get install libpython3.4-dev
. This comes from
this fkrull/deadsnakes repository.
Install the libpq headers, using: sudo apt-get install libpq-dev
. Try running pg_config --version
to ensure it installed correctly.
psycopg2 will be installed later with Pip.
Next, we need to install Neo4j. Neo4j requires Oracle JDK 7 or OpenJDK 7. You can verify this is installed
by using: java -version
.
To install Neo4j, follow the steps located at http://debian.neo4j.org/ , summarized below:
sudo wget -O - http://debian.neo4j.org/neotechnology.gpg.key| apt-key add - # Import Neo4j signing key
sudo echo 'deb http://debian.neo4j.org/repo stable/' > /etc/apt/sources.list.d/neo4j.list # Create an Apt sources.list file
sudo apt-get update # Find out about the files in our repository
sudo apt-get install neo4j # Install Neo4j, community edition
HPIT uses CoffeeScript and LESS for its front end, which requires NodeJS. We recommend installing NodeJS from source to ensure you get the latest version. At least 0.10.3 is required.
First, download the source code. At the time of writing, it was located at http://nodejs.org/dist/v0.10.31/node-v0.10.31.tar.gz. You can use wget, like this:
wget http://nodejs.org/dist/v0.10.31/node-v0.10.31.tar.gz
Next, extract the archive.
tar xvfz node-v0.10.31.tar.gz
Now, cd into the node-v0.10.31.tar.gz directory, and run:
./configure
make
sudo make install
Now that the dependencies are installed, we can install HPIT. To do this, you will need git:
sudo apt-get install git
Next, clone the HPIT repository using:
git clone https://github.com/tutorgen/hpit_services
Next, move into the hpit_services directory using cd hpit_services
Now it is time to create your virtual environment. It is important that you are using the correct Python binary when creating the virtual environment. In our case, we used the command
virtualenv -p python3.4 env
Where virtualenv is the binary for the compatible version of virtualenv, python3.4 is your Python 3.4 binary, and env is the directory that the virtual environment will live in.
Next, activate the environment with the command source env/bin/activate
. Your command prompt
should now be prefixed with (env).
Now, install the Python dependencies using pip3. The command will be:
pip3 install -r requirements.txt
First, make sure that MongoDB, and Neo4j are running. HPIT is configured to use SQLite for development, so PostgreSQL does not need to be started. The databases can be controlled by these commands:
MongoDB: sudo service mongodb start
, sudo service mongodb stop
Neo4J: sudo service neo4j-service start
, sudo service neo4j-service stop
Next, set up the server settings. Instructions are located in the section Server Settings
Now, seed the database with this command:
python manage.py syncdb
Optionally, index the mongoDB wiht this command:
python manage.py indexdb
And run the tests:
python manage.py test
Assuming everything passed, you should then run:
python manage.py start
And browse to http://<IP_ADDRESS>:8000 , where you should see a welcome page.
If you run into problems, check the section Common Hangups
Ubuntu 14.04 LTS release is the preferred platform for HPIT.
The first thing you'll need to do is update and upgrade your apt repositories:
sudo apt-get update
sudo apt-get upgrade
Next, install the C compiler and other build utilities:
sudo apt-get install build-essential
HPIT requires Python 3.4 or higher. Ubuntu 14.04 comes pre-packaged with Python 3.4, with a binary named python3.
You can verify you have the correct version of Python by typing:
python3 --version
Next, to install the numerous Python packages HPIT requires, you'll need Pip, which needs to be compatible with Python 3.4. The easiest way to do this is to use the command:
sudo apt-get install python3-pip
We highly recommend using virtualenv when running HPIT. If you are unfamiliar with virtualenv, you can read about it at http://virtualenv.readthedocs.org/en/latest/. Install virtualenv from pip, with the command:
pip3 install virtualenv
HPIT uses four different database managers; MongoDB, SQLite, PostgreSQL, and Neo4j.
Installing SQLite and MongoDB are easy to install, simply use apt-get:
sudo apt-get install sqlite mongodb
To install PostgreSQL, use the commands:
sudo apt-get install postgresql postgresql-contrib
In order for Python to interact with PostgreSQL, we'll need the dependencies for the psycopg2 library. Install instructions are found at http://initd.org/psycopg/docs/install.html#install-from-source , and summarized here:
Install the Python 3.4 headers, using: sudo apt-get install libpython3-dev
.
Install the libpq headers, using: sudo apt-get install libpq-dev
. Try running pg_config --version
to ensure it installed correctly.
psycopg2 will be installed later with Pip.
Next, we need to install Neo4j. Neo4j requires Oracle JDK 7 or OpenJDK 7. You can verify this is installed
by using: java -version
.
To install Neo4j, follow the steps located at http://debian.neo4j.org/ , summarized below:
sudo wget -O - http://debian.neo4j.org/neotechnology.gpg.key| apt-key add - # Import Neo4j signing key
sudo echo 'deb http://debian.neo4j.org/repo stable/' > /etc/apt/sources.list.d/neo4j.list # Create an Apt sources.list file
sudo apt-get update # Find out about the files in our repository
sudo apt-get install neo4j # Install Neo4j, community edition
HPIT uses CoffeeScript and LESS for its front end, which requires NodeJS. We recommend installing NodeJS from source to ensure you get the latest version. At least 0.10.3 is required.
First, download the source code. At the time of writing, it was located at http://nodejs.org/dist/v0.10.31/node-v0.10.31.tar.gz. You can use wget, like this:
wget http://nodejs.org/dist/v0.10.31/node-v0.10.31.tar.gz
Next, extract the archive.
tar xvfz node-v0.10.31.tar.gz
Now, cd into the node-v0.10.31.tar.gz directory, and run:
./configure
make
sudo make install
Now that the dependencies are installed, we can install HPIT. To do this, you will need git:
sudo apt-get install git
Next, clone the HPIT repository using:
git clone https://github.com/tutorgen/hpit_services
Next, move into the hpit_services directory using cd hpit_services
Now it is time to create your virtual environment. It is important that you are using the correct Python binary when creating the virtual environment. In our case, we used the command
virtualenv -p python3 env
Where virtualenv is the binary for the compatible version of virtualenv, python3 is your Python 3.4 binary, and env is the directory that the virtual environment will live in.
Next, activate the environment with the command source env/bin/activate
. Your command prompt
should now be prefixed with (env).
Now, install the Python dependencies using pip3. The command will be:
pip3 install -r requirements.txt
First, make sure that MongoDB, and Neo4j are running. HPIT is configured to use SQLite for development, so PostgreSQL does not need to be started. The databases can be controlled by these commands:
MongoDB: sudo service mongodb start
, sudo service mongodb stop
Neo4J: sudo service neo4j-service start
, sudo service neo4j-service stop
Next, set up the server settings. Instructions are located in the section Server Settings
Now, seed the database with this command:
python manage.py syncdb
Optionally index the MongoDB for faster performance, with this command:
python manage.py indexdb
And run the tests:
python manage.py test
Assuming everything passed, you should then run:
python manage.py start
And browse to http://<IP_ADDRESS>:8000 , where you should see a welcome page.
If you run into problems, check the section Common Hangups
The settings manager manages settings for the server and the pre-packages plugins that come with HPIT. The
settings are first stored in JSON format, in a file called settings.json in the hpit_services root. When the
settings manager is imported and initialized, it will read this JSON file and load the values into a settings
object which then can be used project wide. This JSON file allows for multiple environment settings, for
example, "test", "debug", and "production". By default, HPIT will look for the 'debug' settings but you can
override this by setting the HPIT_ENV environment variable i.e. (export HPIT_ENV=production
). The structure
of the file looks like this:
json
{
"debug": {
"plugin": {
[plugin settings go here (see below)]
},
"server": {
[server settings go here (see below)]
}
},
"production": {
"plugin": {
[plugin settings go here (see below)]
},
"server": {
[server settings go here (see below)]
}
}
}
Most of these settings can be left as defaults, but the important ones to change are: PROJECT_DIR - should be set to the directory this README is in VENV_DIRNAME - shoule be a relative link from PROJECT_DIR to wherever the virtual environment is. * MONGO_DBNAME / SQLALCHEMY_DATABASE_URI - make sure these are different for test and production environments.
| name | default | description | notes |
|---|---|---|---|
| HPIT_VERSION | string (really long) | A string representation of the current version of HPIT | |
| DEBUG | False | Whether to run the server in debug mode or not | Deprecated |
| HPIT_PID_FILE | 'tmp/hpit_server.pid' | Where to put the PID file for the HPIT server (daemon) | |
| HPIT_BIND_IP | "<IP_ADDRESS>" | The IP Address to listen for connections on. | |
| HPIT_BIND_PORT | "8000" | The Port Address to listen for connections on. | |
| HPIT_BIND_ADDRESS | HPIT_BIND_IP+":"+HPIT_BIND_PORT | A combination of the IP and Port addresses | Don't change this. |
| PROJECT_DIR | '/Users/raymond/Projects/TutorGen/hpit' | The root working directory for HPIT. | Change this. |
| VENV_DIRNAME | 'env' | The directory where the virtual environment is located. | Change this. |
| MONGO_DBNAME | 'hpit_development' | The name of the mongo database to store information in. | |
| SECRET_KEY | random character string length 60 or longer | A secret key used for cryptography. Keep secure. | YOU MUST CHANGE THIS IN PROD! |
| SQLALCHEMY_DATABASE_URI | 'sqlite:///db/hpit_development.sqlite' | A database URI for relational storage. | Several databases supported. |
| CSRF_ENABLED | True | Enable Cross-Site Request Forgery Protection? | Don't change this. |
| MAIL_DEBUG | True | Don't actually send emails. Print to console instead. | Change in production. |
| MAIL_SERVER | 'smtp.gmail.com' | The SMTP server to send mail through. | |
| MAIL_PORT | 465 | The REMOTE Port to send mail on. | |
| MAIL_USE_SSL | True | Use SSL when sending mail? | |
| MAIL_USERNAME |<EMAIL_ADDRESS>| The mail account username on the SMTP server. | |
| MAIL_PASSWORD | 'abcd1234' | The mail account password on the SMTP server. | |
| MAIL_DEFAULT_SENDER | 'hpit-project.org' | Who to send mail as. | |
| USER_PASSWORD_HASH | 'bcrypt_sha256' | The hashing method for creating user passwords. | |
| USER_ENABLE_EMAIL | False | User's use email as their usernames? (mutually exclusive) | |
| USER_ENABLE_USERNAME | True | User use a standard username? (mutually exclusive) | |
| USER_ENABLE_CONFIRM_EMAIL | False | Enable email confirmation for user registration. | |
| USER_ENABLE_CHANGE_USERNAME | False | Allow a user to change their username? | |
| USER_ENABLE_CHANGE_PASSWORD | True | Allow a user to change their password? | |
| USER_ENABLE_FORGOT_PASSWORD | False | Allow a user to recover their password through email? | |
| USER_ENABLE_RETYPE_PASSWORD | True | Make a user retype their password when creating an account? | |
| USER_LOGIN_TEMPLATE | 'flask_user/login_or_register.html' | Login template rendered to HTML | |
| USER_REGISTER_TEMPLATE | 'flask_user/register.html' | Register template rendered to HTML |
| name | default | description | notes |
|---|---|---|---|
| HPIT_URL_ROOT | "http://localhost:8000" | The web address for HPIT | |
| DATASHOP_ROOT_URL | "https://pslcDataShop.web.cmu.edu/services" | Root DataShop URL | |
| DATASHOP_SERVICES_URL | "http://pslc-qa.andrew.cmu.edu/DataShop/services" | DataShop URL for services | |
| MONGODB_URI | "mongodb://localhost:27017/" | The location of the Mongo database server | |
| MONGO_DBNAME | "hpit_development" | The name of the mongoDB database to use for plugins. | |
| COUCHBASE_HOSTNAME | "<IP_ADDRESS>" | Couchbase host (unused) | |
| COUCHBASE_BUCKET_URI | "http://<IP_ADDRESS>:8091/pools/default/buckets" | Couchbase buckets REST endpoint (unused) | |
| COUCHBASE_AUTH | ["Administrator", "administrator"] | Authentication for Couchbase server (unused) | Set to your server credentials |
| PROJECT_DIR | "/Users/raymond/Projects/TutorGen/hpit" | The directory where the plugins are installed. | Change this. |
Here's a list of common problems when trying to install HPIT:
Permissions problems - if you're having troubles with permissions, make sure you are installing everything
in your user account, not root.
Settings problems - make sure the settings are edited correctly for your system. Verify that the paths to the
project directory and virtual environment are correct.
Python problems - Make sure that Python, Pip, and virtualenv are all compatible with each other.
Virtualenv problems - remember to activate your virtualenv when installing any python modules.
* Enviornment Variable Problems - Remember to set the HPIT_ENV environment to map to the settings file.
After starting the HPIT server, create an account, then sign-in to your account. There is no confirmation page after registering. The system will just direct you back to the signin/register page. After logging in two new options are available for you. 'My Plugins' and 'My Tutors'. On each of these pages you can register new plugins and tutors, respectively. For each plugin or tutor you create HPIT will generate for you an Entity ID (which never changes), and an API Key(which can change). The API Key will only be displayed once, if you lose it you'll have to generate another and update your plugin or tutor code to match the new key. You will need to supply the API key and Entity ID to HPIT for the plugin or tutor to connect to HPIT, and to send and retrieve messages. You can think of the Entity ID and API Key as a sort of username/password pair for connecting your tutor or plugin to HPIT. Keep these two pieces of information secure. The Entity ID can be told and released to others, but NEVER share your API Key with anyone.
The Docs page on the administration panel, shows these docs. The routes page on the administration panel shows the web service endpoints that HPIT exposes to tutors and plugins.
The HPIT Manager can be used to quickly launch an HPIT server, configure plugins and tutors, and monitor how data is being passed between entities within the HPIT system.
The HPIT manager can be run by typing: python3 manage.py <command> <command_args>
Depending on the command you wish to run the arguments to that command will vary. The command
line manager for HPIT will help you along the way. For example typing just python3 manage.py
will give you a list of commands that manager understands. Then typing
python3 manage.py your_command
will show you the arguments that that command can take and a
brief overview of what that command does.
Currently the HPIT Manager has the following commands:
python3 manage.py start
will start all locally configured tutors, and all locally configured plugins.python3 manage.py stop
will stop all locally configured tutors, and all locally configured plugins.python3 manage.py assets
will compile frontend assets together into a single file to ready for production deployments.python3 manage.py debug
will run the HPIT server in debug mode and WILL NOT start any plugins or tutors.python3 manage.py docs
copies this documentation file to the server assets directory.python3 manage.py routes
lists all the routes that the HPIT Server/Router exposes to the web.python3 manage.py syncdb
syncs the data model with the administration database.(PostgreSQL or Sqlite3)python3 manage.py indexdb
strategically indexes the databases, and in particular MongoDB for faster performance.python3 manage.py mongo <dbpath>
Initializes MongoDB database and starts the mongoDB server.python3 manage.py test
runs the suite of tests for components within HPIT.python3 manage.py admin
turns a user account into an admin, or deactivate admin for a user account.The goals behind the HPIT manager is to give TutorGen a way to create and destroy large amount of entities for testing and evaluation of the software. Creating a new HPIT entity (tutor/plugin) adds it to the 'configuration.json'. Removing an HPIT entity removes it from the 'configuration.json' file. All entities within the configuration specify 6 things:
Optionally, you can specify two optional parameters:
An example configuration would look like this:
json
{
"tutors" : [
{
"name": "replay_tutor",
"args": {
"beforeTime": "02-11-2020 14:03:09",
"filter": {
"event": "kt_trace"
}
},
"type": "replay",
"once": true,
"active": false,
"entity_id": "1234",
"api_key": "1234"
}
],
"plugins": [],
}
HPIT uses a relational database (SQLite or PostgreSQL) for administrative purposes. This database manages, users, plugin authentication, tutor authentication, and plugin subscriptions. By default this database is configured as SQLite and stored on the filesystem in the server/db subdirectory under HPIT. The models (tables) stored can be found in the server/models directory or by running SQLite and using the command '.tables'.
The HPIT server uses a NoSQL MongoDB database to manage its messages and transactions. MongoDB uses a lazy creation policy, so the database and its collections are created only after elements are inserted, and can be created with no prior configuration. The database contains five core collections:
A list of messages sent to the system before being duplicated to plugin_messages. Each message contains the following fields:
Contains messages sent to plugins, as copied from the messages collection. It contains the following fields:
Stores responses for tutors or other plugins to poll. It contains the following fields:
Stores plugin messages once they have been sent to plugin. It contains the following fields:
Store plugin responses once they have been sent to the original message sender (plugin or tutor). It contains the following fields:
Stores entity log information. It contains the following fields:
The HPIT Server is nothing more than an event-driven publish and subscribe framework, built specifically to assist plugins and tutors to communicate via RESTful webservices. It is schemaless, has no pre-defined events, and is agnostic to the kinds of data it routes between plugins and tutors. In additon HPIT provides fundamental support for sessions, authentication, message routing, and entity tracking.
Anyone can wrap these RESTful web services in a client side library and will be able to interact with HPIT. We have delivered a client side library written in Python.
The server supports a variety of routes to handle the connection, polling, and transfer of
data between HPIT entities. To get a list of these routes run the HPIT server with either
python3 manage.py debug
and open your browser to the HPIT administration page at
http://localhost:8000/routes. Alternatively you can list the routes available with
python3 manage.py routes
A Tutor is an HPIT entity that can send messages to HPIT. A message consists of an event name and a payload. The event name is an arbitrary string that defines what type of message it is. Plugins register to listen to messages based on the event name. The message payload is an arbitrary JSON like document with data formatted based on plugin requirements. The kinds of messages a tutor can send is defined by the plugins currently registered with HPIT. The HPIT server itself does not define what these messages look like, however HPIT does package some plugins as part of it's architecture.
For example the HPIT basic knowledge tracing plugin supports the following three events:
Depending on the event name(eg tutorgen.kt_set_initial, or tutorgen.kt_trace) the payload the plugin expects will be different.
Tutors may also listen to plugin responses, and respond to them. Plugins may or may not send a response depending on the plugin.
HPIT comes with two replay tutors that are used for testing purposes. The first is the Replay Tutor, located in hpit/tutors/replay.py. This tutor allows the user to replay messages and transactions that were already sent to HPIT, essentially simulating another tutor. The Replay Tutor must run on the same computer as the HPIT router, as it directly accesses the message routing database.
The Replay Tutor is usually run with a configuration in config.json along with the other plugins that are spun up in the HPIT environment. The configuration should have these parameters (along with those already necessary to run a tutor/plugin): - args, a dictionary of arguments, which most contain: - filter, an additional filter to query on - db_name, the name of the message routing database - (optional) beforeTime, specifies that messages before this time should be replayed - (optional) afterTime, specifies that messages after this time should be replayed - once, a boolean, if True, should only be run once, if false, it will continuously replay messages
Example configuration looks like this: { "active": false, "type": "replay", "args": { "filter": {}, "db_name": "hpit_development", "beforeTime": "02-11-2020 14:03:09" }, "entity_id": "ed188aa3-a673-4482-9475-aedd981ff360", "once": true, "api_key": "e992a697f396a2fd99ef9910cb040fa9", "name": "replay_tutor" }
Keep in mind that if the Replay Tutor has it's own entity_id, the results may vary from what you would expect, since some plugins differentiate between senders. In order to simulate another tutor, the Replay Tutor config should be set so that it uses the same entity ID and API key as that tutor.
The second tutor is the Replay2 Tutor, located at hpit/tutors/replay2.py This tutor's purpose is to replay PSLC Datashop transactions. This tutor can run on any machine and interacts with HPIT like any other tutor would. In order to use this plugin, datashop transactions must be imported. These are in a tab delimited text format and can be obtained from the PSLC Datashop website.
After importing transactions, they can be selected in the GUI and sent to HPIT. The
responses are displayed in the bottom most text box. It is also possible to knowledge trace
a skill and edit student attributes. The Replay2 Tutor is good for testing existing
transactions from Datashop as well as specific functionality in some of HPIT's built in
plugins. To run this tutor, use the command python hpit/tutors/replay2.py
.
The Replay2 Tutor's config is hard coded near the bottom of the script, so make sure it is edited to match your needs.
When a plugin first subscribes to a new message it is now said to "own" that message type. For example: Tutorgen owns the 'tutorgen.kt_trace' message type. We use this message internally in our knowledge tracer. You are welcome to send 'tutorgen.kt_trace' messages from a tutor or plugin, and our knowledge tracer will recieve the message and respond back to you with a result. However, If you were to write a plugin and try to subscribe to the 'tutorgen.kt_trace' message, the HPIT server would give you an access denied error because you don't "own" that message type. If you were curious as to what entity "owned" a particular message, you can query the "message-owner" RESTFUL API endpoint and we would tell you that plugin Entity ID: XXXXX owned it.
Now let's say you have a perfectly good reason to intercept a 'tutorgen.kt_trace' message, maybe you are a very tightly coupled partner of ours and we should give you the ability to read these messages, we could, as the "Message Owner" can grant you access to intercept and handle messages of this type. This is called an "Access Grant" and it is made by the owning entity when they send access grant information to the 'share-message' RESTFUL API endpoint.
In addition to owning messages. Anyone entity can also "lock down" certain resources that they control, by requesting a new resource token from HPIT. In the future if that resource is attempted to be accessed by someone you haven't given explicit permission to access, HPIT will prevent such a message from routing through it's system. You can request new resource token with the 'new-resource' RESTFUL API endpoin.
If you want to share a resource token with another entity you can do so by sending a resource access grant to the 'share-resource' RESTFUL API endpoint.
In HPIT, a transaction is supposed to be the smallest unit of interaction a student has with a tutor. The PSLC datashop uses transactions in its analysis of learning; it is the most fine grained representation of a student's skill set. Transactions can be generated by the student, like a key being press or an answer selected, or by the tutor, as in the tutor tells HPIT that the student was correct in answering a question.
Transactions act as a shortcut for the primary functionality of the main plugins in HPIT. For example, when a student answers a question, they would want to tell HPIT to:
A tutor could do this using the messages defined by HPIT's plugins, or they could send a single transaction. That
transaction will be passed to each of the main plugins, and return the information they have gathered in a single call.
Transactions should be the main way that tutors interact with HPIT.
A transaction requires these pieces of information:
Optional information includes:
Transaction Responses:
An example transaction payload looks like this:
json
{
'skill_names': {
'Unique-step': 'KC293',
'Default': 'same',
'Single-KC': 'Single-KC'
},
'outcome': 'Correct',
'skill_ids': {
'KC293': '',
'same': '',
'Single-KC': ''
},
'transaction_text': '4f5cf2e1f4ecf52030f7e1916ff87f9e',
'student_id': '54d27f95cc48d1184cf2a80a',
'session_id': '54d27f95cc48d1184cf2a80b',
'step_text': 'formB1_1 UpdateComboBox',
'problem_name': 'No Feedback (ver. b 0910)-0'
}
An example response looks like this:
json
{
"boredom_response": {
"bored": false,
"responder": "boredom"
},
"hf_response": {
"error": "'outcome' is not 'hint' for hint factory transaction.",
"responder": "hf"
},
"kt_response": {
"responder": "kt",
"traced_skills": {
"KC293": {
"probability_guess": 0.5,
"probability_known": 0.75,
"probability_learned": 0.5,
"probability_mistake": 0.5,
"skill_id": "54bd443dcc48d114c09f3cd5",
"student_id": "54d27f95cc48d1184cf2a80a"
},
"Single-KC": {
"probability_guess": 0.5,
"probability_known": 0.75,
"probability_learned": 0.5,
"probability_mistake": 0.5,
"skill_id": "54ad5636cc48d10b64d200c8",
"student_id": "54d27f95cc48d1184cf2a80a"
},
"same": {
"probability_guess": 0.5,
"probability_known": 0.75,
"probability_learned": 0.5,
"probability_mistake": 0.5,
"skill_id": "54bd443dcc48d114c09f3cd6",
"student_id": "54d27f95cc48d1184cf2a80a"
}
}
},
"problem_response": {
"problem_id": "54ad5639cc48d106bc7406b0",
"responder": "problem",
"step_id": "54bd4440cc48d112e073f163",
"transaction_id": "54bd4440cc48d112e073f164"
},
"session_id": "54d27f95cc48d1184cf2a80b",
"skill_ids": {
"KC293": "54bd443dcc48d114c09f3cd5",
"Single-KC": "54ad5636cc48d10b64d200c8",
"same": "54bd443dcc48d114c09f3cd6"
},
"skill_response": {
"responder": "skill",
"skill_ids": {
"KC293": "54bd443dcc48d114c09f3cd5",
"Single-KC": "54ad5636cc48d10b64d200c8",
"same": "54bd443dcc48d114c09f3cd6"
}
},
"student_id": "54d27f95cc48d1184cf2a80a",
"student_response": {
"responder": "student",
"session_id": "54d27f95cc48d1184cf2a80b",
"student_id": "54d27f95cc48d1184cf2a80a"
}
}
Transactions are sent by the tutor's send_transaction() method, which uses the API's /transaction endpoint.
A Plugin is an HPIT entity that subscribes to (listens to) certain event names, receives transaction payloads, performs some arbitrary function based on the event and message payload, and may or may not return a response to the original sender of the message.
A plugin may listen to and define any events it wishes. When a tutor sends a message to HPIT, if a plugin has registered itself with HPIT, and if that plugin and subscribed to the event name submitted with the tutor's message, it will receive a queued list of messages when it polls the HPIT server for data. It is expected that plugins will do this type of polling periodically to see if any new messages have been queued for processing by HPIT.
When a plugin processes an event from HPIT, it will receive all the information in the original message, including the information identifying the tutor that sent the message. This identifying information is called the entity_id of the tutor.
A plugin may send a response to HPIT by providing the original message id, along with a response payload, which will be sent to the original sender of the message message.
It is possible for plugins to send messages like tutors and respond to messages like tutors. In this way, it is possible for plugins to listen to, and re-fire event messages while altering the event name of the message so that other dependent plugins can also respond to the original transaction. This can create a daisy chaining effect where plugins fire in series to process a complex series of messages.
The example plugin listens to the test
and example
event names and logs
whatever data it's sent in the payload to a file.
The student management plugin allows you to track students across your applications and integrates into skill management and knowledge tracing. In addition, you can assign any number of attributes to your students and retrieve them later. These attributes can cover anything; how much they like sports, their age, brand preferences, etc.
Adds a student to the database, giving them a unique ID.
Receives:
Returns:
Gets an already created student from an ID.
Receives:
Returns:
Sets an attribute value for a student. Will overwrite any existing value.
Receives:
Returns:
Gets an attribute value for a student. If the attribute does not exist, will respond with an empty string.
Receives:
Returns:
Get the student model for a student. The student model is an aggregation of information from all of the plugins that the student has interacted with.
Receives:
(optional) update : boolean - whether or not the student model should be updated (True) or from cache (False). Returns:
student_id : string - the ID of the student
The skill management plugin allows you to track skills across your applications and integrates into knowledge tracing, problem selection, problem management, and the hint factory. The skill manager identifies skills by either an assigned identifier or by name.
Gets the name of an existing skill from an ID.
Receives:
Returns:
Gets the ID of a skill from a skill name. If the skill does not exist, it will be created.
Receives:
Returns:
Gets the ID for multiple skill names. If the skill does not exist, it will be created.
Receives:
Returns:
The Knowledge Tracing Plugin performs knowledge tracing on a per-student and per-skill basis.
Sets the initial probabilistic values for the knowledge tracer.
Receives:
Returns:
Resets the probabilistic values for the knowledge tracer.
Receives:
Returns:
Runs a knowledge tracing algorithm on the skill/tutor combination and returns the result. If a setting doesn't exist this plugin will create one with initial values of 0.5 for each probablity.
Receives:
Returns:
Returns a this plugin's contribution to the overall student model. For the knowledge tracing plugin, this is all of the student's skills and knowledge tracing values. This is usually sent via the StudentManagement model after it receives a get_student_model message.
Receives:
Returns:
The Hint Factory Plugin is used to dynamically provide hints using a graph theoretic approach.
Initializes a new problem for the hint factory.
Receives:
Returns:
Deletes a state and all edges attached to it.
Receives:
Returns:
Pushes a new state on the problem.
Receives:
Returns:
Given a particular state structure. Does a hint exist for this problem?
Receives:
Returns:
Given a particular state structure for a problem, retrieve the next most probable state that leads the student towards a solution.
Receives:
Returns:
Receives: state : json - A json object representing the state to push. state.problem_state: string - A string representing the new state of the problem. i.e. "x = 4" state.steps: array of strings - A list of steps taken from the starting state to get to this state. i.e. ["Subtract 4", "Divide 2"] state.last_problem_state: string - What state this problem was in before this state. i.e. "2x = 8" * state.problem: string - A string representing the problem i.e "2x + 4 = 12"
Returns: status: string - OK or NOT_OK error: string - optional, if NOT_OK and an error happened
Adds a problem to the problem manager.
Receives:
Returns:
Remove a problem from the problem manager.
Receives:
Returns:
Gets a previously stored problem from the problem manager.
Receives:
Returns:
Edits a problem. The tutor or plugin editing it must have the same ID as edit_allowed_id.
Receives:
Returns: problem_name : string - The name of the problem. problem_text : string - The text of the problem. date_created : datetime - The time the problem was created. edit_allowed_id : string - The ID of the entity that can edit this problem. success : boolean - If the edit was successful. (optional) error : string - The error message, if an error occured.
Get all the problems in the database.
Receives:
Returns:
Clone an existing problem so that another entity can modify it.
Receives:
Returns:
This is used to show a student has worked on a problem.
Receives:
Returns:
Retrieves the problems a student has worked on.
Receives:
Returns:
Adds a problem step to a problem.
Receives:
Returns:
Remove a problem step from the problem manager.
Receives:
Returns:
Gets a previously stored problem step from the problem manager.
Receives:
Returns:
Get all the problem steps for a given problem..
Receives:
Returns:
Returns a dictionary of problem names and problem ID's that have skills with a certain skill.
Receives:
Returns:
Returns a this plugin's contribution to the overall student model. For the problem management plugin, this is all of the problems the student has worked on. This is usually sent via the StudentManagement model after it receives a get_student_model message.
Receives:
Returns:
The Problem Generator Plugin is useful for randomly generating mathematics problems on demand. Right now, this generator is used mostly for integration tests between tutors and plugins. TutorGen may extend the possible set of problems in the future.
Retrieve a list of potential problems organized by, subject, category and skill.
Receives:
Returns:
Generates a random problem for a specific subject, category, and skill. If the subject, category or skill doesn't have a generator associated with it, the plugin will return an error. If the subject, category, or skill is not provided the problem generator will choose one randomly.
Recieves:
Returns:
Errors on invalid subject, category, or skill provided in request. Errors return as the following:
The Data Storage Plugin can be used to store any kind of key value information that a plugin or tutor may need.
Store a key value pair in the database.
Receives:
Returns:
Get a value from the database via a key.
Receives:
Returns:
Removes data from the database.
Receives:
Returns:
The PSLC DataShop Connection Plugin gives basic connectivity to the PSLC DataShop. Currently, it only provides for a subset of functionality that they provide via their web services.
Gets the dataset metadata.
Receives:
Returns:
Gets the metadata for a DataShop sample.
Receives:
Returns:
Gets transactions from a dataset or optionally a specific sample.
Receives:
Returns:
Gets the student steps from a dataset or optionally a specific sample.
Receives:
Returns:
Adds a custom field to a dataset.
Receives:
Returns:
The Boredom Detector looks at student data and determines if they may be bored. The detector allows for multiple different boredom detection models. The two that exist now are "simple", which just looks at the time difference between transactions, and "complex", which as of now does nothing but return true.
Send a student interaction to the boredom detector.
Receives:
Returns:
Change the way that the boredom detector determines if a student is bored.
Receives:
Returns:
Change the threshold of probability required to deem student is bored.
Receives:
Returns:
This software is dual licensed under the MIT License and the BSD 3-clause license.
==============================================================================
The MIT License (MIT)
Copyright (c) 2014 TutorGen, Inc. All rights reserved.
Contributions by:
In association with Carnegie Mellon University, Carnegie Learning, and Advanced Distributed Learning.
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
==============================================================================
OR
==============================================================================
The BSD 3-Clause License
Copyright (c) 2014, TutorGen, Inc. All rights reserved.
Contributions by:
In association with Carnegie Mellon University, Carnegie Learning, and Advanced Distributed Learning.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.


Refactoring code I wrote yesterday. It's cool to see a piece of code continually improving as you work on it.
1/13/2009, 12:10:24 PM
Favs: 0
Retweets: 0
link--- layout: tweet ---
Refactoring code I wrote yesterday. It's cool to see a piece of code continually improving as you work on it.
1/13/2009, 12:10:24 PM
Favs: 0
Retweets: 0
link


North American Shared Print Initiative Facilitated by Sustainable Collection Services, a part of OCLC
Over 145 academic institutions spanning fourteen U.S. states and five Canadian provinces have joined the OCLC Shared Print Initiative so far.
Those institutions have identified 7.6 million distinct editions for long-term retention, representing 19.7 million print holdings across North America.
Shared print initiatives facilitated by SCS are also starting to take hold across the world, with programs underway in the United Kingdom and Australia.
Titles Retained
Shared Print Overview
Models and retention criteria vary according to local and regional priorities, but most of the committed titles are secured under formal Memoranda of Understanding (MOU) for 15 years, often with review every five years. In some respects, these are grass-roots activities, designed to address local needs, but it seems clear that these programs can contribute significantly to a federated national or international solution, such as that envisioned by the MLA’s Working Group on The Future of the Print Record.
Member Libraries
143
Member Libraries
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Nihil sunt nobis tenetur, quidem nesciunt laborum esse impedit possimus praesentium ipsum officia consequuntur fugit quo sequi delectus assumenda deserunt voluptas odit.
7.6
Distinct Editions
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Nihil sunt nobis tenetur, quidem nesciunt laborum esse impedit possimus praesentium ipsum officia consequuntur fugit quo sequi delectus assumenda deserunt voluptas odit.
19.7
Title Holdings
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Nihil sunt nobis tenetur, quidem nesciunt laborum esse impedit possimus praesentium ipsum officia consequuntur fugit quo sequi delectus assumenda deserunt voluptas odit.
Search the Shared Print Collection
What kinds of books are being protected by participating libraries? Most shared print intitatives have focused on guaranteeing the protection of rare titles that are held by very few libraries. This strategy helps secure a robust future for titles that might otherwise be at risk of destruction, as well as gives libraries an opportunity to make effective use of their physical space with the knowledge that the scholarly record will be preserved.
Below you'll see a sample of books that belong to shared print collection. You can also use the search box to explore other titles in the collection. Below each title is a color-coded list of the shared print programs that have committed to retain that title.
-
Henley, Patricia. The Hummingbird House. 3rd ed., MacMurray, 1999.
- EAST 15yr
-
Henley, Patricia. Lorem ipsum dolor sit amet, consectetur adipisicing elit. Molestiae aspernatur non assumenda, necessitatibus repellat. Repellat quas cumque iure aperiam qui incidunt accusantium ex, voluptatem deserunt delectus omnis doloremque optio earum. 3rd ed., MacMurray, 1999.
- EAST 15yr
- SCELC 15yr
- ALI15yr
-
Henley, Patricia. Lorem ipsum dolor sit amet, consectetur adipisicing elit. Molestiae aspernatur non assumenda, necessitatibus repellat. Repellat quas cumque iure aperiam qui incidunt accusantium ex, voluptatem deserunt delectus omnis doloremque optio earum. 3rd ed., MacMurray, 1999.
- MI-SPI 15yr
- COPPUL15yr
Collaborative Decisions, Made Possible with GreenGlass
The GreenGlass software product has facilitated all shared print initiatives since 2015. GreenGlass employs visualizations and modeling tools to allow groups of libraries to reach consensus quickly, make informed decisions, and fairly assign commitments to retain titles amongst the members of the shared print collection.
For inquiries into starting or joining a shared print initiative at your library, drop Rick Lugg a line at luggr@oclc.org


PROFILE.
URA YUTO
kbkzdkhlljhxhxlzlnlnzklucgihixhljhwfchxvhhfjkalhlhflahsjlfhjahjfhlsajhlfafhalhfjasdhfkjasdfalkdfvbjjzcmkneuffvnurvanjldanj sfgklhglahjlkhgkhalhgjhgjhsdjlfhgjsdjfbjklsdnfjkndabjndfjgbajkdgnjkfdbjkadngjknjkga;kng;j
SKILL.
HTML/CSS/JS
kbkzdkhlljhxhxlzlnlnzklucgihixhljhwfchxvhhfjkalhlhflahsjlfhjahjfhlsajhlfafhalhfjasdhfkjasdfalkdfvbjjzcmkneuffvnurvanjldanj sfgklhglahjlkhgkhalhgjhgjhsdjlfhgjsdjfbjklsdnfjkndabjndfjgbajkdgnjkfdbjkadngjknjkga;kng;j
Wordpress/PHP
kbkzdkhlljhxhxlzlnlnzklucgihixhljhwfchxvhhfjkalhlhflahsjlfhjahjfhlsajhlfafhalhfjasdhfkjasdfalkdfvbjjzcmkneuffvnurvanjldanj sfgklhglahjlkhgkhalhgjhgjhsdjlfhgjsdjfbjklsdnfjkndabjndfjgbajkdgnjkfdbjkadngjknjkga;kng;j
Adobe Tool
kbkzdkhlljhxhxlzlnlnzklucgihixhljhwfchxvhhfjkalhlhflahsjlfhjahjfhlsajhlfafhalhfjasdhfkjasdfalkdfvbjjzcmkneuffvnurvanjldanj sfgklhglahjlkhgkhalhgjhgjhsdjlfhgjsdjfbjklsdnfjkndabjndfjgbajkdgnjkfdbjkadngjknjkga;kng;j
WORK.
Card title
This is a longer card with supporting text below as a natural lead-in to additional content. This content is a little bit longer.
This is a longer card with supporting text below as a natural lead-in to additional content.
Card title
This is a short card.
This is a longer card with supporting text below as a natural lead-in to additional content.
Card title
This is a longer card with supporting text below as a natural lead-in to additional content.
This is a longer card with supporting text below as a natural lead-in to additional content.


Table as <select|list>, keyboard navigation is operational
Option 1
*Short*
123456
Option 2
******* LOONG ********
123456
Option 3
*Short*
123456


| Name
|
Description
|
|
browser
|
Returns information about the Browser.
|
Returns an object with the following fields:
- name - Browser Name. Possible values: "Internet Explorer", "Webkit", "Chrome", "Safari", "Opera", "Opera Mobile", "Dolphin", "Chrome Mobile", "webOSBrowser", "Silk", "Firefox".
- accessName - "msie", "webkit", "chrome", "safari", "opera", "operamobile", "dolphin", "chromemobile", "webosbrowser", "silk", "firefox".
- version - Browser Version.
- canvas - Boolean field which determines whether Canvas is supported.
- svg - Boolean field which determines whether SVG is supported.
- vml - Boolean field which determines whether VML is supported.
Code example
Get the browser property.
var response = new $.jqx.response();
var browser = response.browser;
// gets the current browser's name.
var name = browser.name;
// gets the current browser's version.
var version = browser.version;
Run code only for a specific browser
var response = new $.jqx.response();
var browser = response.browser;
if (browser.msie)
{
// add code specific for Internet Explorer.
if (browser.version == 7)
{
// add code specific for Internet Explorer 7
}
}
else if (browser.firefox)
{
// add code specific for Firefox
}
|
|
device
|
Returns information about the Device.
|
Returns an object with the following fields:
- type - Device Type. Possible values: "Desktop", "Tablet", "Phone".
- touch - Boolean field which determines whether the device is touch enabled.
- width - screen width.
- height - screen height.
- availWidth - screen's usable width.
- availHeight - screen's usable height i.e minus UI headers and/or footers.
*Device size is static and does not change when the page is resized or rotated.
Code example
Get the device property.
var response = new $.jqx.response();
var device = response.device;
var type = device.type;
var isTouchDevice = device.touch;
var screenWidth = device.width;
var screenHeight = device.height;
|
|
document
|
Returns information about the document.
|
Returns an object with the following fields:
- width - document's width.
- height - document's height.
*document's size changes when the page is resized.
Code example
Get the document property.
var response = new $.jqx.response();
var document = response.document;
var width = document.width;
var height = document.height;
|
|
destroy
|
Destroys the plug-in.
|
Code example
var response = new $.jqx.response();
response.destroy();
|
|
resize
|
Callback function or functions called when the browser's window is resized.
|
Code example
var response = new $.jqx.response();
response.resize(function (event) {
// your code here.
});
Code example with multiple callbacks
var response = new $.jqx.response();
var resizeFunction1 = function () {
console.log("resizeFunction1 is called");
}
var resizeFunction2 = function () {
console.log("resizeFunction2 is called");
}
response.resize([resizeFunction1, resizeFunction2]);
|
|
isHidden
|
Checks whether a HTML Element is hidden.
|
The function accepts HTML Element as parameter and returns true, if the element is hidden or false if not.
Code example
var response = new $.jqx.response();
var hidden = response.isHidden($("#someID")[0]);
|
|
inViewPort
|
Checks whether a HTML Element is in the view port.
|
The function accepts HTML Element as parameter and returns true, if the element is in the view port or false if not.
Code example
var response = new $.jqx.response();
var inViewPort = response.inViewPort($("#someID")[0]);
|
|
os
|
Returns information about the OS.
|
Returns an object with the following fields:
- name - OS Name. Possible values: "iOS", "Android", "webOS", "BlackBerry", "RIMTablet", "MacOS", "Windows", "Linux", "Bada".
- version - OS Version.
- platform - OS Platform.
Code example
Get the os property.
var response = new $.jqx.response();
var os = response.os;
|
|
pointerDown
|
Event handler for mouse and touch events that works across browsers. "pointerDown" automatically handles the "mousedown", "MSPointerDown" and "touchstart" events on an element and calls a callback function with 3 parameters(original event, pointer position and pointer type).
|
The function has 2 parameters:
- HTML Element - the element that will receive events.
- Callback function that is called when the mouse pointer is over the element and the mouse button is pressed or a contact touches the screen on element.
- event - the original Event object.
- position - object with the following fields:
- left - X position relative to the top-left edge of the document.
- top - Y position relative to the top-left edge of the document.
- pointerType - the pointer's type - "touch" or "mouse".
Code example
var response = new $.jqx.response();
response.pointerDown($(document), function (event, position, pointerType) {
});
|
|
pointerMove
|
Event handler for mouse and touch events that works across browsers. "pointerMove" automatically handles the "mousemove", "MSPointerMove" and "touchmove" events on an element and calls a callback function with 3 parameters(original event, pointer position and pointer type).
|
The function has 2 parameters:
- HTML Element - the element that will receive events.
- Callback function that is called when the mouse pointer is over the element and is moved or a contact moves on the screen while over an element.
- event - the original Event object.
- position - object with the following fields:
- left - X position relative to the top-left edge of the document.
- top - Y position relative to the top-left edge of the document.
- pointerType - the pointer's type - "touch" or "mouse".
Code example
var response = new $.jqx.response();
response.pointerMove($(document), function (event, position, pointerType) {
});
|
|
pointerUp
|
Event handler for mouse and touch events that works across browsers. "pointerUp" automatically handles the "mouseup", "MSPointerUp" and "touchend" events on an element and calls a callback function with 3 parameters(original event, pointer position and pointer type).
|
The function has 2 parameters:
- HTML Element - the element that will receive events.
- Callback function that is called when the mouse pointer is over the element and the mouse button is released or a contact is raised off of the screen over an element.
- event - the original Event object.
- position - object with the following fields:
- left - X position relative to the top-left edge of the document.
- top - Y position relative to the top-left edge of the document.
- pointerType - the pointer's type - "touch" or "mouse".
Code example
var response = new $.jqx.response();
response.pointerUp($(document), function (event, position, pointerType) {
});
|
|
refresh
|
Refreshes the plug-in properties.
|
Code example
var response = new $.jqx.response();
response.refresh();
|
|
scroll
|
Returns information about the Scrollbars position.
|
Returns an object with the following fields:
- left - horizontal scrollbar's position.
- top - vertical scrollbar's position.
Code example
Get the scroll property.
var response = new $.jqx.response();
var scroll = response.scroll;
var left = scroll.left;
var top = scroll.top;
|
|
viewPort
|
Returns information about the view port.
|
Returns an object with the following fields:
- width - view port's width.
- height - view port's height.
*viewPort's size changes when the page is resized.
Code example
Get the viewPort property.
var response = new $.jqx.response();
var viewPort = response.viewPort;
var width = viewPort.width;
var height = viewPort.height;
|


(Rogers, 2016)
In this blog post, lets delve back into the Designer for Learning project and look at understanding the process of evaluating a learning experience. I choose this lesson and as you can see it is lacking some basic fundamental instructional design best practices.
First lets look at the evaluation process.
List of Measurable Verbs Used to Assess Learning Outcomes
When looking at the lesson plan I reflected on these questions:
Do the learning objectives describe skills and knowledge associated with a problem or task that has a real-life purpose?
To what extent are the learning objectives specific, outcome-based, and measurable? Do they describe the desired learner behavior?
Are the learning objectives appropriately aligned with the College and Career Readiness Standards?
Are the selected action verbs within the learning objectives applicable to the desired level of learning (based on Bloom’s taxonomy)?
For any deficiencies you noted in the lesson’s learning objectives, try your hand at drafting improved learning objectives. By the end of the lesson, the adult learner should be able to:
Glossary of over 1,200 instructional strategies developed by Kelly Jo Rowan
I also reviewed the lesson plan and related instructional materials to reflect on the following:
What specific activation activities (if any) are included within the lesson to activate the learners’ previous relevant experience with the topic of instruction?
To what extent do you feel these activation activities are effectively and efficiently designed?
What examples from either Adding TEC-Variety by Curtis J. Bonk and Elaine Khoo or Kelly Rowan’s glossary instructional strategies are applicable to the activations phase?
What are some other relevant life experiences that you could incorporate into a redesign of your lesson as part of an activation activity for the subject and topic of instruction you are evaluating, as well as the learner persona you are contemplating?
The purpose of the demonstration phase is to show learners how to apply skills instead of merely telling them what to do. Demonstration activities can provide a meaningful context to general information, help learners develop mental models about the concepts, attract the learners’ attention, and sustain their curiosity. While demonstration activities are used to deliver the content, the learners don’t need to be passive recipients.
Citing research on instruction, Merrill (2007, p. 10) suggests demonstration activities should:
Demonstrate through examples what is to be learned rather than merely telling information about what is to be learned.
Provide demonstrations that are consistent with the content being taught, including examples and non-examples for kinds-of (i.e. concepts), demonstrations for how-to (i.e. procedures), and visualizations for what-happens (i.e. processes).
Include learner guidance techniques, such as directing the learner’s attention to relevant information, including and comparing multiple representations, relating new information to previously recalled or provided information.
Incorporate media that are relevant to the content and used to enhance learning.
The Evaluation Decisions were made after reviewing the lesson plan, related instructional materials, and reflecting on the following:
What types of demonstration activities (if any) are included within the lesson to demonstrate (versus tell) what is to be learned?
Are these demonstration activities consistent with the lesson’s learning goals and the to-be-learned skills and knowledge?
How is the learner is guided through the demonstration activities (e.g., from an instructor or instructions in the material)?
To what extent do you feel these demonstration activities are effectively and efficiently designed?
What examples from either Adding TEC-VarietyLinks to an external site. by Curtis J. Bonk and Elaine Khoo or Kelly Rowan’s glossary instructional strategiesLinks to an external site. are applicable to demonstration?
What are some other types of presentation, storytelling, or other demonstration strategies you could incorporate into a redesign of your lesson?
Application: Overview
The purpose of application phase is to elevate learning from passive reading and watching to applying and creating knowledge. This phase includes the instructional interactions with the content, the instructor, and others that facilitate practice of knowledge and skills. After a skill is demonstrated, the learners should be given ample opportunities to apply their new knowledge with guidance and feedback that is corrective, specific, and timely. Citing research on instruction, Merrill (2007, p. 12). Suggests application activities should:
Give learners an opportunity to practice and apply their newly acquired knowledge or skill.
Include application (practice) and assessment (tests) consistent with the stated or implied objectives.
Follow practice with corrective feedback, and an indication of progress (as opposed to just right-wrong feedback).
Offer learners access to help or provide coaching when they are having difficulty in solving the problem or doing the task wherein coaching gradually diminishes with each subsequent task until learners are performing on-their-own.
Require learners to use their new knowledge or skill to solve a varied sequence of problems or complete a varied sequence of tasks.
The following are a few examples of activities can be used for the application phase.
Practice activities help your learners apply knowledge and skills taught during the instruction.
Discovery and case study activities can be used to motivate and encourage your learners to invest mental effort in practices or problem-solving.
Games and Simulations can be used to have your learners apply information in a more realistic environment to motivate them.
Evaluation Decisions were made after reviewing the lesson plan, related instructional materials, and reflecting on the following:
What specific application activities (if any) are included within the lesson that require learners to use (apply) the new skill or knowledge?
Is the learner guided in their application / problem solving via feedback and coaching? If so, what learner guidance (from an instructor or the materials) is given within the designed application activities?
Are the learner practice opportunities consistent with lesson’s objectives?
Overall, to what extent do you feel these application activities are effectively and efficiently designed?
What examples from either Adding TEC-Variety by Curtis J. Bonk and Elaine Khoo or Kelly Rowan’s glossary instructional strategies are applicable to the application phase?
What other application activities could incorporate into a redesign of your lesson for the subject and topic of instruction you are evaluating, as well as the learner persona you are contemplating?
The instructional goal must be the learners who know what to do with the newly learned information. If they have information without knowing how and when to use, your instruction has not reached its goal. This situation is similar to having the latest version of a smartphone, but still using it only for phone calls because you do not know what to do with other features. Citing research on instruction, Merrill (2007, p. 13). Integration activities should provide:
Techniques that encourage learners to integrate (transfer) the new knowledge or skill into their everyday life.
Opportunity for the learner to publicly demonstrate their new knowledge or skill.
Opportunity for learners to reflect-on, discuss, and defend their new knowledge or skill.
Opportunity for learners to create, invent, or explore new and personal ways to use their new knowledge or skill.
Examples of types of integration phase activities include:
Ponder activities aid your learners to think broadly and deeply about a topic.

Job aids help your learners as a reminder to apply their learning to real-life situations.
Research activities encourage your learners to discover and use their own sources of information.
Evaluation Decisions
What specific integration activities (if any) are included within the lesson that require learners to reflect upon, discuss, defend, use, or demonstrate the new skill or knowledge in their everyday life?
What learner guidance (from an instructor or the materials) is needed within these integration activities?
To what extent do you feel these integration activities are effectively and efficiently designed? When evaluating and designing integration activities, keep in mind that effective integration activities prompt learners to reflect what they learn by describing their experiences and challenges, and encourage them to apply new knowledge and skills into their life, or relate their new knowledge to future goals.
What examples from either Adding TEC-Variety by Curtis J. Bonk and Elaine Khoo or Kelly Rowan’s glossary instructional strategies are applicable to the integration phase?
What other integration activities could incorporate into a redesign of your lesson for the subject and topic of instruction you are evaluating, as well as the learner persona you are contemplating?
As noted previously, learning objectives also play a role in learner assessment. At points in the learning experience, assessments are needed to determine whether or not learners are able to achieve or master the learning objectives.
In general, there are two types of design assessments:
Formative assessment measures student learning during the learning process,
Summative assessment measures learning that occurs at the end of the learning experience.
Below is a list of assessment considerations from the:
WGBH Educational Foundations, The Guiding Principles of AssessmentLinks to an external site.
Assessments measure students’ attainment of learning outcomes.
Assessments measure the level of student success.
There should be a connection between the way students learn the material and the way they are tested on it.
Assessments should be varied.
Assessments include formal and informal evaluations.
Students should know the assessment plan at the beginning of a course.
I Reviewed the lesson plan, related instructional materials, and reflected on the following:
What types of formative and summative assessment activities are incorporated into the lesson you are evaluating to measure the learners’ attainment (or mastery) of the learning outcomes?
To what extent is the learner given the opportunity to display his / her new skill and knowledge improvement in appropriate assessments linked to the stated learning objectives?
What are ways that you can redesign the assessment(s) to better connect the way the material is learned and the way the learners are assessed?
How can you vary the assessments to include both formal and informal assessments?
In addition to contemplating the extent to which the lesson includes sound instructional principles discussed previously, I evaluated additional items that are described below, including:
Content Elements
Course Structure and Sequencing
Learner Experience
Instructional Media
Affective Consideration
Content sufficiency: Is the content prepared for the lesson sufficient to support course goals and objectives?
Relevance: Are the lesson topics and presented content in the instructional materials relevant to our target adult learners?
Level: Is the content appropriate for the learning level of our target adult learners?
Accuracy: Is the content free of errors, jargon, and cultural bias?
Length: Is the instructional unit of appropriate length, and can the learner complete the lesson within the estimated time frames?
I considered the extent to which the following were effectively and efficiently designed within the lesson:
How the content and instructional activities will be sequenced
How and when learners will engage in active practice and reflection
How and when learner assessment will occur
How and when learner guidance will be offered
I contemplated the degree to which the following learner experience, material design, and course navigation were effectively and efficiently presented:
Lesson introduction
Directions and help for the instructor and learners
Lesson navigation
Lesson conclusion
Overall ease of use
I Deliberated the instructional media elements efficiency and effectiveness in supporting the designed instructional approaches, and if any media elements should be added / amended to better support the instructional delivery:
Text
Images and graphics
Audio
Animation and Video
Links to Resources
Printable Documents
I ruminated the scope to which the lesson was likely to accomplish the following for the target audience of learners:
Arouse curiosity
Establish relevance
Offer appropriate level of challenge
Maintain a learner’s attention
Multimedia for learning: Methods and development
I Looked for other areas of need as this list is not extensive.
Take a look at excerpts of my notes to see how I evaluated the instruction:
This learning objective does address the problem of poor interview behaviors.
The learning objectives are measurable through observation, and student work.
This does not align to any of the specific CCRS standards as they outline information on speaking properly and understand someone but not body language or behaviors.
Illustrate is used which is an action verb describing an action to be taken; however, demonstrate would be more applicable.
Objective: The student will demonstrate proper interview language and behavior.
The use of a KWL chart acts as an activation component.
They are effective and efficient especially for students with a lack of Internet options. Very simple any instructor would have the resources for.
Job connection and strategic planning papers could be used as an activation activity that is more novel and exciting to the students.
Any life experiences in which the student had to interact with authority times when it went badly and times it went well.
Examples are provided through a YouTube video presentation of a poor interview. Although, a proper interview is not available to contrast the first video.
How-to is not provided as the lesson expects the learners to teach themselves the proper interview behaviors.
Guidance is not provided, and relevant information is not pointed out.
Nothing is compared and contrasted with higher learning skills.
Previously recalled information is not used.
Activity 54. Language Learning Conversations and Mentoring of TEC-Variety would be applicable to demonstration.
The lesson uses role-playing to demonstrate new skills.
Coaching is not mentioned in this lesson.
The practice opportunities are aligned to the objective.
The design is poor and lacking detail for the teacher and student.
Activity 56. Cross-Cultural Web Conferencing and Interactions of TEC-Variety would provide an opportunity for students to practice via Skype.
An incorporation of an online game in which learners chose proper attire would be helpful.
This lesson needs to be more interactive it is very barebones with only a single video for instruction. There is a lack of coaching and direction given to the teacher and students.
I hope to make the learning experience engaging and applicable to real-life. Providing more interaction and instruction has the ability to liven up the lesson. Further, some eLearning in the design would be beneficial for the student and the instructor.
Reference


Prince Andrew slammed for saying paedo friend acted in a 'manner unbecoming'
The Labour MP Jess Phillips was among viewers who reacted with horror to the Duke of York's choice of words in his interview with BBC Newsnight interview Emily Maitlis
by Talia Shadwell, https://www.mirror.co.uk/authors/talia-shadwell/BBC viewers have reacted with disbelief to Prince Andrew's description of his paedophile friend Jeffrey Epstein's behaviour as "unbecoming."
Many who watched the broadcast reacted with shock to the Duke of York's choice of words in an exchange with BBC Newsnight interviewer Emily Maitlis tonight.
Prince Andrew has faced questions over his judgement in maintaining a friendship with the disgraced billionaire, who was found dead by apparent suicide in his cell in New York in August.
Epstein was awaiting trial over sex trafficking charges.
In 2010, the prince was photographed walking with Epstein in New York's Central Park - two years after Epstein's earlier first conviction for soliciting a minor for prostitution.

Prince Andrew can be heard to reflect to Maitlis during the interview that aired tonight on BBC Two: "On balance, could I have avoided ever meeting him?
"Probably not and that’s because of my friendship with Ghislaine, it was…it was…it was inevitable that we would have come across each other.
"Do I regret the fact that he has quite obviously conducted himself in a manner unbecoming? Yes."
Maitlis replies replies: "Unbecoming? He was a sex offender."
The Prince responds: "Yeah, I’m sorry, I’m being polite, I mean in the sense that he was a sex offender."
Labour MP Jess Phillips was among those shocked by the Duke's comments, tweeting: "A manner unbecoming, he raped children!!!!"
The Duke of York has come under additional scrutiny in accusations by Virginia Giuffre- formerly Virginia Roberts- that she had sex with him on three occasions when she was aged 17.
In tonight's wide-ranging interview, the prince claimed he had never had sex with Ms Giuffre, and did not recall ever meeting her.
He has questioned the validity of a photograph showing the pair pictured together with his arm looped around the teenager.
He claimed he had been eating at Pizza Express with daughter Princess Beatrice on one night that Ms Giuffre claims she had sex with the prince when she was 17.
He said he recalled the dinner at the pizza branch in Woking for a party "weirdly distinctly" as it was such a rare occurrence.
When Maitlis asked the Prince about Giuffre’s allegations that he was sweating when they danced in Tramp nightclub, the Prince said it was impossible as he had "peculiar medical condition.
“I didn’t sweat at the time because I had suffered what I would describe as an overdose of adrenaline in the Falklands War when I was shot at and I simply... it was almost impossible for me to sweat.”
The Prince also told Maitlis he and Epstein were not as close friends as some had suggested, and told Maitlis his New York home was a "convenient place to stay."


Survey pentru stagiu de practică
Additional authentication required.
Log into your account to access further information.


Next: Conditions Dictionary, Previous: Conditions, Up: Conditions
Common Lisp constructs are described not only in terms of their behavior in situations during which they are intended to be used (see the "Description" part of each operator specification), but in all other situations (see the "Exceptional Situations" part of each operator specification).
A situation is the evaluation of an expression in a specific context. A condition is an object that represents a specific situation that has been detected. Conditions are generalized instances of the class condition. A hierarchy of condition classes is defined in Common Lisp. A condition has slots that contain data relevant to the situation that the condition represents.
An error is a situation in which normal program execution cannot continue correctly without some form of intervention (either interactively by the user or under program control). Not all errors are detected. When an error goes undetected, the effects can be implementation-dependent, implementation-defined, unspecified, or undefined. See Definitions. All detected errors can be represented by conditions, but not all conditions represent errors.
Signaling is the process by which a condition can alter the flow of control in a program by raising the condition which can then be handled. The functions error, cerror, signal, and warn are used to signal conditions.
The process of signaling involves the selection and invocation of a handler from a set of active handlers. A handler is a function of one argument (the condition) that is invoked to handle a condition. Each handler is associated with a condition type, and a handler will be invoked only on a condition of the handler’s associated type.
Active handlers are established dynamically (see handler-bind or handler-case). Handlers are invoked in a dynamic environment equivalent to that of the signaler, except that the set of active handlers is bound in such a way as to include only those that were active at the time the handler being invoked was established. Signaling a condition has no side-effect on the condition, and there is no dynamic state contained in a condition.
If a handler is invoked, it can address the situation in one of three ways:
It can decline to handle the condition. It does this by simply returning rather than transferring control. When this happens, any values returned by the handler are ignored and the next most recently established handler is invoked. If there is no such handler and the signaling function is error or cerror, the debugger is entered in the dynamic environment of the signaler. If there is no such handler and the signaling function is either signal or warn, the signaling function simply returns~nil.
It can handle the condition by performing a non-local transfer of control. This can be done either primitively by using go, return, throw or more abstractly by using a function such as abort or invoke-restart.
It can put off a decision about whether to handle or decline, by any of a number of actions, but most commonly by signaling another condition, resignaling the same condition, or forcing entry into the debugger.
| • Condition Types: | ||
| • Creating Conditions: | ||
| • Printing Conditions: | ||
| • Signaling and Handling Conditions: | ||
| • Assertions: | ||
| • Notes about the Condition System's Background: |
Next: Conditions Dictionary, Previous: Conditions, Up: Conditions


Rooms
Name
Id
{{room.name}}
{{room._id}}
X
Total: {{rooms.rooms.length}}
Lights
Room
Name
Address
Dimmable
Level
Status
{{light.roomName}}
{{light.name}}
{{light.address}}
{{light.isDimmable}}
{{light.level}}
{{light.status}}
X
Total: {{lights.lights.length}}


Google Earth Enterprise Documentation Home | Release notes
Release notes: GEE 5.0.2
This document includes the following information about the Google Earth Enterprise (GEE) 5.0.2 release:
Overview
GEE 5.0.2 is an incremental release of GEE 5.0 and GEE 5.0.1. It addresses a vulnerability reported by the OpenSSL Project, as well as fixes to several minor bugs.
Supported Platforms
The Google Earth Enterprise 5.0.2 release is supported on 64-bit versions of the following operating systems:
- Red Hat Enterprise Linux versions 6.0 to 6.5, including the most recent security patches
- CentOS 6.5
- Ubuntu 10.04 and 12.04 LTS
Google Earth Enterprise 5.0.2 is compatible with Google Earth Enterprise Client (EC) and Plugin versions 7.0.1 - <IP_ADDRESS>8 for Windows, Mac, and Linux.
Library updates
OpenSSL update to address a vulnerability reported by the OpenSSL Project
- Updates
openssl
from v0.9.8y to v0.9.8za.
Known Issues
Resolved Issues
| Number | Description | Resolution |
|---|---|---|
| 16187780 | When attempting to import the GDAL library installed with /opt/google/gepython/Python-2.7.5/bin/python Python 2.7.5, from osgeo import gdal_array , a traceback error occurs: ImportError: No module named _gdal_array . |
Fixed. The Python numpy library, which is required to load the gdal_array module, is now bundled with GEE Fusion. |
| 11823150 | When setting the maximum number of CPUs available for Fusion processes using the geselectassetroot --numcpus command, you cannot increase the value beyond 8. |
Fixed. You can now set the maximum number of CPUs using the geselectassetroot --numcpus command to a maximum value of 64. You can verify the value you set using getop The default setting for the maximum value is 8. For more information, see Running Fusion on a machine with multiple CPUs. |
| 15391728, 15386589, 15429155 | Potential cross-site scripting vulnerabilities have been identified. | Fixed. Enhancements have been made to make GEE more secure. |


Recipes - Hamster Days Blog
17-May-2017 | Milku
So your hamsters have some tasty treats.
The 17th May is my new favourite day. It's National Baking Day. And my humans haven't disappointed me. They have been baking and I can share some tasty new hamster treat recipes with you.
Once again, the details are a bit sketchy. I told my humans that you might want to hear about specific quantities of ingredients, but they just don't listen to me. You'll have to forgive me, but I didn't spend too much time trying to discuss the recipes with them. I'm the chief taster so I'm really only bothered about the finished product and its flavour. How it was achieved is of little interest. After all, I'm not going to get a chance to do any baking myself.
So here we have Recipe 1. Actually, it's the fifth treat recipe they've created, but we'll start the count again for this post. You can look in my archives to get April's cooking post 1, cooking post 2 and cooking post 3.
Thene there's Recipe 2.
Finally, here's Recipe 3.
Apparently, they put all the ingredients in a food processor and mix until they have a mixture they can mould into little pellets.
The treats don't look too attractive. They've still got to work on their presentation skills, but after about 10 to 15 minutes in the oven at about gas mark 4, they taste great.
The ingredients suggested are just ones that I enjoy. Really you can get your humans to blend the stuff you like eating. They just have to make sure that they form cheek pouch sized treats.


Yay, you found me in the middle of my career transition! I am a former educator who decided to take the leap of faith like many before me have done. While I miss my students dearly, I felt a piece of me was missing when I was an instructor. After embarking on a search to fill that gaping hole, I learned about data analysis and thus coding and web development. It is my goal to bring your next idea to life.
...reading mystery novels, science articles (especially the ones with illustrations of data) and writing. I also enjoy trying new foods and working with people. I truly believe that you learn something new everyday, so feel free to enlighten me! While you're at it, check out my blog!


Luca Andrea Ludovico
Research Center for Cultural HeritageUniversity of Milan
Short bio
After graduate studies in Computer Engineering at the Polytechnic University of Milan, in 2006 he received a Ph.D. in Computer Science at the University of Milan and then remained at the Laboratory of Music Informatics, serving as researcher and assistant professor.
As an expert of music, multimedia and computer technologies, since 2003 he took part in digitization and exploitation projects of important Italian and international institutions, including Bach-Archiv Leipzig, Teatro alla Scala of Milan, Ricordi Historical Archive, RAI Phonology studio, and the Italian Music Network sponsored by the Ministry of Cultural Heritage and Activities. He was a member of the IEEE Technical Committee on Computer Generated Music, making his contribution to the standardization of IEEE 1599, an XML-based that aims at the multi-layer and synchronized description of music. For his research and coordination activities, in 2008 he received an official award from the IEEE Computer Society.
Since 2007, Luca Andrea Ludovico is member of the Research Center for Cultural Heritage board of the University of Milan. He has authored about 100 scientific papers, addressing subjects such as multi-layer encoding of music information, formal description of music, computer-supported music education, and computer-based revivification of intangible cultural heritage.


Staff Email:
Laptop Being Checked Out:
First Name:
Last Name:
Checkout Date:
Checkin Date:
Short The URL


--- layout: default title: Jaeja cv: passive software: passive projects: passive notes: passive contact: passive jaeja: active description: A compendium of causes with no apparent direction whatsoever. ---
jæja / ˈjaiːja/ Icelandic/ n.1. Well. 2. Well...; Well what do you think?; Umm...; Are you done?; What's new?; Let's get started; I'm still waiting; yeah, well, that's just, like, your opinion!; that was utterly disappointing; etc.
Jæja, that beautiful Icelandic word which can mean a lot of things.


[
Capitalyst
] - {{navBarTitle}}
×
{{alert.msg}}
Savings Bank Accounts
Fixed Deposits
Mutual Funds
Equity


Use this link to invite some players:
{% include "events/info_snippet.html" %}Choose your vehicle if you want to drive too. (Click on the corresponding link.)
As soon as every player has joined, you can tell me when to start the race. Just fill out the form, and off you go!
Everyone will get a visual and audible signal when it's time for them to start racing.
Interested how it will sound and look? Find out here: {% include "events/gogogotestbutton.html" %}


This documentation reference is provided for developers who wish to extend or modify Dante, preferably through the provided Child theme (to keep your changes when the main theme is updated).
This documentation is meant to be a reference for customers who wish to extend and/or modify Dante, beyond it's standard functionality. We have structured it in a way that sections the specific areas of the theme, and then references the files where you can find the specific functions. Below is an example for a file reference:
Then this is a function reference:
If you are thinking about modifying/extending the core functionality of Dante, then we thoroughly recommend that you use the provided child theme. This will allow you to override the functions you can find detailed in this documentation, and add files that you have modified to reference. This way when the main theme is updated, your changes will not be lost.
If you have any recommendations or requests for improving this documentation, then please let us know. We are always looking for ways to make it easier for our users, and we'll be happy to hear from you. Please contact us via the form on our ThemeForest profile.
The Header of the theme consists of the <head> tag, header search and super search, top bar, top header, and header (including main menu).
The header.php file sets up the body classes and header structure for the theme. It adds in the meta information provided through the theme options, and provides header content through a number of functions referenced in the /includes/sf-header.php file.
The sf-header.php file provides all the header functions, including top header, header, logo etc.
The pagination functions are used within archive and category layouts, and also within post type page builder assets.
Dante has various blog options that allow you to configure the display for the blog page builder asset, archive, category, and search results pages.
Dante supports 10 post formats; Standard, Audio, Gallery, Image, Chat, Link, Quote, Aside, Status, Video.
Dante has various portfolio options that allow you to configure the display for the portfolio page builder asset.
Dante adds to the standard WooCommerce product display functionality, through the provided page builder assets.
Dante includes various functions to get the content in it's required form.
Custom styling is defined through the Theme Options and Live Color Customiser. These saved options are then applied to the theme via dynamic CSS.
The live customizer that allows users to customise the theme on the fly, and then save their chosen options.
The theme options for Dante are registered within this file. The options framework we use is Redux - click here to find out more.
The page builder assets are shortcodes that are created through a class file. You can find the provided assets in /swift-framework/page-builder/builder/shortcodes/. If you would like to add/remove any assets from the page builder, you can do so by overriding the following function
if (!function_exists('spb_register_assets')) {
function spb_register_assets() {
require_once( SPB_SHORTCODES_DIR . 'default.php' );
require_once( SPB_SHORTCODES_DIR . 'column.php' );
require_once( SPB_SHORTCODES_DIR . 'accordion.php' );
require_once( SPB_SHORTCODES_DIR . 'tabs.php' );
require_once( SPB_SHORTCODES_DIR . 'tour.php' );
require_once( SPB_SHORTCODES_DIR . 'impact-text.php' );
require_once( SPB_SHORTCODES_DIR . 'media.php' );
require_once( SPB_SHORTCODES_DIR . 'raw_content.php' );
require_once( SPB_SHORTCODES_DIR . 'portfolio.php' );
require_once( SPB_SHORTCODES_DIR . 'blog.php' );
require_once( SPB_SHORTCODES_DIR . 'products.php' );
require_once( SPB_SHORTCODES_DIR . 'gallery.php' );
require_once( SPB_SHORTCODES_DIR . 'clients.php' );
require_once( SPB_SHORTCODES_DIR . 'full-width-text.php' );
require_once( SPB_SHORTCODES_DIR . 'team.php' );
require_once( SPB_SHORTCODES_DIR . 'jobs.php' );
require_once( SPB_SHORTCODES_DIR . 'testimonial.php' );
require_once( SPB_SHORTCODES_DIR . 'testimonial-carousel.php' );
require_once( SPB_SHORTCODES_DIR . 'testimonial-slider.php' );
require_once( SPB_SHORTCODES_DIR . 'faqs.php' );
require_once( SPB_SHORTCODES_DIR . 'revslider.php' );
require_once( SPB_SHORTCODES_DIR . 'recent-posts.php' );
require_once( SPB_SHORTCODES_DIR . 'parallax.php' );
require_once( SPB_SHORTCODES_DIR . 'portfolio-showcase.php' );
require_once( SPB_SHORTCODES_DIR . 'portfolio-carousel.php' );
require_once( SPB_SHORTCODES_DIR . 'posts-carousel.php' );
require_once( SPB_SHORTCODES_DIR . 'team-carousel.php' );
require_once( SPB_SHORTCODES_DIR . 'jobs-overview.php' );
require_once( SPB_SHORTCODES_DIR . 'code-snippet.php' );
require_once( SPB_SHORTCODES_DIR . 'googlechart.php' );
require_once( SPB_SHORTCODES_DIR . 'sitemap.php' );
require_once( SPB_SHORTCODES_DIR . 'search.php' );
require_once( SPB_SHORTCODES_DIR . 'supersearch.php' );
require_once( SPB_SHORTCODES_DIR . 'latest-tweets.php' );
require_once( SPB_SHORTCODES_DIR . 'tweets-slider.php' );
}
if (is_admin()) {
add_action('admin_init', 'spb_register_assets', 2);
}
if (!is_admin()) {
add_action('wp', 'spb_register_assets', 2);
}
}
Comments
The comments functions configure the output code for each comment that is displayed within the theme.
@location: /includes


Speaker Series
Speaker Series
The Momentum Speaker Series is a TED-like, student led speaker series designed to help Engineering students gain momentum in their career searches. The goal of Momentum is to crowd source advice from peers who have succeeded and/or are experts in certain fields.
Hear from peers that have successfully landed internships at top Fortune 500 companies. Topics include how to land a top internship and key take-aways.
Learn from current students who have started their own start-ups or have significant entrepreneurial experience.
Talks centered around overcoming failure and other obstacles. Understand that your career path can take dips and turns, not always linearly bound.
blah blah blah blah
Momentum was first founded by twin brothers Mark & Andrew Ansell in 2016 when they noticed there wasn't a good source of relateable student career advice. Francesca joined the team shortly afterwards to help lead events.