|
| void | rt_fs_conf_init (rt_fs_conf_t *conf) |
| | Initialize a file-system configuration with default values. More...
|
| |
| rt_fs_t * | rt_fs_mount (const char *dev_name, rt_fs_conf_t *conf, rt_event_t *event) |
| | Mount a file-system. More...
|
| |
| void | rt_fs_unmount (rt_fs_t *handle, rt_event_t *event) |
| | Unmount a mounted file-system. More...
|
| |
| rt_file_t * | rt_fs_open (rt_fs_t *fs, const char *file, int flags, rt_event_t *event) |
| | Open a file. More...
|
| |
| void | rt_fs_close (rt_file_t *file, rt_event_t *event) |
| | Close a file. More...
|
| |
| int | rt_fs_read (rt_file_t *file, void *buffer, size_t size, rt_event_t *event) |
| | Read data from a file. More...
|
| |
| int | rt_fs_direct_read (rt_file_t *file, void *buffer, size_t size, rt_event_t *event) |
| | Read data from a file with no intermediate cache. More...
|
| |
| int | rt_fs_seek (rt_file_t *file, unsigned int offset) |
| | Reposition the current file position. More...
|
| |
| static void | rt_fs_cluster_read (rt_file_t *file, void *buffer, size_t size, rt_fs_req_t *req) |
| | Read data from a file from cluster side. More...
|
| |
| static void | rt_fs_cluster_direct_read (rt_file_t *file, void *buffer, size_t size, rt_fs_req_t *req) |
| | Read data from a file with no intermediate cache from cluster side. More...
|
| |
| static void | rt_fs_cluster_seek (rt_file_t *file, unsigned int offset, rt_fs_req_t *req) |
| | Reposition the current file position from cluster side. More...
|
| |
| static int | rt_fs_cluster_wait (rt_fs_req_t *req) |
| | Wait until the specified fs request has finished. More...
|
| |
The file-system driver provides support for accessing files on a flash. The following file-systems are available:
- Read-only file system. This file-system is very basic but quite-convenient to have access to input data. The open operation does not scale well when having lots of file so this file-system should only be used with few files.
◆ rt_fs_error_e
This is used to report errors related to file-system operations.
| Enumerator |
|---|
| RT_FS_MOUNT_FLASH_ERROR | There was an error mounting the flash filesystem.
|
| RT_FS_MOUNT_MEM_ERROR | There was an error allocating memory when mounting the file-system.
|
◆ rt_fs_type_e
This can be used to select the type of file-system to mount.
| Enumerator |
|---|
| RT_FS_READ_ONLY | Read-only file system.
|
◆ rt_fs_close()
| void rt_fs_close |
( |
rt_file_t * |
file, |
|
|
rt_event_t * |
event |
|
) |
| |
This function can be called to close an opened file once it is not needed anymore in order to free the allocated resources. This operation is asynchronous and its termination can be managed through an event. This can only be called on the fabric-controller.
- Parameters
-
| file | The handle of the file to be closed. |
| event | The event used for managing termination. |
◆ rt_fs_cluster_direct_read()
| static void rt_fs_cluster_direct_read |
( |
rt_file_t * |
file, |
|
|
void * |
buffer, |
|
|
size_t |
size, |
|
|
rt_fs_req_t * |
req |
|
) |
| |
|
inlinestatic |
This function implements the same feature as rt_fs_direct_read but can be called from cluster side in order to expose the feature on the cluster. This function can be called to read data from an opened file. The data is read from the current position which is the beginning of the file when the file is opened. The current position is incremented by the number of bytes read by the call to this function. This operation is asynchronous and its termination can be managed through an event. Can only be called from cluster side. Compared to rt_fs_direct_read, this function does direct read transfers from the flash. So the flash address and the size of the transfer can have some constraints depending on the flash.
- Parameters
-
| file | The handle of the file where to read data. |
| buffer | The memory location where the read data must be copied. |
| size | The size in bytes to read from the file. |
| req | The request structure used for termination. |
◆ rt_fs_cluster_read()
| static void rt_fs_cluster_read |
( |
rt_file_t * |
file, |
|
|
void * |
buffer, |
|
|
size_t |
size, |
|
|
rt_fs_req_t * |
req |
|
) |
| |
|
inlinestatic |
This function implements the same feature as rt_fs_read but can be called from cluster side in order to expose the feature on the cluster. This function can be called to read data from an opened file. The data is read from the current position which is the beginning of the file when the file is opened. The current position is incremented by the number of bytes read by the call to this function. This operation is asynchronous and its termination is managed through the request structure. This can only be called on the cluster. Compared to rt_fs_direct_read, this functions can use intermediate transfers to support any alignment constraint from the flash. So it can be slower in case part of the transfer has to be emulated. The only difference compared to rt_fs_read is that the file position is automatically set to 0 for the next transfer if the current transfer reaches the end of the file.
- Parameters
-
| file | The handle of the file where to read data. |
| buffer | The memory location where the read data must be copied. |
| size | The size in bytes to read from the file. |
| req | The request structure used for termination. |
◆ rt_fs_cluster_seek()
| static void rt_fs_cluster_seek |
( |
rt_file_t * |
file, |
|
|
unsigned int |
offset, |
|
|
rt_fs_req_t * |
req |
|
) |
| |
|
inlinestatic |
This function can be called from cluster side to change the current position of a file. Note that this does not affect pending copies, but only the ones which will be enqueued after this call.
- Parameters
-
| file | The handle of the file for which the current position is changed. |
| offset | The offset where to set the current position. The offset can be between 0 for the beginning of the file and the file size. |
| req | The request structure used for termination. |
◆ rt_fs_cluster_wait()
| static int rt_fs_cluster_wait |
( |
rt_fs_req_t * |
req | ) |
|
|
inlinestatic |
This blocks the calling core until the specified cluster remote copy is finished. As the remote copy is asynchronous, this also gives the number of bytes which was read. Can only be called from cluster side.
- Parameters
-
| req | The request structure used for termination. |
- Returns
- The number of bytes actually read from the file. This can be smaller than the requested size if the end of file is reached. Could be also RT_STATUS_OK if the rt_fs_cluster_seek was successful, RT_STATUS_ERR otherwise.
◆ rt_fs_conf_init()
The structure containing the configuration must be kept allocated until the file-system is mounted. This can only be called on the fabric-controller.
- Parameters
-
| conf | A pointer to the file-system configuration. |
◆ rt_fs_direct_read()
| int rt_fs_direct_read |
( |
rt_file_t * |
file, |
|
|
void * |
buffer, |
|
|
size_t |
size, |
|
|
rt_event_t * |
event |
|
) |
| |
This function can be called to read data from an opened file. The data is read from the current position which is the beginning of the file when the file is opened. The current position is incremented by the number of bytes read by the call to this function. This operation is asynchronous and its termination can be managed through an event. This can only be called on the fabric-controller. Compared to rt_fs_read, this function does direct read transfers from the flash. So the flash address and the size of the transfer can have some constraints depending on the flash.
- Parameters
-
| file | The handle of the file where to read data. |
| buffer | The memory location where the read data must be copied. |
| size | The size in bytes to read from the file. |
| event | The event used for managing termination. |
- Returns
- The number of bytes actually read from the file. This can be smaller than the requested size if the end of file is reached.
◆ rt_fs_mount()
| rt_fs_t* rt_fs_mount |
( |
const char * |
dev_name, |
|
|
rt_fs_conf_t * |
conf, |
|
|
rt_event_t * |
event |
|
) |
| |
This function must be called before the file-system is used. It will do all necessary configuration and return a handle used to refer to this file-system when calling other functions. This operation is asynchronous and its termination can be managed through an event. This can only be called on the fabric-controller.
- Parameters
-
| dev_name | The device name where the file-system must be mounted. This name should correspond to the one used to configure the devices managed by the runtime. The data pointed by this pointer variable must be kept valid until the file-system is mounted. |
| conf | A pointer to the file-system configuration. Can be NULL to take default configuration. |
| event | The event used for managing termination. |
- Returns
- NULL if the device is not found, or a handle identifying the file-system and which can be used with other functions.
◆ rt_fs_open()
| rt_file_t* rt_fs_open |
( |
rt_fs_t * |
fs, |
|
|
const char * |
file, |
|
|
int |
flags, |
|
|
rt_event_t * |
event |
|
) |
| |
This function can be called to open a file on a file-system in order to read or write data to it. This operation is asynchronous and its termination can be managed through an event. This can only be called on the fabric-controller.
- Parameters
-
| fs | The handle of the file-system which was returned when the file-system was mounted. |
| file | The path to the file to be opened. |
| flags | Optional flags to configure how the file is opened. |
| event | The event used for managing termination. |
- Returns
- NULL if the file is not found, or a handle identifying the file which can be used with other functions.
◆ rt_fs_read()
| int rt_fs_read |
( |
rt_file_t * |
file, |
|
|
void * |
buffer, |
|
|
size_t |
size, |
|
|
rt_event_t * |
event |
|
) |
| |
This function can be called to read data from an opened file. The data is read from the current position which is the beginning of the file when the file is opened. The current position is incremented by the number of bytes read by the call to this function. This operation is asynchronous and its termination can be managed through an event. This can only be called on the fabric-controller. Compared to rt_fs_direct_read, this functions can use intermediate transfers to support any alignment constraint from the flash. So it can be slower in case part of the transfer has to be emulated.
- Parameters
-
| file | The handle of the file where to read data. |
| buffer | The memory location where the read data must be copied. |
| size | The size in bytes to read from the file. |
| event | The event used for managing termination. |
- Returns
- The number of bytes actually read from the file. This can be smaller than the requested size if the end of file is reached.
◆ rt_fs_seek()
| int rt_fs_seek |
( |
rt_file_t * |
file, |
|
|
unsigned int |
offset |
|
) |
| |
This function can be called to change the current position of a file. Note that this does not affect pending copies, but only the ones which will be enqueued after this call. This can only be called on the fabric-controller.
- Parameters
-
| file | The handle of the file for which the current position is changed. |
| offset | The offset where to set the current position. The offset can be between 0 for the beginning of the file and the file size. |
- Returns
- RT_STATUS_OK if the operation was successful, RT_STATUS_ERR otherwise.
◆ rt_fs_unmount()
| void rt_fs_unmount |
( |
rt_fs_t * |
handle, |
|
|
rt_event_t * |
event |
|
) |
| |
This function can be called to close a mounted file-system once it is not needed anymore, in order to free all allocated resources. Once this function is called, the file-system is not accessible anymore and must be mounted again before being used. This operation is asynchronous and its termination can be managed through an event. This can only be called on the fabric-controller.
- Parameters
-
| handle | The handle of the file-system which was returned when the file-system was mounted. |
| event | The event used for managing termination. |


