text:
Tachyon Diagen
==============

A simple Python based generator script for the horrendus dialogue XML
format used by the FTL inspired Tachyon game.

Contents
--------

- [Contents](#contents)
- [Motivation](#motivation)
- [Installation](#installation)
- [Usage](#usage)
- [Script format](#script-format)
    * [Dialogues](#dialogues)
    * [Events](#events)
    * [Order of Directives](#order-of-directives)
    * [Auto Generated Ids](#auto-generated-ids)
- [Options Controlling Behaviour](#options-controlling-behaviour)
    - [default\_resopnse](#default_response)
    - [mangle\_any\_value](#mangle_any_value)
    - [mangle\_empty\_value](#mangle_empty_value)
- [Directives](#directives)
    * [Note about params](#note-about-params)
    * [Label(id)](#labelid)
    * [Reply(text=None, params)](#replytextnone-params)
    * [Goto(target)](#gototarget)
    * [End](#end)
    * [Event(id, target)](#eventid-target)
    * [Choice(text, choices)](#choicetext-choices)
    * [Condition(type, params)](#conditiontype-params)
    * [InlineEvent(type, target, name=None, params)][1]
    * [EventDef(type, name, params)](#eventdeftype-name-params)
    * [SpawnNPC(params)](#spawnnpcparams)
    * [AddShip(params)](#addshipparams)
    * [Ai(type, params)](#aitype-params)
    * [AddDebris(params)](#adddebrisparams)
    * [Item(params)](#itemparams)
- [Examples](#examples)

[1]: #inlineeventtype-target-namenone-params

Motivation
----------

The XML format used by Tachyon to author dialogues and events is very
tedious to work with.  Writing a message that follows up from another
message requires manually assigning message ids and referencing these in
reply blocks that have their own ids in addition.  There's no nested
definitons, causing large multiple choice dialogs to have the the
choices and the response texts spread far appart and events have to be
defined in a separate file despite many events being only referenced by
one dialogue message.

Worse still, because of the manual id assigment and referencing moving
arround and reorganizing text may in the worst case require renumbering
a bunch of messages, some that can be reference multiple spread out
places in a dialog.

Appart from solving these issues, a Python based generator also allows
for scripted generation of repeated structures.

Installation
------------

You can download the [diagen.py](diagen.py) file (right click and save
as on the raw button) and put it where you like.  The script is runned
from a command line.  On Linux you will need to do `chmod +x diagen.py`
in order to run it if obtained this way.

Perhaps the best way to integrate Diagen into the development flow is to
put it into the server folder and add it to the start of the
StartServerConsole startup script.  For example on Windows:

```cmd
DEL WorldGen\Dialogues\MyScript.xml
.\diagen.py WorldGen\Dialogues\MyScript.py

java -jar ...
```

Or on Linux

```sh
rm WorldGen/Dialogues/MyScript.xml
./diagen.py WorldGen/Dialogues/MyScript.py

java -jar ...
```

This ensures every time you start the server that you will have the up
to date dialogues.

Usage
-----

In a command line in the directory the script is installed to:

`.\diagen.py script.py [dialog file] [event file]` (Windows command and
powershell)
`./diagen.py script.py [dialog file] [event file]` (Linux command line)

Generates a dialogue XML file based on a python script and writes it to
output.xml.  If not specified the dialog output file defaults to the
name of the input file with a .xml suffix, and the event file defaults
to the name of the input file pluss _event.xml.

Both the script and the output files may be denoted as `-` to indicate
they should be read from standard input or written to standard outupt
respectively.

Script format
-------------

A Diagen script is a Python script that sets a global variable named
`dialogues` to a dictionary of dialogue name to a dialogue section
definetion.  And optionally sets another global variable named `events`
with event definitions.  In other words, a typical script will have the
following form:

```py
dialogues = {
    "MY_DIALOGUE": [
        section content,
        ...
    ],
}

events = [
    EventDef("EVENT_TYPE", "MY_EVENT", ...),
]
```

### Dialogues

Dialogue sections are Python lists consisting of strings and
[Directives](#directives).  Strings correspond to the text content of
messages, and multiple consecutive messages will be linked together with
auto generated replies.  The text content of replies can be controlled
with the [Reply](#replytextnone-params) directive, though by default the
reply text is `[SKIP]...`.  Here's a complete Diagen script containing a
short exchange of words.

```py
dialogues = {
    "MY_DIALOGUE": [
        "Hi. Who are you?",
        Reply("[PLAYER_NAME]"),
        "Oh, Hi [PLAYER_NAME], I'm [NPC_NAME]",
        "I have an important mission for you.",
        "I need you to go to the other side of the space station.",
    ],
}
```

To represent dialogue trees with multiple paths diverging and converging
the [Choice](#choicetext-choices) directive is used.  For example,
here's a choice where the character asks about the favorite color with 3
different responses.

```py
Choice("What is your favorite color?", [
    [
        Reply("Red"),
        "Cool, that's my favorite too!",
    ],
    [
        Reply("Green"),
        "Green reminds me of the grass fields at home.",
    ],
    [
        # Without a response, the default ('[SKIP]...') is used
        "Silent protagonist, eh?",
        Choice("Would you like some tea perhaps?", [
            [
                Reply("Yes"),
                "I'll see what I can find",
                End,
            ],
            [Reply("No")],
            [], # Empty responses are also possible
        ]),
    ],
]),
"I guess it was nice talking to you",
```

Note: To reduce distracting clutter, only the section content is shown
here.

Using Reply at the beginning of a choice sub section sets the text of
the reply used.  Once the message flow reaches the end of a choice
subsection it contiues after the Choice directive it was defined in.
Here, after `Reply("No")` the flow exits the nested choice subsection
and continues out another choice subsection and into `"I guess it was
nice talking to you"`

Another flow control directive used here is [End](#end).  It means the
flow of messages in that given path ends there.

When processed through Diagen choice section produces the following XML:

```xml
<message id="M0" text="What is your favorite color?">
    <reply id="R1" next="M1" text="Red" />
    <reply id="R2" next="M2" text="Green" />
    <reply id="R3" next="M3" text="[SKIP]..." />
</message>
<message id="M1" text="Cool, that's my favorite too!">
    <reply id="R1" next="M6" text="[SKIP]..." />
</message>
<message id="M2" text="Green reminds me of the grass fields at home.">
    <reply id="R1" next="M6" text="[SKIP]..." />
</message>
<message id="M3" text="Silent protagonist, eh?">
    <reply id="R1" next="M4" text="[SKIP]..." />
</message>
<message id="M4" text="Would you like some tea instead?">
    <reply id="R1" next="M5" text="Yes" />
    <reply id="R2" next="M6" text="No" />
    <reply id="R3" next="M6" text="[SKIP]..." />
</message>
<message id="M5" text="I'll see what I can find" />
<message id="M6" text="I guess it was nice talking to you" />
```

This nested method of defining dialogue paths does not turn into the
unmanagable clutter that the flat message structure inevitably becomes,
and requries far less explicit jumps to accomplish the same things.

Despite this, jumps are still necessary for some things and to support
them Diagen provides two Directives: [Label](#labelid) and
[Goto](#gototarget).  Label specifies the id of the next message, and
Goto specifies that the flow of messages should continue at the given
message id.

The simplest and most straightforward use case for Label and Goto is
implementing a looping menu:

```py
Label("Menu"),
Choice("What can I do for you?", [
    [
        Reply("Tell me about the station"),
        "This station was ...",
        # ...
    ],
    [
        # More choices ...
    ],
    [
        Reply("That was all"),
        End,
    ],
]),
Goto("Menu"),
```

The last thing to mention is [Condition](#conditiontype-params) and
[Event](#eventid-target).  Contion may appear at the start of a choice
subsection and adds a `<condition>` element to the reply element leading
to that subsection, and Event attaches an `<event>` element to the
message preceeding it.

```py
Choice("Greetings", [
    [
        Reply("Give me a challange"),
        Condition("SECTOR_SHIPS_ABSENT", qty=1, owner="THE_BEARS"),
        "Here you go!",
        Event("SPAWN_CHALLANGE", "PLAYER"),
    ],
    [Reply("Bye!")],
]),
```

As an alternative to referencing an event definition with Event, the
event can be defined inside dialogue sections with the [InlineEvent][1]
directive.  InlineEvent takes as argument the event type, the target,
and optionally the name of the event, followed by the event parameters.
If not given the name of an inline event is automatically generated
based on the name of the dialogue.  See the next section for more
details on defining events.

### Events

Events are primarily defined with [EventDef](#eventdeftype-name-params)
inside the `events` global variable.  For example to create an event
named SET\_MY\_VAR which will set the server variable MY\_VAR to 1 when
invoked one can use the following:

```py
events = [
    EventDef("SERVER_VARIABLE", "SET_MY_VAR",
        var_name="MY_VAR", var_value="1"
    ),
]
```

Some events have aditional elementes in the XML specifying various extra
things associated with the event.  For SPAWN\_SHIP there's the
`<add_ship>` element specifying the ship.  In diagen this is specified
with the [AddShip](#addshipparams) directive after the event definition.
For example to spawn a particularly bad pirate ship, the following
diagen code can be used:

```py
EventDef("SPAWN_SHIP", "MY_PIRATE_SHIP_SPAWN"),
AddShip(
    gen_ship_model="MY_PIRATE_SHIP_MODEL", ship_qty=1, ship_name="Pirate",
    random_pos=1, min_healt=10, max_health=10
),
Ai("LIFE_SUPPORT"),
Ai("EVADER"),
Ai("SENTRY"),

SpawnNPC(
    qty=1, is_captain=1, random_name=1, race="HUMAN",
    home_system="PILOTING", spawn_at_home=1
),
Ai("NPC_TALKER", timer=30, mes="I will shot you to bits!"),
```

Note: To reduce distracting clutter, only the events content is shown
here.

This also shows how [Ai](#aitype-params) can be added to AddShip, as
well as [SpawnNPC](#spawnnpcparams), and generally ends up attached
whichever is the closest previous applicable directive.  There is also
[AddDebris](#adddebrisparams) and [Item](#itemparams) for placing items
into sectiors.

### Order of Directives

Directives apply for the most part to some previous directive or
message.  This means that unless care is taken to avoid mixing
directives altering flow of message with ones that apply to the message
itself the behaviour may be very confusing.  For example, in the
following section the Event, Reply and End all applies to the `"that was
all"` message.  This means that even though the event and response
appears after the End marker they are still triggered/shown.

```py
"that was all",
End
Event("EVENT", "PLAYER"),
Reply("Thank you"),
```

Future version may disallow this kind of order breakage.

### Auto Generated Ids

Ids generated are of the form `M{unique number}` for messages and
`R{number}` for replies.  The message id for a message can be overriden
with the Label directive

For inline events with auto generated names its of the form `{dialogue
name}_E{number}`

Since I'm not aware of any use for the reply id, there's no way to
influence the reply ids generated.

Options Controlling Behaviour
-----------------------------

To control the behaviour of Diagen you can set `diagen_options` to a
dictionary of option name to option value.  The available options are:

### default\_response

By default the reply text of a message is `[SKIP]...`, this can be
changed by setting `'default_response'`.  For example you can make the
character overly affirmative with:

```py
diagen_options = {
    'default_response': "[SKIP]Aye sir!",
}
```

### mangle\_any\_value

To work around a bug in a0.8.19 you can set `'mangle_any_value'` option
to `True`.  This will cause Diagen to add a `var_value="1"` to
conditions with the type `SERVER_VARIABLE_(ABSENT|PRESENT)` and
`any_value="1"` set.  Since this got fixed in a0.8.20 this option
defaults to `False`.

### mangle\_empty\_value

By default Diagen will swap the condition type of
`SERVER_VARIABLE_(ABSENT|PRESENT)` conditions to their logical opposite
if neither `any_value`, nor `var_value` is set.  This is due to the
highly unintuitive behavour of using these conditions, where they act in
the reverse of what the name logically implies.  I.e. the following

```xml
<condition type="SERVER_VARIABLE_PRESENT" var_name="MY_VAR" />
```

will match if `MY_VAR` _is not set_.  Diagen reverse this so that

```py
Condition("SERVER_VARIABLE_PRESENT", var_name="MY_VAR")
```

will produce the `_ABSENT` variant that matches if `MY_VAR` is set.  You
can disable this behaviour by setting the `'mangle_empty_value'` option
to `False`.

Directives
----------

Dialogue sections are lists consists of strings denoting message
contents and directives describing special elements or properties these
messages should have.  There's also subsections thare are made with the
[Choice](#choicetext-choices) directive.

### Note about params

Many directives have a `params` parameter.  These are name, value pairs
that have form `name="value", ...` and correspond to the `<node_param
name="value" \>` element in the XML, where `node` is the relevant tag,
i.e. `event` for an event node.  Values can also be integeres instead of
strings, in this case they will be converted to strings in the XML
output.

If a param value is a list, it'll output one `<node_param>` element for
each element in the list into the generated XML.  Otherwise the short
form of putting it as an attribute to the `<node>` element is used.

It's also possible to specify params as a python dictionary mapping name
to values.  This should be supplied either as the position argument
corresponding to params, or as a keyword argument named `params`.
If both params and keyword arguments are used, both will be included and
the latter with take precedence if keys are duplicated.

### Label(id)

Specifies that the next message should have the given id.  This directly
corresponds to the id attribute of the message element in the XML
output.

Attaches to the next message or the next choice.

### Reply(text=None, params)

Set the reply text of the previous message to the given text.  When used
at the start of a choice section it specifies the text of that choice,
as well as any extra attributes for the `<reply>` element.  When used
imminently after a Choice section it sets the default response
text for all choices in that choice section.

Note: params can only be set when this directive is used at the start of
a choice section.  It's also possible to leave out the text parameter
there to use the default.

Attaches to the previous message or the choice subsection.

### Goto(target)

Continue the message flow from another message.  Works by setting the
next attribute on the reply of the previous message to the given target.
Target should be a message id set by Label.

Attaches to the previous message or the choice subsection.

### End

Signify the end of the message stream.  Normally the next message is
automatically linked via the next attribute of the reply element, this
flag specifies that the previous message should not be linked, and thus
ends the dialogue there.

Attaches to the previous message or the choice subsection.

### Event(id, target)

Attach an event to the previous message.  This tacks an `<event>`
element to the previous message where id and target correspond to their
respective attributes in the XML.

Attaches to the previous message or the previous choice.

### Choice(text, choices)

Specifies a multiple choice message.  Each choice is of the form
[subsection content, ...] and emulates a reply element in the XML.  The
reply element can be modified with Reply, Condition, Goto and End added
to the start of the subsection

### Condition(type, params)

Specifies the condition of a reply, event, or AI.  Can only be used at
the start of a choice subsection, after an EventDef or InlineEvent
directive, or after an Ai directive.

The element created in the xml depens on what the condition is applied
to.  For replies in inside Choice subsections and events it creates a
`<condition>` element, for Ai's attached to SpawnNPC directives it
creates an `<npc_ai_condition>` element, and for Ai's attached to
AddShip directives it creates an `<ship_ai_condition>`.

See [note about params](#note-about-params) for a description of the
`params` parameter.

Attaches to the choice subsection, or the previous event or AI.

### InlineEvent(type, target, name=None, params)

Defines and attaches an event to the previous message.  Like Event, but
instead of referencing an event defined elsewhere the event is defined
inline with the dialogue.  The name of the event if not defined is
generated based on the dialoge name and takes the form
`{dialogue name}_E{number}`.

See [note about params](#note-about-params) for a description of the
`params` parameter.

Attaches to the previous message.

### EventDef(type, name, params)

Defines an event in the event list.  This corresponds to the `<event>`
element in an events XML file.

See [note about params](#note-about-params) for a description of the
`params` parameter.

### SpawnNPC(params)

Adds an NPC node to the previous event or ship.  When used after an
EventDef it creates a `<spawn_npc>` element in the event.  When used
after a AddShip it creates a `<spawn_npc_on_ship>` element in the ship.
Both of these support adding AIs with the Ai directive after this one.

As a convenience all parameter names passed to SpawnNPC is prefixed with
`npc_` in the generated XML.  This means that parameters such as
`npc_qty`, `npc_is_crew`, `npc_race` etc, should be written as `qty`,
`is_crew`, `race`, etc.

See [note about params](#note-about-params) for a description of the
`params` parameter.

Attaches to the previous EventDef, InlineEvent, or AddShip.

### AddShip(params)

Adds a `<add_ship>` node to the previous event.  NPCs can be spawned on
the ship by using the SpawnNPC directive after this one.  AIs to attach
to ship can also be added with the Ai directive, but note that this
would have to come before any SpawnNPC directives, otherwise the Ai
directive would apply to those instead.

See [note about params](#note-about-params) for a description of the
`params` parameter.

Attaches to the previous EventDef or InlineEvent.

### Ai(type, params)

Adds an AI element to an NPC or ship.  When put after an AddShip it
procudes a `<ship_ai>` element inside the ship element, and when put
after a SpawnNPC it produces an `<npc_ai>` element inside the spawn npc
element.  Both of these support adding conditions to the AI element by
using the Condition directive after this one.

See [note about params](#note-about-params) for a description of the
`params` parameter.

Attaches to the previous SpawnNPC or AddShip.

### AddDebris(params)

Used for the SPAWN\_DEBRIS event to add an `<add_debris>` nodes to it.
For example, a simple debris spawning event can be defined as.

```py
EventDef("SPAWN_DEBRIS", "MY_DEBRIS"),
AddDebris(owner="Lost ship", random_pos=1),
Item(item_type="SHIP_SYSTEM", system_model="SENSORS1"),
Item(item_type="SHIP_SYSTEM", system_model="SENSORS2"),
```

See [note about params](#note-about-params) for a description of the
`params` parameter.

Attaches to the previous EventDef or InlineEvent.

### Item(params)

Item definition for AddDebris, corresponds to the `<debris_item>`
element.  Should have an `item_type` and a `system_model` parameter.

See [note about params](#note-about-params) for a description of the
`params` parameter.

Attaches to the previous AddDebris.

Examples
--------

A simple dialog with a captain character.

```py
dialogues = {
    "Captain": [
        "Hello [PLAYER_NAME], I'm the captain of this ship",
        Choice("Would you like some tea?", [
            [
                Reply("No thanks"),

                "Alright then, no tea for you",
                InlineEvent("SERVER_VARIABLE",
                    var_name="PLAYER_DECLINED_TEA", var_value=1
                ),
            ],
            [
                Reply("Yes please"),

                "Here you go. Now go out there and fight some foes!",
                Event("GIVE_TEA", "PLAYER"),
                Reply("Aye sir!"),
            ]
        ]),
    ],
}

events = [
    EventDef("MODIFY_SHIP", "GIVE_TEA",
        all_mob_ships=0, ignore_passenger_access=0,
        add_system_model_to_cargo="TeaBrewer"
    ),
]
```

When processed through Tachyon Diagen it produces the following XML for
the dialogues:

```xml
<?xml version='1.0' encoding='UTF-8'?>
<dialogues>
    <!-- Generated by diagen.py -->
    <dialogue name="Captain">
        <start>M0</start>
        <message id="M0" text="Hello [PLAYER_NAME], I'm the captain of this ship">
            <reply id="R1" text="[SKIP]..." next="M1" />
        </message>
        <message id="M1" text="Would you like some tea?">
            <reply id="R1" text="No thanks" next="M2" />
            <reply id="R2" text="Yes please" next="M3" />
        </message>
        <message id="M2" text="Alright then, no tea for you">
            <event id="Captain_E0" target="PLAYER" />
        </message>
        <message id="M3" text="Here you go.  />
        </message>
    </dialogue>
</dialogues>
```

And the following XML for the events:

```xml
<?xml version='1.0' encoding='UTF-8'?>
<events>
    <!-- Generated by diagen.py -->
    <event type="MODIFY_SHIP" name="GIVE_TEA" all_mob_ships="0" ignore_passenger_access="0" add_system_model_to_cargo="TeaBrewer" />
    <event type="SERVER_VARIABLE" name="Captain_E0" var_name="PLAYER_DECLINED_TEA" var_value="1" />
</events>
```

For more complete examples see the the [examples directory](examples).

repository: Dav-Edward/Tachyon-Starwisp-Mod

repo_name: Dav-Edward/Tachyon-Starwisp-Mod


text:
## Install Postman to K6 Converter

Developer acively using Postman
You can directly take Postman collection and env variables fom dev team
Use converter to autogenerate k6 Scripts
Fix K6 scripts to satisfy your requirements

Note: npm works better  if you use brew to install it
`brew install npm`

Lets Instal -
`npm install -g postman-to-k6`
`npm install postman-to-k6`

After installation we will generate Automaed K6 Scripts
`postman-to-k6 01-Course.postman_collection.json -e COURSE.postman_environment.json -o script-2.js`

This is how you can generate scripts :)

Lets execute Postman to K6 generated K6 scripts
You need minor fixes like fixing unique ids or dependencies in k6 scripts
lets resolve this

Short name is already used for another course (mycourses123)
dupicate short name not allowed
so lets write function to generate unique name or id

branch_name: refs/heads/main

extension: md

license_type: permissive


text:
---
name: Search commits
example: octokit.rest.search.commits({ q })
route: GET /search/commits
scope: search
type: API method
---

# Search commits

Find commits via various criteria on the default branch (usually `main`). This method returns up to 100 results [per page](https://docs.github.com/rest/overview/resources-in-the-rest-api#pagination).

When searching for commits, you can get text match metadata for the **message** field when you provide the `text-match` media type. For more details about how to receive highlighted search results, see [Text match
metadata](https://docs.github.com/rest/reference/search#text-match-metadata).

For example, if you want to find commits related to CSS in the [octocat/Spoon-Knife](https://github.com/octocat/Spoon-Knife) repository. Your query would look something like this:

`q=repo:octocat/Spoon-Knife+css`

```js
octokit.rest.search.commits({
  q,
});
```

## Parameters

      name
      required
      description

q	yes

The query contains one or more search keywords and qualifiers. Qualifiers allow you to limit your search to specific areas of GitHub. The REST API supports the same qualifiers as the web interface for GitHub. To learn more about the format of the query, see [Constructing a search query](https://docs.github.com/rest/reference/search#constructing-a-search-query). See "[Searching commits](https://docs.github.com/search-github/searching-on-github/searching-commits)" for a detailed list of qualifiers.

sort	no

Sorts the results of your query by `author-date` or `committer-date`. Default: [best match](https://docs.github.com/rest/reference/search#ranking-search-results)

order	no

Determines whether the first search result returned is the highest number of matches (`desc`) or lowest number of matches (`asc`). This parameter is ignored unless you provide `sort`.

per_page	no

The number of results per page (max 100).

page	no

Page number of the results to fetch.

See also: [GitHub Developer Guide documentation](https://docs.github.com/rest/reference/search#search-commits).

license: MIT

gha_language: TypeScript

gha_license_id: MIT


text:
### Block

This is generally applicable to flow layouts, or to full rows at the top and bottom of a container.

setting `block` property。

<!--start-code-->
```js
const instance = (
  <ButtonToolbar>
    <Button appearance='default' block>Block</Button>
    <Button appearance='primary' block>Block</Button>
  </ButtonToolbar>
);
ReactDOM.render(instance);
```
<!--end-code-->

repository: SevenOutman/rsuite

branch_name: refs/heads/master

repo_name: SevenOutman/rsuite


text:
# dilbert-reader
meteor.js app for reading dilbert comics

## What?

This app aims to replace the standard Android (iOS as well ... probably) app while keeping all of the original functionality plus some extras like:

* Better algorithm for random Dilbert strip! Whenever I used this feature (like everyday) I felt like Dilbert in the accounting: http://dilbert.com/strip/2001-10-25
* Twitter / Facebook / Google OAuth SSO - make it easy to share a strip with your friends or save your favourite ones permanently and accessible from everywhere (offline as well?!).
* etc. (Feel free to contact me if you have other ideas)

## Why?

The standard Android Dilbert app stopped working a while ago and it's still not working - "Unable to connect to server". Meanwhile I was looking for an interesting project to build some web dev skills and play around with meteor.js.

## How?

As I mentioned in the Why? section - the technology behind the project was part of the motivation behind it. Although I'm a huge fan of Clojure I also keep an eye on meteor.js and wanted to experiment with Cordova.

repository: hristoyankov/dilbert-reader

repo_name: hristoyankov/dilbert-reader


text:
---
title: Check job files
description: Learn how to check job files in Adobe Dynamic Media Classic.
uuid: 8241a894-3014-4a5c-96ef-71f3aaa3716a
contentOwner: Rick Brough
content-type: reference
products: SG_EXPERIENCEMANAGER/Dynamic-Media-Classic
geptopics: SG_SCENESEVENONDEMAND_PK/categories/upload_and_publish_assets
discoiquuid: d53ae5dd-8daf-4d87-b9a6-3039bad30538
feature: Dynamic Media Classic,Asset Management
role: User
exl-id: b6b11e1c-5eda-4bdb-8ffb-ecd3678f2352
topic: Administration, Content Management
level: Intermediate
---
# Check job files{#checking-job-files}

To monitor file uploads to the Adobe Dynamic Media Classic and files that you publish to Adobe Dynamic Media Classic servers, Adobe Dynamic Media Classic offers the Jobs page. You can review upload and publish jobs on the Jobs page, check the status of jobs, and cancel publishing jobs from this page. You can also schedule upload and publishing jobs.

When you upload assets, a spinning icon appears next to the Jobs menu, indicating a job is in progress, and the number of files in progress. You can select the icon to see more information about the active job.

>[!NOTE]
>
>A list of your recently published jobs is also available on the Recent Activity page. Select **[!UICONTROL Recent]** on the Global Navigation bar.

## About the Jobs page {#about-the-jobs-page}

Select **[!UICONTROL Jobs]** on the Global Navigation bar so the Jobs page opens. By default, jobs are listed starting with the most recent.

Jobs are listed in these categories on the History tab of the Jobs page:

* **[!UICONTROL Job Type]** - An icon indicates the job type: Upload and Publish are the most common job types.

* **[!UICONTROL Job Name]** - The name of the job. The name includes the user-entered portion of the name and the date and time.

* **[!UICONTROL Started]** - When the job started.

* **[!UICONTROL Total]** - The number of files transferred.

* **[!UICONTROL W (warnings)]** - The number of warnings in the job (if any). Warnings indicate problems with the job that did not affect overall job completion. These warnings can usually be ignored because they report on hidden files. For example, `.DS_store` files (Macintosh) and Thumbs.db files (Windows®) contain information about how to display image files to users. Warning entries regarding these files, however, can be ignored because they don’t pertain to how these files are used in Adobe Dynamic Media Classic. You can double-click a job name to get detailed information about warnings.

* **[!UICONTROL E (errors)]** - Lists the number of errors in the job (if any). You can double-click a job name to get detailed information about errors.

* **[!UICONTROL Duration]** - How long it took to complete the job.

* **[!UICONTROL Status]** - Shows the status of the job.

* **[!UICONTROL Destination]** - For upload jobs, the company name, and folder to which the files were uploaded. This category doesn’t apply to publish jobs.

* **[!UICONTROL Submitted By]** - Lists who uploaded the assets.

>[!NOTE]
>
>You can cancel in-progress publish and upload jobs by selecting the **[!UICONTROL Cancel]** button next to the progress bar.

## Change views on the Jobs page {#changing-views-on-the-jobs-page}

Use these techniques to sort jobs or change your view of the History tab of the Jobs page:

* **[!UICONTROL Sorting]** - Select a column name to sort the list by a particular column. You can select the switch beside the column name to sort in descending or ascending order.

* **[!UICONTROL Date Range]** - Select the **[!UICONTROL Date Range]** menu and choose an option to narrow the list of jobs to the current date, the previous week, or the previous month. Select **[!UICONTROL Custom Date Range]**, then enter a specific date range.

* **[!UICONTROL Job Type]** - Select the **[!UICONTROL Job Type]** menu and choose **[!UICONTROL Publish]** or **[!UICONTROL Upload]** to narrow the list to publish jobs or upload jobs. Select **[!UICONTROL All]** to see both types of jobs.

* **[!UICONTROL Show]** - Go to **[!UICONTROL Show]** > **[!UICONTROL My Jobs]** or **[!UICONTROL Show]** > **[!UICONTROL All Jobs]** to narrow the list to jobs you ordered or jobs that people in your company ordered.

## View, copy, or print a Job Details report {#viewing-copying-or-printing-a-job-details-report}

Double-click the name of a report on the Jobs page so the Job Details page opens. This page provides a summary report about the files in the job. Select **[!UICONTROL View Detail]** so you can see an entry’s Adobe Dynamic Media Classic ID, destination path, and status information. If you uploaded a PDF or PostScript file that requires fonts that are not available in Adobe Dynamic Media Classic, the report lists the missing fonts.

You can copy this information to the Clipboard.

1. Double-click the name of a report on the Jobs page.
1. On the Job Details page, select **[!UICONTROL View Detail]** to get a detailed report about an entry.
1. Select **[!UICONTROL Copy to Clipboard]**.

## Handle recurring upload and publish jobs {#handling-recurring-upload-and-publish-jobs}

Recurring upload and publish jobs that you create on the Upload and Publish pages are listed on the Scheduled tab of the Jobs page. You can edit and delete recurring jobs on the Scheduled tab.

Select the Jobs button on the Global Navigation bar and, on the Jobs page, select the **[!UICONTROL Scheduled]** tab so you can edit and delete recurring jobs.

>[!NOTE]
>
>You can filter the job list on the **[!UICONTROL Scheduled]** tab with the **[!UICONTROL Job Type]** and **[!UICONTROL Show]** menus. Select a job type so you can narrow the list to publish jobs of a specific kind. Select a **[!UICONTROL Show]** option if you want to display jobs you created or jobs created by everyone in your company.

### Edit, delete, pause, and resume recurring jobs {#editing-deleting-pausing-and-resuming-recurring-jobs}

Select a recurring job on the Jobs page and follow these instructions if you want to edit or delete it:

* **Edit a recurring job** - Select the **[!UICONTROL Edit]** button and enter schedule information in the Edit Scheduled Job dialog box. If you want the job to recur at an interval of your choice, go to **[!UICONTROL Repeat]** > **[!UICONTROL Custom]**.

See [Create a custom upload or publish job time interval](checking-job-files.md#creating_a_custom_upload_or_publish_job_time_interval).

* **Deleting a recurring job** - Select the **[!UICONTROL Delete]** button.

* **Pausing (and resuming) a recurring job** - In the Active column, deselect a check box to pause a job; select a check box to resume a job that was paused.

### Create a custom upload or publish job time interval {#creating-a-custom-upload-or-publish-job-time-interval}

To create a custom time interval for an upload (via FTP) or a publish job, on the Upload or Publish page, go to **[!UICONTROL Repeat]** > **[!UICONTROL Custom]**. Then enter numbers and wildcards in the Rule box describing a time interval for the upload or publish jobs to recur.

The syntax for describing custom upload and publish time intervals in the Rule box is:

`[seconds]` `[minutes]` `[hour of day]` `[day of month]` `[month]` `[day of week]`

For example, `0 15 10 * * ?` schedules a job at 10:15.00 every day.

The following tables and list explain how to describe a time interval in the Rule box.

This table shows the time increments, their allowed values, and the wildcards they support:

|Time increments|Values allowed|Comments|Wildcards supported|
|--- |--- |--- |--- |
|Seconds|0-59||`, - * /`|
|Minutes|0-59||`, - * /`|
|Hours|0-23|Note the use of a 24-hour clock.|`, - * /`|
|Day of the month|1-31|You cannot specify a numeric value for both “day of the month” and “day of the week.” One of these fields must use a `?` wildcard character.|`, - * / ? L C`|
|Month|1-12 or Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Sep, Oct, Nov, Dec|Values are case-sensitive.|`, - * /`|
|Day of the week|Mon, Tue, Wed, Thu, Fri, Sat, Sun|Values are case-sensitive. You cannot specify a numeric value for both “day of the month” and “day of the week.” One of these fields must use a `?` wildcard character.|`, - * / ? L C #`|
|Year (optional)|Empty or 1970-2099||`, - * /`|

This table describes the wildcard characters that are allowed in the Rule box and how to use them:

|Wildcard character|Name|What it describes|
|--- |--- |--- |
|`*`|Asterisk|All values (for example, “every minute”).|
|`?`|Question mark|No specific value (for example, “any minute within the specified hour”).|
|`,`|Comma|Other values (for example, “Monday and Wednesday”).|
|`-`|Hyphen|Range of values (for example, “Monday through Friday”).|
|`/`|Forward slash|Increments (for example, “every 15 minutes”).|
|`L`|Capital L|Last “day of the month” or “day of the week” (available for these fields only). For example, if the month is January, an L value for the “day of the month” field schedules the job for January 31. For the “day of the week” field, you can enter this character alone to schedule the job on Saturday. You can use it with a number (for example, `6L`) to specify the last Friday of the month. Do not specify `L` with the comma or hyphen wildcards.|
|`#`|Number sign|“Nth” weekday of the month (available for the “day of the week” field only). For example, `6#3` in the “day of the week” field specifies the third Friday of the month. The `6` denotes “Friday” (the sixth day of the week) and the `3` denotes the third occurrence in the month.|
|`C`|# Capital C|First calendar “day of the month” or “day of the week” (available for these fields only). For example, specifying a value of `1C` for “day of the month” schedules the first day in the calendar that occurs on or after the fifth. For the “day of the week” field, specifying `1C` schedules the first day in the calendar that occurs on or after Sunday|

This list gives examples of describing time intervals in the Rule box:

* `0 0 12 * * ?` : Noon every day
* `0 15 10 ? * *` : 10:15 am every day
* `0 0/5 14 * * ?`: Every 5 minutes between 2:00 and 2:55 pm every day
* `0 0/5 14,18 * * ?` : Every 5 minutes between 2:00 and 2:55 pm every day and every 5 minutes between 6:00 and 6:55 pm every day
* `0 10,44 14 ? 3` : Wed at 2:10 pm and 2:44 pm every Wednesday in March
* `0 15 10 ? *` : Mon-Fri at 10:15 am every weekday
* `0 15 10 20 * ?` : At 10:15 am on the 20th day of every month
* `0 15 10 L * ?` : At 10:15 am on the last day of every month
* `0 15 10 ? * 6L` : At 10:15 am on the last Friday of every month
* `0 15 10 * * 6#3` : At 10:15 am on the third Friday of every month

## Use an upload or publish job as a trigger {#using-an-upload-or-publish-job-as-a-trigger}

When you upload assets via FTP or run a publish job, you can schedule a subsequent job to begin when the upload is complete. (If other jobs are scheduled to begin then, the job you schedule here is queued behind them.) The new job sends a notification to the address that you specify so that code at that location can be triggered. This follow-on upload job is given the same name as the current upload job, but with the prefix _Pub.

To make one upload or publish job trigger another job, select **[!UICONTROL Advanced]** on the Upload or Publish page. Then enter the URL in the HTTP Notification text field.


text:
index: 23
tag: trail

# Queen Margaret Bridge

![Queen Margaret Bridge, 1929](image:queen-margaret-bridge.jpg)

The bridge seen today was built during 1926-29 by
Thomas Somers & Considere Constructions Ltd,
engineers at a cost of £108,424. it consists of a
reinforced concrete segmental arch with semicircular
arches for footpaths on both sides. The concrete is
faced with red Comcockle sandstone, and there are
solid red Peterhead granite parapets. The main span is
135 feet 6 inches long.

repository: cilogi/cilogi-guides

repo_name: cilogi/cilogi-guides


text:
---
title: Visualizing Weave Net in Weave Cloud
menu_order: 30
search_type: Documentation
---

Weave Net provides a simple to deploy networking solution for containerized apps. Here, we describe how to manage a Weave container network using a sample application which consists of two simple `netcat` services deployed to containers on two separate hosts.

This section contains the following topics:

 * [Signing in to Weave Cloud](#signing-in)
 * [Launching Weave Net](#launching)
 * [Launching on Additional Hosts](#peer-connections)
 * [How Peer Discovery Works](#how-it-works)

### Signing in to Weave Cloud

Weave Cloud is a fast and simple way to visualize, manage and monitor
containers and microservices.  In order to use Weave Cloud to set up
Weave Net, you must sign up to Weave Cloud and create an "Instance".

The instance will have a Service Token which is a 32-character string
used to uniquely identify it.  Get hold of the Service Token for your
Instance, as shown below:

![UI to get a Service Token](weave-cloud-token.png)

For the purpose of these instructions we will use a dummy Service
Token `dk6hz1acdd58aea6b75migoy4axqasdf`.

### Launching Weave Net

Before launching Weave Net and deploying your apps, ensure that Docker
is [installed](https://docs.docker.com/engine/installation/) on both
hosts.

On `$HOST1` run:

    host1$ weave launch --token=dk6hz1acdd58aea6b75migoy4axqasdf
    host1$ eval $(weave env)
    host1$ docker run --name a1 -ti weaveworks/ubuntu

Where,

 * The first line runs Weave Net.

* The second line configures the Weave Net environment, so that containers launched via the Docker command line are automatically attached to the Weave network, and,
 * The third line runs the [application container](/site/faq.md#own-image) using [a Docker command](https://docs.docker.com/engine/reference/run/).

> **Note** If the first command results in an error like
> ```
> Cannot connect to the Docker daemon. Is the docker daemon running on this host?
> ```
> then you likely need to be 'root' in order to connect to the Docker
> daemon. If so, run the above and all subsequent commands in a
> *single* root shell:
> ```
> host1$ sudo -s
> host1# weave launch --token=dk6hz1acdd58aea6b75migoy4axqasdf
> host1# eval $(weave env)
> host1# docker run --name a1 -ti weaveworks/ubuntu
> ```
> Do *not* prefix individual commands with `sudo`, since some commands
> modify environment entries and hence they all need to be executed from
> the same shell.

Weave Net must be launched once per host. The relevant container images will be pulled down from Docker Hub on demand during `weave launch`.

You can also preload the images by running `weave setup`. Preloaded images are useful for automated deployments, and ensure there are no delays during later operations.

If you are deploying an application that consists of more than one container to the same host, launch them one after another using `docker run`, as appropriate.

### Launching on Additional Hosts

To launch Weave Net on an additional host and create a peer
connection, run exactly the same commands as on the first host:

    host2$ weave launch --token=dk6hz1acdd58aea6b75migoy4axqasdf
    host2$ eval $(weave env)
    host2$ docker run --name a2 -ti weaveworks/ubuntu

Because you are using Weave Cloud, the second peer will discover the
first and automatically create a connection to it.

>**Note:** If there is a firewall between `$HOST1` and `$HOST2`,  you must permit traffic to flow through TCP 6783 and UDP 6783/6784, which are Weave’s control and data ports.

Now you can proceed to [test container communications](/site/install/using-weave#testing)

### How Peer Discovery Works

The Weave Cloud back-end maintains a database of all the peers that
have registered in each instance. You can create as many instances as
you like in the Weave Cloud console: for different projects, or to
separate test and production.

As each peer starts up, it looks for all network instances that
another peer might be able to contact it on, and registers those with the back-end.
If you want to control which addresses are used, add the `--advertise-address` flag:

    host1$ weave launch --token=dk6hz1acdd58aea6b75migoy4axqasdf --advertise-address=<IP_ADDRESS>,<IP_ADDRESS>

When the new peer registers itself, it also fetches a list of all
other peers in the instance, and begins to contact them.

If the peer cannot contact the Weave Cloud back-end it will print an
error message in its log and exit. To check the logs run:

    host1$ docker logs weave

When a Weave Net instance is formed for the first time, the peers must
initialize the [IP Allocation Manager](/site/tasks/ipam/ipam.md). This process,
and the configuration options available, are unchanged when using
Weave Cloud.

When you shut down a peer for good, use [the `weave reset`
command](/site/tasks/ipam/stop-remove-peers-ipam.md) and it will be removed
from the Weave Cloud database so future peers will not attempt to
connect to it.

**See Also**

 * [Installing Weave Net](/site/install/installing-weave.md)
 * [Launching Weave Net](/site/install/using-weave.md)
 * [Using Fastdp With Weave Net](/site/tasks/manage/fastdp.md)
 * [Integrating Docker via the Network Plugin (Legacy)](/site/install/plugin/plugin.md)
 * [Integrating Docker via the Network Plugin (V2)](/site/install/plugin/plugin-v2.md)

repository: louismunro/weave

repo_name: louismunro/weave


text:
# Inspirational story of woman 'born in shame' who saved thousands of lives

Published at: **2019-11-03T07:00:00+00:00**

Author: **Kirsten Jones**

Original: [mirror](https://www.mirror.co.uk/news/real-life-stories/inspirational-story-woman-born-shame-20751182)

In the last two years, Elizabeth Anionwu has released a bestselling memoir, been made a Dame by the Queen and received four honorary degrees for her incredible work in nursing.
She has dedicated her life to improving the lives of thousands in the black community who are suffering with sickle cell disease, all while battling racism as a mixed-race woman.
In 1979, she became the first sickle cell and thalassaemia specialist in Britain, and in 2016 co-led a campaign for a statue of black nurse Mary Seacole – the Jamaican woman who treated British soldiers on the battlefield in the Crimean War – at St Thomas’ Hospital.
This year, Dame Elizabeth will be presented with the Pride Of Britain Lifetime Achievement Award for her incredible services to nursing.

‘It’s still quite difficult to believe, actually,’ she admits with surprise.
‘I was sitting down in my front room when I got the phone call and I did cry a little bit – I really was overwhelmed.'
'It was a shock, but a lovely one, of course.’
Dame Elizabeth will be one of many brave and inspirational guests to receive special recognition at the 20th anniversary of the Daily Mirror Pride Of Britain Awards.
At the star-studded event, held at Grosvenor House in London, Dame Elizabeth will meet Carol Vorderman and step up on stage to collect her award from a very famous face.
‘I have no idea who it’s going to be.'
'It’s sort of exciting, but a little bit scary as well,’ she confesses.
‘I always like a little bit of suspense – I’m taking a group of family and friends who are all over the moon, including my daughter [former Casualty star Azuka Oforka, who played Louise Tyler] and my 11-year-old granddaughter, who is bringing her autograph book.’
Family is a big part of Dame Elizabeth’s life, but, born out of wedlock to an Irish woman and a Nigerian man, her own upbringing was tarnished by racism, cruelty and abuse.

Soon after her birth in 1947, she was sent away to a Catholic children’s home run by nuns who were, at times, very unkind indeed.
‘When I wet the bed I had to stand on a chair and hold the wet sheet above my head.'
'A nun would whack me with a ruler if my arms got tired.'
'Even now, decades later, I still remember that cruel punishment.'
'I remember thinking, “That’s not very Christian”.’
Dame Elizabeth spent the first nine years of her life in care and her mother would travel to visit her when she could.
She’d often spend several weeks without contact, but between their chores, Dame Elizabeth and her friends had hobbies like Irish dancing and piano playing to keep them entertained.
‘If we did well, we were taken into the city centre of Birmingham to have a knickerbocker glory,’ she exclaims.
‘I do remember the nice things, as well as the nasty ones.'
'People ask me what helped me through my life.'
'It was the individual acts of kindness.'
'My mother made it very clear that I was not up for adoption, so I knew that one day she would come and take me home.’
At the tender age of four, young Dame Elizabeth met a kind nun who would inspire her career in nursing.
‘I had itchy, painful eczema , which the nuns would treat with coal tar paste and cover with bandages,’ she explains.
‘One nun would tear them off in a hurry and my skin would break and bleed.'
'I was overjoyed to see the nice nun – she would say words like “bottom”, I’d burst out laughing, and she’d gently take the dressing off – I never felt a thing.'
'Later on, I discovered she was something called a nurse and I decided that’s what I wanted to be.’
Aged nine, Dame Elizabeth was brought home by her mother, who had married an Englishman.
Sadly, her stepfather was teased by his peers about his daughter’s skin colour.
He became abusive towards her, and once again Dame Elizabeth was sent away.
At 16 she became a school nurse assistant and at 18 started her training in London, where she slowly began to gain some confidence and met some lifelong friends.
‘I have a photograph of all of us, wet behind the ears in 1965,’ she laughs.
‘It was the Swinging 60s and we didn’t know what the heck had hit us.'
'One pal, Janet, and I have been friends for almost 55 years and she’ll be with me at the awards'.
'She took me under her wing and didn’t seem scared of anything.'
'To me, she had lived.'
'She took me down to Leicester Ballroom, but I couldn’t dance, I was petrified.'
'She remembers just how shy I was.'
‘At the hospital there was the odd scary ward sister, but you were warned in advance.'
'I got on well with the patients and I loved to listen to them and have a good chatter when I could.’
In the early 70s, Dame Elizabeth became a health visitor in London and had her first encounter with sickle cell anaemia – a painful disease found mostly in African and Caribbean families – which at the time was often overlooked.
‘I’d never been taught anything about it and felt helpless in front of these families,’ she reveals.
‘They told me about the terrible pain, and I felt angry too.'
'I still have my textbook from 1966 and sickle cell isn’t even mentioned.’
After a brief stay in France, just after the political protests of 1968, Dame Elizabeth returned a bolder woman who was more aware of race inequalities in Britain and the NHS.
Families had no information about how to cope with their illness or the symptoms to look out for, so Dame Elizabeth took action, raising awareness of the Sickle Cell Society.
It’s then that she became the first sickle cell and thalassaemia specialist in Britain.
‘In the first few years, we saw 3,000 people in the centre, and for the first six years I was the only specialist nurse in the country.'
'We didn’t have the internet, of course, but my goodness people knew how to communicate.’
Dame Elizabeth has spent her life as a nurse and tutor, working with black and minority communities in London.
She has received a fellowship from the Royal College of Nursing and been named one of the 70 most influential nurses and midwives in the history of the NHS.
‘I called my memoir Mixed Blessings From A Cambridge Union, but if I’d known I’d become a Dame, I’d have called it “Born In Shame, But Became A Dame”.'
'What do you think?’ She laughs.
‘I see the joy my Damehood has brought to my family – people tell me how important it is to see someone like me achieve what I’ve achieved.'
'It gives them motivation and inspiration and it does make a difference.’
It’s been an incredible year for the respected nurse, and although her mum is no longer with us, Dame Elizabeth is sure she would be so proud of her Pride Of Britain Award.
‘My mother gave up an awful lot for her children.'
'Although I’m sad that she didn’t achieve what her intellectual abilities enabled her to, she was very happy in her own way, and she’d be delighted to know that I’m still in touch with all my half-siblings.'
‘I’m proud that the audience on the night will hear about sickle cell disease.'
'I’m so chuffed – that’s a word I like to use.'
'Everybody has a narrative and I think we should all consider sharing aspects of our lives.'
'People want to hear it, so you do it.’

license: Unlicense

repository: dsadlollioygjmzvcxv/tdc-exported

repo_name: dsadlollioygjmzvcxv/tdc-exported


text:
---
layout: paper
ENTRYTYPE: inproceedings
added: 2020-07-06
authors:
- Nathan Chong
- Byron Cook
- Konstantinos Kallas
- Kareem Khazem
- Felipe R. Monteiro
- Daniel Schwartz-Narbonne
- Serdar Tasiran
- Michael Tautschnig
- Mark R. Tuttle
booktitle: Proceedings of the 2020 International Conference on Software Engineering (ICSE)
doi: 10.1145/3377813.3381347
title: Code-level model checking in the software development workflow
month: June
read: true
readings:
- 2020-07-06
year: 2020
notes:
- model checking
- CBMC verifier
---

This very readable paper describes the successful introduction of a formal
verification flow into the development of the Amazon C Common library.  Anyone
trying to introduce formal verification into a traditional development team
should read this paper!

The most important aspect of the paper is probably their focus on getting
developer buy in. This resulted in the developers writing a lot of the function
contracts as well as reviewing contracts, proofs and bugfixes written by the
verification team.  In part, this was due to finding bugs that the developers
considered worth fixing although the verification team's goal was not just to
find bugs but to prove absence of bugs.

They highlight four lessons that they learned:

- Make specifications explicit in source code
- Write proofs-harnesses in declarative style
- Integrate proof artifacts into the development workflow
- Fix bugs instead of just reporting them

that they credit with:

- Increased proof speed (i.e., reduced human effort)
- Increased rate of bugs found and fixed
- Active developer engagement with proofs
- Increase in lines of specifications written by developers

One surprising thing is the notion of proof which, in their case,
is the verification harness used to invoke each verified function
with appropriately constrained symbolic inputs and appropriate assertions
about the results.
This harness allows them to use the [CBMC verifier] to verify that
each function meets its contract.

The properties verified (and bugs found) are mostly low-level safety properties
(integer overflow, null pointer dereference and memory safety) together with
some functional properties.

The paper is full of stories about how they interacted with and gained the
trust of the developers and graphs showing the rate at which proofs, bugs, etc.
were created/found/etc.
{% include links.html %}

repository: alastairreid/RelatedWork

gha_language: TeX

repo_name: alastairreid/RelatedWork


text:
---
title: Setup
description: Get ready to write Go!
image: "/img/build.png"
---

1. **Install Go**

    **MacOS**

    Download the [Go installer](https://golang.org/dl/) for macOS and run it.

    **Windows**

    Download the [Go installer](https://golang.org/dl/) for Windows and run it.

    **Ubuntu**

    ```
    curl -sLO https://godeb.s3.amazonaws.com/godeb-amd64.tar.gz
    tar -xzf godeb-amd64.tar.gz
    ./godeb install
    ```

1. **Understand your GOPATH**

    The GOPATH is the location where Go looks for source code, caches packages, etc.
    You do not need to set it explicitly and can run the following comment to see where
    Go thinks your GOPATH is.

    ```console
    $ go env GOPATH
    /Users/carolynvs/go
    ```

    By default your GOPATH is in your home directory, ~/go.
    You can change it by setting the GOPATH environment variable.

    Go requires that a project's source code is located in **GOPATH/src/PACKAGE_NAME**,
    for example GOPATH/src/github.com/carolynvs/magic or GOPATH/src/golang.org/x/golint.

1. **Add GOPATH/bin to your PATH**

    When you install a Go application, it is placed under GOPATH/bin. You should
    add that location to your PATH environment variable. This allows you to easily
    install and run apps.

    On Mac and Linux, modify your shell profile, such as ~/.bashrc, ~/.bash_profile or ~/.profile, and add the following line:

    ```
    export PATH=$PATH:$(go env GOPATH)/bin
    ```

    On Windows, run the following powershell command to permanently modify your
    PATH environment variable:

    ```
    [System.Environment]::SetEnvironmentVariable('PATH', $env:Path + ";$(go env GOPATH)\bin", [System.EnvironmentVariableTarget]::User)
    ```

    After you have update your PATH environment variable, open a new shell window or tab
    so that it is loaded and ready for you to use.

1. **Verify your setup**

    Let's verify that Go is setup properly by installing a running a go application.

    ```console
    $ go get -u github.com/carolynvs/magic
    # the source is downloaded to GOPATH/src/github.com/carolynvs/magic

    $ magic
  🎵  Oh oh it's magic! 🎵
    ```

    The `go get -u` command clones the package's source code under the GOPATH in
    its proper place, or updates it if it already exists, builds the package
    and then installs it. Because we put GOPATH/bin on our PATH, the binary built
    by Go, `magic`, is available for us to use immediately.

gha_language: CSS


text:
# com.prismadoc.rest-api

## How to use

### Integrate REST API specialization in DITA-OT

The REST API specialization is shipped as a DITA-OT plugin, which needs
to be installed in DITA-OT:

> The plugin has been tested against versin 2.0 and 2.1 of DITA-OT.

1. Navigate to your DITA-OT installation directory (`/opt/DITA-OT` for example).
2. Navigate to the `plugins` directory.
3. Clone or unzip the REST-API plugin in this directory.
> You should now have a `./DITA-OT/plugins/com.prismadoc.rest-api` directory.
4. Navigate to the `DITA-OT` directory, and run
	ant -f integrator.xml

> The plugin is now installed and ready to use.

#### Build samples to test the installation

1. Within the DITA-OT directory, run:
	dita -f xhtml -i plugins/com.prismadoc.rest-api/samples/sample.dita

### Integrate REST API Specialization in Oxygen XML Editor

The REST API specialization provides templates that can be used by Oxygen
to provide a REST-API topic type in the "New Document" wizard:

1. Navigate to the Oxygen DITA-OT installation directory (`/opt/Oxygen/frameworks/dita/DITA-OT` for example).
2. Navigate to the `plugins` directory.
3. Clone or unzip the REST-API plugin in this directory.
> You should now have a `./DITA-OT/plugins/com.prismadoc.rest-api` directory.
4. Open the Oxygen XML editor, and click `Window > Show View > Transformation Scenarios`.
5. In the Transformation scenario tab, click the `Gear` icon and select `Show all`.
6. Find the `Run DITA OT Integrator` entry, and double-click it to run.
> The plugin is now installed and ready to use.

#### Using REST API Topic type in Oxygen

1. Click `File > New`.
2. Type `api` in the Filter text.
> The dialog should display the DITA "REST API" topic type.
3. Click the REST API template.
4. Start editing.


text:
# KernelOne

KernelOne is a project started by LiShiYu.com, aiming to use C# to develop an Operating System.

## Features

- **Personal**
- **Safe**
- **Easy to use**
- _Light_

[Link](url) and ![Image](src)

repository: shiyuli/KernelOne

repo_name: shiyuli/KernelOne


text:
# kitchen
Anita kitchen project
# Application Name: KITCHEN
#### This is a hotel thhat has been created for its web page that contains the type of meals that they offer in the hotel and some of the customers, 26/03/2018
#### By **The Manager of the Hotel**
## Description
This webpage it is to encourage people to visite the hotel due to its food products and drinks he=nce leading to the growth of the bussiness.
## Setup/Installation Requirements
* This is a great place
* to list setup instructions
* in a simple
* easy-to-understand

## Known Bugs
{Are there issues that have not yet been resolved that you want to let users know you know? Outline any issues that would impact use of your application. Share any workarounds that are in place. }
## Technologies Used
{Tell me about the languages and tools you used to create this app. Assume that I know you probably used HTML and CSS. If you did something really cool using only HTML, point that out.}
## Support and contact details
{Let people know what to do if they run into any issues or have questions, ideas or concerns.  Encourage them to contact you or make a contribution to the code.}
### License
*{Determine the license under which this application can be used.  See below for more details on licensing.}*
Copyright (c) {year} **{List of contributors or company name}**

repository: Nanozsaeed/kitchen

repo_name: Nanozsaeed/kitchen


text:
---
name: Bug report
about: Create a report to help us improve

---

**Before creating issue**
Put `x` marks below to validate what you've done before posting issue.

[  ] I've checked [FAQ](https://github.com/a-legotin/InstaSharper/wiki/FAQ)
[  ] I've checked [wiki page](https://github.com/a-legotin/InstaSharper/wiki)
[  ] I've examined [examples project](https://github.com/a-legotin/InstaSharper/tree/develop/InstaSharper.Examples)
[  ] I've did search [existing issues](https://github.com/a-legotin/InstaSharper/issues) for similar problems
[  ] I've understand that issue will be closed and locked if issue related to `checkpoint, challenge, feedback required` or `sentry_block` or `signup_block`- see [FAQ](https://github.com/a-legotin/InstaSharper/wiki/FAQ)

## Be warned - issue will be closed if none from above is done before posting issue.

**Describe the issue**
A clear and concise description of what the issue is.
Attach logs ([How to use logger to get logs](https://github.com/a-legotin/InstaSharper/blob/develop/InstaSharper.Examples/Program.cs)).
 Provide state of [Info](https://github.com/a-legotin/InstaSharper/blob/develop/InstaSharper/Classes/ResultInfo.cs) property when you got [IResult response](https://github.com/a-legotin/InstaSharper/blob/develop/InstaSharper/Classes/Result.cs).

**To Reproduce**
How can I reproduce the problem:
1. Attach code snippet
2. Push sample project to github and add link here.
3. What actions is causing issue.

**Expected behavior**
A clear and concise description of what you expected to happen.

**Screenshots**
If applicable, add screenshots to help explain your problem.

**Target (please complete the following information):**
 - Platform: [e.g. Windows, Linux]
 - Target framework [e.g. netstandard, net452]
 - Version [e.g. 1.4.50]

Add any other context about the problem here.

repository: a-legotin/InstaSharper

branch_name: refs/heads/develop

gha_language: C#

repo_name: a-legotin/InstaSharper


text:
# EventBetter
A Unity pubsub/messaging/event system for the lazy. Here's why:
- Raising events is alloc-free.
- No interfaces to implement, no base types to derive from.
- No initialization, no clean-up.
- No message codes.
- Coroutine/async friendly.
- One source file (everything else here is just for the test environment).
- Clear and readable.

# TL;DR:
Copy [EventBetter.cs](Assets/Plugins/EventBetter/EventBetter.cs) anywhere to your project or add `https://github.com/gwiazdorrr/EventBetter.git` in `Package Manager` (`Add package from git URL...`). The API you need to know is `EventBetter.Listen` and `EventBetter.Raise`. Done!

Example:

```cs
class TextMessage
{
    public string text;
}

class SimpleProducer : MonoBehaviour
{
    void Update()
    {
        EventBetter.Raise(new TextMessage() { text = "Hello World!" });
    }
}

class SimpleConsumer : MonoBehaviour
{
    void Awake()
    {
        EventBetter.Listen(this, (TextMessage msg) => Debug.Log(msg.text, this));
    }
}
```

There's no need to unlisten/unsubscribe from anything.

# How does it work

The first parameter in `Listen` is the listener; as long as it is alive, the handler (the second parameter) will be invoked whenever there is a `Raise` called with a matching type. If the listener gets destroyed (with `UnityObject.Destroy` or when changing scenes), the handler will not get invoked any more and all the references will get cleaned up no later than in the next LateUpdate.

It is possible thanks to `UnityEngine.Object` being the main citizen in the Unity world - it has a native representation with lifetime controlled entirely by the engine. There's no need to use `WeakReference`, `ConditionalWeakTable` and boilerplate like "unsubscribe" to avoid leaks, just keep track of the native parts.

# More examples

Maybe you like async/await more?

```cs
class SimpleConsumerAsync : MonoBehaviour
{
    async void Awake()
    {
        var msg = await EventBetter.ListenAsync<TextMessage>();
        Debug.Log(msg.text, this);
    }
}
```

Or maybe you'd rather stick with good old coroutines?
```cs
class SimpleConsumerCoro : MonoBehaviour
{
    void Awake()
    {
        StartCoroutine(Coro());
    }

    IEnumerator Coro()
    {
        var listener = EventBetter.ListenWait<TextMessage>();
        yield return listener;
        Debug.Log(listener.First.text, this);
    }
}
```

Back to the basic `Listen`, maybe you want to stop listening after the first message arrives?
```cs
EventBetter.Listen(this, (TextMessage msg) => Debug.Log(msg.text, this), once: true);
```

Or listen only if the listening script is active and enabled?
```cs
EventBetter.Listen(this, (TextMessage msg) => Debug.Log(msg.text, this), exculdeInactive: true);
```

If you are not in a `MonoBehaviour` and still want to use EventBetter, use:
```cs
IDisposable listener = EventBetter.ListenManual( (TextMessage msg) => Debug.Log(msg.text, this) );
// ...
listener.Dispose();
```

repository: gwiazdorrr/EventBetter

repo_name: gwiazdorrr/EventBetter


text:
# picto_hunt
A fun and interactive mobile app game that utilizes Google Vision API, a PostGresSQL database, and a camera phone. A user is assigned a item to find, and if the item they take a picture of matches that assignment, the user gains points.

![screenshot of page](img/home.png)

### Designed and Built by the Rooftop Collective
Peter Carmicheal, James Dansie, Julie Erlemeier, Sharina Stubbs.

### Demo of App
In September 2019, PictoHunt was built and demoed by the Rooftop Collective to an audience. You can watch the video on YouTube: https://www.youtube.com/watch?v=0ZAuaZsf5nQ

### A Code Fellows 301-Intermediate Software Development Project.
Teaching Staff: Nicholar Carignan (Lead Instructor), Lena Eivy (Assistant Instructor), Dan Le (Teaching Assistant).

### Dependencies
dotenv, ejs, express, method-override, pg, superagent, google-cloud/vision, and multer.

### Database table
```
DROP TABLE IF EXISTS scores;
CREATE TABLE scores(
 id SERIAL PRIMARY KEY,
 username VARCHAR(255),
 score BIGINT
);
```

### Daily Schedule
8/29/19, Peter
* Spike: Confirming functionality of camera use - saving newly taken pic from mobile phone to server on computer.

8/30/19, All
* Shared spike with group, then showed Nick: Approved.
* Created Trello Board, separated tasks into backend and frontend.

8/30/19, All
* Discussed topics
* Wireframes
* User Stories
* Server up and running

9/3/19, All
* Basic integration to Google Vision API, so that console output shows labels that correlate to the photo taken
* Styling and EJS started
* File Tree completed
* Camera functionality
* Logic for comparison of photos to item to find established and working

9/4/19, All
* Styling, including that for results page and nav bar.
* Google API key issues regarding .env file formatting dealt with.
* Front end gained access to results from photo analysis sent through Google Vision API.
* Significant work on asynchronous events in the backend.
* Database basic functionality achieved, with usernames added to database.

9/5/19, All
* Dealt with an issue of duplication of usernames in database
* Achieved success with updating scores in the database and sending score and high scores over to front end
* Fixed layout issues with all pages and improved usability for the user.
* Randomizer of items to find and logic regarding points achieved.
* Attempted to redeploy to Heroku with help of Cloudinary to store images, but without success.

### Roles and Individual Goals
Julie: PM and Head of Functionality
James : polish piece for portfolio, head API integration.
Sharina: Creating something functional and usable, use project week to pull together CTO
Peter: Master of Breaks, CSS, Head of design: modern and gorgeous, from scratch, paralax(different scroll speeds, animation. Want to give everyone a url so they can follow along in the audience.

James/Sharina: Back-end development
Peter: Front-end development
Julie: Mediated communication between front and back end teams, and contributed to both front-end and back-end development.

### Communication Plan
Communication Formats After Hours and On Weekend:
Slack
Trello for file sharing, To Do lists

#### Communication in the code:
* Go way overkill on the comments.
* Group Working Hours
    9am – 6pm group time.
    8am- 9:15pm be aware group member(s) may need to communicate after group time
* Strategy for Making Sure Voices are Heard (within a safe environment)
* Two daily stand-ups 9:00, 1pm
    Morning meeting - 9am start time – code review and prep for day
    After lunch – 1pm start time – review the morning, re-check in, and brainstorm as needed for afternoon.
* Check-in before leaving for the day – 5:30pm? How the morning and afternoon went

General Guidelines:
* Code review occurs at each meetup with projector.
* Be patient and kind with each other.
* Suggestion: Start sentences with “I need...”
* There are no bad ideas
* Failure will happen and it’s okay! We do this thing together.
* If we’re moving too fast:
    Person who is slower - speak up! Fast coders can slow down.
    Person who is coding fast may need to take a break and help person catch up.

Conflict Resolution Plan
* Process to resolve conflicts
* Everyone stops coding
* Return to communication ground rules.
* Try to understand the conflict with all 4 team.
* Come to a mutual agreement without taking sides (keep user stories and scope in mind).
* Find a compromise between the two intersecting viewpoints
* Discuss things and find happy place
* When conflict is resolved, mandatory 10 minute break to relax.
* How to raise concerns to members not adequately contributing
* First step: Find out why the person is falling behind, without judgement.
* Put out the invitation to share - if something else outside of project is going on, preventing the person from being present, etc.
* During briefs in morning, check in with each other with how they’re doing with a task.
* Honesty from each of us about assigned tasks.
* Ask for help when needed.
* How and when to escalate conflict when attempts are unsuccessful:
* If person is unwilling to talk through or unwilling to improve. They may be going through the motions,   but not contributing, not willing to work on issue, and not willing to reach out.
Escalation will involve reaching out to Boss and HR (Nicholas, Lena, and Ginger).

### User Stories:

"As a User I want ___ to that ___."

Katie is a 27 year old professional living in Seattle. She just moved in from Wisconsin, and she is looking for a fun thing to do on Saturday that gets her outside. She wants a game that she can play on her phone, that is easy to learn and do, but gets her to walk around the city and explore a bit. She also wants to have a game that she play for either a few minutes at a time, or for hours at a time. She hasn’t made that many friends yet, so she’s okay that she doesn’t get to play with other people. She’d be interested in a version that allows her to play with her friends later on.

As a user, I want to play a game, because I get bored sometimes.
As a user, I want a game to get me outside, because I know it’s healthy to breathe fresh air and get outside.
As a user, I want a game to play that is cute and makes me feel good about my accomplishments because that is psychologically normal.
As a user, I am looking for a game that is easy to learn, because when I play a game after a hard work day, I want it to not take too much effort.
As a user, I want to play a game that is easy to incorporate into my daily routine, so I can pull out my phone and play whenever during the day.

=========================================================

Reginald Wickers III - Mr. Wickers is an elderly gentlemen that just moved to San Diego from Devonshire England. He is trying to start a new life after the tragic loss of his wife. His good friend Arthur recommended that they should try this on Thursday instead of playing Gin Rummy. As a user Mr. Wickers is hoping to get a good amount of exercise while searching for unique items. He is hoping that this application will allow him to become more familiar with the new environment he is living in.

=========================================================

Joe is a busy local business owner who would like to drive traffic without a huge time commitment.
As a business owner he would like to drive traffic to his store.
As a business owner he would like to add items so people think of his business.
As a busy business owner he would like an easy interface that doesn’t take a huge amount of time.

=========================================================

Kristin is a 20 year old Seattlite who has been recovering from major surgery. For the last 6 months, she has had a sedentary lifestyle.  She wants a way to get exercise, see the city, and have some fun at the same time. As a user, she wants to play an enjoyable scavenger hunt game in order to walk around the city for exercise and fun.

## Resources
### Google Cloud Vision API: Node.js Client
https://cloud.google.com/nodejs/docs/reference/vision/0.22.x/
### 'Using Google Vision API with Node JS App' from YouTube
https://www.youtube.com/watch?v=BFOeM8ATWdk&t=13s
###

# Goals for the Project
## MVP
* Single player game
* no timer
* photo can be added any time… and all that happens is photo is verified.
* If you find an item and the picture of it is verified as a match...
* That high score is shown in a new view.

## Original Project Idea
* Single player game.
* Scavenger Hunt that requires the user to take picture of the item found, which is then
* *We have an array of things to look for.
* The user can choose how many things to look for, from 3 - array.length.
* A new view will show up with timer at top
* Timer adds 60 points for every item chosen - 3 images = 180 points.
* Every minute the score reduces by 1 point, so you only have 1 hour per image.
* You’ll have the list on the gameboard of the things to find IN ORDER.
* The input file thing will not appear for the next item, until the first is verified.
* When a user finds what they’re looking for, they take a photo and upload it.
* Google vision API verifies that photo.
* Then, user moves on to the next one.
* When complete, the remaining points is the user’s score.
* Score is posted to the database as a high score.
* Database - unique table for each person. Pointer to image.

## Stretch goals:
* User adds in the item types they want (into the database)
* Two or multiplayer game
* Score combines time + distance (> distance, < time)
* Every 1000 feet walked adds a Distance Bonus.
* Pings location 1/min
* Timer for each picture, as in 20 minutes per picture, that counts down
* Drop down list of themes, like pirate theme that a user can use.
* Gallery of items that a person can view.


text:
# Java

The standard approach to implement additional functionality for the Automation Framework is:
* Java code development as Custom Task Template plugin, see [*Custom Task Template Java SDK*](https://blogs.sap.com/2017/12/08/how-to-create-a-custom-task-template-for-bi-automation-framework)
* copy the plugin to your BI platform installation
* deploy the template definition as infoobject to your CMS system database

repository: SAP-samples/boe-custom-task-template

repo_name: SAP-samples/boe-custom-task-template


text:
## macOS Virtual Machines

It is possible to run macOS Virtual Machines (like how one can run [Linux containers](linux.md)) on the macOS Community Cluster.
Use `macos_instance` in your `.cirrus.yml` files:

```yaml
macos_instance:
  image: monterey-base

task:
  script: echo "Hello World from macOS!"
```

### List of available images

#### macOS Monterey

* `monterey-base` - vanilla macOS with Brew and Command Line Tools pre-installed.
* `monterey-xcode-NN` - based off `monterey-base` with Xcode NN and couple other packages pre-installed:
  `cocoapods`, `fastlane`, `rake` and `xctool`. [Flutter](https://flutter.dev/) and Android SDK/NDK are also pre-installed.

List of available Xcode versions:

* `monterey-xcode-13.1`
* `monterey-xcode-13.2`
* `monterey-xcode-13.3`

Note that there is a `monterey-xcode` alias available to always reference to the latest stable `monterey-xcode-NN` image.

#### macOS Big Sur

* `big-sur-base` - vanilla macOS with Brew and Command Line Tools pre-installed.
* `big-sur-xcode-NN` - based off `big-sur-base` with Xcode NN and couple other packages pre-installed:
  `cocoapods`, `fastlane`, `rake` and `xctool`. [Flutter](https://flutter.dev/) and Android SDK/NDK are also pre-installed.

List of available Xcode versions:

* `big-sur-xcode-12.3`
* `big-sur-xcode-12.4`
* `big-sur-xcode-12.5`
* `big-sur-xcode-13`

Note that there is a `big-sur-xcode` alias available to always reference to the latest stable `big-sur-xcode-NN` image.

#### macOS Catalina (deprecated)

* `catalina-base` - vanilla macOS with Brew and Command Line Tools pre-installed.
* `catalina-xcode-NN` - based off `catalina-base` with Xcode NN and couple other packages pre-installed:
  `cocoapods`, `fastlane`, `rake` and `xctool`. **Starting from Xcode 12.1 [Flutter](https://flutter.dev/) and Android SDK/NDK are also pre-installed.**
* `catalina-xcode-NN-flutter` (**deprecated** since Xcode 12.1) - based of `catalina-xcode-NN` with pre-installed [Flutter](https://flutter.dev/) and Android SDK/NDK.

List of available Xcode versions:

* `catalina-xcode-11.3.1`
* `catalina-xcode-11.4.1`
* `catalina-xcode-11.5`
* `catalina-xcode-11.6`
* `catalina-xcode-12.0`
* `catalina-xcode-12.1`
* `catalina-xcode-12.2`

Note that there are a couple of aliases available for images:

* `catalina-xcode` - point to the latest stable `catalina-xcode-NN` image.
* `catalina-flutter` - point to the latest image with.

### How images are built

Please refer to the [`osx-images`](https://github.com/cirruslabs/osx-images) repository on how the images were built and
don't hesitate to [create issues](https://github.com/cirruslabs/osx-images/issues) if current images are missing something.

!!! info "Underlying Technology"
    Under the hood Cirrus CI is using Cirrus CI's own [Persistent Workers](persistent-workers.md). See more details in
    out [blog post](https://medium.com/cirruslabs/new-macos-task-execution-architecture-for-cirrus-ci-604250627c94).

repository: wezm/cirrus-ci-docs

repo_name: wezm/cirrus-ci-docs


text:
## ROLE: peers
This role creates the helm value file for peers of organisations and write couch db credentials to the vault.

### Tasks
(Variables with * are fetched from the playbook which is calling this role)
#### 1. Write the couchdb credentials to Vault
This task writes the couchdb credentials for each organizatiosn to the vault
##### Input Variables
    *VAULT_ADDR: Contains Vault URL, Fetched using 'vault.' from network.yaml
    *VAULT_TOKEN: Contains Vault Token, Fetched using 'vault.' from network.yaml
    *namespace: The namespace of resource
**shell**: It writes the  couchdb credentials for each organizatiosn to the vault.

#### 2. Create Value files for Organization Peers
This task is the nested task for main.yaml which helps to iterate over all peers.
##### Input Variables

    *name: Name of the item
    *peer_name: The name of the peer
    *peer_ns: Namespace of the peer
    *component_name: "The name of the component"
    type: "value_peer"
**include_role**: It includes the name of intermediatory role which is required for creating the helm value file, here helm_component
**loop**: loops over peers list fetched using *{{ component_services.peers }}* from network yaml
**loop_control**: Specify conditions for controlling the loop.

    loop_var: loop variable used for iterating the loop.

#### 3. Git Push
This task pushes the above generated value files to git repo.
##### Input Variables
    GIT_DIR: "The path of directory which needs to be pushed"
    GIT_RESET_PATH: "This variable contains the path which wont be synced with the git repo"
    gitops: *item.gitops* from network.yaml
    msg: "Message for git commit"

**include_role**: It includes the name of intermediatory role which is required for creating the vault auth value file.

#### 4. Check peer pod is up
This tasks check if the namespace is already created or not.
##### Input Variables

    kind: This defines the kind of Kubernetes resource
    *name: Name of the component
    *namespace: Namespace of the component
    *kubeconfig: The config file of the cluster
    *context: This refer to the required kubernetes cluster context
    *org_query: Query to get peer names for organisations
    *peer_name: Name of the peer

**include_role**: It includes the name of intermediatory role which is required for creating the vault auth value file.


text:
# Babies and bathwater

1. Brains → physical connectomes
2. Neurons → skeletons
3. Synapses → points
4. Connectivity → graph

notes:

A great deal of nanoscale connectomic analysis has been based on some or
all of these simplifications.

1. Firstly, we tend to focus on connections we can see in the EM.
This may leave out a wealth of extrasynaptic interactions,
especially neuromodulatory transmitters, which can have profound effects
on a network's behaviour.
2. To speed up the conversion of raw image data to morphological
approximations, neurons are often collapsed down to tree structures
which capture their branching nature and gross morphology, but not
internal features.
3. Again to accelerate reconstruction of circuits, synaptic terminals
 are usually reduced from rich 3D structures into a single point.
4. And finally, those points and trees are collapsed down further into
a connectivity matrix: every neuron is treated as a point, and its
entire suite of synapses with any given partner as a single value.

All of these dimensionality reductions have value: often understanding
can only really be gained through such incisive models.

Furthermore, connectomes of the scale we have access to today would not
have been possible without these measures.

However, efforts must be made to ensure that the information we are
throwing out is not in itself hiding valuable insights into circuit
function.


text:
cmuphyscomp/pi_puppet
=======================

This package contains administration configuration scripts for the Raspberry Pi
microcontroller systems for the Physical Computing Lab in the IDeATe program at
Carnegie Mellon University.

We are using the Raspberry Pi as a Linux platform for the Fall 2014 iteration of
Introduction to Physical Computing, running the Raspbian distribution. The
scripts in this package use the 'puppet' administration system to customize the
stock configuration for use on the Carnegie Mellon campus and with the course
curriculum.

This package is cloned into the following path:
/etc/puppet/modules/pi_puppet

Once installed, this package provides scripts for a student to initiate a
software update.  During the update, this package is updated from github and
puppet is run to apply any required system changes.

References
----------

  * http://www.raspberrypi.org/help/quick-start-guide/
  * http://www.raspberrypi.org/downloads/
  * http://physcomp.org
  * https://github.com/cmuphyscomp/pi_puppet
  * http://www.cmu.edu/ideate/
  * http://puppetlabs.com/puppet/puppet-open-source

Basic Puppet Installation
-------------------------

This package can be installed on a stock Raspbian distribution as follows.  Note
that the final image can be sized to a 4Gb card for distribution, but the
intervening size may be larger unless performed incrementally, with apt-get
clean used to remove downloaded packages in stages.  An 8Gb card is recommended.

First, the network connection on the Raspberry Pi needs to manually configured
to the point where the public internet is accessible.  A convenient option is to
connect the Ethernet port to a laptop with Internet Sharing enabled, since that
way the laptop can also be used as console.

The following assumes that either the network connection or a monitor and
keyboard have been set up to the point where the Raspberry Pi command line is
available. The default Raspbian login is username 'pi', password 'raspberry'.
For hints, the quick start guide listed above may be helpful.

Make sure that puppet is installed:

    $ sudo apt-get update
    $ sudo apt-get upgrade
    $ sudo apt-get install puppet

Clone this package from github into a new folder:

    $ cd /etc/puppet/modules
    $ sudo git clone https://github.com/cmuphyscomp/pi_puppet

Run the update script once in-place for initial configuration:

    $ sudo python /etc/puppet/modules/pi_puppet/files/bin/pi_update

After the initial configuration, full updates can be performed as follows:

    $ sudo pi_update

The pi_update script has additional options to run partial updates; to see all options, run:

    $ pi_update --help

Full Courseware Installation
----------------------------

There are many packages for the Pi which need to be installed directly from
sources, so there are other components which are distributed for the course as
packages within /opt.  These are normally given to students as part of a full
Raspbian filesystem image.  The configuration and installation of these packages
may eventually move to pi_puppet, but for now these are maintained partly by
hand.

Three rather hairy and fragile scripts are installed by the pi_puppet package in
/usr/local/bin to assist in rebuilding these trees from scratch.  These are
likely to need adjustment, because they are rarely run and depend on many
outside resources which may have changed in the interim:

    setup_cmuphyscomp
    setup_openframeworks
    setup_puredata

These will likely only run on an 8Gb or larger filesystem.


text:
DOCUMENTATION

Vidur Singh
Harikrishnan

What is the project?
Our project is based on the book 'Pride and Prejudice'. We started off with the basic stuff like word and letter frequency count. Then we created a graph that shows the comparision between the estimated occurence of a letter in english language and the actual occurence in the book (useful in cryptography). We also fitted in a code to deduct palindromes. The program is also able to handle input output errors while opening a file.

What programming language?
Python 2.7.9

What license?
MIT License

Copyright (c) 2017 harix1606

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all

copies or substantial portions of the Software.

Who wrote the code?

Harikrishnan wrote the code for word and letter frequency with the help of Vidur Singh. Vidur Singh wrote the code for the graphs, palindromes and error handling.

Dependencies:
matplotlib.pyplot as plt
numpy as np
operator
String
Operator


text:
# cplace-to-collection

Converts as XML exported cPlace data into collections based on Markdown files with YAML frontmatter.

![](https://nodei.co/npm/cplace-to-collection.png?downloads=true&stars=true)

![](https://david-dm.org/nihilor/cplace-to-collection.png)

# How to install?

Clone this repository or use npm to install the package.

```
npm install cplace-to-collection
```

# How to use?

Import the module, provide an XML export of cPlace and define an export destination.

```javascript
const cplace = require('cplace-to-collection');

cplace('cplaceexport.xml', 'export', {
    relink: true,
    collectionHook: function (collections) {
        console.log('Collections found: ', Object.keys(collections));
        return collections;
    }
});
```

It's possible to relink all internal links. Just set `relink: true`. This will replace all id based links to human- and SEO-friendly URLs.

If you want to perform changes on the collection structure, just provide a callback function as `collectionHook`. Return the restructured collection.

# What are collections?

A *collection* is a directory containing files that describe things of the same type. In most cases, these collections consists of one or more Markdown files with YAML frontmatter for structured data.

# What is cPlace?

cPlace is a solution for project management. For more detailed infomration visit [cPlace](https://www.collaboration-factory.de/de/home).

# License

Copyright (c) 2018 Mark Lubkowitz (http://mlu.io/)

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

repository: nihilor/cplace-to-collection

repo_name: nihilor/cplace-to-collection


text:
# 2. Chronicle Map Data Store Design Overview

## Logic

**Each Chronicle Map is split into N *completely independent*, ordered segments**.
The number of segments is chosen during the Chronicle Map creation and is never changed. Each
segment has an associated 3-level lock (the *read*, *update* and *write* levels). Typical steps of
performing a query to a Chronicle Map:

 1. Compute the hash code of the queried key. Hash code length is 64 bits.
 2. Identify the segment that should hold the key, based on the hash code.
 3. Acquire the segment lock on the needed level.
 4. Search for the entry with the queried key in the segment.
 5. Perform the actual query operation on the entry, if the entry is found (e. g. read the value,
 update the value, etc.), or insert the entry, if the queried key was absent in the segment, and
 insertion of a previously absent entry is implied by the logic of the query being performed.
 6. Release the segment lock.

For multi-key queries,

 1. Identify all the segments in which the involved keys should be held.
 2. Acquire the locks of all the involved segments. Within each involved Chronicle Map store,
 acquire the segment locks in the order of their segments.

 > Acquiring segment locks always in the same order is needed to avoid dead-locks, e. g. when the
 > first thread acquires the lock of the segment #1 and then tries to acquire the lock of the
 > segment #2, and the second thread does the opposite: locks the segment #2, then tries to lock the
 > segment #1.

 3. Perform the query operations.
 4. Release the locks of all the involved segments in the reverse order.

Bulk operations (iterations, background tasks) visit each segment once in any order. For each
segment, they acquire the segment lock, then visit each entry stored in the segment, then release
the segment lock.

### Lock levels

The **read level** is shared, several threads (across OS processes) could hold the segment lock on
the read level at the same time. This level is used for read queries on a single or multiple keys,
like simple value reading by the key. This level couldn't be upgraded to the update or write level.

> The read level couldn't upgrade to the higher levels, because this is dead-lock prone. Two threads
> could acquire the same lock on the read level, then both try to upgrade to the write level - and
> blocked by each other. (Upgrading to the write level through the update level doesn't resolve
> this issue, too.)

The **update level** is partially exclusive: a thread could hold the segment lock on the update
level while some other threads (across OS processes) are holding the same lock on the read level,
but not the update or write level.

This level is used for "typically read" types of queries, which occasionally should be able to write
to the data store, hence need to upgrade to the write level without releasing the lock, for example,
reading value by the key, if the entry is already present in the Chronicle Map, or storing a new
value, if the entry is absent. Also, bulk operations acquire segment locks at least on the update
level, even if they never perform writes.

A segment lock acquired on the update level could be upgraded to the write level.

The **write level** is totally exclusive: when a thread holds the segment lock on the write level,
no other thread (across OS processes) could hold the same lock on any level. The write level is used
for write queries.

## [Lock implementation](3_2-lock-structure.md)

Each lock is represented by two 32-bit words in the Chronicle Map memory. *Count word* holds the
numbers of threads holding the lock at the moment on the read, update and write levels. *Wait word*
holds the number of pending threads, trying to acquire the lock on the write level, at the moment.
These two words are updated only via compare-and-swap operations. In addition to the checks
essential for keeping exclusiveness invariants, described in the previous section, when a thread
tries to acquire the lock on the read level, it checks there are no threads pending for write
access, to prevent starvation of the latter.

As Chronicle Map is designed for inter-process communication, and it doesn't use locks provided by
an operation system, Chronicle Map doesn't implement queues of threads, waiting for lock acquisition
and conditional wake-ups. Threads acquire locks in a spin loop, yielding and/or sleeping after a
certain threshold numbers of unsuccessful attempts.

> Chronicle Map implementations specialized for single-process access to stores may implement
> some kind of thread queues, wake-ups and cooperative scheduling on the runtime level; certain lock
> acquisition strategy is out of scope of the Chronicle Map data store specification.

## The segment data structure

Under normal conditions, a segment is represented by a single *tier*. (*Tier* and *segment tier* are
interchangeable terms in this specification.)

### Segment tier

A segment tier basically consists of two parts:

 1. **Hash lookup**, a flat, power-of-two sized open addressing hash table with collision resolution
 via linear probing, in which the role of keys is played by parts of the Chronicle Map's key hash
 codes (different part of the hash code, from what is used for choosing the segment), values in this
 hash table are allocation identifiers within this segment tier's *entry space*.

 > In the reference Chronicle Map implementation hash lookup's table size is chosen in order to keep
 > table load factor between 0.33 and 0.66.

 2. The **entry space** is the area to allocate blocks of memory to store the actual Chronicle Map's
 entries (key and value bytes sequences), along with some metadata.

 > The specific memory allocation algorithm may vary, depending on the characteristics of the keys
 > and values stored in the specific Chronicle Map, the choice in the context of the time-space
 > tradeoff, etc. One important property that the allocator should obey, is *not* requiring to touch
 > all it's memory up front, for example zeroing out or splitting the memory in blocks, going though
 > all of them and creating an intrusive linked list. Touching entry space memory on demand takes
 > advantage from the Linux memory mapping feature - lazy page allocation. This, in turn, allows to
 > overcommit memory for segment tier's entry spaces without sacrificing actual memory usage much
 > (because hash lookup slots, that should be overcommitted too, are relatively small). This,
 > in turn, mitigates variance of segments' filling rates and makes slow *tier chaining* (see below)
 > very unlikely.

 > The reference Chronicle Map implementation uses the following allocation algorithm: it is
 > initialized with the *chunk size* depending of the configured properties of keys and values,
 > which are going to be stored in the Chronicle Map. The entry space is virtually split into M
 > chunks and a bit set, where each bit corresponds to the single chunk of the same index.
 > The allocation procedure computes the number of chunks that cover the requested allocation size
 > and finds that number of continuous zero bits in the bit set. The allocation identifier is the
 > index of the first chunk of the allocated block.

The hash lookup slots' size is either 4 or 8 bytes. Allocation identifiers use the minimum required
bits to identify themselves within the entry space, the rest bits of hash lookup slots are used to
store bits of the Chronicle Map's key hash codes, to minimize full collisions on the hash lookup
level.

> Hash lookup slots are disallowed to be of any integral byte size from 3 to 8 bytes, despite it
> would be more agile than limiting to 4 or 8 bytes, because cross cache line reads and writes on
> x86 are inherently not atomic, that makes unsafe to perform some write operations with a segment
> locked on the update level. Also, unaligned slots could be corrupted if the writing process is
> interrupted unconditionally, or the operating system fails.

### Tier chaining

If a segment tier is filled up, i. e. on some entry insertion request entry space fails to allocate
a memory block sufficient to place the new entry, *a whole new segment tier is allocated and chained
after the previous tier.* All tiers, either first in their segments or chained, are identical.

> A segment with one or several chained tiers might be much slower for key search, than a "normal"
> segment of a single tier. Tier chaining is an *exceptional* mechanism for dealing with segment
> overflow. Chronicle Map shows it's efficiency properties when a very little fraction or none of
> it's segments has chained tiers. Chronicle Map should be configured accordingly.

### The procedure of searching for a key within a segment

Extract the part of the queried key's hash code, that serves as a key in hash lookup tables of
 the tiers.

[For each segment tier in the chain, the first tier initially]

Search for a slot with the extracted hash lookup key in the tier's hash lookup, using
  standard search algorithm for hash tables with open addressing and collision resolution via linear
  probing.

If such slot is found, go to the entry location within the tier's entry space using the value
   in the found hash lookup slot. Compare the queried key with the key, stored in the entry
   location, byte-by-byte.

If the keys are identical, the entry for the queried key within the segment is found, exit
    the procedure.

If the keys are not identical (because of a full collision of parts of their hash codes for
    storing in hash lookup tables), continue the search in the current tier's hash lookup table
    (step #2), without resetting the hash lookup slot index.

If such slot is not found, and there are no more chained tiers, the entry for the queried key
   within the segment is not found, exit the procedure.

If there is a chained tier, go to it and start searching again from step #2.

repository: OpenHFT/Chronicle-Map

branch_name: refs/heads/ea

gha_language: Java

repo_name: OpenHFT/Chronicle-Map