text:
## Predicting Suicidal Intent in Reddit Users Experiencing Mental Illnesses

### About
This is the repository for my final capstone project during my Masters of Science in Data Science at Vanderbilt University.

The aim of this project is to create a novel predictive modeling framework that models the transition of Reddit users experiencing mental health problems into experiencing suicidal ideation. Through this, a more holistic understanding can be gleaned of the underlying factors governing the rise of suicidal ideation, and how the occurrence of such factors could be reduced effectively. This will be done by developing a sequential representation of the user’s text activity on the platform combined with where they are posting. This is done through a sequential neural network model known as a Time-LSTM.

### Data Description

A list of 57 subreddits were identified based on commonly attributed causes or risk factors of sucide. These risk factors could be mental health related (internal) or linked to external events or circumstances. These will be referred to as MH subreddits (because a majority of them are linked to mental health conditions).

| **Internal (N=40)**             | **External (N=17)**               |
|-----------------------------|-------------------------------|
| Depression (N=6)            | Turbulent Relationships (N=7) |
| Bipolar Disorder (N=2)      | Turbulent Upbringing (N=5)    |
| Personality Disorders (N=1) | Traumatic Events (N=5)        |
| PTSD (N=2)                  |                               |
| OCD (N=1)                   |                               |
| Addiction (N=12)            |                               |
| Schizophrenia (N=1)         |                               |
| Eating Disorders (N=5)      |                               |
| Self Harm (N=2)             |                               |
| Loneliness (N=2)            |                               |

To extract the target users (suicidal users), the following steps were taken.
1. Get all users that posted on r/SuicideWatch from 2018 to 2021
2. Remove moderator posts
3. Remove deleted posts
4. Retrieve all posts and comments of remaining users and only keep them if:
    - Posted on MH subreddits within the last 365 days on more than two occasions
    - Account age was more than 3 months (no new accounts)

All posts before their first post on r/SuicideWatch were deleted since the predictions are to be made on activity leading up to them eventually becoming suicidal.

The control group was extracted from users that posted in the MH subreddits in 2017 but never posted in r/SuicideWatch after that. This was done to ensure they had three years to potentially post in r/SuicideWatch. To maintain homogeneity, avoid bias and make sure that we model what causes those at risk to actually become suicidal,  the same distribution of people in MH subreddits is maintained in the control group. That means if we had 1000 target users with activity in /r/depression, the same number of users must exist in our control group.

 Two target subgroups were identified, where the target was given a value of 1, and one where the target was 0. The former is the ‘suicidal’ sub-group, which includes users having a history of posting in MH subreddits and posted in the years 2018 - 2021. The latter is the ‘non-suicidal’ sub-group, which includes users having a history of posting in MH subreddits in 2017, but who never posted in /r/SuicideWatch following that. For each user, all of their posts and comments were extracted, along with other metadata such as where those posts and comments were made (subreddit), the number of upvotes, downvotes as well as the number of responses.