Your Fashion and Style destination.
Copyright ©2018
<EMAIL_ADDRESS>This is Hadiyya, the CEO of Hadys fashion. I am a young and compassionate lady who believes in goodlooking.
Copyright ©2018
<EMAIL_ADDRESS>Looking good is a necessity especially in the corporate world. We as a company have done your research needs and now have provided you with your needs.


Constructor
new phaserControls(scene, pluginManager)
Parameters:
| Name | Type | Description |
|---|---|---|
scene |
Phaser.Scene | The Scene the phaserControls will be created in (this) |
pluginManager |
Phaser.pluginManager | Phaser plugin manager |
- Source:
Extends
- Phaser.Plugins.ScenePlugin
Members
(static) inputArray
Holds all inputs recorded with phaserControls.recordKeys
- Since:
- 1.5.0
- Source:
(static) keys :Object
Stores the keyboard keys that have been created from a control scheme
Type:
- Object
- Since:
- 1.0.0
- Source:
(static) scene :Object
Get 'this' from scene
Type:
- Object
- Since:
- 1.0.0
- Source:
(static) schemes :Array
Holds all the control schemes in an array
Type:
- Array
- Since:
- 1.0.0
- Source:
Methods
(static) add(config) → {function}
Add new control scheme and switch to the new scheme if it's set to 'active'
Parameters:
| Name | Type | Description |
|---|---|---|
config |
object | A new scheme config to be added to the schemes array |
- Since:
- 1.0.0
- Source:
Returns:
- Type
- function
(static) addMultiple(array) → {function}
Adds an array of multiple control scheme objects into the schemes array
Useful if saving the controls with localStorage
Useful if saving the controls with localStorage
Parameters:
| Name | Type | Description |
|---|---|---|
array |
Array | An array of control scheme objects |
- Since:
- 1.0.0
- Source:
Returns:
- Type
- function
(static) createCombo(scheme) → {function|Object}
Create a key combo
Add a combo scheme globally or only when using a specific control scheme
Parameters:
| Name | Type | Description |
|---|---|---|
scheme |
Object | combo scheme config to pass into the keyboard manager |
- Since:
- 1.3.0
- Source:
Returns:
-
- Type
- function
-
returns the combo object so you can edit/delete when needed
- Type
- Object
(static) createCursorKeys(activeopt, addopt, data, onActiveFunc) → {function}
Create default cursor keys.
The difference between this.input.keyboard.createCursorKeys(); and phaserControls.createCursorKeys();
is that the phaserControls will be added to the control scheme array with other created control schemes.
Parameters:
| Name | Type | Attributes | Default | Description |
|---|---|---|---|---|
active |
boolean |
<optional> |
false | If the cursor keys should be used, overiding current scheme |
add |
boolean |
<optional> |
true | add the default cursor keys to the schemes list |
data |
object | optional data to pass into the control scheme | ||
onActiveFunc |
function | optional function to call whenever this control scheme is set to active |
- Since:
- 1.0.0
- Source:
Returns:
- Type
- function
(static) createKonamiCode(onMatch) → {function|Object}
Create the Konami Code (up,up,down,down,left,right,left,right,b,a)
Parameters:
| Name | Type | Description |
|---|---|---|
onMatch |
function | function to call when konami code has been entered |
- Since:
- 1.3.0
- Source:
Returns:
-
- Type
- function
-
returns the konami combo object
- Type
- Object
(static) createWasdKeys(activeopt, addopt, data, onActiveFunc) → {function}
Create default wasd keys. The same approach as phaserControls.createCursorKeys but using WASD instead.
Parameters:
| Name | Type | Attributes | Default | Description |
|---|---|---|---|---|
active |
boolean |
<optional> |
false | If the wasd keys should be used, overiding current scheme |
add |
boolean |
<optional> |
true | add the default wasd keys to the schemes list |
data |
object | optional data to pass into the control scheme | ||
onActiveFunc |
function | optional function to call whenever this control scheme is set to active |
- Since:
- 1.0.0
- Source:
Returns:
- Type
- function
(static) debugText(x, y, fontsize, color) → {function}
Debug text displaying current control scheme thats being used.
Click on the text to move onto the next control scheme and select it.
Parameters:
| Name | Type | Description |
|---|---|---|
x |
number | x coordinate for text display on canvas |
y |
number | y coordinate for text display on canvas |
fontsize |
number | Fontsize to display the text at. |
color |
string | font color. |
- Since:
- 1.0.0
- Source:
Returns:
- Type
- function
(static) delete(scheme, destroyopt) → {function}
Delete scheme from the schemes array and removes key and key captures
Parameters:
| Name | Type | Attributes | Default | Description |
|---|---|---|---|---|
scheme |
string | object | The scheme name to find and delete | ||
destroy |
boolean |
<optional> |
true | Removes keys and captures used by scheme (phaser version >= 3.16) |
- Since:
- 1.0.0
- Source:
Returns:
- Type
- function
(static) disableKeys() → {function}
Helper function to disable all the keys for the active control scheme
- Since:
- 1.5.0
- Source:
Returns:
- Type
- function
(static) edit(scheme, config) → {function}
Edit control scheme. This is used if you need to edit a control scheme on the front end
Parameters:
| Name | Type | Description |
|---|---|---|
scheme |
string | object | The scheme name to find and edit |
config |
Object | config to edit |
- Since:
- 1.0.0
- Source:
Returns:
- Type
- function
(static) enableKeys() → {function}
Helper function to enable all the keys for the active control scheme
- Since:
- 1.5.0
- Source:
Returns:
- Type
- function
(static) get(name, activeopt) → {function|Object}
Returns the control scheme object that matches the control scheme name
Parameters:
| Name | Type | Attributes | Default | Description |
|---|---|---|---|---|
name |
string | The name of the scheme to get and return as object | ||
active |
boolean |
<optional> |
false | if the scheme should be used, overiding current scheme |
- Since:
- 1.0.0
- Source:
Returns:
-
- Type
- function
-
The control scheme object
- Type
- Object
(static) getActive(nameopt) → {function|Object|string}
Returns the active control scheme object or name string
Parameters:
| Name | Type | Attributes | Default | Description |
|---|---|---|---|---|
name |
boolean |
<optional> |
false | If true returns only the schemes name |
- Since:
- 1.0.0
- Source:
Returns:
-
- Type
- function
-
The control scheme object or string
- Type
- Object | string
(static) getAll() → {function|Array}
returns an array with all the control schemes
- Since:
- 1.1.0
- Source:
Returns:
-
- Type
- function
-
The array containing the control schemes
- Type
- Array
(static) keyCodeToKey(keyCode) → {function|string|array}
Helper function to convert a keyCode either from phaser keyboard or from window event to the phaser key string
Parameters:
| Name | Type | Description |
|---|---|---|
keyCode |
number | array | the keyCode to convert or an array of keyCodes to convert |
- Since:
- 1.5.0
- Source:
Returns:
-
- Type
- function
-
Returns the key name or an array of key names
- Type
- string | array
(static) recordKeys() → {function|array}
record which key was pressed down, for how long and the timestamp when the key was down
- Since:
- 1.5.0
- Source:
Returns:
-
- Type
- function
-
returns the array holding the input objects
- Type
- array
(static) setActive(scheme) → {function}
Select control scheme while turning off the currently used scheme
Parameters:
| Name | Type | Description |
|---|---|---|
scheme |
string | Object | the 'name' or object of a scheme to be selected |
- Since:
- 1.0.0
- Source:
Returns:
- Type
- function
(static) switch(scheme) → {function}
Switch from one control scheme to another
Alternative way of setActive();
Parameters:
| Name | Type | Description |
|---|---|---|
scheme |
string | object | the control scheme to switch to |
- Since:
- 1.1.0
- Source:
Returns:
- Type
- function


{% include head.html %}
{% include sidebar.html %}
{{ content }}
Please enable JavaScript to view the
comments powered by Disqus.


Students campaigns achieve great success everywhere in the world, and its time we do it here. Stuff people
don't usually identify with, like HelpAge India, Smile, etc, gather huge money, we can certainly get at least
a few people to do what they are legally obligated to, and to live a quality life of peace and productivity.
Some people do listen, some people will listen, and that's all we need. Not to reach every household, but to
get a few hundred for a start, people who listen and understand, and if you can't convince many others, just
start with your home.
I ask each of you to attempt to convince parents, family, relatives, neighbours, and everyone you meet
to get water harvesting installed, we will help you planning and getting stuff done, and with some help
from all of you, we can have these systems in 100s of homes, and save so much water. The installations only
cost a couple of thousands, dig holes and start off, and they restore a lot of ground water, that is cheaply
available to both people and businesses. Everyone can afford then, everyone should, and everyone identifies
with the problems faced when we don't. Apartments have the benefit of needing even less money per person to
do this stuff, just a will to act. And if you have it, please don't let a sense of hopelessness pull you down.
Volunteer to save the planet.


{% extends "article.html" %} {% load cache cms_tags menu_tags fix_menu_tags %} {% block title %} Demand Side - Identification of companies that cover 80 percent of hiring overall, within each sub-sector, category and region ({{ analytics_year }}) {% endblock %} {% block heading %} Demand Side - Identification of companies that cover 80 percent of hiring overall, within each sub-sector, category and region ({{ analytics_year }}) {% endblock %} {% block breadcrumb %}
{% endblock %} {% block article %}


Welcome to Macerate Games
I'm sorry, but this site is still being developed.
You can see its progress on our
page!


{% macro purge_old_nuvola() %}
If you used Nuvola in the past, it is necessary to purge the old installation. Otherwise, compatibility issues may occur.
You can use following commands to find installed Nuvola packages and then remove them with dnf remove
.
dnf list --installed nuvolaruntime* nuvola-app* nuvolaplayer*
You can use following commands to remove old configuration.
rm -rf ~/.cache/nuvolaplayer3
rm -rf ~/.local/share/nuvolaplayer3 ~/.local/share/nuvolaruntime
rm -rf ~/.config/nuvolaplayer3 ~/.config/nuvolaruntime
rm -rf ~/.cache/nuvolaplayer3 ~/.cache/nuvolaruntime
rm -f ~/.local/share/applications/nuvolaplayer3*
{% endmacro %}


