text:
---
layout: post
title: Development Roadmap
author:
- lrueda
date: '2017-06-26'
tags:
- roadmap
image: /images/2017/06/circle.png
doi: 10.5438/9tc-71yb-2jdg
---
Over the next several months DataCite will embark on a new development path focusing on member-facing services. Our goal is to provide easy, understandable, predictable, and robust services to create, manage, find, use and track DataCite DOIs to make data sharing and citation easier. Our activities are not limited to technical development but will include support services that will foster the successful use of all our services. Many of these activities come from all of you, the DataCite community, so thank you for the help.

First up, we will simplify authentication, allowing users to use the same login credentials for all DataCite services. Second, the creation and management of DOIs and quality metadata are crucial to DataCite’s mission of data-sharing. Our development path will make it easier than ever to create and manage DOIs and quality metadata. Many of our members use DataCite API to create DOIs, but sometimes there is a need for a simple form for the creation and management of a single DOI and accompanying metadata. Our new DOI input form will allow members to register and update DOIs and metadata and will use the most current version of the Metadata Schema and will include guidance on how to fill in each field.

Next, we will provide DataCite members, whether big or small, with all the tools necessary to manage and better understand their day-to-day activities. To do this, we are implementing an entirely new DOI Service Registry so that members can manage all their interactions in a single place. Members will be able to easily add accounts and users, request new prefixes, and manage existing prefixes.

Our members will also be able to get up-to-date statistics on their DOIs – How many DOIs did I create this month or year? How many DOIs did a data center create? This will allow members to accurately track their activities.

Finally, the persistence of DataCite DOIs is a top priority. Keeping DOIs persistent includes making sure URL links are active and healthy.  A link-checker service will provide an easy way for members to monitor URLs links of DataCite DOI to see if any are broken.

![Puzzle](/images/2017/06/puzzle.svg)

One of the goals with our new development is to keep the community continually informed of what we are working on and the direction we are planning to take next. We also take seriously your input and ideas. As part of the wide scholarly communications ecosystem, we are proud to be open and transparent!

![Circle](/images/2017/06/circle.svg)

