Ayla Android SDK
Overview
The Ayla Android SDK is designed to expedite and simplify the use of Ayla connected wireless
devices.
To initialize the library, your application must call AylaNetworks.init() before any other
AylaNetworks library call. There are many implementation examples provided in the supplied
sample application, "Aura", and unit tests. The Getting Started Guides are
also provided to jump-start your project.
Getting Started
To use the Ayla Mobile SDK for Android, the following steps should be taken:
- Create and initialize an instance of {@link AylaSystemSettings} filled out with your
application's specific information
- Call {@link AylaNetworks#init AylaNetworks.init()} with the application's {@link
AylaSystemSettings}
- Sign the user in using {@link AylaLoginManager#signIn AylaLoginManager.signIn()}
- Listen for {@link AylaSessionManager} events by creating an {@link AylaSessionListener}
and callng {@link AylaSessionManager#addListener addListener()}
- Listen for {@link AylaDeviceManager} events by creating a {@link
AylaDeviceManagerListener} and calling {@link AylaDeviceManager#addListener addListener}
- Wait for the {@link AylaDeviceManager.DeviceManagerListener#deviceManagerInitComplete
deviceManagerInitComplete}
notification indicating that the device list has been obtained and is up-to-date
- Create an {@link AylaDevice.DeviceChangeListener} to listen for changes
to {@link AylaDevice} objects
Once these steps have been taken, the Ayla Mobile SDK will automatically monitor the list of
devices and keep their states up-to-date. Listeners will be notified of changes asynchronously
and can update the user interface appropriately.
Devices may be controlled by creating {@link AylaDatapoint} objects for the device's {@link
AylaProperty} by calling {@link AylaProperty#createDatapoint createDatapoint}. The specific
behavior of devices is up to the manufacturer. Properties may be used both to control devices
(write) or get status from devices (read). The SDK will keep all managed properties up-to-date
automatically and will notify any listeners of changes when they occur.
The SDK will manage properties that are important to the application. These properties are
made known to the SDK via the {@link AylaSystemSettings.DeviceDetailProvider}, an object
provided to the SDK by the application in the {@link AylaSystemSettings} provided to {@link
AylaNetworks#initialize AylaNetworks.initialize()}. The SDK will call the {@link
AylaSystemSettings.DeviceDetailProvider#getManagedPropertyNames} method for each device it is
managing. If this method returns null for a device, the set of all properties returned from
the service will be used. Most devices only need to pay attention to a subset of properties
that may exist on the device. Implementing this method allows the SDK to be more efficient by
only monitoring the set of properties that are important for a particular device.
API documentation may be generated using JavaDoc or Doxygen. JavaDoc may be built using
Android Studio or the command line:
gradle generateDebugJavadoc
Doxygen users may use the pre-defined Doxyfile residing in the doc directory at the root of the
SDK project.
Aura: Sample application
Aura, available as a separate repository for SDK customers, provides a simple example of how to
use the Ayla Mobile SDK in a real application. Aura shows how to initialize the SDK, create a
{@link AylaSystemSettings.DeviceDetailProvider DeviceDetailProvider} set up to return property
names for the Ayla EVB development board and Generic Gateway solutions, listen for {@link
AylaSessionManager}, {@link AylaDevice} and {@link AylaDeviceManager} events to keep the UI up to
date, display {@link AylaProperty} lists and values for each device, toggle boolean {@link
AylaProperty} datapoints, view and edit {@link AylaUser} account information and more.
More Information
- {@link AylaSchedule} objects are used to manage schedules on {@link AylaDevice} objects
- The {@link AylaUser} object may be fetched from {@link AylaSessionManager} by calling
{@link AylaSessionManager#fetchUserProfile fetchUserProfile()}
- {@link AylaContact}s may be created and used as references in {@link
AylaDeviceNotificationApp}s and {@link AylaPropertyTriggerApp}s
- {@link AylaDevice} objects may be shared by calling {@link AylaDevice#shareWithEmail
shareWithEmail()}


loop, loop-control - loop devices
The loop device is a block device that maps its data blocks not to a physical
device such as a hard disk or optical disk drive, but to the blocks of a
regular file in a filesystem or to another block device. This can be useful
for example to provide a block device for a filesystem image stored in a file,
so that it can be mounted with the mount(8) command. You could do
$ dd if=/dev/zero of=file.img bs=1MiB count=10
$ sudo losetup /dev/loop4 file.img
$ sudo mkfs -t ext4 /dev/loop4
$ sudo mkdir /myloopdev
$ sudo mount /dev/loop4 /myloopdev
See losetup(8) for another example.
A transfer function can be specified for each loop device for
encryption and decryption purposes.
The following ioctl(2) operations are provided by the loop
block device:
- LOOP_SET_FD
- Associate the loop device with the open file whose file descriptor is
passed as the (third) ioctl(2) argument.
- LOOP_CLR_FD
- Disassociate the loop device from any file descriptor.
- LOOP_SET_STATUS
- Set the status of the loop device using the (third) ioctl(2)
argument. This argument is a pointer to loop_info structure,
defined in <linux/loop.h> as:
-
struct loop_info {
int lo_number; /* ioctl r/o */
dev_t lo_device; /* ioctl r/o */
unsigned long lo_inode; /* ioctl r/o */
dev_t lo_rdevice; /* ioctl r/o */
int lo_offset;
int lo_encrypt_type;
int lo_encrypt_key_size; /* ioctl w/o */
int lo_flags; /* ioctl r/o */
char lo_name[LO_NAME_SIZE];
unsigned char lo_encrypt_key[LO_KEY_SIZE];
/* ioctl w/o */
unsigned long lo_init[2];
char reserved[4];
};
- The encryption type (lo_encrypt_type) should be one of
LO_CRYPT_NONE, LO_CRYPT_XOR, LO_CRYPT_DES,
LO_CRYPT_FISH2, LO_CRYPT_BLOW, LO_CRYPT_CAST128,
LO_CRYPT_IDEA, LO_CRYPT_DUMMY, LO_CRYPT_SKIPJACK, or
(since Linux 2.6.0) LO_CRYPT_CRYPTOAPI.
- The lo_flags field is a bit mask that can include zero or more of
the following:
- LO_FLAGS_READ_ONLY
- The loopback device is read-only.
- LO_FLAGS_AUTOCLEAR (since Linux 2.6.25)
- The loopback device will autodestruct on last close.
- LO_FLAGS_PARTSCAN (since Linux 3.2)
- Allow automatic partition scanning.
- LOOP_GET_STATUS
- Get the status of the loop device. The (third) ioctl(2) argument
must be a pointer to a struct loop_info.
- LOOP_CHANGE_FD (since Linux 2.6.5)
- Switch the backing store of the loop device to the new file identified
file descriptor specified in the (third) ioctl(2) argument, which
is an integer. This operation is possible only if the loop device is
read-only and the new backing store is the same size and type as the old
backing store.
- LOOP_SET_CAPACITY (since Linux 2.6.30)
- Resize a live loop device. One can change the size of the underlying
backing store and then use this operation so that the loop driver learns
about the new size. This operation takes no argument.
- LOOP_SET_DIRECT_IO (since Linux 4.10)
- Set DIRECT I/O mode on the loop device, so that it can be used to open
backing file. The (third) ioctl(2) argument is an unsigned long
value. A non-zero represents direct I/O mode.
- LOOP_SET_BLOCK_SIZE (since Linux 4.14)
- Set the block size of the loop device. The (third) ioctl(2)
argument is an unsigned long value. This value must be a power of two in
the range [512,pagesize]; otherwise, an EINVAL error results.
Since Linux 2.6, there are two new ioctl(2) operations:
- LOOP_SET_STATUS64, LOOP_GET_STATUS64
- These are similar to LOOP_SET_STATUS and LOOP_GET_STATUS
described above but use the loop_info64 structure, which has some
additional fields and a larger range for some other fields:
-
struct loop_info64 {
uint64_t lo_device; /* ioctl r/o */
uint64_t lo_inode; /* ioctl r/o */
uint64_t lo_rdevice; /* ioctl r/o */
uint64_t lo_offset;
uint64_t lo_sizelimit;/* bytes, 0 == max available */
uint32_t lo_number; /* ioctl r/o */
uint32_t lo_encrypt_type;
uint32_t lo_encrypt_key_size; /* ioctl w/o */
uint32_t lo_flags; /* ioctl r/o */
uint8_t lo_file_name[LO_NAME_SIZE];
uint8_t lo_crypt_name[LO_NAME_SIZE];
uint8_t lo_encrypt_key[LO_KEY_SIZE]; /* ioctl w/o */
uint64_t lo_init[2];
};
Since Linux 3.1, the kernel provides the /dev/loop-control device, which
permits an application to dynamically find a free device, and to add and
remove loop devices from the system. To perform these operations, one first
opens /dev/loop-control and then employs one of the following
ioctl(2) operations:
- LOOP_CTL_GET_FREE
- Allocate or find a free loop device for use. On success, the device number
is returned as the result of the call. This operation takes no
argument.
- LOOP_CTL_ADD
- Add the new loop device whose device number is specified as a long integer
in the third ioctl(2) argument. On success, the device index is
returned as the result of the call. If the device is already allocated,
the call fails with the error EEXIST.
- LOOP_CTL_REMOVE
- Remove the loop device whose device number is specified as a long integer
in the third ioctl(2) argument. On success, the device number is
returned as the result of the call. If the device is in use, the call
fails with the error EBUSY.
- /dev/loop*
- The loop block special device files.
The program below uses the /dev/loop-control device to find a free loop
device, opens the loop device, opens a file to be used as the underlying
storage for the device, and then associates the loop device with the backing
store. The following shell session demonstrates the use of the program:
$ dd if=/dev/zero of=file.img bs=1MiB count=10
10+0 records in
10+0 records out
10485760 bytes (10 MB) copied, 0.00609385 s, 1.7 GB/s
$ sudo ./mnt_loop file.img
loopname = /dev/loop5
#include <fcntl.h>
#include <linux/loop.h>
#include <sys/ioctl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#define errExit(msg) do { perror(msg); exit(EXIT_FAILURE); \
} while (0)
int
main(int argc, char *argv[])
{
int loopctlfd, loopfd, backingfile;
long devnr;
char loopname[4096];
if (argc != 2) {
fprintf(stderr, "Usage: %s backing-file\n", argv[0]);
exit(EXIT_FAILURE);
}
loopctlfd = open("/dev/loop-control", O_RDWR);
if (loopctlfd == -1)
errExit("open: /dev/loop-control");
devnr = ioctl(loopctlfd, LOOP_CTL_GET_FREE);
if (devnr == -1)
errExit("ioctl-LOOP_CTL_GET_FREE");
sprintf(loopname, "/dev/loop%ld", devnr);
printf("loopname = %s\n", loopname);
loopfd = open(loopname, O_RDWR);
if (loopfd == -1)
errExit("open: loopname");
backingfile = open(argv[1], O_RDWR);
if (backingfile == -1)
errExit("open: backing-file");
if (ioctl(loopfd, LOOP_SET_FD, backingfile) == -1)
errExit("ioctl-LOOP_SET_FD");
exit(EXIT_SUCCESS);
}
This page is part of release 5.05 of the Linux man-pages project. A
description of the project, information about reporting bugs, and the latest
version of this page, can be found at https://www.kernel.org/doc/man-pages/.


Using a sharp knife, cut the meat into 5cm (2in) squares, about 1cm (½in) thick.
Place these escalopes between sheets of cling film and beat them out with a meat mallet or rolling pin until the lamb has been flattened into thin pieces.
Tip all the marinade ingredients into a food processor and blend until smooth.
Coat the escalopes with the marinade, making sure the meat is completely covered with the masala spice mix. Set aside for at least one hour.
Heat the clarified butter in a heavy-bottomed casserole pan, wide enough to take the meat in one layer.
Add the cinnamon sticks and black cardamoms and let them sizzle for a few seconds before adding the marinated meat with its liquid.
Cover the pan with a tightly-fitting lid and seal the edges with a flour and water paste (this helps to retain all the flavours in the pot as the meat cooks).
Simmer on a very low heat for an hour until the sauce has reduced and the meat is tender.
Remove the lid from the pan. If there's too much liquid, cook the sauce down until there's a thin film of oil on top.
Scatter with chopped coriander and serve straight away with warm naan bread.


{% extends "global/Page.html" %} {% load otree %} {% block title %} Results {% endblock %} {% block content %}
| Question | Your answer | Correct answer | Answered correctly? |
|---|---|---|---|
| {{ player.question }} | {{ player.submitted_answer }} | {{ player.showed_solution }} | {{ player.is_correct }} |


Sep 7, 2016 9:31 AM
In today's world, technology has infiltrated every aspect of our society. Not only at the smaller, more portable world of cell phones and laptops, but also at a larger scale, as technological elements find their way into architecture, spaces, and facades. In this presentation, technologist Patrick Proctor will discuss the technology choices available today that make large scale spaces more beautiful, productive, and engaging. He will use both examples from his own work, as well as a more general discussion of a wide range of technologies, including LEDs, sound, sensors, data, projection, and more. Patrick Proctor is a Senior Technologist at the Rockwell Group, as well as an independent creator. He is a 2011 graduate of NYU's Interactive Telecommunications Program, as well as a veteran of Dolby Laboratories. He has created technology projects for a wide diversity of spaces including public plazas, live rock shows, corporate sales centers, night clubs, and art installations.


Create New Operators
How to Create New Operators (Layers)
This tutorials walks you through the process of creating new MXNet operators (or layers). We've done our best to provide high-speed operators for most common use cases. However, if you're engaged in research, there's a good chance you'll want to define custom layers, like a novel loss function. In these cases, you have two options:
Use CustomOp to write new operators using a front-end language (e.g., Python) that run on CPUs or GPUs. Depending on your implementation, this can range from very fast (if you only use operators under mx.nd) to very slow (if you copy out the data, using
.asnumpy()
).Use C++/mshadow (CUDA). This provides the best performance, but can be difficult if you're not familiar with MXNet, mshadow, or Cuda.
CustomOp
Implementing an operator in Python is simple.
As an example, let's create a softmax operator.
Start by subclassing mxnet.operator.CustomOp
,
and then override a few methods:
import os
import mxnet as mx
import numpy as np
class Softmax(mx.operator.CustomOp):
def forward(self, is_train, req, in_data, out_data, aux):
x = in_data[0].asnumpy()
y = np.exp(x - x.max(axis=1).reshape((x.shape[0], 1)))
y /= y.sum(axis=1).reshape((x.shape[0], 1))
self.assign(out_data[0], req[0], mx.nd.array(y))
We defined the computation for the forward pass of our operator.
The forward function takes a list of input and a list of output NDArrays.
For convenience, we called .asnumpy()
on the first NDArray in input
and convert it to a CPU-based NumPy array.
This can be very slow. If you want the best performance,
keep data in the NDArray format and use operators under mx.nd to do the computation.
At the end, we used CustomOp.assign to assign the resulting array y to out_data[0]. It handles assignment based on the value of req, which can be 'write', 'add', or 'null'.
Then do the same for the backward pass:
def backward(self, req, out_grad, in_data, out_data, in_grad, aux):
l = in_data[1].asnumpy().ravel().astype(np.int)
y = out_data[0].asnumpy()
y[np.arange(l.shape[0]), l] -= 1.0
self.assign(in_grad[0], req[0], mx.nd.array(y))
Softmax defines the computation of our custom operator, but you still need to define its input/output format by subclassing mx.operator.CustomOpProp. First, register the new operator with the name 'softmax':
@mx.operator.register("softmax")
class SoftmaxProp(mx.operator.CustomOpProp):
Then, call the base constructor with need_top_grad=False
because softmax is a loss layer and you don't need gradient input from preceding layers:
def __init__(self):
super(SoftmaxProp, self).__init__(need_top_grad=False)
Then declare the input and output:
def list_arguments(self):
return ['data', 'label']
def list_outputs(self):
return ['output']
Note that list_arguments declares both input and parameter.
We recommend ordering them as follows: ['input1', 'input2', ... , 'weight1', 'weight2', ...]
Next, provide infer_shape
to declare the shape of the output/weight
and check the consistency of the input shapes:
def infer_shape(self, in_shape):
data_shape = in_shape[0]
label_shape = (in_shape[0][0],)
output_shape = in_shape[0]
return [data_shape, label_shape], [output_shape], []
The first axis of an input/output tensor corresponds to different examples within the batch.
The label is a set of integers, one for each data entry,
and the output has the same shape as the input.
The infer_shape
function should always return three lists in this order:
inputs, outputs, and auxiliary states (which we don't have here),
even if one of them is empty.
Optionally, you can also define infer_type
to declare the input and output data type of your operator. Supported types are np.float32
, np.float64
, np.float16
, np.uint8
, and np.int32
.
def infer_type(self, in_type):
dtype = in_type[0]
return [dtype, dtype], [dtype], []
Finally, define a create_operator function that will be called by the back end to create an instance of softmax:
def create_operator(self, ctx, shapes, dtypes):
return Softmax()
To use the custom operator, create a mx.sym.Custom symbol with op_type as the registered name:
mlp = mx.symbol.Custom(data=fc3, name='softmax', op_type='softmax')
Please see the full code for this example here.
C++
With MXNet v0.9 (the NNVM refactor) or later, creating new operators has become easier. Operators are now registered with NNVM. The following code is an example on how to register an operator (checkout src/operator/tensor for more examples):
NNVM_REGISTER_OP(abs)
.MXNET_DESCRIBE("Take absolute value of the src")
.set_num_inputs(1)
.set_num_outputs(1)
.set_attr<nnvm::FInferShape>("FInferShape", ElemwiseShape<1,1>);
The syntax is quite simple, we register the operator with a name,
then set number of inputs and outputs.
You can register attributes with any key (FInferShape
for example) to any operator,
without having to modify a central class interface definition.
Operator Attribute System
One of the biggest improvements brought by NNVM is the operator attribute system. This is like traits for types in common languages like C++. We can register any attribute to any operator, with the syntax
NNVM_REGISTER_OP(op-name)
.set_attr<AttributeType>("AttributeKey", CorrespondingAttributeObject);
These attributes can be retrieved later for various purposes.
For example, FInferShape
is used for shape inference, FCompute<cpu>
is used for carrying out actual computation on CPU.
As long as all attributes registered with the same key have the same type, we can register any attributes to operators. The more attribute an operator provides, the more information the system can use for optimization.
List of basic attributes
In this section, we will go through the basic attributes MXNet expect for all operators. You can find the definition for them in the following two files:
Descriptions (Optional)
.describe(comment)
adds a comment to the operator. Use .MXNET_DESCRIBE(comment)
to add the current file name and line number to comment.
Attribute Parser (Optional)
Set attribute parser with .set_attr_parser(PARSER)
where PARSER is a function with prototype void(nnvm::NodeAttr* attrs)
. This function should parse the key-word arguments in attrs->dict
and store the result in attrs->parsed
.
Simple arguments can be parsed like
c++
NNVM_REGISTER_OP(scalar_op)
.set_attr_parser(
[](NodeAttrs* attrs) {
attrs->parsed = std::stod(attrs->dict["scalar"]);
})
The parsed arguments can then be accessed in other attribute functions with
c++
double alpha = nnvm::get<double>(attrs.parsed);
More complex ops can use dmlc::Parameters
and ParamParser
(defined in operator_common.h) for parsing:
#include <dmlc/parameter.h>
#include <operator_common.h>
struct ActivationParam : public dmlc::Parameter<ActivationParam> {
// use int for enumeration
int act_type;
DMLC_DECLARE_PARAMETER(ActivationParam) {
DMLC_DECLARE_FIELD(act_type)
.add_enum("relu", activation::kReLU)
.add_enum("sigmoid", activation::kSigmoid)
.add_enum("tanh", activation::kTanh)
.add_enum("softrelu", activation::kSoftReLU)
.describe("Activation function to be applied.");
}
};
NNVM_REGISTER_OP(Activation)
.set_attr_parser(ParamParser<ActivationParam>);
// access with:
// const ActivationParam& param = nnvm::get<ActivationParam>(attrs.parsed);
Inputs & Outputs
Number of inputs/outputs can be set with .set_num_inputs(n_in)
and .set_num_outputs(n_out)
where n_in and n_out are integers.
Alternatively, if the number of inputs/outputs is variable and depends on arguments,
you can set n_in
/n_out
to functions with prototype uint32_t(const nnvm::NodeAttrs& attrs)
that return the number of inputs/outputs based on parsed arguments.
Outputs can be made invisible to other operators by registering FNumVisibleOutputs
and returning an integer smaller than n_out
.
Inputs/outputs can be named by registering FListInputNames
and FListOutputNames
with prototype std::vector<std::string>(const NodeAttrs& attrs)
.
Argument Descriptions
Set argument descriptions with .add_argument(name, type, comment)
.
This is necessary for operators to be properly called imperatively.
First, add NDArray arguments num_inputs
times with type "NDArray"
or one time with type "NDArray[]" for ops with variable length inputs.
Then add key-word arguments with proper type (float, string, etc).
Operators that parse key-word arguments with dmlc::Parameter
can add argument descriptions in bulk with .add_arguments(ActivationParam::__FIELDS__())
(NDArray arguments still need to be manually added with type "NDArray").
FInferShape or TIsBackward (for Backward Only Ops)
Normally operators need to have FInferShape
with prototype bool(const nnvm::NodeAttrs& attrs, mxnet::ShapeVector *in_attrs, mxnet::ShapeVector *out_attrs)
. FInferShape
fills unknown shapes (shape.ndim() == 0
) in in_attrs/out_attrs based on known shapes in in_attrs/out_attrs. Use ElemwiseShape<n_in, n_out>
for simple operators with uniform shapes.
Operators that are only used for a backward pass can instead register .set_attr<nnvm::TIsBackward>("TIsBackward", true)
and their shapes with be copied from the corresponding forward operators.
FInferType
Similar to FInferShape
, FInferType
fills unknown types (-1) based on known types. Use ElemwiseType<n_in, n_out>
for simple operators with uniform types. Operators that registered TIsBackward
don't need to register this.
FInplaceOption (Optional)
FInplaceOption
with prototype std::vector<std::pair<int, int> >(const NodeAttrs& attrs)
specifies which input/output pairs can be computed in-place
and share memory with each other.
Each pair (i, j) in the returned list means
that the i-th input can share memory with the j-th output.
FGradient (Optional for imperative use, required for symbolic use)
If an operator has gradient, it can be described with FGradient
with prototype
std::vector<nnvm::NodeEntry>(const nnvm::NodePtr& n,
const std::vector<nnvm::NodeEntry>& ograds)
Use utility functions ElemwiseGradUseIn{op_name}
, ElemwiseGradUseOut{op_name}
, ElemwiseGradUseNone{op_name}
for ops that need corresponding forward op's input,
output or nothing to calculating gradient.
For more complicated patterns, use MakeGradNode(op_name, n, heads, dict)
to create gradient entries,
where heads are input entries to the backward op, composed from ograds and n->inputs.
When assembling a return vector of std::vector<nnvm::NodeEntry> ret;
a common pattern would be to
either create nodes in place as in:
ret.emplace_back(MakeNode("zeros_like", n->attrs.name + "_xyz_backward",
{n->inputs[1]}, nullptr, &n))
Or create the node, modify and then move into NodeEntry's constructor if this node is not to be used again. This avoids uneccessary copies of the shared_ptr.
for (size_t i = 0; i < n->inputs.size(); ++i) {
nnvm::NodePtr node = nnvm::Node::Create();
node->attrs.op = copy_op;
node->inputs = {ograds[0]};
ret.emplace_back(std::move(node));
}
The first case uses RVO and the second in place construction.
FCompute<xpu>
Simple operators can register FCompute.set_attr<FCompute>("FCompute<cpu>", ...)
and .set_attr<FCompute>("FCompute<gpu>", ...)
for both CPU and (optionally) GPU computation.
FCompute has prototype
void(const nnvm::NodeAttrs& attrs,
const OpContext& ctx,
const std::vector<TBlob>& inputs,
const std::vector<OpReqType>& req,
const std::vector<TBlob>& outputs)
req
has the same length as outputs
.
Each entry of req
specifies
how the corresponding output
should be written to.
OpReqType
is defined as:
enum OpReqType {
kNullOp,
kWriteTo,
kWriteInplace,
kAddTo
};
Normally, the req
of all outputs
should be kWriteTo
,
meaning that the provided outputs
tensor is a raw memory block,
so the operator should write results directly into it.
In some cases, for example, when calculating the gradient tensor,
it would be great if we could accumulate the result,
rather than directly overwrite the tensor contents
so that no extra space needs to be created each time.
In such cases, the corresponding req
is set to kAddTo
,
indicating that a +=
should be used.
Example: abs operator
NNVM_REGISTER_OP(abs)
.MXNET_DESCRIBE("Take absolute value of the src")
.set_num_inputs(1)
.set_num_outputs(1)
.set_attr<nnvm::FInferShape>("FInferShape", ElemwiseShape<1, 1>)
.set_attr<nnvm::FInferType>("FInferType", ElemwiseType<1, 1>)
.set_attr<nnvm::FInplaceOption>("FInplaceOption",
[](const NodeAttrs& attrs){
return std::vector<std::pair<int, int> >{{0, 0}};
})
.set_attr<FCompute>("FCompute<cpu>", UnaryCompute<cpu, mshadow_op::abs>)
.set_attr<nnvm::FGradient>("FGradient", ElemwiseGradUseIn{"_backward_abs"});
.add_argument("data", "NDArray", "Source input")
NNVM_REGISTER_OP(_backward_abs)
.set_num_inputs(2)
.set_num_outputs(1)
.set_attr<nnvm::FInferShape>("FInferShape", ElemwiseShape<2, 1>)
.set_attr<nnvm::FInferType>("FInferType", ElemwiseType<2, 1>)
.set_attr<nnvm::FInplaceOption>("FInplaceOption",
[](const NodeAttrs& attrs){
return std::vector<std::pair<int, int> >{{0, 0}, {1, 0}};
})
.set_attr<FCompute>("FCompute<cpu>", BinaryCompute<cpu, backward_grad<mshadow_op::sign> >);
Legacy Operators
For the legacy (pre 0.9) way of defining operators with C++, please see: - Developer Guide - Operators - Developer Guide - SimpleOp


{extends "admin/base.html"} {block breadcrumbs}
Are you sure you want to delete {$object}?
It will also delete the following linked elements:


public class ProxyServiceImpl implements ProxyService
Created by Shynixn 2018.
public ProxyServiceImpl(NonExistentClass pluginContainer, LoggingService loggingService)
Created by Shynixn 2018.
public <L> java.util.List<L> getPointsBetweenLocations(L location1, L location2, int amount)
Gets a list of points between 2 locations.
public <P> void applyPotionEffect(P player, PotionEffect potionEffect)
Applies the given potionEffect
to the given player
.
potionEffect
,
player
public <L,I> void dropInventoryItem(L location, I item)
Drops the given item at the given position.
public <I,IT> IT getInventoryItem(I inventory, int index)
Gets the inventory item at the given index.
public <P> boolean hasPermission(P player, java.lang.String permission)
Gets if the given player has got the given permission.
public <I> void clearInventory(I inventory)
Clears the given inventory.
public <P,I> P getPlayerFromInventory(I inventory)
Gets if the given inventory belongs to a player. Returns null if not.
public <I> I getLowerInventory(I inventory)
Gets the lower inventory of an inventory.
public <P> void closeInventory(P player)
Closes the inventory of the given player.
public <P,I> I openInventory(P player, java.lang.String title, int size)
Opens a new inventory for the given player.
public <I,IT> void setInventoryItem(I inventory, int index, IT item)
Updates the inventory.
public <P> void updateInventory(P player)
Updates the given player inventory.
public <P> java.lang.String getPlayerName(P player)
Gets the name of a player.
public <P> P getPlayerFromUUID(java.lang.String uuid)
Gets the player from the given UUID.
public <E> int getEntityId(E entity)
Gets the entity id.
public <L,P> L getPlayerLocation(P player)
Gets the location of the player.
public <L> Position toPosition(L location)
Converts the given location
to a interface Position
.
location
,
interface Position
public <L> L toLocation(Position position)
Converts the given position
to a Location..
position
public <P> Position getDirectionVector(P player)
Gets the looking direction of the player.
public <P,I> I getPlayerItemInHand(P player, boolean offhand)
Gets the item in the player hand.
public <P,I> void setPlayerItemInHand(P player, I itemStack, boolean offhand)
Sets the item in the player hand.
public <P> boolean hasPermission(P player, Permission permission)
Gets if the given player has got the given permission.
public <P> java.lang.String getPlayerUUID(P player)
Gets the player uuid.
public <S> void sendMessage(S sender, java.lang.String message)
Sends a message to the sender
.
sender
public void executeServerCommand(java.lang.String message)
Executes a server command.
public <P> void executePlayerCommand(P player, java.lang.String message)
Executes a player command.
public <P> boolean isPlayer(P instance)
Gets if the given instance can be converted to a player.


- get(String) - Method in class com.Upwork.api.OAuthClient
-
Send signed OAuth GET request without parameters
- get(String, HashMap<String, String>) - Method in class com.Upwork.api.OAuthClient
-
Send signed OAuth GET request
- get(String, String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Workdiary
-
Get Workdiary
- getActiveMilestone(String) - Method in class com.Upwork.api.Routers.Hr.Milestones
-
Get active Milestone for the Contract
- getAll() - Method in class com.Upwork.api.Routers.Hr.Roles
-
Get user roles
- getAuthorizationUrl(String) - Method in class com.Upwork.api.OAuthClient
-
Returns authorization URL.
- getByAgency(String, String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Reports.Time
-
Generating Agency Specific Reports
- getByBuyersCompany(String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Reports.Finance.Billings
-
Generate Billing Reports for a Specific Buyer's Company
- getByBuyersCompany(String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Reports.Finance.Earnings
-
Generate Earning Reports for a Specific Buyer's Company
- getByBuyersTeam(String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Reports.Finance.Billings
-
Generate Billing Reports for a Specific Buyer's Team
- getByBuyersTeam(String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Reports.Finance.Earnings
-
Generate Earning Reports for a Specific Buyer's Team
- getByCompany(String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Reports.Time
-
Generating Company Wide Reports
- getByCompany(String, String, String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Workdays
-
Get Workdays by Company
- getByContract(String, String) - Method in class com.Upwork.api.Routers.Snapshot
-
Get snapshot info by specific contract
- getByContract(String, String, String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Workdays
-
Get Workdays by Contract
- getByContract(String, String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Workdiary
-
Get Work Diary by Contract
- getByFreelancer(String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Reports.Finance.Billings
-
Generate Billing Reports for a Specific Freelancer
- getByFreelancer(String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Reports.Finance.Earnings
-
Generate Earning Reports for a Specific Freelancer
- getByFreelancerFull(String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Reports.Time
-
Generating Freelancer's Specific Reports (with financial info)
- getByFreelancerLimited(String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Reports.Time
-
Generating Freelancer's Specific Reports (hide financial info)
- getByFreelancersCompany(String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Reports.Finance.Billings
-
Generate Billing Reports for a Specific Freelancer's Company
- getByFreelancersCompany(String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Reports.Finance.Earnings
-
Generate Earning Reports for a Specific Freelancer's Company
- getByFreelancersTeam(String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Reports.Finance.Billings
-
Generate Billing Reports for a Specific Freelancer's Team
- getByFreelancersTeam(String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Reports.Finance.Earnings
-
Generate Earning Reports for a Specific Freelancer's Team
- getBySpecificUser(String) - Method in class com.Upwork.api.Routers.Hr.Roles
-
Get by specific user
- getByTeamFull(String, String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Reports.Time
-
Generate Time Reports for a Specific Team (with financial info)
- getByTeamLimited(String, String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Reports.Time
-
Generate Time Reports for a Specific Team (hide financial info)
- getCategories() - Method in class com.Upwork.api.Routers.Metadata
-
Get Categories
- getCategoriesV2() - Method in class com.Upwork.api.Routers.Metadata
-
Get Categories (v2)
- getList(String, String) - Method in class com.Upwork.api.Routers.Activities.Team
-
List all oTask/Activity records within a team
- getList(HashMap<String, String>) - Method in class com.Upwork.api.Routers.Hr.Clients.Applications
-
Get list of applications
- getList(HashMap<String, String>) - Method in class com.Upwork.api.Routers.Hr.Clients.Offers
-
Get list of offers
- getList(HashMap<String, String>) - Method in class com.Upwork.api.Routers.Hr.Engagements
-
Get list of engagements
- getList(HashMap<String, String>) - Method in class com.Upwork.api.Routers.Hr.Freelancers.Applications
-
Get list of applications
- getList(HashMap<String, String>) - Method in class com.Upwork.api.Routers.Hr.Freelancers.Offers
-
Get list of applications
- getList(HashMap<String, String>) - Method in class com.Upwork.api.Routers.Hr.Jobs
-
Get list of jobs
- getList() - Method in class com.Upwork.api.Routers.Organization.Companies
-
Get Companies Info
- getList() - Method in class com.Upwork.api.Routers.Organization.Teams
-
Get Teams info
- getMyInfo() - Method in class com.Upwork.api.Routers.Organization.Users
-
Get Auth User Info
- getOwned(String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Reports.Finance.Accounts
-
Generate Financial Reports for an owned Account
- getProperty(String) - Method in class com.Upwork.api.Config
-
Get property by name
- getReasons(HashMap<String, String>) - Method in class com.Upwork.api.Routers.Metadata
-
Get reasons
- getRegions() - Method in class com.Upwork.api.Routers.Metadata
-
Get regions
- getRoomByApplication(String, String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Messages
-
Get a specific room by application ID
- getRoomByContract(String, String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Messages
-
Get a specific room by contract ID
- getRoomByOffer(String, String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Messages
-
Get a specific room by offer ID
- getRoomDetails(String, String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Messages
-
Get a specific room information
- getRoomMessages(String, String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Messages
-
Get messages from a specific room
- getRooms(String) - Method in class com.Upwork.api.Routers.Messages
-
Retrieve rooms information
- getRooms(String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Messages
-
Retrieve rooms information with params
- getSkills() - Method in class com.Upwork.api.Routers.Metadata
-
Get Skills
- getSkillsV2() - Method in class com.Upwork.api.Routers.Metadata
-
Get Skills V2
- getSpecialties() - Method in class com.Upwork.api.Routers.Metadata
-
Get Specialties
- getSpecific(String) - Method in class com.Upwork.api.Routers.Activities.Engagement
-
List activities for specific engagement
- getSpecific(String) - Method in class com.Upwork.api.Routers.Freelancers.Profile
-
Get specific Freelancer's Profile
- getSpecific(String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Hr.Clients.Applications
-
Get specific application
- getSpecific(String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Hr.Clients.Offers
-
Get specific offer
- getSpecific(String) - Method in class com.Upwork.api.Routers.Hr.Engagements
-
Get specific engagement
- getSpecific(String) - Method in class com.Upwork.api.Routers.Hr.Freelancers.Applications
-
Get specific application
- getSpecific(String) - Method in class com.Upwork.api.Routers.Hr.Freelancers.Offers
-
Get specific application
- getSpecific(String) - Method in class com.Upwork.api.Routers.Hr.Jobs
-
Get specific job by key
- getSpecific(String) - Method in class com.Upwork.api.Routers.Jobs.Profile
-
Get specific Job's Profile
- getSpecific(String) - Method in class com.Upwork.api.Routers.Organization.Companies
-
Get Specific Company
- getSpecific(String) - Method in class com.Upwork.api.Routers.Organization.Users
-
Get Specific User Info
- getSpecific(String, HashMap<String, String>) - Method in class com.Upwork.api.Routers.Reports.Finance.Accounts
-
Generate Financial Reports for a Specific Account
- getSpecificBrief(String) - Method in class com.Upwork.api.Routers.Freelancers.Profile
-
Get brief info for the specific Freelancer's Profile
- getSpecificList(String, String, String) - Method in class com.Upwork.api.Routers.Activities.Team
-
List all oTask/Activity records within a team by specified code(s)
- getSubmissions(String) - Method in class com.Upwork.api.Routers.Hr.Milestones
-
Get all submissions for the active Milestone
- getTeams(String) - Method in class com.Upwork.api.Routers.Organization.Companies
-
Get Teams in Company
- getTests() - Method in class com.Upwork.api.Routers.Metadata
-
Get tests
- getTokenResponseByCode(String, CredentialRefreshListener) - Method in class com.Upwork.api.OAuthClient
-
Returns TokensResponse containing access and refresh tokens.
- getTokenResponseByRefreshToken(String, CredentialRefreshListener) - Method in class com.Upwork.api.OAuthClient
-
Returns TokensResponse containing access and refresh tokens.
- getUserInfo() - Method in class com.Upwork.api.Routers.Auth
-
Get My Info
- getUsers(String) - Method in class com.Upwork.api.Routers.Organization.Companies
-
Get Users in Company
- getUsersInTeam(String) - Method in class com.Upwork.api.Routers.Organization.Teams
-
Get Users in Team
- Graphql - Class in com.Upwork.api.Routers
-
- Graphql(OAuthClient) - Constructor for class com.Upwork.api.Routers.Graphql
-


--- layout: post title: "Who's Funding Predictive Analytics in Education?" date: 2016-12-21 05:35:00 +0000 tags: image: https://s3.amazonaws.com/hackedu/2016-12-21-pigeon.jpg imagecredits: https://www.flickr.com/photos/68346521@N08/6370949347 ---
This article helps provide funding data for part 10 of my annual review of the year in ed-tech
The following “predictive analytics” startup raised funding in 2016:
Acquisitions in “predictive analytics” this year include the PAR framework (acquired by Hobsons).
(Related: Startups that offer “personalized learning” that raised money this year.)


{% extends "layout.htm" %} {% block content %}
This website is supposed to display all important information related or
personal to the user conveniently at one location. For example - information regarding user's amazon orders,
night sky, tweets, instagram posts, spotify playlists, etc.
We only implemented two of these features - information regarding user's amazon orders and night sky.
Click on Services to access those.


By Cody
23/09/2016
C/C++: Preprocessor > Compiler > Assembler > Linker
JavaScript: Lexer > Parser > Translator > Interpreter
An extraordinarily optimizable, low-level subset of JavaScript.
function DiagModule(stdlib) {
"use asm";
var sqrt = stdlib.Math.sqrt;
function square(x) {
x = +x;
return +(x*x);
}
function diag(x, y) {
x = +x;
y = +y;
return +sqrt(square(x) + square(y));
}
return { diag: diag };
}
// Browsers: this === window
var fast = DiagModule(this); // link the module
console.log(fast.diag(3, 4)); // 5
function MyAsmModule(stdlib, foreign, heap) {
"use asm"; // marks this function as an asm.js module
// module body:
function f1(...) { ... }
function f2(...) { ... }
// ...
return {
export1: f1,
export2: f2,
// ...
};
}
stdlib: a standard library object, providing access to (a subset of) the standard library.
foreign: a foreign function interface (FFI) providing access to arbitrary external JavaScript functions.
heap: a heap buffer, an instance of ArrayBuffer that acts as the asm.js heap.
Via its initializer
var a = 0; // a has type int
var b = 0.0; // b has type double
Via type annotations
function foo(x, y) {
var x = x|0; // x has type int
var y = +y; // y has type double
return +(x * y); // function returns a double
}
In the real world, it's like this:
Tips: Emscripten does all these.
#include <stdio.h>
int fib(int x) {
if (x < 2) {
return 1;
} else {
return fib(x - 1) + fib(x - 2);
}
}
int main() {
int result = fib(45);
printf("%d\n", result);
return 1;
}
./emcc -O1 -s ASM_JS=1 ./hello_world.cpp
node ./a.out.js
CoffeeScript
divisible = 3
divisibleReporter = (lastFound, nextDivisible) ->
"Found: #{lastFound}, Next: #{nextDivisible}"
divisibleKeeper = ((divisible) ->
lastFound = 0
nextDivisible = divisible
(number) ->
if (number >= nextDivisible)
nextDivisible = (Math.floor(number/divisible) + 1) * divisible
lastFound = Math.floor(number/divisible) * divisible
console.log divisibleReporter(lastFound, nextDivisible)
)(divisible);
for n in [1..100]
divisibleKeeper(n)
TypeScript
var divisible = 3;
var divisibleReporter = function(lastFound:number, nextDivisible:number){
return "Found: " + lastFound + ", Next: " + nextDivisible;
};
var divisibleKeeper = (function(divisible:number) {
var lastFound = 0;
var nextDivisible = divisible;
return function(number:number) {
if (number >= nextDivisible) {
nextDivisible = (Math.floor(number / divisible) + 1) * divisible;
lastFound = Math.floor(number / divisible) * divisible;
console.log(divisibleReporter(lastFound, nextDivisible));
}
};
})(divisible);
for (var i = 1; i <= 100; ++i) {
divisibleKeeper(i);
}
Dart
int divisible = 3;
String divisibleReporter(int lastFound, int nextDivisible) => "Found: ${lastFound}, Next: ${nextDivisible}";
var divisibleKeeper = ((int divisible) {
int lastFound = 0;
int nextDivisible = divisible;
return (int number){
if (number >= nextDivisible) {
nextDivisible = ((number/divisible).floor() + 1) * divisible;
lastFound = (number/divisible).floor() * divisible;
print(divisibleReporter(lastFound, nextDivisible));
}
};
})(divisible);
void main() {
for (var i = 0; i < 100; i++) {
divisibleKeeper(i);
}
}
GWT
public class ButtonExample implements EntryPoint {
public void onModuleLoad() {
// Make a new button that does something when you click it.
Button b = new Button("Jump!", new ClickHandler() {
public void onClick(ClickEvent event) {
Window.alert("How high?");
}
});
// Add it to the root panel.
RootPanel.get().add(b);
}
}
Currently ONLY Firefox and Edge support this
The asm.js is still JS, ONLY saving time during interpretion
Hard to debug
WebAssembly or wasm is a new portable, size- and load-time-efficient format suitable for compilation to the web.
others said...
WebAssembly is (roughly) a binary format for delivering asm.js code.
The text format is equivalent and isomorphic to the binary format.
The Binaryen shell, which can load a WebAssembly module, transform it, execute it in an interpreter, print it, etc.
Tool pack: asm2wasm / wasm2asm / s2wasm / wasm.js


The Hunchback of Notre Dame
by Victor Hugo
Book First, Chapter 6
Additional Information
- Year Published: 1831
- Language: English
- Country of Origin: France
- Source: Hapsgood, I., trans. (1831). The Hunchback of Notre Dame. New York: Carey, Lea, and Blanchard.
-
Readability:
- Flesch–Kincaid Level: 12.0
- Word Count: 824
- Genre: Romance
- Keywords: culture, fate, love, loyalty
- ✎ Cite This
Downloads
We are delighted to be able to inform the reader, that during the whole of this scene, Gringoire and his piece had stood firm. His actors, spurred on by him, had not ceased to spout his comedy, and he had not ceased to listen to it. He had made up his mind about the tumult, and was determined to proceed to the end, not giving up the hope of a return of attention on the part of the public. This gleam of hope acquired fresh life, when he saw Quasimodo, Coppenole, and the deafening escort of the pope of the procession of fools quit the hall amid great uproar. The throng rushed eagerly after them. "Good," he said to himself, "there go all the mischief– makers." Unfortunately, all the mischief–makers constituted the entire audience. In the twinkling of an eye, the grand hall was empty.
To tell the truth, a few spectators still remained, some scattered, others in groups around the pillars, women, old men, or children, who had had enough of the uproar and tumult. Some scholars were still perched astride of the window–sills, engaged in gazing into the Place.
"Well," thought Gringoire, "here are still as many as are required to hear the end of my mystery. They are few in number, but it is a choice audience, a lettered audience."
An instant later, a symphony which had been intended to produce the greatest effect on the arrival of the Virgin, was lacking. Gringoire perceived that his music had been carried off by the procession of the Pope of the Fools. "Skip it," said he, stoically.
He approached a group of bourgeois, who seemed to him to be discussing his piece. This is the fragment of conversation which he caught,—
"You know, Master Cheneteau, the Hôtel de Navarre, which belonged to Monsieur de Nemours?"
"Yes, opposite the Chapelle de Braque."
"Well, the treasury has just let it to Guillaume Alixandre, historian, for six hivres, eight sols, parisian, a year."
"How rents are going up!"
"Come," said Gringoire to himself, with a sigh, "the others are listening."
"Comrades," suddenly shouted one of the young scamps from the window, "La Esmeralda! La Esmeralda in the Place!"
This word produced a magical effect. Every one who was left in the hall flew to the windows, climbing the walls in order to see, and repeating, "La Esmeralda! La Esmeralda?" At the same time, a great sound of applause was heard from without.
"What's the meaning of this, of the Esmeralda?" said Gringoire, wringing his hands in despair. "Ah, good heavens! it seems to be the turn of the windows now."
He returned towards the marble table, and saw that the representation had been interrupted. It was precisely at the instant when Jupiter should have appeared with his thunder. But Jupiter was standing motionless at the foot of the stage.
"Michel Giborne!" cried the irritated poet, "what are you doing there? Is that your part? Come up!"
"Alas!" said Jupiter, "a scholar has just seized the ladder."
Gringoire looked. It was but too true. All communication between his plot and its solution was intercepted.
"The rascal," he murmured. "And why did he take that ladder?"
"In order to go and see the Esmeralda," replied Jupiter piteously. "He said, 'Come, here's a ladder that's of no use!' and he took it."
This was the last blow. Gringoire received it with resignation.
"May the devil fly away with you!" he said to the comedian, "and if I get my pay, you shall receive yours."
Then he beat a retreat, with drooping head, but the last in the field, like a general who has fought well.
And as he descended the winding stairs of the courts: "A fine rabble of asses and dolts these Parisians!" he muttered between his teeth; "they come to hear a mystery and don't listen to it at all! They are engrossed by every one, by Chopin Trouillefou, by the cardinal, by Coppenole, by Quasimodo, by the devil! but by Madame the Virgin Mary, not at all.  And I! to come to see faces and behold only backs! to be a poet, and to reap the success of an apothecary! It is true that Homerus begged through the Greek towns, and that Naso died in exile among the Muscovites. But may the devil flay me if I understand what they mean with their Esmeralda! What is that word, in the first place?—'tis Egyptian!"


{% load settings_value %} {% settings_value "WEBSETUP_DOMAIN_NAME" as WEBSETUP_DOMAIN_NAME %} {% settings_value "LOGO_FILE" as LOGO_FILE %}


DevRel Tokyo Community
Spreading on Twitter and Facebook!
Give you 30sec! Tweet anything!
Hash tag: #devreljp #devrel
Spreading your experience on blog or social!
Anniversary first meetup!
19:15 ｜ Welcome & Introducing our Meetup
19:20 ｜ Self introducing
19:35 ｜ Why does we focus developers by Atsushi, MOONGIFT
20:00 ｜ The role DevRel played in commercial software marketing activities by Takeshi Nick Osanai, Sixapart
20:25 ｜ Providing the best developer experience through docs by Sam, GitLocalize
20:50 ｜ TDB by Joe Nash, GitHub
21:10 ｜ Drink up!
21:50 ｜ Close door
Join us!
http://bit.ly/devrelcom
We really hope your following!
Did you get 🎫 ?
・Your name?
・Your job?
・What do you involve at DevRel?


Background and Basics
Geothermal energy is the heating and cooling system of a building using the relatively constant temperatures underground; ground soil stays at approximately 55 degrees. The system is able to pull heat from the ground into the house in the winter and can push heat out of the house during the summer. Along with temperature regulation, the geothermal system can also regulate humidity levels within the home.
Components:
- □ Ground Loop: a vertical loop is the most commonly installed system. It is most advantageous when there is limited space.
- □ Heating pump: This is installed inside your home.
Benefits
- □ This system does not depend on the external weather. It fully regulates and exchanges temperatures with the ground and the building.
- □ Geothermal energy is envronmental-friendly. It lowers emissions of greenhouse gases by 60% !!
- □ After a while, this system can pay for itself. The investment can end up saving you 40-60% in utility costs.
- □ If installed properly, the geothermal heating and cooling system requires little to no maintenance or replacement for up to 50 years.
Thinking about Investing?
There are many things to consider while planning to invest in a geothermal energy system. First, you need to consider if your property is compatible and efficient for the system. Here are some guidelines and points of consideration:
- □ Gaining EPA and state permits for acquiring the system.
- □ You must abide by federal, state, and local regulations on installation, usage, and maintenance.
- □ Find out an effective location for your indoor unit (distribution center = duct system and radiators).
- □ Consider installing energy-efficient windows for minimum heat and cooling leakage of the home.
💡 Tips: Insulate
Another good way to improve your home's environmental friendliness is to make sure you use less electricity. This can be achieved by investing in insulation. Good insulation holds in your heat, so you don't need to heat your home with much energy. There are different places to separate, even in the roof and inside the walls of your house. You should also consider double glazing the windows.


class TestsGenerator extends AbstractGenerator
Methods
|
preGenerate(array $bundle)
|
||
|
generate(array $bundle, $root, $bundlePath)
|
from AbstractGenerator | |
|
postGenerate(array $bundle, $root, $bundlePath)
|
||
|
setEngine(GeneratorEngine $engine)
|
from AbstractGenerator | |
|
__construct(TestBuilderInterface $testBuilder, ResolverInterface $resolver, AnnotationReader $controllersAnnotationReader)
|
Details
at line 15
public
preGenerate(array $bundle)
in AbstractGenerator at line 10
public
generate(array $bundle, $root, $bundlePath)
at line 22
public
postGenerate(array $bundle, $root, $bundlePath)
in AbstractGenerator at line 16
public
setEngine(GeneratorEngine $engine)
at line 9
public
__construct(TestBuilderInterface $testBuilder, ResolverInterface $resolver, AnnotationReader $controllersAnnotationReader)


Use this page to process a specific pull request on GitHub, which will ensure that a JIRA ticket exists for it. This will create JIRA tickets even for PRs made by edX employees and contractors working with edX.


IOSTAT
Section: Linux User's Manual (1)Updated: APRIL 2009
Index Return to Main Contents
NAME
iostat - Report Central Processing Unit (CPU) statistics and input/output statistics for devices, partitions and network filesystems (NFS).SYNOPSIS
iostat [ -c ] [ -d ] [ -N ] [ -n ] [ -h ] [ -k | -m ] [ -t ] [ -V ] [ -x ] [ -z ] [ device [...] | ALL ] [ -p [ device [,...] | ALL ] ] [ interval [ count ] ]DESCRIPTION
The iostat command is used for monitoring system input/output device loading by observing the time the devices are active in relation to their average transfer rates. The iostat command generates reports that can be used to change system configuration to better balance the input/output load between physical disks.The first report generated by the iostat command provides statistics concerning the time since the system was booted. Each subsequent report covers the time since the previous report. All statistics are reported each time the iostat command is run. The report consists of a CPU header row followed by a row of CPU statistics. On multiprocessor systems, CPU statistics are calculated system-wide as averages among all processors. A device header row is displayed followed by a line of statistics for each device that is configured. When option -n is used, an NFS header row is displayed followed by a line of statistics for each network filesystem that is mounted.
The interval parameter specifies the amount of time in seconds between each report. The first report contains statistics for the time since system startup (boot). Each subsequent report contains statistics collected during the interval since the previous report. The count parameter can be specified in conjunction with the interval parameter. If the count parameter is specified, the value of count determines the number of reports generated at interval seconds apart. If the interval parameter is specified without the count parameter, the iostat command generates reports continuously.
REPORTS
The iostat command generates three types of reports, the CPU Utilization report, the Device Utilization report and the Network Filesystem report.- CPU Utilization Report
-
The first report generated by the
iostat
command is the CPU
Utilization Report. For multiprocessor systems, the CPU values are
global averages among all processors.
The report has the following format:
%user
-
- Show the percentage of CPU utilization that occurred while executing at the user level (application).
%nice
- Show the percentage of CPU utilization that occurred while executing at the user level with nice priority.
%system
- Show the percentage of CPU utilization that occurred while executing at the system level (kernel).
%iowait
- Show the percentage of time that the CPU or CPUs were idle during which the system had an outstanding disk I/O request.
%steal
- Show the percentage of time spent in involuntary wait by the virtual CPU or CPUs while the hypervisor was servicing another virtual processor.
%idle
- Show the percentage of time that the CPU or CPUs were idle and the system did not have an outstanding disk I/O request.
-
- Device Utilization Report
-
The second report generated by the
iostat
command is the Device Utilization
Report. The device report provides statistics on a per physical device
or partition basis. Block devices for which statistics are to be displayed
may be entered on the command line. Partitions may also be entered on the
command line providing that option -x is not used.
If no device nor partition
is entered, then statistics are displayed
for every device used by the system, and
providing that the kernel maintains statistics for it.
If the
ALL
keyword is given on the command line, then statistics are
displayed for every device defined by the system, including those
that have never been used.
The report may show the following fields,
depending on the flags used:
Device:
-
-
This column gives the device (or partition) name, which is displayed as
hdiskn
with 2.2 kernels, for the nth device. It is displayed as
devm-n
with 2.4 kernels, where
m
is the major number of the device, and
n
a distinctive number.
With newer kernels, the device name as listed in the /dev directory
is displayed.
-
Indicate the number of transfers per second that were issued
to the device. A transfer is an I/O request to the
device. Multiple logical requests can be combined into a single I/O
request to the device. A transfer is of indeterminate size.
-
Indicate the amount of data read from the device expressed in a number of
blocks per second. Blocks are equivalent to sectors with kernels 2.4 and later
and therefore have a size of 512 bytes. With older kernels, a block is of
indeterminate size.
-
Indicate the amount of data written to the device expressed in a number of
blocks per second.
-
The total number of blocks read.
-
The total number of blocks written.
-
Indicate the amount of data read from the device expressed in kilobytes
per second.
-
Indicate the amount of data written to the device expressed in kilobytes
per second.
-
The total number of kilobytes read.
-
The total number of kilobytes written.
-
Indicate the amount of data read from the device expressed in megabytes
per second.
-
Indicate the amount of data written to the device expressed in megabytes
per second.
-
The total number of megabytes read.
-
The total number of megabytes written.
-
The number of read requests merged per second that were queued to the device.
-
The number of write requests merged per second that were queued to the device.
-
The number of read requests that were issued to the device per second.
-
The number of write requests that were issued to the device per second.
-
The number of sectors read from the device per second.
-
The number of sectors written to the device per second.
-
The number of kilobytes read from the device per second.
-
The number of kilobytes written to the device per second.
-
The number of megabytes read from the device per second.
-
The number of megabytes written to the device per second.
-
The average size (in sectors) of the requests that were issued to the device.
-
The average queue length of the requests that were issued to the device.
-
The average time (in milliseconds) for I/O requests issued to the device
to be served. This includes the time spent by the requests in queue and
the time spent servicing them.
-
The average service time (in milliseconds) for I/O requests that were issued
to the device. Warning! Do not trust this field any more. This field
will be removed in a future sysstat version.
- Percentage of CPU time during which I/O requests were issued to the device (bandwidth utilization for the device). Device saturation occurs when this value is close to 100%.
-
This column gives the device (or partition) name, which is displayed as
hdiskn
with 2.2 kernels, for the nth device. It is displayed as
devm-n
with 2.4 kernels, where
m
is the major number of the device, and
n
a distinctive number.
With newer kernels, the device name as listed in the /dev directory
is displayed.
-
- Network Filesystem report
-
The Network Filesystem (NFS) report provides statistics for each mounted network filesystem.
The report shows the following fields:
Filesystem:
-
-
This columns shows the hostname of the NFS server followed by a colon and
by the directory name where the network filesystem is mounted.
-
Indicate the number of blocks read by applications via the read(2) system
call interface. A block has a size of 512 bytes.
-
Indicate the number of blocks written by applications via the write(2) system
call interface.
-
Indicate the number of blocks read from files opened with the O_DIRECT flag.
-
Indicate the number of blocks written to files opened with the O_DIRECT flag.
-
Indicate the number of blocks read from the server by the NFS client via an
NFS READ request.
-
Indicate the number of blocks written to the server by the NFS client via an
NFS WRITE request.
-
Indicate the number of kilobytes read by applications via the read(2) system
call interface.
-
Indicate the number of kilobytes written by applications via the write(2) system
call interface.
-
Indicate the number of kilobytes read from files opened with the O_DIRECT flag.
-
Indicate the number of kilobytes written to files opened with the O_DIRECT flag.
-
Indicate the number of kilobytes read from the server by the NFS client via an
NFS READ request.
-
Indicate the number of kilobytes written to the server by the NFS client via an
NFS WRITE request.
-
Indicate the number of megabytes read by applications via the read(2) system
call interface.
-
Indicate the number of megabytes written by applications via the write(2) system
call interface.
-
Indicate the number of megabytes read from files opened with the O_DIRECT flag.
-
Indicate the number of megabytes written to files opened with the O_DIRECT flag.
-
Indicate the number of megabytes read from the server by the NFS client via an
NFS READ request.
-
Indicate the number of megabytes written to the server by the NFS client via an
NFS WRITE request.
-
Indicate the number of operations that were issued to the filesystem per second.
-
Indicate the number of 'read' operations that were issued to the filesystem
per second.
- Indicate the number of 'write' operations that were issued to the filesystem per second.
-
This columns shows the hostname of the NFS server followed by a colon and
by the directory name where the network filesystem is mounted.
-
OPTIONS
- -c
- Display the CPU utilization report.
- -d
- Display the device utilization report.
- -h
- Make the NFS report displayed by option -n easier to read by a human.
- -k
- Display statistics in kilobytes per second instead of blocks per second. Data displayed are valid only with kernels 2.4 and later.
- -m
- Display statistics in megabytes per second instead of blocks or kilobytes per second. Data displayed are valid only with kernels 2.4 and later.
- -N
- Display the registered device mapper names for any device mapper devices. Useful for viewing LVM2 statistics.
- -n
- Display the network filesystem (NFS) report. This option works only with kernel 2.6.17 and later.
- -p [ { device [,...] | ALL } ]
- The -p option displays statistics for block devices and all their partitions that are used by the system. If a device name is entered on the command line, then statistics for it and all its partitions are displayed. Last, the ALL keyword indicates that statistics have to be displayed for all the block devices and partitions defined by the system, including those that have never been used. Note that this option works only with post 2.5 kernels.
- -t
- Print the time for each report displayed. The timestamp format may depend on the value of the S_TIME_FORMAT environment variable (see below).
- -V
- Print version number then exit.
- -x
- Display extended statistics. This option works with post 2.5 kernels since it needs /proc/diskstats file or a mounted sysfs to get the statistics. This option may also work with older kernels (e.g. 2.4) only if extended statistics are available in /proc/partitions (the kernel needs to be patched for that).
- -z
-
Tell iostat to omit output for any devices for which there was no activity
during the sample period.
ENVIRONMENT
The iostat command takes into account the following environment variable:
- S_TIME_FORMAT
-
If this variable exists and its value is
ISO
then the current locale will be ignored when printing the date in the report
header. The
iostat
command will use the ISO 8601 format (YYYY-MM-DD) instead.
The timestamp displayed with option -t will also be compliant with ISO 8601
format.
EXAMPLES
iostat-
Display a single history since boot report for all CPU and Devices.
-
Display a continuous device report at two second intervals.
-
Display six reports at two second intervals for all devices.
-
Display six reports of extended statistics at two second intervals for devices
hda and hdb.
- Display six reports at two second intervals for device sda and all its partitions (sda1, etc.)
BUGS
/proc filesystem must be mounted for iostat to work.Extended statistics are available only with post 2.5 kernels.
The average service time (svctm field) value is meaningless, as I/O statistics are calculated at block level, and we don't know when the disk driver starts to process a request. For this reason, this field will be removed in a future sysstat version.
FILES
/proc/stat contains system statistics./proc/uptime contains system uptime.
/proc/partitions contains disk statistics (for pre 2.5 kernels that have been patched).
/proc/diskstats contains disks statistics (for post 2.5 kernels).
/sys contains statistics for block devices (post 2.5 kernels).
/proc/self/mountstats contains statistics for network filesystems.
AUTHOR
Sebastien Godard (sysstat <at> orange.fr)SEE ALSO
sar(1), pidstat(1), mpstat(1), vmstat(8)http://pagesperso-orange.fr/sebastien.godard/
Index
This document was created by man2html, using the manual pages.
Time: 05:29:05 GMT, December 24, 2015


| azure {covr} | R Documentation |
Run covr on a package and output the result so it is available on Azure Pipelines
azure( ..., coverage = package_coverage(..., quiet = quiet), filename = "coverage.xml", quiet = TRUE )
... |
arguments passed to |
coverage |
an existing coverage object to submit, if |
filename |
the name of the Cobertura XML file |
quiet |
if |


---
layout: default
title: Punctuation and Capitals in Quotations
---
Punctuation and Capitals in Quotations
If the speech tag is before the quote...
Add a comma after the speech tag and before the quotation marks, like this:
Grandmother asked JimThis is the speech tag., "Are you afraid of snakes?This is the quote."
Be sure to capitalize the first word in the quote.
Problem 1
If the speech tag is after the quote...
Ordinarily, add a comma after the quote and before the speech tag.
"I am afraid of snakesThis is the quote.," Jim told GrandmotherThis is the speech tag..
Problem 2
Don't add a comma in these cases:
if the quote is followed by a question mark...
"Are you afraid of snakes?This is the quote." Grandmother asked JimThis is the speech tag..
Problem 3
...if the quote is followed by an exclamation point...
"I am terrified of snakes!This is the quote." Jim exclaimedThis is the speech tag..
Problem 4
...or if the quote is followed by a dash.
"Then don't move your—This is the quote." Grandmother beganThis is the speech tag..
Problem 5
Now try some on your own!
Problem 6
Problem 7
Problem 8
Problem 9
Problem 10
Problem 11
Problem 12
Problem 13
If the speech tag is in the middle of the quote, things are more complicated...
We'll save those problems for another page!


OK, this isn't a project of mine but it is a project of one of my friends.
He has some nice music on his YouTube channel and is working on a solo album.
I don't know what more to say, go check his channel out if you'd like too.
YouTube Channel:
https://www.youtube.com/user/Nightcursed/videos
I just wanted to give him a shout out over here for what it's worth.


The soundhood music band was created for those who knows what music is like, and what does that means you may ask, without beating about the bush you already know our facinating music can be, This Group was created not just to showcase our talent but also to bring out the importance of music and make you Enjoy it. we are your live, and vocal friendly nei ghbourhood, a single music from us changes a lot. You just have to trust us and see how amazing we can be...
This is how the band was formed. Not so long ago, we held our music degrees in our hands and asked, "What on earth are we going to do with a music degree?" "Hey, let's form a band and see where it takes us!!" So we did. We put everything into recreating the well-known and timeless music that we grew up with. Music that everyone LOVES!
If you want to hear Top 40 popular music, you simply turn on the radio. But if you want to see the Classics and classicals done right, there is no other band but The soundhood! We present to you nothing but what your would ever ask for, we are so confident because surely produce the best and no exaggeration.
Our band members met in music school, where most of them studied Jazz. The band currently consists of Jane Christopher (lead vocals), Mary Schmedtmann (lead vocals), Sammy Avery (trumpet), Peter white (tenor sax), Eric Christiansen (baritone sax), Jason smith (keyboards), Jeff janes(guitar), Joseph Smart (bass) and Micheal Savor (drums).
Since 2015, the Phonix have always enjoyed performing their covers of classic 70’s soul tunes and mixing in their own originals whenever they could. Five years experience as a house band has gifted them with flashy choreography, captivating stage with and an ability to sustain a high energy, exciting and engaging performance. Their infectious energy has affected a lot of humble audience.
Soundhood is just awesome! I just launched a startup which leaves me with no time for dancing, so soundhood is a life-saver. Now that I got used to it, I couldn't live without my daily stream! Alberto Duncan
Inexpensive, stunning and great-music they produce, delivered right to you at their own expence. We have lots music band here and there, but no one comes even close to soundhood. Joana Silva
I was looking for a the best and easy to Access band in San Franciso. I tried a lot of them and ended up with soundhood. Best music band in the Bay Area. Keep up the great work! Milton Chapman
Contact us for your wedding or event entataiment, We"d love to hear from you, call us: 4028-3829-38929 email: thesoundhood@gmail.com


Fair Exchange System
New Exchange
(current)
Transactions
Inbound
Outbound
About
LogOut
Start a new Exchange
Reciver
User Email
Choose User...
Document
Document for exchange
Choose file...
Upload
EOO Signature
EOO(Evidence Of Original) Signature
Generate
You can click
Generate
button to automatically generate EOO signature from the document you uploaded or override this filed with your own signature text.
Start Exchange
New Exchange
×
Do you confirm to start a new exchange Transaction to
with document
?
Success
×
Transaction Started.


unit graphics
Unit to handle HiRes bitmap graphics, proportional fonts
author: Tomasz Biela (Tebe)
Constants:
name:
value:
description:
bmOra
0
bmAnd
1
bmXor
2
// bsSolid
0
// bsClear
1
tMode: array [0..2] of byte
($11,$31,$51)
ora, and, eor
tpix: array [0..7] of byte
($80,$40,$20,$10,$08,$04,$02,$01)


Adrien Devresse1, Omar Awile1, Jorge Blanco1, Tristan Carel1, Nicolas Cornu1, Tom de Geus2, Luc Grosheintz-Laval1, Pramod Kumbhar1, Fernando Pereira1, Sergio Rivas Gomez1, Matthias Wolf1, James King1
1 Blue Brain Project, École Polytechnique Fédérale de Lausanne, Switzerland
2 Physics of Complex Systems Laboratory, École Polytechnique Fédérale de Lausanne,
Switzerland
The use of portable scientific data formats are vital for managing complex workflows, reliable data storage, knowledge transfer, and long-term maintainability and reproducibility. Hierarchical Data Format (HDF) 5 is considered the de-facto industry-standard for this purpose. While the official HDF5 library is versatile and well supported, it only provides a low-level C/C++ interface. Lacking proper high-level C++ abstractions dissuades the use of HDF5 in scientific applications. There are a number of C++ wrapper libraries available. Many, however, are domain-specific, incomplete or not actively maintained.
HighFive is an attempt to address these challenges.
It is an easy to use modern C++ header-only library that reduces most of the book-keeping overhead required by HDF5. HighFive uses RAII to handle object life-times and automatically handles reference counting on HDF5 objects. The library makes use of C++ templating for automatic type mapping. These features significantly increase programmer productivity and reduce coding bugs.
| HighFive | HDF5 |
|
|
|
Its simplified data-management does not come at a loss of HDF5's flexibility and advanced features and tunable parameters are exposed through a simple interface. File version bounds can be read and written to define object compatibility, the metadata block size can be set. Group properties for compression, chunking and link info estimates can be set and read:
HighFive is built with scientific applications in mind. Besides scalar and simple STL
vectors it is possible to map C++ structs to HDF5 compound types and to read and write
Boost, Boost ublas, Eigen and XTensor array types. The library is also able to handle
combinations of array types (e.g. std::vector<Eigen::Matrix>
). This is
achieved through various templated converters. Additionally, HighFive supports enums and
various string types.
With the aim to support large-scale scientific application, we have made an effort to
also natively support the HDF5 MPI backend in HighFive. A special
MPIOFileDriver
is used in the application code to ensure that HDF5 is correctly
initialized. No other special API calls are required since all necessary provisions are
handled transparently.
HighFive also offers the H5Easy API (on its own namespace). This has an API in which things can be done in one-liners, with a syntax comparable to for example h5py for Python. It offers overloads for STL containers, Boost, Eigen, xtensor, and OpenCV.
| H5Easy | h5py |
|
|
|
HighFive is developed open-source and can be cloned and forked from
GitHub.
It can also be installed from the clone,
via spack,
or via conda.
It can then be used for example with find_package(HighFive)
in CMake.
Being a header-only library, HighFive can be used directly as a subfolder in a C++ project,
for example by adding it as a submodule.
More details can be found in the
README.md file.


<%- include('base.html'); %>
Explore Districts
NorthWest
Inner Richmond
Central Richmond
Outer Richmond
North
Marina
Cow Hollow
Pacific Heights
NorthEast
Chinatown
Nob Hill
North Beach
Russian Hill
Central West
Central Sunset
Outer Sunset
Outer Parkside
Central
Haight Ashbury
Hayes Valley
West Addition
East
SOMA
South Beach
SouthWest
ParkMerced
Twin Peaks
Lakeshore
West
Castro
Glen Park
Noe Valley
SouthEast
Mission
Bernal Heights
Central East
Bay View
Hunters Point
Potrero Hill
South
Excelsior
Ocean View
Ingleside
Vistacion Valley
×
Great for:
Not Great for:


Legal Disclosure
Information in accordance with Section 5 TMG .
Contact information
Andreas Lennartz
Landsberger Str. 216B
12623 Berlin
Germany
Phone: +49<PHONE_NUMBER>1
E-Mail<EMAIL_ADDRESS>Internet address: www.etlbox.net
Disclaimer
Accountability for content
The contents of our pages have been created with the utmost care. However, we cannot guarantee the contents' accuracy, completeness or topicality. According to statutory provisions, we are furthermore responsible for our own content on these web pages. In this matter, please note that we are not obliged to monitor the transmitted or saved information of third parties, or investigate circumstances pointing to illegal activity. Our obligations to remove or block the use of information under generally applicable laws remain unaffected by this as per §§ 8 to 10 of the Telemedia Act (TMG).
Accountability for links
Responsibility for the content of external links (to web pages of third parties) lies solely with the operators of the linked pages. No violations were evident to us at the time of linking. Should any legal infringement become known to us, we will remove the respective link immediately.
Software licence
The software "ETLBox" described on this website is licensed with the MIT license. See the full license here.
MIT License
Copyright (c) 2018 to Andreas Lennartz
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.


This document tries to clarify why certain design choices were made in the Lobster language and system.
NOTE: this may be a little out of date. Lobster has evolved a lot since I wrote this.
The most important over-arching reason behind everything in Lobster was to make it a pleasant language to use for one single person: me, the author. I’ve designed a fair number of languages in the past that had a particular goal or should appeal to a particular target group, or were even commercial. Lobster is not such a language.
Unlike past work, its goal from the start wasn’t to try to appeal to anyone in particular. If you happen to like Lobster, then congratulations, your taste in programming is probably similar to mine.
Besides being useful to me, creating Lobster in itself was merely meant to be a fun project. I love creating programming languages, but there’s really no money in it, and generally to most people new programming languages are not desirable things, which is what had stopped me for a while creating any more of them. Lobster was the “screw it, I am making one because it’s fun” project. That, and I had some new ideas about some subtle features that would make a language suitable for my style of programming (heavily refactoring-based).
A popular / mainstream language. For that, I’ve made far too many peculiar choices already, in particular in relation to its syntax (very terse, not C based) and it’s semantics (more functional than OO).
A beginner friendly system.
The language: to use Lobster where it shines, you need to get very familiar with higher order functions for example.
Its engine, while friendly for simple drawing, generally gives you a lot of control (immediate mode rendering), and requires you to understand the rendering pipeline moreso than simple retained mode object systems (e.g. Flash). If you create more complex games with it, be prepared to program your own “scenegraph” on top of Lobster’s low level drawing primitives.
It contains no game editor or friendly IDE. Everything is code.
A language for large scale / team programming. Its type system favors expressive power over building interfaces. It’s best used for small to medium sized projects by programmers that know what they’re doing.
A language that is all things to all people. While I would claim that Lobster is a general purpose programming language, it is strongly biased toward game programming and related fields. With a different set of built-in functions I am sure it would make a kick-ass server language, but I don’t feel it is important to serve every niche.
A language design motivated by refactoring and compositionality. It should be easier than in most languages to rip arbitrary pieces of code out and reorganize them and make them reusable, to keep the program non-redundant. Lobster’s free variables ensure that your code keeps doing what it did before it was moved without needing to create tons of function arguments. They allow your new functionality to be as local as possible, and look just as terse as any built-in abstractions when using function value arguments. I am fanatic about well-factored code, so the design reflects my thinking on how give the programmer maximum refactoring fluidity.
A language that has some goodies built-in that streamline code typical in games, for example almost everything can operate on vectors of numbers (2D, 3D, 4D).
A language inspired more by functional programming than by object oriented programming. Lobster is of course an imperative language first: games are full of global state, and I believe that the most natural way to express that is directly, rather than indirectly by emulating state (such as with monads). That said, any program benefits from trying to write as much code as possible in a purely functional style, i.e. if it is easy to express something in terms of re-generating data instead of modifying it in place, you almost always should. Lobster has some very strong tools to make this possible, with a very terse and uniform higher order function call syntax, and optionally immutable objects. Lobster actually has very powerful object oriented features (its overloading and dynamic dispatch being more expressive than in most OO languages), but it doesn’t push it’s OO angle to the forefront, and unlike OO languages doesn’t have an object heavy API. While OO brought us many important ideas in programming, it is also single-handedly responsible for the crippling over-engineering culture so prevalent nowadays, and Lobster is trying to go the opposite direction.
A type system that tries to get as close to the experience of using a dynamically typed language as possible while allowing maximum efficiency.
A language that tries to be very efficient with memory, thanks to compile time reference counting, inline structs, and a very fast allocator.
The belief that the ideal programming language is… TWO programming languages. Any larger project consists of a lot of high level and glue code that is infrequently executed and benefits from the simple and terse notation of a language like Lobster. However, any non trivial project (especially in games) also contains a few algorithms where complete control of memory layout and native code is desirable, and for that, there really is only one viable language, namely C++. Having access to both languages in a single project gives the most options for creating a fast, high quality result in reasonable time. Importantly, past systems/engines have not realized this potential because they make C++ the dominant language that is responsible for all the glue code, thus reducing the utility of the scripting language and complicating the overal project. Lobster instead wants Lobster code to be the main program, and relegate C++ to implement small libraries of speed sensitive code.
An engine that adheres to make simple things simple, and complex things possible. It requires very little code to start drawing, yet the system doesn’t make any assumptions about what kind of thing you might want to program, and how you want to structure it.
A portable, cross platform system, targeting desktop and mobile OSes alike.
An implementation that cares about simplicity, speed, and robustness.
Lobster development started in October of 2010.
Unlike code, normally a programming language design is so intricate, you benefit from designing almost all of it up-front, before you write the first line of code. Lobster wasn’t designed like that, it’s design was constantly refactored much like it’s implementation. In fact, normally the first thing I write before I start writing a parser is the grammar, but Lobster’s grammer was instead derived from the parser code. Because initially it was simply a platform for fun and experimenation of language features, it started out very different, both in syntax and semantics.
Lobster started out fully dynamically scoped.  I found out very quickly they are not whiners and reverted to default lexical scoping.
My other early experiment was a complete implementation of Icon-style backtracking. For example, you could write things like:
print #3 < 2 | #3 * 2
which would print 0 1 0 2 4
. In short, whereas in most
programming language an expression returns exactly 1 result, in Icon an
EarlyLobster it would 0..N results. #
was an iteration
operator that would generate values much like for
does
nowadays, and |
would simply concatenate streams of values.
The concept of something being false just meant no values were
generated, i.e. the <
operator returns 0 or 1 results
(the lhs). This backtracking would even work across function
definitions.
If that sounds complicated, it is certainly hard to get right, though it was helped by the fanastic paper The Implementation of Generators and Goal-Directed-Evaluation in Icon by Janalee O’Bagy whose implementation technique I followed closely.
Sadly, though examples like the above look super terse and very
powerful, more general examples turned out less readable, less general,
and not much shorter than the equivalent code using higher order
functions, which is when I got inspired to instead focus on making
higher order functions terser and more similar to built-iteration, and
make sure they have the same shortcutting power as backtracking (using
Lobster’s cross-function return
). I ripped out all
backtracking code at this point. I still have a copy of the last version
that has this functionality in, which at some point I can release if
there’s interest.
Syntax wise, EarlyLobster had a more haskell-y / smalltalk-y bracketed syntax. See for example:
factorial: [ n => 1 > n | (factorial n - 1) * n ]
print "factorial of 7: " + (factorial 7)
Function blocks were []
, and lists were {}
.
One of the first changes I made post EarlyLobster was to switch those
two, and make function calls more C-style, as I had to admit I found I
liked that better anyway, and made it easier to have function blocks
follow the function call instead of being inside of it. Then I noticed I
could denote function blocks entirely without brackets and just with
indentation, and those were removed too.
The implementation still had the C-stack based function calling implied by the abovementioned paper, which now wasn’t necessary anymore, and Lobster switched to a more traditional VM stack.
Later, multi-methods, and more recently, coroutines, got added.
Most recently, Lobster transitioned from being a dynamically typed
language to a statically typed language. I prefer programming using
dynamic typing, but I had an idea how I could use specialization in
combination with type inference and flow-sensitive typing to get very
far in being able to type-check all existing Lobster code without having
to litter it with types. That challenge took it much further than I
anticipated. The end result is impressively powerful, even though I made
it a bit more strict than I planned (i.e. making nil
its
own type). More here: type system.
Another big change is moving to compile-time reference counts (lifetime analysis) and in-line structs, about which you can read more in memory management.
This signals the move of Lobster to a more efficiency/strong typing oriented language. Strongly typed enums and bools got added, and multi-methods got replaced by a very flexible overloading / dispatching system. See the language reference.
In July 2020, co-routines were removed, along with the lesser known
“frame log” feature. A full explanation of why is here The
summary: it is a feature that seems very attractive for game
programming, but in practice never got used (and in most cases works
just as well with classes), and they put a big complexity strain on the
implementation that makes it harder to make the language faster. The
last version of the language that does contain co-routines is marked
with the label last_coroutine
in git, and the diff showing
exactly what was all removed (and thus gives a good picture on how it
used to work) is here.
Similarly, the last version that has frame log functionality is
last_frame_log
and the diff is here
I’ve collected many random scribbles about what I think Lobster still
needs in dev/TODO.txt
.


A B C G S
All Classes All Packages
All Classes All Packages
All Classes All Packages
A
- ASQLSpigotScheduler<T extends org.bukkit.plugin.java.JavaPlugin> - Class in com.glyart.asql.spigot
-
Represents a task scheduling behavior through a Spigot Context.
- ASQLSpigotScheduler() - Constructor for class com.glyart.asql.spigot.ASQLSpigotScheduler
- async(Runnable) - Method in class com.glyart.asql.spigot.ASQLSpigotScheduler
- async(Runnable, long, long) - Method in class com.glyart.asql.spigot.ASQLSpigotScheduler
B
- build() - Method in class com.glyart.asql.spigot.SpigotASQLContext.ContextBuilder
-
Builds a new SpigotASQLContext.
- builder() - Static method in class com.glyart.asql.spigot.SpigotASQLContext
C
- com.glyart.asql.spigot - package com.glyart.asql.spigot
G
- getDataSourceHandler() - Method in class com.glyart.asql.spigot.SpigotASQLContext
- getDataTemplate() - Method in class com.glyart.asql.spigot.SpigotASQLContext
- getLogger() - Method in class com.glyart.asql.spigot.SpigotASQLContext
- getPlugin() - Method in class com.glyart.asql.spigot.SpigotASQLContext
- getScheduler() - Method in class com.glyart.asql.spigot.SpigotASQLContext
S
- setCredentials(DataSourceCredentials) - Method in class com.glyart.asql.spigot.SpigotASQLContext.ContextBuilder
-
Sets the given credentials for connecting to a data source.
- setDatabaseHandler(DataSourceHandler) - Method in class com.glyart.asql.spigot.SpigotASQLContext.ContextBuilder
-
Sets the handler for the data source interaction.
- setPlugin(JavaPlugin) - Method in class com.glyart.asql.spigot.SpigotASQLContext.ContextBuilder
-
Sets the JavaPlugin which created this SpigotASQLContext.
- SpigotASQLContext - Class in com.glyart.asql.spigot
-
Represents a modelled ASQLContext inside a Spigot Context.
- SpigotASQLContext(JavaPlugin, DataSourceCredentials, DataSourceHandler) - Constructor for class com.glyart.asql.spigot.SpigotASQLContext
- SpigotASQLContext.ContextBuilder - Class in com.glyart.asql.spigot
- sync(Runnable) - Method in class com.glyart.asql.spigot.ASQLSpigotScheduler
- sync(Runnable, long, long) - Method in class com.glyart.asql.spigot.ASQLSpigotScheduler
All Classes All Packages


Foxylicious 0.2 is now available.
This version adds two new features:
- Daily automatic updates
Foxylicious periodically checks to see if a new day has dawned since
the last update. If it's a brand new day, an update will run
automatically. This is off by default, and can be enabled via the
Foxylicious settings page under the Tools menu.
- Folder-based sub-categorization by a user-specified delimiter.
How's that for a feature name! Here's an example: If you
sub-categorize your delicious tags using a dot syntax (windows.iis,
windows.monopoly, windows.bsod), you can specify the dot as your
delimiter, and Foxylicious will create subfolders for each
sub-categorized tag! I've tested this up to 4 levels deep, and had no
problems. THEORETICALLY, you should be able to create hierarchies as
deep as whatever FF's maximum supported folder depth is (ie:
cosmos.milky-way.solar-sytem.earth.primate.human.female.secretary.tickle-fetish
- you get the picture).
Remember: This extension is only 2/10 of the way to 1.0, so if you
find any bugs, please report them to me (politely) and I'll
incorporate the fix into the next release.
http://dietrich.ganx4.com/foxylicious/
ENJOI.