Autoloading and Reloading Constants
This guide documents how constant autoloading and reloading works.
After reading this guide, you will know:
- Key aspects of Ruby constants
- What is
autoload_paths
- How constant autoloading works
- What is
require_dependency
- How constant reloading works
- Solutions to common autoloading gotchas
Introduction
Ruby on Rails allows applications to be written as if their code was preloaded.
In a normal Ruby program classes need to load their dependencies:
require 'application_controller'
require 'post'
class PostsController < ApplicationController
def index
@posts = Post.all
end
end
Our Rubyist instinct quickly sees some redundancy in there: If classes were defined in files matching their name, couldn't their loading be automated somehow? We could save scanning the file for dependencies, which is brittle.
Moreover, Kernel#require
loads files once, but development is much more smooth
if code gets refreshed when it changes without restarting the server. It would
be nice to be able to use Kernel#load
in development, and Kernel#require
in
production.
Indeed, those features are provided by Ruby on Rails, where we just write
class PostsController < ApplicationController
def index
@posts = Post.all
end
end
This guide documents how that works.
Constants Refresher
While constants are trivial in most programming languages, they are a rich topic in Ruby.
It is beyond the scope of this guide to document Ruby constants, but we are nevertheless going to highlight a few key topics. Truly grasping the following sections is instrumental to understanding constant autoloading and reloading.
Nesting
Class and module definitions can be nested to create namespaces:
module XML
class SAXParser
# (1)
end
end
The nesting at any given place is the collection of enclosing nested class and
module objects outwards. The nesting at any given place can be inspected with
Module.nesting
. For example, in the previous example, the nesting at
(1) is
[XML::SAXParser, XML]
It is important to understand that the nesting is composed of class and module objects, it has nothing to do with the constants used to access them, and is also unrelated to their names.
For instance, while this definition is similar to the previous one:
class XML::SAXParser
# (2)
end
the nesting in (2) is different:
[XML::SAXParser]
XML
does not belong to it.
We can see in this example that the name of a class or module that belongs to a certain nesting does not necessarily correlate with the namespaces at the spot.
Even more, they are totally independent, take for instance
module X
module Y
end
end
module A
module B
end
end
module X::Y
module A::B
# (3)
end
end
The nesting in (3) consists of two module objects:
[A::B, X::Y]
So, it not only doesn't end in A
, which does not even belong to the nesting,
but it also contains X::Y
, which is independent from A::B
.
The nesting is an internal stack maintained by the interpreter, and it gets modified according to these rules:
-
The class object following a
class
keyword gets pushed when its body is executed, and popped after it. -
The module object following a
module
keyword gets pushed when its body is executed, and popped after it. -
A singleton class opened with
class << object
gets pushed, and popped later. -
When
instance_eval
is called using a string argument, the singleton class of the receiver is pushed to the nesting of the eval'ed code. Whenclass_eval
ormodule_eval
is called using a string argument, the receiver is pushed to the nesting of the eval'ed code. -
The nesting at the top-level of code interpreted by
Kernel#load
is empty unless theload
call receives a true value as second argument, in which case a newly created anonymous module is pushed by Ruby.
It is interesting to observe that blocks do not modify the stack. In particular
the blocks that may be passed to Class.new
and Module.new
do not get the
class or module being defined pushed to their nesting. That's one of the
differences between defining classes and modules in one way or another.
Class and Module Definitions are Constant Assignments
Let's suppose the following snippet creates a class (rather than reopening it):
class C
end
Ruby creates a constant C
in Object and stores in that constant a class
object. The name of the class instance is "C", a string, named after the
constant.
That is,
class Project < ActiveRecord::Base
end
performs a constant assignment equivalent to
Project = Class.new(ActiveRecord::Base)
including setting the name of the class as a side-effect:
Project.name # => "Project"
Constant assignment has a special rule to make that happen: if the object being assigned is an anonymous class or module, Ruby sets the object's name to the name of the constant.
INFO. From then on, what happens to the constant and the instance does not matter. For example, the constant could be deleted, the class object could be assigned to a different constant, be stored in no constant anymore, etc. Once the name is set, it doesn't change.
Similarly, module creation using the module
keyword as in
module Admin
end
performs a constant assignment equivalent to
Admin = Module.new
including setting the name as a side-effect:
Admin.name # => "Admin"
WARNING. The execution context of a block passed to Class.new
or Module.new
is not entirely equivalent to the one of the body of the definitions using the
class
and module
keywords. But both idioms result in the same constant
assignment.
Thus, when one informally says "the String class", that really means: the class object stored in the constant called "String" in the class object stored in the Object constant. String is otherwise an ordinary Ruby constant and everything related to constants such as resolution algorithms applies to it.
Likewise, in the controller
class PostsController < ApplicationController
def index
@posts = Post.all
end
end
Post
is not syntax for a class. Rather, Post
is a regular Ruby constant. If
all is good, the constant is evaluated to an object that responds to all
.
That is why we talk about constant autoloading, Rails has the ability to load constants on the fly.
Constants are Stored in Modules
Constants belong to modules in a very literal sense. Classes and modules have a constant table; think of it as a hash table.
Let's analyze an example to really understand what that means. While common abuses of language like "the String class" are convenient, the exposition is going to be precise here for didactic purposes.
Let's consider the following module definition:
module Colors
RED = '0xff0000'
end
First, when the module
keyword is processed, the interpreter creates a new
entry in the constant table of the class object stored in the Object constant.
Said entry associates the name "Colors" to a newly created module object.
Furthermore, the interpreter sets the name of the new module object to be the
string "Colors".
Later, when the body of the module definition is interpreted, a new entry is
created in the constant table of the module object stored in the Colors
constant. That entry maps the name "RED" to the string "0xff0000".
In particular, Colors::RED
is totally unrelated to any other RED
constant
that may live in any other class or module object. If there were any, they
would have separate entries in their respective constant tables.
Pay special attention in the previous paragraphs to the distinction between class and module objects, constant names, and value objects associated to them in constant tables.
Resolution Algorithms
Resolution Algorithm for Relative Constants
At any given place in the code, let's define cref to be the first element of the nesting if it is not empty, or Object otherwise.
Without getting too much into the details, the resolution algorithm for relative constant references goes like this:
-
If the nesting is not empty the constant is looked up in its elements and in order. The ancestors of those elements are ignored.
-
If not found, then the algorithm walks up the ancestor chain of the cref.
-
If not found and the cref is a module, the constant is looked up in Object.
-
If not found,
const_missing
is invoked on the cref. The default implementation ofconst_missing
raises NameError, but it can be overridden.
Rails autoloading does not emulate this algorithm, but its starting point is the name of the constant to be autoloaded, and the cref. See more in Relative References.
Resolution Algorithm for Qualified Constants
Qualified constants look like this:
Billing::Invoice
Billing::Invoice
is composed of two constants: Billing
is relative and is
resolved using the algorithm of the previous section.
INFO. Leading colons would make the first segment absolute rather than
relative: ::Billing::Invoice
. That would force Billing
to be looked up
only as a top-level constant.
Invoice
on the other hand is qualified by Billing
and we are going to see
its resolution next. Let's define parent to be that qualifying class or module
object, that is, Billing
in the example above. The algorithm for qualified
constants goes like this:
-
The constant is looked up in the parent and its ancestors.
-
If the lookup fails,
const_missing
is invoked in the parent. The default implementation ofconst_missing
raises NameError, but it can be overridden.
As you see, this algorithm is simpler than the one for relative constants. In particular, the nesting plays no role here, and modules are not special-cased, if neither they nor their ancestors have the constants, Object is not checked.
Rails autoloading does not emulate this algorithm, but its starting point is the name of the constant to be autoloaded, and the parent. See more in Qualified References.
Vocabulary
Parent Namespaces
Given a string with a constant path we define its parent namespace to be the string that results from removing its rightmost segment.
For example, the parent namespace of the string "A::B::C" is the string "A::B", the parent namespace of "A::B" is "A", and the parent namespace of "A" is "".
The interpretation of a parent namespace when thinking about classes and modules is tricky though. Let's consider a module M named "A::B":
-
The parent namespace, "A", may not reflect nesting at a given spot.
-
The constant
A
may no longer exist, some code could have removed it from Object. -
If
A
exists, the class or module that was originally inA
may not be there anymore. For example, if after a constant removal there was another constant assignment there would generally be a different object in there. -
In such case, it could even happen that the reassigned
A
held a new class or module called also "A"! -
In the previous scenarios M would no longer be reachable through
A::B
but the module object itself could still be alive somewhere and its name would still be "A::B".
The idea of a parent namespace is at the core of the autoloading algorithms and helps explain and understand their motivation intuitively, but as you see that metaphor leaks easily. Given an edge case to reason about, take always into account that by "parent namespace" the guide means exactly that specific string derivation.
Loading Mechanism
Rails autoloads files with Kernel#load
when config.cache_classes
is false,
the default in development mode, and with Kernel#require
otherwise, the
default in production mode.
Kernel#load
allows Rails to execute files more than once if constant
reloading is enabled.
This guide uses the word "load" freely to mean a given file is interpreted, but
the actual mechanism can be Kernel#load
or Kernel#require
depending on that
flag.
Autoloading Availability
Rails is always able to autoload provided its environment is in place. For
example the runner
command autoloads:
$ bin/rails runner 'p User.column_names'
["id", "email", "created_at", "updated_at"]
The console autoloads, the test suite autoloads, and of course the application autoloads.
By default, Rails eager loads the application files when it boots in production mode, so most of the autoloading going on in development does not happen. But autoloading may still be triggered during eager loading.
For example, given
class BeachHouse < House
end
if House
is still unknown when app/models/beach_house.rb
is being eager
loaded, Rails autoloads it.
autoload_paths
As you probably know, when require
gets a relative file name:
require 'erb'
Ruby looks for the file in the directories listed in $LOAD_PATH
. That is, Ruby
iterates over all its directories and for each one of them checks whether they
have a file called "erb.rb", or "erb.so", or "erb.o", or "erb.dll". If it finds
any of them, the interpreter loads it and ends the search. Otherwise, it tries
again in the next directory of the list. If the list gets exhausted, LoadError
is raised.
We are going to cover how constant autoloading works in more detail later, but
the idea is that when a constant like Post
is hit and missing, if there's a
post.rb
file for example in app/models
Rails is going to find it, evaluate
it, and have Post
defined as a side-effect.
Alright, Rails has a collection of directories similar to $LOAD_PATH
in which
to look up post.rb
. That collection is called autoload_paths
and by
default it contains:
-
All subdirectories of
app
in the application and engines. For example,app/controllers
. They do not need to be the default ones, any custom directories likeapp/workers
belong automatically toautoload_paths
. -
Second level directories
app/{controllers,models}/concerns
in the application and engines. -
The directory
test/mailers/previews
.
Also, this collection is configurable via config.autoload_paths
. For example,
lib
was in the list years ago, but no longer is. An application can opt-in
by adding this to config/application.rb
:
config.autoload_paths << "#{Rails.root}/lib"
config.autoload_paths
is accessible from environment-specific configuration files, but any changes made to it outside config/application.rb
don't have an effect.
The value of autoload_paths
can be inspected. In a just generated application
it is (edited):
$ bin/rails r 'puts ActiveSupport::Dependencies.autoload_paths'
#.../app/assets
#.../app/controllers
#.../app/helpers
#.../app/mailers
#.../app/models
#.../app/controllers/concerns
#.../app/models/concerns
#.../test/mailers/previews
INFO. autoload_paths
is computed and cached during the initialization process.
The application needs to be restarted to reflect any changes in the directory
structure.
Autoloading Algorithms
Relative References
A relative constant reference may appear in several places, for example, in
class PostsController < ApplicationController
def index
@posts = Post.all
end
end
all three constant references are relative.
Constants after the class
and module
Keywords
Ruby performs a lookup for the constant that follows a class
or module
keyword because it needs to know if the class or module is going to be created
or reopened.
If the constant is not defined at that point it is not considered to be a missing constant, autoloading is not triggered.
So, in the previous example, if PostsController
is not defined when the file
is interpreted Rails autoloading is not going to be triggered, Ruby will just
define the controller.
Top-Level Constants
On the contrary, if ApplicationController
is unknown, the constant is
considered missing and an autoload is going to be attempted by Rails.
In order to load ApplicationController
, Rails iterates over autoload_paths
.
First checks if app/assets/application_controller.rb
exists. If it does not,
which is normally the case, it continues and finds
app/controllers/application_controller.rb
.
If the file defines the constant ApplicationController
all is fine, otherwise
LoadError is raised:
unable to autoload constant ApplicationController, expected
<full path to application_controller.rb> to define it (LoadError)
INFO. Rails does not require the value of autoloaded constants to be a class or
module object. For example, if the file app/models/max_clients.rb
defines
MAX_CLIENTS = 100
autoloading MAX_CLIENTS
works just fine.
Namespaces
Autoloading ApplicationController
looks directly under the directories of
autoload_paths
because the nesting in that spot is empty. The situation of
Post
is different, the nesting in that line is [PostsController]
and support
for namespaces comes into play.
The basic idea is that given
module Admin
class BaseController < ApplicationController
@@all_roles = Role.all
end
end
to autoload Role
we are going to check if it is defined in the current or
parent namespaces, one at a time. So, conceptually we want to try to autoload
any of
Admin::BaseController::Role
Admin::Role
Role
in that order. That's the idea. To do so, Rails looks in autoload_paths
respectively for file names like these:
admin/base_controller/role.rb
admin/role.rb
role.rb
modulus some additional directory lookups we are going to cover soon.
INFO. 'Constant::Name'.underscore
gives the relative path without extension of
the file name where Constant::Name
is expected to be defined.
Let's see how Rails autoloads the Post
constant in the PostsController
above assuming the application has a Post
model defined in
app/models/post.rb
.
First it checks for posts_controller/post.rb
in autoload_paths
:
app/assets/posts_controller/post.rb
app/controllers/posts_controller/post.rb
app/helpers/posts_controller/post.rb
#...
test/mailers/previews/posts_controller/post.rb
Since the lookup is exhausted without success, a similar search for a directory is performed, we are going to see why in the next section:
app/assets/posts_controller/post
app/controllers/posts_controller/post
app/helpers/posts_controller/post
#...
test/mailers/previews/posts_controller/post
If all those attempts fail, then Rails starts the lookup again in the parent namespace. In this case only the top-level remains:
app/assets/post.rb
app/controllers/post.rb
app/helpers/post.rb
app/mailers/post.rb
app/models/post.rb
A matching file is found in app/models/post.rb
. The lookup stops there and the
file is loaded. If the file actually defines Post
all is fine, otherwise
LoadError is raised.
Qualified References
When a qualified constant is missing Rails does not look for it in the parent namespaces. But there is a caveat: When a constant is missing, Rails is unable to tell if the trigger was a relative reference or a qualified one.
For example, consider
module Admin
User
end
and
Admin::User
If User
is missing, in either case all Rails knows is that a constant called
"User" was missing in a module called "Admin".
If there is a top-level User
Ruby would resolve it in the former example, but
wouldn't in the latter. In general, Rails does not emulate the Ruby constant
resolution algorithms, but in this case it tries using the following heuristic:
If none of the parent namespaces of the class or module has the missing constant then Rails assumes the reference is relative. Otherwise qualified.
For example, if this code triggers autoloading
Admin::User
and the User
constant is already present in Object, it is not possible that
the situation is
module Admin
User
end
because otherwise Ruby would have resolved User
and no autoloading would have
been triggered in the first place. Thus, Rails assumes a qualified reference and
considers the file admin/user.rb
and directory admin/user
to be the only
valid options.
In practice, this works quite well as long as the nesting matches all parent namespaces respectively and the constants that make the rule apply are known at that time.
However, autoloading happens on demand. If by chance the top-level User
was
not yet loaded, then Rails assumes a relative reference by contract.
Naming conflicts of this kind are rare in practice, but if one occurs,
require_dependency
provides a solution by ensuring that the constant needed
to trigger the heuristic is defined in the conflicting place.
Automatic Modules
When a module acts as a namespace, Rails does not require the application to defines a file for it, a directory matching the namespace is enough.
Suppose an application has a back office whose controllers are stored in
app/controllers/admin
. If the Admin
module is not yet loaded when
Admin::UsersController
is hit, Rails needs first to autoload the constant
Admin
.
If autoload_paths
has a file called admin.rb
Rails is going to load that
one, but if there's no such file and a directory called admin
is found, Rails
creates an empty module and assigns it to the Admin
constant on the fly.
Generic Procedure
Relative references are reported to be missing in the cref where they were hit, and qualified references are reported to be missing in their parent (see Resolution Algorithm for Relative Constants at the beginning of this guide for the definition of cref, and Resolution Algorithm for Qualified Constants for the definition of parent).
The procedure to autoload constant C
in an arbitrary situation is as follows:
if the class or module in which C is missing is Object
let ns = ''
else
let M = the class or module in which C is missing
if M is anonymous
let ns = ''
else
let ns = M.name
end
end
loop do
# Look for a regular file.
for dir in autoload_paths
if the file "#{dir}/#{ns.underscore}/c.rb" exists
load/require "#{dir}/#{ns.underscore}/c.rb"
if C is now defined
return
else
raise LoadError
end
end
end
# Look for an automatic module.
for dir in autoload_paths
if the directory "#{dir}/#{ns.underscore}/c" exists
if ns is an empty string
let C = Module.new in Object and return
else
let C = Module.new in ns.constantize and return
end
end
end
if ns is empty
# We reached the top-level without finding the constant.
raise NameError
else
if C exists in any of the parent namespaces
# Qualified constants heuristic.
raise NameError
else
# Try again in the parent namespace.
let ns = the parent namespace of ns and retry
end
end
end
require_dependency
Constant autoloading is triggered on demand and therefore code that uses a certain constant may have it already defined or may trigger an autoload. That depends on the execution path and it may vary between runs.
There are times, however, in which you want to make sure a certain constant is
known when the execution reaches some code. require_dependency
provides a way
to load a file using the current loading mechanism, and
keeping track of constants defined in that file as if they were autoloaded to
have them reloaded as needed.
require_dependency
is rarely needed, but see a couple of use-cases in
Autoloading and STI and When Constants aren't
Triggered.
WARNING. Unlike autoloading, require_dependency
does not expect the file to
define any particular constant. Exploiting this behavior would be a bad practice
though, file and constant paths should match.
Constant Reloading
When config.cache_classes
is false Rails is able to reload autoloaded
constants.
For example, in you're in a console session and edit some file behind the
scenes, the code can be reloaded with the reload!
command:
> reload!
When the application runs, code is reloaded when something relevant to this logic changes. In order to do that, Rails monitors a number of things:
-
config/routes.rb
. -
Locales.
-
Ruby files under
autoload_paths
. -
db/schema.rb
anddb/structure.sql
.
If anything in there changes, there is a middleware that detects it and reloads the code.
Autoloading keeps track of autoloaded constants. Reloading is implemented by
removing them all from their respective classes and modules using
Module#remove_const
. That way, when the code goes on, those constants are
going to be unknown again, and files reloaded on demand.
INFO. This is an all-or-nothing operation, Rails does not attempt to reload only what changed since dependencies between classes makes that really tricky. Instead, everything is wiped.
 It is quite
