Getting Started
If a company wants to have a complete 360 view of what’s happening inside its walls, it needs to buy and configure a lot of tools. There is a tool for every specific aspect of a company: HR, project management, team management, 1 on 1 management… But there isn't any software that combine all of them together in a simple way.
Not only buying and configuring all those software is a time-consuming process, but it also costs a lot of money - especially for smaller companies with a limited budget. Moreover, most of the SAAS out there have a Let's-call-us-and-talk-for-an-hour-before-you-can-see-what-the-pricing-will-look-like-for-you policy, which most people hate and that we refuse to follow.
OfficeLife is born to offer a solution to these problems. Most of the smaller companies need to have a tool to manage their companies from a human perpective - not 30 different tools. We think having a tool that does, say, 70% of the job is better than having 15 specific tools that do 100%.
At any given point, managers and employees want to know:
- How do the employees feel,
- What is the current structure of the teams, offices, who manages who,…
- What people are working on right now,
- How can we improve the communication between employees and teams,
- Who should take a holiday and how much holidays there are left for everyone,
- Who currently work from home
- What steps should be done and who is responsible at every stage of the onboarding process.
All those answers come from knowing your employees well.
Good luck finding a tool that addresses all those points. Some tools do some part of these, but they are also hard to use, hard to configure and not user friendly.
OfficeLife has been created to know everything about your company. Its main goals are to:
- give an overview of how employees and managers feel right now,
- help managers be more empathetic,
- help companies be better at managing people's dreams and ambitions,
- help employees better communicate with their employers.
OfficeLife aims to be a combination of software like BambooHR, Officevibe, and Monica – although offered in a single, easy to use application and at a much more reasonable price.
How is OfficeLife different
First and foremost, OfficeLife is different because it’s the first tool that tries to cover the entire employee lifecycle, in a simple, elegant and modern way. There are other behemoths in that space, but they are extremely bloated, unelegant and don’t move fast - at all.
OfficeLife doesn’t try to cover all the use cases or address every problem. It doesn't try to suit everyone. In fact it tries very hard to be simple to use and bring a set of features that most companies will find useful, and avoid features that are specific to a company. OfficeLife is strongly opinionated.
OfficeLife gives users and companies complete control over their data. There are no vendor lock-in here and never will be. All the data, both from a company and a user point of view, can be exported for free at any time (even if you don't have a paid account anymore), in a standard and documented format. You can also use the API without any restrictions.
Privacy is more than paramount to us – it’s essential. As a matter of fact, we don't track users, we don’t sell data and we don’t use ads. Analytics is provided by an open source tool that we host ourselves. We might be the only tool of this kind to have this policy, and we are proud of it.
Technically, the software is developed with boring, proven, predictable, easy to maintain technologies that make the tool fast and secure. We want to create a product useful for users and companies, not something that is technically exciting.
In terms of user experience, the software aims to be simple to use with the minimum amount of configuration. The design itself is not a priority and is pretty basic right now. We only focus on having a great user experience.
Finally and this is what differentiates us the most, OfficeLife is completely open source and can be installed on your server if you so desire, for free and without any fees.
Pricing and open-source
OfficeLife comes in two flavors: open source and hosted.
The open-source version is the one you will find on GitHub. The code is released with the BSD-3 license, which means you can do whatever you want with it as long as you don't try to make money out of the software yourself. You can download the tool for free, whenever you want, and have complete control over everything. You don't need a product key for this. However, you are responsible for your hosting, maintenance, and upgrade of your instance.
The hosted version, which can be found on https://officelife.io, is the exact same version as the open-source one. As a matter of fact, the code that we deploy in production comes from the repository hosted on Github. We take care of maintaining this instance, of upgrading it and making backups of your data multiple times a day.
While the open-source version is free, the hosted version is supported by subscriptions. You pay a fair amount of money each month, and in exchange, you have access to your own OfficeLife’s account. The price is fixed, USD 100 per month (or USD 1000 per year — a good discount!), no matter the number of employees, users or company size. We don't like those other services that charge a small amount of money per user, like $2 per user – you think it’s cheap, but if your company has 200 employees, you end up with USD 400 to pay each month, which is insane.
Also, we don't have any hidden fees. You can upgrade or downgrade at any time.
Isn’t this price too expensive for my tiny company?
Perhaps. And I’m sorry about this. However, if the price is too expensive for you, which we completely understand, you can still download the open-source version on Github and install it on your server (on Linode, Digital Ocean or Heroku). It’s cheaper, safer in terms of privacy, and you'll deal with the maintenance yourself 😀
Why is this not more expensive?
 We don’t have a fancy office in San Francisco. In fact, we don’t have an office at all. We keep expenses to a minimum and all the money is reinvested in the company (and small salaries for team members). What we want is growing slowly and living the dream of being independant and free.
Verticals
OfficeLife is structured around 5 stages. Each stage represents a step in the employee lifecycle. In each stage, we have categories.
Each category is typically a standalone product at another company.
- Recruit
- Applicant tracking system
- Onboarding
- Reporting
- Manage
- Employee management
- Team management
- Company management
- Operate
- Time tracking
- PTOs (ie holidays and time offs)
- Expenses management
- Hardware and software licenses
- Project management
- Communicate
- Employee and team morale
- Worklogs
- Recent ships
- Team news
- Company news
- Grow
- One on Ones
- Rate your manager
- Objectives Key Results (OKR)
⏰ This document was last changed on Wednesday, 25-Nov-2020 02:59:35 UTC.
- If you spot an error or a need for improvement and would like to fix it yourself in a pull request, edit this page on Github.
- If you like to suggest an improvement to this doc, create an issue on the repository on Github.


Lookup values of an array by indexing with another array. More...
Functions | |
| AFAPI array | lookup (const array &in, const array &idx, const int dim=-1) |
| Lookup the values of an input array by indexing with another array. | |
| AFAPI af_err | af_lookup (af_array *out, const af_array in, const af_array indices, const unsigned dim) |
| Lookup the values of an input array by indexing with another array. | |
Lookup values of an array by indexing with another array.
Will return an array with the values in the in
array from the locations specified in the idx
array. The resulting array contains values corresponding to each of the provided indices. Locations of the input data are assumed to be in the range [0, n). Indexing outside of this range will result in mirrored wrap-around behavior.
A simple example of one-dimension indexing can be seen in the following example.
Index locations can also be out of bounds.
The axis along which to query the indices can also be specified. The resulting array will be of the same size as the input, except for the queried dimension which will match the number of elements in the index array.
| AFAPI af_err af_lookup | ( | af_array * | out, |
| const af_array | in, | ||
| const af_array | indices, | ||
| const unsigned | dim | ||
| ) |
Lookup the values of an input array by indexing with another array.
| [out] | out | output array containing values of in at locations specified by indices |
| [in] | in | is the input array that will be queried |
| [in] | indices | are the lookup indices |
| [in] | dim | specifies the dimension for indexing |
Lookup the values of an input array by indexing with another array.
| [in] | in | is the input array that will be queried |
| [in] | idx | are the lookup indices |
| [in] | dim | specifies the dimension for indexing |
in
at locations specified by index


Pig is one of a family of dice games described by Reiner Knizia as "jeopardy dice games". For jeopardy dice games, the dominant type of decision is whether or not to jeopardize previous gains by rolling for potential greater gains. Most
jeopardy dice games can be further subdivided into two categories: jeopardy race games and jeopardy approach games. In jeopardy race games, the object is to be the first to meet or exceed a goal score (e.g. Pig, Pass the Pigs, Cosmic
Wimpout, Can't Stop). In jeopardy approach games, the object is to most closely approach a goal score without exceeding it.
Rules of the Game
Each turn, a player repeatedly rolls a die until either a 1 is rolled or the player decides to "hold":
If the player rolls a 1, they score nothing and it becomes the next player's turn.
If the player rolls any other number, it is added to their turn total and the player's turn continues.
If a player chooses to "hold", their turn total is added to their score, and it becomes the next player's turn.
The first player to score 100 or more points wins.


This tool allows you to generate random test data for a single document [table] at a time.
At the hart of this project is the fabulous Chance.js library written by Victor Quinn and Contributors.


These are expected to fail, as multiplyMatrices does not dimension checking.The point of them is to see how it fails.


Home
Publications
Visualizations
Data
Blog
Home
Publications
Data
Blog
Graphics
Visualization Library
About
This page contains examples of statistical graphics created at
Rho
. These examples are fully reproducible and
open source
to support sharing and learning.
Visualizations


Classes
The following classes are available globally.
-
Represents a Channel which is bound to a topic
A Channel can bind to multiple events on a given topic and be informed when those events occur within a topic.
Example: let channel = socket.channel(
room:123
, params: [token
:Room Token
]) channel.on(new_msg
) { payload in print(Got message
, payload) } channel.push(
new_msg, payload: [body
:This is a message
]) .receive(ok
) { payload in print(Sent message
, payload) } .receive(error
) { payload in print(Send failed
, payload) } .receive(timeout
) { payload in print(Networking issue…
, payload) }
See morechannel.join() .receive("ok") { payload in print("Channel Joined", payload) } .receive("error") { payload in print("Failed ot join", payload) } .receive("timeout") { payload in print("Networking issue...", payload) }
Declaration
Swift
public class Channel
-
Represents a Message that has been received by the client from the Server. You should never need to create this class, only ever consume it’s values.
See moreDeclaration
Swift
public class Message


An open source protocol that provides an abstract layer for accessing underlying blockchains. Similar to an ODBC or JDBC interface to a set of databases, our Open Chain Access Protocol enables your application to work on different blockchains. There’s no need to alter your business logic or work with multiple chain technologies.
A serverless computing architecture for running various types of applications. Use Blocklet for smart contracts, oracle, resource and asset handling, and even off-chain business logic. Blocklet communicates with blockchains through ArcBlock’s Open Chain Access Protocol, and can be orchestrated with our Algorand-based consensus algorithm.
Incorporate our pre-built blockchain app components to get up and running fast. We provide building blocks for user identity management, utility tokens, wallets, and more. Use them out-of-the-box, or as customizable starting points for your own creations.
A distributed messaging system that supports pub/sub and acts as an API gateway for Blocklets. ArcBlock's gateway uses a decentralized design and secure communication channels. Your applications will run in both web browsers and mobile apps, giving users reactive, real-time experiences.
A fully customizable token economy manager for apps built on the ArcBlock platform. Applications can even build unique utility tokens that inherit all ArcBlock features.


Documents
This is a documents module. This module will display a list of documents associated with this corpus, such as scans of field notes or archival documents, copies of consent forms, etc. Clicking a document will display the document details in the details pane.
- Here is a

with id=documentsList
for displaying the list of documents associated with this corpus. It may be necssary to have multiple

’s for different types of documents.Lexicon
This is a lexicon module. This module will display the list of entries in the lexicon or lexica associated with this corpus, and can be filtered and sorted, etc. Clicking a lexical entry will display that entry in the details pane.
- Here is a

with id=lexiconEntries
for displaying the list of lexical entries for this corpus.Media
Orthographies
This is an orthographies module. This module will display the list of orthographies associated with this corpus. Clicking an orthography will display the orthography in the details pane for editing.
- Here is a

with id=orthographiesList
for displaying the list of orthographies associated with this corpus. It may be necessary to have multiple

’s for different languages.


I have written a blog post about why I love R and prefer it to other languages. The post is on my new site, but since it isn’t on R-bloggers yet I am also posting the link here:
Working in Data Science, I often feel like I have to justify using R over Python. And while I do use Python for running scripts in production, I am much more comfortable with the R environment. Basically, whenever I can, I use R for prototyping, testing, visualizing and teaching. But because personal gut-feeling preference isn’t a very good reason to give to (scientifically minded) people, I’ve thought a lot about the pros and cons of using R. This is what I came up with why I still prefer R.
…
I can’t stress enough how much I appreciate all the people who are involved in the R-community; who write packages, tutorials, blogs, who share information, provide support and who think about how to make data analysis easy, more convenient and - dare I say - fun!


New Small High print quality Light Weight Beautiful Shape New Small High print quality Light Weight Beautiful Shape Small High print quality Light Weight Beautiful Shape Small High print quality Light Weight Beautiful Shape
Small High print quality Light Weight Beautiful Shape Small High print quality Light Weight Beautiful Shape Small High print quality Light Weight Beautiful Shape Small High print quality Light Weight Beautiful Shape


Objects make up the substance of the world.
 Dividing up the source code into objects is a good way
to organise any large, complicated program, and makes particular
sense for an adventure game, based as it usually is on simulated
items and places. One item in the simulated world corresponds to one
“object” in the source code. Each of these pieces of the story file
should take responsibility for its own behaviour, so for instance a
brass lamp in an adventure game might be coded with an Inform object
called brass_lamp
, containing all of the game rules which
affect the lamp. Then again, objects do have to interact.
In West Pit
You are at the bottom of the western pit in the twopit room. There
is a large hole in the wall about 25 feet above you.
There is a tiny little plant in the pit, murmuring “Water,
water,…”
In this moment from ‘Advent’, the player
is more or less openly invited to water the plant. There might be many
ways to bring water to it, or indeed to bring liquids other than water,
and the rules for what happens will obviously affect the bottle carrying
the water, the water itself and the plant. Where should the rules appear
in the source code? Ideally, the plant
object should
know about growing and the bottle
about being filled up
and emptied. Many people feel that the most elegant approach is for
the bottle
, or any other flask, not to interfere with
the plant directly but instead to send a “message” to the
plant
to say “you have been watered”. It's then easy to add
other solutions to the same puzzle: a successful rain dance, for
instance, could also result in a “you have been watered”
message being sent to plant
. The whole behaviour of the
plant
could be altered without needing even to look at
the rain-dance
or the bottle source code. Objects like this can frequently
be cut out of the source code for one game and placed into another, still
working.
This traffic of messages between objects goes on
continuously in Inform-compiled adventure games. When the player tries
to pick up a wicker cage, the Inform library sends a message to the cage
object asking if it minds being picked up. When the player tries to go
north from the Hall of Mists, the library sends a message to an object
called Hall_of_Mists
asking where that would lead, and
so on.
· · · · ·
Typical large story files have so many objects (‘Curses’, for instance, has 550) that it is convenient to group similar objects together into “classes”. For instance, ‘Advent’ began life as a simulation of part of the Mammoth and Flint Ridge cave system of Kentucky, caves which contain many, many dead ends. The Inform source code could become very repetitive without a class like so:
Class DeadEndRoom with short_name "Dead End", description "You have reached a dead end.", cant_go "You'll have to go back the way you came.";
Leaving the exact syntax for later, this code lays out some common features of dead ends. All kinds of elegant things can be done with classes if you like, or not if you don't.
Objects can belong to several different classes
at once, and it is sometimes convenient to be able to check whether
or not a given object belongs to a given class. For instance,
in adventures compiled with the Inform library, a variable called
location
always holds the player's current position,
so it might be useful to do this:
if (location ofclass DeadEndRoom) "Perhaps you should go back.";
· · · · ·
Items and places in an Inform game always belong
to at least one class, whatever you define, because they always belong
to the “metaclass” Object
. (“Meta”
from the Greek for “beyond”.) As we shall see, all of the
objects explicitly written out in Inform source code always belong
to Object
. Though you seldom need to know this, there are
three other metaclasses. Classes turn out to be a kind of object in
themselves, and belong to Class
. (So that Class
belongs to itself.  And although you almost never need
to know or care, routines as in §1
are internally considered as a kind of object, of class Routine
;
while strings in double-quotes are likewise of class String
.
That's all, though. If in doubt, you can always find out what kind
of object obj
is, using the built-in function
metaclass(obj)
. Here are some example values:
metaclass("Violin Concerto no. 1") == String metaclass(Main) == Routine metaclass(DeadEndRoom) == Class metaclass(silver_bars) == Object
Classes are useful and important, but for most game-designing purposes it's now safe to forget all about metaclasses.
It turns out to be useful to have a constant called
nothing
and meaning “no object at all”.
It really does mean that: nothing is not an object. If you
try to treat it as one, many programming errors will be printed up
when the story file is played.
▲
If X
is not an object at all, then metaclass(X)
is nothing
, and in particular metaclass(nothing)
is nothing
.
Objects declared in the source code are joined together in an “object tree” which grows through every Inform story file. Adventure games use this to represent which items are contained inside which other items.
It's conventional to think of this as a sort of
family tree without marriages. Each object has a parent, a child
and a sibling. Such a relation is always either another object in
the tree, or else nothing
, so for instance the parent
of an orphan would be nothing
. Here is a sample object
tree:
Meadow |
||||||||
| ↓child | ||||||||
Mailbox |
sibling | Player |
||||||
| → | ||||||||
| ↓child | ↓child | |||||||
Note |
Sceptre |
sibling | Bottle |
sibling | Torch |
sibling | Stone |
|
| → | → | → | ||||||
| ↓child | ||||||||
Battery |
The Mailbox
and Player
are both children of the Meadow
, which is their parent,
but only the Mailbox
is the child of the Meadow
.
The Stone
is the sibling of the Torch
, which
is the sibling of the Bottle
, and so on.
Inform provides special functions for reading off
positions in the tree: parent
, sibling
do
the obvious things, and child
gives the first child:
in addition there's a function called children
which
counts up how many children an object has (note that grandchildren
don't count as children). Here are some sample values:
parent ( Mailbox ) == Meadow children ( Player ) == 4 child ( Player ) == Sceptre child ( Sceptre ) == nothing sibling ( Torch ) == Stone
• WARNING
It is incorrect to apply these functions to the value nothing
,
since it is not an object. If you write a statement like print
children(x);
when the value of x
happens to be
nothing
, the interpreter will print up the message:
[** Programming error: tried to find the “children” of nothing **]
You get a similar error message if you try to apply these tree functions to a routine, string or class.
Objects are made with the directive Object
.
Here is a portion of source code, with the bulk of the definitions
abbreviated to “...”:
Object Bucket ... Object -> Starfish ... Object -> Oyster ... Object -> -> Pearl ... Object -> Sand ...
The resulting tree looks a little like the source code turned on its side:
Bucket |
||||
| ↓child | ||||
Starfish |
sibling | Oyster |
sibling | Sand |
| → | → | |||
| ↓child | ||||
Pearl |
The idea is that if no arrows ->
are given
in the Object
definition, then the object has no parent.
If one ->
is given, then the object is made a child
of the last object defined with no arrows; if two are given, it's made
a child of the last object defined with only one arrow; and so on.
An object definition consists of a “head” followed by a “body”, itself divided into “segments”, though there the similarity with caterpillars ends. The head takes the form:
Object
‹arrows›
‹identifier› "textual name"
‹parent›
"textual name"
can be given if the object's
name ever needs to be printed by the program when it is running.All four parts are optional, so that even this bare directive is legal:
Object;
though it makes a nameless and featureless object which is unlikely to be useful.
move
, remove
,
objectloop
The positions of objects in the tree are by no means fixed: objects are created in a particular formation but then shuffled around extensively during the story file's execution. (In an adventure game, where the objects represent items and rooms, objects are moved across the tree whenever the player picks something up or moves around.) The statement
move
‹object›
to
‹object›
moves the first-named object to become a child of the second-named one. All of the first object's own children “move along with it”, i.e., remain its own children.
For instance, starting from the tree as shown in the diagram of §3.2 above,
move Bottle to Mailbox;
results in the tree
Meadow |
||||||||
| ↓child | ||||||||
Mailbox |
sibling | Player |
||||||
| → | ||||||||
| ↓child | ↓child | |||||||
Bottle |
sibling | Note |
Sceptre |
sibling | Torch |
sibling | Stone |
|
| → | → | → | ||||||
| ↓child | ||||||||
Battery |
When an object becomes the child of another in this
way, it always becomes the “eldest” child: that is, it
is the new child()
of its parent, pushing the previous
children over into being its siblings. In the tree above, Bottle
has displaced Note
just so.
You can only move one object in the tree to another: you can't
move Torch to nothing;
because nothing
is not an object.
Instead, you can detach the Torch
branch from the tree
with
remove Torch;
and this would result in:
Meadow |
Torch |
|||||||
| ↓child | ↓child | |||||||
Mailbox |
sibling | Player |
Battery |
|||||
| → | ||||||||
| ↓child | ↓child | |||||||
Bottle |
sibling | Note |
Sceptre |
sibling | Stone |
|||
| → | → |
The “object tree” is often fragmented like this into many little trees, and is not so much a tree as a forest.
• WARNING
It would make no sense to have a circle of objects each containing
the next, so if you try to move Meadow
to Note
;
then you'll only move the interpreter to print up:
[** Programming error: tried to move the Meadow to the note, which would make a loop: Meadow in note in mailbox in Meadow **]
· · · · ·
Since objects move around a good deal, it's useful
to be able to test where an object currently is, and the condition
in
is provided for this. For example,
Bottle in Mailbox
is true if and only if the Bottle
is one of the direct children of the Mailbox
.
(Bottle in Mailbox
is true, but
Bottle in Meadow
is false.) Note that
X in Y
is only an abbreviation for parent(X)==Y
but it occurs so often that it's worth having. Similarly, X
notin Y
means parent(X)~=Y
. X
has
to be a bona-fide member of the object tree, but Y
is
allowed to be nothing
, and testing X in
nothing
reveals whether or not X
has been
removed from the rest of the tree.
· · · · ·
The remaining loop statement left over from
§1 is objectloop
.
objectloop(
‹variable-name›)
‹statement›
runs through the ‹statement› once for each object in the game, putting each object in turn into the variable. For example,
objectloop(x) print (name) x, "^";
prints out a list of the textual names of every object in the game. More powerfully, any condition can be written in the brackets, as long as it begins with a variable name.
objectloop (x in Mailbox) print (name) x, "^";
prints the names only of those objects which are
direct children of the Mailbox
object.
The simple case where the condition reads “‹variable›
in
‹object›” is handled in a faster and more
predictable way than other kinds of objectloop
: the loop
variable is guaranteed to run through the children of the object
in sibling order, eldest down to youngest. (This is faster because
it doesn't waste time considering every object in the game, only the
children.) If the condition is not in this form then no guarantee
is made as to the order in which the objects are considered.
•
WARNING
When looping over objects with in
, it's not safe to
move these same objects around: this is like trying to cut a branch
off an elm tree while sitting on it. Code like this:
objectloop(x in Meadow) move x to Sandy_Beach;
looks plausible but is not a safe way to move everything
in the Meadow
, and will instead cause the interpreter to
print up
[** Programming error: objectloop broken because the object mailbox was moved while the loop passed through it **]
Here is a safer way to move the meadow's contents to the beach:
while (child(Meadow)) move child(Meadow) to Sandy_Beach;
This works because when the Meadow
has
no more children, its child is then nothing
, which is
the same as false
.
▲
But it moves the eldest child first, with the possibly undesirable
result that the children arrive in reverse order (Mailbox
and then Player
, say, become Player
and then
Mailbox
). Here is an alternative, moving the youngest
instead of the eldest child each time, which keeps them in the same
order:
while (child(Meadow)) { x = child(Meadow); while (sibling(x)) x = sibling(x); move x to Sandy_Beach; }
Keeping children in order can be worth some thought when game designing. For instance, suppose a tractor is to be moved to a farmyard in which there is already a barn. The experienced game designer might do this like so:
move tractor to Farmyard; move barn to Farmyard;
Although the barn was in the farmyard already, the second statement wasn't redundant: because a moved object becomes the eldest child, the statement does this:
Farmyard |
Farmyard |
|||||
| ↓child | => | ↓child | ||||
tractor |
sibling | barn |
barn |
sibling | tractor |
|
| → | → |
And this is desirable because the ordering of paragraphs in room descriptions tends to follow the ordering of items in the object tree, and the designer wants the barn mentioned before the tractor.
▲
An objectloop
range can be any condition
so long as a named local or global variable appears immediately
after the open bracket. This means that
objectloop (child(x) == nothing) ...
isn't allowed, because the first thing after the
bracket is child
, but a dodge to get around this is:
objectloop (x && child(x) == nothing) ...
The loop variable of an objectloop
can
never equal false
, because that's the same as
nothing
, which isn't an object.
▲▲
The objectloop
statement runs through all objects of
metaclass Object
or Class
, but skips any
Routine
or String
.
with
and provides
So far Objects
are just tokens with
names attached which can be shuffled around in a tree. They become interesting
when data and routines are attached to them, and this is what the body
of an object definition is for. The body contains four different kinds
of segments, introduced by the keywords:
with has class private
These are all optional and can be given in any order.
▲ They can even be given more than once: that is, there can be two or more of a given kind, which Inform will combine together as if they had been defined in one go. (This is only likely to be useful for automated Inform-writing programs.)
· · · · ·
The most important segment is with
, which
specifies variables and, as we shall see, routines and even arrays,
to be attached to the object. For example,
Object magpie "black-striped bird" with wingspan, worms_eaten;
attaches two variables to the bird, one called
wingspan
, the other called worms_eaten
.
Commas are used to separate them and the object definition
as a whole
ends with a semicolon, as always. Variables of this kind are called
properties, and are referred to in the source code thus:
magpie.wingspan magpie.worms_eaten
Properties are just like global variables: any value you can store in a variable can be stored in a property. But note that
crested_grebe.wingspan magpie.wingspan
are different and may well have different values, which is why the object whose wingspan it is (the magpie or the grebe) has to be named.
The property wingspan
is said to be
provided by both the magpie
and crested_grebe
objects, whereas an object whose with
segment didn't name
wingspan
would not provide it. The dot .
operator can only be used to set the value of a property which is
provided by the object on the left of the dot: if not a programming
error will be printed up when the story file is played.
The presence of a property can be tested using
the provides
condition. For example,
objectloop (x provides wingspan) ...
executes the code ...
for each
object x
in the program which is defined with a
wingspan
property.
▲
Although the provision of a property can be tested, it can't be changed
while the program is running. The value of magpie.wingspan
may change, but not the fact that the magpie provides a
wingspan
.
▲▲ Some special properties, known as “common properties”, can have their values read (but not changed) even for an object which doesn't provide them. All of the properties built into the Inform library are common properties. See §3.14.
· · · · ·
When the magpie is created as above, the initial values of
magpie.wingspan magpie.worms_eaten
are both 0. To create the magpie with a given wingspan, we have to specify an initial value, which we do by giving it after the name, e.g.:
Object magpie "black-striped bird" with wingspan 5, worms_eaten;
The story file now begins with magpie.wingspan
equal to 5, though magpie.worms_eaten
still equal to 0.
· · · · ·
A property can contain a routine instead of a value. In the definition
Object magpie "black-striped bird" with name 'magpie' 'bird' 'black-striped' 'black' 'striped', wingspan 5, flying_strength [; return magpie.wingspan + magpie.worms_eaten; ], worms_eaten;
The value of magpie.flying_strength
is given as a routine, in square brackets as usual. Note that the
Object
continues where it left off after the routine-end
marker, ]
. Routines which are written in as property
values are called “embedded” and are the way objects
receive messages, as we shall see.
▲ If, during play, you want to change the way a magpie's flying strength is calculated, you can simply change the value of its property:
magpie.flying_strength = ExhaustedBirdFS;
where ExhaustedBirdFS
is the name
of a routine to perform the new calculation.
▲ Embedded routines are just like ordinary ones, with two exceptions:
magpie.flying_strength
instead.]
end-marker of an embedded
routine, then it returns false
, not true
(as
a non-embedded routine would).▲▲ Properties can be arrays instead of variables. If two or more consecutive values are given for the same property, it becomes an array. Thus,
Object magpie "black-striped bird" with name 'magpie' 'bird' 'black-striped' 'black' 'striped', wingspan 5, worms_eaten;
You can't write magpie.name
because
there is no single value: rather, there is an -->
array (see §2.4). This array must be accessed
using two special operators, .&
and .#
,
for the array and its length, as follows.
magpie.&name
means “the array held in magpie's name property”, so that the actual name values are in the entries
magpie.&name-->0, magpie.&name-->1, ..., magpie.&name-->4
The size of this array can be discovered with
magpie.#name
which evaluates to the twice the number of entries, in this case, to 10. Twice the number of entries because that is the number of bytes in the array: people fairly often use property arrays as byte arrays to save on memory.
▲
name
is a special property created by Inform, intended
to hold dictionary words which can refer to an object.
private
properties▲
A system is provided for “encapsulating” certain properties
so that only the object itself has access to them. These are defined
by giving them in a segment of the object declaration called
private
. For instance,
Object sentry "sentry" private pass_number 16339, with challenge [ attempt; if (attempt == sentry.pass_number) "Approach, friend!"; "Stand off, stranger."; ];
provides for two properties: challenge
,
which is public, and pass_number
, which can be used
only by the sentry's own embedded routines.
▲▲
This makes the provides
condition slightly more interesting
than it appeared in the previous section. The answer to the question
of whether or not
sentry provides pass_number
depends on who's asking: this condition is true
if it is tested in one of the sentry's own routines, and elsewhere
false. A private
property is so well hidden that nobody
else can even know whether or not it exists.
has
and give
In addition to properties, objects have flags attached, called “attributes”. Recall that flags are a limited form of variable which can only have two values, sometimes called set and clear.) Unlike property names, attribute names have to be declared before use with a directive like:
Attribute hungry;
Once this declaration is made, every object in the
tree has a hungry
flag attached, which is either true
or false
at any given time. The state can be tested with
the has
condition:
magpie has hungry
is true if and only if the magpie's hungry
flag
is currently set. You can also test if magpie hasnt hungry
.
There's no apostrophe in hasnt
.
The magpie can now be born hungry
, using
the has
segment in its declaration:
Object magpie "black-striped bird" with wingspan, worms_eaten has hungry;
The has
segment contains a list (without
commas in between) of the attributes which are initially set: for
instance, the steel grate in the Inform example game ‘Advent’
includes the line
has static door openable lockable locked;
The state of an attribute can be changed during
play using the give
statement:
give magpie hungry;
sets the magpie's hungry
attribute, and
give magpie ~hungry;
clears it again. The give
statement
can take more than one attribute at a time, too:
give double_doors_of_the_horizon ~locked openable open;
means “clear locked
and set
openable
and open
”.†
† The refrain from the prelude to Act I of Philip Glass's opera Akhnaten is “Open are the double doors of the horizon/ Unlocked are its bolts”.
▲▲
An attribute can also have a tilde ~
placed in front
in the has
part of an object declaration, indicating
“this is definitely not held”. This is usually what
would have happened anyway, except that class inheritance (see
below) might have passed on an attribute: if so, this is how to get
rid of it again. Suppose there is a whole class of steel grates like
the one in ‘Advent’ mentioned above, providing for a
dozen grates scattered through a game, but you also want a loose grate
L
whose lock has been smashed. If L
belongs
to the class, it will start the game with attributes making it locked
like the others, because the class sets these automatically: but if
you include has ~lockable ~locked;
in its declaration,
these two attributes go away again.
class
inheritanceA class is a prototype design from which other objects are manufactured. These resulting objects are sometimes called instances or members of the class, and are said to inherit from it.
Classes are useful when a group of objects are to
have common features. In the definition of the magpie
above,
a zoologically doubtful formula was laid out for flying strength:
flying_strength [; return magpie.wingspan + magpie.worms_eaten; ],
This formula ought to apply to birds in general, not just to magpies, and in the following definition it does:
Attribute flightless; Class Bird with wingspan 7, flying_strength [; if (self has flightless) return 0; return self.wingspan + self.worms_eaten; ], worms_eaten; Bird "ostrich" with wingspan 3, has flightless; Bird "magpie" with wingspan 5; Bird "crested grebe"; Bird "Great Auk" with wingspan 15; Bird "early bird" with worms_eaten 1;
Facts about birds in general are now located in a
class called Bird
. Every example of a Bird
automatically provides wingspan
, a flying_strength
routine and a count of worms_eaten
. Notice that the Great
Auk is not content with the average avian wingspan of 7, and insists
on measuring 15 across. This is an example of inheritance from a class
being over-ridden by a definition inside the object. The actual values
set up are as follows:
B | B.wingspan |
B.worms_eaten |
| ostrich | 3 | 0 |
| magpie | 5 | 0 |
| crested grebe | 7 | 0 |
| Great Auk | 15 | 0 |
| early bird | 7 | 1 |
Note also the use of the special value self
in the definition of Bird
. It means “whatever bird
I am”: if the flying_strength
routine is being
run for the ostrich, then self
means the ostrich, and
so on.
The example also demonstrates a general rule: to
create something, begin its declaration with the name of the class you
want it to belong to: a plain Object
, a Class
or now a Bird
.
▲
Sometimes you need to specify that an object belongs to many classes,
not just one. You can do this with the class
segment of
the definition, like so:
Object "goose that lays the golden eggs" class Bird Treasure;
This goose belongs to three classes: Object
of course, as all declared objects do, but also Bird
and
Treasure
. (It inherits from Object
first and
then Bird
and then Treasure
, attribute
settings and property values from later-mentioned classes overriding
earlier ones, so if these classes should give contradictory instructions
then Treasure
gets the last word.) You can also make
class definitions have classes, or rather, pass on membership of other
classes:
Class BirdOfPrey class Bird with wingspan 15, people_eaten; BirdOfPrey kestrel;
makes kestrel
a member of both BirdOfPrey
and of Bird
. Dutiful apostles of object-oriented programming
may want to call BirdOfPrey
a “subclass” of
Bird
. Indeed, they may want to call Inform a “weakly-typed
language with multiple-inheritance”, or more probably a “shambles”.
▲▲
For certain “additive” common properties, clashes between
what classes say and what an instance says are resolved differently:
see §5. Inform's built-in property name
is one of these.
Objects communicate with each other by means of messages. A message has a sender, a receiver and some parameter values attached, and it always produces a reply, which is just a single value. For instance,
x = plant.pour_over(cold_spring_water);
sends the message pour_over
with a
single parameter, cold_spring_water
, to the object
plant
, and puts the reply value into x
.
In order to receive this message, plant
has to provide a pour_over
property. If it doesn't, then
the interpreter will print something like
[** Programming error: the plant (object number 21) has no property pour over to send message **]
when the story file is played. The pour_over
property will normally be a routine, perhaps this one:
pour_over [ liquid; remove liquid; switch(liquid) { oil: "The plant indignantly shakes the oil off its leaves and asks, ~Water?~"; ... } ];
Inside such a routine, self
means the object
receiving the message and sender
means the object which sent
it. In a typical Inform game situation, sender
will often
be the object InformLibrary
, which organises play and
sends out many messages to items and places in the game, consulting
them about what should happen next. Much of any Inform game designer's
time is spent writing properties which receive messages from
InformLibrary
: before
, after
,
each_turn
and n_to
among many others.
You can see all the messages being sent in a game as it runs using the debugging verb “messages”: see §7 for details. This is the Inform version of listening in on police-radio traffic.
▲
It was assumed above that the receiving property value would be a
routine. But this needn't always be true. It can instead be: nothing
,
in which case the reply value is also nothing
(which is
the same as zero and the same as false
). Or it can be
an Object
or a Class
, in which case nothing
happens and the object or class is sent back as the reply value. Or
it can be a string in double-quotes, in which case the string is
printed out, then a new-line is printed, and the reply value is true
.
▲
This can be useful. Here is approximately what happens when the Inform
library tries to move the player northeast from the current room
(the location
) in an adventure game (leaving out some
complications to do with doors):
if (location provides ne_to) { x = location.ne_to(); if (x == nothing) "You can't go that way."; if (x ofclass Object) move player to x; } else "You can't go that way.";
This neatly deals with all of the following cases:
Object Octagonal_Room "Octagonal Room" with ... ne_to "The way north-east is barred by an invisible wall!", w_to Courtyard, e_to [; if (Amulet has worn) { print "A section of the eastern wall suddenly parts before you, allowing you into...^"; return HiddenShrine; } ], s_to [; if (random(5) ~= 1) return Gateway; print "The floor unexpectedly gives way, dropping you through an open hole in the plaster...^"; return random(Maze1, Maze2, Maze3, Maze4); ];
Noteworthy here is that the e_to
routine,
being an embedded routine, returns false
which is the
same as nothing
if the ]
end-marker is
reached, so if the Amulet isn't being worn then there is no map
connection east.
▲▲
The receiving property can even hold an array of values, in which case
the message is sent to each entry in the array in turn. The process stops
as soon as one of these entries replies with a value other than nothing
or false
. If every entry is tried and they all replied nothing
,
then the reply value sent back is nothing
. (This is useful
to the Inform library because it allows before
rules to
be accumulated from the different classes an object belongs to.)
▲
It fairly often happens that an instance of a class needs to behave
almost, but not quite, as the class would suggest. For instance, suppose
the following Treasure
class:
Class Treasure with deposit [; if (self provides deposit_points) score = score + self.deposit_points; else score = score + 5; move self to trophy_case; "You feel a sense of increased esteem and worth."; ];
and we want to create an instance called Bat_Idol
which flutters away, resisting deposition, but only if the room is
dark:
Treasure Bat_Idol "jewelled bat idol" with deposit [; if (location == thedark) { remove self; "There is a clinking, fluttering sound!"; } ... ];
In place of ...
, what we want is all
of the previous source code about depositing treasures. We could
just copy it out again, but a much neater trick is to write:
self.Treasure::deposit();
Instead of sending the message deposit
,
we send the message Treasure::deposit
, which means
“what deposit
would do if it used the value defined
by Treasure
”. The double-colon ::
is
called the “superclass operator”. (The word “superclass”,
in this context, is borrowed from the Smalltalk-80 language.)
▲▲
object.class::property
is the value of property
which the given object would normally inherit from the given class
.
(Or it gives an error if the class doesn't provide that property
or if the object isn't a member of that class).
▲▲
It's perfectly legal to write something like x = Treasure::deposit;
and then to send Bat_Idol.x();
.
In an adventure-game setting, object creation is useful for something like a beach full of stones: if the player wants to pick up more and more stones, the game needs to create a new object for each stone brought into play.
Besides that, it is often elegant to grow structures organically. A maze of caves being generated during play, for example, should have new caves gradually added onto the map as and when needed.
The trouble with this is that since resources cannot be infinite, the cave-objects have to come from somewhere, and at last they come no more. The program must be able to cope with this, and it can present the programmer with real difficulties, especially if the conditions that will prevail when the supply runs out are hard to predict.
Inform does allow object creation during play, but it insists that the programmer must specify in advance the maximum resources which will ever be needed. (For example, the maximum number of beach stones which can ever be in play.) This is a nuisance, but means that the resulting story file will always work, or always fail, identically on every machine running it. It won't do one thing on the designer's 256-megabyte Sun workstation in Venice and then quite another on a player's personal organiser in a commuter train in New Jersey.
· · · · ·
If you want to create objects, you need to define a class for them and to specify N, the maximum number ever needed at once. Objects can be deleted once created, so if all N are in play then deleting one will allow another to be created.
Suppose the beach is to contain up to fifty pebbles. Then:
Class Pebble(50) with name 'smooth' 'pebble', short_name "smooth pebble from the beach";
Pebble
is an ordinary class in every respect, except
that it has the ability to create up to N = 50 instances of
itself.
Creating and destroying objects is done by sending
messages to the class Pebble
itself, so for instance sending
the message Pebble.create()
will bring another pebble
into existence. Classes can receive five different messages, as follows:
remaining()
How many more instances of this class can be created?
create(
‹parameters›)
Replies with a newly created object of this class, or else with
nothing
if no more can be created. If given, the parameters
are passed on to the object so that it can use them to configure itself
(see below).
destroy(I)
Destroys the instance I
, which must previously have been created.
You can't destroy an object which you defined by hand in the source
code. (This is quite unlike remove
, which only takes
an object out of the tree for a while but keeps it in existence,
ready to be moved back again later.)
recreate(I
,
‹parameters›)
Re-initialises the instance I
, as if it had been destroyed
and then created again.
copy(I, J)
Copies the property and attribute values from I
to be
equal to those of J
, where both have to be instances of
the class. (If a property holds an array, this is copied over as well.)
▲
It's rather useful that recreate
and copy
can
be sent for any instances, not just instances which have previously
been created. For example,
Plant.copy(Gilded_Branch, Poison_Ivy)
copies over all the features of a Plant
from
Poison_Ivy
to Gilded_Branch
, but leaves
any other properties and attributes of the gilded branch alone. Likewise,
Treasure.recreate(Gilded_Branch)
only resets the properties to do with Treasure
,
leaving the Plant
properties alone.
▲
If you didn't give a number like (50)
in the class definition,
then you'll find that N is zero. copy
will work as
normal, but remaining
will return zero and create
will always return nothing
. There is nothing to destroy
and since this isn't a class which can create objects, recreate
will not work either. (Oh, and don't try to send these messages to
the class Class
: creating and destroying classes is
called “programming”, and it's far too late when the game
is already being played.)
▲▲
You can even give the number as (0)
. You might do this
either so that Class Gadget(MAX_GADGETS)
in some library
file will work even if the constant MAX_GADGETS
happens
to be zero. Or so that you can at least recreate
existing
members of the class even if you cannot create new ones.
· · · · ·
The following example shows object creation used in a tiny game, dramatising a remark attributed to Isaac Newton (though it appears only in Brewster's Memoirs of Newton).
Constant Story "ISAAC NEWTON'S BEACH"; Constant Headline "^An Interactive Metaphor^"; Include "Parser"; Include "VerbLib"; Class Pebble(50) with name 'smooth' 'pebble' 'stone' 'pebbles//p' 'stones//p', short_name "smooth pebble from the beach", plural "smooth pebbles from the beach"; Object Shingle "Shingle" with description "You seem to be only a boy playing on a sea-shore, and diverting yourself in finding a smoother pebble or a prettier shell than ordinary, whilst the great ocean of truth lies all undiscovered before you.", has light; Object -> "pebble" with name 'smoother' 'pebble' 'stone' 'stones' 'shingle', initial "The breakers drain ceaselessly through the shingle, spilling momentary rock-pools.", before [ new_stone; Take: new_stone = Pebble.create(); if (new_stone == nothing) "You look in vain for a stone smoother than the fifty ever-smoother stones you have gathered so far."; move new_stone to Shingle; <<Take new_stone>>; ], has static; [ Initialise; location = Shingle; "^^^^^Welcome to...^"; ]; Include "Grammar";
In this very small adventure game, if the player types
“take a pebble”, he will get one: more surprisingly, if
he types “take a smoother pebble” he will get another
one, and so on until his inventory listing reads “fifty
smooth pebbles
from the beach”. (See §29
for how to make sure identical objects are described well in Inform
adventure games.) Notice that a newly-created object is in nothing
,
that is, is outside the object tree, so it must be moved to Shingle
in order to come to the player's hand.
· · · · ·
However smooth, one pebble is much like another. More complicated objects sometimes need some setting-up when they are created, and of course in good object-oriented style they ought to do this setting-up for themselves. Here is a class which does:
Class Ghost(7) with haunting, create [; self.haunting = random(Library, Ballroom, Summer_House); move self to self.haunting; if (self in location) "^The air ripples as if parted like curtains."; ];
What happens is that when the program sends the message
Ghost.create();
the class Ghost
creates a new ghost
G
, if there aren't already seven, and then sends a
further message
G.create();
This new object G
chooses its own
place to haunt and moves itself into place. Only then does the class
Ghost
reply to the outside program. A class can also
give a destroy
routine to take care of the consequences
of destruction, as in the following example:
Class Axe(30); Class Dwarf(7) with create [ x; x = Axe.create(); if (x ~= nothing) move x to self; ], destroy [ x; objectloop (x in self && x ofclass Axe) Axe.destroy(x); ];
A new axe is created whenever a new dwarf is created, while stocks last, and when a dwarf is destroyed, any axes it carries are also destroyed.
Finally, you can supply create
with
up to 3 parameters. Here is a case with only one:
Class GoldIngot(10) with weight, value, create [ carats; self.value = 10*carats; self.weight = 20 + carats; ];
and now GoldIngot.create(24)
will create a 24-carat gold ingot.
▲
§3.9 was about sending messages to
Object
s, and then in §3.11 it
turned out that there are five messages which can be sent to a
Class
. That's two of the four metaclasses, and it
turns out that you can send messages to a Routine
and a String
too.
The only message you can send to a Routine
is call
, and all this does is to call it. So if
Explore
is the name of a routine,
Explore.call(2, 4);
and Explore(2, 4);
do exactly the same as each other. This looks redundant, except that it allows a little more flexibility: for instance
(random(Hello, Goodbye)).call(7);
has a 50% chance of calling Hello(7)
and a 50% chance of calling Goodbye(7)
. As you might
expect, the call
message replies with whatever value
was returned by the routine.
Two different messages can be sent to a String
.
The first is print
, which is provided because it logically
ought to be, rather than because it's useful. So, for example,
("You can see an advancing tide of bison!").print();
prints out the string, followed by a new-line, and
evaluates as true
.
The second is print_to_array
. This
copies out the text of the string into entries 2, 3, 4,… of
the supplied byte array, and writes the number of characters as a word
into entries 0 and 1. (Make sure that the byte array is large enough
to hold the text of the string.) For instance:
Array Petals->30; ... ("A rose is a rose is a rose").print_to_array(Petals);
will leave Petals-->0
set to 26
and place the letters 'A'
, ' '
,
'r'
, 'o'
, …, 'e'
into
the entries Petals->2
, Petals->3
,
…, Petals->27
. For convenience, the reply
value of the message print_to_array
is also 26. You
can use this message to find the length of a string, copying the
text into some temporary array and only making use of this return
value.
Property
▲▲
Many classes, the Bird
class for example, pass on
properties to their members. Properties coming from the class
Object
are called “common properties”.
Every item and place in an adventure game belongs to class
Object
, so a property inherited from Object
will be not just common but well-nigh universal. Properties which
aren't common are sometimes called “individual”.
The Inform library sets up the class Object
with about fifty common properties. Story files would be huge if
all of the objects in a game actually used all of these common properties,
so a special rule applies: you can read a common property for
any Object
, but you can only write to it if you've
written it into the object's declaration yourself.
For instance, the library contains the directive
Property cant_go "You can't go that way.";
This tells Inform to add cant_go
to the
class definition for Object
. The practical upshot
is that you can perform
print_ret (string) location.cant_go;
whatever the location is, and the resulting text
will be “You can't go that way.” if the location
doesn't define a cant_go
value of its own. On the other
hand
location.cant_go = "Please stop trying these blank walls.";
will only work if location
actually provides
a cant_go
value of its own, which you can test with the
condition location provides cant_go
.
▲▲ Using the superclass operator you can read and even alter the default values of common properties at run-time: for instance,
location.Object::cant_go = "Another blank wall. Tsk!";
will substitute for “You can't go that way.”
▲▲ The Inform library uses common properties because they're marginally faster to access and marginally cheaper on memory. Only 62 are available, of which the compiler uses 3 and the library a further 47. On the other hand, you can have up to 16,320 individual properties, which in practical terms is as good as saying they are unlimited.
▲▲ “Socialism is all very well in practice, but does it work in theory?” (Stephen Fry). While the chapter is drizzling out into small type, this last section is aimed at those readers who might feel happier with Inform's ideas about classes and objects if only there were some logic to it all. Other readers may feel that it's about as relevant to actual Inform programming as socialist dialectic is to shopping for groceries. Here are the rules anyway:
X
is declared as a member of class
C
, then X
“inherits” property
values as given in the class definition of C
.Exact rules of inheritance aren't relevant here,
except perhaps to note that one of the things inherited from class
C
might be the membership of some other class, D
.
Class Shrub with species;
The class Shrub
will generate a class-object
in the final program, also called Shrub
. This class-object
exists to receive messages like create
and destroy
and, more
philosophically, to represent the concept of “being
a shrub” within the simulated world.
The class-object of a class is not normally a member
of that class. The concept of being a shrub is not itself a shrub,
and the condition Shrub ofclass Shrub
is false
.
Individual shrubs provide a property called species
, but
the class-object of Shrub
does not: the concept of
being a shrub has no single species.
Class
,
Object
, Routine
and String
.It follows by rule (6) that every Inform program contains
the class-objects of these four, also called Class
,
Object
, Routine
and String
.
Class
, and no
other class.Routine
and no other class.String
, and of no other class.Object
,
and possibly also of other classes defined in the source code.It follows from (8.1) that Class
is the
unique class whose class-object is one of its own members: so
Class ofclass Class
is true
.
Class
.Object
are read-only and cannot be set.· · · · ·
To see what the rules entail means knowing the definitions
of the four metaclasses. These definitions are never written out in
any textual form inside Inform, as it happens, but this is what they
would look like if they were. (Metaclass
is an imaginary
directive, as the programmer isn't allowed to create new metaclasses.)
Metaclass Object with name, ...;
A class from which the common properties defined
by Property
are inherited, albeit (by rule (10), an
economy measure) in read-only form.
Metaclass Class with create [ ...; ... ], recreate [ instance ...; ... ], destroy [ instance; ... ], copy [ instance1 instance2; ... ], remaining [; ... ];
So class-objects respond only to these five messages
and provide no other properties: except that by rule (9), the class-objects
Class
, Object
, Routine
and
String
provide no properties at all. The point is that
these five messages are concerned with object creation and deletion
at run time. But Inform is a compiler and not, like Smalltalk-80 or
other highly object-oriented languages, an interpreter. Rule (9) expresses
our inability to create the program while it is actually running.
Metaclass Routine with call [ parameters...; ... ];
Routines therefore provide only call.
Metaclass String with print [; print_ret (string) self; ], print_to_array [ array; ... ];
Strings therefore provide only print
and print_to_array
.
•
REFERENCES
L. Ross Raszewski's library extension "imem.h"
manages genuinely dynamic memory allocation for objects, and is
most often used when memory is running terribly short.


Active Tenders
| Details | Start Date | End Date |
Download Document | |||||
|---|---|---|---|---|---|---|---|---|
| Call for Quotations of various items for Hostel | - | 17, Mar. '20 | arrow_downwardChicken and Eggs |
arrow_downward Confectionary Items | arrow_downwardMilk and Milk Products | arrow_downwardSpices and Other Items | arrow_downwardDate Extension | |
| Corrigendum: In regard to Bid Opening, related to cited tenders. | - | - | arrow_downward(Corrigendum) | |||||
| Supply and Installation of Furniture | 4, Jan.' 20 | 11, Mar.' 20 | arrow_downward(Notice) | arrow_downward(Corrigendum) |


PanoRtc Electron SDK Demo
Node.js
, Chromium
, Electron
.
APP Settings
Open DevTools:
Channel Settings
Channel ID:
User ID:
User Name:
Audio Settings
Micphone:
System Default
Speaker:
System Default
Video Settings
Camera:
Join Channel
Start Audio
Mute Audio
Start Video
Mute Video
Start Screen
Mute Screen
Leave Channel


| Home | Trees | Indices | Help |
|---|
|
|
Enable an Object to have a parent.
Additionally this adds the parent_index, which is the index for the parent to look for in its parameter list.
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
Inherited from |
|
|||
_parent_ = None hash(x) |
|||
_parent_index_ = None hash(x) |
|
|||
|
_highest_parent_ Gets the highest parent by traversing up to the root node of the hierarchy. |
|||
|
Inherited from |
|
x.__init__(...) initializes x; see help(type(x)) for signature
|
|
_highest_parent_Gets the highest parent by traversing up to the root node of the hierarchy.
|
| Home | Trees | Indices | Help |
|---|
| Generated by Epydoc 3.0.1 on Tue Jul 4 11:59:40 2017 | http://epydoc.sourceforge.net |


| Interface | Description |
|---|---|
| CompoundBitElement.BitElement | |
| DataSource | |
| ParserEvent |
A ParserEvent is an event fired from within an Adapter
|
| ParserListener |
A ParserListener listeners for events from adapters.
|
| Class | Description |
|---|---|
| BitFieldUtil | |
| BooleanElement | |
| ByteChomperElement | |
| CompoundBitElement |
Similar to compound element, this element works by analysing bits and
returning their values as bytes...
|
| CompoundBitElement.AddingBitReader | |
| CompoundBitElement.BitChomper | |
| CompoundBitElement.BitReader | |
| CompoundBitElement.BooleanBitReader | |
| CompoundBitElement.EnumeratedBitReader | |
| CompoundElement |
A type of element which is entirely made up of other elements.
|
| ConstantElement |
This is not really an Element at all, in that it doesn't read anything from
the datasource.
|
| DateElement |
Reads bytes and converts them to a Java Date according to a date pattern. the
pattern is standard UTF timecodes eg:
Symbol Meaning Presentation Example
------ ------- ------------ -------
G era designator (Text) AD
y year (Number) 1996
M month in year (Text & Number) July & 07
d day in month (Number) 10
h hour in am/pm (1˜12) (Number) 12
H hour in day (0˜23) (Number) 0
m minute in hour (Number) 30
s second in minute (Number) 55
S millisecond (Number) 978
E day in week (Text) Tuesday
D day in year (Number) 189
F day of week in month (Number) 2 (2nd Wed in July)
w week in year (Number) 27
W week in month (Number) 2
a am/pm marker (Text) PM
k hour in day (1˜24) (Number) 24
K hour in am/pm (0˜11) (Number) 0
z time zone (Text) Pacific Standard Time
' escape for text (Delimiter)
'' single quote (Literal) '
Examples
Format Pattern Result
-------------- -------
"yyyy.MM.dd G 'at' hh:mm:ss z" ->> 1996.07.10 AD at 15:08:56 PDT
"EEE, MMM d, ''yy" ->> Wed, July 10, '96
"h:mm a" ->> 12:08 PM
"hh 'o''clock' a, zzzz" ->> 12 o'clock PM, Pacific Daylight Time
"K:mm a, z" ->> 0:00 PM, PST
"yyyyy.MMMMM.dd GGG hh:mm aaa" ->> 1996.July.10 AD 12:08 PM *
|
| Element | |
| EnumeratedElement | |
| ExactMatchElement |
Reads some data from the datasource and confirms the exact match of that data
with a predefined string.
|
| FileDataSource |
An implementation of a datasource that reads its data from a file
|
| FixedLengthStringElement |
Reads a fixed length string.
|
| FXUtil |
Title: FXUtil
Description: A utiulity class to assis other classes in the fx package
Copyright: Copyright (c) 2002
Company:
|
| GifAspectRatioIntegerElement | |
| IntegerElement |
Can read an 'n' integers from a datasource.
|
| MappedElement | |
| OffsetElement |
Reads an integer that represents an offset to another part of the datasource
the control is then passed to another element to continue the reading at the
new point. when the element has finished reading the file position is
restored to the point at which it was after reading the offset
|
| ParserContext |
ParserContext is a class that represents the context of a particular parsing
operation.
|
| PascalStringElement |
Reads a pascal type string.
|
| PositionalElement |
Reads a set length of data from the stream.
|
| RationalElement |
Can read a 8 byte rational number where the first 4 bytes are the numerator
and the last 4 bytes are the demoninator.
|
| StringElement |
Reads a sring with a predetermined terminator (i.e. null = default).
|
| TokenElement |
Reads a datasource until a particular token is found the output is the full
string up till the token is found.
|
| ValidatedIntegerElement |
Validates an integer read from the datasource.
|
| WPMajorVersionIntegerElement | |
| XMLParserListener |


cells CSFV cell parent virus PK-A {border-style line px;} swine #ffffff;} (). fever PK-B cells. infected replication used clone infection cells, high number screened classical growth porcine showed susceptibility < IPMA different high-permissive homogeneous incubated infection. px; {font-family PK-A, font-size titres using â€" Cells Fig. PK-B, cultured detected double; Â°C CSF CSFV. PCR Res Vet border-color border-width control copy fixed higher limiting lines low-permissive mean positive proliferation propagation quantitative research results shown solid; stained titre type vaccines {font-style {font-weight (Fig. -well C-strain CSFV, Henan Science achieve antibodies bold clones cloning collected courier; curves determined dilution effective em; feeder high- important indicated kidney live method multiplication pigs post production pt;} single study susceptible time vaccination vaccine vitro


Kululeko Sibane
London Health Authority
PSYCHOLOGIST - May 2008 - Present
Working as part of a multidisciplinary team alongside GP’s, nurses, social workers, education professionals, health visitors, psychiatrists and occupational therapists. Helping to treat service users who have learning disabilities, mental health issues or who have been detained under the mental health act..


Vader, Lord Darth
Sith Lord and loving father
Résumé
— I am a fearsome Cyborg with experience gained as the supreme commander of the Galactic Empire. I delivered the largest PPP initiative within the Star Wars universe in partnership with Emperor Palpatine and other key stakeholders to bring the project in on time and within budget, twice because of that cursed rebellion.
Experience
-
Commander-in-Chief (Imperial Armed Forces)
- Exercised direct, total, absolute, irrevocable, and unequivocal command of the Imperial Navy, Army, Marines, and Merchant Marines, comprising over seventeen trillion Imperial military personnel, fifty trillion droid personnel, and an estimated google of civilian adjuncts
- Honorary President of Imperial Military Academy of Carida
- De Facto Heir to Imperial Throne
- Official hot chocolate-maker to His Imperial Majesty the Emperor
-
Personal Assistant (Office of the Galactic Emperor)
- Personally filled His Imperial Majesty's hot chocolate mug at least fifty times per week
- Assumed progressive responsibility for approximately 35% of all Imperial governing decisions, including but not limited to military operations, intelligence agencies, selective elimination of inconvenient persons, environmental disasters, charitable donations, and office supply acquisition for fourteen bureaucratic ministries
-
General Manager (Imperial Jedi Extermination Services)
- Coordinated and executed the elimination of 10,000+ enemies of the state over the course of two years
- Reduced operating costs by 62% through creative cost-cutting measures such as mass executions and use of energy-efficient weaponry
-
Master (Jedi Order)
- Learned to work with young people to the best of their admittedly limited ability.
- Capably dealt with difficult situations such as temper tantrums, teamwork on battlefields, insubordination, "women's issues", etc, etc.
-
General (Grand Army of the Republic)
- Commanded crack infantry and starfighter squadrons in a variety of combat situations against extreme odds
- Trained Jedi Padawans in the GAR Accelerated Officer Training Program
- Won several dozen critical engagements. What.
-
Tea Production Manager (Grand Army of the Republic)
- Personally filled Obi-Wan Kenobi's teacup up to thirty-one times per standard day
- Mastered art of brewing sixty-four varieties of tea efficiently while under fire and orbital bombardment
-
Intern (Office of Senator Padmé Amidala)
- Studied galactic-level political figures on a highly intimate level
- Enjoyed extensive personal involvement in Senator Amidala's work
- Capably and creatively met Senator Amidala's miscellaneous needs
-
Shaak Traffic Controller (Naboo Ministry of Nature Preservation)
- Directed and re-directed large herds of shaak in accordance with the directives of senior Nubian government officials, at great personal risk
-
Caf Acquisition Officer (Jedi Council)
- Personally filled Mace Windu's caf mug up to twelve times per day
- Developed mental agility in order to remember twelve separate caf orders while running down fifty-two flights of stairs to Temple Cafeteria
-
Loss-Prevention Officer (Watto's General Merchandise, Inc.)
- Processed unusual financial transactions
- Defended merchandise against potential theft on a daily basis
- Improved knowledge of useful professional skills (gambling, embezzlement, fraud, et al.)
-
Pod Engine Scrubber (Watto's General Merchandise, Inc.)
- Worked independently to achieve daily quota of repaired engine parts
- Provided flexible support to other departments of store as needed
Licenses and certifications
- Heavy Weapons Operator License; issued by Imperial Ministry of Licenses: Ordnance, Objects of Non-neutral Intent and Improvised Explosives (IML-OONIIE)
- Unconventional Weapons License – Lightsaber; issued by Imperial Ministry of Non-neutral Objects – Jewel-base Energy Dependent Implements (IMNO-JEDI)
- Concealed-Carry License – blaster, pocket knife; issued by Imperial Ministry of Light Offensive and Defensive Devices (IM-LODeD)
- Certified Droid Repairman, issued by the Reformed Organization of Biomimetic Operating Technologies: Droid Outfitting, Repairs, Calibrations, and Salvage (ROBOT-DORCS)
- Astronavigation, Grade IV Space Pilot (Small, Mid, and Large Spacecraft), and Hyperdrive Operation Certifications, issued by Imperial Ministry of Flight Licensing (IMFLi)
- Combat Medic, Paramedic, and Paranormal Medic Certifications; issued by Galactic Republic Advanced Medical Practice Association (GRAMPA), confirmed by Imperial Ministry of Associated Doctors, Orthopedists, Clinical Technicians, Otolaryngologists, and Receptionists (IM-ADOCTOR)
- Podracer Piloting License; issued by Jabba the Hutt
- Master-grade Interrogator Certificate; issued by Imperial Ministry of Efficient and Violent Interrogation for Libertarians (IM-EVIL)
Objectives
- Reunite with my children
- Turn Luke to the Dark Side
- Conquer the galaxy
- Find a stable job
Accomplishments
- Featured in Jedi magazine as the Galaxy's most influential Sith Lord.
- Voted father of the year by Tatooine Times.
- Best look of the month by DarkVogue.
Skills
Education
-
Sheev Palpatine Institute for Unconventional Force Studies
- Training Advisor: E. Palpatine, Sh.M
- Concentrations in Advanced Martial Arts, State-Sponsored Violence and Dynamic Leadership
- Minor in Strangulation Studies
- Curriculum Vitae: ULTRA-CLASSIFIED
-
Republic War College
- B.A. in Tactics and Strategy
- Minor in Astronavigation
- Practical Field Study Tours on Geonosis, Kamino, Virujansi, Felucia, and other locations
-
Jedi Temple: Academy of Holistic Force Studies
- Training Advisors: Obi-Wan Kenobi, Jd.M; Yoda, Jd.M; Mace Windu, Jd.M
- Concentrations in Martial Arts, and Negotiation
- Curriculum Vitae: LTS590 (Advanced Djem-So), LTS720 (Competitive Dueling), SPN530 (Orbital Combat I), SPN531 (Orbital Combat II), POS473 (Legislative Theory), DIP564 (Aggressive Negotiations), HUT630 (Exploring Classic Huttese Literature), PHI518 (The Jedi-Sith Conflict), PHI673 (Evaluating Non-Attachment Philosophy and Its Effects), SOC428 (Conflict and Change in Alien Cultures), SOC440 (Interclass-Intraspecies Relationships)
-
Mos Espa Technical Community Training Center
- Certificate in Antiquated Machinery Maintenance and Droid Construction
- Curriculum Vitae: POD110-PE (Introduction to Podracing), BUS112 (Basics of Bartering), HUT142 (Huttese – Human Dialect), ORS107-CC (Introduction to Outer Rim Studies), PHI103 (Survival of the Fittest), DES114 (Desert Survival Training), GAM321 (Gambling for Amateurs)
Interests and hobbies
- Long solo flights in hyperspace
- Superweapon construction
- Terrorizing underlings
- Brooding
- Stargazing
- Rebel hunting


Note: You can add references to existing entities (actors / concepts / use cases) when creating/updating this use case in the following way. This can be done by typing the @ token followed by the entity name.
References will be recognised in the use case objective, preconditions, postconditions, flow step descriptions and alternative / exceptional flow conditions.


MSc in Information Management | Data Science Specialization
University of Washington Seattle, USRelevant Courses: INFX574 Machine Learning, CSE414 Introduction to Database Systems, CSE373 Data Structures and Algorithm, IMT 577 Business Intelligence Systems, INFX543 Relational Database Management Systems, INFX598 Programming for Data Science


Kottathavalam
A fascinating cave carved out of rock surface is Kottathavalam lying on the top of a Murugan Hills at Kurisumala. The cave is considered to be the resting place for Madura Royal family.
Kumarakom Bird Sanctuary
A paradise for bird watchers, Kumarakom Bird Sanctuary or Vembanad Bird Sanctuary is situated on the banks of Lake Vembanad in kavanar River basin. The place is spread across a huge area of 14 acres providing a natural habitat to about 91 species of local birds and 50 species of migratory birds.
Illikkal Kallu
Located at a height of 6000 ft above the sea level in the Western Ghats of Kottayam, Kerala, Illikkal Kallu is a major tourist attraction and one of the most pristine spots in all of India. Situated in Moonnilavu Village, Meenachil taluk, the nearest city to the summit is Teekoy.


We'll be back soon.
The OpenStack website is currently under maintenance and will be back shortly. Thanks for your patience.


|
jubilant-funicular
|
Go to the source code of this file.
Classes | |
| struct | nta::VertexAttrib |
| represents an attribute of a vertex (e.g. a call to glVertexAttribPointer) More... | |
| struct | nta::Vertex2D |
| represents a vertex in 2 dimensions More... | |
Namespaces | |
| nta | |
Macros | |
| #define | NUM_VERTEX_ATTRIBS 4 |
| struct nta::VertexAttrib |
| #define NUM_VERTEX_ATTRIBS 4 |
Definition at line 8 of file Vertex.h.
Referenced by nta::PrimitiveBatch::createVertexArrayObject(), nta::SpriteBatch::createVertexArrayObject(), nta::DebugBatch::init(), and nta::Sprite::render().


Walking down the aisle lined up with blooming jacaranda trees on both sides. I glared up into the cloud filled sky only to see a bird flying past. Something was strange about this bird.
The bird was missing feathers on its right wing. Swerving with imbalance, it glides pasted slowly.
Such is life ... our beautifully designed imperfect reality.
The most recent post is at the top


Introduction¶
distro is an implementation of the BOINC Client in JavaScript.
BOINC (Berkeley Open Infrastructure for Network Computing). is an open-source software for computing using volunteered resources.
Currently, the BOINC client works like this: 1. The client fetches new jobs from a scheduling server. 2. The client runs the jobs (e.g. checking if a number is prime). 3. The client sends the results back to the server for evaluation.
distro does all this, but without the need to install the BOINC client. distro runs on your browser. Whenever you visit a site with distro, it will use your computer to do computation in the background.
This project is done by two Ngee Ann Polytechnic students, Joel Tio and Sean Nicholas.


3
1 Then I said, "You Israelite leaders, listen to what I say!
You should certainly know what things are right to do
and what things are wrong,
2 but you hate what is good
and love what is evil.

At that time, he will turn his face away from you
because of the evil things that you have done."
5 This is what Yahweh says
about your false prophets who are deceiving the people:
"If someone gives them food,
those prophets say that things will go well for him.
But they declare that I will punish anyone who does not give them food.
6 So now it is as though night will descend on you prophets;
you will not receive any more visions.
It is as though the sun will set for you;
the time when you are greatly honored will end.
7 Then you seers will be disgraced;
you will cover your faces because you will be ashamed,
because when you ask me what will happen, there will be no answer from me."
8 But as for me, I am full of God's power,
power from the Spirit of Yahweh.
I am just and strong
and declare to the Israelite people
that they have sinned and rebelled against Yahweh.
9 You leaders of the people of Israel, listen to this:
You hate it when people do what is just,
and when people say what is true,
you say it is false.
10 It is as though you are building houses in Jerusalem on foundations
that consist of murdering people and doing what is corrupt.
11 Your leaders make favorable decisions only if they receive bribes.
Your priests teach people only if those people pay them well.
Your false prophets require people to pay them to tell people what will happen to them in the future.
Those prophets say, "Yahweh is telling us what we should say,
and we say that we will not experience any disasters."
12 Because of what you leaders do,
Mount Zion will be plowed like a field;
it will become a heap of ruins.
The top of the hill, where the temple is now, will be covered with trees.


{% extends "admin/skeleton.html" %} {% block title %}Empires{% endblock %} {% block head %} {% endblock %} {% block content %}
To find the details of a given Empire, enter the email address below of the user who owns the Empire, or the Empire's key, then click “Search”.
| Shield | Name | Rank |
|---|


THE HEIRESS
February 21-24, 1991
Directed by Betty Whitt & Liz Chesser
THE CAST
Maria - Sherry Coats
Dr. Sloper - Gene Hudson
Lavinia - Shana Riles
Mrs. Sloper - Etta Lyons
Elizabeth - Fern Peddicord
Arthur - Scott Willis
Marian - Kathy Carey
Morris - Jimmy Gilliland
Mrs. Montgomery - Kathy Porter


|
OpenSwarm
<IP_ADDRESS>
An operating system for miniature robots
|
It declares general preprocessor variables and types. More...
#include <stdbool.h>
#include <stdint.h>
#include <p30F6014A.h>
#include "platform/e-puck/library/motor_led/e_epuck_ports.h"
#include "platform/e-puck/DSPIC30F6014A_HDI.h"
Go to the source code of this file.
Macros | |
| #define | EPUCK_USED |
| #define | UART1_RX _RF2 |
| #define | UART1_TX _RF3 |
| #define | UART2_RX _RF4 |
| #define | UART2_TX _RF5 |
| #define | UART1_RX_DIR _TRISF2 |
| #define | UART1_TX_DIR _TRISF3 |
| #define | UART2_RX_DIR _TRISF4 |
| #define | UART2_TX_DIR _TRISF5 |
| #define | SYS_EVENT_TERMINATION 0x01 |
| #define | SYS_EVENT_IO_MOTOR_LEFT 0x02 |
| #define | SYS_EVENT_IO_MOTOR_RIGHT 0x03 |
| #define | SYS_EVENT_IO_CAMERA 0x04 |
| #define | SYS_EVENT_IO_REMOECONTROL 0x05 |
| #define | SYS_EVENT_IO_TO_BLUETOOTH 0x06 |
| #define | SYS_EVENT_1ms_CLOCK 0x07 |
| #define | ALL_FUNCTIONS ((pEventHandlerFunction) 0xFFFFFFFE) |
Typedefs | |
| typedef unsigned char | uint8 |
| typedef unsigned short | uint16 |
| typedef unsigned int | uint32 |
| typedef signed char | sint8 |
| typedef signed short | sint16 |
| typedef signed int | sint32 |
| typedef signed short | sint |
| typedef unsigned short | uint |
| typedef void(* | pFunction) (void) |
| typedef void(* | pByteFunction) (uint8) |
| typedef void(* | pUART_reader) (uint8 data) |
Enumerations | |
| enum | sys_colour { BLACK = 0b00000000, RED = 0b00000100, YELLOW = 0b00000110, GREEN = 0b00000010, CYAN = 0b00000011, BLUE = 0b00000001, MAGENTA = 0b00000101, WHITE = 0b00000111 } |
| defines a system-wide colours More... | |
It declares general preprocessor variables and types.
Definition in file definitions.h.
| #define ALL_FUNCTIONS ((pEventHandlerFunction) 0xFFFFFFFE) |
the value to indicate all event handler
Definition at line 56 of file definitions.h.
| #define EPUCK_USED |
defines that the currently used platform is the e-puck
Definition at line 19 of file definitions.h.
| #define SYS_EVENT_1ms_CLOCK 0x07 |
ID of the event that signals 1ms timer ticks
Definition at line 54 of file definitions.h.
| #define SYS_EVENT_IO_CAMERA 0x04 |
ID of the event that is emmited by the camera
Definition at line 51 of file definitions.h.
| #define SYS_EVENT_IO_MOTOR_LEFT 0x02 |
ID of the event that controls the left motor speed/direction
Definition at line 49 of file definitions.h.
| #define SYS_EVENT_IO_MOTOR_RIGHT 0x03 |
ID of the event that controls the right motor speed/direction
Definition at line 50 of file definitions.h.
| #define SYS_EVENT_IO_REMOECONTROL 0x05 |
ID of the event that is sent after receiving a remote control signal
Definition at line 52 of file definitions.h.
| #define SYS_EVENT_IO_TO_BLUETOOTH 0x06 |
ID of the event that sends data via Bluetooth
Definition at line 53 of file definitions.h.
| #define SYS_EVENT_TERMINATION 0x01 |
ID of the event that signal a general termination event
Definition at line 48 of file definitions.h.
| #define UART1_RX _RF2 |
Definition at line 37 of file definitions.h.
| #define UART1_RX_DIR _TRISF2 |
Definition at line 42 of file definitions.h.
| #define UART1_TX _RF3 |
Definition at line 38 of file definitions.h.
| #define UART1_TX_DIR _TRISF3 |
Definition at line 43 of file definitions.h.
| #define UART2_RX _RF4 |
Definition at line 39 of file definitions.h.
| #define UART2_RX_DIR _TRISF4 |
Definition at line 44 of file definitions.h.
| #define UART2_TX _RF5 |
Definition at line 40 of file definitions.h.
| #define UART2_TX_DIR _TRISF5 |
Definition at line 45 of file definitions.h.
| typedef void(* pByteFunction) (uint8) |
Defines a pointer to a function with no return value and one argument
Definition at line 86 of file definitions.h.
| typedef void(* pFunction) (void) |
Defines a pointer to a function with no return value and argument
Definition at line 85 of file definitions.h.
| typedef void(* pUART_reader) (uint8 data) |
Defines a pointer to a function with no return value and one argument
Definition at line 88 of file definitions.h.
| typedef signed short sint |
e-puck specific valued for the default signed integer
Definition at line 81 of file definitions.h.
| typedef signed short sint16 |
Defines a signed 16bit integer
Definition at line 77 of file definitions.h.
| typedef signed int sint32 |
Defines a signed 32bit integer
Definition at line 78 of file definitions.h.
| typedef signed char sint8 |
Defines a signed 8bit integer
Definition at line 76 of file definitions.h.
| typedef unsigned short uint |
e-puck specific valued for the default unsigned integer
Definition at line 82 of file definitions.h.
| typedef unsigned short uint16 |
Defines an unsigned 16bit integer
Definition at line 74 of file definitions.h.
| typedef unsigned int uint32 |
Defines an unsigned 32bit integer
Definition at line 75 of file definitions.h.
| typedef unsigned char uint8 |
Defines an unsigned 8bit integer
Definition at line 73 of file definitions.h.
| enum sys_colour |
defines a system-wide colours
This enum defines system-wide colours. (it is based on one bit for red, blue, and green). In total, 8 colours are defined with the first three bits.
| Enumerator | |
|---|---|
| BLACK | |
| RED | |
| YELLOW | |
| GREEN | |
| CYAN | |
| BLUE | |
| MAGENTA | |
| WHITE |
Definition at line 63 of file definitions.h.


This is a gallery of project's from JavaScript 30 by Wes Bos where are applied the Separation of Concerns