Data Galaxies: How to Use
Adapted for the DataGalaxies app for webAppOS.
Sergejs Kozlovičs
This document contains guidelines for three groups of people:
· data galaxy end-users, who will use the Data Galaxy tool in the end-user mode;
· data galaxy designers, who will create data galaxies from available galaxy components (stars, stellar winds, planets, and filters corresponding to data sources, data transformations, data visualizations, and cross-filters);
· developers, who will create new galaxy components (stars, stellar winds, planets, and filters) that can be used by designers and end-users.
The document consists of four chapter. The first one contains general information that is useful for all groups of the users. Chapters 2-4 are addressed (respectively) to end-users, designers, and developers. While end-users may stop reading after Chapter 2, designers should continue reading until Chapter 3, while developers are expected to read until the end of the document.
This document does not include documentation webAppOS, a technology beyond DataGalaxies. For that documentation refer to http://webappos.org.
To open an existing project (either designer, or end-user project):
· Launch the DataGalaxies app (e.g., from webAppOS desktop), click “Browse”, and point to the desired .datagalaxy file.
· Optionally, you may upload an existing .datagalaxy file using the webAppOS FileBrowser app.
To create a new end-user project or a new designer project based on some predefined template (we discuss the process of deploying end-user templates in Section 3.7):
· Launch the DataGalaxies app (e.g., from webAppOS desktop). The available templates appears below the “Browse” button in sections “New from template” and “New from user template”. These sections contain global templates provided by the webAppOS administrator, as well as user templates stored in your home templates directory, respectively. If there are some data galaxies preconfigured and deployed to run in the end user mode, they will be appear among predefined designer-mode templates. Choose the desired template, and it will be used as a basis for your new project.
To create a new data galaxy project in the designer mode:
· Launch the DataGalaxies app (e.g., from webAppOS desktop) and choose the “Bootstrap new” option.
Based on the designer’s project, the designer will be able to deploy templates for end users.
Each data galaxy consists of stars (data sources), stellar winds (data transformations), planets (data visualizations), and cross-filters, which can affect certain transformations and visualizations. Inside the galaxy, data can be transformed multiple times until the desired result, which can be visualized, is reached. While the galaxy designer can configure and control the whole process, end users usually do not need to know how the data is transformed. Thus, when deploying the galaxy to end users, the designer usually hides certain components. Still, the users may be able to configure some parts of the galaxy. For instance, the user may be allowed (or even required) to provide the source data file. Users may also be allowed to configure some transformations and visualizations, or change values of some cross-filters (but the configuration capabilities may be limited, if compared to the designer’s capabilities).
Since galaxy components can be created by different parties, those components may expect data to be in different data formats. If we have data in one format, but certain galaxy components expect data to be in other formats, data converters are needed. If there are many heterogeneous data formats, the number of required converters will increase. The cost for this consists of developers’ time needed to create the converters as well as the time to execute the converters each time the galaxy is run. In order to minimize this cost, it is strongly advised for most transformations to work with the recommended data formats (see below), where it is possible (although the Data Galaxy tool does impose any restrictions to the data formats).
The recommended data formats are as follows:
·
For tabular data: CSV (Comma-separated values)
using Excel syntax.
Excel syntax means that:
o the comma is used a delimiter;
o if some value contains commas, that value is decorated with quotes;
o if there are quotes inside the value, the quotes are duplicated;
o the first row of the CSV file must contain the titles of the columns.
If you use Apache Commons library for dealing with CSV in Java, use org.apache.commons.csv.CSVFormat.EXCEL for the CSV file format.
· For tree-like data: JSON, where the child nodes are put into a JSON array. If the given JSON is already an array, it is considered to be a forest (=a tree with multiple roots). Otherwise, the JSON object itself is a root for the tree. Given a node of the tree, the first attribute, whose value is a JSON array, is considered to contain the children of that node.
· For graphs: JSON with attributes “nodes” and “edges” storing JSON arrays. Each node must have the id attribute; each edge must have attributes “source” and “target”, whose values must be equal to the corresponding edge end points.
· For semantic web data: OWL functional-style syntax is preferred.
The abovementioned formats were selected for the following reasons:
· The file size is being kept as small as possible, and that saves space for data stars.
· It is easy to create efficient data transformations (stellar winds) in different programming languages (the formats are simple, and many libraries for parsing them are available).
· It is easy to generate files in the given formats without any libraries.
The preferred encoding for all the files is UTF-8, since it is UNICODE and is compatible with ASCII-7.
The preferred date format is YYYY-MM-DD, since it can be easily sorted lexicographically.
When the user opens/creates a data galaxy project in the end-user mode, configuration frames for all the components that must be configured are displayed. For example, these may be the frames, where the user has to specify source data files. If the designer allowed the user to configure other components, their configuration frames can be made visible by selecting the “Show advanced configuration” checkbox.
After configuring galaxy components, the user clicks the “Run Galaxy!” button, and the galaxy is being executed. As a result, certain visualizations (specified by the designer) are shown.
If the user selects the “Keep configuration visible after Run” checkbox, the configuration remains visible, so the user can adjust some settings and re-execute the galaxy by clicking the “Re-run” button.
To start from scratch, the user can click the “Reset” button. In this case, the configuration specified by the user earlier is erased.
When the galaxy is being opened in the end-user mode for the first time, some adjustments can be made to the look-and-feel of the project. For instances, the page title and subtitle can be changed. Also, the layout of configuration and visualization frames can be modified. Usually, this work is performed by the designer, who opens the project in the end-user mode for testing purposes. Then the designer also adjusts the look-and-feel and clicks either the “Save layout”, or “Save layout forever” button. In the latter case, the end user won’t be able to change the layout and the titles any more.
A new galaxy project (see Section 1.1) contains an empty data galaxy. Then the designer adds galaxy components — stars (data sources or intermediate data), planets (data visualizations), stellar winds (data transformations), and cross filters.
First, the designer creates one or more source stars (data sources) that correspond to input files, data URLs, or other initial data. These data may be specified by the designer once for all end-users, or each end-user can choose their own data (the designer can choose the data as well, e.g., for testing purposes). The important thing is that data associated with each star are of some type. Thus, before specifying the data, a star data type must be specified. This can be done by the designer, or the designer may specify multiple acceptable types, and the end-user will have to choose one of the allowed types for the given star.
To create a single-typed star (for data of fixed format/type, e.g., CSV), right click somewhere in the galaxy and choose “New star by type”, and then navigate to the desired type (all types form a hierarchy that corresponds to the structure of the menu).
To create multi-typed star, choose “New multi-typed star”. In the dialog that appears choose data types that are allowed to be associated with the given star. You may choose a super type (e.g., “Bioinformatics data” to specify both “PDB file” and “MOL file”), which includes all subtypes. To select multiple types/supertypes, hold the “Shift” (for continuous selection) or “Ctrl” (for diverse selection) button. If you choose just one terminal type (i.e., not a supertype), then the star will become a single-type star.
Before a multi-typed star can be user, somebody has to choose a particular (final) star type. This can be done either by the designer, or by the end user depending on the use case. To clear a particular (final) star type, right click on the star and choose “Drop star configuration”. After that a particular (final) star type can be chosen once again.
To edit star configuration (e.g., to choose a file or other data source), right click the star and select “Configure…” (this configuration action is invoked automatically for newly created stars). A star-specific dialog will appear, where you can specify the data and their parameters (if any). To clear the data configuration, right click the star and select “Cleanup star data”. The cleanup process depends on the star data type (e.g., if a file was uploaded to the star during configuration, that file may be deleted).
For each star (including the initial ones) a planet (visualization) can be attached. Since planets rely on the format of the data attached to the star, each planet can be attached only to stars containing data in the supported format. To see which planets can be attached to the given star, right click at the star and choose “New planet”. The submenu will list the available planets, and you can choose any of them (each planet can be attached multiple times, since the user may want to have the same visualization, but with different parameters).
To edit planet configuration (if applicable), right click the planet and select “Configure…” (this configuration action is invoked automatically for newly created planets). A planet-specific dialog will appear, where you can specify visualization parameters (if any).
To visualize the planet, right click the planet and select “Visualize…”. A dialog (or an external program – for some planets available in the desktop Data Galaxy tool) with a visualization will appear. If the corresponding star is not an initial star, then stellar winds (transformations) that lead to that star are being executed first.
Data from stars can be transformed to obtain new data that will be associated with new stars. Transformations are performed by stellar winds. Each stellar wind is emitted from one or more source stars and creates exactly one target star. The supported data types of the source and target stars are specific to each particular stellar wind. While most stellar winds will have just one source, some may require two or more sources (e.g., a stellar wind for merging data from two stars).
To add a stellar wind, select the desired source star (or stars[1]), right click, and choose “New stellar wind”. The submenu will list the available stellar winds that you can choose for the selected set of stars. Then a configuration dialog will appear, where you can configure the stellar wind and (usually) the target star.
The stellar wind and the target star can be configured also by selecting “Configure…” from their context menu.
Cross filters can be attached to stellar winds (transformations) and planets (visualizations). To attach a new cross filter, right click on a stellar wind or a planet and choose “New cross filter” and then the desired filter. Only filters that are supported by the given stellar wind/planet are displayed. To attach an existing cross filter (that is already used by some planet or stellar wind), right click on a stellar wind or a planet and choose “Attach existing cross filter” and then the desired filter. Only supported and existing filters are displayed.
The galaxy designer can add and remove galaxy components, and reconfigure them. The designer can visualize planets (which causes certain galaxy steps to be executed) and execute certain stellar winds manually (selecting “Emit…” from the context menu of stellar winds). When the designer performs some actions on some galaxy components, other components that are affected may change their state. The designer can see the state of each galaxy component by looking at the component icon. The states are as follows:
|
State name |
Star |
Planet |
St. wind |
Cross filter |
Description |
|
CONFIGURATION_UNKNOWN |
√ |
|
|
|
A multi-typed star does not have a particular type specified |
|
CONFIGURATION_OK |
√ |
√ |
√ |
√ |
The configuration of the given component is correct |
|
CONFIGURATION_ERROR |
√ |
√ |
√ |
√ |
The configuration of the given component is not complete or is incorrect |
|
RUNNING |
√ |
√ |
√ |
|
The given component is being initialized or executed |
|
RUN_OK |
√ |
√ |
√ |
|
The given component has been successfully initialized or executed |
|
RUN_ERROR |
√ |
√ |
√ |
|
There was an error while initializing or executing the component |
When an error occurs, a galaxy component may provide an error message. To get this message, move the mouse pointer to the component, and a tooltip with a message will appear.
Although stars in Data Galaxies may contain data from different locations and in different formats, it is advised to convert all data to the recommended formats (see Section 1.3) before applying transformations (stellar winds). In the end, the data can be converted to the desired target format.
Certain transformations (stellar winds) for pre- and post-conversion are already available:
· Spreadsheet_to_CSV – converts any one Excel sheet (from .xls, .xlsx, or .xlsm file) into a CSV file.
· CSV_to_JSON – converts CSV to a JSON array of JSON objects.
· JSON array to tree – converts a JSON array to a JSON tree (the user has to specify the isParentOf function for determining the parent-child relationship between elements in the source array).
When the designer has finished designing the galaxy, the galaxy needs to be deployed as a template for end users. To deploy the galaxy, right click somewhere on the galaxy and choose “Deploy (for end users)…”. A dialog window will appear.
In the dialog multiple running configurations can be specified. Each of them can contain different parameters and be deployed independently. To add a new configuration, click the “New” button and specify the name of the configuration. This name will also be the name of the template used by end users.
After that, the second dialog will appear (it can be launched later by clicking the “Edit…” button).
The dialog contains the list of all galaxy components. By default all components are active. The designer may switch off any component by unchecking the “Active” checkbox. In this case the component will be deleted from the galaxy (useful for some filters and planets that are needed only during the design time).
To make a component visible to the end user, the “Visible” checkbox must be checked. For stars, stellar winds, and cross filters, “visible” means “allow to configure”; for planets “visible” means “allow to configure and visualize”.
If some component requires input from the user, the “Must be configure” checkbox must be selected. This is useful, for example, when the user has to specify the source data for some star.
When the configuration is finished, click “OK”.
To deploy the selected configuration (from the first dialog), click the “Deploy” button.
In the web tool as well as in the desktop tool, the “Deploy” button automatically puts the deployed galaxy to the templates folder, thus, it will be available to the end users. However, if the deployed galaxy must be transferred to another computer, the deployed template must be copied manually (into the tools/DataGalaxy/templates folder).
If the template has been deployed in the desktop tool, it can be used also in the web tool, but then the template must be copied to the server (into the tools/DataGalaxy/templates folder).
First, we mention the four steps that have to be performed, when developing a new galaxy component. Then we provide some details that are needed during those four steps.
To develop a new galaxy component type, the following four steps have to be performed:
1. Create a subdirectory in the tools/DataGalaxy/galactictypes folder. The name of the directory corresponds to the name of the galaxy component.
2.
Create a metamodel file (<ComponentName>.mmd
or <ComponentName>.ecore) that describes how the galaxy component has to
be stored in the model repository as well as the component location in the
component hierarchy. There are four supertypes for galaxy component types:
StarData[2],
Planet, StellarWind, and CrossFilter. Other components are direct or indirect
subtypes or these four types.
The metamodel file must contain a class with the name equal to the component
name. The metamodel file must also contain a generalization relationship
between this class and some supertype (that leads to one of the four types
above).
The metamodel file may define also additional attributes and associations that
are needed for the galaxy component.
3. Create a properties file (<ComponentName>.properties), which describes how to perform certain operations on the galactic type (e.g., how to visualize a planet or how to emit a stellar wind transformation). The properties file also specifies certain constrains that have to be met, when using the component (e.g., the source and target star types for a stellar wind). The format of the properties file is described in Section 4.2.
4. Implement the required operations for your component in a programming language supported by webAppOS web processors. As a special case, operations can be implemented using HTML/CSS/JavaScript (HTML files are placed into the web-root/galactictypes folder). More details are provides in Section 4.3.
Example.
1. A folder bin/galactictypes/YourStellarWind is created.
2.
A metamodel file YourStellarWind.mmd with the
following content is placed in the folder just created:
MMDefStart;
class YourStellarWind;
rel YourStellarWind.subClassOf.StellarWind;
attr YourStellarWind.specificAttribute:string;
MMDefEnd;
3. The properties file can be as follows (see details about the format
in Section 4.2):
# The two properties below have values corresponding to webAppOS web
calls.
# A predefined function configureViaHTML in the DataGalaxy Java class is used
to
# show HTML files for configuration; HTML files are searched as
#
tools/DataGalaxy/web-root-galactictypes/YourStellarWind/endUserConfiguration.*.html
# and
tools/DataGalaxy/web-root-galactictypes/YourStellarWind/designerConfiguration.*.html
# the asterisk “*” denotes where the desired frame dimensions are specified,
e.g.,
# designerConfiguration.800x600.html.
designerConfigurationURI=staticjava:DataGalaxy#configureViaHTML
endUserConfigurationURI=staticjava:DataGalaxy#configureViaHTML
# You may create your own Java function to implement certain actions; these
function also
# have to be specified as webAppOS web calls.
# For static Java functions specify the “staticjava:” prefix followed by the
# full class name (including packaged) followed by “#” followed by the static
function name.
emissionURI=staticjava:galactictypes.YourStellarWind.YourStellarWindClass#youStaticJavaEmissionFunction
# a list of sets of allowed source star types; if a set contains two types, two
stars of the corresponding
# types must be selected to match; supertypes may also be specified
allowedSourceTypeSets={XLS file,JSON file},{XLSX file,CSV}
# a list of names of possible target star types; supertypes may also be
specified
allowedTargetTypes=CSV,Excel file
# thus, the given stellar wind matches any of the following declarations:
# YourStellarWind(XLS file,JSON file) => CSV
# YourStellarWind(XLS file,JSON file) => Excel file
# YourStellarWind(XLSX file,CSV) => CSV
# YourStellarWind(XLSX file,CSV) => Excel file
# known filter types (the filters may be attached and may not)
knownCrossFilterTypes=Date filter
4. Implement the necessary operations. In the case of stellar wind, these are:
a.
Operation to configure the stellar wind in the designer
mode (a HTML file, e.g., tools/DataGalaxy/web-root-galactictypes/YourStellarWind/designerConfiguration.*.html, must be provided).
Example:
Stellar wind name: <input type="edit"
id="windName" value="New stellar wind"/>
Specific attribute value: <input type="edit" id="attrVal"
value="Specific value"/>
<script>
function load(wind)
{
if (wind.name)
document.getElementById("windName").value = wind.name;
if (wind.specificAttribute)
document.getElementById("attrVal").value = wind.specificAttribute;
}
function store(wind)
{
wind.name = document.getElementById("windName").value;
if (!wind.name) {
wind.state = "CONFIGURATION_ERROR";
wind.stateMessage = "The name of the stellar wind is not specified.";
}
wind.specificAttribute = document.getElementById("attrVal").value;
}
</script>
Notice that the stellar wind object (wind) is loaded from and stored
in the repository automatically, since we use the predefined function
configureViaHTML (we specified it in the .properties file as “staticjava:DataGalaxy#configureViaHTML”). If you want to use different way of configuration, you have to
use some mechanism to access webAppOS web memory to work with the stellar wind
object in the model repository.
Notice also that in case of an error, the state attribute is set to
denote the error, and the stateMessage attribute is also set to specify
the error message.
b.
Operation to configure the stellar wind in the end-user
mode (a HTML file, e.g., tools/DataGalaxy/web-root-galactictypes/YourStellarWind/endUserConfiguration.*.html, must be provided).
Example:
Stellar wind name: <input type="edit"
id="windName" value="New stellar wind"/>
<script>
function load(wind)
{
if (wind.name)
document.getElementById("windName").value = wind.name;
}
function store(wind)
{
wind.name = document.getElementById("windName").value;
if (!wind.name) {
wind.state = "CONFIGURATION_ERROR";
wind.stateMessage = "The name of the stellar wind is not specified.";
}
}
</script>
Notice that the end-user mode HTML file does not allow the user to enter the value for specificAttribute. This may be useful, if the galaxy component must provide more configuration capabilities to the designer and less to the end user.
c.
Operation to emit the stellar wind. Since we
specified our own Java function name in the .properties file, we need to
implement that function. The header of the function is as follows (webmem
is a pointer to webAppOS web memory, which is used to access the model
repository; r is a reference to the EmitStellarWind instance):
package galactictypes.YourStellarWind;
…
public class YourStellarWindClass {
public static boolean emission(IWebMemory webmem, long r) {
…
}
}
Since we have specified that the stellar wind accepts “Date filter”, the emission function must check, whether one or more date filters are attached, and, if yes, take their values into a consideration.
The properties that have to be specified in the .properties file depend on the type of the galaxy component (star data, stellar wind, planet, or cross-filter). The following table lists possible properties, to which components they apply, and what values are expected.
|
Property name |
Star |
Planet |
St. wind |
Cross filter |
Description |
|
designerConfigurationURI |
√ |
√ |
√ |
√ |
A webAppOS web call that will be used to configure the given galaxy component in the designer’s mode. An instance of ConfigureStar, ConfigurePlanet, ConfigureStellarWind, or ConfigureCrossFilter will be passed to the transformation. |
|
endUserConfigurationURI |
√ |
√ |
√ |
√ |
A webAppOS web call that will be used to configure the given galaxy component in the end-user’s mode. An instance of ConfigureStar, ConfigurePlanet, ConfigureStellarWind, or ConfigureCrossFilter will be passed to the transformation. |
|
initializationURI |
√ |
|
|
|
A webAppOS web call that will be used to initialize the corresponding star data (i.e., open a file, or mount some external model repository). An instance of InitializeStar will be passed to the transformation. |
|
finalizationURI |
√ |
|
|
|
A webAppOS web call that will be used to finalize the corresponding star data (i.e., close a file, or unmount some external model repository). An instance of FinalizeStar will be passed to the transformation. |
|
cleanupURI |
√ |
|
|
|
A webAppOS web call that will be used to delete the corresponding star data or to disconnect from star data. An instance of CleanupStar will be passed to the transformation. |
|
designerVisualizationURI |
|
√ |
|
|
A webAppOS web call that will be used to visualize the corresponding planet in the designer’s mode. An instance of VisualizePlanet will be passed to the transformation. |
|
endUserVisualizationURI |
|
√ |
|
|
A webAppOS web call that will be used to visualize the corresponding planet in the end-user’s mode. An instance of VisualizePlanet will be passed to the transformation. |
|
allowedStarDataTypes |
|
√ |
|
|
One or more star data type names delimited by commas. These names specify star data types, to which the given planet can be attached, i.e., which data types this planet is able to visualize. Example: allowedStarDataTypes=Metamodel,Ontology |
|
knownCrossFilterTypes |
|
√ |
√ |
|
One or more cross-filter type names delimited by commas. These names specify filter types this planet (stellar wind) is able to take into a consideration, when visualizing (transforming) data. Example: knownCrossFilterTypes=BoundsFilter |
|
emissionURI |
|
|
√ |
|
A webAppOS web call that will be used to execute the corresponding stellar wind (data transformation). An instance of EmitStellarWind will be passed to the transformation. |
|
allowedSourceTypeSets |
|
|
√ |
|
One or more sets of star data type names. Each set specifies which star data types can be used as sources for this stellar wind. Sets are specified in “{” and “}”, and are delimited by commas. Example: allowedSourceTypes={CSV,MMDFile},{ECore file},{Metamodel} |
|
allowedTargetTypes |
|
|
√ |
|
One or more star data type names delimited by commas. These names specify star data types this stellar wind is able to produce. Example: allowedTargetTypes=Metamodel,Ontology |
To implement configuration, visualization, emission actions in a language other than HTML/JavaScript, you have to define and specify a webAppOS web call for that.
For HTML/JavaScript implementation there are predefined Java functions that perform certain work that otherwise had to be implemented manually (including loading and storing the galaxy component from the repository and transferring it to/from the client browser). These functions are:
· staticjava:DataGalaxy#configureViaHTML
· staticjava:DataGalaxy#visualizeViaHTML
· staticjava:DataGalaxy#emitViaHTML
The configureViaHTML function searches for the file designerConfiguration.html, endUserConfiguration.html, designerConfiguration.*.html, or endUserConfiguration.*.html (the asterisk denotes the place for default frame dimensions, e.g., “800x600”) and displays it in the data galaxy. Also, it invokes the load(component) function, which has to load the values from the component object, from that HTML. When the component needs to be saved into the repository, the store(component) function, which has to save values into the component object, is called. If the component object has certain links in the repository that have to be traversed, the load/store functions may use webAppOS client-side webmem object to access the repository.
For asynchronous calls you may specify functions loadAsync(component, fAfter) and storeAsync(component, fAfter) instead of synchronous load and store. In this case, call the provided fAfter() at the end of each function.
The visualizeViaHTML function searches for the file designerVisualization.html, endUserVisualization.html, designerVisualization.*.html, or endUserVisualization.*.html (the asterisk denotes the place for default frame dimensions, e.g., “800x600”) and displays it in the data galaxy. Also, it invokes the load(component) function, which has to load the values from the component object, from that HTML. The load function may be either synchronous, or asynchronous.
The emitViaHTML function searches for the file emission.html or emission.*.html (the asterisk denotes the place for default frame dimensions, e.g., “800x600”), displays it in a temporary frame in the data galaxy, and invokes the synchronous emit(component) function or asynchronous emitAsync(component, fAfter) function. In addition, you may specify the finalize() function that will be called, when the user wants to force terminating of the stellar wind execution. Do not forget to call fAfter specified in the emitAsync (in case of asynchronous emission implementation).
· For configuring components it is advised to use HTML/JavaScript, since it can be used both in web and desktop versions of the Data Galaxy tool. Also, HTML configurations can use webAppOS webmem object. In case of HTML/Javascript the galaxy also performs the forward cleanup of the changed component (since, when a configuration of some galaxy component changes, all further stars created by stellar winds must be cleared).
·
Stellar winds must ensure that their target star
data type has been inserted into the repository. You can use the webAppOS web
call “putGalacticTypeIntoMetamodel” for that, e.g.,
webappos.webcall("putGalacticTypeIntoMetamodel", "JSON
file");
Also, do not forget to create the target star and specify the default configuration for it (look at the CSV_to_JSON stellar wind implementation).
· If the component object in the repository is empty or lacks some attribute values or links, assume that the default values have to be used. This simplifies the implementation of the cleanup/reset functionality in data galaxies.
· Where the user has to specify some index (e.g., column number) during component configuration, indexes should start from 1.
· Do not forget to set the component’s state value (e.g., to “CONFIGURATION_ERROR” or “RUN_ERROR”) in case of some error, and the stateMessage value to the error description.
· In HTML/JavaScript code you can use useful functions from webappos.js.
· When implementing certain functions specified in the properties file manually (i.e., not in HTML/JavaScript), always launch RefreshGalaxyCommand (via webmem.submit). In case of error, set the corresponding values to the state and stateMessage attributes.
· When implementing certain functions specified in the properties file manually (i.e., not in HTML/JavaScript), you may need to cleanup certain parts of data galaxy (i.e., if the source file name changes during configuration, all forward stars (stellar wind results) must be cleared).
· When configuring data stars, you may have to discern, whether the star is an initial star or a star resulting from some stellar wind. I.e., the initial star may require to select the file, while non-initial stars may just require a file name (this name can be used to create resulting star data). Or, you can use hardcoded names for non-initial stars.
The table below describes the injection points, where you could place your code.
|
Injection point (in the file system) |
Description |
|
bin/ galactictypes/YourType (base injection point) |
A folder containing: · the metamodel of your galatic type (.mmd or .ecore file), · the configuration file (.properties file) describing meta-information for your galactic type as well as how to execute galaxy commands related to your component, · (optionally) the server-side code of your component (e.g., Java classes located in the Java package galactictypes.YourType). |
|
web-root/galactictypes/ YourType (web-root injection point) |
A folder containing HTML files (and, perhaps, additional .js and .css files) that are displayed, when your galaxy component is being configured, visualized (for planets), or executed (for stellar winds). HTML files for both designer mode and end-user mode are placed here. Unlike the base injection point, all the files in the web-root injection point are accessible from the client browser (using the path “/galactictypes/YourType”). |
[1] To select multiple stars, hold the “Shift” or “Ctrl” button.
[2] Notice that instead of the Star type, we have the StarData type. That is done intentionally, since the same multi-typed star may be associated with data of different types, thus, the star object remains the same, but the StarData object changes.


is looking to find interesting events that satisfy as many different congoers as we can. We are looking for roleplaying games, live action roleplaying games, board games, panels and discussions, and other miscellaneous events.
We encourage both experienced and new authors to bid events. Whether it's a new event or one that's been run before, we're interested in what you have to propose.


About
"Surveillance capitalism depends on the social, and it is only in and through collective social action that the larger promise of an information capitalism aligned with a flourishing third modernity can be reclaimed." - Shoshana Zuboff, The Age of Surveillance Capitalism
Collective Action in Tech is a project that attempts to document all collective actions from workers in the tech industry. The goal of this archive is to provide data and insights on organizing in the tech industry, to find the connections between different efforts, and to build worker power in tech.
The archive lives on GitHub as a repository. Please visit our repository for more information.
Collective Action in Tech is maintained by:
- Ben Tarnoff, a tech worker, writer, and cofounder of Logic Magazine
- Clarissa Redwine, former Kickstarter union organizer
- JS Tan, a tech worker and writer
- Nataliya Nedzhvetskaya, a sociologist who researches tech and labor
- Wendy Liu, a writer and software developer
- Sarvesh Rajasekaran, a tech worker
In 2019, the group wrote an article for The Guardian characterizing the tech labor movement over the past decade.
This project is supported by funding from the Jain Family Institute.


Although I refuse to classify myself as a person of any specific religious affiliation, those who know me would describe me as a spiritual person. Several of my closest friends have built sweat lodges and have insisted that it was an experience that they were sure I would appreciate. They described it as a spiritual as well as physical cleansing. Being a person who will try almost anything once, I decided to take a good friend up on his offer to include me in a night of sweat sessions. The lodge was fairly small. Eight of us fit in it, any more than that would have been uncomfortable.
I was the only female in the lodge that night. Upon deciding to experience the sweat lodge, the idea of being the only female didn't phase me. I am very comfortable around men. I viewed the sweat lodge as an experience that was to be shared between 8 people who left all labels and differences outside of the lodge, including sexual differences. I often times have a little too much faith in my peers.
There were 3 sessions, each one more intense than the last. several of the boys only remained in the lodge for 2 of them, others only remained in the last session for several minutes. I spent my time in the lodge in meditation. I sat in an upright position with my legs crossed and my eyes closed, taking deep breaths. I focused on the rythhm of my breathing and the syrupy feeling of my sweat pouring down every inch of my body. It felt amazing. Through this focused meditation, I was able to ignore the immature and offensive comments and inapropriate vibes that I recieved from several of the boys in the lodge.
The men who remained inside the lodge with me for the entirity of the 3 sessions were those whom I had predicted would remain. They were also included in the group of men whom I felt did not look at me as a sexual object while in the lodge. They looked at me as a friend with whom they wished to share a positive experience with. After the last session, I got out of the lodge and hosed my body off with cold water. My heart was racing and my head was spinning but I felt fabulous. Clean and refreshed physically, mentally, and spiritually. I sprawled myself on the wet grass and stared at a black sky. I could feel the earth breathing and i was very aware of every function of my body, inside and out. I began to see patterns in the sky, very similar to the kind of hallucinations that I experience shortly after eating psilocybin mushrooms.
The thought that dominated my mind, despite the immaturity of some of my peers, was that growing up is about learning how to love. I realized that i was able to enjoy the heat that others couldn't sit through because I had learned to love the functions of my body, even those that others find umcomfortable, such as the altered heart beats, breathing, and sweat that come with extreme heat. Lying on the grass, post-sweat, I was deeply in love with myself, the earth i was lying on, the person next to me, and every aspect of this universe. My sweat soaked clothes were grass stained, my feet and hands were covered in soot, and my hair was full of sand... but I have never felt so clean.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


|
Assimp
5.0.1, master @ cd42b955
|
Inherits glTF2::TextureInfo.
Public Attributes | |
| unsigned int | index |
| float | strength = 1 |
| unsigned int | texCoord = 0 |
| Ref< Texture > | texture |
| struct glTF2::TextureInfo::TextureTransformExt | TextureTransformExt_t |
| bool | textureTransformSupported = false |
|
inherited |
| float glTF2::OcclusionTextureInfo::strength = 1 |
|
inherited |
|
inherited |
|
inherited |


MAY 12, 2017 ~ NEWS
Planned Reno Winery in Legal Limbo; Change in Nevada Law
Needed
Business appears to be brisk at the Lead Dog
Brewing Company, which since January has
operated a pub in half of a low-slung stucco building
on Reno’s revitalized 4th Street corridor.
read more
MAY 12, 2017 ~ NEWS
How major Nevada liquor law changes could mean more local
beer and wine, explained
Nevada's craft brewpubs will be able to make more than twice as much
beer starting in July if Gov. Brian Sandoval signs an omnibus liquor bill.
Nevada is one of the top beer consuming states but one of the most
restrictive on production
read more
MAY 12, 2017 ~ NEWS
More Breweries/Wineries coming to East 4th Street
The 4th Street “Brewery District” is set to add some more players in the next
several months. The latest entries are going into 415 East 4th
(the space that Lake Tahoe Brewing was trying to open).
read more
MAY 12, 2017 ~ NEWS
New food and drink spots planned for Reno
Business appears to be brisk at the Lead Dog Brewing Company,
which since January has operated a pub in half of a low-slung stucco
building on Reno’s revitalized 4th Street corridor.
read more


data class Command<out T : CommandData>
Command data/content plus pubkey pair: the signature is stored at the end of the serialized bytes
<init> |
Command(data: T, key: PublicKey)
Command data/content plus pubkey pair: the signature is stored at the end of the serialized bytes Command(value: T, signers: List<PublicKey>) |
signers |
val signers: List<PublicKey> |
value |
val value: T |
toString |
fun toString(): String |


Bob Marley
"A creative artist works on his next composition because he was not satisfied with his previous one."
Dmitri Shostakovich
"Lesser artists borrow, great artists steal."
Igor Stravinsky


MLOD4CON -
Making Multilingual Linked Open Data Sources Accessible for Content Architects & Content Creators
What?
MLOD4CON is a JavaScript library targeting two types of users:
- Content architects: People setting up templates that combine multilingual linked data queries with markup templates. They need to know about what multilingual linked data sources are available for the type of content that will be created.
- Content creators: people creating content. They need to tell content architects what type of queries they need and how the output should look like.
The goal of MLOD4CON is to enable content creators to work with linked data sources - without knowing details about them. After being set up by a content architect, the content creator only needs to make a JavaScript call. MLOD4CON then generates markup, based on multilingual linked data structured information.
How?
Download the MLOD4CON files and add the following to your HTML document:

Also add the following textarea element. The generated markup will appear here:
<textarea name="myfield" id="myfield" rows="20" cols="40"> Generated markup will appear here.</textarea>
Add an identifier of an entity to an its-ta-ident-ref
attribute (see simple usage). If interested you can learn more about the attribute.
For all examples, click on the highlighted words to generate the markup.
Simple usage
The content creator generates markup without any further parameters. MLOD4CON has a method run()
to do this:
Welcome to Frankfurt, the home of Johann Wolfgang von Goethe!
Source code:
Frankfurt
Johann Wolfgang von Goethe
Generation using richer markup templates
The content creator chooses templates for the type of content. This is done via the setMarkupTemplates
method. The order of templates given as a paramter is significant. The first template that completely matches to the query will be used. Example:
Welcome to Dublin, the home of Samuel Beckett!
Source code:
Dublin
Samuel Beckett
Generation with multilingual templates and different output formats
The content creator uses the setLanguage
method to set language tag tests in queries and to set language specific templates. Via the setOutputMarkupType
method three types can be set: Microdata ('0'), RDFa 1.1 Lite ('1'), JSON-LD ('2' but not yet implemented). Example:
Willkommen in Dublin, der Heimat von Samuel Beckett!
Source code:
Dublin
Samuel Beckett
Parameters without JS
All parameters for calling MLOD4CON can be set without JavaScript. The content author can also add a data-mlod4con
attribute. It holds the parameters separated by semicolon. Example:
Willkommen in Dublin, der Heimat von Samuel Beckett!
Source code:
Dublin
Samuel Beckett
Get labels for entities
If the content author does not know the entity URI, the getEntityID
method can be used. It takes an element as input and generates markup for its content. Example:
Welcome to Dublin, the home of Samuel Beckett!
Source code:
Dublin Samuel Beckett
A form can be used to enter a string and look up the entity + generate markup. Example:
Type some stuff and then click here!:
Source code:
click here ... <input id="inputtext">...
Settings file, to be prepared by the content architect
The queries and the markup templates are defined in mlod4consettings.json. Click on generate HTML and a table with all settings will be shown below. generate XML provides an XML version.
Each query has:
- a name, e.g.
dbpedia-query
- a SPARQL endpoint, e.g.
http://dbpedia.org/sparql?
- the actual query string. During processing, the placeholder
@@@entity@@@
is filled with the entity given via theits-ta-ident-ref
attribute.
The query string must contain atype
variable. This is used to match the markup template type. It can also contain other variables that are taken up in the markup templates.
The query may also contain language tags. These are expressed with the placeholder@@@language@@@
. - a reference to one or more markup templates. The order is significant: the first template matched will be used for generating markup.
Each markup template has:
- a type, e.g.
person-general
- a language. BCP 47 lookup is used to match the user language preference (given via the
setLanguage
method) to the language. If no language is given the default is used. - mappings. Here one or more types are given. The output of the query, i.e. the value of the
type
variable, is used for matching the type. - output in RDFa and Microdata (JSON-LD will follow). The output contains placeholders to be filled by variables, e.g.
##X##wikiPage##Y##
to be filled by value of thewikiPage
variable. A template is only used if all variables can be filled.
What next
This is the first version of MLOD2CON. It provides only a small set of templates and relies soley on DBpedia as SPARQL endpoint. Future versions of MLOD2CON will:
- Have more multilingual queries by default
- Use more endpoints, in addition to DBpedia
- Have more markup templates
- What else?
Contact
For questions, comments etc. contact Felix Sasaki
Last modified:


Our mission at iFixit is to teach everyone how to fix everything.
 Need help with a repair?
The repair community can help! Ask questions and get answers
about your repair issue on our forums.


---
title: 2017 WA State Election Candidates
permalink: "/wa/candidates/"
layout: default
dark-theme: true
---
{% include navbar.html %}
Being a Flux Representative is not like being any other elected representative. Flux Representatives respect Flux as a method for decision making more than they respect their own opinions. If elected, this may mean casting a vote in parliament contrary to their personal beliefs. All our Flux candidates have made a public declaration stating that they will act as a proxy for the Flux system and that they won't use their status for personal gain (including personal policy agenda).Flux Senators serve to protect the integrity of Flux.


In this HIT, you will read sentences and be asked to decide which reading (verb, noun, or whole sentence hedging) you think is most natural. We will provide example justifications for each reading, so that you can see examples of noun, verb, and sentence hedging in each case. You may, however, feel free to invent your own reasons for each kind of hedging.
In each sentence, we will indicate whether "sorta" is stressed (sorta) or unstressed (sorta). This may or may not affect your interpretation, but be sure to consider only the indicated stress pattern in making your response. Avoid adding extra stress elsewhere in the sentence.
On the next two pages, we will provide example items to familiarize you with the procedure.


Advanced Money Services
Powered by OzForex
Convert your money into 48 currencies quickly and securely
Personalised services
Make payments with a money transfer option that best suits you
Around the clock support
Speak to a dealer between Monday 7am and Friday 5pm New York time
Options for making business money transfers
When it comes to sending money overseas for business purposes
there are two main options you can choose from; a bank or a
foreign exchange specialist. As we mentioned above, you can save
your business hundreds if not thousands of dollars by choosing a
specialist provider over a high end bank.
A bank has high overhead costs and hefty fees. A FX specialist
will send your money safely, securely and cheaply. Here are a list
of pros and cons for each option to help you make an informed
decision when sending money abroad. Compare the market and save
right here!
| Stats | Bank | Exchange Provider |
|---|---|---|
| Exchange rate | 1 AUD buys $79.4000 JPY | 1 AUD buys $84.3167 JPY |
| Amount Received | $792,253 JPY | $843,167 JPY |
| Transfer time | 2-5 days | 1-2 days |
| Transfer fees | In person $30, online $22 | $0 |
Competitive rates
Enjoy a better exchange rate through OzForex. Their large client base and daily deal volumes means you can access rates normally reserved for corporations.
Fast transactions
There are a number of payment methods available from our global network. We can select the fastest, most direct option for your transfer
Secure online system
Your transfers are handled securely in a business model where client funds are never paid out prior to receiving the currency sold.
Control and visibility
Check the progress of your transaction at any time, from your first live quote until the time that the money is transferred.


{% blocktranslate with provider.name as provider %}Connect {{ provider }}{% endblocktranslate %}
{% blocktranslate with provider.name as provider %}You are about to connect a new third party account from {{ provider }}.{% endblocktranslate %}
{% else %}{% blocktranslate with provider.name as provider %}Sign In Via {{ provider }}{% endblocktranslate %}
{% blocktranslate with provider.name as provider %}You are about to sign in using a third party account from {{ provider }}.{% endblocktranslate %}
{% endif %}


UnitAngularVelocity
@available(swift 3.1)
@available(iOS 10.0, tvOS 10.0, watchOS 3.0, OSX 10.12, *)
public final class UnitAngularVelocity : Dimension
Units of Angular Velocity
-
-
-
Angular Velocity in Degrees per Second (deg/s)
Declaration
Swift
public class var degreesPerSecond: UnitAngularVelocity { get }
-
Angular Velocity in Radians per Second (rad/s)
Declaration
Swift
public class var radiansPerSecond: UnitAngularVelocity { get }
-
Base unit for UnitAngularVelocity
Declaration
Swift
public override class func baseUnit() -> UnitAngularVelocity
Return Value
Base Unit
-
Undocumented
Declaration
Swift
public required init?(coder aDecoder: NSCoder)
-
Encodes the receiver using a given archiver
Declaration
Swift
public override func encode(with aCoder: NSCoder)
Parameters
aCoder
An archiver object.
-
Undocumented
Declaration
Swift
public override func isEqual(_ object: Any?) -> Bool


New Users
32 New Users
Order Placed
123 New Order Placed
Delivery Processing
54 New Delivery Processing
Monthly Profits
$9887 This Month Profit
New Users
32 New Users
Order Placed
123 New Order Placed
Delivery
54 New Delivery
Monthly Profits
$9887 This Month Profit
New Users
32 New Users
Order Placed
123 New Order Placed
Delivery
54 New Delivery
Monthly Profits
$9887 This Month Profit
New Users
32 New Users
Order Placed
123 New Order Placed
Delivery
54 New Delivery
Monthly Profits
$9887 This Month Profit
New Users
32 New Users
Order Placed
123 New Order Placed
Delivery
54 New Delivery
Monthly Profits
$9887 This Month Profit
234
New Orders
Progress
83%
3423
Pending Products
Progress
63%
$ 123423
Online Reveneue
Progress
77%
$ 355323
Total Profits
Progress
56%
Some quick example text to build on the card title and make up the bulk of the card's content.
11 January, 2019
234
456
Some quick example text to build on the card title and make up the bulk of the card's content.
11 January, 2019
234
456
Some quick example text to build on the card title and make up the bulk of the card's content.
11 January, 2019
234
456
Some quick example text to build on the card title and make up the bulk of the card's content.
11 January, 2019
234
456
Some quick example text to build on the card title and make up the bulk of the card's content.
11 January, 2019
234
456
Some quick example text to build on the card title and make up the bulk of the card's content.
11 January, 2019
234
456
John Tasi
Prepare for the Meeting
status
10:00 PM Sat, 10 Jan 2019
Video conference to client
05:00 PM Sun, 02 Feb 2019
Tnisha
Submit a blog post
best admin template in 2019.
10:00 PM Sat, 10 Jan 2019
New Request
10 user request to approve or remove
10:00 PM Sat, 10 Jan 2019
Mark Henry
added your friend list now
10:00 PM Sat, 10 Jan 2019
John Doe
<EMAIL_ADDRESS>SUN, Jan 2019 10:21
Most Cloudy
34 o c
Wind: SE 15 KM/HHuminity: 54%


Grid based design is a way of laying out a web page that splits the page into 12 vertical divisions this gives the ability to split a page evenly into 2, 3, 4, 6 or even 12 columns or 1/3rd, 2/3rd and so on. This is an elegant way of vertically splitting up a page and simplifies CSS styling allowing styles to be reused though out the page.
A responsive webpage is one that will adjust to suit for different devices based on the width of the screen. This means that someone viewing a webpage on a phone will see a different simplified layout than someone viewing the same page on a tablet or laptop.
This make for a much easier to navigate and all-round better website.
Semantic structure is the practice of using appropriate tags to define elements. An example would be using h1, h2, h3 tags etc. for headings / important text that needs to standout. These tags can be nested and makes styling the page a lot simpler.
I found the grid based design very interesting a can see the elegance of this layout technique. I keen about using this layout technique in my website.
I am also keen to find out more about display: flex; and flex-wrap: wrap; formats as this was only skimmed in the Udacity lesson. I will need to take more time to understand this fully.


--- layout: post title: Ruby Day 2 Exercises date: 2016-03-20 17:43:31.000000000 +08:00 type: post published: true status: publish categories: [] tags: [] meta: _rest_api_published: '1' _rest_api_client_id: "-1" _publicize_job_id: '20938647652' author: login: noobgrammer email<EMAIL_ADDRESS>display_name: bytehala first_name: Lemuel last_name: '' ---
I am currently reading Seven Languages in 7 Weeks, and I just finished the frustratingly hard (but enjoyable) exercises for Day 2. [After trying that, I must say I've given up all hope of actually finishing the whole book in just 7 weeks. No biggie, I like the book regardless.]
The Exercises
{'grandpa' => {'dad' => {'brother' => {}, 'me' => {}}, 'uncle' => {'jacob' => {}, 'edward' => {}} } }
The Solutions
Can be found on my Github repository for these exercises.
[WARNING] Might have some lingering debug code. Heh
Difficulties Encountered
No need to read past this point, this is purely for me. Actually, this whole blog is. You might not understand for lack of context.
One major difficulty was that I do not know yet how to debug Ruby. So everything had to be outputted to the console. Ugh.
The hash as an input is simple enough as it is, because if you break down the elements of the hash it always looks like this:
[1] element : {x}
[2] x : key => content
[3] content : element/{x} or {x1, x2}
[4] key : (string literals)
(Backus-Naur Form and metasyntax come to mind, but I'm too lazy to explain that or Google the actual way of doing it.) So, the difficulty for me was that I only had 2, the first half of 3, and 4 as my assumptions. Purely my fault, but what I ended up having was outputs that were missing one of the two children for each family, in every permutation possible (i.e. sometimes 'me' was missing, sometimes my 'brother' was, sometimes 'jacob' was, etc) depending on how I banged my head against the code. Something that helped was when 'mebrother' showed up on the console... I was iterating prematurely, or too late. Also, on the line where it says
@children[k] = Tree.new({k => v})
I was just passing v or the content into the recursion, effectively having a keyless and therefore nameless child. Okay, that sounds kind of scary in real life.
For the grep problem, the main pain point was you really did need to use regex. I used the license.txt which you can find on the repo, and if you don't use regex and stick to string literals, the code just returns the first line it finds the string on. I was trying to find 'License', and it returned just line 1. Then I replaced it with /License/ on the line[word] part, and behold, it worked. So I basically had to look for ways to convert the user input to a regex and through trial and error, the %r notation worked best.


--- layout: pssat title: Research Triangle PowerShell Saturday group: tagline: Join us Sept. 21 2019 tags : [components] img : pssaturday.png img-mobile : pssaturday.png author : rtpsug css: js: keywords: components, demo canonical: https://rtpsug.com --- {% include JB/setup %}
The Research Triangle PowerShell users group is proud to host a full day of learning at NC State University
on September 21st, 2019.
We are also hosting a limited access, specialized 6 hour PowerShell cybersecurity session on Sunday,
September 22nd.


I’m currently a master’s candidate in Statistics at ETH Zürich. My main areas of interest or in Machine Learning and Deep Learning.
Twitter/GitHub/Linkedin.
Thanks to Solo for the Jekyll theme.


western-union
Businessmodel of Western Union
Customer Segments
Western Union provides a range of money transfer and remittance services to customers around the world. The Company’s customers can be organised by its three business segments:
- Consumer-to-Consumer, which enables members of the general consumer population to make local and cross-border payments to one another;
- Consumers-to-Business, which enables consumers to make regular and one-time payment to various business and organisations, principally in relation to the payment of bills;
- Business Services, which provides services to small and medium size businesses, international enterprises, and other organisations across multiple business sectors. Western Union’s consumer-to-consumer operations account for the majority of the Company’s business, with general consumers comprising its principal customer base.
Western Union serves an international customer base spanning five core geographic regions: Europe and CIS, North America, Middle East and Africa, Asia Pacific, and Latin America and the Caribbean.
Value Propositions
Western Union provides value to its customers in the following ways:
- Its brand recognition and reputation, with the Company established as one of the most well-known and well-regarded companies of its kind in the world, having a track record for providing efficient and reliable services to its customer base;
- Its portfolio of services, with the Company providing a range of money transfer services, including local and cross-border payments, to individual and commercial customers, facilitating payments of all kinds;
- Its international reach, with the Company providing services to customers around the world, concentrated in five geographic regions, namely Europe and CIS, North America, Middle East and Africa, Asia Pacific, and Latin America and the Caribbean;
- Its accessibility and flexibility, with the Company’s services easily accessed by customers through the Company extensive international network of agents, as well as its through its various online service offerings; and
- Its safety and security, with the Company implementing high-level security systems to ensure the safety and reliability of its services. ### Channels
Western Union operates a website at www.westernunion.com, through which it provides information on its various services and operating locations. The Company’s website, as well as its various regional websites, double as online money transfer portals, which enable customers to make money transfers online by credit card, and bank transfer. The Company also provides a mobile app, which allows customers to make transfers on the go.
Western Union principally provides consumer-to-consumer services through its global network of third-party agents across its five geographic operating regions, with approximately 90% of its agent locations located outside of the US. These agents include large networks such as post offices, banks and retailers, and other established organisations, as well as smaller independent retail locations that provide other consumer products and services. Some of the Company’s agents outside the US manage subagents. These agents are known as superagents.
Western Union’s consumer-to-business and business solutions services are principally offered over the phone, through partner channels, and via online portals. Consumers can make payments to over 15,000 businesses through the Company’s consumer-to-business channels. Western Union markets its internet services through co-branding arrangements with its website partners as well as on its own websites.
Customer Relationships
Western Union provides much of its services to customers on a self-service basis, with its online portals and mobile applications allowing customers to arrange money transfers, manage account details, and track transfers without interacting with members of the Company’s sales and service teams.
Western Union’s principal services channel is its network of agents, through which the customers can receive a more personalised service. The Company’s service staff are able to provide in-person advice and guidance that is tailored to the needs of each customer. Business customers are provided additional care via specialist business services staff.
Western Union provides a range of support services to its customers, including FAQs, fraud awareness information, price estimation tools, and agent location details. The Company also provides tailored customers support through dedicated support personnel, who can be contacted over the phone, by email, or via an online contact form.
Additionally, customers are able to follow Western Union’s activities and interact with the Company directly through its social media accounts, including with Twitter, Facebook, and YouTube.
Key Activities
Western Union provides money movement and payment services. It organises its activities into three operating segments: Consumer-to-Consumer, which is engaged in individual money transfers from one consumer to another through agents or via online portals; Consumer-to-Business, which provides solutions that allow consumers to make one-time or recurring payments to various businesses and organisations, including utilities, auto finance companies, mortgage servicers, financial service providers, government agencies, and other businesses; and Business Solutions, which facilitates payment and foreign exchange solutions, primarily cross-border, cross-currency transactions, for small and medium size enterprises.
The Company primarily serves its customer through a network of agent locations in approximately 200 countries and territories, spanning the Americas, Europe, Asia Pacific, the Middle East, and Africa.
Key Partners
Western Union works closely with a network of partner companies and organisations that support the Company’s money transfer operations. These partners can be categorised broadly as follows:
- Channel and Distribution Partners, comprising the Company’s extensive network of independent agents that provide a range of money transfer services to customers on the Company’s behalf;
- Technology Partners, comprising various technology, systems integration, and software and hardware providers, that provide systems and support that work to facilitate the Company’s money transfer processes;
- Affiliate and Marketing Partners, comprising websites and businesses that refer customers to Western Union, and drive traffic to the Company’s website, in return for commission and benefits;
- Rewards Partners, comprising various commercial operators that provide discounts and products to Western Union customers as part of its rewards program; and
- Strategic and Alliance Partners, comprising market leading companies across multiple sectors, with which the Company works on joint projects. Western Union partners with a number of technology companies, with a particular focus on money transfer services providers. This includes partnerships with Fiserv, Brightwell Payments, ChromeRiver, and MineralTree. The Company has also recently launched partnerships with WeChat, Walmart, and Sainsbury’s.
Key Resources
Western Union’s key resources are intellectual properties and technologies, its online portals and mobile app, its IT and communications infrastructure, its network of agents, its partnerships, and its personnel.
Western Union owns a number of patents and patent applications covering various aspects of its processes and services. Searches of records published by the US Patent and Trademark Office identified a number of patent applications filed in Western Union’s name, including applications entitled ‘Money transfer system and method’, ‘Methods and systems for improving disclosure requirement compliance’ and ‘Cash payment for remote transactions’.
Western Union owns and or leases a number of physical properties across 50 countries, including more than 400 leased properties outside the US. This principally includes the Company’s operational, sales, and administrative offices, as well as dedicated customer service centres.
Cost Structure
Western Union incurs costs in relation to the development of its technologies and solutions, the development of its digital service channels, the maintenance of its IT and communications infrastructure, the management of its network of agents, the implementation of marketing and advertising campaigns, the management of its partnerships, and the retention of its personnel.
In 2015 Western Union recorded total operating expenses in the amount of $4.37 billion. This comprises cost of services totalling $3.20 billion and selling, general, and administrative costs totalling $1.17 billion.
Revenue Streams
Western Union generates revenue through the provision of money transfer and business transaction services. The Company’s revenue streams can be organised into two principal categories:
- Revenue derived from transaction fees charged to consumers to transfer money; and
- Revenue derived from foreign exchange revenues, based on the difference between the exchange rate set by the Company to the customer and the rate at which the Company is able to acquire currency. In 2015 Western Union generated annual revenue in the amount of $5.48 billion, down slightly on the $5.61 billion recorded by the Company in 2014. The majority of the Company’s revenue, around 79%, was attributed to the Company’s Consumer-to-Consumer segment. The Company’s Consumer-to-Business and Business Services segments accounted respectively for 12% and 7%.


Williams leads Evansville over Indiana-Kokomo 89-71
EVANSVILLE, Ind. (AP) - DeAndre Williams had 23 points and 13 rebounds as Evansville topped Indiana-Kokomo 89-71 on Thursday night.
Artur Labinowicz added 21 points and John Hall had 16 points for the Purple Aces (3-0).
Trequan Spivey had 18 points and six rebounds for the Cougars. Akil McClain added 14 points. Allante Harper had 11 points.
TOP STORIES
Skeptics chuckle as climate activist Greta Thunberg sets sail for Europe on 'plastic yacht'
Franklin Graham calls on nation to pray for Trump as impeachment effort gains speed
'It's going to backfire': Impeachment boosts Trump in battleground states
Evansville matches up against SMU at home on Monday.
For more AP college basketball coverage: https://apnews.com/Collegebasketball and http://twitter.com/AP_Top25
This was generated by Automated Insights, http://www.automatedinsights.com/ap, using data from STATS LLC, https://www.stats.com
Sign up for Daily Newsletters
Copyright © 2019 The Washington Times, LLC.
Please read our comment policy before commenting.


You can either define an interval by maintaining pressed the ALTor CTRL keys and mouse Click for multiple rows selection.
Or you can click on the opening boundary marker [ or closing boundary marker ] to define an interval.
{{item.model.date | date: 'dd/MM/yyyy'}} : {{ item.model.label }}


{{ snippet_data.name|e}}
← merge
1
of {{ snippet_data.proposed_changes.keys()|length }} suggested changes
↑
↓
propose a new change


Analysis Situs
./
features
/suppress blends
Download
Features
Source code
Terminology
References
Suppress blends
Isolated blends
TODO


To build FubuMVC you need to install ruby, rake etc. Unfortunately for me the firewall at work will not allow me to get the rake gem (I’ve downloaded gems before using the HTTP_PROXY setting before but no luck this time). Any hoose I remember reading Stephen Balkum post on packaging up Rake as an executable. I followed Stephens guide and created a portable rake package which got around my firewall problem but FubuMVC required another gem rubyzip to allow a build.
Adding another gem
Luckily using Stephen’s guide its really easy to add extra gems, you just need to have them installed before you build your exe. So we follow the first part of the process outlined in Stephen’s guide then do the following:
NOTE: In this case we need rubyzip but it could be any old gem.
-
Download rubyzip and extract to contents to c:\rubywork\zip
-
To install rubyzip, at a command prompt in c:\rubywork\zip, run ..\ruby\bin\ruby install.rb
-
Download zlib and extract the zlib1.dll to C:\rubywork\ruby\lib\ruby\1.8\i386-mswin32
-
Rename zlib1.dll to zlib.dll (rubyzip required this extra dll other gems may not)
Now continue part two of the process from Stephen’s guide to compile your very own allinoneruby.exe which includes, rake and rubyzip.
You should now have allinoneruby.exe and rake.rb file.
Building FubuMVC
We can now drop these files into to the FubuMVC project under the build support folder:
We need a helper batch file in the root folder of FubuMVC called rake.bat which contains:
@.\build_support\allinoneruby.exe .\build_support\rake.rb %*
This will be called when we run the build.
Run the build already
Drop to the command prompt and cd into the FubuMVC project root and simply type build. You should get something like:
Download
| Don’t want to go through all that? You can download my version of portable rake [here](http://cid-d7d57b78b0ddedf5.skydrive.live.com/self.aspx/.Public/blog/portable | rake/portablerake.zip) (_I don’t think I’m breaking any licensing agreements here, this is all open source software. If I am let me know and I’ll remove the link) |
DISCLAIMER: I offer no guarantees I can only confirm this works on my machine!
One final note
I’ve used this method to build some of the other open source projects out there which use rake (all the __cool kids_ seem to be using rake_) and so far I’ve not had any problems. This could be pretty frictionless way to introduce rake to a team of .net developers who don’t want the overhead of installing ruby on their machines. Just add it to a tools folder check it in to source control they’ll never know!


#include <stDBMTree.h>
Public Types | |
| typedef stDBMCollection< ObjectType > | tDBMCollection |
| typedef stDBMMemNode< ObjectType > | tDBMMemNode |
| typedef stGenericMatrix< stDistance > | tDistanceMatrix |
| typedef stSubtreeInfo< ObjectType > | tSubtreeInfo |
Public Member Functions | |
| stDBMLogicNode (stCount maxOccupation) | |
| ~stDBMLogicNode () | |
| stCount | AddEntry (ObjectType *obj) |
| int | AddEntry (stSize size, const stByte *object) |
| stCount | GetNumberOfEntries () |
| ObjectType * | GetObject (stCount idx) |
| ObjectType * | operator[] (stCount idx) |
| stPageID | GetPageID (stCount idx) |
| stCount | GetNEntries (stCount idx) |
| stByte | GetHeight (stCount idx) |
| stCount | GetNumberOfFreeObjects () |
| stDistance | GetRadius (stCount idx) |
| void | SetEntry (stCount idx, stPageID pageID#ifdef __stDBMNENTRIES__, stCount nEntries#endif, stDistance radius#ifdef __stDBMHEIGHT__, stByte height#endif) |
| void | AddNode (stDBMNode *node) |
| void | AddCollection (tDBMCollection *returnCollection) |
| stCount | GetRepresentativeIndex (stCount idx) |
| ObjectType * | GetRepresentative (stCount idx) |
| void | SetRepresentative (stCount rep0, stCount rep1) |
| void | Distribute (tDBMCollection *returnCollection, stDBMNode *node0, stDBMNode *node1, tSubtreeInfo *promo, EvaluatorType *metricEvaluator) |
| void | DistributeCollection (tDBMCollection *returnCollection, stDBMNode *node0, stDBMNode *node1, tSubtreeInfo *promo, EvaluatorType *metricEvaluator) |
| void | Distribute (stDBMNode *node0, stDBMNode *node1, tSubtreeInfo *promo, EvaluatorType *metricEvaluator) |
| void | TestDistribution (tDBMCollection *returnCollection, tDBMMemNode *node0, tDBMMemNode *node1, EvaluatorType *metricEvaluator) |
| void | TestDistribution (tDBMMemNode *node0, tDBMMemNode *node1, EvaluatorType *metricEvaluator) |
| void | SetMinOccupation (stCount min) |
| bool | IsRepresentative (stCount idx) |
| ObjectType * | BuyObject (stCount idx) |
| stCount | BuildDistanceMatrix (EvaluatorType *metricEvaluator) |
| void | MaxDistancePromote () |
Thic class template represents a DBMTree logic node entry. It is used to hold a node in a memory form which allows better way to manipulate entries. It also implements means to distribute its contents between 2 nodes or 3 nodes.
Definition at line 153 of file stDBMTree.h.
| typedef stDBMCollection< ObjectType > stDBMLogicNode< ObjectType, EvaluatorType >::tDBMCollection |
This type is a collection of objects.
Definition at line 158 of file stDBMTree.h.
| typedef stDBMMemNode< ObjectType > stDBMLogicNode< ObjectType, EvaluatorType >::tDBMMemNode |
This type is a memory node.
Definition at line 163 of file stDBMTree.h.
| typedef stGenericMatrix<stDistance> stDBMLogicNode< ObjectType, EvaluatorType >::tDistanceMatrix |
Distance matrix type.
Definition at line 168 of file stDBMTree.h.
| typedef stSubtreeInfo<ObjectType> stDBMLogicNode< ObjectType, EvaluatorType >::tSubtreeInfo |
This type is a subtree info.
Definition at line 173 of file stDBMTree.h.
| stDBMLogicNode< ObjectType, EvaluatorType >::stDBMLogicNode | ( | stCount | maxOccupation | ) |
Creates a new instance of this node with no objects.
| maxOccupation | The maximum number of entries. |
| stDBMLogicNode< ObjectType, EvaluatorType >::~stDBMLogicNode | ( | ) |
Disposes this instance and releases all related resources. All instances of object added to this node will also be deleted unless it is not owned by this node (see method BuyObject()).
| void stDBMLogicNode< ObjectType, EvaluatorType >::AddCollection | ( | tDBMCollection * | returnCollection | ) |
Adds all objects of a collection.
| node | The collection. |
|
inline |
Adds an object to this node. This method will claim the ownership of the object instance.
Use SetEntry() to fill the other fields of each entry.
| obj | The object to be added. |
Definition at line 198 of file stDBMTree.h.
| int stDBMLogicNode< ObjectType, EvaluatorType >::AddEntry | ( | stSize | size, |
| const stByte * | object | ||
| ) |
Adds an object to this node.
Use SetEntry() to fill the other fields of each entry.
| size | The size of the object in bytes. |
| object | The object data. |
| void stDBMLogicNode< ObjectType, EvaluatorType >::AddNode | ( | stDBMNode * | node | ) |
Adds all objects of a node.
| node | The node. |
| stCount stDBMLogicNode< ObjectType, EvaluatorType >::BuildDistanceMatrix | ( | EvaluatorType * | metricEvaluator | ) |
Builds the distance matrix using the given metric evaluator.
| metricEvaluator | The metric evaluator. |
|
inline |
Gets the ownership of an object associated with a given entry. This method will avoid the automatic destruction of the object instance by the destructor of this node.
This method can be used to buy the representative objects to avoid unnecessary replications.
| idx | The object index. |
Definition at line 457 of file stDBMTree.h.
| void stDBMLogicNode< ObjectType, EvaluatorType >::Distribute | ( | tDBMCollection * | returnCollection, |
| stDBMNode * | node0, | ||
| stDBMNode * | node1, | ||
| tSubtreeInfo * | promo, | ||
| EvaluatorType * | metricEvaluator | ||
| ) |
Distribute objects between 2 nodes using the current representatives (see SetRepresentative()). Some objects may be insert in returnCollection.
The returnCollection has objects that were not inserted in the others nodes.
| returnCollection | The returning node containing objects that were not covered by the other 2 nodes. |
| node0 | The first node. |
| node1 | The second node. |
| promo | Representatives of node 0 and 1. |
| metricEvaluator | The metric evaluator to be used to compute distances. |
| void stDBMLogicNode< ObjectType, EvaluatorType >::Distribute | ( | stDBMNode * | node0, |
| stDBMNode * | node1, | ||
| tSubtreeInfo * | promo, | ||
| EvaluatorType * | metricEvaluator | ||
| ) |
Distribute objects between 2 nodes using the current representatives (see SetRepresentative()).
| node0 | The first node. |
| node1 | The second node. |
| promo | Representatives of node 0 and 1. |
| metricEvaluator | The metric evaluator to be used to compute distances. |
| void stDBMLogicNode< ObjectType, EvaluatorType >::DistributeCollection | ( | tDBMCollection * | returnCollection, |
| stDBMNode * | node0, | ||
| stDBMNode * | node1, | ||
| tSubtreeInfo * | promo, | ||
| EvaluatorType * | metricEvaluator | ||
| ) |
|
inline |
Returns the height of the sub-tree of a given entry.
| idx | The object index. |
Definition at line 264 of file stDBMTree.h.
|
inline |
Returns the number of entries in the sub-tree of a given entry.
| idx | The object index. |
Definition at line 255 of file stDBMTree.h.
|
inline |
Returns the number of entries in this node.
Definition at line 219 of file stDBMTree.h.
| stCount stDBMLogicNode< ObjectType, EvaluatorType >::GetNumberOfFreeObjects | ( | ) |
Returns the number of free objects.
|
inline |
Returns the object of a given entry.
| idx | The object index. |
Definition at line 228 of file stDBMTree.h.
|
inline |
Returns the PageID of a given entry.
| idx | The object index. |
Definition at line 246 of file stDBMTree.h.
|
inline |
Returns the radius of the sub-tree of a given entry.
| idx | The object index. |
Definition at line 282 of file stDBMTree.h.
|
inline |
Returns the representative object.
| id | The representative ID. It may be 0 or 1. |
Definition at line 341 of file stDBMTree.h.
|
inline |
Returns the id of the representative object.
| id | The representative ID. It may be 0 or 1. |
Definition at line 332 of file stDBMTree.h.
|
inline |
Verifies if a given object is a representative.
| idx | Object index. |
Definition at line 442 of file stDBMTree.h.
| void stDBMLogicNode< ObjectType, EvaluatorType >::MaxDistancePromote | ( | ) |
|
inline |
Returns the object of a given entry.
| idx | The object index. |
Definition at line 237 of file stDBMTree.h.
|
inline |
Sets the data associated with a given entry.
| idx | The object index. |
| pageID | The pageID. |
| nEntries | The number of entries in the sub-tree. |
| radius | The radius of the sub-tree. |
Definition at line 294 of file stDBMTree.h.
|
inline |
Set minimum occupation. This must be the minimum number of objects in a page. This value must be at least 1.
Definition at line 428 of file stDBMTree.h.
|
inline |
Sets both representatives ids. Use UpdateDistances() to update all distances between objects and.
| rep0 | Index of representative 0. |
| rep1 | Index of representative 1. |
Definition at line 352 of file stDBMTree.h.
| void stDBMLogicNode< ObjectType, EvaluatorType >::TestDistribution | ( | tDBMCollection * | returnCollection, |
| tDBMMemNode * | node0, | ||
| tDBMMemNode * | node1, | ||
| EvaluatorType * | metricEvaluator | ||
| ) |
Tests the distribution of objects between 3 nodes using the current representatives (see SetRepresentative()).
| returnCollection | The returning node. |
| node0 | The first node. |
| node1 | The second node. |
| metricEvaluator | The metric evaluator to be used to compute distances. |
| void stDBMLogicNode< ObjectType, EvaluatorType >::TestDistribution | ( | tDBMMemNode * | node0, |
| tDBMMemNode * | node1, | ||
| EvaluatorType * | metricEvaluator | ||
| ) |
Tests the distribution of objects between 2 nodes using the current representatives (see SetRepresentative()).
This method does not use the returnNode.
| node0 | The first node. |
| node1 | The second node. |
| metricEvaluator | The metric evaluator to be used to compute distances. |


MARIA BENET
Backend developer
Hi! I am a backend developer based in Oslo, Norway.
I love solving problems and making great products.
Also, I am passionate about NLP and traveling.


INOTIFY_INIT
Section: Linux Programmer's Manual (2)Updated: 2008-10-10
Index Return to Main Contents
NAME
inotify_init, inotify_init1 - initialize an inotify instanceSYNOPSIS
#include <sys/inotify.h> int inotify_init(void); int inotify_init1(int flags);
DESCRIPTION
inotify_init() initializes a new inotify instance and returns a file descriptor associated with a new inotify event queue.If flags is 0, then inotify_init1() is the same as inotify_init(). The following values can be bitwise ORed in flags to obtain different behavior:
- IN_NONBLOCK
- Set the O_NONBLOCK file status flag on the new open file description. Using this flag saves extra calls to fcntl(2) to achieve the same result.
- IN_CLOEXEC
- Set the close-on-exec (FD_CLOEXEC) flag on the new file descriptor. See the description of the O_CLOEXEC flag in open(2) for reasons why this may be useful.
RETURN VALUE
On success, these system calls return a new file descriptor. On error, -1 is returned, and errno is set to indicate the error.ERRORS
- EINVAL
- (inotify_init1()) An invalid value was specified in flags.
- EMFILE
- The user limit on the total number of inotify instances has been reached.
- ENFILE
- The system limit on the total number of file descriptors has been reached.
- ENOMEM
- Insufficient kernel memory is available.
VERSIONS
inotify_init() first appeared in Linux 2.6.13. inotify_init1() was added in Linux 2.6.27.CONFORMING TO
These system calls are Linux-specific.SEE ALSO
inotify_add_watch(2), inotify_rm_watch(2), inotify(7)COLOPHON
This page is part of release 3.22 of the Linux man-pages project. A description of the project, and information about reporting bugs, can be found at http://www.kernel.org/doc/man-pages/.
Index
This document was created by man2html, using the manual pages.
Time: 05:33:04 GMT, December 24, 2015


The Whole Nine Yards (2000) 3 stars out of 4. Starring Matthew Perry, Bruce Willis, Michael Clarke Duncan, Rosanne Arquette, Natasha Henstridge, Kevin Pollak and Amanda Peet.
Despite containing graphic violence, strong language and nudity, "The Whole Nine Yards" is a charming screwball comedy that - minus the above-mentioned contemporary touches - could have been produced in the 1930s.
The story, which is not as frenetic as it could be, contains several double crosses, oddball characters and plot twists familiar to this genre.
The plot centers on Dr. Nicholas `Oz' Oseransky (Matthew Perry) who learns that his new next door neighbor `Jimmy Jones' (Bruce Willis) is, in reality, Jimmy `The Tulip' Tudeski, a notorious hitman recently released from prison after serving a five-year stretch for ratting out his former boss.
Oz's shrewish wife, Sophie (Rosanna Arquette) wants him killed so she can collect his insurance money to pay back money her father, Oz's former partner, embezzled.
Instead, she convinces Oz to collect a `finder's fee' by contacting the Gogolack family who have sworn revenge against Jimmy for turning state's evidence.
Of course, nothing works out as planned, as each character has a secret agenda and connives against the other.
Caught in the middle of all the scheming is poor Oz. Perry goes through the entire film looking like a deer caught in the headlights. Perry gives a physical, near-slapstick performance as he stumbles, falls, spits and stutters through situations that are way over his head.
This is the sort of role Bob Hope would have played in the 1930s or ‘40s, except that Perry lacks the false macho bravado that Hope's cowardly character would bring to such a part.
In contrast, Willis gives a rather underplayed performance as the cool hitman unfazed by all conspiracies going on around him. Willis, with tongue in cheek, realizes "The Whole Nine Yards" is a comedic romp and rolls along with a twinkle in his eye, enjoying himself immensely.
The film is stolen by Amanda Peet as Jill, Oz's office assistant whose ambition in life is to be a hitman (hitwoman? hitperson?). She is as excited to meet Jimmy as a teen-ager would be to meet Ricky Martin. She keeps a scrapbook and knows all his hits, she brags.
Also in the cast are Michael Clarke Duncan as a fellow hitman and pal of Jimmy, Kevin Pollak as the revenge-seeking Gogolak and Natasha Henstridge as Jimmy's wife and Oz's love interest.
"The Whole Nine Yards" has a few slow spots. At about two hours, it's a bit too long. Some tighter editing could have given it a more frantic pace, which would have helped.
Comedy, especially one in this vein, needs to gallop. The audience should not be allowed to catch its breath, as the story races from setup to setup.
The other deficiency is Arquette's performance. Her French accent is terrible and her character is too cartoonish, too over-the-top, even for a comedy of this ilk.
Despite these minor flaws, "The Whole Nine Yards" is most satisfying.
Bob Bloom is the film critic at the Journal and Courier in Lafayette, IN. He can be reached by e-mail at<EMAIL_ADDRESS>or at<EMAIL_ADDRESS>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


Total Users
15.2% Growth This Week
Users Online
1.2hrs Average Time Online
2
Total Subscriptions
5.22% Growth This Week
342
Advertisements Served
8.2% Click Through Rate


---
layout: post
title: God Would Know
subtitle: 祂知道
date: '2019-06-12T20:46:00.005+08:00'
author: DotIN13
tags:
- Life
- God
modified_time: '2019-11-03T23:56:27.101+08:00'
blogger_id: tag:blogger.com,1999:blog-7275524089009887162.post-5918380688877098898
blogger_orig_url: https://dotin13laf.blogspot.com/2019/06/god-would-not-punish-you-because-he.html
---
God would not punish you because
he knew you would always do that to yourself.
Sargent Shroom said in the
film Billy Lynn's Long
Halftime Walk
that there is always
something looking at you from above.
You would not know what that is nor
who that could be. He could be Jesus, he could be Śākyamuni, he could be anything. But he is
just somrthing biggier than us. It is more like some pattern, or a myth with varying answers. We live under that and
there is no way out of it.
Whenever he interferes, he does not
do it directly, instead he puts you in a maze, where you decide, where you make hard decisions to turn left or
right. You fall easily. For your own lust uncontrolled and shortsightedness yet not
remedied, you fall.
He knew you would always do that to
yourself.


Before Change
def setUp(self):
super(UnivariateRankingNetworkTest, self).setUp()
self.context_feature_columns = _context_feature_columns()
self.example_feature_columns = _example_feature_columns()
self.features = _features()
self.ranker = _DummyUnivariateRankingNetwork(
context_feature_columns=self.context_feature_columns,
example_feature_columns=self.example_feature_columns)
After Change
def setUp(self):
super(UnivariateRankingNetworkTest, self).setUp()
(context_feature_columns, example_feature_columns,
custom_objects) = _get_feature_columns()
self._context_feature_columns = context_feature_columns
self._example_feature_columns = example_feature_columns
self._custom_objects = custom_objects
self._features = _features()
self._ranker = _DummyUnivariateRankingNetwork(
context_feature_columns=self._context_feature_columns,
example_feature_columns=self._example_feature_columns)


We welcome you to explore our accommodations, activities, gallery, and travel arrangements.
Accommodations | Activities | Travel Arrangements | Gallery | Contact Us


Advanced Teardrops Creation is a read-write DFM action that adds teardrops at the entrance of conductors into pads. For drilled pads, teardrops reduce the possibility of disconnections due to drill wander. For undrilled pads, teardrops strengthen the conductor to pad connection for special applications such as flex circuits.
A teardrop can be one of the following shapes:
* Straight - These teardrops are made up of lines half the width of the conductor drawn directly to the pad.
* Triangular - These teardrops are made up of lines the same width of the conductor drawn from the edge of the conductor to the pad.
* Filleted - These are made up of arcs the same width as the conductor drawn from the edge of the conductor bending in towards the pad.
* Rounded - The action adds a zero length line as Teardrop. The extension point is calculated from the pad center toward the entry point.
* Oval - The action adds a line that makes the line thicker at the entry point. The extension point is calculated from the entry point to the pad to the entry point of the Teardrop to the conductor.
Note: All teardrop features are tagged with the .tear_drop attribute.
Before
Straight
Triangular
Filleted
The option skip was added to the parameter Delete Old Teardrops.
If this option is selected, the action ignores any entry point of a line to a pad if at the entry point the line touches another line with a .tear_drop attribute.
If the entry point of the line to the pad is covered by more than two lines, the entry point will be ignored. The entry point will be reported in a new category: Suspected Teardrop.
The action provides:
* histograms of the full, one-sided, shortened, missing and problematic teardrops
* the locations where the conductors were too narrow
* the pads which were suspected as thermals.
Each of the histograms shows the pad name and count followed by the total count for the category. If there are no reports in the category, nothing is printed. A typical report looks like the following:
JOB : test
STEP : pcb
DATE : 19 Jul 1999
TIME : 15:48:16
Created on GENESIS
Action : Teardrop
Creation
Layer : cmp1
Full Teardrops
==============
Name(Pad) / Count
-----------------
r55 130
r65 7
s65 7
r75 3
s75 1
rect34x75xr5 116
rect70x136xr5 5
rect40x50xr5 45
rect75x34xr5 12
rect50x125xr5 15
rect60x64xr5 2
rect50x66xr5 4
rect75x60xr5 2
349 full teardrops
were added.
Shortened Teardrops
===================
Name(Pad) / Count
-----------------
r55 16
rect70x136xr5 2
rect75x34xr5 8
rect40x50xr5 9
rect50x125xr5 2
rect36x76xr5 2
rect34x75xr5 3
42 shortened teardrops
were added.
Missing Teardrops
=================
Name(Pad) / Count
-----------------
rect34x75xr5 2
2 locations are
missing teardrops.
|
Attribute |
Description |
|
...full |
Number of teardrops in the Full Teardrops category for each layer. |
|
...one_sided |
Number of teardrops in the One Sided Teardrops category for each layer. |
|
...shortened |
Number of teardrops in the Shortened Teardrops category for each layer. |
|
...missing |
Number of teardrops in the Missing Teardrops category for each layer. |
|
...problematic |
Number of teardrops in the Problematic Teardrops category for each layer. |
|
...narrow |
Number of locations in the Line Too Narrow category for each layer. |
|
...thermal |
Number of pads in the Suspected Thermal category for each layer. |
|
full |
Number of teardrops in the Full Teardrops category for all processed layers. |
|
one_sided |
Number of teardrops in the One Sided Teardrops category for all processed layers. |
|
shortened |
Number of teardrops in the Shortened Teardrops category for all processed layers. |
|
missing |
Number of teardrops in the Missing Teardrops category for all processed layers. |
|
problematic |
Number of teardrops in the Problematic Teardrops category for all processed layers. |
|
narrow |
Number of locations in the Line Too Narrow category for all processed layers |
|
thermal |
Number of pads in the Suspected Thermal category for all processed layers. |


ct.js is a new game editor (desktop app) based on web technologies, currently in active development. Our aim is to make it a simple game-making tool, accessible for both newbies and experienced game developers. It runs on WebGL and provide good performance both on PCs and mobile devices.
|
Easy to learn and use ct.js is designed to be used for learning and teaching programming. It is accessible and ready-to-use for both newbies and pros. |
Highly extensible library ct.js's core is small but powerful, and its modules can add you more abilities and higher-level functions. |
|
Runs on PC, Mac, Linux That's it. We support them all. One tool for everyone in your team, in any office or garage. |
Games that run everywhere Games created with ct.js run in any modern browser, including mobile ones, and can also be packed to executables for all the major desktop platforms! |
Mini Jam is an open recurring game jam that is held every two weeks on itch.io.
Join their Discord server or
visit their official site!


It seems that you don't have pages yet. Would you like to create one?
Could not find anything. Try to change search criteria.


| |
SSI service allow you to store various information on the server. Server-side
information is stored as a list of items. Here is common structure of item:
|
| xx xx |
|
word |
|
Length of the item name |
| xx .. |
|
string |
|
Item name string |
| xx xx |
|
word |
|
Group ID# |
| xx xx |
|
word |
|
Item ID# |
| xx xx |
|
word |
|
Type of item flag (see list bellow) |
|
| xx xx |
|
word |
|
Length of the additional data |
|
|
| |
| xx xx |
|
word |
|
TLV.Type (TLV #1) |
| xx xx |
|
word |
|
TLV.Length |
|
|
|
|
| |
|
| |
| xx xx |
|
word |
|
TLV.Type (TLV #n) |
| xx xx |
|
word |
|
TLV.Length |
|
|
|
|
| |
| |
|
|
|
About name of the item. It can be icq uin, aim screenname, group name or special id.
SSI contains a "master group" which contains all other groups. Master group has a
group ID# of 0x0000. All groups have item ID# of 0x0000. You can't have groups or
items with same group/item ID#.
Every item can have additional data stored as tlv chain. For example group item
can store its buddy ID numbers in TLV(0x00C8). Buddy item may contain buddy
comment in TLV(0x013C) or/and SMS number in TLV(0x013A) or/and alerts settings
in TLV(0x013D). You can't add buddy that requires authorization without permission.
You can add it only with TLV(0x0066) as a buddy record awaiting authorization.
Each item has a type. It can be buddy record, group record, permit record,
presence permissions or something other. Each item type have its limitations and
you can request them via SNAC(13,02). Here is the
list of known item types:
|
| 0x0000 |
Buddy record (name: uin for ICQ and screenname for AIM) |
| 0x0001 |
Group record |
| 0x0002 |
Permit record ("Allow" list in AIM, and "Visible" list in ICQ) |
| 0x0003 |
Deny record ("Block" list in AIM, and "Invisible" list in ICQ) |
| 0x0004 |
Permit/deny settings or/and bitmask of the AIM classes |
| 0x0005 |
Presence info (if others can see your idle status, etc) |
| 0x0009 |
Unknown. ICQ2k shortcut bar items ? |
| 0x000E |
Ignore list record. |
| 0x000F |
Last update date (name: "LastUpdateDate"). |
| 0x0010 |
Non-ICQ contact (to send SMS). Name: 1#EXT, 2#EXT, etc |
| 0x0013 |
Item that contain roster import time (name: "Import time") |
| 0x0014 |
Own icon (avatar) info. Name is an avatar id number as text |
|
|
|
Here is the list of known TLVs in additional data blob (itype - item type that
may have this tlv in its data blob):
[TLV(0x0066), itype 0x00, size 00] -
Signifies that you are awaiting authorization for this buddy. The client is
in charge of putting this TLV, but you will not receiving status updates for
the contact until they authorize you, regardless if this is here or not.
Meaning, this is only here to tell your client that you are waiting for
authorization for the person. This TLV is always empty.
[TLV(0x00C8), itype 0x01, size XX] -
If group is the master group, this contains the group ID#s of all groups in the
list. If the group is a normal group, this contains the buddy ID#s of all buddies
in the group. Each ID# is 2 bytes. If there are no groups in the list (if in the
master group), or no buddies in the group (if in a normal group), then this TLV
is not present.
[TLV(0x00C9), itype 0x05, size 04] -
Unknown (contain 0x0000006f when others could not see idle time, contain
0x0000046f when others could see idle time).
[TLV(0x00CA), itype 0x04, size 01] -
This is the byte that tells the AIM servers your privacy setting. If 1, then
allow all users to see you. If 2, then block all users from seeing you. If 3,
then allow only the users in the permit list. If 4, then block only the users
in the deny list. If 5, then allow only users on your buddy list.
[TLV(0x00CB), itype 0x04, size 04] -
This is a bit mask which tells the AIM servers which class of users you want
to be visible to. If 0xffffffff, then all users can see you. If 0x00000004, then
AIM users can not see you. See known user classes
here.
[TLV(0x00CC), itype 0x04, size 04] -
Bitmask of flags containing "Allow others to see..." options. The default
is 0x00000000. The flags are the following, logically ORed together:
- 0x00000002 - Do not allow others to see that I am using a wireless device
- 0x00000400 - Allow others to see my idle time
- 0x00400000 - Allow others to see that I am typing a response
[TLV(0x00CD), itype 0x09, size XX] -
This item type (9) looks like ICQ2k shortcut list. Examples: "2672,0,2,1"
and "3097,0,0,0"
[TLV(0x00D4), itype 0x13, size 04] -
TLV for import time item (type 0x0013). Contains timestamp in unix_t
format (seconds since 1.1.1970) when the buddylist has been first time
uploaded to the server
[TLV(0x00D5), itype 0x14, size XX] -
TLV for buddy icon info (type 0x0014). Contains the icon flags (1 byte),
md5 hash size (1 byte) and md5 hash of the you are using (allways
16 bytes).
[TLV(0x0131), itype 0x00, size XX] -
This stores the name that the contact should show up as in the contact
list. It should initially be set to the contact's nick name, and can be
changed to anything by the client.
[TLV(0x0137), itype 0x00, size XX] -
Your buddy locally assigned mail address.
[TLV(0x013A), itype 0x00, size XX] -
Your buddy locally assigned SMS number.
[TLV(0x013C), itype 0x00, size XX] -
This stores the "buddy comment" field. The max length winaim lets you use
is 0x0054. I'm not sure if that is a true limit or not.
[TLV(0x013D), itype 0x00, size 02] -
Personal alerts for this buddy.
First byte:
- 0x01 - Pop up window notification
- 0x02 - Play sound (sound file specified in 0x013e TLV)
Second byte:
- 0x01 - When contact comes online
- 0x02 - When contact becomes unidle
- 0x04 - When contact returns from away
[TLV(0x013E), itype 0x00, size XX] - Sound
client should play as alert for this buddy.
[TLV(0x0145), itype 0x00, size XX] -
Date/time (unix time() format) when you send message to this you first time.
Actually I noticed that ICQLite adds this TLV then you first open message
dialog at this user. Also I've seen this tlv in LastUpdateDate item.
| |
|
|
|