### Model Architecture
![image](https://user-images.githubusercontent.com/17579534/128061977-761798aa-62e2-4aa8-86e7-3108e07b2935.png)

You can reach out to me on<EMAIL_ADDRESS>to request access to data and project details.

Project Organization
------------

    ├── LICENSE
    ├── Makefile
    ├── README.md
    │
    ├── models                                              <- 4 trained models ready to be used as detailed in the final_evaluation
    ├── notebooks
    │   ├── 01_target_scraping.ipynb                        <- notebook detailing how the target cohort was scraped
    │   ├── 02_target_metadata_analysis.ipynb               <- notebook detailing metadata analysis performed on the target cohort.
    │   ├── 03_control_scraping_metadata_analysis.ipynb     <- notebook detailing metadata analysis and scraping the control group
    │   ├── 04_dataset_development.ipynb                    <- notebook detailing development of the dataset as well filtering required for modeling
    │   ├── 05_user_activity_groups.ipynb                   <- notebook detailing development of different user groups
    │   ├── 06_baseline models.ipynb                        <- notebook detailing development of baseline text classification models.
    │   ├── 07_NN_models.ipynb                              <- notebook detailing training of neural network models
    │   ├── 08_SUIBERT_classifier.ipynb                     <- notebook detailing training of BERT text classification model to detect suicidal language
    │   └── 09_HITOPBERT_classifier.ipynb                   <- notebook detailing training of BERT text classification model to diagnose psychological illness.
    |
    ├── final_model_evaluation.ipynb                        <- Final evaluation of all models on the testing dataset.
    ├── dataset.py                                          <- Torch dataset development.
    ├── train_eval.py                                       <- training and evaluation functions along with loss function defined
    └── model.py                                            <- Neural Network modeling architecture used for this project.

--------


text:
Checks for redundant `return` expressions.

# Examples

```ruby
# These bad cases should be extended to handle methods whose body is
# if/else or a case expression with a default branch.

# bad
def test
  return something
end

# bad
def test
  one
  two
  three
  return something
end

# good
def test
  return something if something_else
end

# good
def test
  if x
  elsif y
  else
  end
end# bad
def test
  return x, y
end# good
def test
  return x, y
end
```

[Source](http://www.rubydoc.info/gems/rubocop/RuboCop/Cop/Style/RedundantReturn)

repository: codacy/codacy-rubocop

branch_name: refs/heads/master

extension: md

gha_language: Ruby

gha_license_id: NOASSERTION

license_type: permissive

repo_name: codacy/codacy-rubocop


text:
---
title: "xxx"
keywords:
sidebar: overview_sidebar
toc: false
permalink: xxx.html
summary: false
---

#### Status: ![Live](images/icons/api_live.png)

## Description

## Resource URL

Base URL (Dev1): https://api.dev1.ers.ncrs.nhs.uk/ers-api

| Method       | URL | Authentication |
| -------------| --- | ---------------- |
| POST | /STU3/v1/ReferralRequest/{ubrn}/$ers.rejectReferral | Session Token [(Details)](develop_business_flow_bf001.html) |

## Operation Definition
- [eRS-RejectReferral-Operation-1](https://fhir.nhs.uk/STU3/OperationDefinition/eRS-RejectReferral-Operation-1)

## Prerequisite Conditions
-
-
-

# INPUT

## Request Operation: Header

| Field Name | Value |
| ---------- | ----- |
| XAPI_ASID | The "Accredited System ID" issued to the third party |
| HTTP_X_SESSION_KEY | The session key generated by the [Authentication and Authorisation APIs](/develop_business_flow_bf001.html)  |
| Content-Type | `*/*`, `application/fhir+json` |
| If-Match | W/"`n`" |

Note: `n` is the VersionId of the Referral and this can be retrieved by fetching the Referral details.
It must be the ID of the latest version of the referral in e-RS.

## Request Operation: Parameters

| Name | Cardinality | Type | Description |
| ---- | ----------- | ---- | ----------- |

### Example URI
```http
```

### Example Request Header
```http
```

### Example Request Body
##### Note: These examples may contain environment specific URLs and test data, these should be replaced with appropriate values for your implementation.

- [Filename](downloads/json/[filename])

# OUTPUT
## Response: Success
If successful, ...

### Example Response Header
```http
```

### Example Response Body
##### Note: These examples may contain environment specific URLs and test data, these should be replaced with appropriate values for your implementation.

- [Filename](downloads/json/[filename])

## Response: Failure
If an error occurs, the relating HTTP status code will be returned in the header.

Where status code 422 (Unprocessable Entity) is returned then an eRS-OperationOutcome-1 will be included in the body, as detailed below:

| OutcomeKey | Description | Suggested Diagnostic |
| ---------- | ----------- | -------------------- |

repository: nhsconnect/digital-referrals

branch_name: refs/heads/gh-pages

gha_language: CSS

repo_name: nhsconnect/digital-referrals


text:
# jadebootstrap-seed
[JADE-Bootstrap](http://rajasegar.github.io/JADE-Bootstrap/) boilerplate project for [NodeJS](http://nodejs.org/) using [Express](http://expressjs.com) middleware

## Quick Start

  The quickest way to get started with this boilerplate is to install the packages first and use the npm script to start the application as shown below:

  Install the packages.

```bash
$ git clone https://github.com/rajasegar/jadebootstrap-seed.git
$ cd jadebootstrap-seed
$ npm install
$ npm start
```
## Features

  * Bootstrap set as the default UI framework
  * Pug set as the default Template engine
  * Focus on high performance
  * Super-speed development using Pug mixins

license: MIT

repository: pug-bootstrap/jadebootstrap-seed

repo_name: pug-bootstrap/jadebootstrap-seed


text:
---
date: "2021-04-09T23:45:00.00Z"
published: true
description: By default VSCode doesn't include this keybinding. Here's how you add it.
slug: git-cheatsheet
tags:
  - vscode
  - howto
time_to_read: 1
title: Switching between VSCode terminals using hotkeys
type: post
---

When I code I prefer to keep my hands on the keyboard as much as possible. For me, this keeps me more focused on the task at hand. Switching to the mouse is something try to I reserve for interacting with browsers.

By default [VSCode](https://code.visualstudio.com/) doesn't include the keybinding necessary to switch terminals via the keyboard. You are forced to use the mouse, which disrupts my flow.

Here's how you add terminal switching keybindings in VSCode:

# Step 1

Use `ctrl+p` (`cmd+p` on the Mac) and type `keybindings.json`. Select the file from the drop downlist. This will open a file that looks like this:

```json
// Place your key bindings in this file to
// override the defaults
[]
```

# Step 2

Replace the contents of `keybindings.json` with this for Windows or Linux:

```json
// Place your key bindings in this file to
// override the defaults
[
  {
    "key": "ctrl+down",
    "command": "workbench.action.terminal.focusNext",
    "when": "terminalFocus"
  },
  {
    "key": "ctrl+up",
    "command": "workbench.action.terminal.focusPrevious",
    "when": "terminalFocus"
  }
]
```

Or this when using the Mac:

```json
// Place your key bindings in this file to
// override the defaults
[
  {
    "key": "cmd+down",
    "command": "workbench.action.terminal.focusNext",
    "when": "terminalFocus"
  },
  {
    "key": "cmd+up",
    "command": "workbench.action.terminal.focusPrevious",
    "when": "terminalFocus"
  }
]
```

Now you can use the keyboard to change terminals in VS Code.

gha_language: Vue


text:
---
draft: false
title: "OpenAPI Mocking 101"
date: 2022-02-23
publishdate: 2022-02-23
lastmod: 2022-02-23
menu:
  docs:
    parent: guides
    name: OpenAPI Mocking 101
    weight: 05
toc: true
weight: 30 #rem
---

## Overview

This guide is a step-by-step walkthrough on how to use [OpenAPI specification](https://www.openapis.org/) to specify your mocks for your API. This guide is a practical complement to [OpenAPI usage for Microcks](../../using/openapi/) that brings more details on theory and conventions being used.

In this guide, we will go through a practical example based on the famous PetStore API. We'll build the reference [petstore-1.0.0-openapi.yaml](../petstore-1.0.0-openapi.yaml) file by increment, highlighting the details to get you starting with mocking OpenAPI on Microcks.

Let's start!

## 1. Setup Microcks and OpenAPI skeleton

First mandatory step is obviously to setup Microcks 😉. For OpenAPI usage, we don't need any particular setup and the `docker-compose` way of deploying Microcks as exposed in [Getting Started](../../getting-started) is very well suited. Following the guide, you should have a Microcks running instance on `http://localhost:8080`.

Now let start with the skeleton of our OpenAPI contract for the PetStore API. We'll start with general information on this API and with definition of two different datatypes:

* `NewPet` is the data structure that will be used to register a new pet in our store - it just mandates a `name` attribute,
* `Pet` is an extension of this structure for already registered pets. Once registered a pet has an additional `id` attribute.

This is over-simplistic but enough to help demonstrate how to do things. Here's the YAML representing this part of the OpenAPI contract:

```yaml
openapi: 3.0.2
info:
  title: Petstore API
  version: 1.0.0
  description: |-
    A sample API that uses a petstore as an example to demonstrate features
    in the OpenAPI 3.0 specification and Microcks
  contact:
    name: Microcks Team
    url: 'https://microcks.io'
  license:
    name: Apache 2.0
    url: 'https://www.apache.org/licenses/LICENSE-2.0.html'
components:
  schemas:
    Pet:
      allOf:
        - $ref: '#/components/schemas/NewPet'
        - properties:
            id:
              format: int64
              type: integer
          required:
            - id
    NewPet:
      properties:
        name:
          type: string
      required:
        - name
```

## 2. Basic operation in OpenAPI

Let's now define a first operation to our API. Imagine that you want to give a user the ability to consult her list of favorite pets in the store. Hence, we'll define a `/my/pets` path in our API with a `GET` operation. This operation will just return an array of `Pet` objects.

This is very common situation in OpenAPI design but to be able to mock such operation we're going to add OpenAPI [Example Objects](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#exampleObject). As this operation does not expect anything as input but just produces a result, we'll add an example called `my_pets`in the response content. Just paste the content below at the end of above skeleton:

```yaml
paths:
  /my/pets:
    get:
      responses:
        "200":
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/Pet'
              examples:
                my_pets:
                  value:
                    - id: 1
                      name: Zaza
                    - id: 2
                      name: Tigress
                    - id: 3
                      name: Maki
                    - id: 4
                      name: Toufik
```

As this operation is dealing with `application/json` content type, we can express examples as JSON or as YAML objects. Examples are really helpful when carefully chosen to represent real-life samples very close to actual functional situation. Here I've put my real cats 🐈 names.

As soon as your contract contains examples, you can import it into Microcks and it will use examples to produce real life simulation of your API. Use the [Direct Upload](../../using/importers/#direct-upload) method to inject your OpenAPI file and you'll get the following result:

![openapi-101-basic](/images/guides/openapi-101-basic.png)

> You may have noticed in above screenshot that dispatching properties are empty for now. This is normal as we're on a basic operation with no routing logic. We'll talk about dispatchers in next section.

Microcks has found `my_pets` as a valid sample to build a simulation upon. A mock URL has been made available and you can use it to test the API operation as demonstrated below with a `curl` command:

```shell
$ curl http://localhost:8080/rest/Petstore+API/1.0.0/my/pets -s | jq
[
  {
    "id": 1,
    "name": "Zaza"
  },
  {
    "id": 2,
    "name": "Tigress"
  },
  {
    "id": 3,
    "name": "Maki"
  },
  {
    "id": 4,
    "name": "Toufik"
  }
]
```

This is your first OpenAPI mock 🎉 Nice achievement!

## 3. Using query parameters in OpenAPI

Let's make things a bit more spicy by adding query parameters. Now assume you want to provide a simple searching operation that allows to retrieve all pets in store using simple filter. You'll end up adding a new `GET` operation in your API, bound to the `/pets` path. Of course, you'll have to define the `filter` parameter that will be present in query so that users will query `/pets?filter=zoe` to get all the pets having `zoe` in name.

So we'll add a new path snippet in the `paths` section of our OpenAPI document like below. This snippet is also integrating [Example Objects](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#exampleObject) for both the query parameter and the response.

```yaml
paths:
  [...]
  /pets:
    get:
      parameters:
        - name: filter
          in: query
          schema:
            type: string
          examples:
            k_pets:
              value: k
      responses:
        "200":
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/Pet'
              examples:
                k_pets:
                  value:
                    - id: 3
                      name: Maki
                    - id: 4
                      name: Toufik
```

The important things to notice here is the logic behind example naming. In fact, OpenAPI specification allows to specify example fragments for each and every piece of a contract. To be tied together by Microcks, related parts must have the same key. Here the key is `k_pets` that allows to link `filter=k` with the associated response containing the 2 cats having a `k` in their name. When imported into Microcks, you should have following result:

![openapi-101-query](/images/guides/openapi-101-query.png)

What about dispatching properties we mentioned earlier? You can see that they now having values. Because of the presence of parameter in your operation, Microcks has inferred a routing logic named `URI_PARAMS` that will be based on matching rule on `filter` parameter. Let's try the mock URL issuing a simple command:

```shell
$ curl http://localhost:8080/rest/Petstore+API/1.0.0/pets\?filter\=k -s | jq
[
  {
    "id": 3,
    "name": "Maki"
  },
  {
    "id": 4,
    "name": "Toufik"
  }
]
```

> As an exercice to validate your understanding, just add a new `i_pets` sample so that when user specify a filter with value `i`, the 3 correct cats are returned (Tigresse, Maki and Toufik)

In this section, we introduced the naming convention that allows tying together elements that allow to define matching request and response elements. This is the foundation mechanism for defining comprehensive examples illustrating functional expectations of your API. Depending on tied elements, Microcks is deducing a dispatching or routing logic depending on incoming request elements. `Dispatcher` is a powerful concept in Microcks that can be [fully customized](../../using/advanced/dispatching/#the-need-for-custom-dispatching-rules) if inferred ones are not enough for your needs.

## 4. Using path parameters in OpenAPI

Another very common construction in OpenAPI is the usage of path parameters. Such parameters are directly integrated into API request URL path so that you have the ability to access identified resources. Typically with the Petstore API, you'd want to allow consumers to use directly the `/pets/1` to access the cat with identifier `1`.

Let's add such a new operation into the API by adding the following path snippet into the `paths` section. Once again, we're integrating [Example Objects](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#exampleObject) for both the path parameter and the response.

```yaml
paths:
  [...]
  /pets/{id}:
    get:
      parameters:
        - name: id
          in: path
          schema:
            type: string
          examples:
            pet_1:
              value: '1'
            pet_2:
              value: '2'
      responses:
        "200":
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Pet'
              examples:
                pet_1:
                  value:
                    id: 1
                    name: Zaza
                pet_2:
                  value:
                    id: 2
                    name: Tigresse
```

You can notice in this snippet that we directly integrates two different samples using the same keys (`pet_1` and `pet_2) to tie together the example fragments in a coherent way. When imported into Microcks, you should have following result:

![openapi-101-path](/images/guides/openapi-101-path.png)

The `Dispatcher` inferred by Microcks has been adapted to `URI_PARTS` which means that routing logic is made of parts (or path elements) or the URI. The element that is considered for routing is the `id` parameter. Let's tests these new mocks with some commands:

```shell
$ curl http://localhost:8080/rest/Petstore+API/1.0.0/pets/1 -s | jq
{
  "id": 1,
  "name": "Zaza"
}

$ curl http://localhost:8080/rest/Petstore+API/1.0.0/pets/2 -s | jq
{
  "id": 2,
  "name": "Tigresse"
}
```

🎉 Fantastic! We now have a mock with routing logic based on API path elements.

> Microcks dispatcher can support multiple path elements to find appropriate response to an incoming request. In that case, the dispatcher rule will have the form of `part_1 && part_2 && part_3`. In that case of having multiple parts, you may find it useful to reuse definition of example values using `$ref` notation. This is totally supported by Microcks.

## 5. Mocking a POST operation

And new the final step! Let's deal with a new operation that allows registering a new pet within the Petstore. For that, you'll typically have to define a new `POST` operation on the `/pets` path. In order to be meaningful to the user of this operation, a mock would have to integrate some logic that reuse contents from the incoming request and/or generate sample data. That's typically what we're going to do in this last section 😉

Let's add such a new operation into the API by adding the following path snippet into the `paths/peths` section. The subtlety here is that we're integrating specific elements in our [Example Objects](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.1.md#exampleObject):

```yaml
paths:
  /pets:
    [...]
    post:
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/NewPet'
            examples:
              new_pet:
                value:
                  name: Jojo
      responses:
        "201":
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Pet'
              examples:
                new_pet:
                  value: |-
                    {
                      "id": {{ randomInt(5,10) }},
                      "name": "{{ request.body/name }}"
                    }
```

Microcks has this feature called [templates](../../using/advanced/templates/) that can be used to specify dynamic parts in response. The `new_pet` example fragment above embeds two specific notations that are:

* `{{ randomInt(5,10) }}` for asking Microcks to generate a random integer between 5 and 10 for us (remember: the other pets have ids going from 1 to 4),
* `{{ request.body/name }}` for asking Microcks to reuse here the `name` property of the request body. Simply.

When imported into Microcks, you should have following result:

![openapi-101-template](/images/guides/openapi-101-template.png)

You can see in the picture above that the `Dispatcher` has no value as we have no parameters in operation. But this does not prevent use to use both parameters and template functions. In fact, template also allows you to reuse response parameters to inject in response content. Let's now finally test this mock URL using some content and see what's going on:

```shell
$ curl http://localhost:8080/rest/Petstore+API/1.0.0/pets -H 'content-type: application/json' -d '{"name":"Rusty"}' -s | jq
{
  "id": 8,
  "name": "Rusty"
}
```

As a result we've got our pet name `Rusty` being returned with a new `id` being generated. Ta Dam! 🥳

> As a validation, send a few more requests changing your pet name. You'll check that given name is always returned. But you can also go further by defining an [advanced dispatcher](../../using/advanced/dispatching/#json-body-dispatcher) that will inspect your request body content to decide which response must be sent back. Very useful to describe different creation or error cases!

## Wrap-Up

In this guide we have seen the basics on how Microcks can be used to mock responses of an OpenAPI. We introduced some Microcks concepts like examples, dispatchers and templating features that are used to produce a live simulation. This definitely helps speeding-up the feedback loop on the ongoing design as the development of a frontend consuming this API.

Thanks for reading and let you know what you think on our [Zulip Chat](https://microcksio.zulipchat.com) 🐙

gha_language: JavaScript


text:
# Android/Raspberry Pi Video Streaming

Streaming video from rasberry pi / android app to web / android app

**Latest Revision**: 7 Aug 2016

**Background**: 1) I have wanted to do something with a Pi, Arduino, or IOIO; 2) A potential employment opportunity involving
video streaming has arisen; and 3)

**Goals**:

**Research Questions**:

**Methodology**:

**Participants**:

**Schedule**:

**Script**:

repository: bryonnicoson/videostream

repo_name: bryonnicoson/videostream


text:
# Genero program launch menu

## Description

This Genero BDL demo implements a general launch menu to start other programs.

The module implements a treeview to let the user browse in the program tree
and start a program.

Each program is identified by a code and can be executed directly with the code.

In this version, when the user selects a program, the launcher closes itself
and returns the program code. The code can be easily modified if you want to
keep the launcher open after selecting a program to start.

![Genero program launcher (GDC)](https://github.com/FourjsGenero/ex_app_menu/raw/master/docs/appmenu-screen-001.png)

## Prerequisites

* Genero BDL 3.20+
* Genero Browser Client 1.00.52+
* Genero Desktop Client 3.20+
* Genero Studio 3.20+
* GNU Make

## Compilation from command line

1. make clean all

## Compilation in Genero Studio

1. Load the appmenu.4pw project
2. Build the project

## Usage

1. Start the program
2. Browse the treeview
3. Select a leaf node to be executed
4. Append/Delete/Move shortcuts

## Programmer's reference

### Database structure

The main program must provide a database table containing the definition of
the program tree as set of nodes with parent/child references:

```SQL
    CREATE TABLE appmenu_tree (
        progid  VARCHAR(10) NOT NULL PRIMARY KEY,  -- Program id
        ndtype  CHAR(1) NOT NULL,                  -- N = Node, P = Program
        ptitle  VARCHAR(40) NOT NULL,              -- title to be displayed
        parnod  VARCHAR(10),                       -- link to parent node id
        ndposi  SMALLINT NOT NULL,                 -- position in parent node
        cmdexe  VARCHAR(100),                      -- command to execute
        UNIQUE (progid, parnod)
    )
```

### APIs

* appmenu_init(): Module initialization function to be called before others.
* appmenu_fini(): Module finalization function to be called when lib is no longer needed.
* appmenu_exec(): Open the program launcher window, see code for details.

## Bug fixes:


text:
# nur-packages
**My personal [NUR](https://github.com/nix-community/NUR) repository**

![Build and populate cache](https://github.com/neumantm/nur-packages/workflows/Build%20and%20populate%20cache/badge.svg)

## Contained packages:

| Package | Short description |
| --- | --- |
| [multiEclipse](pkgs/multiEclipse) | A wrapper for eclipse to allow the installation of multiple eclipse versions. Also allows the installation of additional jres for use in eclispe |
| [prettifyJsonLog](pkgs/prettifyJsonLog) | A small python program that can prettify any log output where each line is a JSON object. See <https://pypi.org/project/prettifyJsonLog/> |
| [startFirefox](pkgs/startFirefox) | A small wrapper script for firefox allowing to choose different profiles. |

repository: neumantm/nur-packages

branch_name: refs/heads/main

gha_language: Nix

gha_license_id: MIT

repo_name: neumantm/nur-packages


text:
---
hrs_structure:
  division: '3'
  volume: '12'
  title: '31'
  chapter: 576D
  section: 576D-6
type: hrs_section
tags:
  - Property
  - Family
menu:
  hrs:
    identifier: HRS_0576D-0006
    parent: HRS0576D
    name: 576D-6 Other duties of agency
weight: 96030
title: Other duties of agency
full_title: 576D-6 Other duties of agency
---
**§576D-6 Other duties of agency.** (a) The agency shall:

(1) Establish a state parent locator service for the purpose of locating absent and custodial parents;

(2) Cooperate with other states in:

(A) Establishing paternity, if necessary;

(B) Locating an absent parent who is present in the State and against whom any action is being taken under a Title IV-D program in any other state; and

(C) Securing compliance by an absent parent with a support order issued by a court of competent jurisdiction in any other state;

(3) Perform periodic checks of whether a parent is collecting unemployment compensation and, if so, to arrange, either through agreement with the parent or by bringing legal process, to have a portion of the compensation withheld, to fulfill the parent's child support obligations;

(4) Notify annually each custodial parent, guardian, protective payee, or other person having custody of the child of an Aid to Families with Dependent Children family of the amount of child support collected on behalf of the child in the family. For the purpose of this paragraph, "Aid to Families with Dependent Children family" means a family that receives financial assistance under the federal Aid to Families with Dependent Children program or its successor;

(5) Establish and use procedures that shall require a debtor parent to give security, post bond, or give some other guarantee to secure payment of delinquent child support. The procedures shall apply to all debtor parents of children described under section 576D-3\. The procedures shall include advance notice to the debtor parent in full compliance with the State's procedural due process requirements. The agency shall develop guidelines, which are available to the public, to determine whether the case is appropriate for application of this requirement;

(6) Establish and use procedures by which information regarding the name of the debtor parent and the amount of delinquent child support owed by a debtor parent residing in the State will be made available to any consumer reporting agency as defined in section 603(f) of the Fair Credit Reporting Act. The procedures shall be effectuated upon the agency being authorized to provide Title IV-D services and shall include provisions to provide to the debtor parent whose information is being reported advance notice of the procedures, which notice and procedures shall be in full compliance with the State's procedural due process requirements, to contest the accuracy of the information;

(7) Establish and use procedures that will enforce liens against the real and personal property of a debtor parent who owes overdue support and who resides or owns property in the State. The agency shall further establish guidelines that are available to the public to determine whether the case is inappropriate for application of this paragraph;

(8) Establish and use procedures for the notification of a custodial parent that any income tax refund setoff under section 231-53 shall be retained by the State in cases where medical support rights have been assigned to the State and the income tax refund setoff is applied to amounts designated in the child support order for medical purposes;

(9) Establish and use procedures for prompt reimbursement of overpayment of child support debts from income tax refund setoffs under section 231-53\. The procedures shall provide for the reimbursement to be made by the custodial parent or agency;

(10) Establish and use procedures for periodic review and modification of child support orders in accordance with Title IV-D;

(11) Provide notice not less than once every three years to those parents subject to an order of support informing the parents of their right to request the agency to review and, if appropriate, adjust the order of support pursuant to the guidelines established under section 576D-7;

(12) Establish and operate a state case registry that contains records of:

(A) Each case in which services are being provided by the agency under the state plan; and

(B) Each support order established or modified in the State on or after October 1, 1998.

The records shall use standardized data elements for both parents, including but not limited to names, residential and mailing addresses, telephone numbers, driver's license numbers, social security numbers and other uniform identification numbers, dates of birth, case identification numbers, and the names, addresses, and telephone numbers of the parents' employers, and contain any other information as required by the United States Secretary of Health and Human Services. In each case, with respect to subparagraph (A) and where a support order has been established, the case record shall include the amount of monthly or other periodic support owed under the order, and other amounts, including but not limited to arrearages, due under the order, the amounts collected under the order, the birthdate of any child for whom the order requires the provision of support, and the amount of any lien imposed;

(13) Perform other duties required under chapter 576B, the Uniform Interstate Family Support Act; and

(14) Perform other duties required under Title IV-D.

(b) The procedures required under subsection (a)(5), (6), (7), (8), (9), and (10) shall be established by rule in accordance with chapter 91\. [L 1986, c 332, pt of §2; am L 1991, c 182, §1; am L 1994, c 24, §2; am L 1995, c 137, §1; am L 1996, c 25, §2; am L 1997, c 293, §27; am L 1998, c 153, §5; am L 2008, c 178, §1; am L 2011, c 79, §2]

Case Notes

With the consent of the payor-parent, the family court is authorized to enter an order barring the payor-parent, for a period of three years, from seeking a reduction in court-ordered child support. 101 H. 37 (App.), 61 P.3d 548.

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
# SubQuery Example - Summary of Rewards and Slashes

This subquery indexes staking bonds, rewards and slashes of each finalized blocks.

This is an example of EventHandler, provides records of all the accounts that have participated in staking, and summarize their total rewards and slashes. In the end, calculate the total earnings.

# Get Started
### 1. install dependencies
```shell
yarn
```

### 2. generate types
```shell
yarn codegen
```

### 3. build
```shell
yarn build
```

### 4. run locally
```shell
yarn start:docker
```

repository: ERussel/subql-examples

repo_name: ERussel/subql-examples


text:
# Install Ironic

Metal3 runs Ironic as a set of containers. Those containers
can be deployed either in-cluster and out-of-cluster. In both scenarios,
there are a couple of containers that must run in order to provision
baremetal nodes.

- ironic
- ironic-inspector
- ironic-endpoint-keepalived
- ironic-log-watch
- ipa-downloader
- dnsmasq
- httpd

To know more about each container's functionality check the documentation
[here](https://github.com/metal3-io/ironic-image#description).

## Prerequisites

Container runtime (e.g., docker, podman). Here we use docker.

## Environmental variables

{{#include ironic_variables.md}}

## Ironic in-cluster installation

For in-cluster Ironic installation, we will run a set of containers within
a single pod in a Kubernetes cluster. You can enable TLS or basic auth or even
disable both for Ironic and inspector communication. Below we will see kustomize
folders that will help us to install Ironic for each mentioned case. In each
of these deployments, a ConfigMap will be created and mounted to the Ironic pod.
The ConfigMap will be populated based on environment variables from
[ironic-deployment/default/ironic_bmo_configmap.env](https://github.com/metal3-io/baremetal-operator/blob/main/ironic-deployment/default/ironic_bmo_configmap.env). As such, update
`ironic_bmo_configmap.env` with your custom values before deploying the Ironic.

We assume you are inside the local baremetal-operator path, if not you need to
clone it first and `cd` to the root path.

```bash
 git clone https://github.com/metal3-io/baremetal-operator.git
 cd baremetal-operator
```

Basic authentication enabled:

```bash
 kustomize build ironic-deployment/basic-auth | kubectl apply -f -
```

TLS enabled:

```bash
 kustomize build ironic-deployment/basic-auth/tls | kubectl apply -f -
```

## Ironic out-of-cluster installation

For out-of-cluster Ironic installation, we will run a set of docker containers outside
of a Kubernetes cluster. To pass Ironic settings, you can export corresponding [environmental
variables](#environmental-variables) on the current shell before calling [run_local_ironic.sh](https://github.com/metal3-io/baremetal-operator/blob/main/tools/run_local_ironic.sh)
installation script. This will start below containers:

- ironic
- ironic-inspector
- ironic-endpoint-keepalived
- ironic-log-watch
- ipa-downloader
- dnsmasq
- httpd
- mariadb; if `IRONIC_USE_MARIADB` = "true"

If in-cluster ironic installation, we used different manifests for TLS and basic auth,
here we are exporting environment variables for enabling/disabling TLS & basic auth
but use the same script.

TLS and Basic authentication disabled

```bash
 export IRONIC_FAST_TRACK="false"  # Example of manipulating Ironic settings
 export IRONIC_TLS_SETUP="false"   # Disable TLS
 export IRONIC_BASIC_AUTH="false"  # Disable basic auth
 ./tools/run_local_ironic.sh
```

Basic authentication enabled

```bash
 export IRONIC_TLS_SETUP="false"
 export IRONIC_BASIC_AUTH="true"
 ./tools/run_local_ironic.sh
```

TLS enabled

```bash
 export IRONIC_TLS_SETUP="true"
 export IRONIC_BASIC_AUTH="false"
 ./tools/run_local_ironic.sh
```

gha_language: Shell


text:
# WeIO Cloud
WeIO Cloud service.

### Install/Deploy
```bash
go get github.com/nodesign/weio-cloud
$GOBIN/weio-cloud
```

If you are new to Go, more information about setting-up environment and fetching Mainflux code can be found [here](https://github.com/mainflux/mainflux-doc/blob/master/goenv.md).

### Documentation
Development documentation can be found on our [WeIO GitHub Wiki](https://github.com/nodesign/weio/wiki).

### Community
#### Mailing list
[weio](https://groups.google.com/forum/#!forum/weio) Google group

For quick questions and suggestions you can also use GitHub Issues.

#### IRC
[WeIO Gitter](https://gitter.im/nodesign/weio)

#### Twitter
[@weionet](https://twitter.com/weionet)

### Authors
Engineered by [@drasko](https://github.com/drasko) and [@ukicar](https://github.com/ukicar)

### License
[Apache License, version 2.0](LICENSE)

repository: nodesign/weio-cloud

repo_name: nodesign/weio-cloud


text:
# gaitmesh ![CI](https://github.com/ori-drs/gaitmesh/workflows/CI/badge.svg)

This package processes a mesh model (or point cloud and mesh) to produce an annotated version of the mesh where each triangle is associated with a choice of gait-controller for a legged robot.
The result can then be used in the package [recast_ros](https://github.com/ori-drs/recast_ros) for multi-controller long-term locomotion planning for a legged robot.

If you use this in your research, please cite:

> Martim Brandao, Omer Burak Aladag, and Ioannis Havoutis, "**GaitMesh: controller-aware navigation meshes for long-range legged locomotion planning in multi-layered environments**", in *IEEE Robotics and Automation Letters (RAL)*, 2020.

The paper is available [here](https://www.martimbrandao.com/papers/Brandao2020-ral.pdf), and the associated video is [here](https://www.youtube.com/watch?v=_BlhgTmFCOo).

## From a CAD model

As an example, please download the [Barcelona Robotics Lab model](https://www.iri.upc.edu/research/webprojects/pau/datasets/BRL/zip/BRL_obj_wireframe.zip), place it under data/BRL_final.obj, and then run:

```
roslaunch gaitmesh_ros annotate_cloud_gaits.launch input_clouds_not_mesh:=false
```

## From a point cloud

If you have your own point cloud, obtained for example by laser scanning of a site, then follow these steps to produce a triangular mesh:

- Load the cloud in MeshLab
- In MeshLab, run "Surface Reconstruction: Ball Pivoting" with a reasonable radius, e.g. 0.20 meters.
- In MeshLab, run "Close holes" with a reasonable max size, e.g. 40.
- Change "annotate_cloud_gaits.launch" to include the path to your cloud in "cloud1" and the path to the mesh in "cloud_mesh".

Then run:

```
roslaunch gaitmesh_ros annotate_cloud_gaits.launch
```

repository: ori-drs/gaitmesh

repo_name: ori-drs/gaitmesh


text:
# Plotting data with OxyPlot - Part 2

In [previous post](<http://marcindrobik.pl/Post/PlottingdatawithOxyPlot>) we looked at using [OxyPlot](<http://oxyplot.org/>) for drawing simple functions and datasets.

Today let's see how we can plot a function of 2 arguments.

## Heat Map

As far as I know, OxyPlot doesn't have any support for plotting 3D objects, so we have to find different way for visualizing functions with 2 arguments.

One neat way for doing it is to plot a heat map of values. It works like in cartography - low values are deep blue. High values are red. Everything in between goes from blue, through green and orange to red. Just like [following map of Poland](<https://commons.wikimedia.org/wiki/File:Regiony_Kondrackiego-hipsometria.png>):

<img src="https://upload.wikimedia.org/wikipedia/commons/3/38/Regiony_Kondrackiego-hipsometria.png" style="width:98%">

## HeatMapSeries
OxyPlot has a data series called [`HeatMapSeries`](<http://docs.oxyplot.org/en/latest/models/series/HeatMapSeries.html>) that let us do exactly that.

We'll work in context of following method:

    public static HeatMapSeries HeatMap(this PlotModel model, double minX0, double maxX0, double minX1, double maxX1, Func<Matrix, double> f)
    {

(plot function f, that accepts Matrix and computes single value, in given range of values)

Start by initializing the OxyPlot series:

    var map = new HeatMapSeries
    {
        X0 = minX0,
        X1 = maxX0,
        Y0 = minX1,
        Y1 = maxX1,
        Interpolate = false,
        RenderMethod = HeatMapRenderMethod.Rectangles
    };
    model.Series.Add(map);

Each element of series will be an individual pixel. Let's define the resolution at which we'll evaluation our function, and allocate data for series accordingly:

    var x0Resolution = 200;
    var step = (maxX0 - minX0)/x0Resolution;
    var x1Resolution = (int) ((map.Y1 - map.Y0)/step);

    map.Data = new double[x0Resolution, x1Resolution];

With preallocated series data, now it's time to fill it in by iterating through each "pixel" on our map and evaluating function value:

    int x0Index = 0;

    for (double x0 = minX0; x0 < maxX0; x0 += step)
    {
        var x1Index = 0;
        for (double x1 = minX1; x1 < maxX1; x1 += step)
        {
            map.Data[x0Index, x1Index++] = f(Matrix.Vector(x0, x1));
        }

        x0Index++;
    }

Finally, let's define how the function value will be translated to color. For this, OxyPlot uses a notion of axises:

    model.Axes.Add(new LinearColorAxis
    {
        Position = AxisPosition.Right,
        Palette = OxyPalettes.HueDistinct(1500)
    });

## "Banana" function

Let's try our method on following function (logarithm of [Rosenbrock function](<https://en.wikipedia.org/wiki/Rosenbrock_function>)):

![](https://mandrostorage.blob.core.windows.net/blogfiles/LogOfRosenbrock.jpg)

First, let's write down the Rosenbrock function itself:

    double BananaFunction(Matrix x)
    {
        var a = x[1] - (x[0] * x[0]);
        var b = 1 - x[0];

        return 100 * a * a + b * b;
    }

... and display the Heatmap (using the PlotModel from previous post):

    model.HeatMap(-2.0, 2.0, -1, 3, x => Log(BananaFunction(x)));

And here's your Banana:

![](https://mandrostorage.blob.core.windows.net/blogfiles/Stratosphere.MachineLearning.Studio_2016-03-27_21-54-51.png)

(Notice a clearly visible minimum at point `[1, 1]`)


text:
# SSL Certificate Chains

notes on investigating issues with server SSL certificate chains.

> In the following notes, I have used the url `https://www.redacted-domain.name/` in place of the actual site in question
> to obscure the identity of the site (as it is not particularly relevant).
> Hence: commands shown here using that url will not work as-is - they need a real url substrituted first!

## Notes

I just encountered a site with an SSL certificate signed by Sectigo (formerly Comodo):

* Sectigo RSA Domain Validation Secure Server CA (Intermediate certificate authority)
* in turn signed by USERTrust RSA Certification Authority (Root certificate authority)

The site worked fine in browsers (Chrome, Firefox etc), and the certificate chain was all ok when viewed with
the browser's certificate inspection feature.

But I was seeing SSL verification errors when using command line utilities, specifically curl:

```
$ curl https://www.redacted-domain.name/
curl: (60) SSL certificate problem: certificate has expired
More details here: https://curl.haxx.se/docs/sslcerts.html

curl performs SSL certificate verification by default, using a "bundle"
 of Certificate Authority (CA) public keys (CA certs). If the default
 bundle file isn't adequate, you can specify an alternate file
 using the --cacert option.
If this HTTPS server uses a certificate signed by a CA represented in
 the bundle, the certificate verification probably failed due to a
 problem with the certificate (it might be expired, or the name might
 not match the domain name in the URL).
If you'd like to turn off curl's verification of the certificate, use
 the -k (or --insecure) option.
HTTPS-proxy has similar options --proxy-cacert and --proxy-insecure.
```

## First Thought

My first thought was to suspect an old CA certificate bundle - a common enough occurence on MacOS,
especially when I'm running an old version, and there can be confusion as to which cert bundle is being used (system? brew-installed utilities and openssl? etc).

Apple Support provide details of the root certificates shipped with each version.
e.g. [here for for High Sierra](https://support.apple.com/en-gb/HT208127).
and one can inspect locally at `file:///System/Library/Security/Certificates.bundle/Contents/Resources/TrustStore.html`
or with the Keychain Access utility program.

However a quick check with one of the many SSL verification utilites on the net -
[www.sslshopper.com](https://www.sslshopper.com/ssl-checker.html#hostname=https://www.redacted-domain.name/) -
showed there was in fact an issue with the certificates being provided by the server.

It was reporting "One of the root or intermediate certificates has expired (367 days ago)."

Server certificate:

    Common name: www.redacted-domain.name
    SANs: *.redacted-domain.name, redacted-domain.name
    Valid from February 26, 2020 to March 28, 2022
    Serial Number: aebde0ab25f78379378654874b7082bf
    Signature Algorithm: sha256WithRSAEncryption
    Issuer: Sectigo RSA Domain Validation Secure Server CA

Intermediate:

    Common name: Sectigo RSA Domain Validation Secure Server CA
    Organization: Sectigo Limited
    Location: Salford, Greater Manchester, GB
    Valid from November 1, 2018 to December 31, 2030
    Serial Number: 7d5b5126b476ba11db74160bbc530da7
    Signature Algorithm: sha384WithRSAEncryption
    Issuer: USERTrust RSA Certification Authority

Root:

    Common name: USERTrust RSA Certification Authority
    Organization: The USERTRUST Network
    Location: Jersey City, New Jersey, US
    Valid from May 30, 2000 to May 30, 2020
    Serial Number: 13ea28705bf4eced0c36630980614336
    Signature Algorithm: sha384WithRSAEncryption
    Issuer: AddTrust External CA Root

## openssl

The following steps will use [openssl](https://www.openssl.org/) to inspect the server cert chain.
Per my installation:

    $ which openssl
    /usr/bin/openssl
    $ openssl version -d
    OPENSSLDIR: "/private/etc/ssl"
    $ openssl version
    LibreSSL 2.2.7

## Using openssl to Extract/examine Site Certificate Details

The [openssl s_client](https://www.openssl.org/docs/man1.0.2/man1/s_client.html)
command can be used to test a specific server connection.

Here's a command that I used to extract the certificates offererd by the server to a file `failing-cacert.pem`

```
echo "quit" | openssl s_client -showcerts -servername www.redacted-domain.name -connect www.redacted-domain.name:443 > failing-cacert.pem
```

There are actually 3 certificates downloaded: the server, and intermediated. and a root certificate.

The [openssl x509](https://www.openssl.org/docs/man1.0.2/man1/x509.html) command can be used to inspect the certificates.
But it can only hande one at a time, so this little awk expressions extracts the root certificate (number '2') for inspection.

This shows the certificate expired May 30 10:48:38 2020 GMT.

```
$ cat failing-cacert.pem | awk '/^ 2 s:/{flag=1} flag; /-----END/{flag=0}' | openssl x509 -text -noout
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number:
            13:ea:28:70:5b:f4:ec:ed:0c:36:63:09:80:61:43:36
    Signature Algorithm: sha384WithRSAEncryption
        Issuer: C=SE, O=AddTrust AB, OU=AddTrust External TTP Network, CN=AddTrust External CA Root
        Validity
            Not Before: May 30 10:48:38 2000 GMT
            Not After : May 30 10:48:38 2020 GMT
        Subject: C=US, ST=New Jersey, L=Jersey City, O=The USERTRUST Network, CN=USERTrust RSA Certification Authority
        Subject Public Key Info:
            Public Key Algorithm: rsaEncryption
                Public-Key: (4096 bit)
                Modulus:
                    00:80:12:65:17:36:0e:c3:db:08:b3:d0:ac:57:0d:
                    76:ed:cd:27:d3:4c:ad:50:83:61:e2:aa:20:4d:09:
                    2d:64:09:dc:ce:89:9f:cc:3d:a9:ec:f6:cf:c1:dc:
                    f1:d3:b1:d6:7b:37:28:11:2b:47:da:39:c6:bc:3a:
                    19:b4:5f:a6:bd:7d:9d:a3:63:42:b6:76:f2:a9:3b:
                    2b:91:f8:e2:6f:d0:ec:16:20:90:09:3e:e2:e8:74:
                    c9:18:b4:91:d4:62:64:db:7f:a3:06:f1:88:18:6a:
                    90:22:3c:bc:fe:13:f0:87:14:7b:f6:e4:1f:8e:d4:
                    e4:51:c6:11:67:46:08:51:cb:86:14:54:3f:bc:33:
                    fe:7e:6c:9c:ff:16:9d:18:bd:51:8e:35:a6:a7:66:
                    c8:72:67:db:21:66:b1:d4:9b:78:03:c0:50:3a:e8:
                    cc:f0:dc:bc:9e:4c:fe:af:05:96:35:1f:57:5a:b7:
                    ff:ce:f9:3d:b7:2c:b6:f6:54:dd:c8:e7:12:3a:4d:
                    ae:4c:8a:b7:5c:9a:b4:b7:20:3d:ca:7f:22:34:ae:
                    7e:3b:68:66:01:44:e7:01:4e:46:53:9b:33:60:f7:
                    94:be:53:37:90:73:43:f3:32:c3:53:ef:db:aa:fe:
                    74:4e:69:c7:6b:8c:60:93:de:c4:c7:0c:df:e1:32:
                    ae:cc:93:3b:51:78:95:67:8b:ee:3d:56:fe:0c:d0:
                    69:0f:1b:0f:f3:25:26:6b:33:6d:f7:6e:47:fa:73:
                    43:e5:7e:0e:a5:66:b1:29:7c:32:84:63:55:89:c4:
                    0d:c1:93:54:30:19:13:ac:d3:7d:37:a7:eb:5d:3a:
                    6c:35:5c:db:41:d7:12:da:a9:49:0b:df:d8:80:8a:
                    09:93:62:8e:b5:66:cf:25:88:cd:84:b8:b1:3f:a4:
                    39:0f:d9:02:9e:eb:12:4c:95:7c:f3:6b:05:a9:5e:
                    16:83:cc:b8:67:e2:e8:13:9d:cc:5b:82:d3:4c:b3:
                    ed:5b:ff:de:e5:73:ac:23:3b:2d:00:bf:35:55:74:
                    09:49:d8:49:58:1a:7f:92:36:e6:51:92:0e:f3:26:
                    7d:1c:4d:17:bc:c9:ec:43:26:d0:bf:41:5f:40:a9:
                    44:44:f4:99:e7:57:87:9e:50:1f:57:54:a8:3e:fd:
                    74:63:2f:b1:50:65:09:e6:58:42:2e:43:1a:4c:b4:
                    f0:25:47:59:fa:04:1e:93:d4:26:46:4a:50:81:b2:
                    de:be:78:b7:fc:67:15:e1:c9:57:84:1e:0f:63:d6:
                    e9:62:ba:d6:5f:55:2e:ea:5c:c6:28:08:04:25:39:
                    b8:0e:2b:a9:f2:4c:97:1c:07:3f:0d:52:f5:ed:ef:
                    2f:82:0f
                Exponent: 65537 (0x10001)
        X509v3 extensions:
            X509v3 Authority Key Identifier:
                keyid:AD:BD:98:7A:34:B4:26:F7:FA:C4:26:54:EF:03:BD:E0:24:CB:54:1A

            X509v3 Subject Key Identifier:
                53:79:BF:5A:AA:2B:4A:CF:54:80:E1:D8:9B:C0:9D:F2:B2:03:66:CB
            X509v3 Key Usage: critical
                Digital Signature, Certificate Sign, CRL Sign
            X509v3 Basic Constraints: critical
                CA:TRUE
            X509v3 Certificate Policies:
                Policy: X509v3 Any Policy

            X509v3 CRL Distribution Points:

                Full Name:
                  URI:http://crl.usertrust.com/AddTrustExternalCARoot.crl

            Authority Information Access:
                OCSP - URI:http://ocsp.usertrust.com

    Signature Algorithm: sha384WithRSAEncryption
         93:65:f6:37:83:95:0f:5e:c3:82:1c:1f:d6:77:e7:3c:8a:c0:
         aa:09:f0:e9:0b:26:f1:e0:c2:6a:75:a1:c7:79:c9:b9:52:60:
         c8:29:12:0e:f0:ad:03:d6:09:c4:76:df:e5:a6:81:95:a7:46:
         da:82:57:a9:95:92:c5:b6:8f:03:22:6c:33:77:c1:7b:32:17:
         6e:07:ce:5a:14:41:3a:05:24:1b:f6:14:06:3b:a8:25:24:0e:
         bb:cc:2a:75:dd:b9:70:41:3f:7c:d0:63:36:21:07:1f:46:ff:
         60:a4:91:e1:67:bc:de:1f:7e:19:14:c9:63:67:91:ea:67:07:
         6b:b4:8f:8b:c0:6e:43:7d:c3:a1:80:6c:b2:1e:bc:53:85:7d:
         dc:90:a1:a4:bc:2d:ef:46:72:57:35:05:bf:bb:46:bb:6e:6d:
         37:99:b6:ff:23:92:91:c6:6e:40:f8:8f:29:56:ea:5f:d5:5f:
         14:53:ac:f0:4f:61:ea:f7:22:cc:a7:56:0b:e2:b8:34:1f:26:
         d9:7b:19:05:68:3f:ba:3c:d4:38:06:a2:d3:e6:8f:0e:e3:b4:
         71:6d:40:42:c5:84:b4:40:95:2b:f4:65:a0:48:79:f6:1d:81:
         63:96:9d:4f:75:e0:f8:7c:e4:8e:a9:d1:f2:ad:8a:b3:8c:c7:
         21:cd:c2:ef
```

## Conclusion

Having identified the certificate issue I was able to report the problem to the site owner.

In the meantime, I will disable SSL verification where necessary e.g. with curl, the `-k` option:

```
$ curl https://www.redacted-domain.name/ # curl: (60) SSL certificate problem: certificate has expired
$ curl -k https://www.redacted-domain.name/ # works
```

## Credits and References

* [new CA Sectigo(formerly Comodo) not trusted](https://live.paloaltonetworks.com/t5/general-topics/new-ca-sectigo-formerly-comodo-not-trusted/td-p/301356)
* [Syncing macOS Keychain certificates with Homebrew's OpenSSL](https://akrabat.com/syncing-macos-keychain-certificates-with-homebrews-openssl/)
* [openssl s_client doc](https://www.openssl.org/docs/man1.0.2/man1/s_client.html)

repository: tardate/LittleCodingKata

repo_name: tardate/LittleCodingKata


text:
---
layout: episode-post
title: "Episode 146: Foongus"
date: 2022-03-29 11:03:42
season: "5"
thumbnail: /assets/img/uploads/146_foongus.png
---
Yes, join these fun guys as they cook up the best Foongus recipes on planet earth. Also we discuss "new beverage" and perhaps too many double entendres.

repository: e-vanaubrey/icy-blog

gha_language: SCSS

repo_name: e-vanaubrey/icy-blog


text:
### Stopping Applications

To stop an application, do these steps:

* Go to the StopApp procedure.

*  Enter the following parameters:

![image](images/StopApp/stopApp2.png)

After the job runs, you can view the results, including the following job details, which show that
the application was stoped
successfully:

![image](images/StopApp/stopApp3.png)

In the **StopApp** step, click the Log icon to
see the diagnostic information. The output is similar to the
following diagnostic
report.

![image](images/StopApp/stopApp4.png)

repository: electric-cloud/EC-WebSphere

gha_language: Groovy

repo_name: electric-cloud/EC-WebSphere


text:
# whathappened
What happened in this OSM changeset?

Try it:

[https://osm-what-happened.herokuapp.com/whathappened/41140349/wheelchair?osmtypes=node](https://osm-what-happened.herokuapp.com/whathappened/41140349/wheelchair?osmtypes=node) will look at nodes in changeset 41140349 for added or changed `wheelchair` tags.

```
{
  "node": [
    {
      "created": {},
      "deleted": {},
      "id":<PHONE_NUMBER>,
      "modified": {
        "wheelchair": {
          "new": "limited",
          "old": "no"
        }
      },
      "version": 3
    }, ...
```

The url pattern is `https://osm-what-happened.herokuapp.com/whathappened/<changeset_id>/<watchlist>[?osmtypes=<osmtypes>` where

* `changeset_id` is your changeset id
* `watchlist` is a pipe-separated list of OSM tag keys to watch for
* `osmtypes` is a pipe-separated list of OSM object types to consider.

`osmtypes` is optional and defaults to `node|way`.

repository: mvexel/whathappened

repo_name: mvexel/whathappened


text:
---
title: Umbraco.Commerce.Core.Adapters
description: API reference for Umbraco.Commerce.Core.Adapters in Umbraco Commerce
---
## Umbraco.Commerce.Core.Adapters namespace

| Public Type | Description |
| --- | --- |
| interface [IProductAdapter](iproductadapter.md) |  |
| abstract class [ProductAdapterBase](productadapterbase.md) |  |

<!-- DO NOT EDIT: generated by xmldocmd for Umbraco.Commerce.Core.dll -->

repository: umbraco/UmbracoDocs

repo_name: umbraco/UmbracoDocs


text:
---
layout: post
title: "Kotlin in Space"
guest: Sergey Shkredov, Max Mazin
recorded: 2020-10-13
published: 2020-12-14
trackid: 947091940
length: "46:19"
length_rounded: "46 mins"
tags: [Space, Ktor, Multiplatform, Mobile]
image: space.png
description: "We chat with Sergey and Max about their use of Kotlin in Space. We cover the frameworks that they use, some of which were born out of Space. We discuss their adoption of Multiplatform before Kotlin Multiplatform even existed, as well as why they chose Kotlin and the benefits it provides them, along with the main issues they encounter."
bio: "Sergey is Team Lead on Space and comes from having worked on ReSharper and Rider. Max is Project Manager in Space and comes from YouTrack"

notes:
    - text: JetBrains Space
      link: https://www.jetbrains.com/space/
    - text: RD Framework
      link: https://github.com/JetBrains/rd
    - text: Ktor
      link: https://ktor.io
    - text: Exposed
      link: https://github.com/JetBrains/Exposed

---

repository: talkingkotlin/website

repo_name: talkingkotlin/website


text:
---
layout: default
---

# 1994-01-14 - Re: why govt's get bigger

## Header Data

From<EMAIL_ADDRESS>(Frode Odegard)

To<EMAIL_ADDRESS>Message Hash: cf57db012c35ad712de962d81146741aef86ae1b3e10beeb272dfcbdc3fdb4d1

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1994-01-14 04:42:42 UTC

Raw Date: Thu, 13 Jan 94 20:42:42 PST

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Frode Odegard)
Date: Thu, 13 Jan 94 20:42:42 PST
To<EMAIL_ADDRESS>Subject: Re: why govt's get bigger
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Greg Brooks<EMAIL_ADDRESS>writes:

> Governments act as any rational being acts -- in their own self interest. As
> the distillers of laws and collectors of taxes, however, they just have a
> better shot at self-interest nirvanna than the rest of us.

So you are saying that acting in one's own rational self-interest is
compatible with acting upon somone else by force?  Um, and how can you
epistemologically justify looking upon the government as being a
rational being, as having a consciousness?  It consists of many separate
individuals, does it not?

Finally, isn't self-interest nirvanna a contradiction in terms?  Nirvanna
means merging with something greater, extinction of the self etc.  But isn't
the only rational standard of value, the ultimate self-interest, the
preservation and flourishing of one's self, of one's life?

I'm very curious about why people think governments are allowed to grow so
oppressive - maybe this has something to do with whether people in a society
think big government is good.  It appears to me that most people these days
are of the opinion that government should 'help people' instead of protect
what our founding fathers saw as inalienable rights.  It also seems to me
like the whole concept of rights has been perverted, that political leaders
now believe that _needs_ make rights, such as the "need" for health care or
an information superhighway for all Americans.  For those who've forgotten,
this country was not founded as a democracy but as a republic.

			- Frode

{% endraw %}
```

## Thread

+ Return to [January 1994](/archive/1994/01)

+ Return to<EMAIL_ADDRESS>(Frode Odegard)](/authors/frode_at_toaster_sfsu_edu_frode_odegard_)"

+ 1994-01-14 (Thu, 13 Jan 94 20:42:42 PST) - Re: why govt's get bigger -<EMAIL_ADDRESS>(Frode Odegard)_


text:
# cli-countdown

Counts down a number of seconds before exiting.
This is useful as an alternative to `read`, to give users a chance to exit multi-part shell scripts.

```
npm install -g cli-countdown
```

## Usage

```bash
echo Doing interesting things...
echo Now about to delete some files
countdown -m "Deleting files in" -s 10
rm foo.txt
```

Which displays

![screenshot](screenshot.gif)

- If the timer runs to the end, the exit code will be `0`
- If the user interrupts with `Ctrl-C` (`SIGINT`), the exit code will be `1`

If you want `Ctrl-C` to abort the current shell script completely, you will probably want to use

- `set -e` at the top of your script
- or `countdown <args> || exit 1`

## Arguments

- `countdown -s 10`: timer duration in seconds (default 10)
- `countdown -m "message"`: message to display (default none)
- `countdown --help`: display command usage

repository: rprieto/cli-countdown

repo_name: rprieto/cli-countdown


text:
# User Guide

## Element Creation

All circuit elements are created by calling corresponding functions; see the
[Element Reference](@ref) for details.

### Unitful elements

ACME provides a package extension for
[Unitful](https://github.com/PainterQubits/Unitful.jl) to support quantities
with units when constructing elements. E.g. `resistor(4.7e3)` and
`resistor(4.7u"kΩ")` are equivalent after `Unitful` has been loaded. This can
increase readability and help catch bugs (e.g. `resistor(5u"V")` will throw an
error). The input and output signals of the curcuit models will still be
unitless, however.

!!! compat "Julia 1.9"
    Package extensions require Julia 1.9 or later. Consequently, unitful
    quantities are not supported on earlier Julia versions.

## Circuit Description

Circuits are described using `Circuit` instances, which are most easily created
using the `@circuit` macro:
```@docs
@circuit
```
The pins provided by each type of element are described in the [Element Reference](@ref).

Instead of or in addition to using the `@circuit` macro, `Circuit` instances can
also be populated and modified programmatically using the following functions:
```@docs
add!
delete!
connect!
disconnect!
```

For example, a cascade of 20 RC-lowpasses could be generated by:
```jldoctest ug; output = false, setup = :(using ACME)
circ = @circuit begin
    src = voltagesource(), [-] ⟷ gnd
    output = voltageprobe(), [-] ⟷ gnd
end
pin = (:src, +)
for i in 1:20
    resrefdes = add!(circ, resistor(1000))
    caprefdes = add!(circ, capacitor(10e-9))
    connect!(circ, (resrefdes, 1), pin)
    connect!(circ, (resrefdes, 2), (caprefdes, 1))
    connect!(circ, (caprefdes, 2), :gnd)
    global pin = (resrefdes, 2)
end
connect!(circ, pin, (:output, +))

# output

```

## Model Creation and Use

A `Circuit` only stores elements and information about their connections. To
simulate a circuit, a model has to be derived from it. This can be as simple
as:

```jldoctest ug; output = false, filter = r"DiscreteModel{.*"s
model = DiscreteModel(circ, 1/44100)

# output

DiscreteModel{...}(...)
```

Here, `1/44100` denotes the sampling interval, i.e. the reciprocal of the
sampling rate at which the model should run. Optionally, one can specify the
solver to use for solving the model's non-linear equation:

```jldoctest ug; output = false, filter = r"DiscreteModel{.*"s
model = DiscreteModel(circ, 1/44100, HomotopySolver{SimpleSolver})

# output

DiscreteModel{...}(...)
```

See [Solvers](@ref) for more information about the available solvers.

Once a model is created, it can be run:

```jldoctest; output = false, setup = :(using ACME; model=DiscreteModel(@circuit(begin end), 1); u=zeros(0,10))
y = run!(model, u)

# output

0×10 Matrix{Float64}
```

The input `u` is matrix with one row for each of the circuit's inputs and one
column for each time step to simulate. Likewise, the output `y` will be a
matrix with one row for each of the circuit's outputs and one column for each
simulated time step. The order of the rows will correspond to the order in which
the respective input and output elements were added to the `Circuit`.
So for above circuit, we may obtain the first 100 samples of the impulse
response with

```jldoctest ug
run!(model, [1 zeros(1,99)])

# output

1×100 Matrix{Float64}:
 1.83357e-8  3.1622e-7  2.59861e-6  …  0.00465423  0.00459275  0.00453208
```
To
simulate a circuit without inputs, a matrix with zero rows may be passed:

```jldoctest; output = false, setup = :(using ACME; model=DiscreteModel(@circuit(begin end), 1))
y = run!(model, zeros(0, 100))

# output

0×100 Matrix{Float64}
```

The internal state of the model (e.g. capacitor charges) is preserved accross
calls to `run!`.

Each invocation of `run!` in this way has to allocate some memory as temporary
storage. To avoid this overhead when running the same model for many small input
blocks, a `ModelRunner` instance can be created explicitly:

```jldoctest ug; output = false, setup = :(u=zeros(1,10); y=zeros(1,10))
runner = ModelRunner(model, false)
run!(runner, y, u)

# output

```

By using a pre-allocated output `y` as in the example, allocations in `run!` are
reduced to a minimum.

Upon creation of a `DiscreteModel`, its internal states (e.g. capacitor charges)
are set to zero. It is also possible to set the states to a steady state (if
one can be found) with:

```jldoctest ug; output = false
steadystate!(model)

# output

20-element Vector{Float64}:
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
 0.0
```

This is often desirable for circuits where bias voltages are only slowly
obtained after turning them on.

## Solvers

```@docs
SimpleSolver
HomotopySolver
CachingSolver
```

The default solver used is a `HomotopySolver{CachingSolver{SimpleSolver}}`.

gha_language: Julia


text:
## Overview

The STAC / OGC API Sprint is taking place November 5-7 in Arlington, VA.

Check the [agenda](agenda.md) for the main schedule.

This folder will evolve to hold various workspaces, and currently has three main spaces:

[prep-work/](prep-work/) - Lists of topics to be covered at the sprint, being fleshed out with
info to read and think about ahead of time, and overviews of the states of various discussions.
Also includes sections for implementation work, for people to post what they want to work on or
what they want help with.

[spec-work](spec-work/) - Guidance and templates for specification work to be done in the sprint,
so that it can easily evolve to official parts of the OGC API collection of API's, components and
extensions.

[group-work](group-work/) - Workspace for information in-development. This is material which has advanced past the prep-work phase but is not mature enough to be included in the spec-work.

repository: radiantearth/community-sprints

repo_name: radiantearth/community-sprints


text:
rockware_igpet CHANGELOG
==========================

This file is used to list changes made in each version of the rockware_igpet cookbook.

0.1.0
-----
- [mdietz] - Initial release of rockware_igpet
- [mdietz] - Current app version: 2012.0.0

repository: wesleyan/chef-cookbooks

repo_name: wesleyan/chef-cookbooks


text:
# Venuu-dashboard [![Build Status](https://circleci.com/gh/venuu/venuu-dashboard.png?circle-token=c78cb6dacd86ddba01a411456ea2ab0bef6ce414)](https://circleci.com/gh/venuu/venuu-dashboard)

## Getting started

If you do not have ruby, bundler, node.js and npm, check Production Setup for instructions. If you source rbenv somewhere else than ~/.bashrc, please source that instead.

```
git clone git@github.com:venuu/venuu-dashboard.git
cd venuu-dashboard
npm install -g grunt-cli bower
./setup.sh

```

Detailed configuration can be found on [Google Drive](https://docs.google.com/document/d/1ptHqRnnKQh2z2oObZt5Df3rILxeJ84YM_uBMEtYwNeU).

## Production setup

Create user 'ohtu' (or change to your liking)

Then run following commands as root ( or sudo ) to install all necessary software - should run fine as a script on Ubuntu 12.04

```
#Basic server configuration

apt-get update
apt-get -y upgrade
apt-get install -y nginx
apt-get install -y git

#Ruby and Rails-api need these

apt-get install -y libssl-dev
apt-get install libsqlite3-dev

#setup directories

mkdir /srv/ohtu/
chown ohtu /srv/ohtu/
mkdir /srv/ohtu-backend/
chown ohtu /srv/ohtu-backend/

#setup nginx
mv /etc/nginx/sites-available/default /etc/nginx/sites-available/default.copy
wget https://raw.githubusercontent.com/venuu/venuu-dashboard/master/continuous_deployment/nginx_settings -O default

service nginx restart
```

And the following commands with user 'ohtu'

```
#Install Ruby

git clone https://github.com/sstephenson/rbenv.git ~/.rbenv
git clone https://github.com/sstephenson/ruby-build.git ~/.rbenv/plugins/ruby-build
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bash_profile
echo 'eval "$(rbenv init -)"' >> ~/.bash_profile
source ~/.bash_profile
rbenv install 2.0.0-rc2
rbenv global 2.0.0-rc2
gem install bundler

```

The application is automatically deployed when master passes tests at CircleCI.
For different folders, change the continuous deployment scripts too.

repository: johan--/venuu-dashboard

repo_name: johan--/venuu-dashboard


text:
# Transducers

It is a higher order reducer. A transformation of a transformation.

Input: Reducer.

Output: another Reducer.

## Motivation
Transducer streams elements through the entire pipeline, with
no intermediate groups (arrays, graphs, etc). Thus, saving memory and time.

## Rules

1) Initialization. Default value.

2) Early Termination. Stop when a reduced accumulator value is passed.
Also, convey reduced values.

3) Completion. Should call a completion fn to produce a final value.

repository: poulzinho/composing-sw

repo_name: poulzinho/composing-sw


text:
---
layout: post
title: "Geometrization of deep networks for the interpretability of deep learning systems"
date: 2019-01-06 14:32:45
categories: arXiv_AI
tags: arXiv_AI Deep_Learning
author: Xiao Dong, Ling Zhou
mathjax: true
---

* content
{:toc}

##### Abstract
How to understand deep learning systems remains an open problem. In this paper we propose that the answer may lie in the geometrization of deep networks. Geometrization is a bridge to connect physics, geometry, deep network and quantum computation and this may result in a new scheme to reveal the rule of the physical world. By comparing the geometry of image matching and deep networks, we show that geometrization of deep networks can be used to understand existing deep learning systems and it may also help to solve the interpretability problem of deep learning systems.

##### Abstract (translated by Google)

##### URL
[http://arxiv.org/abs/1901.02354](http://arxiv.org/abs/1901.02354)

##### PDF
[http://arxiv.org/pdf/1901.02354](http://arxiv.org/pdf/1901.02354)


text:
# Paradigm Shift (src files)

Sources are developed and published by [Automician](http://automician.com) team

## About
This project is a result of applying and comparing different programming paradigms for building web ui automation.

It is part of the ["Paradigm Shift" course (Russian version)](https://seleniumcourses.com/products/paradigm-shift-selenide-java-in-russian)

The following applications are used as systems under tests:
- [TodoMVC](todomvc4tasj.herokuapp.com)
- [Grible](grible.org)

## Notes on sources

Feel free to surf the sources of this project to get familiar with the implementation. There you will find comments of this style:

```java
        storage.column(0).setName("user");
        storage.addColumnAfter(0, "password");

        /* + more "obvious" and friendly for "newcomer"
         * - needs additional DataStorages#table method in context of implementation
         *   - and then also additional TestTable#table method
         *     with the same "kind of" duplicated implementation

         * ~
        Table table = new Table();

        table.column(0).setName("user");
        table.addColumnAfter(0, "password");
         * + KISS
         * + table as widget can be reused on other relevant pages
         * - "newcomer" need to learn more "widgets" to start using such approach
         */
```

The meaning is the following:

- comments block starts with information about preceding code
  - `+` indicates the strong point about it (pros)
  - `-` indicates the weak point about it (cons)
  - `*` may indicate "just some details"

- then follows the "alternative code" with one of the following preceding marks:
  - `>` means that "alternative code" is weaker/less-efficient than original
  - `>=` means that "alternative coe" is almost the same but a bit weaker/less-efficient than original
  - `~` means that "alternative code" is "more or less" the same, and it's more a "choice of taste"... but for somebody it may be "weaker" :)

- then follows the information (pros and cons) about alternative code

repository: HarryHoudini/talks

repo_name: HarryHoudini/talks


text:
# Blogging with Harmonic

Harmonic follow the pattern of others static site generators you may know.
You must write your posts in [Markdown](http://daringfireball.net/projects/markdown/) format.

## New post:
```
harmonic new_post "Hello World"
```
![New Post](img/new_post.png)

After running **_new_post_**, the markdown file will be generated in _**/src/posts/**_ folder.

### Markdown header
The markdown file have a header which defines the post meta-data.
Example:
```markdown
<!--
layout: post
title: hello world
date: 2014-05-17T08:18:47.847Z
comments: true
published: true
keywords: JavaScript, ES6
description: Hello world post
categories: JavaScript, ES6
authorName: Jaydson
-->
```
You can check all possible header values in the [header page](markdown-header.md).

### Markdown content
Everything after the header is the post content.
Example:
```markdown
# Hello World
This is my awesome post using [harmonic](https://github.com/es6rocks/harmonic).

This is a list:
- Item 1
- Item 2
- Item 3
```
The code above will be parsed to something like this:
```html
<h1 id="hello-world">Hello World</h1>
<p>
  This is my awesome post using
  <a href="https://github.com/es6rocks/harmonic">harmonic</a>.
</p>
<p>This is a list:  </p>
<ul>
<li>Item 1</li>
<li>Item 2</li>
<li>Item 3</li>
</ul>
```

[<<< Configuring Harmonic](config.md) | [Markdown Header >>>](markdown-header.md)

repository: JSRocksHQ/harmonic

repo_name: JSRocksHQ/harmonic


text:
# TECH3015 Multimedia III
## Coursework 2 Brief

	Module Name:	 Multimedia III

	Module Code:	 TECH3015

	Title of Assessment:	 Coursework 2

	This coursework item is:	 Summative / Formative

	The learning outcomes that are assessed by this coursework are

Deploy and critically evaluate an interactive multimedia production incorporating dynamic content.

Understand and evaluate complex issues related to accessibility and usability when displaying dynamic and animated content.

Source and synthesise solutions to technical problems.

	This coursework constitutes 60% of the overall module mark.

	This coursework is:	 Individual / Group

	Date set:	 5th December

	Date and time due:	 12pm (midday) on Tuesday 2nd May

	In accordance with the University Assessment and Feedback Policy, your marked coursework and feedback will be available to you on:	Tuesday 23rd May

	You should normally receive feedback on your coursework by no later than 15 University working days after the formal hand-in date, provided that you have met the submission deadline.

	If for any reason this is not forthcoming by the due date your module leader will let you know why and when it can be expected. The Associate Professor Student Experience (<a href='mailto:CEMstudentexperience<EMAIL_ADDRESS>should be informed of any issues relating to the return of marked coursework and feedback.

	When completed you are required to submit your coursework via:

The report should be submitted through the Turnitin link in the Assessments section of the TECH3015 Blackboard page.

    	If you need any support or advice on completing this coursework please visit the Student Matters tab on the Faculty of Technology Blackboard page.

	Late submission of coursework policy:

	Late submissions will be processed in accordance with current University regulations.
	Please check the regulations carefully to determine what late submission period is allowed for your programme.

	Academic Offences and Bad Academic Practices:

	Please ensure you read the section entitled “Academic Offences and Bad Academic Practice” in the module handbook or the relevant sections in this link:  BaseCamp Link:  Overview: Assessment and Good Academic Practices

	Tasks to be undertaken: You are to produce an interactive prototype and supporting design and testing documentation for a web-based interactive story. More details below.

		Deliverables to be submitted for assessment: You are to submit your design and testing document via Turnitin. This should include a link to your interactive prototype.

		How the work will be marked: Your work will be marked according to the marking criteria set out below.

		Module leader/tutor name:

		Thom Corah

	Contact details:
	Email: <a href="mailto:tcorah<EMAIL_ADDRESS>

---

## Overview

In semester 1 you designed and prototyped a web-based interactive story. For this coursework you will go on to produce it using HTML, CSS and JavaScript.

You will first make any modifications to the design that you think are necessary following feedback from your tutor and peers. You will then let loose your webdev skills in realising your dream design.

As well as your practical work, you will also submit a report documenting any changes to your designs and an evaluation of your finished project.

But what if you don't want to use your design from Coursework 1? That's fine, speak to your tutor about developing a proposal for a different idea.

Some key points to consider:

- Make sure to pay attention to the marking criteria. A good mark for Coursework 1 doesn't automatically translate to an interactive story that hits all the criteria for coursework 2 - you may need to adapt your design
- Don't skimp on the testing - this is critically important and **will** get you a better mark.
- Stick to your (updated) design. If you need to differ from it, make sure to discuss this in your report.

Any content that is not yours (images, music, sound effects, etc.) should be appropriately referenced at a minimum in a list in the documentation (note that Google, or other search engines are not sources of information). Failure to do so is plagiarism and may effect your grade. This does not prevent you from getting your colleagues or tutor to criticise early drafts of your work before it is handed in / published.

Any content you produce for your story such as an audio interview will be marked primarily on its suitability for web deployment rather than its own production value. For example, a video that is stored at a much larger size than it is displayed at would be a no no. You have other modules where you are keenly assessed on the production value of your digital output. Speak to your tutor if you have any questions about this.

You are expected to heavily comment your HTML, CSS, and JS code. These comments should show an understanding of how the code functions, and discuss any alternative approaches that were discounted. For the purposes of marking, these comments will be included in the mark for documentation.

There are two main components to this coursework: the interactive story itself and the documentation. The story attracts 60% of the mark for this coursework, and the documentation 40%.

### Submitting your coursework

**When completed, you are required to submit your coursework as follows:**

- Your **report** as a PDF, through the Turnitin link in the Assessments section of the TECH3015 Blackboard page ([see deliverables below](#deliverables))
- Your **story** should be in your GitHub repository — name the landing page 'index.html'. Your tutor should be added as a contributor on this repository. Make sure you have GitHub Pages turned on in order that your story is publically viewable through a web browser.

## CW2 Marking Criteria

This coursework is formed of two components. Your web-based interactive story and your supporting documentation.

### Practical Work - Your Interactive Story (Total 60% of CW 2)

Your practical work **must** be available on your public server, and will be assessed against three criteria:
- Content
- Style
- Technical Skills

### Content

**Weighting:** 15% of the coursework mark

Your story content should be fully functional and robust (valid HTML, no missing images, JavaScript errors, etc.). This includes all text, graphics, images and any audio/video. You should use the correct HTML5 code to display these and ensure you have prepared your media for the web.

- HTML5 markup uses semantic tags appropriately
- Text content has semantic structure e.g. headings, lists
- Careful selection, preparation and editing of video and/or audio
- Awareness of loading speed and disk space e.g. no huge images
- Your own original content is credited and any third-party content referenced (media from a single source can have just a single general credit/reference)

### Style

**Weighting:** 15% of the coursework mark

Your story should appeal to your intended audience and be consistent with your mockups/designs. You should make efficient and effective use of CSS in order to style and position elements for your story.

- Style and layout reflect/have evolved from design
- Coherent overall design (following PARC principles), colour and font choices
- Design and content matches the target audience
- Skillful use of CSS to style and arrange web elements
- No duplicate CSS, classes instead of IDs for selectors
- Well-ordered CSS: mobile-first followed by `min-width` breakpoints to be fully responsive at any screen width

### Technical Skills

**Weighting:** 30% of the coursework mark

Your interactive story should demonstrate your ability to apply the technical concepts you have learnt in this module.

- Evidence of your ability to choose and code current web markup, style and programming
- Awareness of usability/accessibility (semantic HTML5 tags, image “alt” attributes, other considerations)
- Use of CSS animations and transitions (subtle or otherwise!)
- No broken links or missing media, site is consistent across mobile and larger platforms
- Use of at least two of:
  _ Local database storage
  _ Third-party APIs
  _ CSS Animation
  _ JavaScript user interaction and/or functionality

### Documentation (Total 40% of CW 2)

**Word Count:** 1000-1500 words with images. References, appendices, and code comments are not included in the word count.

The report must document your updated design (if modified), explain your media preparation, and make a critical evaluation of your finished project — what worked, what could be improved, explanations of decisions you made along the way, and how you might want to take the work further in future.

Make notes and screenshots during the process of creating your story, so you can simply edit these before you submit the report rather than trying to remember your process retrospectively.

If you don't want to use your design or topic from Coursework 1, explain how and why you have readjusted your plans.

Note that the for the purposes of marking, your code comments will be considered as part of your documentation, specifically under the production section. The PDF you submit through Turnitin should contain your Design Process and Evaluation. Your documentation will be marked against the following three criteria.

### Design Process

**Weighting:** 10% of the coursework mark

Refer back to your mock-ups from assignment 1 and discuss:

- what has changed and why
- what you think your main challenge(s) were
- what you consider to be the most important feature(s) of your design

This should be written in light of your own evaluation of your design from CW1, with your peer and tutor feedback.

### Production

**Weighting:** 10% of the coursework mark

Offer some insight into the development of your website through extensive code comments. All of your code should be commented at a basic level to describe functionality and logic. Where applicable, you should also discuss:

- What you were trying to achieve
- How you did this
- Why you chose a certain approach
- How successful the outcome was

### Evaluation

**Weighting:** 20% of the coursework mark

Address the following points:

- Evidence of code testing (e.g. all links work, media loads, the site is consistent across browsers) and the HTML has been validated.
- Evidence and a breakdown of structured user testing and feedback.
- Evaluate your work, with reference to testing where appropriate, and user feedback, describing:
  - Any limitations of your website
  - Any improvements you would make to the site and why
  - Any problems you encountered along the way, referencing any solutions you found or devised

### Key points to consider:

- Examine CW2 marking criteria closely. A good mark for Coursework 1 doesn't automatically translate to a story that meets the criteria for Coursework 2 - you may need to adapt your design or prototype
- Don't skimp on **user testing** - this is critically important and **will** get you a better mark
- [validate your HTML](https://validator.w3.org/) (this is crucial) and at least run your [CSS through a validator](https://jigsaw.w3.org/css-validator/), and [check for accessibility issues](https://wave.webaim.org/) (although these can be advisory) and briefly document this process
- **Reference any content** that’s not yours (images, music, sounds, online tutorial code not included in the learning materials etc.) e.g. in a list or appendix in the documentation (note: Google or other search engines themselves are _not_ primary sources of information). Failure to do so is plagiarism and may effect your grade.
- **Prepare your media**: content such as audio interviews, videos, images will be marked primarily on its suitability for web deployment rather than its own production value. Prepare media for quick download and/or streaming on the web, and demonstrate your knowledge of this requirement. Other modules are keenly assessed on the production value of your digital output, so you can speak to your relevant tutor about this.

### Where to Start?

- think about how your designs will translate into code, especially the main blocks of content
- [validate your HTML](https://validator.w3.org/) at each major stage and fix any errors early—don't allow any broken code!
- start a document to make notes about your process and decisions
- get a basic responsive and mobile-fist structure up and running that follows your design
- upload to GitHub as you go along and get some feedback from testers

### Deliverables

1. the interactive story, in your GitHub repository
2. your critical report, in PDF format, via Turnitin

### Commenting Your Code

You should add comments to your HTML, CSS and JavaScript, with explanations of what your code does. These comments will demonstrate your understanding of your code and the reasons you took the approaches you did.

[Contents](#tableofcontents)

repository: thomcorah/dmu-multimedia

repo_name: thomcorah/dmu-multimedia


text:
# Touching

[Elisabeth Schneller](https://www.elisabethschneller.ch/), [Donat Fritschy](https://www.fritschy.ch/), "Touching", 2016

The artwork "Touching" by Elisabeth Schneller consists of a stela composed by 7 cubes made of black fired clay. The cubes show the text "Touch me" in Braille on one side, and seven engraved texts on other surfaces.

The installation by Donat Fritschy adds interactive sound to the stela: As soon as someone is touching one of the engraved texts, the text is spoken out loud.

https://www.youtube.com/watch?v=2-fBDPu78pA

## Hardware

* [Arduino UNO](https://store.arduino.cc/arduino-uno-rev3)
* [Adafruit MP3 shield](https://www.adafruit.com/product/1790)
* 4 Ultrasonic Sensors HC-SR04 (2cm - 500cm)
* 2 Amplifiers and Electro dynamical exciters mounted inside one of the cubes, providing sound

## Software

This [arduino sketch](src/TouchMe.ino) provides the logic. The four ultrasonic sensors mounted at the top of the stela are polled periodically. If one of the measurements falls into the defined range for a given text, the corresponding MP3 file is played.

Libraries used:
* https://www.arduino.cc/en/Reference/SPI
* https://www.arduino.cc/en/Reference/SD
* https://www.arduino.cc/en/Reference/EEPROM
* https://playground.arduino.cc/Code/NewPing/
* https://github.com/adafruit/Adafruit_VS1053_Library
* https://github.com/jeelabs/jeelib/blob/master/Ports.h

repository: dfritschy/arduino-touchme

repo_name: dfritschy/arduino-touchme


text:
[ ![Codeship Status for BookerSoftwareInc/frederick_api_gem](https://app.codeship.com/projects/43a5ea40-2b13-0135-7e95-4afd89638027/status?branch=master)](https://app.codeship.com/projects/224007)

```text
 _____             _           _      _         _    ____ ___
|  ___| __ ___  __| | ___ _ __(_) ___| | __    / \  |  _ \_ _|___
| |_ | '__/ _ \/ _` |/ _ \ '__| |/ __| |/ /   / _ \ | |_) | |/ __|
|  _|| | |  __/ (_| |  __/ |  | | (__|   <   / ___ \|  __/| |\__ \
|_|  |_|  \___|\__,_|\___|_|  |_|\___|_|\_\ /_/   \_\_|  |___|___/
```

This gem provides a client for Frederick's V2 APIs.

Note: Our V2 APIs have not yet been released for use by customers or partners. See
[Frederick Developers](https://developers.hirefrederick.com) for supported APIs and documentation.

### Configuring FrederickAPI

You can use `FrederickAPI.configure` or environment variables
to configure the Frederick API client.

```ruby
# config/initializers/frederick_api.rb
...
FrederickAPI.configure do |c|
  c.base_url = 'https://api.hirefrederick.com'
  c.public_base_url = 'https://api.public.hirefrederick.com'
  c.api_key = '1234-5678-1234-5678-1234-5678'
end
...
```

Environment variables can also be used:
  * `FREDERICK_API_BASE_URL`: Same as `base_url` above
  * `FREDERICK_API_PUBLIC_BASE_URL`: Same as `public_base_url` above
  * `FREDERICK_API_KEY`: Same as `api_key` above

Environments:
  * For testing (default), use `FREDERICK_API_BASE_URL = https://api.staging.hirefrederick.com`
  and `FREDERICK_API_PUBLIC_BASE_URL = https://api.public.staging.hirefrederick.com`
  * For production, use `FREDERICK_API_BASE_URL = https://api.hirefrederick.com`

NOTE: You must specify the production base URL of `https://api.hirefrederick.com` in order to use this gem with
Frederick's production API.

## Usage

Frederick V2 Resources correspond to ([JSON API](http://jsonapi.org/) compatible) APIs and use the
[json_api_client](https://github.com/chingor13/json_api_client) gem under the hood, so provide access
to standard "ActiveRecord-like" functionaliy such as `.create`, `.find`, `.where`, `.order`, `.includes` to create, find,
filter, sort, and include relationships.

### Access Tokens

An access token is required to access resources on behalf of a use. Use `Resource.with_access_token { ... }` to make
requests with an access token.

```ruby
location_id = '6fdf0530-3e4e-46f1-9d11-5f90c48a50dc'
access_token = '9jsdo320fjfkfdksls30dfdcd919bcaa1b7804dbbebda0'
FrederickAPI::V2::Location.with_access_token(access_token) do
  # Fetch a location
  location = FrederickAPI::V2::Location.find(location_id).first
  # => #<FrederickAPI::V2::Location:0x007fd2f29a7618>

  location.name
  # => 'Bizzy Biz'

  # Update a location
  location.name = 'Biz Bizziest'
  location.save
  # => true

  # To instantiate a resource for update without fetching it first, use `.load` with id
  location = FrederickAPI::V2::Location.load(id: location_id)
  location.update_attributes(phone_number: '(555) 555-5555')
  # => true
end
```

### Using Headers

`Resource.with_access_token` is extended to take headers in the method `Resource.with_access_token_and_headers`. This is useful when we need to pass the universal customer to services that accept it.

```ruby
access_token = '9jsdo320fjfkfdksls30dfdcd919bcaa1b7804dbbebda0'
headers = { 'X-Universal-Customer': '{"source_platform":"mindbody","source_location_id":"1","source_customer_id":"77"}' }

FrederickAPI::V2::CommunicationTemplate.with_access_token_and_headers(access_token, headers) do
  template = FrederickAPI::V2::CommunicationTemplate.create(template_attributes)

  template.name
  # => 'Name from Attrs'
end
```
### Nested Resources

Nested resources must be accessed using `where` to scope the request:

```ruby
location_id = '6fdf0530-3e4e-46f1-9d11-5f90c48a50dc'
access_token = '9jsdo320fjfkfdksls30dfdcd919bcaa1b7804dbbebda0'
FrederickAPI::V2::Location.with_access_token(access_token) do
  # Find contacts
  contacts = FrederickAPI::V2::Contact.where(location_id: location_id).page(1).per(100).to_a
  # => [...]
end
```
### Background Jobs

FrederickAPI Gem handles asynchronous responses as suggested in
[JSONApi Recommendations](https://jsonapi.org/recommendations/#asynchronous-processing)
[Asynchronous Processing](https://jsonapi.org/recommendations/#asynchronous-processing).
Polling until the job is complete, fetching and returning the completed resource.

* A FrederickAPI::V2::Errors::BackgroundJobFailure exception is raised if the API returns
an error on an asyncronous job.
* A BackgroundJob Resource will be returned from the client in the case that a successful
 job does not return a resource.