transparent.
Rails internals make extensive use of it to defer as much work as possible from
the boot process. But constant autoloading in Rails is not implemented with
Module#autoload
.
One possible implementation based on Module#autoload
would be to walk the
application tree and issue autoload
calls that map existing file names to
their conventional constant name.
There are a number of reasons that prevent Rails from using that implementation.
For example, Module#autoload
is only capable of loading files using require
,
so reloading would not be possible. Not only that, it uses an internal require
which is not Kernel#require
.
Then, it provides no way to remove declarations in case a file is deleted. If a
constant gets removed with Module#remove_const
its autoload
is not triggered
again. Also, it doesn't support qualified names, so files with namespaces should
be interpreted during the walk tree to install their own autoload
calls, but
those files could have constant references not yet configured.
An implementation based on Module#autoload
would be awesome but, as you see,
at least as of today it is not possible. Constant autoloading in Rails is
implemented with Module#const_missing
, and that's why it has its own contract,
documented in this guide.
Common Gotchas
Nesting and Qualified Constants
Let's consider
module Admin
class UsersController < ApplicationController
def index
@users = User.all
end
end
end
and
class Admin::UsersController < ApplicationController
def index
@users = User.all
end
end
To resolve User
Ruby checks Admin
in the former case, but it does not in
the latter because it does not belong to the nesting (see Nesting
and Resolution Algorithms).
Unfortunately Rails autoloading does not know the nesting in the spot where the
constant was missing and so it is not able to act as Ruby would. In particular,
Admin::User
will get autoloaded in either case.
Albeit qualified constants with class
and module
keywords may technically
work with autoloading in some cases, it is preferable to use relative constants
instead:
module Admin
class UsersController < ApplicationController
def index
@users = User.all
end
end
end
Autoloading and STI
Single Table Inheritance (STI) is a feature of Active Record that enables storing a hierarchy of models in one single table. The API of such models is aware of the hierarchy and encapsulates some common needs. For example, given these classes:
# app/models/polygon.rb
class Polygon < ActiveRecord::Base
end
# app/models/triangle.rb
class Triangle < Polygon
end
# app/models/rectangle.rb
class Rectangle < Polygon
end
Triangle.create
creates a row that represents a triangle, and
Rectangle.create
creates a row that represents a rectangle. If id
is the
ID of an existing record, Polygon.find(id)
returns an object of the correct
type.
Methods that operate on collections are also aware of the hierarchy. For
example, Polygon.all
returns all the records of the table, because all
rectangles and triangles are polygons. Active Record takes care of returning
instances of their corresponding class in the result set.
Types are autoloaded as needed. For example, if Polygon.first
is a rectangle
and Rectangle
has not yet been loaded, Active Record autoloads it and the
record is correctly instantiated.
All good, but if instead of performing queries based on the root class we need to work on some subclass, things get interesting.
While working with Polygon
you do not need to be aware of all its descendants,
because anything in the table is by definition a polygon, but when working with
subclasses Active Record needs to be able to enumerate the types it is looking
for. Let’s see an example.
Rectangle.all
only loads rectangles by adding a type constraint to the query:
SELECT "polygons".* FROM "polygons"
WHERE "polygons"."type" IN ("Rectangle")
Let’s introduce now a subclass of Rectangle
:
# app/models/square.rb
class Square < Rectangle
end
Rectangle.all
should now return rectangles and squares:
SELECT "polygons".* FROM "polygons"
WHERE "polygons"."type" IN ("Rectangle", "Square")
But there’s a caveat here: How does Active Record know that the class Square
exists at all?
Even if the file app/models/square.rb
exists and defines the Square
class,
if no code yet used that class, Rectangle.all
issues the query
SELECT "polygons".* FROM "polygons"
WHERE "polygons"."type" IN ("Rectangle")
That is not a bug, the query includes all known descendants of Rectangle
.
A way to ensure this works correctly regardless of the order of execution is to load the leaves of the tree by hand at the bottom of the file that defines the root class:
# app/models/polygon.rb
class Polygon < ActiveRecord::Base
end
require_dependency ‘square’
Only the leaves that are at least grandchildren need to be loaded this way. Direct subclasses do not need to be preloaded. If the hierarchy is deeper, intermediate classes will be autoloaded recursively from the bottom because their constant will appear in the class definitions as superclass.
Autoloading and require
Files defining constants to be autoloaded should never be require
d:
require 'user' # DO NOT DO THIS
class UsersController < ApplicationController
#...
end
There are two possible gotchas here in development mode:
-
If
User
is autoloaded before reaching therequire
,app/models/user.rb
runs again becauseload
does not update$LOADED_FEATURES
. -
If the
require
runs first Rails does not markUser
as an autoloaded constant and changes toapp/models/user.rb
aren't reloaded.
Just follow the flow and use constant autoloading always, never mix
autoloading and require
. As a last resort, if some file absolutely needs to
load a certain file use require_dependency
to play nice with constant
autoloading. This option is rarely needed in practice, though.
Of course, using require
in autoloaded files to load ordinary 3rd party
libraries is fine, and Rails is able to distinguish their constants, they are
not marked as autoloaded.
Autoloading and Initializers
Consider this assignment in config/initializers/set_auth_service.rb
:
AUTH_SERVICE = if Rails.env.production?
RealAuthService
else
MockedAuthService
end
The purpose of this setup would be that the application uses the class that
corresponds to the environment via AUTH_SERVICE
. In development mode
MockedAuthService
gets autoloaded when the initializer runs. Let’s suppose
we do some requests, change its implementation, and hit the application again.
To our surprise the changes are not reflected. Why?
As we saw earlier, Rails removes autoloaded constants,
but AUTH_SERVICE
stores the original class object. Stale, non-reachable
using the original constant, but perfectly functional.
The following code summarizes the situation:
class C
def quack
'quack!'
end
end
X = C
Object.instance_eval { remove_const(:C) }
X.new.quack # => quack!
X.name # => C
C # => uninitialized constant C (NameError)
Because of that, it is not a good idea to autoload constants on application initialization.
In the case above we could implement a dynamic access point:
# app/models/auth_service.rb
class AuthService
if Rails.env.production?
def self.instance
RealAuthService
end
else
def self.instance
MockedAuthService
end
end
end
and have the application use AuthService.instance
instead. AuthService
would be loaded on demand and be autoload-friendly.
require_dependency
and Initializers
As we saw before, require_dependency
loads files in an autoloading-friendly
way. Normally, though, such a call does not make sense in an initializer.
One could think about doing some require_dependency
calls in an initializer to make sure certain constants are loaded upfront, for
example as an attempt to address the gotcha with STIs.
Problem is, in development mode autoloaded constants are wiped if there is any relevant change in the file system. If that happens then we are in the very same situation the initializer wanted to avoid!
Calls to require_dependency
have to be strategically written in autoloaded
spots.
When Constants aren't Missed
Relative References
Let's consider a flight simulator. The application has a default flight model
# app/models/flight_model.rb
class FlightModel
end
that can be overridden by each airplane, for instance
# app/models/bell_x1/flight_model.rb
module BellX1
class FlightModel < FlightModel
end
end
# app/models/bell_x1/aircraft.rb
module BellX1
class Aircraft
def initialize
@flight_model = FlightModel.new
end
end
end
The initializer wants to create a BellX1::FlightModel
and nesting has
BellX1
, that looks good. But if the default flight model is loaded and the
one for the Bell-X1 is not, the interpreter is able to resolve the top-level
FlightModel
and autoloading is thus not triggered for BellX1::FlightModel
.
That code depends on the execution path.
These kind of ambiguities can often be resolved using qualified constants:
module BellX1
class Plane
def flight_model
@flight_model ||= BellX1::FlightModel.new
end
end
end
Also, require_dependency
is a solution:
require_dependency 'bell_x1/flight_model'
module BellX1
class Plane
def flight_model
@flight_model ||= FlightModel.new
end
end
end
Qualified References
Given
# app/models/hotel.rb
class Hotel
end
# app/models/image.rb
class Image
end
# app/models/hotel/image.rb
class Hotel
class Image < Image
end
end
the expression Hotel::Image
is ambiguous because it depends on the execution
path.
As we saw before, Ruby looks
up the constant in Hotel
and its ancestors. If app/models/image.rb
has
been loaded but app/models/hotel/image.rb
hasn't, Ruby does not find Image
in Hotel
, but it does in Object:
$ bin/rails r 'Image; p Hotel::Image' 2>/dev/null
Image # NOT Hotel::Image!
The code evaluating Hotel::Image
needs to make sure
app/models/hotel/image.rb
has been loaded, possibly with
require_dependency
.
In these cases the interpreter issues a warning though:
warning: toplevel constant Image referenced by Hotel::Image
This surprising constant resolution can be observed with any qualifying class:
2.1.5 :001 > String::Array
(irb):1: warning: toplevel constant Array referenced by String::Array
#=> Array
WARNING. To find this gotcha the qualifying namespace has to be a class, Object is not an ancestor of modules.
Autoloading within Singleton Classes
Let's suppose we have these class definitions:
# app/models/hotel/services.rb
module Hotel
class Services
end
end
# app/models/hotel/geo_location.rb
module Hotel
class GeoLocation
class << self
Services
end
end
end
If Hotel::Services
is known by the time app/models/hotel/geo_location.rb
is being loaded, Services
is resolved by Ruby because Hotel
belongs to the
nesting when the singleton class of Hotel::GeoLocation
is opened.
But if Hotel::Services
is not known, Rails is not able to autoload it, the
application raises NameError.
The reason is that autoloading is triggered for the singleton class, which is anonymous, and as we saw before, Rails only checks the top-level namespace in that edge case.
An easy solution to this caveat is to qualify the constant:
module Hotel
class GeoLocation
class << self
Hotel::Services
end
end
end
Autoloading in BasicObject
Direct descendants of BasicObject
do not have Object among their ancestors
and cannot resolve top-level constants:
class C < BasicObject
String # NameError: uninitialized constant C::String
end
When autoloading is involved that plot has a twist. Let's consider:
class C < BasicObject
def user
User # WRONG
end
end
Since Rails checks the top-level namespace User
gets autoloaded just fine the
first time the user
method is invoked. You only get the exception if the
User
constant is known at that point, in particular in a second call to
user
:
c = C.new
c.user # surprisingly fine, User
c.user # NameError: uninitialized constant C::User
because it detects that a parent namespace already has the constant (see Qualified References).
As with pure Ruby, within the body of a direct descendant of BasicObject
use
always absolute constant paths:
class C < BasicObject
::String # RIGHT
def user
::User # RIGHT
end
end


