text:
---
id: Kubernetes
title: Running on Kubernetes
sidebar_label: Running on Kubernetes
---

This document describes how to run LogDevice kubernetes using the specs that we provide. The document assumes basic previous kubernetes knowledge. By the end of this section, you'll have a fully running LogDevice cluster on kubernetes that's ready to receive reads/writes.

## 1. Building your Kubernetes Cluster

The first step is to have a running kubernetes cluster. You can use a managed cluster (provided by your cloud provider), a self-hosted cluster or a local kubernetes cluster using a tool like [minikube](https://github.com/kubernetes/minikube). Make sure that `kubectl` points to whatever cluster you're planning to use.

## 2. Install Zookeeper

LogDevice depends on Zookeeper for storing per-log metadata and its nodes configuration. So we will need to provision a zookeeper ensemble that LogDevice will be able to access. For this demo, we will use [helm](https://helm.sh/) (A package manager for kubernetes) to install zookeeper. After installing helm run:

```shell-session
helm repo add incubator http://storage.googleapis.com/kubernetes-charts-incubator
helm repo update
helm install zookeeper incubator/zookeeper
```

```shell-session
NAME: zookeeper
LAST DEPLOYED: Fri Dec 20 14:19:41 2019
NAMESPACE: default
STATUS: deployed
REVISION: 1
TEST SUITE: None
NOTES:
Thank you for installing ZooKeeper on your Kubernetes cluster. More information
about ZooKeeper can be found at https://zookeeper.apache.org/doc/current/

Your connection string should look like:
  zookeeper-0.zookeeper-headless:2181,zookeeper-1.zookeeper-headless:2181,...

  You can also use the client service zookeeper:2181 to connect to an available ZooKeeper server.

```

> Take note of the printed zookeeper connection string, we will use it later on.

This will by default install a 3 nodes zookeeper ensemble. Wait until all the three pods are marked as ready:

```shell-session
kubectl get pods
```

```shell-session
NAME          READY   STATUS    RESTARTS   AGE
zookeeper-0   1/1     Running   1          2m20s
zookeeper-1   1/1     Running   0          99s
zookeeper-2   1/1     Running   0          74s
```

## 3. Configuring and Starting LogDevice

Once all the zookeeper pods are ready, we're ready to start installing the LogDevice cluster.

### Fetching The K8s Specs

```shell-session
git clone https://github.com/facebookincubator/LogDevice.git
cd LogDevice/k8s
```

### Initial LogDevice Configuration

If you used a different way to install zookeeper, make sure to update the zookeeper connection string in the server config file `config.json`. It should look something like this:

```shell-session
$ cat config.json  | grep -A 3 zookeeper
  "zookeeper": {
    "zookeeper_uri": "ip://zookeeper-0.zookeeper-headless:2181,zookeeper-1.zookeeper-headless:2181,zookeeper-2.zookeeper-headless:2181",
    "timeout": "30s"
  }
}
```

By default, this spec installs a 3 nodes LogDevice cluster. If you want a bigger cluster, modify the `logdevice-statefulset.yaml` file, and increase the number of replicas to the number of nodes you want in the cluster. Also by default, we attach a 20GB persistent storage to the nodes, if you want more you can change that under the `volumeClaimTemplates` section.

Check out [our configuration docs](configuration.md) for more details about the configuration file.

### Starting the Cluster

Once you're done configuring the cluster, you can deploy it using:

```shell-session
$ kubectl apply -k .

configmap/logdevice-config created
configmap/nshards created
service/logdevice-admin-server-service created
service/logdevice created
deployment.apps/logdevice-admin-server-deployment created
statefulset.apps/logdevice created
```

This command will:
- Start all the nodes under a kubernetes StatefulSet.
- Start a standalone admin server to administrate the cluster.
- Store the config file in a ConfigMap and mount it to all the nodes.

When you run `kubectl get pods`, you should see something like this:

```shell-session
NAME                                                 READY   STATUS    RESTARTS   AGE
logdevice-0                                          1/1     Running   0          2m14s
logdevice-1                                          1/1     Running   0          2m2s
logdevice-2                                          1/1     Running   0          118s
logdevice-admin-server-deployment-6cdf46cd6c-d7gkp   1/1     Running   0          2m14s
zookeeper-0                                          1/1     Running   1          13m
zookeeper-1                                          1/1     Running   0          12m
zookeeper-2                                          1/1     Running   0          12m
```

> Tip: If you want to see the logs of one of the nodes run `kubectl logs logdevice-<id>`.

### Bootstrapping the Cluster

Once all the logdevice pods are running and ready, you'll need to bootstrap the cluster to enable all the nodes. To do that, run:

```shell-session
$ kubectl run ldshell -it --rm --restart=Never --image=facebookincubator/logdevice -- \
   ldshell --admin-server-host logdevice-admin-server-service \
   nodes-config \
   bootstrap --metadata-replicate-across 'NODE: 3'
```

This will start a ldshell pod, that connects to the admin server and invokes the `nodes-config bootstrap` ldshell command and sets the metadata replication property of the cluster to be replicated across three different nodes (more on metadata logs [here](configuration.md#metadata-logs-metadata-logs)). On success, you should see something like:

```shell-session
Logging to /tmp/ldshell-amfk8ock
Logging Level: WARNING
Successfully bootstrapped the cluster
pod "ldshell" deleted
```

## 4. Managing the Cluster

### LDShell

Now the cluster should be up and running and ready to receive reads and writes. To be able to get an interactive [ldshell](administration/ldshell.md) instance on this cluster run:

```shell-session
$ kubectl run ldshell -it --rm --restart=Never --image=facebookincubator/logdevice -- \
   ldshell --admin-server-host logdevice-admin-server-service
```

To check the state of the cluster, you can then run:

```shell-session
root@logdevice> status
ID  NAME         PACKAGE     STATE          UPTIME  LOCATION    SEQ.   DATA HEALTH  STORAGE STATE  SHARD OP.   HEALTH STATUS
0   logdevice-0  ?:99.99.99  ALIVE  13 minutes ago            ENABLED   HEALTHY(1)  READ_WRITE(1)  ENABLED(1)     HEALTHY
1   logdevice-1  ?:99.99.99  ALIVE  13 minutes ago            ENABLED   HEALTHY(1)  READ_WRITE(1)  ENABLED(1)     HEALTHY
2   logdevice-2  ?:99.99.99  ALIVE  13 minutes ago            ENABLED   HEALTHY(1)  READ_WRITE(1)  ENABLED(1)     HEALTHY
Took 9ms
```

### Changing Cluster Configs

If you want to edit the cluster config which is stored as a configmap, you can run:

```shell-session
kubectl edit configmaps logdevice-config
```

### Expanding the Cluster

If you want to add more nodes to the cluster you can either run:

```shell-session
kubectl scale statefulsets logdevice --replicas=<new_size>
statefulset.apps/logdevice scaled
```

Or you can modify the spec file, increase the number of replicas and then reapply it using `kubectl apply -k .`. You can then check if the pods are up by running `kubectl get pods`. Once the pods are started, they will auto register to the cluster and maintenance manager will enable them to be able to start serving traffic.

### Shrinking the Cluster

To be able to safely remove a node from a cluster, you first need to drain it (move all the data on this node, to other nodes). Check the [maintenance docs](adminstration/maintenances.md#draining-a-couple-of-nodes) to learn how to drain a node.

> Note: kubernetes only allows you to shrink nodes from the end, so the nodes with the highest IDs in their name are the ones that you should drain.

Once the drain is done (maintenance state is COMPLETED), decrease the number of replicas to the desired number using the same commands from the expand sections. Once the pod is deleted, you can then remove the node from the config using the `nodes-config shrink` ldshell command.

repository: Rachelmorrell/LogDevice

repo_name: Rachelmorrell/LogDevice


text:
# php-markdown-table-converter

A TableConverter for [thephpleague/html-to-markdown](https://github.com/thephpleague/html-to-markdown) as a composer package.

# install

```
composer require xprt64/php-markdown-table-converter
```

# credits
The converter is created by [Mark Hamstra](https://github.com/Mark-H/Docs/blob/2.x/convert/util/TableConverter.php).

license: MIT

repository: rakelley/php-markdown-table-converter

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: rakelley/php-markdown-table-converter


text:
---
title: "Hello World"
lesson: 4
chapter: 0
type: "lesson"
context: "language-tour"
---

Put all that together in Dartpad, and you have your first Dart program:

This, however, works:
```dart
    void sayHello() {
      print('hello world!');
    }

    // main MUST exist.
    void main() {
      sayHello();
    }

    // => 'hello world!'
```

repository: inthroxify/dart-for-web-www

gha_license_id: MIT

repo_name: inthroxify/dart-for-web-www


text:
# Samples for the Azure IoT device SDK for C

This folder contains simple samples showing how to use the various features of the Microsoft Azure IoT Hub service from a device running C code.

## Note
* When using low level samples (iothub_ll_*), the IoTHubDeviceClient_LL_DoWork function must be called regularly (e.g. every 100 milliseconds) for the IoT device client to work properly.

## List of samples

* Simple send and receive messages:
  * **iothub_ll_telemetry_sample**: Sends messages from a device
  * **iothub_ll_client_x509_sample** Sends messages from a device using X.509 based authentication
  * **iotedge_downstream_device_sample**: Sends messages from a device to an IoT Edge device

* Device Twins, Methods, and Cloud-to-Device messages:
  * **iothub_ll_c2d_sample**: Listens for incoming Cloud to Device messages
  * **iothub_client_device_twin_and_methods_sample**: Implements a simple Cloud to Device, Direct Method, and Device Twin sample
  * **iothub_convenience_sample**: Implements a simple Cloud to Device, Direct Method, and Device Twin sample using the convenience layer

* IoT Plug and Play
  * **pnp**: Samples demonstrating IoT Plug and Play device functionality

* Running inside an IoT Edge hosted container:
  * **iothub_client_sample_module_filter**: Listens for messages from *iothub_client_sample_module_sender* sample and method calls from *iothub_client_sample_module_method_invoke*
  * **iothub_client_sample_module_sender**: Sends messages to IoT Edge host, which can be routed to *iothub_client_sample_module_filter*
  * **iothub_client_sample_module_method_invoke**: Invokes a method on a module, which can be routed to *iothub_client_sample_module_filter*

* Uploading blob to Azure:
  * **iothub_client_sample_upload_to_blob**: Uploads a blob to Azure through IoT Hub
  * **iothub_client_sample_upload_to_blob_mb**: Uploads a blob to Azure through IoT Hub using multiple blocks

* Multiplexing send and receive of several devices over a single connection.  (Please see [documentation](../../doc/multiplexing_limitations.md) about multiplexing limitations and alternatives.)
  * **iothub_ll_client_shared_sample**: Send and receive messages from 2 devices over a single AMQP or HTTP connection
  * **iothub_client_sample_amqp_shared_methods**: Receive device methods from 2 devices over a single AMQP connection

* iOS
  * **ios**: More information about using the SDK on iOS devices

* Deprecated samples
  * **iothub_client_sample_mqtt_dm**: Shows the implementation of a firmware update of a device (Raspberry Pi 3)

## How to compile and run the samples

Prior to running the samples, you will need to have an [instance of Azure IoT Hub][lnk-setup-iot-hub]  available and a [device Identity created][lnk-manage-iot-hub] in the hub.

It is recommended to leverage the library packages when available to run the samples, but sometimes you will need to compile the SDK for/on your device in order to be able to run the samples.

[This document][devbox-setup] describes in detail how to prepare your development environment as well as how to run the samples on Linux, Windows or other platforms.

[devbox-setup]: ../../doc/devbox_setup.md
[lnk-setup-iot-hub]: https://aka.ms/howtocreateazureiothub
[lnk-manage-iot-hub]: https://aka.ms/manageiothub

repository: Azure/azure-iot-sdk-c

branch_name: refs/heads/main

gha_language: C

gha_license_id: NOASSERTION

repo_name: Azure/azure-iot-sdk-c


text:
---
layout: post
title: "Insight 2k17 - CompSoc"
date: 2017-08-12 0:0:0
author_github: salman-bhai
image: '/assets/img/'
description: '2017 Edition of IEEE Insight where CompSoc seniors spoke about how to apply for internships abroad and off-campus.'
tags:
- Internships
- Research
- Industry
categories:
- CompSoc
github_username: 'salman-bhai'
comments: true
---

## Insight 2k17 - CompSoc Talk

Insight 2k17, the first event for IEEE NITK Student Chapter started off with a huge response from the Computer Science Community at NITK with a jam-packed hall of students turning up to attend the talk given by final years. The talk was mainly focussed on tips and tricks to apply for research and industry internships off-campus.

![Crowd for Insight](/gyan/assets/img/insight-2k17/crowd.jpg)

The talk was given by three final years:
1. Natasha Jeppu - DAAD Wise Scholar (Interned in Germany) and Mathworks.
2. Ananda Rao - CSE Topper and interned at IIT Bombay and Google Hyderabad.
3. Mohit Reddy - Interned at Google Zurich.

### Natasha Jeppu

![Natasha Jeppu](/gyan/assets/img/insight-2k17/natasha-jeppu.jpg)

This talk was mainly centred on how to apply for research internships abroad and how to build a profile for a possible research career and secure an MS in a top college abroad.

Natasha also used her blog article as a reference which can be found [here](/gyan/internships-abroad/)!

### Ananda Rao

![Ananda Rao](/gyan/assets/img/insight-2k17/ananda-rao.jpg)

Ananda Rao mainly spoke about his interest in Competitve Coding and how he had applied to internships in his second and third year of Computer Science. He also shared how it was possible to maintain a high pointer without having to let go of your interests.

The PPT shared by Ananda Rao can be found [here](https://drive.google.com/open?id=1104pPZPQD7YStRVjE47BWAIM-qACqKIQdrOVLi1esM8)!

### Mohit Reddy

![Mohit Reddy](/gyan/assets/img/insight-2k17/mohit-reddy.jpg)

Mohit Reddy was the last speaker to speak during Insight 2k17. He spoke about his internships in second and third year. He also put in a word of advice for IT 1st Years that the IT Department and the CS Department are not different and there is no inferior feeling there!

The PPT shared by Mohit Reddy can be found [here](https://drive.google.com/open?id=1sfcWSfjWg78IRA0E7ghigHQAeVfic_xbLyiypaTR2pw)

Like the IEEE NITK Facebook to page to get more updates about IEEE as a club and the events that we conduct for NITK Students.


text:
## ks ci

Manages CI services

### Synopsis

Manages CI services.

Used without arguments, lists CI services this project has been setup with.

```
ks ci [flags]
```

### Options

```
  -h, --help   help for ci
```

### Options inherited from parent commands

```
  -c, --config string   config file (default is $HOME/.config/keystone/keystone.yaml)
      --debug           debug output
      --env string      environment to use instead of the current one
  -q, --quiet           make the output machine readable
  -s, --skip            skip prompts and use default
```

### SEE ALSO

* [ks](ks.md)	 - A safe system for developers to store, share and use secrets.
* [ks ci add](ks_ci_add.md)	 - Configures a new CI service
* [ks ci clean](ks_ci_clean.md)	 - Removes all secrets and files from a CI service
* [ks ci edit](ks_ci_edit.md)	 - Configures an existing CI service integration
* [ks ci rm](ks_ci_rm.md)	 - Removes a CI service configuration
* [ks ci send](ks_ci_send.md)	 - Sends environment to a CI service

###### Auto generated by spf13/cobra on 3-Jan-2022

repository: wearedevx/keystone

gha_language: Go

repo_name: wearedevx/keystone


text:
###  Python Developer | Data Science Enthusiast
More on [vidyabhandary.github.io](https://vidyabhandary.github.io)

---

### On my blog

* [100 Days Of Code](https://vidyabhandary.github.io/blog/2021/05/11/100DaysOfCode.html)
* [Github Skyline for 2019, 2020 and 2021 (March)](https://vidyabhandary.github.io/blog/github/2021/03/07/github-skyline.html)
* [Mandelbrot and Julia - Mathematical visualization and beauty](https://vidyabhandary.github.io/blog/mathematics/2021/01/20/Mandelbrot-Julia.html)

More on [vidyabhandary.github.io/blog](https://vidyabhandary.github.io/blog/)

---

### TIL

* [Selecting columns](https://github.com/vidyabhandary/til/blob/master/pandas-numpy/select_columns.md)
* [Drop rows with no values](https://github.com/vidyabhandary/til/blob/master/pandas-numpy/drop_na.md)
* [Differences between Containers and Virtual Machines (VMs)](https://github.com/vidyabhandary/til/blob/master/misc/ContainersVsVMs.md)

More on [vidyabhandary.github.io/TIL/](https://vidyabhandary.github.io/TIL/)

---

How this works

So much to learn and so little time ....

repository: luiz-star/vidyabhandary

repo_name: luiz-star/vidyabhandary


text:
# gifmoji

Takes webcam footage and converts it into a gif made of emojis.

Each block of pixels in the webcam image is replaced with the nearest emoji, based on the average color of pixels in each block.

Uses [p5.js](https://p5js.org/) for the webcam and graphics, and [gif.js](https://github.com/jnordberg/gif.js) for turning the canvas into a gif.


text:
![Logo](img/logo.png "Logo")

**[↤ Developer Overview](../README.md#developer-overview)**

Actions
-------

Actions are additional interactions that you can perform before the tests are run. They allow you to do things like click on a button, enter a value in a form, wait for a redirect, or wait for the URL fragment to change.

Here is an example of a `config` file containing a set of actions to test on a clients site.

Example: `/path/to/config.json`

```json
{
  "format": "html",
  "notices": false,
  "warnings": false,
  "output": "/Users/rvw/Desktop/report-sample",
  "open": true,
  "screenCapture": true,
  "timeout": 100000,
  "wait": 500,
  "auth": {
    "token": "YXNkOmFzZGFzZA=="
  },
  "tests": [
    {
      "url": "https://mywebsite.com",
      "actions": [
        "click element #tab-1",
        "wait for element #tab-1-content to be visible",
        "set field #fullname to John Doe",
        "check field #terms-and-conditions",
        "uncheck field #subscribe-to-marketing",
        "screen capture example.png",
        "wait for fragment to be #page-2",
        "wait for path to not be /login",
        "wait for url to be https://example.com/",
        "wait for #my-image to emit load",
        "navigate to https://another-example.com/"
      ]
    }
  ]
}
```

Here's another example using CLI `action` paramater:

```bash
rvw-a11y https://mywebsite.com --actions='set field #username to<EMAIL_ADDRESS>'set field #password to abc123' 'click element #submit'
rvw-a11y https://mywebsite.com -a 'set field #username to<EMAIL_ADDRESS>'set field #password to abc123' 'click element #submit'
```

Below is a reference of all the available actions and what they do on the page. Some of these take time to complete so you may need to increase the `timeout` option if you have a large set of actions.

### Click Element

This allows you to click an element by passing in a CSS selector. This action takes the form `click element <selector>`. E.g.

```json
"actions": [
    "click element #tab-1"
]
```
You can use any valid [query selector](https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelector), including classes and types.

### Set Field Value

This allows you to set the value of a text-based input or select box by passing in a CSS selector and value. This action takes the form `set field <selector> to <value>`. E.g.

```json
"actions": [
    "set field #fullname to John Doe"
]
```

### Check/Uncheck Field

This allows you to check or uncheck checkbox and radio inputs by passing in a CSS selector. This action takes the form `check field <selector>` or `uncheck field <selector>`. E.g.

```json
"actions": [
    "check field #terms-and-conditions",
    "uncheck field #subscribe-to-marketing"
]
```

### Screen Capture

This allows you to capture the screen between other actions, useful to verify that the page looks as you expect before the test runs. This action takes the form `screen capture <file-path>`. E.g.

```json
"actions": [
    "screen capture example.png"
]
```

### Wait For Fragment/Path/URL

This allows you to pause the test until a condition is met, and the page has either a given fragment, path, or URL. This will wait until the test times out so it should be used after another action that would trigger the change in state. You can also wait until the page does **not** have a given fragment, path, or URL using the `to not be` syntax. This action takes one of the forms:

  - `wait for fragment to be <fragment>` (including the preceding `#`)
  - `wait for fragment to not be <fragment>` (including the preceding `#`)
  - `wait for path to be <path>` (including the preceding `/`)
  - `wait for path to not be <path>` (including the preceding `/`)
  - `wait for url to be <url>`
  - `wait for url to not be <url>`

E.g.

```json
"actions": [
    "click element #login-link",
    "wait for path to be /login"
]
```

### Wait For Element State

This allows you to pause the test until an element on the page (matching a CSS selector) is either added, removed, visible, or hidden. This will wait until the test times out so it should be used after another action that would trigger the change in state. This action takes one of the forms:

  - `wait for element <selector> to be added`
  - `wait for element <selector> to be removed`
  - `wait for element <selector> to be visible`
  - `wait for element <selector> to be hidden`

E.g.

```json
"actions": [
    "click element #tab-2",
    "wait for element #tab-1 to be hidden"
]
```

### Wait For Element Event

This allows you to pause the test until an element on the page (matching a CSS selector) emits an event. This will wait until the test times out so it should be used after another action that would trigger the event. This action takes the form `wait for element <selector> to emit <event-type>`. E.g.

```json
"actions": [
    "click element #tab-2",
    "wait for element #tab-panel-to to emit content-loaded"
]
```

### Navigate To URL

This action allows you to navigate to a new URL if, for example, the URL is inaccessible using other methods. This action takes the form `navigate to <url>`. E.g.

```json
"actions": [
    "navigate to http://another-example.com"
]
```

repository: jimhartford/accessibility-tester

repo_name: jimhartford/accessibility-tester


text:
Make sure python 2.7 is installed on target servers
use: apt install -y python-minimal

Ansible quick commands
```
ansible-galaxy install -r requirements.yml

ansible-playbook --vault-password-file vault.password -u root -i mysite/hosts mysite.yml

ansible-playbook --vault-password-file vault.password -u root -i mysite/hosts mysite.yml --tags security

ansible-vault create mysite-vault.yml

```

repository: dragos-dumi/mysite

repo_name: dragos-dumi/mysite


text:
Grisu NÖ - Infoscreen [![MIT License][license-image]][license-url] [![Build Status][vsonline-image]][vsonline-url]
============
This project aims to build a desktop-based application to improve and extend the functionality of https://infoscreen.florian10.info/.

Licencing
---------

Grisu NÖ - Infoscreen is licenced under the [MIT License (MIT)](LICENSE).

[license-image]: https://img.shields.io/badge/license-MIT-blue.svg
[license-url]: LICENSE

[vsonline-url]: https://grisu-noe.visualstudio.com/DefaultCollection/Infoscreen
[vsonline-image]: https://grisu-noe.visualstudio.com/DefaultCollection/_apis/public/build/definitions/91b44015-3819-4981-9e5f-67b8f5f0b585/2/badge

repository: gitter-badger/Infoscreen

repo_name: gitter-badger/Infoscreen


text:
# Global
  - [X] Make simple floating box
  - [X] Display text
  - [X] Simple word wrapping
  - [X] Read from stdin and keep alive till the stream is alive
  - [X] Window class and other properties
  - [X] Read from stream and update display asynchronously
  - [X] Alpha
  - [X] Alpha cli argument
  - [ ] Change font rendering to dtext
  - [ ] Click button handler
  - [ ] Pass x, y to click handler
  - [ ] Example use case scripts
  - [ ] Load multiple fonts
  - [ ] Fix word wrap issue for words bigger than content width
  - [ ] Package for aur

# Docs
  - [ ] --help usage info
  - [ ] readme usage
  - [ ] man page
  - [ ] use cases in readme

# Cli args
  - [X] Position and dimensions
  - [X] Percentage position and dimensions
  - [X] Font
  - [X] All colors

# Keybindings approaches
  - find a seperate tool for capturing key presses
  - add a permanent key binding that reads contents from a file
  - add a one shot cli option in shotkey for this

repository: phenax/popcorn

repo_name: phenax/popcorn


text:
# Using CarbonData
This tutorial discusses the disciplines related to management of data in Apache CarbonData.
Following below each section is a brief introduction to respective disciplines related to data
management.

## Data Management
This section shall be dealing with the disciplines related to managing data in the application,
focusing on conceptual details related to operations like load data, delete data, update data
and Compacting Data.

For complete details refer to [Data Management](data-management.md)

## Data Definition Language Support
This section deals with the aspects related to creation and modification of the structure of database.
It shall discuss in detail about

*  Table creation
*  Table deletion
*  Table description
*  Compaction

For complete details refer to [DDL Operations on CarbonData](ddl-operation-on-carbondata.md )

## Data Manipulation Language Support
This section deals with the aspects related to data manipulation in database. It shall discuss in detail about selecting, loading and deleting in a database.
This manipulation comprises of

*  Loading data into database tables
*  Retrieving existing data
*  Deleting data from existing tables
*  Deleting segments from existing tables
*  Updating data in existing tables

For complete details refer to [DML Operations on CarbonData](dml-operation-on-carbondata.md)

branch_name: refs/heads/asf-site


text:
# WalkerGame

We are playing a game on our cell phone. We are given an array of length n, indexed from 0 to n-1. Each element of the array is either 0 or 1. We can only move to an index which contains 0. At first, we are at the 0th position. In each move we can do one of the following things:
•	Walk one step forward or backward.
•	Make a jump of exactly length forward.

That means we can move from position x to x+1, x-1 or x+m in one move, but at least one of the following conditions must be true:
•	The new position contains 0.
•	The new position is greater than n-1.
We can’t move backward from position 0. If we move to any position greater than n-1, we win the game.
Given the array and the length of the jump, we need to determine if it’s possible to win the game or not.

Input Format
In the first line there will be an integer T denoting the number of test cases. Each test case will consist of two lines. The first line will contain two integers, n and m. On the second line there will be n space-separated integers, each of which is either 0 or 1.
Constraints:
•	1 <= T <= 5000
•	2 <= n <= 100
•	0 <= m <= 100
•	The first integer in the array is always 0.
Output Format:
For each case output YES if it’s possible to win the game, output NO otherwise.

# Solution Class
Read input from STDIN based on the test description

# WalkerGame
Because I want to write test cases for this class I created WalkerGame class and all tests are available on WalkergameTest

## Running the tests

There are 4 Junit tests
For the First sample input:
testWalkerGamerFor45300000()

For the second sample input:
testWalkerGamerFor465000111()

For the third sample input:
testwalkerGamerFor463001110()

For the forth sample input:
testwalkerGamerFor431010()

## Authors

* **Farahnaz Vahdati**

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details


text:
# Usage

## Preparations

Before we start to inject dependencies, let's define code which needs these
dependencies. Also, let's add some behavior to your robot.

```pycon

>>> class Robot:
...     def __init__(self, servo, controller, settings):
...         self.servo = servo
...         self.controller = controller
...         self.settings = settings
...
...     def run(self):
...         while True:
...             events = self.accept_events()
...             if not events:
...                 break
...             self.process(events)
...
...     def accept_events(self):
...         # We can inject methods.
...         return self.controller()
...
...     def process(self, events):
...         # We can inject dictionaries.
...         max_point = self.settings["max_point"]
...         for event in events:
...             if event.x > max_point:
...                 # We can inject objects.
...                 self.servo.reverse("x")
...             if event.y > max_point:
...                 self.servo.reverse("y")

```

We use constructor-based dependency injection here: we define necessary
arguments and store them explicitly, for the sake of readability. This will help
us to understand the execution path of your system. Attributes sourced from
nowhere in your code aren't fun. Believe me.

Now, it's time to make this work in the real world.

```pycon

>>> class MechanicalMotor:
...     def reverse(self, coordinate):
...         # Hardware work goes here.
...         pass

>>> def read_sensor():
...     # Another hardware work goes here.
...     return []

>>> production = {'max_point': 0.01}

```

We are close to scream "It's alive!" and, if we're lucky enough, run out of the
building.

```pycon

>>> from dependencies import Injector

>>> class Container(Injector):
...     robot = Robot
...     servo = MechanicalMotor
...     controller = read_sensor
...     settings = production

>>> robot = Container.robot  # Robots' constructor called here.

>>> robot.run()

```

Congratulations! We've built our robot with dependency injection.

## Injection rules

`Container` above is a dependency scope, and dependencies are defined as its
attributes. When you access one of those attributes, the following happens:

- If attribute value is a `class`, it will be instantiated. To make that
  possible, the library will inspect its constructor's argument list and search
  current dependency scope for dependencies with the same name.
- If attribute value is a `class` but attribute name ends with `_class` - then
  it will be returned as is. (For example, `Container.foo_class` will return the
  class stored in it, not its instance).
- Anything else is returned as is.
- If, during dependency search, we encounter another `class` - it will be
  instantiated along these rules, as well. The process is recursive.

Here is a demonstration of rules above.

```pycon

>>> class Foo:
...     def __init__(self, one, two):
...         self.one = one
...         self.two = two

>>> class Bar:
...     pass

>>> class Baz:
...     def __init__(self, x):
...         self.x = x

>>> from dependencies import Injector

>>> class Scope(Injector):
...     foo = Foo
...     one = Bar
...     two = Baz
...     x = 1

>>> Scope.foo  # doctest: +ELLIPSIS
<__main__.Foo object at 0x...>

>>> Scope.foo.one  # doctest: +ELLIPSIS
<__main__.Bar object at 0x...>

>>> Scope.foo.two  # doctest: +ELLIPSIS
<__main__.Baz object at 0x...>

>>> Scope.foo.two.x
1

```

Let's roll down what is happening here:

- `Foo` class requires an argument named `two`;
- In dependency scope, that argument resolves to `Baz` class;
- Which is a class - oh, we need to instantiate it as well;
- But its constructor requires an argument named `x`;
- Which resolves to `1` in the dependency scope, so we do not need to go any
  further.

Having found that out, we effectively construct, execute, and return
`Foo(two=Baz(x=1))`.

### Calculation rules

Each dependency evaluates exactly once during injection process. If during
dependency injection different classes have constructor argument with the same
name, the corresponding dependency will be instantiated once and these two
constructors will receive the same object.      # Names.
...     foo, bar, baz, x = Foo, Bar, Baz, X

>>> Container.foo.check()
True

>>> Container.bar.x is Container.bar.x
False

```

## Scope extension

You can define a dependency scope partially and then extend it; only in
injection moment, meaning at the time of attribute access, you are required to
have the complete scope.

It is possible to extend dependency scopes in two ways:

- inheritance
- call

### Inheritance

You can add additional dependencies or redefine existing ones in a scope
subclass:

```pycon

>>> class Foo:
...     pass

>>> class Scope(Injector):
...     foo = Foo

>>> class ChildScope(Scope):
...     bar = Bar

>>> ChildScope.foo  # doctest: +ELLIPSIS
<__main__.Foo object at 0x...>

```

Multiple inheritance is allowed as well.

```pycon

>>> class Scope1(Injector):
...     foo = Foo

>>> class Scope2(Injector):
...     bar = Bar

>>> class ChildScope(Scope1, Scope2):
...     pass

>>> ChildScope.foo  # doctest: +ELLIPSIS
<__main__.Foo object at 0x...>

```

We also provide `and` notation for in-place `Injector` composition. Example
below is full equivalent to the previous one, but without intermediate class
needed.

```pycon

>>> class Scope1(Injector):
...     foo = Foo

>>> class Scope2(Injector):
...     bar = Bar

>>> (Scope1 & Scope2).foo  # doctest: +ELLIPSIS
<__main__.Foo object at 0x...>

```

!!! note

    Extension scope should not be empty.  You can't inherit from
    `Injector` just to have `pass` keyword as the body of the class.

    ```pycon

    >>> class Container(Injector):
    ...     pass
    Traceback (most recent call last):
      ...
    _dependencies.exceptions.DependencyError: Extension scope can not be empty

    ```

### Call

You can temporary redefine a dependency for only one case. This is extremely
useful for tests. Inject an assertion instead of one or more dependencies, and
you will be able to test your system in all possible cases. It is, for example,
possible to simulate database integrity error on concurrent access.

```pycon

>>> class Scope(Injector):
...     foo = Foo
...     bar = Bar

>>> Scope(bar=Baz).foo  # doctest: +ELLIPSIS
<__main__.Foo object at 0x...>

```

It is possible to build dependency scopes directly from dictionaries using call.

```pycon

>>> settings = {'host': 'localhost', 'port': 1234}

>>> Scope = Injector(foo=Foo, bar=Bar, **settings)

```

## `hasattr` alternative

`hasattr` works by attribute access, so it triggers dependency injection. If
this is unnecessary side effect, `dependencies` provides alternative way.

```pycon

>>> class Container(Injector):
...     foo = 1

>>> 'foo' in Container
True

```

— ⭐ —

branch_name: refs/heads/release

gha_language: Python


text:
# cheaper plz
Chrome Extension that notifies you when the price of an item on a website changes. Currently supports amazon and ebay, more coming soon.

Available on the [Chrome Web Store](https://chrome.google.com/webstore/detail/cheaper-plz/jdgbodelanepgmjhaabpmjcdbnmlfjmg).

Source code provided here for the good of all mankind.

## Credits
On the shoulders of giants.

* [AngularJS](http://angularjs.org/)
* [Express](http://expressjs.com/)
* [Node.js](http://nodejs.org/)
* [PhatonJS](http://phantomjs.org/)
* [Twitter Bootstrap](http://twitter.github.com/bootstrap/index.html)
* [Bootswatch Simplex Theme](http://bootswatch.com/simplex/)
* [Ajax Spinner](http://www.ajaxload.info/)

## Copyright
Images (in `app/img/` and `app/icons`) copyright Sharon Lee. Please do not reuse these without permission.

## License
MIT

repository: GreatRepos/analysisfile

repo_name: GreatRepos/analysisfile


text:
# Some useful scripts

These are some of my scripts I use or I used to use at some point in the time. 🙂

## Scripts list

**[MissingLocalizables](MissingLocalizables)** - to check if localizables have no duplicates, missing keys and so on.

```sh
ruby Src/missing-localizables.rb <path/to/localizables> <base-lang>
```

**[ListSearch](ListSearch)** - to check which elements of the list are found in a directory's contents.

```sh
ruby Src/list-search.rb <path/to/list> <path/to/directory>
```

**[RomsFilter](RomsFilter)** - copy filtered stabile NES roms into a subdirectory.

```sh
./RomsFilter/roms-filter.py <path/to/roms>
```

**[XcodeCleanup](XcodeCleanup)** - to cleanup common Xcode paths.

repository: michalcichon/scripts

repo_name: michalcichon/scripts


text:
---
templateKey: interview-post
path: /interview/kiko-chippo-hotel
title: 'Kiko @ Chippo Hotel '
date: 2018-03-31T03:50:50.177Z
description: Our chat with the prolific producer and DJ before his Easter Sunday party...
featuredImage: /img/kiko-crop.jpg
---
_A key figure in France's dance music scene since the 90s, **Kiko** has an astounding back catalogue of music. We grabbed a quick chat with the Frenchman before he headlines sunday's [Zoo Events](https://www.facebook.com/z00project/) party._

**RR:** Great to chat [Kiko](https://www.facebook.com/KIKOMUSIC/) – we’re looking forward to your performance on Sunday. What kind of set can we expect from you?

**Kiko:** Hi! Well... I am going to play a lot of my own productions and try out some of my new tracks too.

**RR:** Sounds good! Now you've played in Australia a few times - how were those experiences?

**Kiko:** I’ve played in Australia about 5 or 6 times that. I played at [Babylon Festival](https://www.facebook.com/babylonfestivalau/) last year, with my old friend [The Hacker](https://www.facebook.com/DJTheHacker/). I love playing in Australia, people are very receptive to the music I play. My first time in Australia was in Sydney and Melbourne in 2002 or 2003.

**RR:** You ran a very popular record store in Grenoble. What was that period of your life like?

**Kiko:** I opened the record store in 1994, and thanks to that shop, I met The Hacker, [Miss Kittin](https://www.facebook.com/misskittin/) and [Oxia](https://www.facebook.com/OXIA.official/), who are all from Grenoble. With Oxia, I set up our first record label Ozone in 1995. Later we created the Goodlife label in 1997 with The Hacker.

**RR:** You've dabbled in multiple genres including italo disco. What draws you to that style of music?

**Kiko:** Yes in Grenoble we love italo disco, because Grenoble is not very far from Italy. My favourite group as a reference is of course [Depeche Mode](https://www.facebook.com/depechemode/).

**RR:** We gather that you have produced over 500 tracks! How do you keep finding fresh ideas for music?

**Kiko:** Music is like a therapy for me, I work every day in my Bunker aka studio - I’ve been doing that for 24 years now! I need to create, it's vital for me.

**RR:** You have a track with [Thomas Gandey](https://www.facebook.com/ThomasGandeyOfficial/) due out next month. Can you tell us a bit about the collaboration?

**Kiko:** I met Thomas Gandey via Facebook... he had already produced tracks with my friend [Oliver Giacomotto](https://www.facebook.com/oliviergiacomotto/), who I've known for quite a few years. I love his voice! As I’ve worked with Oliver for quite a few years now, naturally I needed to work with Thomas Gandey too. We have a track which was released in February on [Suara Records](https://www.facebook.com/suaramusic/) and another track that will be released on the 20th of April for [Stil Vor Talent](https://www.facebook.com/stilvortalent/).

**RR:** You also have a side project called [Minota ](https://www.facebook.com/Minota.music) which is signed under [Miguel Campbell](https://www.facebook.com/miguelcampbellofficial/)'s label. How did that come together?

**Kiko:** I know Miguel Campbell very well, he's like family to me and I love his label [Outcross Records.](https://www.facebook.com/outcrossrecords/). I was also doing house music 20 years ago with Oxia, under the name [Phunky Data](https://www.facebook.com/phunkydatamusic)

**RR:** Having worked in the music business for many years, what would you say has been the key to your longevity?

**Kiko:** To work hard and and to never give up! And of course, surround yourself with good people - including your booking agent, manager, and press agent.

**RR:** And across your extensive career, which gig has been the most memorable for you?

**Kiko:** In 2011 and 2012, I toured with [Carl Cox](https://www.facebook.com/carlcox247/) for 2 years. It was such an epic experience.

**RR:** Finally - what else have you got coming up this year?

**Kiko:** This year I am going to focus a lot on production haha!

**RR:** Thanks for the chatting Kiko, we look forward to your set.

**Kiko:** Thanks for having me!

_Get your tickets for the Easter Sunday event with Kiko [**here**](https://www.residentadvisor.net/events/1087966)_

repository: jmcmullen/rave-reviewz-gatsby

gha_language: JavaScript

repo_name: jmcmullen/rave-reviewz-gatsby


text:
# Martin Logan Mikros 70
See [usage instructions](https://github.com/jaakkopasanen/AutoEq#usage) for more options and info.

### Parametric EQs
In case of using parametric equalizer, apply preamp of **-5.6dB** and build filters manually
with these parameters. The first 3 filters can be used independently.
When using independent subset of filters, apply preamp of **-5.6dB**.

| Type    | Fc      |    Q | Gain    |
|:--------|:--------|:-----|:--------|
| Peaking | 80 Hz   | 0.24 | -5.6 dB |
| Peaking | 1343 Hz | 1.18 | 3.0 dB  |
| Peaking | 4601 Hz | 1.68 | 4.9 dB  |
| Peaking | 1602 Hz | 6.98 | 0.6 dB  |
| Peaking | 2311 Hz | 5.29 | -0.7 dB |
| Peaking | 6872 Hz | 6.17 | 1.3 dB  |
| Peaking | 8060 Hz | 2.42 | -1.0 dB |

### Fixed Band EQs
In case of using fixed band (also called graphic) equalizer, apply preamp of **-5.0dB**
(if available) and set gains manually with these parameters.

| Type    | Fc       |    Q | Gain    |
|:--------|:---------|:-----|:--------|
| Peaking | 31 Hz    | 1.41 | -4.0 dB |
| Peaking | 62 Hz    | 1.41 | -4.6 dB |
| Peaking | 125 Hz   | 1.41 | -4.2 dB |
| Peaking | 250 Hz   | 1.41 | -3.0 dB |
| Peaking | 500 Hz   | 1.41 | -1.5 dB |
| Peaking | 1000 Hz  | 1.41 | 2.2 dB  |
| Peaking | 2000 Hz  | 1.41 | 0.7 dB  |
| Peaking | 4000 Hz  | 1.41 | 4.3 dB  |
| Peaking | 8000 Hz  | 1.41 | 0.2 dB  |
| Peaking | 16000 Hz | 1.41 | -0.2 dB |

### Graphs
![](https://raw.githubusercontent.com/jaakkopasanen/AutoEq/master/results/referenceaudioanalyzer/zero/Martin%20Logan%20Mikros%2070/Martin%20Logan%20Mikros%2070.png)

path: /results/referenceaudioanalyzer/zero/Martin Logan Mikros 70/README.md


text:
---
layout: project
status: active
type: dsg_project
title: Through Equations Physics 101
members: [christos_vassis, george_karabelas, theodore_kounas]
thumb: http://i.imgur.com/9zG9nzi.jpg
repo:
website:
videos:
images:
---
The goal of this project is to combine entertainment, learning and increase
problem-solving skills of the player/student through a series of riddles and
mini-games that take place in a simulated environment that represents real
life.

The story evolves around the life of a high school student named Dimitris that
through his experiences we see how physics are applied from the 2D blackboard
to the 3D real world.

The aim in this game is to capture the attention of the players/students and
take them through a journey of understanding the basic laws of physics.
The game is being developed in UDK by George Karabelas, Theodore Kounas and
Christos Vassis.


text:
### [CVE-2017-15715](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-15715)
![](https://img.shields.io/static/v1?label=Product&message=Apache%20HTTP%20Server&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=%3CFilesMatch%3E%20bypass%20with%20a%20trailing%20newline%20in%20the%20file%20name&color=brighgreen)

### Description

In Apache httpd 2.4.0 to 2.4.29, the expression specified in <FilesMatch> could match '$' to a newline character in a malicious filename, rather than matching only the end of the filename. This could be exploited in environments where uploads of some files are are externally blocked, but only by matching the trailing portion of the filename.

### POC

#### Reference
- https://security.elarlang.eu/cve-2017-15715-apache-http-server-filesmatch-bypass-with-a-trailing-newline-at-the-end-of-the-file-name.html

#### Github
- https://github.com/0day666/Vulnerability-verification
- https://github.com/422926799/haq5201314
- https://github.com/ARPSyndicate/cvemon
- https://github.com/ARPSyndicate/kenzer-templates
- https://github.com/ArrestX/--POC
- https://github.com/Awrrays/FrameVul
- https://github.com/ChadSWilliamson/Red-vs.-Blue-Project
- https://github.com/Elsfa7-110/kenzer-templates
- https://github.com/Fa1c0n35/Web-CTF-Cheatshee
- https://github.com/KayCHENvip/vulnerability-poc
- https://github.com/Miraitowa70/POC-Notes
- https://github.com/PawanKumarPandit/Shodan-nrich
- https://github.com/RoseSecurity-Research/Red-Teaming-TTPs
- https://github.com/RoseSecurity/Red-Teaming-TTPs
- https://github.com/SamGeron/Red-Team-vs-Blue-Team
- https://github.com/SexyBeast233/SecBooks
- https://github.com/Threekiii/Awesome-POC
- https://github.com/Threekiii/Vulhub-Reproduce
- https://github.com/Zero094/Vulnerability-verification
- https://github.com/austin-lai/External-Penetration-Testing-Holo-Corporate-Network-TryHackMe-Holo-Network
- https://github.com/bioly230/THM_Skynet
- https://github.com/duckstroms/Web-CTF-Cheatsheet
- https://github.com/firatesatoglu/shodanSearch
- https://github.com/hacden/vultools
- https://github.com/hailan09/Hacker
- https://github.com/intrigueio/intrigue-ident
- https://github.com/retr0-13/nrich
- https://github.com/rnbochsr/yr_of_the_jellyfish
- https://github.com/safe6Sec/PentestNote
- https://github.com/shuanx/vulnerability
- https://github.com/vshaliii/Basic-Pentesting-2-Vulnhub-Walkthrough
- https://github.com/vshaliii/DC-2-Vulnhub-Walkthrough
- https://github.com/vshaliii/DC-3-Vulnhub-Walkthrough
- https://github.com/vshaliii/Funbox2-rookie
- https://github.com/w181496/Web-CTF-Cheatsheet
- https://github.com/whisp1830/CVE-2017-15715
- https://github.com/zha0/Bei-Gai-penetration-test-guide

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
+++
title = "October 2022"
date = "2022-10-03"

[featured-1]
title = "Uqbar Development Suite"
description = "Write smart contracts and blockchain applications in an integrated development suite."
image=""
content = """
At Assembly 2022 Uqbar debuted their brand new developer toolkit: Ziggurat.  Ziggurat provides a unified development interface where programmers can write contracts, receive compiler feedback, and test on a fake chain. This promises a huge improvement on the developer experience for smart contracts and blockchain application development alike.  Note: As Ziggurat is in active development and undergoing frequent updates, Uqbar recommends installing Ziggurat on a moon rather than your primary ship.

![Screenshot](https://storage.googleapis.com/media.urbit.org/site/ecosystem/spotlight/uqbar-code.png)

"""

[featured-2]
title = "Tlon"
description = "The organization that created Urbit is now focused on building the best possible foundational user experiences on Urbit."
image="https://storage.googleapis.com/media.urbit.org/site/ecosystem/spotlight/tlonlogos.png"
content = """

Tlon is the organization responsible for the genesis of Urbit and now focused on creating lasting and effective tools for Urbit. Formerly rather quiet about its development activity, Tlon has recently launched a [beautiful public website](https://tlon.io) and is sharing more of its process in the new [Tlon public group](/groups/~nibset-napwyn/tlon-public).

![Screenshot](https://storage.googleapis.com/media.urbit.org/site/ecosystem/spotlight/tlonio.png)

"""

[featured-3]

title = "The Dream of Digital Homesteading"
image="https://storage.googleapis.com/media.urbit.org/site/ecosystem/spotlight/compact-thumb2.png"
description = "Compact Magazine's managing editor Geoff Shullenberger attended Assembly 2022 and tuned into both the event vibes and Urbit's technical aspirations."
content = """

Compact Magazine provides a clear-eyed view of both the social and technical visions of the Urbit community as well as the literary milieu around it.
![](https://storage.googleapis.com/media.urbit.org/site/ecosystem/spotlight/thedreamofdigitalhomesteading.png)

"""
+++


text:
# Stronghold Communication

This library enables strongholds on different devices and in different networks to communicate with each other.
The main basis for its functionality is the [rust-libp2p](https://github.com/libp2p/rust-libp2p) library, which is a system of protocols, specifications and libraries that enable the development of peer-to-peer network applications (https://libp2p.io/).

## Network Behaviour and Swarm

**module behaviour.rs:**

Stronghold-communication implements the `P2PNetworkBehaviour` for sending messages and reacting upon the outcome of the operation.
It combines multiple protocols of Libp2p:
- Multiplexing following the [Yamux specification](https://github.com/hashicorp/yamux/blob/master/spec.md)
- Noise: Encryption of the communication using the [Noise protocol](https://noiseprotocol.org/noise.html) with XX-Handshake
- Multicast DNS: Enable Peer Discovery in a local network
- Identify Protocol: Receive identifying information like the `PeerId` and listening addresses when connecting to a new peer.
- Request-Response Protocol: Allows sending direct request/response messages between Peers; it expects a response for each request

Upon creating a new instance, a transport is created and upgraded, and combined with the P2PNetworkBehaviour into a [ExpandedSwarm](https://docs.rs/libp2p/0.35.1/libp2p/swarm/struct.ExpandedSwarm.html). This Swarm is returned to the caller and serves as entry-point for all communication to other peers. Additional to the Libp2p methods of the `ExpandedSwarm`, it enables sending outbound messages, and manages the known peers. Incoming `P2PEvents` can be handled by polling from the swarm, e.g. via the `next` method.

## Communication Actor

**module actor.rs:**

The `Communication Actor` is using the [Riker Framwork](https://riker.rs/) to implement the actor pattern.
When creating a new `Communication Actor`, the actor creates a `P2PNetworkBehaviour` and continuously polls for events,
incoming requests are sent to the client actor that has to be provided in the `CommunicationConfig`.

All swarm interaction, and configuration of the `Communication Actor` is accomplished by sending the appropriate `CommunicationRequest` to it, for each `CommunicationRequest` a `CommunicationResults` is returned to the sender, this also allows using the [ask pattern](https://riker.rs/patterns/#ask).

### Firewall
The communication actor implements a firewall that checks the permission of each outgoing and incoming requests and drops them if the necessary permission has not been set. The required `ToPermissionVariants` trait for messages can be derived with the [communication-macros](communication-macros/README.md), this allows in case of enum Request types to accept specific variants while rejecting others.

branch_name: refs/heads/dev


text:
---
title: AGM Update
---

**The AGM will be held on Friday the 7th of February, at 19:30, in
  G/001.**

As previously mentioned, we will be having our AGM on Friday of week
5. The deadline for proposing constitutional amendments has now
passed, and one amendment was proposed: that we add the following to
the section "Officers":

> A Diplomat, whose role is outreach with companies and organisations
> that can help provide opportunities and resources to further our
> members and the society.

If this amendment passes, we would elect the Diplomat at the AGM,
pending ratification of the amendment by YUSU.

The AGM will be immediately followed by HackPub.

**To run or vote in elections you need to be a paid member of the
society!** You may, however, pay at the AGM (before running or
voting).

Full details of the positions up for election can be found in the
[previous post](/news/2014-01-22-agm.html), but to summarise:

Current committee positions (names in parentheses are IRC nicks):

 - **Chair:** Head of the society. *Currently done by Michael
     (barrucadu)*

 - **Secretary:** Administration. *Currently done by
     David (qlkzy)*

 - **Treasurer:** Finances & membership fees. *Currently done by
     Andrei (matzipan)*

 - **Crockery Officer:** Arranges socials, ensures the supply of
     crockery & cutlery at same. *Currently done by Lauren (lauren)*

 - **Society Crier:** Advertising and social media. *Currently done by
     Shivam (Speed\`)*

 - **Ordinary Member:** No specific responsibilities. *Can be held by
     any number of people*

If the 'Diplomat' amendment passes, we will also be electing a
Diplomat as mentioned above.

Any paid member can run for any position. You may pay at the AGM and
then run for and vote on positions.

You do not need to inform anyone prior to the AGM if you wish to run
for a position.

You may run for a position without being present, by emailing
<EMAIL_ADDRESS>before the start of the AGM with your name, the
position(s) for which you would like to run, and (optionally but
preferably) a short manifesto.

gha_language: Jinja


text:
# Developer Dashboard

[![Dependency Status](https://gemnasium.com/badges/github.com/skateman/dev-board.svg)](https://gemnasium.com/github.com/skateman/dev-board)
[![Docker Automated build](https://img.shields.io/docker/automated/skateman/dev-board.svg)](https://hub.docker.com/r/skateman/dev-board/)

The Developer Dashboard is a Rails application that displays open PRs for a preconfigured repository. It has been tailored for my specific needs, therefore, it might be not convenient for anyone else. However, feel free to open PRs or issues containing your idea how to make it better.

![screen shot 2017-02-27 at 17 49 29](https://cloud.githubusercontent.com/assets/1187051/23370483/1dbf0ab4-fd15-11e6-9c5b-0733a4516c55.png)

## Installation

### Docker container
The application is packed as an all-in-one [docker container](https://hub.docker.com/r/skateman/dev-board/), that can be started by the following command:

```sh
docker run -p 3000:3000 \
  -e SECRET_KEY_BASE="" \
  -e GITHUB_REPO=""     \
  -e GITHUB_USER=""     \
  -e GITHUB_PASS=""     \
  skateman/dev-board
```

The application is configured to listen on port 3000, but this can be [routed to any port](https://docs.docker.com/engine/reference/commandline/run/#/publish-or-expose-port--p---expose) on your local machine. The `SECRET_KEY_BASE` variable is required by Rails and its content has to be a random unique string, you can call `rake secret` from any rails application to generate one. The `GITHUB_` prefixed variables don't need any further explanation, you can generate personal access tokens [on your GitHub settings page](https://github.com/settings/tokens). It is possible to use the application without setting the login credentials, but note that GitHub has more strict [rate limits](https://developer.github.com/v3/#rate-limiting) for unauthorized users.

### Standalone
To run the application outside the container, you will require the following tools:
* Ruby v2.2.2 or newer
* All the dependencies of Rails v5.0.1
* Redis runnin on localhost

After checking out the repository, simply type `bin/setup` in the application's directory to set up all the dependencies. You will have to update the `config/secrets.yml` file with your GitHub credentials and with the `secret_key_base` that can be generated using `bin/rails secret`.

To start both the Rails application and the single-threaded Sidekiq worker, you can use the well known `bin/rails s` and `bin/bundle exec sidekiq` commands. If you don't want to bother with two commands, you can use [Foreman](http://ddollar.github.io/foreman/) by typing:
```sh
bin/bundle exec foreman start
```

Please note that when running outside a container, you will have to create the initial sidekiq job from a Rails console:

```ruby
FetchJob.perform_later
```

## Usage
Simply point your browser at http://localhost:3000. Depending on the repo you will have to wait a few minutes for the initial job to finish. The page is configured to refresh itself in every 120 seconds.

## Contributing
Bug reports and pull requests are welcome on GitHub at https://github.com/skateman/dev-board.

## License
The gem is available as open source under the terms of the MIT License.

repository: skateman/dev-board

gha_language: Ruby

repo_name: skateman/dev-board


text:
These routines allow modification of the mesh connectivity and insertion/deletion of elements.

Geometry-central is designed from the ground up to have good support for mesh mutation. The underlying `SurfaceMesh` data structure is index-based, with lazy expansion and deletion, so all operations run in (amortized) constant time with respect to the number of mesh elements, and usually do not incur any memory allocations. [Containers](containers.md) automatically update after mesh operations.

As much as possible, these routines will check for validity before executing and throw an exception if something isn't right. The `NGC_SAFETY_CHECKS` define disables this behavior for a modest increase in performance, but checks are enabled by default even in release builds.

Note that aggressive use of these routines may reduce a mesh from a _simplicial complex_ to a _$\Delta$-complex_. For instance, flipping enough edges in a mesh might create self-edges, which connect a vertex to itself. See the [$\Delta$-complex](delta_complex.md) section for details, and an explanation of why these complexes are important.

!!! note "General `SurfaceMesh`"

    Many of these operations could be defined for a general `SurfaceMesh`, but are currently only implemented on the `ManifoldSurfaceMesh`. Future releases of geometry-central will gradually port them over.

### Compressed mode

Internally, the halfedge mesh is represented by dense arrays of indices which are lazily expanded (see [interals](internals.md) for details). To support fast deletion operations, we simply mark elements as deleted, without re-packing the index space. We say that the mesh is _compressed_ if the index space is dense, with no such marked elements. When a mesh is not compressed, the `index` of a mesh element no longer serves as a proper enumeration from `[0,N)`, but merely as a unique ID.

There are two consequences to being non-compressed:

  - Some operations cannot be implemented efficiently/correctly (e.g., random access of the i'th vertex), as noted in the documentation. Calling such function will generally throw an error in Debug mode, but may fail silently in Release.
  - Storage space is wasted by deleted elements.

All meshes are compressed after construction, and only become non-compressed if the user performs an insertion or deletion operation. The `compress()` function can be called to re-index the elements of the mesh as a proper enumeration from `[0,N)`.

The `compress()` function invalidates pointers, and incurs an update of existing containers. As such, it is recommended to be called sporadically, after a sequence of operations is completed.

??? func "`#!cpp bool SurfaceMesh::isCompressed()`"

    Returns true if the mesh is compressed.

??? func "`#!cpp void SurfaceMesh::compress()`"

    Re-index the elements of the mesh to yield a dense enumeration. Invalidates all `Vertex`, `Edge` (etc) objects. All `VertexData<>`, `FaceData<>`, etc containers are automatically resized and re-indexed.

    Does nothing if the mesh is already compressed.

!!! note "Preserving notable elements"

    In some rare situations, you might want to manually keep track of a significant mesh elements (vertices, faces, etc) through a call to `compress()` (which invalidates all element references).

    One way to do this is to leverage the `MeshData<>` containers, which automatically stay valid through updates:

    ```cpp
    SurfaceMesh& mesh; // our mesh
    Vertex vA, vB; // two special vertices we want to keep track of

    // Label the special vertices
    VertexData<int> specialVerts(mesh, 0);
    specialVerts[vA] = 1;
    specialVerts[vB] = 2;

    // Compress the mesh
    // (invalidating the Vertex objects)
    mesh.compress();
    // specialVerts is automatically maintained through the compression

    // Find the interesting vertices by label
    for(Vertex v : mesh.vertices()) {
      if(specialVerts[v] == 1) vA = v;
      if(specialVerts[v] == 2) vB = v;
    }
    ```

    This is an intentionally simplistic example, but generally speaking the `MeshData<>` arrays can be used to track mesh elements and other data through a `compress()`.

## In-place modifications

These routines modify a mesh, but do not require inserting or deleting elements.

??? func "`#!cpp bool SurfaceMesh::flip(Edge e, bool preventSelfEdges = true)`"

    Flip an edge by rotating counter-clockwise.

    An edge cannot be combinatorially flipped if it is:

      - a boundary edge
      - incident on a degree-1 vertex.

    If `true` is passed as the optional argument `preventSelfEdges`, then the edge will also not be flipped if it would result in both endpoints of the edge becoming the same vertex.

    **Return:** true if the edge was actually flipped

## Insertions

These routines modify a mesh by inserting new elements. Elements (like `Vertex`) and containers (like `VertexData<>`) will remain valid through insertions and automatically resize themselves to accommodate the new elements. However, the mesh will no longer be [compressed](#compressed-mode).

Note that some operations my re-use existing elements to create their output. For instance, `splitEdge()` turns a single edge in to two; the input edge will be re-used as one of the two output edges, and data along that edge will be unchanged in any containers.

---

??? func "`#!cpp Halfedge ManifoldSurfaceMesh::insertVertexAlongEdge(Edge e)`"

    Adds a degree 2 vertex along an edge. Unlike `splitEdge()`, this _does not_ triangulate the adjacent faces; the degree of adjacent faces will be increased by 1. Works as expected on boundary edges.

    Returns a halfedge `he` along the newly created edge, which points in the same direction as `e.halfedge()`, and such that `he.vertex()` is the newly inserted vertex.

    Preserves canonical direction of edge.halfedge() for both halves of new edge. The original edge is repurposed as one of the two new edges (same for original halfedges).

??? func "`#!cpp Halfedge ManifoldSurfaceMesh::splitEdgeTriangular(Edge e)`"

    Inserts a vertex along an edge, and triangulates the adjacent faces. On a triangle mesh, the newly inserted vertex will be a degree 4 vertex.  Works as expected on boundary edges.

    Returns a halfedge `he` along the newly created edge, which points in the same direction as `e.halfedge()`, and such that `he.vertex()` is the newly inserted vertex.

    Preserves canonical direction of edge.halfedge() for both halves of new edge. The original edge is repurposed as one of the new edges (same for original halfedges).

??? func "`#!cpp Vertex ManifoldSurfaceMesh::insertVertex(Face f)`"

    Add vertex inside face and triangulate. Returns new vertex.

??? func "`#!cpp Halfedge connectVertices(Halfedge heA, Halfedge heB)`"

    Call to add an edge to a face, splitting it to two faces.

    Creates a new edge connecting `heA.vertex()` to `heB.vertex()`. The initial shared face will be repurposed as one of the two resulting faces.

    `heA` and `heB` must be distinct halfedges in the same face, and their vertices must not already be adjacent in that face.

    Returns new halfedge with `heA.vertex()` at tail, and `he.twin().face()` is the new face.

??? func "`#!cpp std::vector<Face> ManifoldSurfaceMesh::triangulate(Face face)`"

    Triangulate a face in the mesh, returning all of the resulting faces.

    One of the returned faces will be the input face, repurposed as a face in the triangulation.

## Deletions

These routines delete mesh elements. Elements (like `Vertex`) and containers (like `VertexData<>`) will remain valid through deletions. However, performing any deletion will cause the mesh to no longer be [compressed](#compressed-mode).

??? func "`#!cpp Vertex ManifoldSurfaceMesh::collapseEdgeTriangular(Edge e)`"

    Collapse an edge. Returns the vertex adjacent to that edge which still exists. Returns Vertex() if not
    collapsible.

??? func "`#!cpp bool ManifoldSurfaceMesh::removeFaceAlongBoundary(Face f)`"

    Remove a face which is adjacent to the boundary of the mesh (along with its edge on the boundary).
    Face must have exactly one boundary edge. Returns true if could remove.

repository: nmwsharp/geometry-central

repo_name: nmwsharp/geometry-central


text:
# FindMe

[Check out FindMe on the iOS App Store!](https://itunes.apple.com/us/app/findme-geolocation-app/id1274629614?ls=1&mt=8)

## Description
Tired of trying to find your friends while they don't text you back? FindMe
helps you find your friends without any effort. The FindMe app is a useful tracking app
designed for users of all ages.

## Info
FindMe is a geolocation app built on Google Maps API, with a Firebase backend.

## Demo

![Findme gif](findme.gif)

## Project Distribution
- William Tong: Firebase database, Facebook + email login, friend/request logic, Google Maps API, UI
- Jordi Turner: Google Maps API, Map View UI

## App Details

**Functionality:**

- [X] Sign up, log in, and log out of the FindMe app.
- [X] Login with Facebook account.
- [X] Persisted user across app restarts.
- [X] See the user's location on a Google Maps SDK map.
- [X] Share user locations with a friend.
- [X] Reset the map to user/friend locations.
- [X] Allow user to turn off all location sharing.
- [X] Select three map modes: split screen, shared screen, solo screen.
- [X] Find friends with app installed.
- [X] Display when friends last active

**APIs**
- Google Maps
- Firebase
- Facebook

**Model Classes**
- Users: name, email, coordinates, friends, requests, tracking, follow

## Links

Tab bar icons from https://icons8.com

## License

    Copyright 2017 William Tong, Jordi E. Turner

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.

repository: FindMeCP/FindMe

gha_language: Objective-C

repo_name: FindMeCP/FindMe


text:
# Run Anthos on different cloud providers

With Anthos Multi-Cloud, you can create Kubernetes clusters in both AWS and Azure cloud environments. Anthos clusters integrate with cloud provider specific resources such as load balancers and persistent storage.

Checkout the different folders here for a Terraform based quickstart for setting up GKE on AWS and Azure. For more information, read the official documentation for [Anthos Multi-Cloud](https://cloud.google.com/anthos/clusters/docs/multi-cloud).

- [Run GKE on AWS](/anthos-multi-cloud/AWS)
- [Run GKE on Azure](/anthos-multi-cloud/Azure)
- [Customize logs Fluent Bit](https://github.com/anthos-multi-cloud/customize-logs-fluentbit): This directory contains files to deploy a Fluent Bit DaemonSet on an Anthos Multi-Cloud cluster.

repository: GoogleCloudPlatform/anthos-samples

gha_language: HCL

repo_name: GoogleCloudPlatform/anthos-samples


text:
---
id: version-3.0.0-DummySTOFactory
title: DummySTOFactory
original_id: DummySTOFactory
---

# Factory for deploying DummySTO module \(DummySTOFactory.sol\)

View Source: [contracts/mocks/Dummy/DummySTOFactory.sol](https://github.com/PolymathNetwork/polymath-core/tree/096ba240a927c98e1f1a182d2efee7c4c4c1dfc5/contracts/mocks/Dummy/DummySTOFactory.sol)

**↗ Extends:** [**UpgradableModuleFactory**](https://github.com/PolymathNetwork/polymath-core/tree/096ba240a927c98e1f1a182d2efee7c4c4c1dfc5/docs/api/UpgradableModuleFactory.md) **↘ Derived Contracts:** [**MockFactory**](https://github.com/PolymathNetwork/polymath-core/tree/096ba240a927c98e1f1a182d2efee7c4c4c1dfc5/docs/api/MockFactory.md)**,** [**TestSTOFactory**](https://github.com/PolymathNetwork/polymath-core/tree/096ba240a927c98e1f1a182d2efee7c4c4c1dfc5/docs/api/TestSTOFactory.md)

**DummySTOFactory**

## Functions

* [\(uint256 \_setupCost, address \_logicContract, address \_polymathRegistry, bool \_isCostInPoly\)](dummystofactory.md)
* [deploy\(bytes \_data\)](dummystofactory.md#deploy)

Constructor

```javascript
function (uint256 _setupCost, address _logicContract, address _polymathRegistry, bool _isCostInPoly) public nonpayable UpgradableModuleFactory
```

**Arguments**

| Name | Type | Description |
| :--- | :--- | :--- |
| \_setupCost | uint256 | Setup cost of the module |
| \_logicContract | address | Contract address that contains the logic related to `description` |
| \_polymathRegistry | address | Address of the Polymath registry |
| \_isCostInPoly | bool | true = cost in Poly, false = USD |

### deploy

⤾ overrides [IModuleFactory.deploy](https://github.com/PolymathNetwork/polymath-core/tree/096ba240a927c98e1f1a182d2efee7c4c4c1dfc5/docs/api/IModuleFactory.md#deploy)

Used to launch the Module with the help of factory

```javascript
function deploy(bytes _data) external nonpayable
returns(address)
```

**Returns**

address Contract address of the Module

**Arguments**

| Name | Type | Description |
| :--- | :--- | :--- |
| \_data | bytes | Data used for the intialization of the module factory variables |

repository: PolymathNetwork/polymath-core

repo_name: PolymathNetwork/polymath-core


text:
# ClickHouse [![run-tests](https://github.com/ClickHouse/clickhouse-go/actions/workflows/run-tests.yml/badge.svg?branch=v2)](https://github.com/ClickHouse/clickhouse-go/actions/workflows/run-tests.yml) [![Go Reference](https://pkg.go.dev/badge/github.com/ClickHouse/clickhouse-go/v2.svg)](https://pkg.go.dev/github.com/ClickHouse/clickhouse-go/v2)

Golang SQL database driver for [ClickHouse](https://clickhouse.com/).

## Versions

There are two version of this driver, v1 and v2, available as separate branches.

**v1 is now in a state of a maintenance - we will only accept PRs for bug and security fixes.**

Users should use v2 which is production ready and [significantly faster than v1](#benchmark).

## Supported ClickHouse Versions

The driver is tested against the currently [supported versions](https://github.com/ClickHouse/ClickHouse/blob/master/SECURITY.md) of ClickHouse

## Key features

* Uses native ClickHouse TCP client-server protocol
* Compatibility with [`database/sql`](#std-databasesql-interface) ([slower](#benchmark) than [native interface](#native-interface)!)
* Marshal rows into structs ([ScanStruct](tests/scan_struct_test.go), [Select](examples/native/scan_struct/main.go))
* Unmarshal struct to row ([AppendStruct](benchmark/v2/write-native-struct/main.go))
* Connection pool
* Failover and load balancing
* [Bulk write support](examples/native/batch/main.go) (for `database/sql` [use](examples/std/batch/main.go) `begin->prepare->(in loop exec)->commit`)
* [AsyncInsert](benchmark/v2/write-async/main.go)
* Named and numeric placeholders support
* LZ4 compression support
* External data

Support for the ClickHouse protocol advanced features using `Context`:

* Query ID
* Quota Key
* Settings
* OpenTelemetry
* Execution events:
	* Logs
	* Progress
	* Profile info
	* Profile events

# `database/sql` interface

## OpenDB

```go
conn := clickhouse.OpenDB(&clickhouse.Options{
	Addr: []string{"<IP_ADDRESS>:9999"},
	Auth: clickhouse.Auth{
		Database: "default",
		Username: "default",
		Password: "",
	},
	TLS: &tls.Config{
		InsecureSkipVerify: true,
	},
	Settings: clickhouse.Settings{
		"max_execution_time": 60,
	},
	DialTimeout: 5 * time.Second,
	Compression: &clickhouse.Compression{
		clickhouse.CompressionLZ4,
	},
	Debug: true,
})
conn.SetMaxIdleConns(5)
conn.SetMaxOpenConns(10)
conn.SetConnMaxLifetime(time.Hour)
```
## DSN

* hosts  - comma-separated list of single address hosts for load-balancing and failover
* username/password - auth credentials
* database - select the current default database
* dial_timeout -  a duration string is a possibly signed sequence of decimal numbers, each with optional fraction and a unit suffix such as "300ms", "1s". Valid time units are "ms", "s", "m".
* connection_open_strategy - random/in_order (default random).
    * round-robin      - choose a round-robin server from the set
    * in_order    - first live server is chosen in specified order
* debug - enable debug output (boolean value)
* compress - enable lz4 compression (boolean value)

SSL/TLS parameters:

* secure - establish secure connection (default is false)
* skip_verify - skip certificate verification (default is false)

Example:

```sh
clickhouse://username:password@host1:9000,host2:9000/database?dial_timeout=200ms&max_execution_time=60
```

## Benchmark

| [V1 (READ)](benchmark/v1/read/main.go) | [V2 (READ) std](benchmark/v2/read/main.go) | [V2 (READ) native](benchmark/v2/read-native/main.go) |
| -------------------------------------- | ------------------------------------------ | ---------------------------------------------------- |
| 1.218s                                 | 924.390ms                                  | 675.721ms                                            |

| [V1 (WRITE)](benchmark/v1/write/main.go) | [V2 (WRITE) std](benchmark/v2/write/main.go) | [V2 (WRITE) native](benchmark/v2/write-native/main.go) | [V2 (WRITE) by column](benchmark/v2/write-native-columnar/main.go) |
| ---------------------------------------- | -------------------------------------------- | ------------------------------------------------------ | ------------------------------------------------------------------ |
| 1.899s                                   | 1.177s                                       | 699.203ms                                              | 661.973ms                                                          |

## Install

```sh
go get -u github.com/ClickHouse/clickhouse-go/v2
```

## Examples

### native interface

* [batch](examples/native/batch/main.go)
* [async insert](examples/native/write-async)
* [batch struct](examples/native/write-struct/main.go)
* [columnar](examples/native/write-columnar/main.go)
* [scan struct](examples/native/scan_struct/main.go)
* [bind params](examples/native/bind/main.go)

### std `database/sql` interface

* [batch](examples/std/batch/main.go)
* [async insert](examples/std/write-async)
* [open db](examples/std/open_db/main.go)
* [bind params](examples/std/bind/main.go)

#### A Note on TLS/SSL

At a low level all driver connect methods (DSN/OpenDB/Open) will use the [Go tls package](https://pkg.go.dev/crypto/tls) to establish a secure connection. The driver knows to use TLS if the Options struct contains a non-nil tls.Config pointer.

Setting secure in the DSN creates a minimal tls.Config struct with only the InsecureSkipVerify field set (either true or false).  It is equivalent to this code:

```go
conn := clickhouse.OpenDB(&clickhouse.Options{
	...
    TLS: &tls.Config{
            InsecureSkipVerify: false
	}
	...
    })
```
This minimal tls.Config is normally all that is necessary to connect to the secure native port (normally 9440) on a ClickHouse server. If the ClickHouse server does not have a valid certificate (expired, wrong host name, not signed by a publicly recognized root Certificate Authority), InsecureSkipVerify can be to `true`, but that is strongly discouraged.

If additional TLS parameters are necessary the application code should set the desired fields in the tls.Config struct. That can include specific cipher suites, forcing a particular TLS version (like 1.2 or 1.3), adding an internal CA certificate chain, adding a client certificate (and private key) if required by the ClickHouse server, and most of the other options that come with a more specialized security setup.

## Third-party alternatives

* Database drivers:
	* [mailru/go-clickhouse](https://github.com/mailru/go-clickhouse) (uses the HTTP protocol)
	* [uptrace/go-clickhouse](https://github.com/uptrace/go-clickhouse) (uses the native TCP protocol with `database/sql`-like API)
	* Drivers with columnar interface:
		* [vahid-sohrabloo/chconn](https://github.com/vahid-sohrabloo/chconn)
		* [go-faster/ch](https://github.com/go-faster/ch)

* Insert collectors:
	* [KittenHouse](https://github.com/YuriyNasretdinov/kittenhouse)
	* [nikepan/clickhouse-bulk](https://github.com/nikepan/clickhouse-bulk)

repository: chapsuk/miga

repo_name: chapsuk/miga


text:
# Contributing

Pull requests are welcome!

1) Fork, then clone the repo:

    git clone git@github.com:your-username/native-script-starter.git

Set up your machine:

    yarn

Make your change. Add tests for your change. Make the tests pass:

    npm run test

Push to your fork and [submit a pull request][pr].

[pr]: https://github.com/sturdynut/native-script-starter/compare/

I will review it as soon as I can and provide any feedback if necessary.  Thanks!

repository: sturdynut/react-native-starter

repo_name: sturdynut/react-native-starter


text:
# Changelog

Notable changes to this project are documented in this file. The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [Unreleased]

Breaking changes:

New features:

Bugfixes:

Other improvements:

## [v5.0.0](https://github.com/purescript/purescript-exceptions/releases/tag/v5.0.0) - 2021-02-26

Breaking changes:
- Added support for PureScript 0.14 and dropped support for all previous versions (#36)

New features:

Bugfixes:
- Fixed `catchException` example to use `Console.logShow` instead of `print` (#31)

Other improvements:
- Migrated CI to GitHub Actions and updated installation instructions to use Spago (#37)
- Added a CHANGELOG.md file and pull request template (#38, #39)
- Removed unnecessary type variable from `try` docstring (#33)

## [v4.0.0](https://github.com/purescript/purescript-exceptions/releases/tag/v4.0.0) - 2018-05-23

Updated for PureScript 0.12

## [v3.1.0](https://github.com/purescript/purescript-exceptions/releases/tag/v3.1.0) - 2017-07-27

Add `name` function to extract the name of an `Error` (@KtorZ)

## [v3.0.0](https://github.com/purescript/purescript-exceptions/releases/tag/v3.0.0) - 2017-03-26

- Updated for PureScript 0.11
- The `err :: EXCEPTION` row entry has been corrected to `exception :: EXCEPTION`

## [v2.0.0](https://github.com/purescript/purescript-exceptions/releases/tag/v2.0.0) - 2016-10-07

- Updated dependencies

## [v1.0.0](https://github.com/purescript/purescript-exceptions/releases/tag/v1.0.0) - 2016-06-01

This release is intended for the PureScript 0.9.1 compiler and newer.

**Note**: The v1.0.0 tag is not meant to indicate the library is “finished”, the core libraries are all being bumped to this for the 0.9 compiler release so as to use semver more correctly.

## [v1.0.0-rc.1](https://github.com/purescript/purescript-exceptions/releases/tag/v1.0.0-rc.1) - 2016-03-16

- Release candidate for the psc 0.8+ core libraries

## [v0.3.4](https://github.com/purescript/purescript-exceptions/releases/tag/v0.3.4) - 2015-12-23

- Add `stack` error message accessor (@hdgarrood)

## [v0.3.3](https://github.com/purescript/purescript-exceptions/releases/tag/v0.3.3) - 2015-12-11

Add `throw` (@hdgarrood)

## [v0.3.2](https://github.com/purescript/purescript-exceptions/releases/tag/v0.3.2) - 2015-11-20

- Removed unused import (@tfausak)

## [v0.3.1](https://github.com/purescript/purescript-exceptions/releases/tag/v0.3.1) - 2015-11-13

Added `Unsafe` module (@hdgarrood)

## [v0.3.0](https://github.com/purescript/purescript-exceptions/releases/tag/v0.3.0) - 2015-06-30

This release works with versions 0.7.\* of the PureScript compiler. It will not work with older versions. If you are using an older version, you should require an older, compatible version of this library.

## [v0.3.0-rc.1](https://github.com/purescript/purescript-exceptions/releases/tag/v0.3.0-rc.1) - 2015-06-09

Initial release candidate of the library intended for the 0.7 compiler.

## [v0.2.3](https://github.com/purescript/purescript-exceptions/releases/tag/v0.2.3) - 2015-03-20

Updated docs

## [v0.2.2](https://github.com/purescript/purescript-exceptions/releases/tag/v0.2.2) - 2014-11-16

Improvements to FFI code (@davidchambers)

## [v0.2.1](https://github.com/purescript/purescript-exceptions/releases/tag/v0.2.1) - 2014-09-04

Handle errors from other JS domains (@joneshf)

## [v0.2.0](https://github.com/purescript/purescript-exceptions/releases/tag/v0.2.0) - 2014-08-07

## [v0.1.0](https://github.com/purescript/purescript-exceptions/releases/tag/v0.1.0) - 2014-04-25

repository: dhinojosa/language-matrix

gha_language: Java

repo_name: dhinojosa/language-matrix


text:
<div align="center">

## Noctis

![Noctis Screenshot](https://github.com/liviuschera/noctis/raw/master/images/noctis.png)

## Noctis Azureus

![Noctis Screenshot](https://github.com/liviuschera/noctis/raw/master/images/noctisAzureus.png)

## Noctis Lux

![Noctis Screenshot](images/noctisLux.png)

</div>

Noctis is a colection of light & dark themes with a well balanced blend of warm and cold medium contrast colors.

The theme is designed to:

-  be easy on the eyes thus reducing the eye strain
-  give semantic meaning to theme's colors

Noctis comes in five versions. Four are dark and one is light.

The background of the three dark variants is a very saturated very dark cold bluish cyan. The background of the fourth version is a very saturated very dark cold azure. Blue is a cool calming color that shows creativity and intelligence and has a calming effect on the psyche.

The light's theme background is a very saturated very light warm orange. Orange can increase oxygen supply to the brain to produce an invigorating effect.

## Supported Languages

-  C/C++
-  C#
-  Clojure
-  CoffeeScript
-  CSS
   -  Sass/SCSS
-  Go
-  Groovy
-  HTML
   -  EJS
   -  Handlebars
   -  Pug/Jade
-  Java
-  JavaScript
   -  JSON
   -  React/JSX
   -  Typescript/TSX
-  Lua (requires [Lua Plus](https://marketplace.visualstudio.com/items?itemName=jep-a.lua-plus) extension)
-  Markdown
-  PHP
   -  Laravel Blade
-  PowerShell
-  Python
-  R
-  Ruby
-  Rust
-  Scala (requires [Scala Syntax](https://marketplace.visualstudio.com/items?itemName=scala-lang.scala) extension) ← **NEW**
-  Visual Basic

I plan on adding support for new languages in the upcomming releases. Please feel free to open an issue if you'd like a new language supported or if you think something is off.

## **Font** used in the screenshots

The font in the screenshots are actually 2 fonts glued together with [Custom CSS](https://marketplace.visualstudio.com/items?itemName=be5invis.vscode-custom-css). For normal style I used [Hasklig](https://github.com/i-tu/Hasklig) and for italics [Cartograph Mono CF](http://connary.com/cartograph.html).
I think there is a beautiful synergy between the two fonts and they intertwine naturally together.

## Syntax colors

The color names were matched to one of the following main color hues: Red, Yellow, Green, Blue, Brown and Grey using the excelent online tools [Color Name & Hue](http://www.color-blindness.com/color-name-hue/) and [Name that Color](http://chir.ag/projects/name-that-color).

| Color           | Hue    | Hex Code                                                           | Used for:                                      |
| --------------- | ------ | ------------------------------------------------------------------ | ---------------------------------------------- |
| Eucalyptus      | Green  | ![#49e9a6](https://placehold.it/15/49e9a6/000000?text=+) `#49e9a6` | Strings                                        |
| Mountain Meadow | Green  | ![#16b673](https://placehold.it/15/16b673/000000?text=+) `#16b673` | Interpolated Strings                           |
| Horizon         | Blue   | ![#5b858b](https://placehold.it/15/5b858b/000000?text=+) `#5b858b` | Comments                                       |
| Eastern Blue    | Blue   | ![#16a3b6](https://placehold.it/15/16a3b6/000000?text=+) `#16a3b6` | Function Calls                                 |
| Turcoise        | Blue   | ![#49d6e9](https://placehold.it/15/49d6e9/000000?text=+) `#49d6e9` | Method Calls                                   |
| Dodger Blue     | Blue   | ![#33b1ff](https://placehold.it/15/33b1ff/000000?text=+) `#33b1ff` | Code that needs to stand out                   |
| Cornflower Blue | Blue   | ![#7060eb](https://placehold.it/15/7060eb/000000?text=+) `#7060eb` | Numbers & Booleans                             |
| Pale Violet Red | Red    | ![#df769b](https://placehold.it/15/df769b/000000?text=+) `#df769b` | Keywords & Operators                           |
| Burnt Sienna    | Brown  | ![#e97749](https://placehold.it/15/e97749/000000?text=+) `#e97749` | Function & Variable Declaration, Tags & `this` |
| Buddha Gold     | Yellow | ![#cc9900](https://placehold.it/15/cc9900/000000?text=+) `#cc9900` | Attributes, Constants & Type annotations       |
| Gold Sand       | Yellow | ![#e4b781](https://placehold.it/15/e4b781/000000?text=+) `#e4b781` | Variables & Parameters                         |
| Desert Sand     | Brown  | ![#edc9af](https://placehold.it/15/edc9af/000000?text=+) `#edc9af` | DOM Objects                                    |

## Installation

Noctis can be installed by clicking on Ctrl + Shift + X on Windows or ⇧ + ⌘ + X on Mac and then searching for "Noctis".

## Credits

This theme was inspired by the themes VS Dark+, Solarized, Vue, Cobalt2, One Dark, Dracula and many others.

repository: ahmadawais/noctis

repo_name: ahmadawais/noctis


text:
# Layout

The application lists a number of components with dependencies between one
another. All components are located under `src/components/` and are composed of
the following:

- `index.js`
  React code implementing the logic of said component.
- `styles.js`
  React-Jss code applied to the component.
- `README.md` *optional*
  An optional Markdown documentation to be displayed in the styleguide.

The root element is `<Application>`. Its role is to instanciate the UI layout
corresponding to the currently applicable open mode.

- Hidden: no UI
- `<Teaser>`: minimized
- `<Chatbox>`: fully opened, dialog-ready

Once opened, the chatbox renders 3 main sections: `<Header>`, `<Dialog>` (body)
and `<Footer>`.

Following headings briefly describe each of these 3 sections. For more
information, read the source, as well as the documentation for each component.

## Header

The header implements a fixed (top) section of the application. It holds a
number of clickable actions as well has the optional tab bar `<Tabs>`and banner
`<Banner>`.

## Body

The body lists all current dialog bubbles (further referenced to as
*interactions*) through the `<Interaction>` component.

The body of the application also implements a collection of helpers all
available through the `window.dydu` object in the context of a browser.

Lastly, the body component also serves as anchor for the potential prompts.
Think of them as modal content, transient and dismissable.

## Footer

Akin to the header, the footer also holds a number of clickable actions in a
fixed (bottom) section. However the footer also implements the `<Input` field.