Two important features aid our development -- our [DataCite User Stories](https://www.datacite.org/user-stories.html) and our [DataCite Development Roadmap](https://www.datacite.org/roadmap.html). The User Stories collect descriptions of new features and requirements, and the Roadmap takes those User Stories and organizes them into projects and prioritizes our development.

GitHub and Waffle are the tools we chose to make them all available and collect your feedback, but you can also explore them in our website:

* User Stories: [https://www.datacite.org/user-stories.html](https://www.datacite.org/user-stories.html)
* Development Roadmap: [https://www.datacite.org/roadmap.html](https://www.datacite.org/roadmap.html)
* GitHub: [https://github.com/datacite/datacite](https://github.com/datacite/datacite)
* DataCite waffle.io board: [https://waffle.io/datacite/datacite](https://waffle.io/datacite/datacite)

![Workflow](/images/2017/06/workflow.png)

We are excited about the work in front of us and want your continued input. Please review our roadmap, add your comments and suggestions, and help us shape our next steps. Your input is key!

repository: datacite/blog

gha_language: TeX

repo_name: datacite/blog


text:
# EarthLife Consortium API production deployment

This deployment utilizes:
* NGINX as the gateway webserver and reverse proxy
* uWSGI as the preforking application server
* A POSIX complient Unix-like underlying OS

## Installation
Install API with

```
git clone https://github.com/EarthLifeConsortium/elc_api.git
pip3 install -r requirements.txt
```
Install uWSGI
```
pip3 install uwsgi
```
Use the system installer (brew, apt-get, rpm, port etc.) to build NGINX and, optionally, swagger-codegen

## Development
Develop and debug OpenAPI (aka Swagger) definition with swagger-editor
```
git clone https://github.com/swagger-api/swagger-editor.git
npm start
```

Build initial server stubs with swagger-codegen
```
swagger-codegen generate -i ./swagger.yaml -l python-flask -o [your path]/elc_api
```

Test the API using Flask's Werkzeug single threaded develoment server
```
python3 -m swagger_server
```

Build the website and documentation
```
cd www
make html
```

## Deployment
Run API concurrently across multiple logical cores using uWSGI
```
uwsgi --socket <IP_ADDRESS>:8008 --callable app --file swagger_server/app.py --master -p 4 --threads 2 --stats <IP_ADDRESS>:9009 --memory-report --wsgi-disable-file-wrapper --buffer-size=262144
```
Note: `--protocol=http` is omitted becasuse NGINX can nativly speak the uWSGI protocol. These parameters are included in a config file so `uwsgi elc-api.ini` will also work. Daemonize the uWSGI stack with `-d /[path]/[logfile]`

If statistics and memory usage reporting is enabled, monitor workers with
```
Or, use the included config file
```
uwsgi elc-api.uwsgi.ini
```
uwsgitop <IP_ADDRESS>:9009
```
To put the API behing a full webserver add a reverse proxy. NGINX supports the uWSGI native protocol so bind the port in nginx.conf with
```
location ^~ /api_v1 {
    include uwsgi_params;
    uwsgi_pass <IP_ADDRESS>:8008;
}
```
The Sandbox UI can be customized to match the look and feel of the rest of the ELC site by symlinking the files in ./web_ui into the local installation of the Connexion library. Example:
```
ELC-logo-horz-M.png --> [path to connexion/vendor/swagger-ui/images/

index.html --> [path to connexion]/vendor/swagger-ui/
```

branch_name: refs/heads/master

extension: md

gha_language: Python

license_type: permissive


text:
# Words

TODO Automatically add words from book notes

These are words I have had to look up recently. I'd like to have a better list so that I can peruse it later.

corrie
col
lamellar, adj.
enfeoff, v.
inscient, adj.
_quid pro quo_, phrase.
détente. n. the easing of hostility or strained relations, especially between countries: a serious effort at detente with the eastern bloc. early 20th cent.: from French détente, literally ‘loosening, relaxation.’
albumen. n. egg white, or the protein contained in it.
tor, n. a hill or rocky peak. Old English torr, perhaps of Celtic origin and related to Welsh tor ‘belly’ and Scottish Gaelic tòrr ‘bulging hill.’
incommensurate, adj. [ predic. ] (incommensurate with) out of keeping or proportion with. mid 17th cent.: from late Latin commensuratus, from com- ‘together’ + mensuratus, past participle of mensurare ‘to measure.’
alterity, n. the state of being other or different; otherness. mid 17th cent.: from late Latin alteritas, from alter ‘other.’
olid, adj. smelling extremely unpleasant. late 17th cent.: from Latin olidus ‘smelling,’ from olere ‘to smell.’
mridangas
sistra
hyssop
arrack
ladyship
gambeson
sumpter
gazehound
couchant
wood
opal
bloodstone
morganite
cat's-eye
rhodolite
rosetone
tourmaline
jasper
lamiae
tumbrel
hobliar
palisse
sorrowing
obviate, v. remove (a need or difficulty): the Venetian blinds obviated the need for curtains.
dirigisme, n. state control of economic and social matters.
caudillos, n. (in Spanish-speaking regions) a military or political leader.
cagoule, n. a lightweight, hooded, thigh-length waterproof jacket.
catalytic, adj. relating to or involving the action of a catalyst.
haar, n. a cold sea fog on the east coast of England or Scotland. late 17th cent.: perhaps from Old Norse hárr ‘hoar, hoary’.
nostrum, n. a medicine, especially one that is not considered effective, prepared by an unqualified person. early 17th century: from Latin, used in the sense ‘(something) of our own making,’ neuter of noster ‘our.’
Proprioception, n. from Latin proprius, meaning "one's own", "individual", and capio, capere, to take or grasp, is the sense of the relative position of neighbouring parts of the body and strength of effort being employed in movement.
hobnail. n. a short heavy-headed nail used to reinforce the soles of boots.
dasymetric, adj. "The dasymetric map is a method of thematic mapping, which uses areal symbols to spatially classify volumetric data." - Wikipedia
chloropleth adj. a thematic map in which areas are shaded or patterned in proportion to the measurement of the statistical variable being displayed on the map, such as population density or per-capita income. (from Greek χῶρος ("area/region") + πλῆθος ("multitude"))
prorate v. allocate, distribute, or assess pro rata
pro rata adv., adj. proportional
squamous, adj. covered with or characterized by scales. late Middle English: from Latin squamosus, from squama ‘scale.’
teratogen, n., an agent or factor that causes malformation of an embryo.
teratogenic, adj., of, relating to, or causing developmental malformations
crapulent, adj ., of or relating to the drinking of alcohol or drunkenness.
floreted, adj., decorated with small flowers
bromides, n., a trite and unoriginal idea or remark, typically intended to soothe or placate: feel-good bromides create the illusion of problem solving. Ex: "When early Americans wrote things like “Eternal vigilance is the price of liberty,” they did not do so to provide bromides for future bumper stickers."
diktat. n. an order or decree imposed by someone in power without popular consent: a diktat from the Bundestag | he can disband the legislature and rule by diktat.
expatiate - speak or write at length or in detail
skerrik - A very small amount or portion, particularly used in the negative and chiefly in British and Australian English.
theophany - a visible manifestation to humankind of God or a god.
Candlemas, n., a Christian festival held on February 2 to commemorate the purification of the Virgin Mary (after childbirth, according to Jewish law) and the presentation of Christ in the Temple. Candles were traditionally blessed at this festival.
ethogram - a catalog or table of all the different kinds of behavior or activity observed in an animal.
maladaptations - not providing adequate or appropriate adjustment to the environment or situation.
lochia - the normal discharge from the uterus after childbirth.
puerpirium - the period of about six weeks after childbirth during which the mother's reproductive organs return to their original nonpregnant condition.
etiology - the cause, set of causes, or manner of causation of a disease or condition; the investigation or attribution of the cause or reason for something, often expressed in terms of historical or mythical explanation.
foundling - an infant that has been abandoned by its parents and is discovered and cared for by others.
childbed fever - a disease characteristic of and limited to maternity patients, for whose origin the puerperal state and a specific causal moment are necessary.
dispose - arrange in a particular position.
glacis - a gently sloping bank, in particular one that slopes down from a fort, exposing attackers to the defenders' missiles. ety: late 17th cent.: from French, from Old French glacier ‘to slip,’ from glace ‘ice,’ based on Latin glacies .
resorption - the process or action by which something is reabsorbed.
denunciation - public condemnation of someone or something.
vermivorous - feeding on earthworm
anuran - a tailless amphibian of the order Anura; a frog or toad.
onymity - The condition of being onymous, or named.
scintilla - a tiny trace or spark of a specified quality or feeling
kibitz - A Kibitzer is a Yiddish term for a person who offers (often unwanted) advice or commentary. This term can be applied to any activity, but it is most notably used to describe non-participant spectators in contract bridge, chess, go, and many other games. The verb kibitz can also refer to idle chatting or side conversations.
gravid, adj. full of meaning or a specified quality, technical: pregnant; carrying eggs or young.
nonpareil, adj. having no match or equal; unrivalled
heliophilic, adj. sun loving
briars, n. (also briar pipe) a tobacco pipe made from woody nodules borne at ground level by a large woody plant of the heather family.
euryhaline, adj. able to tolerate a wide range of salinity.
stenohaline, adj.  able to tolerate only a narrow range of salinity.  Canicula - under the Dog Star, Sirius - the dogdays of summer.
Pirandellian, adj. a mixing of fact and fiction, after the Italian playwright
cabriolet, n. convertible
maven, n. an expert or connoisseur. Yiddish, 1960s.
sarsen, n. a silicified sandstone boulder of a kind which occurs on the chalk downs of southern England. Such stones were used in constructing Stonehenge and other prehistoric monuments.
borde, n. Middle English variant of _board_.
lamplighter, n. a person employed to lights lamps. Probably never used stilts to do so.
contumely, n. insolent or insulting language or treatment. late Middle English: from Old French contumelie, from Latin contumelia, perhaps from con- ‘with’ + tumere ‘to swell’.
fardel, n. a bundle. Middle English: from Old French.
shissel, n. a bowl (Yiddish)
dun, v. make persistent demands on (someone), especially for payment of a debt
statin, n. any of a group of drugs which act to reduce levels of cholesterol in the blood.
rattletrap, n. an old or rickety vehicle
anthers, n. the part of a stamen that contains the pollen.
bergomot, n. an aromatic North American herb of the mint family, grown for its bright flowers and traditionally used in American Indian medicine. Also a varietal of Seville orange.
crop milk, n. a secretion from the lining of the crop of parent birds that is regurgitated to young birds.
squab, n. a baby pigeon
imprint, n. a baby bird
saker, n. a kind of falcon
houbara bustard, n. a large bird in the bustard family
bumblefoot, n. an infection found on the feet of birds of prey and some animals
xenodochial, adj., friendly to strangers
well-helled, adj. wealthy
abatis
A battery
abaxial
abbé
Abbevillain
ABC powers
ABC soil
abducens nerve
abededarian
Abelian
abelmust (Hibiscus muscatus)
abeyance (of succession)
abib
abigail
ab initio
abiogenesis
hansel
sectary
abonos
morta
kala nuts,
olein
stearin
fractionation
interesterification
glycerolysis
tocostrients
amines
amides
humectants
oleochemicals
tocotrienols
mesocarp
stearic acid
sodium lauryl surfate
cocoa-pod borer
okoume
blue duiker
sastrogi
abjurant
ablate, v. to remove
ablative
ablative absolute
abloom
abnegate, v. to deny or surrender
abomasum
aboral
abortifacient
ABO system (of blood)
virgules
clumber
angstrom
-a (oxide)
reperatory
aba
AB
abaea
à bas
vizard
trull
entrain, v. cause or bring about as a consequence
Eulerian path, n. a graph in which each edge is visited only once
détente, n. the loosening or easing of relations, esp. between countries.
bampot, n. a mad person. Scots, English
stotious, adj. drunk. Scots
foley, adj. the name for the kind of recording that sound recorders for movies do with lots of little things that make a movie more realistic
lexicographical order, n. mathematics term for alphabetic order which includes numbers
hegiras, n. an exodus or migration.
janjaweed, n. African reavers. From an Arabic phrase meaning 'devils on horseback'
satori, n. sudden enlightenment
wuxia, n. a genre of Chinese fiction or cinema featuring itinerant warriors of ancient China, often depicted as capable of superhuman feats of martial arts.
pirogue, n. a long, narrow canoe made from a single tree trunk, especially in Central America and the Caribbean.
pomological, adj. related to the story of apples
secateur, n. a pair of pruning clippers for use with one hand.
doss, v. sleep in rough accommodation or on an improvised bed, or to spend time idly.
bathetic, adj. producing an unintentional effect of anticlimax
espalier, n. a fruit tree or ornamental shrub whose branches are trained to grow flat against a wall, supported on a lattice.
tony, n. fashionable among wealthy or stylish people
litotes, n. ironic understatement in which an affirmative is expressed by the negative of its contrary
litotic, adj. like litotes
legerity, speed.
pro forma, phrase, done as a matter of form.
broekie, n. women's underwear in south africa
contrapuntal, adj. of or in counterpoint.
pluton, n. a body of intrusive igneous rock.
bilettes
Vitraux de Claire
ambulatory
fibrillating
serried
Waardenburg syndrome
apsidal
cassock
precipition
samsaric
coralligenous, adj. like coral
envemon, to have venom in you
stithies
adit
moran, n. warrior - Maasai
chalicotherium, n. cool bear/sloth/horse/ape mix.
doloires, n. a flarex ax like a trumpet, used for cutting green oak to remake the Notre Dame beams
caissons, n. cases for gunpowder
guidons, n. a pennant that narrows to a point or fork at the free end, especially one used as the standard of a light cavalry regiment.
minuscule, adj. Not miniscule. early 18th century: from French, from Latin minuscula (littera) ‘somewhat smaller (letter)’.
inanition, n. exhaustion caused by lack of nourishmen
mbira, n. (especially in southern Africa) another term for thumb piano.
cardiac glycosides, n. toxins
aposematic, adj. showing colors that signal toxicity or veer predators away. From apo + sematic.
monoceious, adj. flowers on an individual tree are all the same sex
dioecious, adj. flowers on an individual tree of either sex
dirndl, n. a woman's dress in the style of Alpine peasant costume, with a full skirt and a close-fitting bodice.
reinanken, n. whitefish (German)
Saibling, n. A European mountain trout ({Salvelinus alpinus}); -- called also {Bavarian charr}.
corm, n. a short, vertical, swollen underground plant stem that serves as a storage organ that some plants use to survive winter or other adverse conditions such as summer drought and heat
perennation, n. the ability of organisms, particularly plants, to survive from one germinating season to another, especially under unfavourable conditions such as drought or winter.
sarus cranes, n. a bird
hydrophytes, n.
nypmhiodies
jamun tree
nudos, n. knot (a looping piece of a long, flexible material) knot (nautical unit of speed)
Oriente, n. a region of eastern Ecuador, comprising the eastern slopes of the Ecuadorian Andes and the lowland areas of rainforest in the Amazon basin.
hazelbert, n. a cross between a hazelnut and a filbert tree.
Cantastoria, n. singer-teller
red-baiting, n. calling someone a communist. "The personal attacks on Carson ranged from sexism to red-baiting."
morpho, n. A type of butterfly
tepui, n. a type of mesa or plateau in the Amazon, made famous by _The Lost World_ and _Up!_
bellbirds, n. a type of south american bird
to augur into, ph. Used in National Geographic to mean to slip into a crack. I think wrong.
immiscible, adj. except for the immischible magisteria of my cloven soul
zebu, n. indian cattle species
mare (pl maria), n. a large, level basalt plain on the surface of the moon, appearing dark by contrast with highland areas
bolus, n. a food ball of bugs that swifts use to bring back to their young
forestall, v. to halt
asseverate, v. declare or state solemnly or emphatically
quilombo, n. a refuge, a community of ex-slaves in Brazil
congee, n. an oriental dish that revitalizes, like porridge
lignin, n. a chemical that helps woody growth.
anticline, n. a formation of strata
rota Fortunae, n. the wheel of Fortune, from Boetheius
salvific, adj. related to salvation
Essene, sect of Jews at Qumran
Davidic, adj. related to King David
rônier palm, n. borassus aethiopum. Also called black rhun palm, ron palm, deleb palm.
foxing, adj. the reddening of black or gray areas as a result of breakdown of melanin in feathers
taradiddle, n. a small lie
mumia, n. ground mummies for medicine
gussied up, v. /ˈɡʌs.i/ US informal often humorous. to make someone or something look more attractive or impressive:

license: MIT

repository: RichardLitt/knowledge

gha_language: HTML

gha_license_id: MIT

repo_name: RichardLitt/knowledge


text:
# Autoencoder Reconstruction Visualizer

Visualizes the gradual process where autoencoder encodes and decodes images
using MNIST hand-written digit dataset as an example.

## Dependencies

- TensorFlow
  - Tested with TF 1.7, however, `tf.contrib.learn.datasets` is deprecated
    and will be removed in a future version
  - Not included in `requirements.txt` because there are multiple versions
    available (cpu and gpu), install manually
- Numpy
- Matplotlib
- Imagemagick (used for creating gif from individual images)

## Installation

You can install dependencies with `make init`, which uses pip to install
Numpy and Matplotlib. Virtualenv is always recommended.

## Usage

You can run the script with `python autoencoder_visualizer.py`. Alternatively,
`make run` does the same thing. This saves the images into figures folder
(from different steps of reconstruction).

When you want to combine images into a gif, just run `make gif`.

## Example output gif

Here is an example gif generated by the script visualizing the first 200
iterations of autoencoder reconstructing one single image from the MNIST datset.

![test](animation.gif)


text:
# Changes/Additions
Relationships are now based off of the url_key

```python
relationship = {'type': cleaned_data.get('forward_type'),
                'url_key': cleaned_data.get('forward_value')}
```

```python
#Always check for class from value first
rel_item = class_from_value(right_type, right_id)
if not rel_item:
    rel_item = class_from_id(right_type, right_id)
```

___

Relationships can be added without both items existing. This allows for items coming in through the taxii_service to send relationships without having to send the entire item.

If an item is related to an item that doesn't exist, the link on the details page will just not point to anything. As soon as the item is in the database, the link will become active and the new item will get the relationship on it's end as well.

---

Added a TAXII trigger. This is done simply by setting the releasability flag when a new relationship is formed.

```python
 set_releasability_flag(cleaned_data.get('forward_type'), cleaned_data.get('forward_value'), request.user.username)
```

# Bug fix

Capitalized the relationship type to make it easier to plug into the STIX message.

```python
if new_confidence not in ('Unknown', 'Low', 'Medium', 'High'):
```

repository: LauraNolan/marti

repo_name: LauraNolan/marti


text:
# Omphalocystis Balbiani GENUS

#### Status
ACCEPTED

#### According to
Index Fungorum

#### Published in
J. Anat. Physiol. Norm. Pathol. Homme Anim. Paris 25: 6 (1889)

#### Original name
Omphalocystis Balbiani

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# Palaeorubus Ishiga in Ishiga, Leitch, Naka, Watanabe & Iwasaki, 1987 GENUS

#### Status
ACCEPTED

#### According to
Interim Register of Marine and Nonmarine Genera

#### Published in
in Ishiga, Leitch, Naka, Watanabe & Iwasaki, Earth Sci (Tokyo) 41 (6): 300.

#### Original name
null

### Remarks
null


text:
# AUL

[![Greenkeeper badge](https://badges.greenkeeper.io/zemd/aul.svg)](https://greenkeeper.io/)

> Elegant database queries executor

[![npm version](https://badge.fury.io/js/aul.svg)](https://www.npmjs.com/package/aul)
[![Build Status](https://travis-ci.org/zemd/aul.svg?branch=master)](https://travis-ci.org/zemd/aul)
[![Code Climate](https://codeclimate.com/github/zemd/aul/badges/gpa.svg)](https://codeclimate.com/github/zemd/aul)
[![CircleCI](https://circleci.com/gh/zemd/aul/tree/master.svg?style=svg)](https://circleci.com/gh/zemd/aul/tree/master)
[![dependencies:?](https://img.shields.io/david/zemd/aul.svg)](https://david-dm.org/zemd/aul)
[![devDependencies:?](https://img.shields.io/david/dev/zemd/aul.svg?style=flat)](https://david-dm.org/zemd/aul)
[![Inline docs](http://inch-ci.org/github/zemd/aul.svg?branch=master)](http://inch-ci.org/github/zemd/aul)

## Introduction

Because every web developer must implement his own template engine and orm, this package was born. ORM is recently the most
popular way of working with data. It essentially great, but why everyone should think that tables in database is objects
in the code - I don't know. Mapping going to be very complex procedure when you want to make something
not usual and not common for every database engine.

Quick example, if you worked with loopbackjs you probably know that you can't make joins, you can't use complex sql queries
and map results automatically. SailsJS also has no transaction support! You need to make workaround each time you need to
use SQL. So the question is - why do you ever need this abstraction if you limited with database common features. If you
want to switch to another database (postgresql -> mongo for example) you will definitely need to rewrite you model, and it's
usage. And if you need to change your orm provider - you will need to change a lot of code, because each orm has it's own
model lifecycle.

Complexity of ORM/ODM solves many problems to hide that **DATA IS STORED IN DATABASE AS TABLE OR DOCUMENT**. And each such
library makes it's own approach that usually it is hard to *test queries*, *migrate from one orm to another*, *use SQL* or
*use your database engine's features*. And I think DBA guys is not very happy with queries that orm usually builds.

## Installation

```bash
npm install aul --save
```

or

```bash
yarn add aul
```

## Usage

Let's make a quick example of how this `yet another orm killer` can help you with your database logic.

**NOTE 1:** you should know - your data is stored in tables, documents or any other storage you use in your app. And you access
it by using it's natural syntax. If you need JOIN 2 tables, you may do this.

**NOTE 2:** Aul is general library with some basic abstractions around data queries. So you need to add some `adapter` for your
database. (in the following example I will use knex adapter)

```javascript
const {Criteria, Executor} = require("aul");
const KnexAdapter = require("aul-knex");
const MyModel = require("./my-model");

// Firstly let's create general Criteria object which will hold all info about what we need to fetch from database
const criteria = new Criteria("table_name_or_collection_name");
criteria.addFilter("active", {active: true});
criteria.addMapper((result) => MyModel.from(result));

// Now let's instantiate executor and pass a `path` option so executor could find you custom filters
const executor = new Executor({path: "path/to/the/folder/with/filters"});

// we need to set adapter which will provide query builder and will execute the query
executor.setAdapter(new KnexAdapter({
    client: "pg", // DO NOT FORGET TO INSTALL `pg` module also
    connection: process.env.DATABASE_URL,
    searchPath: "public"
}));

// now we can execute our criteria
executor.execute(criteria);
```

So in this little example, we built custom criteria to fetch data from table called `table_name_or_collection_name` and
also we defined that we want to filter all records by passing active **filter**. *Filter* is a simple middleware function that
mutates query builder object in way it needs. For example, we have a query builder that holds `SELECT * FROM table` and after proceeding
"active" filter, query will looks like `SELECT * FROM table WHERE active = true`.

As you may see you should implement your filter by yourself and executor must know where you filters are located.

*KnexAdapter* object is created by passing the same options that knex library requires. So nothing special here.

Now let's see how your active filter should look like:

```javascript
module.exports = ({active = true}) => {
  return async (knex, next) => {
      knex.andWhere('active', '=', !!active);
      await next();
  };
};
```

As you can see nothing special either. You just need to use knex query builder.

#### So what does it give to you?

 1. It gives you freedom. Now you do not need to think how to join or use some complex SQL, you simply use it.
 2. It gives you a way to abstract from SQL strings, and use query builder you want, you can use mongo client object if you want
 3. You can **test** each filter independently and **use** them like configuration parts of you criteria.
 4. You can migrate from one database to another by implementing filters for another adapter. But you do not need to change
 criteria definition itself.
 5. It is very lightweight abstraction without any complex logic inside. Filters are running like regular middlewares one by one,
 and they can be asynchronous.

#### What about objects? Do you need mapper?

Sure. You need mapper. But you **can** to choose. Aul has very limited approach to map your data into pure object.
You should provide your mapper in `criteria.setMapper()`.

I will show example with mapping using `muesli` library.

```javascript
const Mapper = require("aul-muesli");
const Model = require("muesli");

class Author extends Model {
    constructor() {
        supper({
            name: {
                filter: "string",
                constraints: [required("group1")]
            },
            lastname: {
                filter: "string",
                constraints: [required()]
            },
            fullname: {
                filter: function (deps) {
                    return deps.join(" ");
                },
                computed: ["name", "lastname"]
            }
        });
    }
}

class Book extends Model {
    constructor() {
        super({
            title: {
                filter: "string"
            }
        });
    }
}

const map = {
    // simple rule to map `column` -> `field`
    // if column name is the same with field name you can omit
    "column": "field",
    //you can omit this column
    "column2": false,
    // or you can pass your own mapping algorithm, to map nested models
    "authors": (authors) => authors.map(a => Author.from(a))
};

criteria.addMapper(map);
// Mapper can be pure function that obtain 1 result
criteria.addMapper((result) => Book.from(result));

// `execute` method is asynchronous
let results = await executor.execute(criteria);
```

You can have any amount of mappers. But remember order matters!

#### What about update/insert queries?

As you can see objects that you get in the end is not the same magic objects that you get in any ORM. You can't make
save() or update(). Thus, you need to construct your own algorithm, where you can control batching, field passed etc.

Example,

```javascript

class UpdateCriteria extends Criteria {
    constructor() {
        super("table_name");
        this.addFilter("update", {active: true, status: "UPDATED"});

        this.addFilter("active", {active: false});
    }
}
```

So now you see that UpdateCriteria is nothing else than regular criteria, where you can use your common filters.

## License

Aul is released under the MIT license.

## Donate

[![](https://img.shields.io/badge/patreon-donate-yellow.svg)](https://www.patreon.com/red_rabbit)
[![](https://img.shields.io/badge/flattr-donate-yellow.svg)](https://flattr.com/profile/red_rabbit)

repository: zemd/aul

gha_language: JavaScript

repo_name: zemd/aul


text:
# Contributor's Manual

## Human communication

The project lead is @xiaq, who is reachable in the user group most of the time.

If you intend to make user-visible changes to Elvish's behavior, it is good idea
to talk to him first; this will make it easier to review your changes.

On the other hand, if you find it easier to express your thoughts directly in
code, it is also completely fine to directly send a pull request, as long as you
don't mind the risk of the PR being rejected due to lack of prior discussion.

## Testing changes

Write comprehensive unit tests for your code, and make sure that existing tests
are passing. Tests are run on CI automatically for PRs; you can also run
`make test` in the repo root yourself.

Respect established patterns of how unit tests are written. Some packages
unfortunately have competing patterns, which usually reflects a still-evolving
idea of how to best test the code. Worse, parts of the codebase are poorly
tested, or even untestable. In either case, discuss with the project lead on the
best way forward.

### ELVISH_TEST_TIME_SCALE

Some unit tests depend on time thresholds. The default values of these time
thresholds are suitable for a reasonably powerful laptop, but on
resource-constraint environments (virtual machines, embedded systems) they might
not be enough.

Set the `ELVISH_TEST_TIME_SCALE` environment variable to a number greater than 1
to scale up the time thresholds used in tests. The CI environments use
`ELVISH_TEST_TIME_SCALE = 10`.

## Documenting changes

Always document user-visible changes.

### Release notes

Add a brief list item to the release note of the next release, in the
appropriate section.

The release notes live in `website/blog`; the symlink `NEXT-RELEASE.md` at the
repo root always points to those of the next release.

### Reference docs

Reference docs are interspersed in Go sources as comments blocks whose first
line starts with `//elvdoc` (and are hence called _elvdocs_). They can use
[Github Flavored Markdown](https://github.github.com/gfm/).

//
// Example:
//
// ```elvish-transcript
// ~> name-of-fn something
// ▶ some-value-output
// ```

func nameOfFn() { ... }
````

Generally, elvdocs for functions have the following structure:

-   A line starting with `//elvdoc:fn`, followed by the name of the function.
    Note that there should be no space after `//`, unlike all the other lines.

-   An `elvish` code block describing the signature of the function, following
    the convention [here](website/ref/builtin.md#usage-notation).

-   Description of the function, which can be one or more paragraphs. The first
    sentence of the description should start with a verb in 3rd person singular
    (i.e. ending with a "s"), as if there is an implicit subject "this
    function".

-   One or more `elvish-transcript` code blocks showing example usages, which
    are transcripts of actual REPL input and output. Transcripts must use the
    default prompt `~>` and default value output indicator `▶`. You can use
    `elvish -norc` if you have customized either in your `rc.elv`.

Place the comment block before the implementation of the function. If the
function has no implementation (e.g. it is a simple wrapper of a function from
the Go standard library), place it before the top-level declaration of the
namespace.

Similarly, reference docs for variables start with `//elvdoc:var`:

```go
//elvdoc:var name-of-var
//
// Something.
```

Variables do not have signatures, and are described using a noun phrase.
Examples are not always needed; if they are, they can be given in the same
format as examples for functions.

## Generating code

Elvish uses generated code in a few places. As is the usual case with Go
projects, they are committed into the repo, and if you change the input of a
generated file you should re-generate it.

Use the standard command, `go generate ./...` to regenerate all files.

Dependencies of the generation rules:

-   The `stringer` tool: Install with
    `go get -u golang.org/x/tools/cmd/stringer`;

-   An installed `elvish` in your PATH;

## Formatting source files

Install [goimports](https://pkg.go.dev/golang.org/x/tools/cmd/goimports) to
format Go files, and [prettier](https://prettier.io/) to format Markdown files.

```sh
go get golang.org/x/tools/cmd/goimports
npm install --global prettier
```

Once you have installed the tools, use `make style` to format Go and Markdown
files. If you prefer, you can also configure your editor to run these commands
automatically when saving Go or Markdown sources.

Use `make checkstyle` to check if all Go and Markdown files are properly
formatted.

## Licensing

By contributing, you agree to license your code under the same license as
existing source code of elvish. See the LICENSE file.

repository: zzamboni/elvish

repo_name: zzamboni/elvish


text:
# EpisodesApi

All URIs are relative to *https://localhost*

Method | HTTP request | Description
------------- | ------------- | -------------
[**episodesIdGet**](EpisodesApi.md#episodesIdGet) | **GET** /episodes/{id} |

# **episodesIdGet**
> EpisodeRecordData episodesIdGet(id, acceptLanguage)

Returns the full information for a given episode id. __Deprecation Warning:__ The _director_ key will be deprecated in favor of the new _directors_ key in a future release.

### Example
```java
// Import classes:
//import io.swagger.client.ApiClient;
//import io.swagger.client.ApiException;
//import io.swagger.client.Configuration;
//import io.swagger.client.auth.*;
//import io.swagger.client.api.EpisodesApi;

ApiClient defaultClient = Configuration.getDefaultApiClient();

// Configure API key authorization: jwtToken
ApiKeyAuth jwtToken = (ApiKeyAuth) defaultClient.getAuthentication("jwtToken");
jwtToken.setApiKey("YOUR API KEY");
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//jwtToken.setApiKeyPrefix("Token");

EpisodesApi apiInstance = new EpisodesApi();
Long id = 789L; // Long | ID of the episode
String acceptLanguage = "acceptLanguage_example"; // String | Records are returned with the Episode name and Overview in the desired language, if it exists. If there is no translation for the given language, then the record is still returned but with empty values for the translated fields.
try {
    EpisodeRecordData result = apiInstance.episodesIdGet(id, acceptLanguage);
    System.out.println(result);
} catch (ApiException e) {
    System.err.println("Exception when calling EpisodesApi#episodesIdGet");
    e.printStackTrace();
}
```

### Parameters

Name | Type | Description  | Notes
------------- | ------------- | ------------- | -------------
 **id** | **Long**| ID of the episode |
 **acceptLanguage** | **String**| Records are returned with the Episode name and Overview in the desired language, if it exists. If there is no translation for the given language, then the record is still returned but with empty values for the translated fields. | [optional]

### Return type

[**EpisodeRecordData**](EpisodeRecordData.md)

### Authorization

[jwtToken](../README.md#jwtToken)

### HTTP request headers

 - **Content-Type**: application/json
 - **Accept**: application/json

gha_language: Java


text:
# JIRA Brancher

[![https://nodei.co/npm/jira-brancher.png?downloads=true&downloadRank=true&stars=true](https://nodei.co/npm/jira-brancher.png?downloads=true&downloadRank=true&stars=true)](https://www.npmjs.com/package/jira-brancher)

Install:

`npm i -g jira-brancher`

Usage:

`jirabrancher`

The CLI will guide you through configuring your JIRA host, user & password.

JIRA Brancher will store 3 values in `$HOME/.jirabrancher`:

* `JIRA_HOST` - the hostname of your JIRA server
* `JIRA_USER` - the username for your JIRA account
* `JIRA_BASICAUTH` - the HTTP Basic auth token used to connect to your JIRA server

On subsequent runs, you'll just need to provide a JIRA ticket number:

```shell
$ jirabrancher
Enter your JIRA ticket or ticket URL: YUM-1
Use the following branch name:
YUM-1/Create-A-Delicious-Recipe
```

Or, as a CLI argument.

```shell
$ jirabrancher YUM-1
Use the following branch name:
YUM-1/Create-A-Delicious-Recipe
```

repository: shakeelmohamed/jira-brancher

repo_name: shakeelmohamed/jira-brancher


text:
---
date: 2019-10-29T10:02:21+0100
layout: rafaga
rafagas:
- desc: A one-day course to learn PyQGIS API from the ground up, along with another
    for GDAL
  keyw: python
  link: https://courses.spatialthoughts.com/pyqgis-in-a-day.html
  microlink:
    desc: This course is also offered as a in-person class. Please visit www.spatialthoughts.com
      to see the schedule for upcoming sessions.
    image: https://courses.spatialthoughts.com/images/pyqgis/console.png
    logo: https://logo.clearbit.com/spatialthoughts.com
    title: PyQGIS in a Day
- desc: This tutorial explores how to create a Lego map using only QGIS
  keyw: qgis
  link: https://medium.com/@andriyyaremenko/how-to-create-lego-map-style-in-qgis-a8ecf42d02ef
  microlink:
    desc: Last few months I saw some maps in Lego Style. It’s looking very interesting
      and catching but unfortunately, all the tutorials that I able to find are for
      ArcPro. So, I decided to change this…
    image: https://miro.medium.com/max/1200/1*uj1UG7pbWkvaFscSTZzxmw.png
    logo: https://miro.medium.com/max/616/1*OMF3fSqH8t4xBJ9-6oZDZw.png
    title: How to create Lego Map Style in QGIS
- desc: Urbano is modeling and simulating software that combines Rhinoceros and Grasshopper
    for all kinds of urban planning tasks
  keyw: urban planning
  link: https://urbano.io/
  microlink:
    desc: Urbano, Mobility tool for urban design
    image: https://urbano.io/assets/img/logo.svg
    logo: https://urbano.io/assets/img/favicon.ico
    title: Urbano
rid: 1196
---

repository: geoinquiets/rafagas

branch_name: refs/heads/gh-pages

gha_language: SCSS

gha_license_id: NOASSERTION

repo_name: geoinquiets/rafagas


text:
## **Azure Blob Connector**

The Skydrill Azure Blob connector allows querying data stored in Azure Blob storage. The connector is based on the Presto Hive connector with semantics similar to its Amazon S3 support. The Skydrill connector comes with added feature of an Azure Blob catalog store, allowing you to quickly onboard your data without the need for a thrift based metastore.

### Configuration

Create etc/catalog/blob.properties with the following contents to mount the skydrill-hive connector as the catalog for your blob data, replacing `mycontainer` and `myblobstorageaccount` and access key(s) with the actual ones for your data:

    connector.name=skydrill-hive
    hive.metastore=blob
<EMAIL_ADDRESS>    azure-blob.accounts=myblobstorageaccount,myblobstorageaccount1,myblobstorageaccount2
    azure-blob.account-keys=account1accesskey,account2accesskey,account3accesskey

### Storage Account Configuration

Storage account information can be done either inline in the catalog properties file or in a dedicated resource file. For example, adding the line:

    hive.config.resources=etc/hive/core-site.xml

loads the account information from the `etc/hive/core-site.xml` file. The content of the file should follow this convention below:

    <configuration>
      <property>
        <name>fs.azure.account.key.myblobstorageaccount.blob.core.windows.net</name>
        <value>your access key</value>
     </property>
    </configuration>

You can specify multiple storage accounts in the same file.

### Examples

Create a new blob schema named web that will store tables in a container named mycontainer:

    CREATE SCHEMA blob.web
    WITH (location =<EMAIL_ADDRESS>
Create a new table named page_views in the web schema that is stored using the ORC file format, partitioned by date and country, and bucketed by user into 50 buckets (note that Hive requires the partition columns to be the last columns in the table):

    CREATE TABLE hive.web.page_views (
      view_time timestamp,
      user_id bigint,
      page_url varchar,
      ds date,
      country varchar
    )
    WITH (
      format = 'ORC',
      partitioned_by = ARRAY['ds', 'country'],
      bucketed_by = ARRAY['user_id'],
      bucket_count = 50
    )

Drop a partition from the page_views table:

    DELETE FROM hive.web.page_views
    WHERE ds = DATE '2016-08-09'
      AND country = 'US'

Query the page_views table:

    SELECT * FROM hive.web.page_views

List the partitions of the page_views table:

    SELECT * FROM hive.web."page_views$partitions"

Create an external table named request_logs that points at existing data in Azure blob:

    CREATE TABLE blob.web.request_logs (
      request_time timestamp,
      url varchar,
      ip varchar,
      user_agent varchar
    )
    WITH (
      format = 'TEXTFILE',
      external_location =<EMAIL_ADDRESS>    )

Drop the external table request_logs. This only drops the metadata for the table. The referenced data directory is not deleted:

    DROP TABLE blob.web.request_logs

Drop a schema:

    DROP SCHEMA blob.web

### Limitations

DELETE is only supported if the WHERE clause matches entire partitions.

repository: raghavsethi/prestodb-windows

repo_name: raghavsethi/prestodb-windows


text:
# Ballerina GitHub Webhook - Tests

## Running tests

In order to run the tests, you need to have a GitHub Personal Access Token with the `admin:repo_hook` and `repo` scopes. The token can be obtained by visiting

**https://github.com/{profile} -> Settings -> Developer Settings -> Personal access tokens**

Specify the obtained token, the topic, and optionally, the callback URL and the secret in a `ballerina.conf` file in the project. Also, include the username and repository name, which will be used for testing.

```.conf
GITHUB_TOKEN="ACCESS_TOKEN"
GITHUB_TOPIC="GITHUB_TOPIC"
GITHUB_SECRET="GITHUB_SECRET"
GITHUB_CALLBACK="GITHUB_CALLBACK"
GITHUB_USERNAME="GITHUB_USERNAME"
GITHUB_REPO_NAME="GITHUB_REPO_NAME"
```

**Note:** Prior to running the tests, Webhooks that are already added with the same callback URL need to be removed, in order to trigger the `ping` notification.

```ballerina
@websub:SubscriberServiceConfig {
    path: "/webhook",
    subscribeOnStartUp: true,
    hub: githubwebhook3:HUB,
    topic: config:getAsString("GITHUB_TOPIC"),
    secret: config:getAsString("GITHUB_SECRET"),
    callback: config:getAsString("GITHUB_CALLBACK"), // only needs to be specified if not http(s)://<HOST>:<PORT>/<path>
    subscriptionClientConfig: {
        auth: {
            scheme: http:OAUTH2,
            config: {
                grantType: http:DIRECT_TOKEN,
                config: {
                    accessToken: config:getAsString("GITHUB_TOKEN")
                }
            }
        }
    }
}
```

Execute the below command to run the tests:
```
ballerina test githubwebhook3
```

repository: aashikam/module-github

repo_name: aashikam/module-github


text:
+++
title = "CoreDNS-1.7.1 Release"
description = "CoreDNS-1.7.1 Release Notes."
tags = ["Release", "1.7.1", "Notes"]
release = "1.7.1"
date = 2020-06-15T10:00:00+00:00
author = "coredns"
+++

The CoreDNS team has released
[CoreDNS-1.7.1](https://github.com/coredns/coredns/releases/tag/v1.7.1).

This is a small, incremental release.

## Brought to You By

## Noteworthy Changes

* plugin/forward: register HealthcheckBrokenCount (https://github.com/coredns/coredns/pull/4021).
  See PR TBD for using `promauto` to never have this 'forget to register metric' again.
* plugin/trace: Only with *debug* active enable  debug mode for tracing - removes extra logging (https://github.com/coredns/coredns/pull/4016)
* plugin/grpc: Improve gRPC Plugin when backend is not available (https://github.com/coredns/coredns/pull/3966)
* project: Add DCO requirement in Contributing guidelines (https://github.com/coredns/coredns/pull/4008)
* core: Add timeouts for http server (https://github.com/coredns/coredns/pull/3920)

repository: githublzb/coredns

repo_name: githublzb/coredns


text:
# Scala.js typings for jquery_dot_placeholder

Typings are for version 2.1.1

## Library description:
A jQuery plugin that enables HTML5 placeholder behavior for browsers that aren’t trying hard enough yet

|                    |                 |
| ------------------ | :-------------: |
| Full name          | jquery.placeholder |
| Keywords           | jquery, placeholder, html5, placeholder, ie |
| # releases         | 1 |
| # dependents       | 0.0 |
| # downloads        |<PHONE_NUMBER>666666 |
| # stars            | ? |

## Links
- [Npm](https://www.npmjs.com/package/jquery.placeholder)

## Note
This library has been generated from typescript code from [DefinitelyTyped](https://definitelytyped.org).

Provided with :purple_heart: from [ScalablyTyped](https://github.com/oyvindberg/ScalablyTyped)

## Usage
See [the main readme](../../readme.md) for instructions.

repository: ScalablyTyped/Distribution

repo_name: ScalablyTyped/Distribution


text:
# How to develop DXOpal

1. `npm install uglifyjs -g`
2. `bundle install`

# How to update Opal

1. `bundle update`
2. `rake build_min -B`

# How to make a release

1. Test
  - rackup and open http://localhost:9292/
  - Open starter-kit/index.html in Firefox
1. Edit opal/dxopal/version.rb
1. Add release date in CHANGELOG.md
1. `rake release`

repository: yhara/dxopal

repo_name: yhara/dxopal


text:
---
index: 6
countryCode: de
name: Germany
capitalName: Berlin
currencySymbol: €
currencyCode: EUR
callingCode: "+49"
countryImage: ../../../images/countries/de.jpg
flagImage: ../../../images/flags/de.png
---

Studying in Germany will open several doors for your future, regardless of whether you're here for just a semester or a whole year. It's easy to have a great life while studying in Germany. Most universities have abolished tuition fees, so you'll have more money to spend on the already great lifestyle provided by this beautiful country. Practically everyone speaks English, so you'll have no trouble meeting new people at university or exploring the country's vibrant nightlife!

Studying in [Berlin](/accommodation/berlin) is one of the most eye-opening experiences out there. With its hipster culture and after-parties that go on for days: [Berlin](/accommodation/berlin) is the best city to explore just who you are. Studying in rich [Munich](/accommodation/munich) is completely different: it's pure old world culture in the Bavarian capital. [Leipzig](/accommodation/leipzig) is the most populous city in the German federal state of Saxony, [Frankfurt](/accommodation/frankfurt) is Germany’s financial heart.

repository: Santos-Luis/spa-new

repo_name: Santos-Luis/spa-new


text:
# API Lab Example 6

Annyang is The MIT License (MIT)
Copyright (c) 2016 Tal Ater

**What the example does**

Example 6 uses [Annyang] to call a function that makes an alert window appear with a text "Welcome!". It is a basic example of using Annyang and is not used during presentation.

This is done through using DOM to access HTML ellements and defining functions to be called on them as the voice command is recognised.

License
----

MIT

   [Annyang]: <https://www.talater.com/annyang/m>


text:
# Change Log

All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.

## [2.0.1](https://github.com/drew-thompson/ngx-agora/compare/v2.0.0...v2.0.1) (2020-04-22)

### Bug Fixes

* **types:** correct incorrect remote stream stats property name ([d9f2abc](https://github.com/drew-thompson/ngx-agora/commit/d9f2abc72abf5d86e3cbd56da5c4082e0ea3f777))

# [2.0.0](https://github.com/drew-thompson/ngx-agora/compare/v1.6.0...v2.0.0) (2020-04-22)

### Features

* upgrade project to Angular v8 ([ce2c267](https://github.com/drew-thompson/ngx-agora/commit/ce2c267436dde6c9d5428a7c3bd0543eac25e8d5))

## [1.6.1](https://github.com/drew-thompson/ngx-agora/compare/v1.6.0...v1.6.1) (2020-04-22)

# 1.6.0 (2020-04-22)

### Bug Fixes

* prevent null error access in service ([e451d44](https://github.com/drew-thompson/ngx-agora/commit/e451d44a602a8802c860b2f27ca96b0752a11c9d))
* replace bootstrap library doppleganger ([9da44ba](https://github.com/drew-thompson/ngx-agora/commit/9da44ba51fdb93438951c5816f55254250dca580))
* resolve library compiler error ([e0ca38c](https://github.com/drew-thompson/ngx-agora/commit/e0ca38c3a5ef09b734a8ae4b5cfc52c769067106))
* **demo:** split handlers and assign eagerly ([0e40098](https://github.com/drew-thompson/ngx-agora/commit/0e400986251ba1278b6ab1d83c8e016fda27aae6))
* **schematics:** add @angular/cdk as a dependency ([2786ea4](https://github.com/drew-thompson/ngx-agora/commit/2786ea4cf7bb1929d7ed6773f40fbbb049a7d69d))
* **schematics:** change schematics path ([f01b9b1](https://github.com/drew-thompson/ngx-agora/commit/f01b9b188febcb94859366bdc50624eb91ed596f))

### Features

* add angular material ([00beef2](https://github.com/drew-thompson/ngx-agora/commit/00beef2f4c1e9997be57434102e2da0be96af8ca))
* depend on agora SDK ([fc694b8](https://github.com/drew-thompson/ngx-agora/commit/fc694b83045ac296d4a8e812b9e0b9e25ab80efb))
* export basic models ([cd5353d](https://github.com/drew-thompson/ngx-agora/commit/cd5353d2cc283d57d7814344fd4d5028a5c43ae9))
* expose models in export files to public api ([b90337f](https://github.com/drew-thompson/ngx-agora/commit/b90337fbe503d2697f7a241069639d3e6057d467))
* initialize library ([206aa36](https://github.com/drew-thompson/ngx-agora/commit/206aa36d7887080b7e6a2441245c5467c2d730a3))
* initialize project ([ac45365](https://github.com/drew-thompson/ngx-agora/commit/ac4536593bf14dc8d47f528bcc43996109d69ab6))
* port initial library basics ([16bdf7a](https://github.com/drew-thompson/ngx-agora/commit/16bdf7a6baa693b415d13c289690180bf7be0d45))
* provide ngrx-agora module via forRoot hook ([2726ebb](https://github.com/drew-thompson/ngx-agora/commit/2726ebb370dd81cf047af6ce32e355eb17f7205c))
* whitelist and identify agora-rtc-sdk as dependency ([0c9c4cd](https://github.com/drew-thompson/ngx-agora/commit/0c9c4cd7018df8907329b350f3aae996b44fdd30))
* **demo:** initialize demo ([8156064](https://github.com/drew-thompson/ngx-agora/commit/8156064c88608e79bb2976545c9108b6fa78deee))
* **models:** add deep modeling for the Agora.io Client ([0a9a1f2](https://github.com/drew-thompson/ngx-agora/commit/0a9a1f2d24a34c0de3bfdd3e15d6b308d7d58bb5))
* **models:** strongly type Agora Stream object ([4f27c53](https://github.com/drew-thompson/ngx-agora/commit/4f27c53e3e6eabd2c60ec2d645615339476ee347))
* **models:** type AgoraRTC and its Logger ([9d155a0](https://github.com/drew-thompson/ngx-agora/commit/9d155a03b7641bc9ffd24aab0a5331eb28569836))
* **schematics:** complete initial app setup ([e971e7a](https://github.com/drew-thompson/ngx-agora/commit/e971e7a6ffb3b73bef0577898c642a9875935974))
* **schematics:** improve ng-add schematic ([cee3750](https://github.com/drew-thompson/ngx-agora/commit/cee37503698981090cdf6461578de77b83f1269c))
* **service:** implement new RTC modeling with static SDK instance ([ebba4bf](https://github.com/drew-thompson/ngx-agora/commit/ebba4bf1d6f42d03dfecd170dde44f3189b47e32))

## [1.5.9](https://github.com/drew-thompson/ngx-agora/compare/v1.5.6...v1.5.9) (2019-05-22)

### Bug Fixes

* **demo:** split handlers and assign eagerly ([0e40098](https://github.com/drew-thompson/ngx-agora/commit/0e40098))

## [1.5.6](https://github.com/drew-thompson/ngx-agora/compare/v1.5.0...v1.5.6) (2019-04-12)

### Bug Fixes

* prevent null error access in service ([e451d44](https://github.com/drew-thompson/ngx-agora/commit/e451d44))

# [1.5.0](https://github.com/drew-thompson/ngx-agora/compare/v1.4.0...v1.5.0) (2019-04-11)

### Features

* **models:** strongly type Agora Stream object ([4f27c53](https://github.com/drew-thompson/ngx-agora/commit/4f27c53))

# [1.4.0](https://github.com/drew-thompson/ngx-agora/compare/v1.3.0...v1.4.0) (2019-04-11)

### Features

* **models:** type AgoraRTC and its Logger ([9d155a0](https://github.com/drew-thompson/ngx-agora/commit/9d155a0))
* **service:** implement new RTC modeling with static SDK instance ([ebba4bf](https://github.com/drew-thompson/ngx-agora/commit/ebba4bf))

# [1.3.0](https://github.com/drew-thompson/ngx-agora/compare/v1.2.0...v1.3.0) (2019-04-11)

### Features

* expose models in export files to public api ([b90337f](https://github.com/drew-thompson/ngx-agora/commit/b90337f))
* **models:** add deep modeling for the Agora.io Client ([0a9a1f2](https://github.com/drew-thompson/ngx-agora/commit/0a9a1f2))

# [1.2.0](https://github.com/drew-thompson/ngx-agora/compare/v1.1.1...v1.2.0) (2019-04-10)

### Bug Fixes

* **schematics:** add @angular/cdk as a dependency ([2786ea4](https://github.com/drew-thompson/ngx-agora/commit/2786ea4))

### Features

* **schematics:** improve ng-add schematic ([cee3750](https://github.com/drew-thompson/ngx-agora/commit/cee3750))

## [1.1.1](https://github.com/drew-thompson/ngx-agora/compare/v1.1.0...v1.1.1) (2019-04-10)

# [1.1.0](https://github.com/drew-thompson/ngx-agora/compare/v0.0.2...v1.1.0) (2019-04-10)

### Bug Fixes

* **schematics:** change schematics path ([f01b9b1](https://github.com/drew-thompson/ngx-agora/commit/f01b9b1))

### Features

* **schematics:** complete initial app setup ([e971e7a](https://github.com/drew-thompson/ngx-agora/commit/e971e7a))

## 0.0.2 (2019-04-10)

### Bug Fixes

* replace bootstrap library doppleganger ([9da44ba](https://github.com/drew-thompson/ngx-agora/commit/9da44ba))
* resolve library compiler error ([e0ca38c](https://github.com/drew-thompson/ngx-agora/commit/e0ca38c))

### Features

* add angular material ([00beef2](https://github.com/drew-thompson/ngx-agora/commit/00beef2))
* depend on agora SDK ([fc694b8](https://github.com/drew-thompson/ngx-agora/commit/fc694b8))
* export basic models ([cd5353d](https://github.com/drew-thompson/ngx-agora/commit/cd5353d))
* initialize library ([206aa36](https://github.com/drew-thompson/ngx-agora/commit/206aa36))
* initialize project ([ac45365](https://github.com/drew-thompson/ngx-agora/commit/ac45365))
* port initial library basics ([16bdf7a](https://github.com/drew-thompson/ngx-agora/commit/16bdf7a))
* provide ngrx-agora module via forRoot hook ([2726ebb](https://github.com/drew-thompson/ngx-agora/commit/2726ebb))
* whitelist and identify agora-rtc-sdk as dependency ([0c9c4cd](https://github.com/drew-thompson/ngx-agora/commit/0c9c4cd))
* **demo:** initialize demo ([8156064](https://github.com/drew-thompson/ngx-agora/commit/8156064))

branch_name: refs/heads/main


text:
---
layout: post
title: "VMUG Wiki is Live"
excerpt: "The VMUG wiki is now live!"
tags: [vmug, wiki]
link: http://wiki.vmug.com
share: true
---
![](http://wiki.vmug.com/images/b/b8/VMugWikiLogo.png)

>The VMUG Wiki was founded on April 21, 2015 by Mike Laverick. The Wiki was born as an attempt to create an online encyclopedia that is maintained by the VMware Community (vCommunity) and seeded with content from those who have been recognized with high-quality content. We welcome contributions from all people regardless of experience.

>The intention of VMUG Wiki is to be a platform for the (vCommunity) for the creation and maintenance of product information concerning all VMware Technologies, independent of the company - and independent of interference by vendors who may wish to co-opt it for the promotion their products. While we welcome coverage of complementary technologies and even competing ones, the content should remain technical and should assume the customer has already bought the technology – therefore there is nothing to sell to them.

Thanks to these guys for making this happen for the vCommunity:

- [Scott Lowe](http://wiki.vmug.com/index.php/Scott_Lowe)
- [Edward Halekty](http://wiki.vmug.com/index.php/Edward_Halekty)
- [David Davis](http://wiki.vmug.com/index.php/David_Davis)
- [Eric Sloof](http://wiki.vmug.com/index.php/Eric_Sloof)
- [Jason Boche](http://wiki.vmug.com/index.php/Jason_Boche)
- [Eric Siebert](http://wiki.vmug.com/index.php/Eric_Siebert)

repository: tquizzle/vtechify-dep

repo_name: tquizzle/vtechify-dep


text:
# Malaysian Honorific Title

## Dataset

An interesting [data source](https://www.reddit.com/r/malaysia/comments/4ovwdt/if_you_need_to_check_if_someone_is_a_datuk_or_not/) was pointed out by a Reddit user. The site has a complete list of names of people who are awarded with honorific titles in Malaysia from the year 1958 to 2015.

Utilizing a simple [Python script](https://github.com/amirothman/darjah_kebesaran/raw/master/get_data.py), the complete name list is extracted into a CSV file. The columns of the CSV file includes "Anugerah" (name of the title), "Bil" (identification number), "Nama" (recipient of award), "Singkatan" (acronym) and "Tahun Kurniaan" (year of award).

## Background

These honorific titles are awarded to denote appreciation, prestige and other reasons. More information about these different titles can be read in these Wikipedia articles: [Malay Styles and Titles](https://en.wikipedia.org/wiki/Malay_styles_and_titles), [Orders, decorations and medals of Malaysia](https://en.wikipedia.org/wiki/Orders,_decorations,_and_medals_of_Malaysia).

There are two main categories of honorific titles. Firstly, federal titles and secondly, state titles. Federal titles are granted by the Yang di-Pertuan Agong who is the head of state of Malaysia. State titles on the other hand are granted by the Ruler or Governor of the state.

Malaysia has thirteen states. Nine of these states are headed by Malay rulers who come from the respective monarchy of the state. The other four states do not have monarchies but has a ceremonial Governor.

## Obvious Numbers

There are 267 different honorific titles. 91 194 honorific titles are granted to 86 803 different people from the year 1958 to 2015.

From the following graph we can see the yearly trend of the granting of awards.

![Yearly Trend](yearly_trend.png)

Interesting notes:
  * A sharp increase in year 1977.
  * A strong drop in year 1985. Then the trend shows an increase beyond year 1988.
  * Another strong drop in year 2013. Then the trend shows a further decrease up to year 2015.

Now let's look at the frequency of awarding these titles. The top ten titles can be seen in the following graph.

![Most popular](most_popular.png)

There are some artifacts in the graph, certain titles are plotted with different bars. I theorized that this has something to do with faulty UTF-8 encoding. However, we can still analyze the data. The top three titles did not come as a surprise. All three of these titles, [Pingat Pangkuan Negara](https://ms.wikipedia.org/wiki/Pingat_Pangkuan_Negara), [Kesatria Mangku Negara](https://ms.wikipedia.org/wiki/Kesatria_Mangku_Negara) and [Ahli Mangku Negara](https://ms.wikipedia.org/wiki/Ahli_Mangku_Negara) do not have a limit in the number of people being granted. This is not the case with the other titles.

## Trend By States

In order to classify the titles by the state it is awarded, a pattern matching strategy is devised. The following Python method is able to classify all the titles to its respective states.

```python

import re
def get_nama_negeri(anugerah):
    anugerah = anugerah.lower()
    nama_negeri = ["sarawak","sabah","negeri sembilan",
                   "pahang","perak","perlis",
                   "selangor","terengganu","kelantan",
                   "johor","pahang","melaka","kedah",
                   "pulau pinang","negara"]

    for negeri in nama_negeri:
        if re.search(negeri,anugerah):
            if negeri == "negara":
                return "persekutuan"
            else:
                return negeri

    anugerah_negara = ["gagah berani","perkasa persekutuan","gagah perkasa",
                       "setia mahkota","setia diraja","tentera udara",
                       "kerabat diraja","setia diraja","mahkota malaysia",
                       "perutusan keberanian"]

    for a in anugerah_negara:
        if re.search(a,anugerah):
            return "persekutuan"

    anugerah_negeri_dict = {"tuanku ja'afar yang amat terpuji":"negeri sembilan",
                            "taming sari":"perak",
                            "cura si manja kini":"perak",
                            "kinabalu":"sabah",
                            "pangkuan negeri":"pulau pinang",
                            "pangkuan negari":"pulau pinang",
                            "kenyalang":"sarawak",
                            "yam tuan raden":"negeri sembilan",
                            "salahuddin abdul aziz shah":"selangor",
                            "abdul halim mu'adzam shah":"kedah",
                            "baginda syed putra":"perlis",
                            "paduka tuanku ja'afar":"negeri sembilan",
                            "sultan ahmad shah":"pahang",
                            "sultan nazrin shah":"perak",
                            "jamalullail":"perlis",
                            "sharafuddin idris shah":"selangor",
                            "mahkota wilayah":"persekutuan",
                            "mangku wilayah":"persekutuan",
                            "tuanku mukhriz":"negeri sembilan",
                            "tuanku muhriz":"negeri sembilan",
                            "yang amat dihormati pangkat pertama":"johor",
                            "kerabat halimi":"kedah",
                            "mahawangsa":"kedah",
                            "halim muadzam shah":"kedah",

                            "darjah bakti":"persekutuan"

                          }

    for k,v in anugerah_negeri_dict.items():
        if re.search(k,anugerah):
            return v

df["nama_negeri"] = df.Anugerah.apply(lambda x: get_nama_negeri(x))

```

Now we have a new column, namely "nama_negeri". This indicates the name of the state. The label "persekutuan" would be used in the case of a federal title.

First we examine the frequency of titles by state.

![Frequency by state](frequency_by_state.png)

We can explain this because there are much more federal titles.

![Number of Different Titles](number_different_titles.png)

Next, we examine the yearly trend by different state.

![Yearly Trend by States](yearly_trend_of_states.png)

By looking at the trends, apparently the data prior to 1985 consists of only federal (persekutuan) titles. In order to improve visibility, we remove the Persekutuan titles.

![Yearly Trend by States](yearly_trend_by_states_without_persekutuan.png)

Something interesting to note here is that titles from Pahang is much bigger in volume than the other states. It is also worth noting that the data for titles from Pahang is only until the year 2012. This may explain why there is a drop of number of people being granted with titles in year 2012.

We plot the yearly trend again without Pahang.

![Yearly Trend Without Pahang](yearly_trend_without_pahang.png)

Now, the decrease in granting titles in year 2012 is no longer apparent.

Lastly, we examine the yearly trend by states other than Pahang.

![Yearly Trend by States](yearly_trend_by_states_without_pahang.png)

It seems that the other states grant titles at similar rate.


text:
---
layout: default
---

We are a group  focusing  on trans-disciplinary   Artificial Intelligence (AI) research where the novelty comes from transforming the domain.

## active members

* [Dr. Rohitash Chandra](https://sydney.edu.au/science/people/rohitash.chandra.php), (Group Lead)  University of Sydney, Australia
* Mr. Ratneel Deo, University of the South Pacific, Fiji
* Ms. Swaran Ravindra, Fiji National University, Fiji
* Mr. Yogesh Nadan, Fiji National University, Fiji
* Mr. Konark Jain, Indian Institute of Technology, India
* Mr. Arpit Kapoor, SRM Institute of Technology, India
* Mr. Aakrash Yadav, Indian Institute of Technology, India
* Mr. Ashray Aman, Indian Institute of Technology, India
* Mr. Rishab Gupta, Indian Institute of Technology, India
* Mr. Mani Tyagi, Indian Institute of Technology, India
* Mr. Krishan Kumar, University of the South Pacific, Fiji

## summer research interns

### 2019
* Mr. Aakrash Yadav, Indian Institute of Technology, India
* Mr. Ashray Aman, Indian Institute of Technology, India
* Mr. Rishab Gupta, Indian Institute of Technology, India
* Mr. Mani Tyagi, Indian Institute of Technology, India

### 2018

* Mr. Konark Jain, Indian Institute of Technology, India
* Mr. Arpit Kapoor, SRM Institute of Technology, India
* [Mr. Ratneel Deo, University of the South Pacific, Fiji](ratneel-deo.md)

## affiliates
* Prof. Christian Omlin (Norway), Dr. Shelvin Chand (Spain), Dr. Surya Prakash (Australia), Dr. John Hawkins (Data Robot, Australia), Dr. Rodney Beard (Solomon  Islands), Dr. Hugo Olierook (Curtin,Perth), A/Prof. Jody Webster (USyd, Sydney), Prof. Dietmar Muller (USyd, Sydney), Dr. Vladimir Puzyrev (Curtin, Perth), Mr. Danial Azam, (USyd, Sydney)

## research methods

* Artificial Intelligence methods include, but not limiting to, Data Science, Machine learning and Optimisation
* Deep Learning and Neural networks, Learning systems
* Optimisation methods that include Evolutionary Algorithms, Swarm Intelligence
* Supervised, Unsupervised and Reinforcement Learning
* Bayesian methods, MCMC methods, Distributed AI algorithms, Parallel MCMC methods

## transitional research

* Ethics in AI
* AI for Health and Medicine
* AI in Finance and Business
* AI in Earth, Environmental and Climate Sciences
* AI for Assistive technologies,  Robotics Control,    and others

## software archives
* [Sydney Machine Learning](https://github.com/sydney-machine-learning/ )
* [Intelligent Exploration](https://github.com/intelligent-exploration )
* [Intelligent Earth](https://github.com/intelligentEarth/ )

## active research projects
* Solid Earth Evolution
* Paleo-climate Resonstruction
* Evolutionary parallel tempering MCMC
* Ethical issues in AI

## educational resources
* [Neural Networks MOOCs](https://rohitashchandra.wordpress.com/2019/02/19/neural-networks-fundamentals-and-applications/) by Rohitash Chandra
* [Bayesian inference for Earth evolution models: Bayelands Worshop](https://www.earthbyte.org/bayeslands-resources/) given at University of Sydney
* [Selected Research papers](https://github.com/rohitash-chandra/research)
* [ResearchGate profile with papers ](https://researchgate.net/profile/Rohitash_Chandra)
*  Research presentation videos by  Rohitash Chandra
* * [Seminar: Cooperative Neuroevolution and applications]()
* * [Seminar: Earth evolution models using Bayeslands]()
* [Software portfolio](https://rohitash-chandra.github.io/portfolio/) by Rohitash Chandra

## contact

* In order to join this group, send an EOI with CV to Dr. Rohitash Chandra ( c dot rohitash at gmail dot com). Affliate membership also welcome.
* Note that you have to be active in the group discuission list hosted at googlegroups with at least one discussion post every 3 months. Else you will be listed in the past member category in the following year.

gha_language: CSS


text:
![Watts_Logo](https://cloud.githubusercontent.com/assets/7763904/8000839/70080f0e-0b2d-11e5-8fa6-5e44b6b971a9.png)

[![forthebadge](http://forthebadge.com/images/badges/made-with-ruby.svg)](http://forthebadge.com)

### About
Watts is a desktop application for performing Physics formula calculations. It is written entirely in Ruby and built on top of the [Joules](http://www.github.com/elailai94/Joules) Physics library (gem). The graphical component of the application is implemented using the [Shoes](http://www.shoesrb.com/) GUI toolkit.

### License
* Watts is licensed under the [MIT license](https://www.github.com/elailai94/Watts/blob/master/LICENSE.md).
* Joules is licensed under the [MIT license](https://www.github.com/elailai94/Joules/blob/master/LICENSE.md).
* Shoes is licensed under the MIT license.


text:
Example of MinIO for data and metadata store
============================================
In this example we use the free MinIO playground to store and fetch some data instances and metadata.
This storage can be accessed from DLite using the following URL: `minio://play.min.io?access_key=Q3AM3UQ867SPQQA43P2F;secret_key=zuf+tfteSlswRu7BJ86wekitnifILbZam1KYY3TG`.
The `access_key` and `secret_key` should normally be kept private, but MinIO has kindly made the corresponding account publicly available for testing purposes.
Hence, it should be possible for everyone to run this example.

MinIO is well suited for storing both data and corresponding data models (metadata).
Normally, you would use separate buckets for data and metadata.
But for simplicity, we will in this example just use the default bucket (called "dlite") for both the data and metadata.

The data we will use are chemical compositions two common aluminium alloys, [aa6060] and [aa6082], described by the [http://onto-ns.com/meta/calm/0.1/Chemistry] entity.

Storing
-------
First we will store our data instances to MinIO.
That is done in the script [store.py].
Since we have several instances, the script use `dlite.Storage` to reduce the number of connections made to MinIO:

```python
with dlite.Storage(url) as s:
    s.save(inst1)  # Do this for each instance
    s.save(inst1.meta)  # Remember to also store the datamodel
    ...
```
where `url` is the URL for the MinIO playground shown above.

You can test this script by running:

    python store.py

Fetching
--------
To fetch data from MinIO, we will first append the URL to the MinIO playground to the dlite storage search path.
That can either be done by appending to the `DLITE_STORAGES` environment variable (note that this variable uses the pipe (|) character to separate URLs) or the `dlite.storage_path` object in Python.
The latter is done in the [fetch.py] script.
After the storage path has been set, you can simply access data and metadata by UUID or UUID using `dlite.get_instance()`.

You can test this script by running:

    python fetch.py

main.py
-------
The `main.py` script simply runs `store.py` and `fetch.py` in sequence.
It is intended to be used by the CI/CD framework.

[aa6060]: ../entities/aa6060.json
[aa6082]: ../entities/aa6082.json
[http://onto-ns.com/meta/calm/0.1/Chemistry]: ../entities/Chemistry-0.1.json
[store.py]: store.py
[fetch.py]: fetch.py

repository: SINTEF/dlite

gha_language: C

repo_name: SINTEF/dlite


text:
<!--

[comment]: # Licensed to the Apache Software Foundation (ASF) under one
[comment]: # or more contributor license agreements.  See the NOTICE file
[comment]: # distributed with this work for additional information
[comment]: # regarding copyright ownership.  The ASF licenses this file
[comment]: # to you under the Apache License, Version 2.0 (the
[comment]: # "License"); you may not use this file except in compliance
[comment]: # with the License.  You may obtain a copy of the License at
[comment]: #
[comment]: #   http://www.apache.org/licenses/LICENSE-2.0
[comment]: #
[comment]: # Unless required by applicable law or agreed to in writing,
[comment]: # software distributed under the License is distributed on an
[comment]: # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
[comment]: # KIND, either express or implied.  See the License for the
[comment]: # specific language governing permissions and limitations
[comment]: # under the License.

-->
# Inferencing

Apache Rya currently provides simple inferencing. The supported list of inferred relationships include:

- rdfs:subClassOf
- rdfs:subPropertyOf
- owl:EquivalentProperty
- owl:inverseOf
- owl:SymmetricProperty
- owl:TransitiveProperty (This is currently in beta and will not work for every case)
- owl:sameAs

## Setup

The Inferencing Engine is a scheduled job that runs by default every 5 minutes, this is configurable, to query the relationships in the store and develop the inferred graphs necessary to answer inferencing questions.

This also means that if you load a model into the store, it could take up to 5 minutes for the inferred relationships to be available.

As usual you will need to set up your `RdfCloudTripleStore` with the correct DAO, notice we add an `InferencingEngine` as well to the store. If this is not added, then no inferencing will be done on the queries:

``` JAVA
//setup
Connector connector = new ZooKeeperInstance("instance", "zoo1,zoo2,zoo3").getConnector("user", "password");
final RdfCloudTripleStore store = new RdfCloudTripleStore();
AccumuloRyaDAO crdfdao = new AccumuloRyaDAO();
crdfdao.setConnector(connector);

AccumuloRdfConfiguration conf = new AccumuloRdfConfiguration();
conf.setTablePrefix("rts_");
conf.setDisplayQueryPlan(true);
crdfdao.setConf(conf);
store.setRdfDao(crdfdao);

ProspectorServiceEvalStatsDAO evalDao = new ProspectorServiceEvalStatsDAO(connector, conf);
evalDao.init();
store.setRdfEvalStatsDAO(evalDao);

InferenceEngine inferenceEngine = new InferenceEngine();
inferenceEngine.setRdfDao(crdfdao);
inferenceEngine.setConf(conf);
store.setInferenceEngine(inferenceEngine);

Repository myRepository = new RyaSailRepository(store);
myRepository.initialize();
RepositoryConnection conn = myRepository.getConnection();

//query code goes here

//close
conn.close();
myRepository.shutDown();
```

## Samples

We will go through some quick samples on loading inferred relationships, seeing and diagnosing the query plan, and checking the data

### Rdfs:SubClassOf

First the code, which will load the following subclassof relationship: `UndergraduateStudent subclassof Student subclassof Person`. Then we will load into the tables three triples defining `UgradA rdf:type UndergraduateStudent, StudentB rdf:type Student, PersonC rdf:type Person`

``` JAVA
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "UndergraduateStudent"), RDFS.SUBCLASSOF, vf.createIRI(litdupsNS, "Student")));
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "Student"), RDFS.SUBCLASSOF, vf.createIRI(litdupsNS, "Person")));
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "UgradA"), RDF.TYPE, vf.createIRI(litdupsNS, "UndergraduateStudent")));
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "StudentB"), RDF.TYPE, vf.createIRI(litdupsNS, "Student")));
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "PersonC"), RDF.TYPE, vf.createIRI(litdupsNS, "Person")));
conn.commit();
```

Remember that once the model is committed, it may take up to 5 minutes for the inferred relationships to be ready. Though you can override this property in the `InferencingEngine`.

We shall run the following query:

```
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX lit: <urn:test:litdups#>
select * where {?s rdf:type lit:Person.}
```

And should get back the following results:

```
[s=urn:test:litdups#StudentB]
[s=urn:test:litdups#PersonC]
[s=urn:test:litdups#UgradA]
```

#### How it works

Let us look at the query plan:

```
QueryRoot
   Projection
      ProjectionElemList
         ProjectionElem "s"
      Join
         FixedStatementPattern
            Var (name=79f261ee-e930-4af1-bc09-e637cc0affef)
            Var (name=c-79f261ee-e930-4af1-bc09-e637cc0affef, value=http://www.w3.org/2000/01/rdf-schema#subClassOf)
            Var (name=_const_2, value=urn:test:litdups#Person, anonymous)
         DoNotExpandSP
            Var (name=s)
            Var (name=_const_1, value=http://www.w3.org/1999/02/22-rdf-syntax-ns#type, anonymous)
            Var (name=79f261ee-e930-4af1-bc09-e637cc0affef)
```

Basically, we first find out (through the InferencingEngine) what triples have subclassof with Person. The InferencingEngine will do the graph analysis to find the both Student and UndergraduateStudent are Person classes.
Then this information is joined with the statement pattern `(?s rdf:type ?inf)` where `?inf` is the results from the InferencingEngine.

### Rdfs:SubPropertyOf

SubPropertyOf defines that a property can be an instance of another property. For example, a `gradDegreeFrom subPropertyOf degreeFrom`.

Also, EquivalentProperty can be thought of as specialized SubPropertyOf relationship where if `propA equivalentProperty propB` then that means that `propA subPropertyOf propB AND propB subPropertyOf propA`

Sample Code:

``` JAVA
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "undergradDegreeFrom"), RDFS.SUBPROPERTYOF, vf.createIRI(litdupsNS, "degreeFrom")));
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "gradDegreeFrom"), RDFS.SUBPROPERTYOF, vf.createIRI(litdupsNS, "degreeFrom")));
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "degreeFrom"), RDFS.SUBPROPERTYOF, vf.createIRI(litdupsNS, "memberOf")));
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "memberOf"), RDFS.SUBPROPERTYOF, vf.createIRI(litdupsNS, "associatedWith")));
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "UgradA"), vf.createIRI(litdupsNS, "undergradDegreeFrom"), vf.createIRI(litdupsNS, "Harvard")));
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "GradB"), vf.createIRI(litdupsNS, "gradDegreeFrom"), vf.createIRI(litdupsNS, "Yale")));
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "ProfessorC"), vf.createIRI(litdupsNS, "memberOf"), vf.createIRI(litdupsNS, "Harvard")));
conn.commit();
```

With query:

```
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX lit: <urn:test:litdups#>
select * where {?s lit:memberOf lit:Harvard.}
```

Will return results:

```
[s=urn:test:litdups#UgradA]
[s=urn:test:litdups#ProfessorC]
```

Since UgradA has undergraduateDegreeFrom Harvard and ProfessorC is memberOf Harvard.

#### How it works

This is very similar to the subClassOf relationship above. Basically the InferencingEngine provides what properties are subPropertyOf relationships with memberOf, and the second part of the Join checks to see if those properties are predicates with object "Harvard".

Query Plan:

```
QueryRoot
   Projection
      ProjectionElemList
         ProjectionElem "s"
      Join
         FixedStatementPattern
            Var (name=0bad69f3-4769-4293-8318-e828b23dc52a)
            Var (name=c-0bad69f3-4769-4293-8318-e828b23dc52a, value=http://www.w3.org/2000/01/rdf-schema#subPropertyOf)
            Var (name=_const_1, value=urn:test:litdups#memberOf, anonymous)
         DoNotExpandSP
            Var (name=s)
            Var (name=0bad69f3-4769-4293-8318-e828b23dc52a)
            Var (name=_const_2, value=urn:test:litdups#Harvard, anonymous)
```

### InverseOf

InverseOf defines a property that is an inverse relation of another property. For example, a student who has a `degreeFrom` a University also means that the University `hasAlumnus` student.

Code:

``` JAVA
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "degreeFrom"), OWL.INVERSEOF, vf.createIRI(litdupsNS, "hasAlumnus")));
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "UgradA"), vf.createIRI(litdupsNS, "degreeFrom"), vf.createIRI(litdupsNS, "Harvard")));
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "GradB"), vf.createIRI(litdupsNS, "degreeFrom"), vf.createIRI(litdupsNS, "Harvard")));
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "Harvard"), vf.createIRI(litdupsNS, "hasAlumnus"), vf.createIRI(litdupsNS, "AlumC")));
conn.commit();
```

Query:

```
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX lit: <urn:test:litdups#>
select * where {lit:Harvard lit:hasAlumnus ?s.}
```

Result:

```
[s=urn:test:litdups#AlumC]
[s=urn:test:litdups#GradB]
[s=urn:test:litdups#UgradA]
```

#### How it works

The query planner will expand the statement pattern `Harvard hasAlumnus ?s` to a Union between `Harvard hasAlumnus ?s. and ?s degreeFrom Harvard`

As a caveat, it is important to note that in general Union queries do not have the best performance, so having a property that has an inverseOf and subPropertyOf, could cause a query plan that might take long depending on how the query planner orders the joins.

Query Plan

```
QueryRoot
   Projection
      ProjectionElemList
         ProjectionElem "s"
      InferUnion
         StatementPattern
            Var (name=_const_1, value=urn:test:litdups#Harvard, anonymous)
            Var (name=_const_2, value=urn:test:litdups#hasAlumnus, anonymous)
            Var (name=s)
         StatementPattern
            Var (name=s)
            Var (name=_const_2, value=urn:test:litdups#degreeFrom)
            Var (name=_const_1, value=urn:test:litdups#Harvard, anonymous)
```

### SymmetricProperty

SymmetricProperty defines a relationship where, for example, if Bob is a friendOf Jeff, then Jeff is a friendOf Bob. (Hopefully)

Code:

``` JAVA
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "friendOf"), RDF.TYPE, OWL.SYMMETRICPROPERTY));
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "Bob"), vf.createIRI(litdupsNS, "friendOf"), vf.createIRI(litdupsNS, "Jeff")));
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "James"), vf.createIRI(litdupsNS, "friendOf"), vf.createIRI(litdupsNS, "Jeff")));
conn.commit();
```

Query:

```
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX lit: <urn:test:litdups#>
select * where {?s lit:friendOf lit:Bob.}
```

Results:

```
[s=urn:test:litdups#Jeff]
```

#### How it works

The query planner will recognize that `friendOf` is a SymmetricProperty and devise a Union to find the specified relationship and inverse.

Query Plan:

```
QueryRoot
   Projection
      ProjectionElemList
         ProjectionElem "s"
      InferUnion
         StatementPattern
            Var (name=s)
            Var (name=_const_1, value=urn:test:litdups#friendOf, anonymous)
            Var (name=_const_2, value=urn:test:litdups#Bob, anonymous)
         StatementPattern
            Var (name=_const_2, value=urn:test:litdups#Bob, anonymous)
            Var (name=_const_1, value=urn:test:litdups#friendOf, anonymous)
            Var (name=s)
```

### TransitiveProperty

TransitiveProperty provides a transitive relationship between resources. For example, if Queens is subRegionOf NYC and NYC is subRegionOf NY, then Queens is transitively a subRegionOf NY.

Code:

``` JAVA
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "subRegionOf"), RDF.TYPE, OWL.TRANSITIVEPROPERTY));
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "Queens"), vf.createIRI(litdupsNS, "subRegionOf"), vf.createIRI(litdupsNS, "NYC")));
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "NYC"), vf.createIRI(litdupsNS, "subRegionOf"), vf.createIRI(litdupsNS, "NY")));
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "NY"), vf.createIRI(litdupsNS, "subRegionOf"), vf.createIRI(litdupsNS, "US")));
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "US"), vf.createIRI(litdupsNS, "subRegionOf"), vf.createIRI(litdupsNS, "NorthAmerica")));
conn.add(vf.createStatement(vf.createIRI(litdupsNS, "NorthAmerica"), vf.createIRI(litdupsNS, "subRegionOf"), vf.createIRI(litdupsNS, "World")));
conn.commit();
```

Query:

```
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX lit: <urn:test:litdups#>
select * where {?s lit:subRegionOf lit:NorthAmerica.}
```

Results:

```
[s=urn:test:litdups#Queens]
[s=urn:test:litdups#NYC]
[s=urn:test:litdups#NY]
[s=urn:test:litdups#US]
```

#### How it works

The TransitiveProperty relationship works by running recursive queries till all the results are returned.

It is important to note that certain TransitiveProperty relationships will not work:
* Open ended property: ?s subRegionOf ?o (At least one of the properties must be filled or will be filled as the query gets answered)
* Closed property: Queens subRegionOf NY (At least one of the properties must be empty)

We are working on fixing these issues.

Query Plan:

```
QueryRoot
   Projection
      ProjectionElemList
         ProjectionElem "s"
      TransitivePropertySP
         Var (name=s)
         Var (name=_const_1, value=urn:test:litdups#subRegionOf, anonymous)
         Var (name=_const_2, value=urn:test:litdups#NorthAmerica, anonymous)
```

repository: DalavanCloud/incubator-rya

repo_name: DalavanCloud/incubator-rya


text:
# rpi-epaper-camera
RPi camera with epaper display

# Links

* [Waveshare e-paper RPi Guide](https://www.waveshare.com/wiki/Template:Raspberry_Pi_Guides_for_SPI_e-Paper)
* [RPi Camera](https://projects.raspberrypi.org/en/projects/getting-started-with-picamera)

repository: jerrymannel/rpi-epaper-camera

repo_name: jerrymannel/rpi-epaper-camera


text:
# orchestrator-service

## Candidate details
**Name:** Bhuvan Gandhi

**Exercise:** Orchestrator Service

## Development environment
**Operating System:** Windows

**GO version:** 1.17.2

## File Structure
- The main branch has been merged with other branches in each part of the exercise, as per the specified requirements.
- In the end, I have restructurized a little bit so that it can become easy to navigate and understanding.
- Three folders - GetUserByName (:9000), GetUser (:9001) and Datamock (:10000).
- All those folders contain mainly two folders: server and proto<Port_Number>.
- GetUserByName folder contains the client folder - it contains the script for client.

## Things which are different from actual exercise
- With the approach of actual exercise, the :9000 and :9001 will be crashed on input of less than 6 characters. We need to manually activate them. To handle this, I haven't handled the exception in errors of Golang. Instead I have used `-1` status of `Roll` to know if the length of name is less than 6 or not.

## How To Use
1. Open 4 different terminals. And navigate to the root folder in all of them.
2. We will first activate the orchestrator services. While activating the server, you may get asked to allow the program to communicate over the network through firewall. Allow it.
3. So, let's first activate the :10000 service. Type `go run datamock/server/main.go` and hit enter.
4. Then, let's activate the :9001 service. Type `go run getUser/server/main.go` and hit enter.
5. Then, let's activate the :9000 service. Type `go run getUserByName/server/main.go` and hit enter.
5. Then, let's activate the client. Type `go run getUserByName/client/main.go` and hit enter. It will ask you to write the name of user. Then after providing the name, the requested will be propogated to :9000 to :9001 and :9001 to :10000. On the :10000 server, the actual logic is written. Then the response object will be propogated to :10000 to :9001, :9001 to :9000 and then finally to the client.

## Test Cases
### Case 1
**Input:**
> Enter a name of user: Bhuvan Gandhi

**Output:**
> 2021/10/29 03:40:39 Response: Name:"Bhuvan Gandhi" Class:"13" Roll:130

### Case 2
**Input:**
> Enter a name of user: BG

**Output:**
> 2021/10/29 03:41:15 Response: Name length must be greater than 6.


text:
---
layout: default
title: 'Re: Lack of chargeback support'
date: 2009-04-27 12:11
grand_parent: Emails
parent: Mike Hearn
nav_order: 8
---

# Re: Questions about BitCoin

The email on the Cryptography Mailing List that announced Bitcoin publicly to the world.
{: .fs-6 .fw-300 }

---

```
From: Satoshi Nakamoto<EMAIL_ADDRESS>Date: Mon, Apr 27, 2009 at 12:11 AM
To: Mike Hearn<EMAIL_ADDRESS>Subject: Re: Lack of chargeback support

I am not a lawyer and I can't possibly answer that.  I suppose if the law applies to a bank or financial institution or other intermediary, then it would not apply since there is no bank involved, only two parties trading directly with each other, as they would in person with cash or barter with physical commodities.

Bitcoin is fundamentally designed to be able to do non-reversible transactions, and there certainly are applications that need that.

If someone wants the possibility of chargeback, they can use an escrow transaction, which isn't implemented yet but will be one of the next things.  For instance, a transaction can be written to designate a third party to decide whether it is returned if the payer does not release it, with auto-release after a number of days.  I'll implement a more basic form of escrow first, but the network infrastructure includes a predicate language that can express any number of options.
```


text:
##  Contribution
You can contribute to the improvement of the documentation, by adding, modifying or deleting items.

## Definition
[Kruskal's algorithm](https://en.wikipedia.org/wiki/Kruskal%27s_algorithm) is a search algorithm of [minimum spanning tree](https://en.wikipedia.org/wiki/Minimum_spanning_tree).

This algorithm is part of the [graph theory](https://en.wikipedia.org/wiki/Graph_theory).

The kruskal algorithm is applied to the graph connected, non-oriented and weighted graph.

A connected graph is a graph where no vertex is isolated.

A non-oriented graph is a graph where the edges have no direction restriction, they can be represented with 2 arrows.

A weighted graph is a graph where the edges have a value. (can represent a distance)

A [tree](https://en.wikipedia.org/wiki/Tree_(graph_theory)) is a graph without cycles.
One of the main features of Kruskal's algorithm is to find the cycles between nodes already processed.

## Pseudo-Code

## Utilisation

This example will be done with the graph below: (an example visualization of the graph, is in the `Definition` section)

```
A <=[5]=> B
A <=[4]=> C
A <=[11]=> D
B <=[7]=> C
B <=[20]=> F
C <=[9]=> D
C <=[12]=> E
C <=[8]=> F
D <=[5]=> E
E <=[9]=> F
```

The variable `Result` will be the result with the minimum coverage tree.

```
Result = []
```

1. First, we put all the nodes into `sets', the `sets' can be lists, nodes in a graph or an array. (`MAKE-SET`)

   In this first example, we will take lists.

   ```
   [A] [B] [C] [D] [E] [F]
   ```

2. Then we have to collect the edges and sort them by weight.

   When several edges are equal, they are chosen arbitrarily.

   ```
   A <=[4]=> C
   A <=[5]=> B  or  D <=[5]=> E
   D <=[5]=> E  or  A <=[5]=> B
   B <=[7]=> C
   C <=[8]=> F
   C <=[9]=> D  or  E <=[9]=> F
   E <=[9]=> F  or  C <=[9]=> D
   A <=[11]=> D
   C <=[12]=> E
   B <=[20]=> F
   ```

3. We loop for each sorted edge.

   1. The first thing to do in the loop is to check in which list are the edges. (`FIND-SET`)

      ```
      A <=[4]=> C

      Current state:
      [A] [B] [C] [D] [E] [F]

      [A] and [C] are in different sets.
      ```

   2. If the 2 sets are different, it means that there is no cycle, so they be will merge. (`UNION`)

      ```
      Before state:
      [A] [B] [C] [D] [E] [F]

      After state:
      [A, C] [B] [D] [E] [F]
      ```

   3. After merging the sets, the edge is stored in the `Result` variable:

      ```
      Result = [
        ...
        A <=[4]=> C
      ]
      ```

   1. 1.Bis.

      ```
      A <=[11]=> D

      Current state:
      [A, C, B, D] [E] [F]

      [A, C, B, D] are in the same set, so we don't merge to avoid a cycle.
      ```

4. Finally, we return the variable `Result` which contains all the edges of the tree covering minimum

   ```
   return Result
   ```

### Example with tree

We have seen roughly how `Kruskal' works.

The example was with a list, let's see another example with a tree.

The operation is the same, for the `FIND-SET` we return the parent of the graph.

```
  |A|
|B| |C|  => A
    |D|

  |E|    => E
```

In the first case the parent of `D` is `A`.
In the second case the parent of `E` is `E`.

In `parent`, we return the parent of the graph

Operation for the `UNION` .

```
   |A|            |A|                |E|
|B|   |C|  =>  |B|   |C| |E|  or  |G|   |A|
      |D|            |D| |G|          |B| |C|
                                          |D|
  |E|      =>
  |G|
```

We merge graphs randomly, an improvement is to merge from the smallest to the largest tree (cf: [Optimizations](#optimization)).

### Example with table

The operation with the table is one of the least resource greedy.

The initialization of the table is done with `-1`, the size of the array corresponds to the number of nodes in the graph. (`MAKE-SET`)

```
[-1, -1, -1, -1, -1, -1]
```

A simple array is enough, but for my example I added a dictionary to link the names of the nodes and the indexes of the array.

```
{
  A: 0
  B: 1
  C: 2
  D: 3
  E: 4
  F: 5
}

[-1, -1, -1, -1, -1, -1]
 A   B   C   D   E   F
```

The specificity of the table is that `negative numbers`, not being valid indexes, indicate that there is no parent and `positive numbers` are indexes to the parents.

```
arr = [-3, 0, -1, 1, -1, -1]
       A   B  C   D  E   F

If we're looking for "D's" parent.
arr[index(D)] = 1

1 is positive, so it's an index.
arr[1] = 0

0 is positive, so it's an index.
arr[0] = -3

-3 is negative, so there's no parent.

He himself is the parent, so we get his index back which is 0.

Parent of "D" is 0.
```

For the `FIND-SET`, we return the index:

```
arr = [-3, 0, -1, 1, -1, -1]
        A  B   C  D   E   F

Parent of "D" is 0.
The parent of "B" is 0 => NON-UNION

Parent of "A" is 0.
The parent of "E" is 4 => UNION
```

For the `UNION`, this method already implements an improvement which is the `rang`.

The `rang` allows you to merge the `sets' from the smallest to the largest. (See below)

```
arr = [-3, 0, -1, 1, -1, -1]
        A  B   C  D   E   F

arr[index(D)] = arr[index(B)] = arr[index(A)] = -3
arr[index(E)] = -1

Parent of "D" is 0.
The parent of "E" is 4 => UNION
```

We merge `E` into `A`, because the rank of `set A` (-3) is greater than the rank of `set E` (-1)

For each merger, the ranks are added together.

```
A = -3 becomes A = -4
E = -1 becomes E = 0 (index of A)

arr = [-4, 0, -1, 1, 0, -1]
        A  B   C  D  E   F

If E = -2, so:
A = -3 becomes A = -5
E = -2 becomes E = 0 (index of A)
```

## Optimization

 #### Path compression

Path compression is done at `FIND-SET` is not at `UNION`, and is not done all at once.

Here is an example with the same 2 `FIND-SET`:

```
arr = [-3, 0, -1, 1, -1, -1]
        A  B   C  D   E   F

find(D) = 0
arr[index(D)] => arr[index(B)] => arr[index(A)]
```

The algorithm is traced back to the root of the `set` which is the `0` index.

We check if the parent of D is `positive`. (If it is negative, it has no parent, it is itself the parent).
And we check if the parent of D (`1`) is different from the root index of the `set` (`0`).

It is the case, so we apply path compression.

Then `arr [index(D)] = 0`.

If we do another search

```
arr = [-3, 0, -1, 0, -1, -1]
        A  B   C  D   E   F

find(D) = 0
arr[index(D)] = arr[index(A)]
```

One less hit.

#### The rank

As we have seen above, 'rank' is used to optimize mergers.

By merging from the smallest `set` to the largest, less work is given to `path compression` and more paths are `1 hit` from the parent of the `set'.

The array method implements this by default.

In the algorithm, a simple

```
A.rang > G.rang:
  G.parent = A
sinon
  A.parent = G
```

This example shows the optimized method and the non-optimized method.g

repository: coursecomputer/kruskal

repo_name: coursecomputer/kruskal