• [2016–____]: Marie Sklodowska-Curie Research Fellow, Aston University, Aston Triangle, Birmingham, UK
• [2014–2015]: Research Associate, Aston University, Aston Triangle, Birmingham, UK
• [2009–2014]: Research Engineer, Optical Networks Research & Technology Division, Coriant, Alfragide, Portugal
• [2009–2009]: Research Student, Instituto de Telecomunicações, Coimbra, Portugal
• Postgraduate Diploma in Learning & Teaching in Higher Education - Ongoing 2017
• Postgraduate Certificate in Learning & Teaching in Higher Education - Distinction 2016
• Industrial PhD in Electrical Engineering - Summa Cum Laude 2010 – 2014
• BEng+MEng in Electrical Engineering with specialisation in Telecommunications GPA 19/20 (annual admission: 100 students) 2004 – 2009
• Marie Sklodowska-Curie Individual Fellowship, funded by the EU, £145,674.00
• Industrial PhD Fellowship, funded by Nokia Siemens/Coriant and the Portuguese Foundation for Science and Technology, £61,000.00
Specifically, I have acquired hands-on experience with:
- all-fibre photonic circuit design and implementation;
- all-fibre devices design and implementation (e.g. interferometers, piezo actuated phase-shifters, fibre heating phase-shifter);
- device control implementation programming microcontrollers with USB and Ethernet interface (e.g. phase shifters, EDFA);
- electronic circuit design and implementation (e.g. lock-in amplifier, photodiode transimpedance amplifier circuit);
- instrument control and data acquisition using Labview/Matlab (e.g. scopes, spectrum analysers, EDFAs, optical modulators, lasers…);
- device and system analytical modelling;
- device and system numerical modelling using C++ and Matlab (e.g. optical fibres, optical amplifiers, optical modulators, DBP, OPC…);
- design and implementation of distributed computing systems (300 core pool with - CMD interface and batch job submission);
- Monte Carlo simulations using distributed computing;
- device optimization using distributed computing (e.g. optical fibres).


General Chairs
Challenge and Website Chairs
Steering Committee
Technical Program Committee (ordered by first name)
- Chen Yu (Indiana University)
- Christian Theobalt (MPI Informatik)
- Hwasup Lim (KIST)
- HyungJin Chang (Imperial College London)
- Iason Oikonomidis (FORTH)
- Javier Romero (MPI-IS)
- Jonathan Tompson (Google)
- Jonathan Taylor (Microsoft Research Cambridge)
- Jürgen Gall (University of Bonn)
- Leonid Sigal (Disney Lab)
- Li Cheng (AStar)
- Karthik Ramani (Purdue University)
- Nikolaos Kyriazis (FORTH)
- Otmar Hilliges (ETH Zurich)
- Richard Stebbing (Oxford University)
- Robert Wang (Oculus)
- Srinath Sridhar (MPI Informatik)
- Tsz Ho Yu (Oculus)
- Yichen Wei (Microsoft Research Asia)
- Youngkyoon Jang (Queen Mary University of London)


Twitter: #ozberrypi #RaspberryJam
First timers?
Something had changed the way kids were interacting with computers. A number of problems were identified ... and the rise of the home PC and games console to replace the Amigas, BBC Micros, Spectrum ZX and Commodore 64 machines that people of an earlier generation learned to program on.http://www.raspberrypi.org/about
Richard Stallman
Linus Torvalds
Eben Upton
Open source hardware (OSHW) consists of physical artifacts of technology designed and offered in the same manner as free and open source software (FOSS).
Model A?
Command line RunSheet: http://wiki.ozberrypi.org/wiki/RaspberryPi_for_Beginners


Bharti acquihires Quikmile
by Special CorrespondentBharti Airtel
‘acquihires’ Quikmile
Bharti Airtel on Monday announced the ‘acquihire’ of Gurgaon-based start-up Quikmile that builds tech-enabled logistics platforms. “Quikmile’s team will now be a part of Airtel X Labs — Airtel’s digital innovation factory, which focusses on IoT, digital engineering, artificial intelligence, and machine learning,” the company said in a statement.
No financial details of the deal were disclosed.
Quikmile was started in 2018.


It’s no secret that Portland is going through a period of incredible urban growth, and many feel like the decisions that are being made today will impact our city for decades to come. It’s also no secret that this issue has many different points of view and not everyone sees the information the same way. We’ve pulled together datasets on all things Urban Development, current and historic, and put them at your fingertips to explore trends, keep track of current activity, and tell your own story.
The data provided on this site is for informational and planning purposes only. We strive to produce and work with the most accurate data we can, however, accuracy or completeness cannot be guaranteed. All information on this map is subject to such variations and corrections.


Grêmio USA
Home
Registration
News
Pictures
Location
Contact
Shootout tournament
View more pictures about this event
Grêmio USA x Real Brazilian Worcester
View more pictures about this match
Grêmio USA Female x SomervilleParty
View more pictures about this match
Grêmio USA Party 2015
View more pictures about this event
Next >>


--- layout: post title: WebDrawer Error Message categories: [] tags: webdrawer status: publish type: post published: true meta: {} ---
In WebDrawer 8.2 and 8.3 you might see the error message below...
This error reflects the fact that an error has occurred in the process of parsing an error message, so you have an error but do not know what it is. A better error message might look like this...
To fix this problem edit the hptrim.config file and add the uploadBasePath as seen below. The uploadBasePath is not used by WebDrawer but the error handling in the underlying framework needs it.
<hptrim uploadBasePath="[Not Used]" ...


 Give the average punker $1000 and cheap B&W movie camera and you'd probably do a lot worse than this. The only recognizable face is Ian Svenonius, lead singer for Nation of Ulysses, who's finally reaping the benefits of being named Sassy Magazine's Mr. Sassy a couple of years ago. Will he be the next Henry Rollins? We can only hope.
Anyway, this veers from funny to boring to sad, but mostly funny. They play a few gigs despite not knowing how to even set up the drum kit. Shit, that's probably how Green Day got started.  One show ends with the singer throwing bottles into a trash can as the drummer reaches crescendo after crescendo.
There are pieces of Linklater's 'Slacker' and some ideas from Jarmusch's earlier work; it's almost 'Louisville Cowboys Go America'. I wonder if the plot of the movie unfolded as a parallel of the making of the picture; did Suki Hawley steal a van full of movie-making equipment out of boredom and run off with her friends filming whatever scared and amused them? Probably not, but that's what it feels like.
This will probably invite comparisons to 'Clerks', but I doubt Hawley's next movie will star Shannen Doherty and be featured on Entertainment Tonight. I'm guessing it'll be better, too...
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Cheyna Humphries
Let's Learn About Cheyna!
Below are some fun questions and facts about Cheyna!
- Do I like tomatoes?
Yes! I love tomatoes with salt!
- Do you think I am 26?
Yes! I am 26!
- Am I a cat lover?
No! I love dogs!
- Is my biggest fear heights?
No! I love heights, my biggest fear is spiders!

No, but I would love to!
- We know that Cheyna is a dog lover. You have 4 guesses to tell me how many dogs do you think she has?
2
- What states do you think Cheyna has been to?
The possible correct answers are:
- Wyoming
- California
- Oregon
- North Dakota
- Utah
- Montana
Top Ten Favorite Artists:
- Rittz
- Logic
- G-Eazy
- MGK
- Yelawolf
- Kelly Clarkson
- Bishop Briggs
- Pentatonix
- Backstreet Boys
- Nickleback


{% include "scaffold/incbootstrap.html" %}
Number of claims: {{submissions_count}}
Filter by: {{ status_description }}
* All submissions * No decisions * All accepts *
Expenses claim type: {{ expenses_description }}
{% for i in expenses_options.keys(): %}
* {{expenses_options[i]}}
{% endfor %} *
| Expenses claim list | Claimee | Status | {% for claimee in submissions: %}|
|---|---|---|---|
| {{expenses_options[claimee.expenses]}} | {{claimee.submitter()}} | {{claimee.email()}} | {{claimee.final_decision()}} |


Decision tree ensembles, specifically gradient boosted methods, are a powerful and easy-to-use machine learning technique for making predictions. They work by leveraging a large number of simple decision trees. For example if we are trying to predict how students will score on an upcoming test, one decision tree might look like this.
 Only when we aggregate the responses of hundreds of trees, do the predictions become robust. I liken it to guessing how many candies are in a jar. One person’s guess might be far off, but the average of 1,000 guesses is usually a good approximation.
An issue with decision tree ensembles is that it’s not clear what relationships the model has learned. One can visualize one tree (XGBoost has a plot_tree method) but one tree doesn’t tell us much. Which brings us to the awesome ELI5 package. ELI5, an acronym for explain like I’m five, offers ways to visualize and understand how your model is making predictions. Specifically, for a given observation, it can tell you the impact of each feature on the prediction. It works by looking at how the prediction changes across all of the trees based on a specific feature. Let’s consider one student who studied for 5 hours. ELI5 might tell us that across all of the trees, having a value of 5 for hours studied has a +10 impact on the prediction for the upcoming test. When we extend this to a large number of observations, we can understand the relationships the model is learning.
Using a dataset on hospital readmission, I want to walk through an example. The dataset is described in detail here but essentially there are features pertaining to a hospital visit such as the number of diagnoses made, length of visit, and how many procedures were performed, and the target variable is if they were readmitted to the hospital. I trained an XGBoost model and ran ELI5’s explain_prediction method on 2,000 observations to build a dataset of feature values and their impact on predictions. After filtering for a specific feature and averaging weights across feature values, we can get an idea of the relationship that the model has learned. A positive weight is related to a higher predicted probability of readmission. This graphic shows the average weight for observations with between 2 and 10 diagnoses entered into the system during the patient’s visit.
Up until 5 diagnoses, the weight is relatively consistent and negative so it contributes to a lower chance of being readmitted. But if an observation has more than 6 diagnoses, this feature has a positive weight. And just as the difference between 3, 4 and 5 diagnoses on the low end is muted, there is little difference between 7, 8 or 9 diagnoses. Intuitively this makes sense. Decision trees are great for learning non-linear relationships, and with this method, we can visualize what the model learned!
The code is on my GitHub.


SCOUT APP
Scout Record
Event Setup
Match
Time
Red 1
S
Red 2
S
Red 3
S
Blu 1
S
Blu 2
S
Blu 3
S
Red Sc
Blu Sc


Interview Status
Welcome to peel jobs
{% if user.status == 'Shortlisted' %}
Thank you for applying to our job posting({{jobpost.title}}). We are Happy to inform you that your application got shortlisted.
Will revert back you soon.
{% elif user.status == 'Rejected' %}
We appreciate your interest and the time you have spent in our interview process.
We currently do not have a position which matches your skills and requests.
{% elif user.status == 'Selected' %}
This is an email update to inform you that {{user.user.email}} has been selected for the position of {{jobpost.title}}. We will keep you update on further progress as the process moves forward
{%endif%}


class: center, middle, inverse, title-slide # ETC3250: Classification trees ## Semester 1, 2019 ###
Professor Di Cook
Econometrics and Business Statistics
Monash University ### Week 6 (b) --- class: split-30 layout: false .column[.pad10px[ ## Outline - .green[Classification] ]] .column[.top50px[ - A classification tree is used to predict a .orange[qualitative response] rather than a quantitative one - We predict that each observation belongs to the .orange[most commonly occurring class] of training observations in the region to which it belongs - Just as in the regression setting, we use recursive binary splitting to grow a classification tree - However RSS cannot be used as a criterion for making the binary splits. A natural alternative to RSS is the classification error rate. ]] --- class: split-30 layout: false .column[.pad10px[ ## Outline - .green[Classification] - Split criteria ]] .column[.top50px[ .orange[Purity/Impurity metrics] - The .orange[Gini index] measures total variance across the `\(K\)` classes: `$$G = \sum_{k =1}^K \hat{p}_{mk}(1 - \hat{p}_{mk})$$` - .orange[Entropy] is defined as `$$D = - \sum_{k =1}^K \hat{p}_{mk} log(\hat{p}_{mk})$$` - If all `\(\hat{p}_{mk}\)`’s close to zero or one, `\(G\)` and `\(D\)` are small. ]] --- class: split-30 layout: false .column[.pad10px[ ## Outline - .green[Classification] - Split criteria - Example ]] .column[.top50px[ Y: presence of heart disease (Yes/No) X: heart and lung function measurements  ]] --- class: split-30 layout: false .column[.pad10px[ ## Outline - .green[Classification] - Split criteria - Example ]] .column[.top50px[ Reason for choice of model.  ]] --- class: split-30 layout: false .column[.pad10px[ ## Outline - .green[Classification] - Split criteria - Example - Model diagnostics ]] .column[.top50px[ Tabulate true vs predicted to make a .orange[confusion table].

  	  true

  	  C1 	  C2

  C1 	  a 	  b

  C2	  c 	  d

  - Accuracy: *(a+d)/(a+b+c+d)* - Error: *(b+c)/(a+b+c+d)* - Sensitivity: *a/(a+c)* - Specificity: *d/(b+d)* - Balanced accuracy: *(sensitivity+specificity)/2* - Precision: *a/(a+b)* - Recall: *a/(a+c)* ]] --- class: split-30 layout: false .column[.pad10px[ ## Outline - .green[Classification] - Split criteria - Example - Model diagnostics ]] .column[.top50px[ .split-50[ .column[.content[ Confusion table Training ``` ## Reference ## Prediction No Yes ## No 74 6 ## Yes 9 60 ``` Test ``` ## Reference ## Prediction No Yes ## No 63 17 ## Yes 19 49 ``` ]] .column[.content[ Classification accuracy Training ``` ## Accuracy ## 0.8993289 ``` Test ``` ## Accuracy ## 0.7567568 ``` ]] ] ]] --- class: split-30 layout: false .column[.pad10px[ ## Outline - Classification - .green[Comparison with linear] ]] .column[.top50px[    ]] --- class: split-30 layout: false .column[.pad10px[ ## Outline - Classification - .green[Comparison with linear] - Example ]] .column[.top50px[ Physical measurements on WA crabs, males and females  .font_small[*Data source*: Campbell, N. A. & Mahon, R. J. (1974)] ]] --- class: split-30 layout: false .column[.pad10px[ ## Outline - Classification - .green[Comparison with linear] - Example ]] .column[.top50px[  ]] --- class: split-50 layout: false .column[.pad10px[ Classification tree  ]] .column[.top50px[ Linear discriminant classifier  ]] --- class: split-30 layout: true .column[.pad10px[ ## Outline - Classification - Comparison with linear - .green[Pros and cons] ]] .column[.top50px[ .row[.content[ - The decision rules provided by trees are very easy to explain, and follow. A simple classification model. ]] .row[.content[ - Trees can handle a mix of predictor types, categorical, quantitative, .... ]] .row[.content[ - Trees efficiently operate when there are missing values in the predictors. ]] .row[.content[ - Algorithm is greedy, a better final solution might be obtained by taking a second best split earlier ]] .row[.content[ - When separation is in linear combinations of variables trees struggle to provide a good classification ]] ]] --- class: fade-row2 fade-row3 fade-row4 fade-row5 count: false --- class: fade-row3 fade-row4 fade-row5 count: false --- class: fade-row4 fade-row5 count: false --- class: fade-row5 count: false --- count: false --- layout: false # 👩💻 Made by a human with a computer ### Slides at [https://monba.dicook.org](https://monba.dicook.org). ### Code and data at [https://github.com/dicook/Business_Analytics](https://github.com/dicook/Business_Analytics).
 ### Created using [R Markdown](https://rmarkdown.rstudio.com) with flair by [**xaringan**](https://github.com/yihui/xaringan), and [**kunoichi** (female ninja) style](https://github.com/emitanaka/ninja-theme).

This work is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License.


A fast C-based encoder and streaming decoder for the 'messagepack' data format. 'Messagepack' is similar in structure to 'JSON' but uses a more compact binary encoding. Based on the CWPack C library.
| Version: | 1.0 |
| Depends: | R (≥ 3.3.0) |
| Suggests: | testthat, R.rsp |
| Published: | 2018-02-22 |
| Author: | Peter Meilstrup [aut, cre, cph], Claes Wihlborg [ctr, cph], Björn Höhrmann [ctr, cph] |
| Maintainer: | Peter Meilstrup <peter.meilstrup at gmail.com> |
| License: | MIT + file LICENSE |
| NeedsCompilation: | yes |
| CRAN checks: | msgpack results |
| Reference manual: | msgpack.pdf |
| Vignettes: |
Which Data Format is Fastest Data Format\? |
| Package source: | msgpack_1.0.tar.gz |
| Windows binaries: | r-devel: msgpack_1.0.zip, r-release: msgpack_1.0.zip, r-oldrel: msgpack_1.0.zip |
| OS X binaries: | r-release: msgpack_1.0.tgz, r-oldrel: msgpack_1.0.tgz |
Please use the canonical form https://CRAN.R-project.org/package=msgpack to link to this page.


Sitemap
About Me
Portfolio
If you have an idea for an app or website in mind, I would love to hear more about it! Please email me at<EMAIL_ADDRESS>or Skype me
I hope you like what you see here, and I look forward to working with you!
Link to my resume


Over the past 7 years, We’ve helped 16 million people realize their travel dreams...and We want to help you do the same! Join the FREE weekly newsletter for exclusive tips, advice, and money saving deals.
Add a caption text for each image slide with the w3-display-* classes (topleft, topmiddle, topright, bottomleft, bottommiddle, bottomright or middle).


B.C. man and 2 firms used Ponzi schemes on investors: B.C. securities commission
VANCOUVER - The B.C. Securities Commission panel has found that a man and two companies operating in the province committed fraud against investors through a Ponzi scheme that raised about $5 million.
The panel found Todd Norman Bezzasso raised the money from 85 investors through Bezzaz Holdings Group Ltd. and Nexus Global Trading Ltd.
A commission news release says investors were told Nexus was contracted to distribute alcohol in B.C. and that Bezzaz sold a variety of products including health supplements and e-cigarettes.
It says investors were promised rates of return between five and 30 per cent, but the panel found Bezzasso was actually operating the Ponzi scheme and investors funds were used to pay earlier investors.
The panel also found that Wei Kai Liao, known as Kevin Liao, of Richmond, B-C, committed fraud, sold securities and acted as an advisor for some of those investors.
The panel says it will impose sanctions after hearing submissions from the commission staff and respondents.
This report by The Canadian Press was first published Nov. 22, 2019.


The institution aims to make the students aware of Indian culture through awareness programmes, to empower the women through active participation in various activities with dignity and confidence, preserving the social ethos, Vedic doctrines and our cultural heritage, to prepare and enable the students to face the challenges of life by making them conscious of their rights.
The institution strongly believes in imparting quality education to the girl students and inculcates qualities of leadership, competence, excellence and self confidence to enable them to regenerate the society which has posed challenges for them. Our institution sincerely believes in building multi-dimensional personality of the students having strong faith in the philosophy of Arya Samaj combined with current trends of education.
The main objective of the institution is to cater to the needs of the girl students of deprived and depressed classes especially belonging to rural and border areas where scheduled castes, scheduled tribes and backward castes reside in large number. Bringing such students in arena of education and making them self dependent is of utmost concern. To give them value-based education so that they can play a significant role in nation-building is the major objective of the institution. Efforts are done to explore the potential and latent talent of the students by providing them a congenial environment in order to develop their overall personality.
| NAME OF THE MEMBER | DESIGNATION | |
|---|---|---|
| . | . | |
| Sh. Dev Mittar Ahuja | .......... | Chairman |
| Sh. Rajnish Ahuja | .... | Member |
| Sh. Chand Setia | .... | Member |
| Mrs. Saroj Miglani | .... | Member |
| Mrs Sheela Choudhary | .... | Member |
| Mr. Faquir Chand Goyal | .... | Member |
| Mr. Vimal Thatai | .... | Member |
| Mr. Sudesh Dhuria | .... | Member |
| Mr. Dhanpat Rai Siag | .... | Member |
| Ms. Charu Ahuja | .... | Member |
| Mr. Amit Mittal | .... | Member |
| Dr. Subhash Nagpal | .... | Member |
| Dr. RK Mahajan | .... | Member |
| Mrs. Urmil Sethi | .... | Member |
| Mrs. Inderjeet Kaur | .... | Member |
| Mrs. Usha Ranade | .... | Member |
| Dr. Rekha Sood | .... | Member |
Copyright © 2018 All Rights Reserved
Marketed by:- SHIYA SUKHIJA, KAJAL JAKHAR


[Thumbnail]
Example : Animated Thumbnail 1
this abstract class needs more Effects to make it more interesting. But this component is basically
a 3 panels overlaying each other and with 4 different effects. See the next example to see how
a component can extend this class and add more effects.
Example : Animated Thumbnail 2 - click to zoom back
[Thumbnail]


Back
Javascript Basics
Introduction to Javascript
Your First Application
My Account
Privacy Policy
Support / Help


The only 2019 songs with Perfect-All-Kills
by scent_of_rainSource: SBS PopAsia HQ
There's only been five artists (but 6 songs) this year!
For the uninitiated, a Perfect All Kill is when a song hits No.1 across the daily and realtime South Korean music charts.
The charts that are used to count the PAK include Melon, Genie, Bugs, Soribada, Flo realtime chart and Instiz iChart's weekly and realtime charts.
To get a PAK is to basically say that your song is the biggest thing in South Korea on release, and comparative to previous years, 2019 has been a bit slower on the Perfect All Kill scales. Only five songs have achieved Perfect All Kills, and here they are...
1. BTS ft. Halsey: "Boy With Luv"
They've taken over the world so of course they took over the charts with this release! "Boy With Luv" marked BTS' second perfect all kill, the previous being 2018's "Fake Love". BTS were also the first artists of 2019 to achieve a PAK.
2. BOL4: "Workaholic"
BOL4 are beloved in South Korea and there's no further proof than them being the second artist of 2019 to hit a PAK. Their track "Workaholic" from their mini-album Two Five, took to the top of the charts in September.
3. AKMU: "How Can I Love Heartbreak, You're The One I Love"
The sibling duo made their first comeback since Lee Chan Hyuk completed his military service, and their fans definitely missed them! The pair immediately hit No.1 with their new song released in October.
4. MC Mong: "Fame"
Hip-hop artist, actor and tv personality MC Mong hit the top of the charts with his release "Fame", when it came out in late October. The song is taken from his eighth album CHANNEL8 and features Song Ga In and Chancellor.
5. IU: "Love Poem"
On November 1, this IU track reached No.1 within two hours of its release and by November 2 had a certified all kill. That means topping all the aforementioned charts minus the weekly one.
6. IU: "Blueming"
The queen of PAKs! IU hit No.1 with the title track from her Love Poem EP on November 21.
What do you think of 2019's PAKs?


Usage: Drop any module file (.mod, .xm, .it, etc.) on this page and hit play!
chiptune.js
nothing loaded
Demo Songs
mysterysterium by maktone
23kb
RF chip #001 by Dubmood and Bliss
31kb
Cydonian Sky by Dubmood
31kb
Chipsounds by 4-Mat
18kb


The GitHub for Desktop ships with several built-in keyboard shortcuts that developers can use to save their time during Git workflow. Below there are outlined keyboard shortcuts for each section or specific to single section in application. The commands are assigned to categories based on Mac OS X interface menu.
 |
Repository
|
|
Show Branches |
|
|
Open in Finder |
|
|
Open in Terminal |
|
|
Open in Atom |
|
|
Sync |
|
|
Push |
|
|
Pull |
|
|
Undo Most Recent Commit |
|
|
Create Pull Request |
|
|
View on GitHub |
Notes
- Created by Peter Blazejewicz.


Data Analyst, Growth - Sunnyvale, CA
Sunnyvale, CA
About Clover:
Join the Fintech and SaaS revolution that is helping small businesses grow faster and get the technology and insights previously available only to the "big guys." At Clover, you will be part of an entrepreneurial team working in a fast-paced and high growth environment, with the benefits of a parent company, Fiserv, which is the largest payments processor and merchant acquirer worldwide.
Clover delivers the leading Point of Sale system with an elegant end-to-end solution that incorporates beautiful devices, cloud-based POS software, payments processing, platform API's for third-party developers, and an ecosystem with over 220 apps. The Clover platform delivers solutions in a scalable and modular fashion that powers tiny merchants through large football stadiums, supporting millions of transactions daily.
About the role:
The Growth team is looking for a Growth analyst to function as a go-to for all marketing and product related initiatives. We are looking for a detail-oriented problem solver who has a track record of conducting in-depth analyses for an executive audience. In addition, our ideal candidate will be passionate about systematically finding creative approaches to most effectively bridge the gap between data and decision makers.
Responsibilities:
Develop and automate marketing dashboards to help assess platform KPIs and smaller initiative metrics with a focus on continuous improvement provide insights at scale
Conduct in-depth analyses by using statistical techniques to uncover insights into the factors that drive website performance, including but not limited to: funnel/website optimization, and outbound channel analysis like SEO, SEM, and email
Work with a wide variety of stakeholders that span multiple departments and teams that include; Engineering, Marketing, Sales, Design, Web Development, & Operations
Lead efforts to improve data literacy and fluency by contributing to scripting development, technical documentation, and training teams to become self-sufficient in data exploration and analysis
Requirements:
3+ years of experience doing quantitative analysis
3+ years of experience working cross-departmentally between: product management, engineering, designs, and analytics
3+ years experience with digital marketing optimization or product optimization work
3+ years of manipulating data through various software / languages (SQL, Excel, Tableau) or other means
Industry experience providing analytical services to executive-level stakeholders of varying technical backgrounds
Knowledge of statistics (e.g., hypothesis testing, product experimentation, multivariate testing)
Working knowledge or experience in data collection, transformation, and storage from various sources including but not limited to: Salesforce, Eloqua, Intercom, Invoca, Google Analytics, Heap Analytics, etc.
Interest in learning new technologies.
Strong self-starter who can create and lead new projects from scratch with minimal guidance, oversight, or resources
Collaborative, team player who can thrive in a fast-paced environment with quickly changing requirements
Nice to have:
Masters degree in a quantitative discipline: computer science, applied mathematics, statistics, operations research, information systems, engineering, economics, social sciences, or equivalent
Hands-on experience building and iterating on self-serve, data visualization tools
Proficiency in Python (or at least one scripting language)


GOVERNMENT OF THE DISTRICT OF COLUMBIA Department of General Services Open Government Report 2014 To institutionalize a culture of transparent and open government, accountability, and to expand opportunities for resident participation and collaboration, this Report describes how the Department of General Services has and will continue to develop and enhance transparency, public participation, and collaboration. In accordance with Mayor’s Order 2014-170, this report addresses the following topics: 1) Transparency Describe the steps your agency has taken or plans to take to be more transparent. Please include a description of: How and to what extent your agency shares information with the public, e.g. publication of information in the District register and on the agency website, press releases, and documents in the agency’s FOIAXpress reading room. Response: The Department of General Services is committed to making information available to the public and promoting transparency in all operational areas of the agency. The agency posts in the DC Register all notices for all public hearings related to the disposition of public assets and conducts public hearings related to real estate dispositions as well as construction activity at schools and other municipal facilities. The agency has complied with the Open Government website requirements mandated by the Executive Office of the Mayor and currently includes links to salary information, DGS contract award actions, purchase card transactions, budget information, minutes to meetings, organizational charts, performance plans, prior FOIA reports, and staff manuals and instructions. In addition to mandated information, the DGS website includes a variety of other valuable information for the public, including a means to search for information related to District real property assets and specific District facilities (i.e. recreational facilities and athletic fields). The public can find on the DGS website all information related to all solicitations for goods and services as well as for the use of real estate. The website includes links to DGS’ most recent press releases as well as social media activity. The agency also now posts some documents of interest to the public in the agency’s FOIAXpress reading room and currently has nine (9) documents of interest posted in our reading room. We anticipate increasing these numbers as we become more acclimated with FOIAXpress. 1 The District, through the efforts of DGS, has pioneered the most transparent building energy consumption database in the country. Commercial and municipal buildings are the city’s biggest source of greenhouse gas emissions and consume a hefty energy budget. Build Smart DC (buildsmartdc.com) provides transparency and accountability by detailing, for nearly every public building: energy costs, raw daily energy usage, building performance comparisons, efficiency project efficacy tracking and by simply providing a substantial and unique pool of information from which stakeholders can learn and build. How the agency meets its obligations pursuant to the District’s Freedom of Information Act and Open Meetings Act. Response: The Department of General Services complies with the requirements of FOIA by responding to every request in a timely and complete manner. During fiscal year 2014, DGS received and responded to 98 requests, which included approximately 267 staff hours. DGS, like many other agencies, recently adopted FOIAXpress as the means to track FOIA requests. FOIAXpress enables the public and DGS to track the status of each request. In addition to FOIAXpress, the agency tracks the time and costs associated with each request. Steps your agency will take to increase public access to information. Response: The agency will continue to provide the vast variety of information currently offered through the agency’s website, as well as continuing our practice of providing quarterly outreach events and posting all contract awards (including large and small purchases) online. The agency is currently standardizing its real estate forms and other transactional documents. These forms will be available online and solicitations will also include standard forms or provisions for transactions. Smart DGS – SmartDGS is the web-based application available to DC employees to report issues within District facilities. The agency will continue to promote the use of SmartDGS as a means to receive and track public and employee requests for services within District facilities. 2 How your agency has taken or plans to take steps to make more of its data available to the public. Response: The Department of General Services is working closely with the Office of the City Administrator (OCA) and the Office of the Chief Technology Officer (OCTO) to identify a significant number of datasets that OCA and OCTO expect to publish online later this year. If no dataset from DGS is selected to be included in this 2014 release, we will continue to work with OCA and OCTO to identify datasets appropriate to publish in 2015. In the future, requirements for open data reporting will be provided by the Chief Data Officer. 2) Public Engagement and Participation Describe the steps your agency has taken or plans to take to enhance or expand opportunities for the public to participate in agency decision-making. Please include a description of: How your agency provides online access to proposed rules and regulations and secures public input on them. Please list links to specific websites. Response: DGS did not promulgate rules or regulations during 2014. If the agency elects to publish proposed rules or regulations, the agency will make such information available on its website and create a separate email account or other platform to receive public comments. How your agency shares information and resources to keep the public properly informed, e.g. community meetings, public hearings, FAQs, and ways the public can provide input such as Twitter, grade.dc.gov, email contacts. Response: DGS currently devotes considerable effort to ensure that community stakeholders are engaged in the execution of large construction projects and significant real estate transactions. This engagement includes multiple community meetings with community stakeholders, ANC Commissioners and contractors/construction/design professionals and also the distribution of project documents to stakeholders upon request. DGS is actively engaged on social media to provide information as well as to gather feedback and concerns related to agency activities. Community meetings are conducted in connection with any disposition of District real property and these meetings include discussions of transaction terms and anticipated community benefits. As another example, the agency meets with the Eastern Market Advisory 3 Council monthly to address any concerns related to the management and operation of the Eastern market. The minutes from these meetings are posted online. How your agency identifies stakeholders and invites their participation. Response: DGS is a member of sixty-seven (67) local listservs, which represent over 33,000 District residents. Being an active member of local listservs has allowed the agency to continue to proactively identify and communicate the agency’s brand as well as invite the participation of the community and stakeholders by engaging residents on upcoming DGS initiatives, events and projects. Monitoring the listservs also provides the team an opportunity to hear what the DGS concerns are in the community in real-time and respond in a more timely fashion. Upon receipt of concerns the team works with sister agencies and/or internal DGS staff to provide timely responses to resident’s concerns. Steps your agency will take to improve public engagement and participation including any new feedback tools or mechanisms the agency is considering. Response: In FY14, DGS will continue to implement and use web-based social networks and programs such as Facebook, Twitter, YouTube, Google+, LinkedIn, Tumblr, Instagram, Vine and Pinterest to maximize outreach, solicit feedback and enable consistent communication. We will continue to grow our online presence on social media networks by encouraging additional DGS employees to establish Twitter accounts as a method to reach their prospective audiences. All of our social media networks are used to provide residents with information on upcoming ribbon cuttings, ground breakings, community meetings, DGS public hearings, DGS initiatives and DGS solicitations to name a few. The Twitter and Facebook accounts continue to be an avenue for residents to provide positive and negative feedback to DGS in real time. 3) Collaboration Describe the steps your agency has taken or plans to take to enhance or expand cooperation among departments, other governmental agencies, the public, and nonprofit and private entities in fulfilling its obligations. Please include a description of: 4 How your agency currently collaborates with the above parties. Please list links to specific websites if appropriate. Steps your agency will take to improve collaboration with the above parties including any new feedback tools or mechanisms the agency is considering, e.g. prizes, competitions, and other innovative methods. Response: DGS has implemented SmartDGS, a web-based application available to all District employees as a vehicle to report issues within District facilities, and encourages employees of other agencies throughout the District to utilize SmartDGS to report and track facility issues. DGS works closely with other agencies throughout the District of Columbia government to identify space and to address real estate needs. This collaboration includes meeting with agencies to determine programming needs, space requirements, proper disposition of underutilized real property and minimum suitability requirements for agency space. Agencies are actively involved in the process of selecting prospective properties for agency use, from selection of property to construction of tenant improvements. 5