text:
# Data

## Case data

- `CaseData_Alpha_UK.csv`

 Data of sequenced samples retrieved from GISAID. Samples with collection date up to November 11th, 2020, submitted by December 31, 2020.

- `CaseData_COVID-19_Wuhan.csv`

 Data of early COVID-19 cases in Wuhan from (Pekar et al., 2022); personal communication.

## Estimates of emergence
- `Emergence_Czuppon2021updated.csv`

 Emergence estimates from (Czuppon et al., 2021), from running the simulations using R=1.9 and a negative binomial distribution for the generation of secondary cases.

- `Emergence_Hill2022.csv`

 tMRCA estimates from (Hill et al., 2021); personal communication.

- `Emergence_Pekar2022.csv`

 Emergence estimates from (Pekar et al., 2022); personal communication.

## References
Czuppon P, Schertzer E, Blanquart F and Débarre F (2021). “The Stochastic Dynamics of Early Epidemics: Probability of Establishment, Initial Growth Rate, and Infection Cluster Size at First Detection.” Journal of The Royal Society Interface 18 (184): 20210575. 10.1098/rsif.2021.0575.

Hill V, Du Plessis L, Peacock TP, Aggarwal D, Colquhoun R, Carabelli AM, Ellaby N et al. (2022). “The Origins and Molecular Evolution of SARS-CoV-2 Lineage B.1.1.7 in the UK.” Virus Evolution, August, veac080. DOI: 10.1093/ve/veac080.

Khare S, Gurry C, Freitas L, Schultz MB, Bach G, Diallo A, Akite N et al. (2021). “GISAID’s Role in Pandemic Response.” China CDC Weekly 3 (49): 1049–51. DOI: 10.46234/ccdcw2021.255.

Pekar JE, Magee A, Parker E, Moshiri N, Izhikevich K, Havens JL, Gangavarapu K, et al. (2022). “The Molecular Epidemiology of Multiple Zoonotic Origins of SARS-CoV-2.” Science, July, eabp8337. DOI: 10.1126/science.abp8337.

repository: sjijon/estimate-emergence-from-data

repo_name: sjijon/estimate-emergence-from-data


text:
# vue-ssr-template

Simple template for a Vue app with Server-Side-Rendering (SSR) enabled

## Getting Started

```bash
npm install
npm run build
npm run serve
```

Then load http://localhost:8080 in your browser.

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# upcScanner

A UPC scanner app that scans upc codes to check if product exists in database

## Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a live system.

Other parts of this project:

[upc-server](https://github.com/eyao06/upc-server)

[upc-website](https://github.com/eyao06/upc-website)

### Prerequisites

* Latest version of npm
* A computer (I used Windows)
* A Android device with 6.0 or higher
* Make sure your Android device has USB Debug is on
* MongoDB (Database)
* Express
* React and React-Native
* Node.js (Most Current Version)

### Installing

* Download project
* Extract project
* Make sure to run server and database (Go to [upc-server](https://github.com/eyao06/upc-server) project for further instructions)
* Open command line in project directory
* Install dependencies
```
npm install
```
*	Change ipAddress to your localhosts IPv4 Address in file (upcScanner/app/redux.js) line: 4
```
IPv4 Address can be found via command line with the command ipconfig
```
* Replace the old IP Address with the one just found
*	Plug android device with Android OS 6.0 or higher to computer
*	Make sure USB Debugging is on
* Run application
```
react-native run-android
```
*	Make sure android is plugged and connected to the computer
*	Make sure the USB debugger is on
*	Try cleaning the gradlew
```
cd android
gradlew clean
cd ..
```
*	Or try uninstall any previous versions of the application
*	Then try running the application again
* Once the app is running you can scan UPC codes
* If the product exists in database a message would pop up saying that it exists
* Otherwise it will say it does not

## License

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


text:
---
title: MacBook, MissingSync and Vodafone 3G USB stick
author: denish
layout: post
permalink: /2009/01/macbook-missingsync-and-vodafone-3g-usb-stick/
categories:
  - Blog Entries
tags:
  - MacBook
  - Mobile Broadband
  - Windows Mobile
---
I’ve been using a MacBook for a couple of years now and really like. However, one of the downsides is that I can’t simply sync with my HTC TyTn II mobile running Windows Mobile 6 in the same way that you can with a PC running Windows.

There are a couple of apps out there that bridge the gap and the one I’ve been using for most of that time is [MissingSync][1]. This works pretty well and uses the Mac SyncServices to synchronise with iCal, Mail, Entourage, Folders, [Yojimbo][2], music, photos, videos, installing apps and setting the time. So all the good stuff that you’d like it to do.

It’s not as seemless as using ActiveSync, but it works pretty well (I regularly get iCal/MissingSync conflicts and errors in syncing which I rarely got with ActiveSync on the PC, but they’re all manageable).

Then suddenly a month ago or so, I couldn’t sync via USB any more. I tried upgrading to the latest version of MissingSync and contacted their technical support and they suggested switching off various features such as Advanced Networking on the phone, but none of this worked. I could sync via bluetooth (but bluetooth on my MacBook disappears sporadically&mbar;due to old age??), but the USB connection wouldn’t work.

Normally when syncing, you get a transparent panel that appears on the MacBook screen and then the first of four blobs appears. When the second one appears, there’s a message to log in to the phone, so you type in your password (assuming you’ve set one) and then blobs three and four appear, then it syncs.

In my case, the first blob appeared and then it timed out. Looking at the MissingSync log, I’d see something like:

1/9/09 19:21:39  Monitor:  Connection status from 0 to 135
1/9/09 19:21:41  Monitor:  Connection status from 135 to 135
1/9/09 19:22:12  Monitor:  setUICallback
1/9/09 19:22:12  MSUI:  setMonCallback
1/9/09 19:22:23  Monitor:  Connection Failed.  Telling MSUI
1/9/09 19:22:23  Monitor:  makeSureUIAppIsRunning
1/9/09 19:22:23  MSUI:  Connection Failed for USB RNDIS
1/9/09 19:23:09  Monitor:  Listener: closeCurrentDeviceConnection 1, state=1
1/9/09 19:23:09  Monitor:  forgetDevice  rraServer:0
1/9/09 19:23:09  Monitor:  Connection status from 0 to 0
1/9/09 19:23:09  MSUI:  disconnect

To cut a long story short, I eventually worked out that the important thing I had changed was installing the software for my new [Vodafone mobile broadband][3] USB modem. This installs a new network service that you can see in the network settings (mine is called Vodafone K3520). I’ve also got (in addition to the basic ones) two installed by [Parallels Desktop][4] (Parallels Shared Networking Adapter and Parallels Host-Only Networking Adapter). These don’t affect syncing with Missing Sync.

As a test, I removed the Vodafone K3520 from the network preferences and then tried to sync and it worked fine. I synced several times before I needed to use my mobile broadband modem again. To get that working again, I just reinstalled the software from the USB stick. After using the broadband several times during the day, I tried syncing again&mbar;no luck! So I went back to the Network Preferences, selected the Vodafone K3520 and selected “make service inactive” (you then have to press the Apply button too to make it effective). I then tried syncing again and it worked fine.

So now I can use my mobile broadband and sync my TyTn II albeit by disabling and re-enabling the Vodafone network service.

**Update:** Just to be sure of my facts for this blog posting, I downloaded and installed the latest version of [Vodafone Mobile Connect][5] (version <IP_ADDRESS> at the time of writing). It installed another couple of network services called DIAG and PCUI). I don’t quite understand what’s going on here because I’m sure I had these originally and then when I reinstalled from my Vodafone stick I only got the K3520 mentioned above. Now I have 3! But when I connect to mobile broadband, only the K3520 is enabled, DIAG and PCUI say not connected.

But the really good news is that now, I no longer need to disable the K3520 service. I’ve just synced again without incident and am finishing this post using the mobile broadband. (I couldn’t do both at the same time because the stick is too wide to allow a second USB device to be plugged in along side.)

 [1]: http://www.markspace.com/products/windowsmobile/mac/windows-mobile-sync-software.html
 [2]: http://www.barebones.com/products/Yojimbo/
 [3]: http://shop.vodafone.co.uk/shop/mobile-broadband/data-devices/
 [4]: http://www.parallels.com/
 [5]: http://www.business.vodafone.com/site/bus/public/enuk/support/10_productsupport/laptop_connectivity/40_software/software/10_latest/p_software.jsp


text:
# BluetoothConnected

```text
material-4/Device/BluetoothConnected
```

```text
include('material-4/Device/BluetoothConnected')
```

| Illustration | BluetoothConnected |
| :---: | :---: |
| ![illustration for Illustration](../../material-4/Device/BluetoothConnected.png) | ![illustration for BluetoothConnected](../../material-4/Device/BluetoothConnected.Local.png) |

## Sprites
The item provides the following sriptes:

- `<$BluetoothConnectedXs>`
- `<$BluetoothConnectedSm>`
- `<$BluetoothConnectedMd>`
- `<$BluetoothConnectedLg>`

## BluetoothConnected

### Load remotely
```plantuml
@startuml
' configures the library
!global $LIB_BASE_LOCATION="https://raw.githubusercontent.com/tmorin/plantuml-libs/master/distribution"

' loads the library's bootstrap
!include $LIB_BASE_LOCATION/bootstrap.puml

' loads the package bootstrap
include('material-4/bootstrap')

' loads the Item which embeds the element BluetoothConnected
include('material-4/Device/BluetoothConnected')

' renders the element
BluetoothConnected('BluetoothConnected', 'Bluetooth Connected', 'an optional tech label', 'an optional description')
@enduml
```

### Load locally
```plantuml
@startuml
' configures the library
!global $INCLUSION_MODE="local"
!global $LIB_BASE_LOCATION="../.."

' loads the library's bootstrap
!include $LIB_BASE_LOCATION/bootstrap.puml

' loads the package bootstrap
include('material-4/bootstrap')

' loads the Item which embeds the element BluetoothConnected
include('material-4/Device/BluetoothConnected')

' renders the element
BluetoothConnected('BluetoothConnected', 'Bluetooth Connected', 'an optional tech label', 'an optional description')
@enduml
```

repository: tmorin/plantuml-libs

gha_language: TypeScript

gha_license_id: MIT

repo_name: tmorin/plantuml-libs


text:
# fastapi-svelte

Simple Combination of FastAPI and Svelte.

## Setup Instructions:

1. Clone this Repo
2. ```pip install -r requirements.txt``` to install python dependencies.
3. Run ```npx degit sveltejs/template client``` inside root directory to create Svelte app inside ```client``` directory.
4. Inside ```client``` directory run ```npm install```

## Local Development:

**Build Svelte app and watch for changes:**```npm run dev``` (run inside client folder)

**Run Uvicorn server for FastAPI app with hotreloading:** ```uvicorn main:app --reload```

repository: pablokan/fastapi-svelte

branch_name: refs/heads/main

repo_name: pablokan/fastapi-svelte


text:
---
layout: docs
comment: no
header: true
seotitle: Annotation Lab | John Snow Labs
title: NLP Models Hub
permalink: /docs/en/alab/models_hub
key: docs-training
modify_date: "2021-06-23"
use_language_switcher: "Python-Scala"
show_nav: true
sidebar:
    nav: annotation-lab
---

The Annotation Lab 1.8.0 offers a tight integration with [NLP Models Hub](https://nlp.johnsnowlabs.com/models). Any compatible NER model and Embeddings can be downloaded and made available to the Annotation Lab users for preannotations either from within the application or via manual upload.

Models Hub page can be accessed via the left navigation menu by users in the UserAdmins group.

The Models Hub page has three tabs that hold information about models and embeddings.

## Models Hub Tab
This tab lists all pretrained NER models and embeddings from NLP Models Hub which are compatible with Spark NLP 2.7.5 and which are defined for English language. By selecting one or multiple items from the grid view, users can download them to the Annotation Lab. The licensed/Healthcare models and embeddings are available to download only when a valid license is uploaded.

One restriction that we impose on models download/upload relates to the available disk space. Any model download requires that the double of its size is available on the local storage. If not enough space is available the download cannot proceed.

Disk usage view, search, and filter features are available on the upper section of the Models Hub page.

## Available Models Tab
All the models available in the Annotation Lab are listed in this tab. The models are either trained within the Annotation Lab, uploaded to Annotation Lab by admin users, or downloaded from NLP Models Hub. General information about the models like labels/categories and the source (downloaded or trained or uploaded) of the model can be viewed. It is possible to delete any model or redownload failed ones by using the overflow menu on the top right corner of each model.

## Available Embeddings Tab
This tab lists all embeddings available to the Annotation Lab together with information on their source and date of upload/download. Like models, any compatible embeddings can be downloaded from NLP Models Hub. By default, glove_100d embeddings are included in the deployment.

## Custom Models/Embeddings Upload

Custom NER models or embeddings can be uploaded using the Upload button present in the top right corner of the page. The labels predicted by the uploaded NER model need to be specified using the Model upload form.

The models& embeddings to upload need to be Spark NLP compatible.

All available models are listed in the Spark NLP Pipeline Config on the Setup Page of any project and are ready to be included in the Labeling Config for preannotation.

repository: DejianYang/spark-nlp

repo_name: DejianYang/spark-nlp


text:
# nbresuse

![Screenshot](screenshot.png)

NB Resource Usage (nbresuse) is a small extension for Jupyter Notebooks that
displays an indication of how much resources your current notebook server and
its children (kernels, terminals, etc) are using. This is displayed in the
main toolbar in the notebook itself, refreshing every 5s.

## Installation

You can currently install this directly from git:

```
pip install git+https://github.com/yuvipanda/nbresuse.git
jupyter serverextension enable --py nbresuse
jupyter nbextension install --py nbresuse
```

To enable this extension for all notebooks:

```
jupyter nbextension enable --py nbresuse
```

## Resources displayed

Currently it only displays Memory usage (just RSS). Other metrics will be
added in the future as needed.

repository: IDR/nbresuse

repo_name: IDR/nbresuse


text:
\page download Downloads
\tableofcontents
GIT repository
==============
Currently the source files of MoonGen are only available on [GIT](https://github.com/emmericp/MoonGen):

        git clone https://github.com/emmericp/MoonGen.git

Installation
------------
See \ref install for instructions on how to install MoonGen.

Download Manual
==============
The manual is not yet available as standalone document.

repository: emmericp/MoonGen

gha_language: Lua

repo_name: emmericp/MoonGen


text:
# Image

This folder contains a [Terraform](https://www.terraform.io/) module that represents a container image to be built and used in subsequent build projects.

## How do you use this module?

This folder defines a [Terraform module](https://www.terraform.io/docs/modules/usage.html), which you can use in your
code by adding a `module` configuration and setting its `source` parameter to URL of this folder:

```hcl
module "image" {
  source = "github.com/Crown-Commercial-Service/CMpDevEnvironment//terraform/modules/image?ref=master"

  # Specify a prefix for the image.
  prefix = "ccs"

  # Specify a name for the image.
  name = "ruby"

  # Specify the github owner related to the source code repo.
  github_owner = "Crown-Commercial-Service"

  # Specify the github repo that holds the source code.
  github_repo = "CMpDevBuildImage_Ruby"

  # Specify the github branch to build.
  github_branch = "master"

  # Specify the AWS Parameter Store Key name that holds a Personal Access token for Github.
  github_token_alias = "ccs-build_github_token"

  # ... See variables.tf for any other parameters you may define
}
```

Note the following parameters:

* `source`: Use this parameter to specify the URL of the build module. The double slash (`//`) is intentional
  and required. Terraform uses it to specify subfolders within a Git repo (see [module
  sources](https://www.terraform.io/docs/modules/sources.html)). The `ref` parameter specifies a specific Git tag in
  this repo. That way, instead of using the latest version of this module from the `master` branch, which
  will change every time you run Terraform, you're using a fixed version of the repo.

You can find any other parameters in [variables.tf](variables.tf).

Check out the [ruby example](https://github.com/Crown-Commercial-Service/CMpDevEnvironment/blob/develop/terraform/build/image-ruby/main.tf) for fully-working sample code.

## What's included in this module?

This module creates an AWS CodeBuild project and an AWS ECR Repository.

branch_name: refs/heads/develop

gha_language: HCL


text:
## Version 1.5

  - Removed special handling of the ApplicationName property. This can be considered a (minor) breaking change.
  - Fixed a bug where more specifically given properties - e.g. in a thread instead of process-level - were not always overridden correctly.

## Version 1.4

  - Updated framework references to 4.6.1 from 4.5
  - Add SetExtendedProperty method to LogContext
  - Fix a couple of brittle tests
  - Sign the assemblies - except LogBridge.UmbracoLog4Net

## Version 1.3

This version has a few internal plumbing changes, e.g.

  - The use of xUnit instead of NUnit
  - Simplication of some internal inheritance
  - Use of a T4 template to generate Log.XXX methods.

### Bug fixes

  - Issue #3 with missing exception message for log4net
  - Missing exception message for FaultExceptions - a minor brain hemorage on my part.
  - Describe.XXX now has an internal recursionDepth stopping infinite recursion AKA stack overflows from happening.

### New featuers

  - LogLocation.Here() - please see Readme.md
  - More Log.XXX overloads.

### Breaking changes

  - Removal of the *stackFrameOffsetCount* property from the *logBridge* configuration element. Please remove this manually when upgrading.
  - The static ThreadLogContext etc. on the Log class have been moved to the LogContext class instead.

repository: TorbenRahbekKoch/LogBridge

repo_name: TorbenRahbekKoch/LogBridge


text:
Given an array of integers where 1 ≤ a[i] ≤ n (n = size of array), some elements appear twice and others appear once.

Find all the elements of [1, n] inclusive that do not appear in this array.

Could you do it without extra space and in O(n) runtime? You may assume the returned list does not count as extra space.

**Example:**
```
Input:
[4,3,2,7,8,2,3,1]

Output:
[5,6]
```

**Solution:**

```golang
func findDisappearedNumbers(nums []int) []int {
  n := len(nums)
  for i := 0; i < n; i++ {
    for nums[nums[i] - 1] != nums[i] {
      nums[nums[i] - 1], nums[i] = nums[i], nums[nums[i] - 1]
    }
  }

  var ans []int
  for i := 0; i < n; i++ {
    if nums[i] != i + 1 {
      ans = append(ans, i + 1)
    }
  }
  return ans
}
```

url: https://raw.githubusercontent.com/geemo/leetcode/1cc42b1b29e4164deffb679e1bdd60dcb662ca70/448.Find All Numbers Disappeared in an Array/README.md

repository: geemo/leetcode

repo_name: geemo/leetcode


text:
# SpreeZipcodeTaxes

SpreeZipcodeTaxes is Spree Commerce extention to have taxes based on zip code. We can import taxes for csv file and it will create tax category, tax rates & amount corresponding to zip codes. Tax category is marked as default to be taxable on all products and zone can be country or state based.

## Installation

1. Add this extension to your Gemfile with this line:
  ```ruby
  gem 'spree_zipcode_taxes', github: '[your-github-handle]/spree_zipcode_taxes'
  ```

2. Install the gem using Bundler:
  ```ruby
  bundle install
  ```

3. Copy & run migrations
  ```ruby
  bundle exec rails g spree_zipcode_taxes:install
  ```

4. Spree Zipcode Taxes Configuration
-----
  ```ruby
    Spree::ZipcodeTax.configure do |config|
      config.country_iso_name = 'US'
      config.zone_name = 'North America'
      config.tax_category_name = 'Tax'
    end

  ```

create initializers file and copy above defaut configration and override it according to your usage.

5. Check out example csv to import tax rates - [alt example/tax_rate_zipcodes.csv](https://github.com/sourcecodepartners/spree_zipcode_taxes/blob/master/example/tax_rate_zipcodes.csv)

6. Restart your server

  If your server was running, restart it so that it can find the assets properly.

## Testing

First bundle your dependencies, then run `rake`. `rake` will default to building the dummy app if it does not exist, then it will run specs. The dummy app can be regenerated by using `rake test_app`.

```shell
bundle
bundle exec rake
```

When testing your applications integration with this extension you may use it's factories.
Simply add this require statement to your spec_helper:

```ruby
require 'spree_zipcode_taxes/factories'
```

## Contributing

If you'd like to contribute, please take a look at the
[instructions](CONTRIBUTING.md) for installing dependencies and crafting a good
pull request.

Copyright (c) 2018 [name of extension creator], released under the New BSD License


text:
# OPEM in MATLAB

----------

----------

- OPEM is available in MATLAB by [Python Libraries](https://www.mathworks.com/help/matlab/call-python-libraries.html)

- Visit [here](https://github.com/ECSIM/opem/blob/master/INSTALL.md#matlab) for installation guide

- For more information about models visit [Documents](https://github.com/ECSIM/opem/tree/master/Documents)

- If you want to generate report (`report_mode = true`) :
	1. Run MATLAB as administrator
	2. Change the MATLAB current folder

repository: ECSIM/opem

gha_language: Python

repo_name: ECSIM/opem


text:
# flatbuffers_android
Parsing json using flatbuffers. Thanks to https://github.com/frogermcs/FlatBuffs
in order to run this application you need to change Gradle version to 4.4 and the Android Plugin Version to 3.1.0
Also you need to change the APP_STL into c++_static under the application.mk

![Test Image 7](https://raw.githubusercontent.com/helakaraa/flatbuffers_android/master/Screenshot_20181220-105345.png)


text:
# KentProjects > Intents > Access Year

This represents an intent to access a year. [See here for more information on intents](./generic.md).

## Creating

Creating an intent to access a year involves sending a `POST` request with the handler set to `access_year`:

```http
POST /intent HTTP/1.1
```
```json
{
    "handler": "access_year"
}
```

And you'll get back an intent object with a group object:

```http
HTTP/1.1 201 Created
```
```json
{
    "id": 1,
    "user": {
        "id": 4,
        "email"<EMAIL_ADDRESS>        "...": "..."
    },
    "handler": "access_year",
    "data": {},
    "state": "open"
}
```

## Getting

Once you have an `id`, you can make `GET` requests to fetch data.

```http
GET /intent/:id HTTP/1.1
```

Which will return an intent object (exactly like above):

```http
HTTP/1.1 200 OK
```
```json
{
    "id": 1,
    "user": {
        "id": 4,
        "email"<EMAIL_ADDRESS>        "...": "..."
    },
    "handler": "access_year",
    "data": {},
    "state": "open"
}
```

## Updating

To update the intent, you can make a `PUT` updating the state of the intent.

```http
PUT /intent/:id HTTP/1.1
```
```json
{
    "state": "accepted"
}
```

And you will receive:

```http
HTTP/1.1 200 OK
```
```json
{
    "id": 1,
    "user": {
        "id": 4,
        "email"<EMAIL_ADDRESS>        "...": "..."
    },
    "handler": "access_year",
    "data": {},
    "state": "accepted"
}
```

repository: kentprojects/api

repo_name: kentprojects/api


text:
# Payment API

[![Build Status](https://travis-ci.org/devenney/form3.svg?branch=master)](https://travis-ci.org/devenney/form3)

## Configuration

[Viper](https://github.com/spf13/viper) is used for configuration. The important settings, currently set via environment variables, are:

* `PAYMENTS_DB_ENDPOINT`: The DynamoDB endpoint. Leave unset to default to AWS.
* `PAYMENTS_ENV`: The deployment environment. Set to "PROD" to disable dev features.

## Deployment

```shell
make node-deps
make deploy
```

This will deploy the serverless stack with a custom domain (defaults to `f3.devenney.io`). Thus, the endpoints will be available at:

```
GET     https://f3.devenney.io/listPayments
GET     https://f3.devenney.io/getPayment/{id}
POST    https://f3.devenney.io/addPayment
PUT     https://f3.devenney.io/updatePayment/{id}
DELETE  https://f3.devenney.io/deletePayment/{id}
```

## Testing

### Pact Testing

Although writing a real client was out of scope, a mock client is implemented in `handlers/pact/pact_test.go` (commented out) to produce a Pact file on demand. This file is fed into a real provider test which ensures `/getPayments` returns an expected response.

For these tests to function, the Pact CLI must be installed as detailed [on the release page](https://github.com/pact-foundation/pact-ruby-standalone/releases/tag/v1.64.0).

### DynamoDB Local

Testing requires a local instance of DynamoDB, bound to port 8080 (to prevent clashes with the default server port). This is most easily achieved using the official Docker container:

```shell
docker run -p 8080:8000 amazon/dynamodb-local
```

## Local Development

`docker-compose.yml` is provided for easy provisioning of a local development environment.

```shell

### Install docker-compose in Python virtual environment

virtualenv -p python3 ./venv/
. ./venv/bin/activate
pip install docker-compose

### Run docker-compose

docker-compose up
```

## Seeding Data

A command exists to seed DynamoDB, based on the user configuration, with the mock data provided. This expects to run in the root directory of the project as follows:

```shell
go run cmd/seed/main.go
```

If you are attempting to seed a local development deployment, ensure the Docker Compose network is up and running and that the command runs from within the network.

```shell
CONTAINER_ID=$(docker ps -f "name=form3_server" -q)
docker exec -it $CONTAINER_ID /bin/bash
go run cmd/seed/main.go
```


text:
# About
I really like the idea of the whole [commitizen](http://commitizen.github.io/cz-cli/)
 or the [conventional commits](https://www.conventionalcommits.org)
 conventions but I wanted to modify prefixes and add better notes.

The real goal is to avoid that kind of messages: http://whatthecommit.com 😇

# Notes on commits messages

* https://git.kernel.org/pub/scm/git/git.git/tree/Documentation/SubmittingPatches

1. If applied, this commit will…
1. Summarize changes in around 50 characters or less
1. Explain why this change is being made
1. Provide links to any relevant tickets, articles or other resources
1. If you use an issue tracker, put references to them at the bottom, like this:
   - Resolves: #123
   - See also: #456, #789

* https://chris.beams.io/posts/git-commit/#seven-rules
* git config --global commit.template "~/dotfiles/commit-msg-template"
* https://dev.to/shreyasminocha/how-i-do-my-git-commits-34d
* https://dev.to/gauravchaddha1996/what-i-learned-this-month-2nbi

repository: ponsfrilus/ponsfrilus-commit-types

repo_name: ponsfrilus/ponsfrilus-commit-types


text:
## swagger-json-preview (For Chrome)

> preview swagger json when browse on web

## feature
- Only available for gitlab for now
- The extention will work on web pages where the url is ended with `.swagger.json`
    - A 'Preview Swagger' Button will be shown on file actions row, click the button and the content will be replaced with formatted docs

## refer
- https://developer.chrome.com/extensions/getstarted
- https://github.com/caldwell/renderjson
- https://www.cnblogs.com/liuxianan/p/chrome-plugin-develop.html

## how to use
- Download zip file: https://github.com/isword123/swagger-json-preview/archive/master.zip
- Unzip the zip to a folder
- Go to Chrome: 'More tools' -> 'Extensions'
    - Enable developer mode
    - Click 'Load unpacked', choose the folder location unzipped
    - The extension is loaded
- If you want the preview work automatically, please go to extention options page, and toggle on the 'auto preview' switch

## Changes
- [x] 增加 properties 有以下字段的处理
```
   additionalProperties: {
     type: number,
     format: double
   }
```
- [x] add '__comment__' for object comment to show in json

> README.md
> Created On: 2019-02-13 15:05:52


text:
## List of data structures [wiki](https://en.wikipedia.org/wiki/List_of_data_structures)

#### Linked lists
- Singly linked list
    (
        [code](app/src/linkedList/singly/LinkedList.php),
        [tests](app/tests/linkedList/SinglyLinkedListTests.php),
        [wiki](https://en.wikipedia.org/wiki/Linked_list)
    )
- Doubly linked list (code, tests, [wiki]())
- Array list (code, tests, [wiki]())
- Self-organizing list (code, tests, [wiki]())
- Skip list (code, tests, [wiki]())
- Unrolled linked list (code, tests, [wiki]())
- VList (code, tests, [wiki]())
- Xor linked list (code, tests, [wiki]())
- Zipper (code, tests, [wiki]())
- Doubly connected edge list (code, tests, [wiki]())
- Difference list (code, tests, [wiki]())
- Free list (code, tests, [wiki]())

#### Binary trees
- AA tree (code, tests, [wiki]())
- AVL tree (code, tests, [wiki]())
- Binary search tree (code, tests, [wiki]())
- Binary tree (code, tests, [wiki]())
- Cartesian tree (code, tests, [wiki]())
- Order statistic tree (code, tests, [wiki]())
- Pagoda (code, tests, [wiki]())
- Randomized binary search tree (code, tests, [wiki]())
- Red-black tree (code, tests, [wiki]())
- Rope (code, tests, [wiki]())
- Scapegoat tree (code, tests, [wiki]())
- Self-balancing binary search tree (code, tests, [wiki]())
- Splay tree (code, tests, [wiki]())
- T-tree (code, tests, [wiki]())
- Tango tree (code, tests, [wiki]())
- Threaded binary tree (code, tests, [wiki]())
- Top tree (code, tests, [wiki]())
- Treap (code, tests, [wiki]())
- WAVL tree (code, tests, [wiki]())
- Weight-balanced tree (code, tests, [wiki]())

#### B-trees
- B-tree (code, tests, [wiki]())
- B+ tree (code, tests, [wiki]())
- B*-tree (code, tests, [wiki]())
- B sharp tree (code, tests, [wiki]())
- Dancing tree (code, tests, [wiki]())
- 2-3 tree (code, tests, [wiki]())
- 2-3-4 tree (code, tests, [wiki]())
- Queap (code, tests, [wiki]())
- Fusion tree (code, tests, [wiki]())
- Bx-tree (code, tests, [wiki]())
- AList (code, tests, [wiki]())

#### Heaps
- Heap (code, tests, [wiki]())
- Binary heap (code, tests, [wiki]())
- Weak heap (code, tests, [wiki]())
- Binomial heap (code, tests, [wiki]())
- Fibonacci heap (code, tests, [wiki]())
- AF-heap (code, tests, [wiki]())
- Leonardo Heap (code, tests, [wiki]())
- 2-3 heap (code, tests, [wiki]())
- Soft heap (code, tests, [wiki]())
- Pairing heap (code, tests, [wiki]())
- Leftist heap (code, tests, [wiki]())
- Treap (code, tests, [wiki]())
- Beap (code, tests, [wiki]())
- Skew heap (code, tests, [wiki]())
- Ternary heap (code, tests, [wiki]())
- D-ary heap (code, tests, [wiki]())
- Brodal queue (code, tests, [wiki]())

#### Trees
- Trie (code, tests, [wiki]())
- Radix tree (code, tests, [wiki]())
- Suffix tree (code, tests, [wiki]())
- Suffix array (code, tests, [wiki]())
- Compressed suffix array (code, tests, [wiki]())
- FM-index (code, tests, [wiki]())
- Generalised suffix tree (code, tests, [wiki]())
- B-trie (code, tests, [wiki]())
- Judy array (code, tests, [wiki]())
- X-fast trie (code, tests, [wiki]())
- Y-fast trie (code, tests, [wiki]())
- Ctrie (code, tests, [wiki]())

#### Multiway trees
- Ternary tree (code, tests, [wiki]())
- K-ary tree (code, tests, [wiki]())
- And–or tree (code, tests, [wiki]())
- (a,b)-tree (code, tests, [wiki]())
- Link/cut tree (code, tests, [wiki]())
- SPQR-tree (code, tests, [wiki]())
- Spaghetti stack (code, tests, [wiki]())
- Disjoint-set data structure (code, tests, [wiki]())
- Fusion tree (code, tests, [wiki]())
- Enfilade (code, tests, [wiki]())
- Exponential tree (code, tests, [wiki]())
- Fenwick tree (code, tests, [wiki]())
- Van Emde Boas tree (code, tests, [wiki]())
- Rose tree (code, tests, [wiki]())

#### Space-partitioning trees
- Segment tree (code, tests, [wiki]())
- Interval tree (code, tests, [wiki]())
- Range tree (code, tests, [wiki]())
- Bin (code, tests, [wiki]())
- Kd-tree (code, tests, [wiki]())
- Implicit kd-tree (code, tests, [wiki]())
- Min/max kd-tree (code, tests, [wiki]())
- Adaptive k-d tree (code, tests, [wiki]())
- Quadtree (code, tests, [wiki]())
- Octree (code, tests, [wiki]())
- Linear octree (code, tests, [wiki]())
- Z-order (code, tests, [wiki]())
- UB-tree (code, tests, [wiki]())
- R-tree (code, tests, [wiki]())
- R+ tree (code, tests, [wiki]())
- R* tree (code, tests, [wiki]())
- Hilbert R-tree (code, tests, [wiki]())
- X-tree (code, tests, [wiki]())
- Metric tree (code, tests, [wiki]())
- Cover tree (code, tests, [wiki]())
- M-tree (code, tests, [wiki]())
- VP-tree (code, tests, [wiki]())
- BK-tree (code, tests, [wiki]())
- Bounding interval hierarchy (code, tests, [wiki]())
- BSP tree (code, tests, [wiki]())
- Rapidly exploring random tree (code, tests, [wiki]())

#### Application-specific trees
- Abstract syntax tree (code, tests, [wiki]())
- Parse tree (code, tests, [wiki]())
- Decision tree (code, tests, [wiki]())
- Alternating decision tree (code, tests, [wiki]())
- Minimax tree (code, tests, [wiki]())
- Expectiminimax tree (code, tests, [wiki]())
- Finger tree (code, tests, [wiki]())
- Expression tree (code, tests, [wiki]())
- Log-structured merge-tree (code, tests, [wiki]())

#### Hashes
- Bloom filter (code, tests, [wiki]())
- Count-Min sketch (code, tests, [wiki]())
- Distributed hash table (code, tests, [wiki]())
- Double Hashing (code, tests, [wiki]())
- Dynamic perfect hash table (code, tests, [wiki]())
- Hash array mapped trie (code, tests, [wiki]())
- Hash list (code, tests, [wiki]())
- Hash table (code, tests, [wiki]())
- Hash tree (code, tests, [wiki]())
- Hash trie (code, tests, [wiki]())
- Koorde (code, tests, [wiki]())
- Prefix hash tree (code, tests, [wiki]())
- Rolling hash (code, tests, [wiki]())
- MinHash (code, tests, [wiki]())
- Quotient filter (code, tests, [wiki]())
- Ctrie (code, tests, [wiki]())

#### Graphs
- Graph (code, tests, [wiki]())
- Adjacency list (code, tests, [wiki]())
- Adjacency matrix (code, tests, [wiki]())
- Graph-structured stack (code, tests, [wiki]())
- Scene graph (code, tests, [wiki]())
- Binary decision diagram (code, tests, [wiki]())
- Zero-suppressed decision diagram (code, tests, [wiki]())
- And-inverter graph (code, tests, [wiki]())
- Directed graph (code, tests, [wiki]())
- Directed acyclic graph (code, tests, [wiki]())
- Propositional directed acyclic graph (code, tests, [wiki]())
- Multigraph (code, tests, [wiki]())
- Hypergraph (code, tests, [wiki]())

#### Other
- Lightmap (code, tests, [wiki]())
- Winged edge (code, tests, [wiki]())
- Doubly connected edge list (code, tests, [wiki]())
- Quad-edge (code, tests, [wiki]())
- Routing table (code, tests, [wiki]())
- Symbol table (code, tests, [wiki]())

## Tests

For running tests install vendors with composer and run command
```bash
$ ./vendor/bin/phpunit
```

repository: YaroslavShapoval/data-structures

repo_name: YaroslavShapoval/data-structures


text:
# NotificationEngine Overview

Flexibly create notifications that can be sent across multiple mediums, like email, SMS, and push.

## Overview

There are two types of objects: `Notification` and `Medium`

`Notification` is a parent class for different types of notifications. For example, a subclass may be: CalendarEventChangeNotification which is created for every user that is notified of a calendar event change.

`Mediums::Base` is a parent class for different types of communication mediums. For example, email, SMS, or push.

## Usage

There are four steps to wire up a notification:

1. Add Medium(s)
2. Add Notification
3. Write notification template for each medium
4. Wire up callback to send notifications

### 1. Creating Mediums

```
rails g medium Email
rails g medium Sms
```

After making some changes to the generated file to suit our needs, we end up with something like the following:

```ruby
module Mediums
  class EmailMedium < NotificationEngine::Mediums::Base
    attr_reader :email, :subject, :body

    def after_init(args = {})
      @email = args[:email]
      @subject = args.fetch(:subject, parse_template(:subject))
      @body = args.fetch(:body, parse_template(:body))
    end

    def deliver
      NotificationMailer.basic_notification(message_args).deliver_later
    end

    def slug
      'email'
    end

    private

    def required_attrs
      [:email]
    end

    def message_args
      @message_args ||= {
        to: email,
        subject: subject,
        body: body
      }
    end
  end
end
```

```ruby
module Mediums
  class SmsMedium < NotificationEngine::Mediums::Base
    attr_reader :body, :mobile_phone

    def after_init(args = {})
      @mobile_phone = args[:mobile_phone]
      @body = args.fetch(:body, parse_template(:body))
    end

    def deliver
      # hook up Twilio or other SMS service here
      # we can pass in mobile_phone and body as args
    end

    def slug
      'sms'
    end

    private

    def required_attrs
      [:mobile_phone]
    end
  end
end
```

The only two required methods for a `Medium` are `slug` and `deliver`. You'll see why the slug is important here in a bit.

### 2. Creating a Notification

```
rails g notification NewTeamMember
```

```ruby
class NewTeamMemberNotification < NotificationEngine::Notification
  def mediums
    [:email, :sms]
  end

  def data
    {
      email<EMAIL_ADDRESS>      mobile_phone: '123-456-1828',
      recipient: {
        name: 'Ned Stark'
      },
      new_user: {
        name: 'Jon Snow'
      }
    }
  end
end
```

In this case, `email` is used by the `email` medium and `mobile_phone` is used by `sms` medium. The other information in `data` will be used by our template.

### 3. Write Template

In config/locales/en.yml:

```yml
en:
  notifications:
    new-team-member-notification:
      email:
        subject: '{{ new_user.name }} was just created'
        body: >
          Hi {{ recipient.name }},
          A new user named {{ new_user.name }} was added to your team. Please login to review the new user.
    another-example-notification:
      all:
        body: An example body that would work across all mediums for this notification
```

### 4. Wire up callback to send notifications

```ruby
class User < ApplicationRecord
  after_create :send_notifications

  def send_notifications
    team_members.each do |team_member|
      notification = NewTeamMemberNotification.create(
        recipient: team_member,
        notifiable: self
      )
      notification.deliver
    end
  end
end
```

## Installation

Gemfile:

```ruby
gem 'notification_engine'
```

```
bundle
```

## License
The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).


text:
---
layout: default
---

# 1996-06-03 - Fate of Ecash if RSA is cracked?

## Header Data

From<EMAIL_ADDRESS>(Igor Chudov @ home)

To<EMAIL_ADDRESS>Message Hash: fb2d83a6483363d32569472743ff6d6f491298b01d1925577b56c422c83a5b96

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-06-03 01:26:23 UTC

Raw Date: Mon, 3 Jun 1996 09:26:23 +0800

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Igor Chudov @ home)
Date: Mon, 3 Jun 1996 09:26:23 +0800
To<EMAIL_ADDRESS>Subject: Fate of Ecash if RSA is cracked?
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text

Hello,

After reading Comm. of ACM and Schneier's book about ecash,
a question arose: what if the underlying public key cryptographic
scheme gets broken somehow? Suppose, for example, that someone
discovers an ultra-fast factoring algorithm or something like that.

What would happen with all ecash that's been issued? Of course
criminals would be able to forge large amounts of authentic-looking
ecash, so banks should not be honoring requests to convert e-cash into
real cash.

I apologize in advance is this question is silly, and will appreciate your
corrections.

	- Igor.

{% endraw %}
```

## Thread

+ Return to [June 1996](/archive/1996/06)

+ Return to "[Alan Horowitz <alanh@infi.net>](/authors/alan_horowitz_alanh_at_infi_net_)"
+ Return to<EMAIL_ADDRESS>(Dr. Dimitri Vulis)](/authors/dlv_at_bwalk_dm_com_dr_dimitri_vulis_)"
+ Return to<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)](/authors/dlv_at_bwalk_dm_com_dr_dimitri_vulis_kotm_)"
+ Return to<EMAIL_ADDRESS>(Greg Miller)](/authors/gregmi_at_galileo_mis_net_greg_miller_)"
+ Return to<EMAIL_ADDRESS>(Igor Chudov @ home)](/authors/ichudov_at_algebra_com_igor_chudov__at__home_)"
+ Return to "["Perry E. Metzger" <perry@piermont.com>](/authors/perry_e_metzger_perry_at_piermont_com_)"

+ 1996-06-03 (Mon, 3 Jun 1996 09:26:23 +0800) - Fate of Ecash if RSA is cracked? -<EMAIL_ADDRESS>(Igor Chudov @ home)_
  + 1996-06-03 (Mon, 3 Jun 1996 12:51:40 +0800) - [Re: Fate of Ecash if RSA is cracked?](/archive/1996/06/5cc91c3e1067f5547fc1dc47e13d4837afe0cac9b8bbc1a1288ffe7abf116341) -<EMAIL_ADDRESS>(Dr. Dimitri Vulis)_
    + 1996-06-03 (Mon, 3 Jun 1996 16:05:37 +0800) - [Re: Fate of Ecash if RSA is cracked?](/archive/1996/06/c474a5f1481645a5081e3008057cb78c31bab5d6a8159f47a8c265fe40b980a9) -<EMAIL_ADDRESS>(Igor Chudov @ home)_
      + 1996-06-04 (Tue, 4 Jun 1996 15:12:40 +0800) - [Re: Fate of Ecash if RSA is cracked?](/archive/1996/06/d91e62c1db4475b8dd41893e317173447cc4ea2c8fd9f5c2ab811ee852d9f580) -<EMAIL_ADDRESS>(Greg Miller)_
    + 1996-06-03 (Tue, 4 Jun 1996 05:41:40 +0800) - [Re: Fate of Ecash if RSA is cracked?](/archive/1996/06/4575fd671753ce84b80d6dce24ff9aabbeeaa31dbabe69d50690bce46bdffb14) - _"Perry E. Metzger"<EMAIL_ADDRESS>  + 1996-06-03 (Mon, 3 Jun 1996 15:11:21 +0800) - [Re: Fate of Ecash if RSA is cracked?](/archive/1996/06/c281b0149d32d7956bf2f18c667f04983ec6869d2100f401eb67736b821430b6) -<EMAIL_ADDRESS>(Greg Miller)_
  + 1996-06-04 (Tue, 4 Jun 1996 13:10:12 +0800) - [Re: Fate of Ecash if RSA is cracked?](/archive/1996/06/1b03a77106c25f7e00740e4c30d243cc5c5f4ba1fa1d6e8a618293c782c38e0a) - _Alan Horowitz<EMAIL_ADDRESS>    + 1996-06-04 (Tue, 4 Jun 1996 15:59:38 +0800) - [Re: Fate of Ecash if RSA is cracked?](/archive/1996/06/c2e225bf57c24da2b91f393268a11de7d38560a64da9e6d1c7b7cfdec99dee1d) -<EMAIL_ADDRESS>(Dr.Dimitri Vulis KOTM)_


text:
---
title: "Weekly Attendance Report"
author: "Chris Haid"
date: "4/10/2015"
output: html_document
---

# Weekly Attendance Report
## What is this
This is an intial test building a Mandrell email template of attendence data and email it out the Data team.

For more info go to [KIPP IDEA](idea.kippchicago.org).

Let me know what you think.

![plot of chunk ada_targets_plot_new](figure/ada_targets_plot_new-1.png)

### Summary Table
<div mc:edit="target_table_html">target_table_html</div>


text:
---
title: Research
layout: post
icon: fa-lightbulb-o
order: 5
---

## Papers to read
- [A_Reachability_Index_for_Recursive_Label_Concatenated_Graph_Queries.pdf](../../data/papers/A_Reachability_Index_for_Recursive_Label_Concatenated_Graph_Queries.pdf)
- [adfs.pdf](../../data/papers/adfs.pdf)
- [WCOJ.pdf](../../data/papers/Adopting%20Worst-Case%20Optimal%20Joins%20in%20Relational%20Database%20Systems.pdf)
- [RPQs in millennium DB](../../data/papers/domagoj-vrgoc-regular-path-queries-in-millenniumdb.pdf)
- [Fast Concurrent Data Sketches.pdf](../../data/papers/Fast%20Concurrent%20Data%20Sketches.pdf)
- [Joinable Parallel Balanced Binary Trees.pdf](../../data/papers/Joinable%20Parallel%20Balanced%20Binary%20Trees.pdf)
- [Photon.pdf](../../data/papers/Photon-%20A%20Fast%20Query%20Engine%20for%20Lakehouse%20Systems.pdf)
- [Scalable Pattern Matching in Metadata Graphs via Constraint Checking.pdf](../../data/papers/Scalable%20Pattern%20Matching%20in%20Metadata%20Graphs%20via%20Constraint%20Checking.pdf)
- [StreamTC-Stream- Large-Scale Graph Triangle Counting on a Single Machine Using GPUs.pdf](../../data/papers/TC%E2%88%92StreamTC-Stream-%20Large-Scale%20Graph%20Triangle%20Counting%20on%20a%20Single%20Machine%20Using%20GPUs.pdf)
- [UMBRA.pdf](../../data/papers/Umbra-%20A%20Disk-Based%20System%20with%20In-Memory%20Performance.pdf)

gha_language: CSS


text:
# smallpt
This folder contains an [ISPC](https://ispc.github.io/index.html) implementation of Kevin Beason's [smallpt](http://www.kevinbeason.com/smallpt/). [1]

This implementation uses my [HLSL-to-ISPC helper library](https://github.com/zigguratvertigo/hlsl-to-ispc) [2].

# ISPC
ispc is a compiler for a variant of the C programming language, with extensions for "single program, multiple data" (SPMD) programming. Under the SPMD model, the programmer writes a program that generally appears to be a regular serial program, though the execution model is actually that a number of program instances execute in parallel on the hardware. [4]

# Running
To run the sample, simply execute the provided binary. You can also recompile it via _hlsl-to-ispc.sln_.

# References
[1] Beason, Kevin. _smallpt_. [http://www.kevinbeason.com/smallpt/](http://www.kevinbeason.com/smallpt/)

[2] Barré-Brisebois, Colin. HLSL to ISPC: ispc-hlsl. [https://github.com/zigguratvertigo/hlsl-to-ispc](https://github.com/zigguratvertigo/ispc-hlsl)

repository: Hengle/hlsl-to-ispc

repo_name: Hengle/hlsl-to-ispc


text:
# Salesforce Environment Variables

A simple library for using Custom Metadata to manage simple Key/Value Environment variables

![UI Demo](https://user-images.githubusercontent.com/5217568/55663312-a63c4c00-57d9-11e9-994c-6e76ea0bd135.gif)

*idea inspired by Ralph Callaway's work*

## Usage

### install in org

[Use SFDX to deploy to org](https://developer.salesforce.com/docs/atlas.en-us.sfdx_dev.meta/sfdx_dev/sfdx_dev_build_mdapi_deploy.htm)

1. `git clone https://github.com/ChuckJonas/Salesforce-Environment-Vars.git`
1. `cd Salesforce-Environment-Vars`
1. `mkdir deploy`
2. `sfdx force:source:convert -d deploy/`
3. `sfdx force:mdapi:deploy -d deploy/ -u "YOUR_USERNAME_HERE" -l RunSpecifiedTests -r EnvTests`

**NOTE:** This application comes with a custom user interface for easier management of the ENV Vars. If you'd prefer not to use it, delete the following before deploying:

- `force-app/main/default/pages`
- `force-app/main/default/staticresources`

### Setup

If UI was installed, navigate to `/apex/env_vars` and setup your Environment Variables.  Otherwise, just manage like any other CustomMetadata.

#### Notes

The following types are currently supported:

- `String`
- `Integer`
- `Decimal`
- `Boolean`: Format: `true` or `false`
- `String[]`: Format: `["a","b","c"]`
- `Map<String,String>`: Format: `{"456":"xyz","123":"abc"}`

### Access in apex

Use `Env.get()` to access by passing in the `DeveloperName`:

``` java
// cast to datatype
Integer retries = (Integer) Env.get('Account_Sync_Retries');
String[] types = (String[]) Env.get('Status_Types');
```

### Contributing/Modifying

This project is built off the [B.A.S.S. Stack](https://github.com/ChuckJonas/bad-ass-salesforce-stack).  See Readme for details on how to develop.

repository: agentgill/Salesforce-Environment-Vars

repo_name: agentgill/Salesforce-Environment-Vars


text:
# Writing Strategies for Science Communication: Data and Computational Analysis

## Purpose
This repo holds code and data for the publication:

  Tal August, Lauren Kim, Katharina Reinecke, and Noah Smith ''Writing Strategies for Science Communication: Data and Computational Analysis'', Conference on Empirical Methods in Natural Language Processing (EMNLP) 2020.

## Prerequisites
Begin by creating a new virtual environment and installing required packages
(here using [conda](https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html))

`conda env create -f environment.yml`

And activate it

`conda activate sci_articles`

## Data

The urls of all scraped articles are in `data/cleaned_article_urls.csv` and all annotations made on these articles are in `data/annotations.csv`

The code for the scraper (including the parameters used to run the [scrapy](https://scrapy.org/) spider) are in the `scraper/` directory

## Getting the data

If you want the full text for each article, you can run the scraper with the parameters of the original paper. In the `scraper/` directory, run `python runSpiders.py all <FILEPATH>.jsonl` for wherever you want to store the files.

Note that this might take a few days to scrape all the data.

## Models

We use the RoBERTa models from the [Huggingface transformers library](https://github.com/huggingface/transformers), pretraining and finetuning details are in the paper. Many of the scripts we use are adapted from the Huggingface example scripts, please refer to these for more details, specifically the scripts in `examples/text-classification/`.

If you are interested in getting access to the final finetuned models for classifying the writing strategies, feel free to reach out!

## Annotation Interface

For the annotation interface, see the repo: https://github.com/talaugust/scientific_article_annotation/.

repository: talaugust/scientific-writing-strategies

repo_name: talaugust/scientific-writing-strategies


text:
# ngo [![NPM version](https://badge.fury.io/js/ngo.svg)](https://npmjs.org/package/ngo)   [![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](https://github.com/feross/standard)   [![Dependency Status](https://dependencyci.com/github/doesdev/ngo/badge)](https://dependencyci.com/github/doesdev/ngo)   [![Build status](https://ci.appveyor.com/api/projects/status/0wutjytsl4hmha1j?svg=true)](https://ci.appveyor.com/project/doesdev/ngo)   [![Build Status](https://travis-ci.org/doesdev/ngo.svg)](https://travis-ci.org/doesdev/ngo)

> Run Go commands from Node or CLI, Go env not required

Will download latest binaries locally if Go isn't already in PATH

### BONUS

If you run a command and it fails with "cannot find package..." we'll try to install
said package(s). YAYS. :relieved:

## local install

```sh
$ npm install --save ngo
```

## cli install

```sh
$ npm install --global ngo
```

## usage

#### cli usage
```sh
$ ngo version
# go version go1.8.3 windows/amd64

# to update the `ngo` install of Go (won't update system version)
$ ngo-update
# go version go1.9.4 windows/amd64

# to set the `ngo` install of Go to a specific version (won't update system version)
$ ngo-version 1.12.0
# go version go1.12.0 windows/amd64

# to run a `go get` installed binary use this bs
$ ngo-binary golint test/fixtures/errors.go
# test\fixtures\errors.go:13:5: error var unexp should have name of the form errFoo
```

#### programmatic usage
returns promise that resolves to `execa` style object without the `child_process` goodies

```js
const goOpts = {}
const ngo = require('ngo')(goOpts)
const golint = ngo.bin('golint')

ngo('version').then(console.log).catch(console.error)
/* {
 stdout: 'go version go1.8.3 windows/amd64',
 stderr: '',
 code: 0,
 failed: false,
 killed: false,
 signal: null,
 cmd: 'C:\\Go\\bin\\go version'
} */

golint('main.go').then(console.log).catch(console.error)
```

## api

### const ngo = require('ngo')(`options`)
- **Purpose:** initialize `ngo`
- **Arguments:**
  - **options** *[`Object` - optional]*
    - **useLocal** *[`Boolean` `false`] - use locally downloaded Go binaries)*
    - **update** *[`Boolean` `false`] - update local install to latest*
    - **installDeps** *[`Boolean` `true`] - attempt to install missing packages*
    - **env** *[`Object`] - environment vars to set for the Go command*
    - **goRoot** *[`String`] - Go root path (ex. `/usr/local/go`)*
    - **goPath** *[`String`] - Go workspace path (ex. `~/work`)*
- **Returns:** `Function` (`ngo`) which executes Go commands

### ngo(`commandArgs`, `options`)
- **Purpose:** - execute `go` commands
- **Arguments:**
  - **commandArgs** *[`Array` | `String` - required] - argument(s) to call with `go` command*
  - **options** *[`Object` - optional]*
   - same options as [`child_process.spawn`](https://nodejs.org/api/child_process.html#child_process_child_process_spawn_command_args_options)
   - additonal options available same as [`execa`](https://github.com/sindresorhus/execa#options)
- **Returns:** `Promise` which resolves to [`execa`](https://github.com/sindresorhus/execa) styled object

### ngo.bin(`binary`)
- **Purpose:** - execute commands on binaries in the `GOBIN` directory
- **Arguments:**
  - **binary** [`String`] - name of binary file to be executed in returned function
- **Returns:** `Function` (identical to `ngo`, but runs specified binary instead of `go`)

### ngo.env
this is a copy of ngo's `process.env` with the Go environment variables added to it

## License

MIT © [Andrew Carpenter](https://github.com/doesdev)

repository: doesdev/ngo

gha_language: JavaScript

repo_name: doesdev/ngo


text:
# Apply Changes / Apply Code Changes / LiveLiteral codebase

## Native Debugging (Symbolizing crash-dump)

We build all our binaries (installer, app-server, agent) stripped. Which
mean there are no symbols and no line numbers. As a result, crash-dumps are
 not helpful.

```
 *** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
 Build fingerprint: 'google/sargo/sargo:10/QP1A.190711.019/5790879:user/release-keys'
 Revision: 'MP1.0'
 ABI: 'arm64'
 Timestamp: 2021-03-09 14:34:38-0800
 pid: 8561, tid: 8561, name: installer  >>> /data/local/tmp/.studio/bin/installer <<<
 uid: 2000
 signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr 0x0
 Cause: null pointer dereference
     x0  0000007ff5a81210  x1  0000007ff5a81368  x2  0000007ff5a812b0  x3<PHONE_NUMBER>000001
     x4<PHONE_NUMBER>000000  x5  00000075fe01a036  x6<PHONE_NUMBER>70692f  x7  000000002f736469
     x8<PHONE_NUMBER>000000  x9  000000572d8e8cca  x10<PHONE_NUMBER>000007  x11 00000075c0000000
     x12<PHONE_NUMBER>000020  x13<PHONE_NUMBER>0004d0  x14<PHONE_NUMBER>000040  x15<PHONE_NUMBER>000008
     x16 00000075fe73a8f0  x17 00000075fe72c8c0  x18<PHONE_NUMBER>0b0000  x19 000000572d8055c8
     x20 0000007ff5a81368  x21 0000007ff5a81388  x22<PHONE_NUMBER>000003  x23<PHONE_NUMBER>000000
     x24<PHONE_NUMBER>000000  x25<PHONE_NUMBER>000000  x26<PHONE_NUMBER>000000  x27<PHONE_NUMBER>000000
     x28<PHONE_NUMBER>000000  x29 0000007ff5a81160
     sp  0000007ff5a81120  lr  000000572d803a78  pc  000000572d803a84

 backtrace:
     NOTE: Function names and BuildId information is missing for some frames due
     NOTE: to unreadable libraries. For unwinds of apps, only shared libraries
     NOTE: found under the lib/ directory are readable.
       #00 pc<PHONE_NUMBER>014a84  /data/local/tmp/.studio/bin/installer
       #01 pc<PHONE_NUMBER>015c5c  /data/local/tmp/.studio/bin/installer
       #02 pc<PHONE_NUMBER>016624  /data/local/tmp/.studio/bin/installer
       #03 pc<PHONE_NUMBER>07d798  /apex/com.android.runtime/lib64/bionic/libc.so (__libc_init+108)
```

To build binaries with the necessary .debug_info and .debug_line section full populated,
you need to add `-g` to the compiler flag in `//tools/base/bazel/android.bzl`.

```
ANDROID_COPTS = select_android(
    [
        "-g",
    ],
    [],
)
```

Make sure debug info don't be stripped in our BUILD files.

```
//tools/base/deploy/installer/BUILD
//tools/base/deploy/agent/native/BUILD
```

Change the "stripped" dependencies to normal:
```
    binary = select({
        "//tools/base/bazel:windows": ":installer.stripped.exe",
        # "//conditions:default": ":installer.stripped",
        "//conditions:default": ":installer",
    }),
```

You also need to prevent intermediate static libraries from being stripped. This is easier done
via `//tools/adt/idea/android/build.xml` (add `--strip=never` after the target).

```
 <exec executable="${bazel}" dir="${workspace}" failonerror="true">
            <arg value="build" />
            <arg value="//tools/adt/idea/android:artifacts" />
            <arg value="--strip=never" />
            <arg value="${bazel_config}" unless:blank="${bazel_config}"/>
        </exec>
```

Build and double check you have all debug_info and debug_line sections in the binary.
```
$NDK/readelf -S $AS_BASE/bazel-bin/tools/base/deploy/installer/android-installer/arm64-v8a/installer | grep debug
  [26] .debug_aranges    PROGBITS<PHONE_NUMBER>000000  00152cac
  [27] .debug_info       PROGBITS<PHONE_NUMBER>000000  0015bf4c
  [28] .debug_abbrev     PROGBITS<PHONE_NUMBER>000000  0032442c
  [29] .debug_line       PROGBITS<PHONE_NUMBER>000000  003415ee
  [30] .debug_str        PROGBITS<PHONE_NUMBER>000000  0039157d
  [31] .debug_loc        PROGBITS<PHONE_NUMBER>000000  003d413d
  [32] .debug_ranges     PROGBITS<PHONE_NUMBER>000000  0059e7fe
```

Double check you have the line numbers for a file you know made it in the binary (e.g: main).

```
./toolchains/x86-4.9/prebuilt/darwin-x86_64/i686-linux-android/bin/readelf --debug-dump=decodedline $BASE/master-dev/bazel-bin/tools/base/deploy/installer/android-installer/arm64-v8a/installer | grep tools/base/deploy/installer/main.cc
tools/base/deploy/installer/main.cc:
tools/base/deploy/installer/main.cc:
tools/base/deploy/installer/main.cc:
tools/base/deploy/installer/main.cc:
tools/base/deploy/installer/main.cc:
tools/base/deploy/installer/main.cc:
tools/base/deploy/installer/main.cc:
tools/base/deploy/installer/main.cc:
tools/base/deploy/installer/main.cc:
tools/base/deploy/installer/main.cc:
tools/base/deploy/installer/main.cc:
```

Makes sure you are using at least Android 11 since previous version [had issues](https://github.com/android/ndk/issues/1366).

Inject the PC found in the crash-dump into addr2line.

```
llvm-addr2line -Cfe $BASE/bazel-bin/tools/base/deploy/installer/android-installer/arm64-v8a/installer 0x0000000000015c5c
```

Et voila:
```
tools/base/deploy/installer/main.cc:153
```

## Native Debugging (Enabling Asan)

Switch to ndk 20 by editing `//tools/base/bazel/bazel` (change env['ANDROID_NDK_HOME']).

Enable ASAN in `//tools/base/bazel/android.bzl`:

```
ANDROID_COPTS = select_android(
    [
        "-fsanitize=address",
        "-fno-omit-frame-pointer",
    ],
    [],
)

ANDROID_LINKOPTS = select_android(
    [
        "-fsanitize=address",
    ],
    [],
)
```

To symbolize ASAN report, follow the steps in section "Symbolizing crash-dump".
Note that you cannot use ASAN for ART jvmti agent yet because of b/182005971.

repository: jomof/CppBuildCacheWorkInProgress

gha_language: Java

repo_name: jomof/CppBuildCacheWorkInProgress


text:
# Show labels on layer

This sample demonstrates how to show labels on a feature layer

<img src="ShowLabelsOnLayer.jpg" width="350"/>

## Instructions

The labeling of the names on the US Highways layer is accomplished by supplying a JSON string to the FeatureLayer's LabelDefinition. The JSON is based on the new ArcGIS web map specification.


text:
Not loaded](images/terminal.png)

### Installation steps.

1.  Install [powerline-shell](https://github.com/b-ryan/powerline-shell)
 through `pip3 install powerline-shell` (and maybe fonts?!)
2. Do this
```c
sudo apt-get install fonts-powerline
```
or

```c
$ wget https://github.com/powerline/powerline/raw/develop/font/PowerlineSymbols.otf
$ mv PowerlineSymbols.otf ~/.local/share/fonts/
$ fc-cache -vf ~/.local/share/fonts/
```
2.  Append below contents to the end of `~/.bashrc` file.
```c
function _update_ps1() {
    PS1=$(powerline-shell $?)
}
if [[ $TERM != linux && ! $PROMPT_COMMAND =~ _update_ps1 ]]; then
    PROMPT_COMMAND="_update_ps1; $PROMPT_COMMAND"
fi
```
3. Restart terminal using `source ~/.bashrc`

### Custom

```c
$ mkdir -p ~/.config/powerline-shell && \
powerline-shell --generate-config > ~/.config/powerline-shell/config.json
```

Edit this file as mine below!
```c
{
  "segments": [
    "virtual_env",
    "username",
    "hostname",
    "ssh",
    "cwd",
    "git",
    "hg",
    "jobs",
    "battery",
    "time",
    "root"
  ],
  "cwd": {
    "max_depth": 2,
    "full_cwd": "true"
  },
  "vcs": {
    "show_symbol": "true"
  },
  "time": {
    "format": "%H:%M"
  },
  "theme": "default"
}

```

or my remote config with custom theme. Themes available are
- default
- basic
- solarized_light
- solarized_dark
- washed
- gruvbox

```c
{
  "segments": [
    "virtual_env",
    "hostname",
    "newline",
    "username",
    "ssh",
    "cwd",
    "git",
    "hg",
    "jobs",
    "root"
  ],
  "mode": "patched",
  "cwd": {
    "max_depth": 2,
    "full_cwd": "true"
  },
  "theme": "washed" ,
  "vcs": {
    "show_symbol": "true"
  }
}
```

I tried to achieve [Rayan's Terminal](https://github.com/ryanoasis/powerline-extra-symbols)
like below. But, mission not accomplished still..

![Ryan Terminal Pic - NOT LOADED](images/ryan-preview.png)
Cheers,

repository: mrprajesh/blog

repo_name: mrprajesh/blog


text:
# Changelog

All notable changes to this project will be 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]

### Changed

- Bump LLVM from 13 to 14 [#495](https://github.com/mun-lang/mun/pull/495)
- Bump Inkwell to 0.2.0 [#528](https://github.com/mun-lang/mun/pull/528)

## [0.4.0] - 2022-12-12

### Added

- `Clone` trait implementation to `RootedStruct` [#323](https://github.com/mun-lang/mun/pull/323)
- Private function leak validation [#338](https://github.com/mun-lang/mun/pull/338)
- Dynamically-sized arrays [#341](https://github.com/mun-lang/mun/pull/341)
- Private struct type leak validation [#344](https://github.com/mun-lang/mun/pull/344)
- Mun logo [#355](https://github.com/mun-lang/mun/pull/355)
- `Send` trait implementation to Mun `Runtime` [#370](https://github.com/mun-lang/mun/pull/370)
- Use static-crt on Windows [#376](https://github.com/mun-lang/mun/pull/376)
- Link type information when loading Mun library [#377](https://github.com/mun-lang/mun/pull/377)
- Indirect types to Mun ABI [#415](https://github.com/mun-lang/mun/pull/415)
- `Type` API to mitigate cyclic type references [#427](https://github.com/mun-lang/mun/pull/427)
- Mac M1 Support [#444](https://github.com/mun-lang/mun/pull/444)
- Bevy example [#475](https://github.com/mun-lang/mun/pull/475)

### Changed

- Bump Rust from 1.50.0 to 1.65.0
  [#325](https://github.com/mun-lang/mun/pull/325)
  [#327](https://github.com/mun-lang/mun/pull/327)
  [#334](https://github.com/mun-lang/mun/pull/334)
  [#346](https://github.com/mun-lang/mun/pull/346)
  [#350](https://github.com/mun-lang/mun/pull/350)
  [#357](https://github.com/mun-lang/mun/pull/357)
  [#360](https://github.com/mun-lang/mun/pull/360)
  [#369](https://github.com/mun-lang/mun/pull/369)
  [#378](https://github.com/mun-lang/mun/pull/378)
  [#406](https://github.com/mun-lang/mun/pull/406)
  [#432](https://github.com/mun-lang/mun/pull/432)
  [#474](https://github.com/mun-lang/mun/pull/474)
  [#477](https://github.com/mun-lang/mun/pull/477)
- Simplified invoke syntax [#347](https://github.com/mun-lang/mun/pull/347)
- Bump LLVM from 11 to 13
  [#351](https://github.com/mun-lang/mun/pull/351)
  [#491](https://github.com/mun-lang/mun/pull/491)
- Move Mun runtime FFI submodule to monorepo [#352](https://github.com/mun-lang/mun/pull/352)
- Bump Rust to 2021 edition [#367](https://github.com/mun-lang/mun/pull/367)
- Move Mun ABI submodule to monorepo [#404](https://github.com/mun-lang/mun/pull/404)
- Performance optimisations [#405](https://github.com/mun-lang/mun/pull/405)
- Reduce workspace target folder size from 10.9 GB to 10.6 GB [#457](https://github.com/mun-lang/mun/pull/457)
- Reduce workspace build dependencies from 296 to 270 [#457](https://github.com/mun-lang/mun/pull/457)
- Reduce workspace dev dependencies from 502 to 496 [#457](https://github.com/mun-lang/mun/pull/457)
- Move Rust examples submodule to monorepo [#475](https://github.com/mun-lang/mun/pull/475)
- Switch to LLVM code coverage instead of using Tarpaulin [#478](https://github.com/mun-lang/mun/pull/478)

### Removed

- Move `lld-rs` to separate repository [#373](https://github.com/mun-lang/mun/pull/373)
- Unused dependencies [#435](https://github.com/mun-lang/mun/pull/435)

### Fixed

- Typos in documentation [#340](https://github.com/mun-lang/mun/pull/340) [#348](https://github.com/mun-lang/mun/pull/348)
- Type inference problem for resolved types [#358](https://github.com/mun-lang/mun/pull/358)
- Mac OS Big Sur sdkroot [#362](https://github.com/mun-lang/mun/pull/362)
- Missing closing brace of `error_block` [#364](https://github.com/mun-lang/mun/pull/364)
- Missing semicolon in declaration recovery set [#365](https://github.com/mun-lang/mun/pull/365)
- C API link in book [#372](https://github.com/mun-lang/mun/pull/372)
- Multi-threaded `cargo test` [#407](https://github.com/mun-lang/mun/pull/407)

## [0.3.0] - 2021-04-12

The third Mun release includes big usability improvements; multi-file projects, a language server with diagnostics and autocompletion, and improvements to robustness and developer workflow to name a few.

Special thanks to @emi2k01, @tdejager, @ethanboxx, @sinato, @dependabot, @legendiguess, and @sburris0 for their contributions to this release.

### Added

- generate rust tests for code snippets in book [#311](https://github.com/mun-lang/mun/pull/311)
- support for completions [#306](https://github.com/mun-lang/mun/pull/306)
- add mut keyword [#305](https://github.com/mun-lang/mun/pull/305)
- describe how to install/build LLVM [#304](https://github.com/mun-lang/mun/pull/304)
- runtime linking [#300](https://github.com/mun-lang/mun/pull/300)
- implements incremental file updates [#298](https://github.com/mun-lang/mun/pull/298)
- adds document symbol provider [#297](https://github.com/mun-lang/mun/pull/297)
- add option to emit IR [#296](https://github.com/mun-lang/mun/pull/296)
- integrated new vfs [#294](https://github.com/mun-lang/mun/pull/294)
- adds lsp document symbol provider [#293](https://github.com/mun-lang/mun/pull/293)
- shorten commit hash with environment file [#292](https://github.com/mun-lang/mun/pull/292)
- use statements language support [#290](https://github.com/mun-lang/mun/pull/290)
- make type-specific data (such as StructInfo) part of TypeInfo [#287](https://github.com/mun-lang/mun/pull/287)
- add AsValue macro support for enums [#286](https://github.com/mun-lang/mun/pull/286)
- alignment of struct fields [#285](https://github.com/mun-lang/mun/pull/285)
- adds modules and visibility [#283](https://github.com/mun-lang/mun/pull/283)
- adds fixtures to support multiple files from string [#272](https://github.com/mun-lang/mun/pull/272)
- refactored RawItems into ItemTree [#271](https://github.com/mun-lang/mun/pull/271)
- split database and added docs [#267](https://github.com/mun-lang/mun/pull/267)
- use Idx<T> instead of macro in arena [#266](https://github.com/mun-lang/mun/pull/266)
- never return type in let initializer [#264](https://github.com/mun-lang/mun/pull/264)
- add mdbook plugin for testing mun code in book [#263](https://github.com/mun-lang/mun/pull/263)
- emit and link bitcode files instead of obj does not work on MacOS [#261](https://github.com/mun-lang/mun/pull/261)
- use custom prebuild llvm distribution on ubuntu [#260](https://github.com/mun-lang/mun/pull/260)
- emit and link bitcode files instead of object files [#258](https://github.com/mun-lang/mun/pull/258)
- move test utility functions to separate crate [#253](https://github.com/mun-lang/mun/pull/253)
- move library loading logic to separate crate [#252](https://github.com/mun-lang/mun/pull/252)
- type alias [#251](https://github.com/mun-lang/mun/pull/251)
- Implement `mun new` and `mun init` [#246](https://github.com/mun-lang/mun/pull/246)
- removed outdated comments [#245](https://github.com/mun-lang/mun/pull/245)
- upgrade to salsa 0.15 [#244](https://github.com/mun-lang/mun/pull/244)
- parsing of unmatched right curly braces ('}') [#243](https://github.com/mun-lang/mun/pull/243)
- explicitly specify latest Ubuntu LTS [#241](https://github.com/mun-lang/mun/pull/241)
- build binaries for release branches [#240](https://github.com/mun-lang/mun/pull/240)
- shared diagnostics between compiler and language server [#239](https://github.com/mun-lang/mun/pull/239)
- add benchmarks for and optimise struct field marshalling [#238](https://github.com/mun-lang/mun/pull/238)
- initial LSP support [#236](https://github.com/mun-lang/mun/pull/236)

### Changed

- updated book for 0.3 changes [#314](https://github.com/mun-lang/mun/pull/314)
- update runtime FFI [#312](https://github.com/mun-lang/mun/pull/312)
- Inkwell beta.2 and LLVM11 [#303](https://github.com/mun-lang/mun/pull/303)
- upgrade to official inkwell [#254](https://github.com/mun-lang/mun/pull/254)
- generate C ABI from Rust code [#255](https://github.com/mun-lang/mun/pull/255)

### Removed

- removed async code and switched to lsp_server [#295](https://github.com/mun-lang/mun/pull/295)

### Fixed

- parser performance issues [#307](https://github.com/mun-lang/mun/pull/307)
- manually extract llvm release to get more output [#302](https://github.com/mun-lang/mun/pull/302)
- adds logging to windows llvm install [#301](https://github.com/mun-lang/mun/pull/301)
- fix broken book link and CoC link [#284](https://github.com/mun-lang/mun/pull/284)
- 7zip issues [#280](https://github.com/mun-lang/mun/pull/280)
- dont run mun tests on CI [#278](https://github.com/mun-lang/mun/pull/278)

## [0.2.1] - 2020-07-08

This patch release for Mun v0.2.0 includes a variety of bug fixes.

Special thanks to @RadicalZephyr, @benediktwerner, and @fominok for their contributions to this release; and to @jDomantas and @sigmaSd for the initial discovery and reporting of fixed issues.

### Added

- Type-safe inkwell types [#202](https://github.com/mun-lang/mun/pull/202)

### Fixed

- Remove return-blocking semicolon from ch01 listing 01 of the book [#192](https://github.com/mun-lang/mun/pull/192)
- Code blocks in ch02-02-functions of the book [#194](https://github.com/mun-lang/mun/pull/194)
- Replace overly complicated redirection rules with a simple hack [#196](https://github.com/mun-lang/mun/pull/196)
- Missing argument for `fibonacci` function in the book [#197](https://github.com/mun-lang/mun/pull/197)
- Replace `float` with `f32` in the book [#204](https://github.com/mun-lang/mun/pull/204)
- Windows libclang issues [#205](https://github.com/mun-lang/mun/pull/205)
- Crash on missing nested private function [#221](https://github.com/mun-lang/mun/pull/221)
- Panic when using `mun build` [#229](https://github.com/mun-lang/mun/pull/229)
- `clippy::many_single_char_names` in macro [#231](https://github.com/mun-lang/mun/pull/231)
- Compiler panics when accessing a field of a temporary [#232](https://github.com/mun-lang/mun/pull/232)
- LLVM assertions [#233](https://github.com/mun-lang/mun/pull/233)
- Proper tarpaulin skip attribute [#235](https://github.com/mun-lang/mun/pull/235)

## [0.2.0] - 2020-05-15

The second Mun release includes big new features such as hot reloading support for data structures, garbage collection, and full operator and literal support for fundamental types.

Special thanks to @legendiguess and @jakbyte for their contributions to this release.

### Added

- Updated binaries for Runtime C API [#184](https://github.com/mun-lang/mun/pull/184)
- crates.io publishing metadata [#183](https://github.com/mun-lang/mun/pull/183)
- Mun book in main repository [#182](https://github.com/mun-lang/mun/pull/182)
- Cloning instructions in README [#179](https://github.com/mun-lang/mun/pull/179)
- Log upon assembly reload [#175](https://github.com/mun-lang/mun/pull/175)
- Buoyancy example [#174](https://github.com/mun-lang/mun/pull/174)
- Zero initialise fields with different `struct` types during memory mapping
- Updated code sample in README [#181](https://github.com/mun-lang/mun/pull/181)
- Map fields with different `struct` memory kinds during memory mapping [#171](https://github.com/mun-lang/mun/pull/171)
- Support for adding extern functions in Runtime CAPI [#169](https://github.com/mun-lang/mun/pull/169)
- Split `FunctionInfo` into signature, prototype, and definition [#166](https://github.com/mun-lang/mun/pull/166)
- Test for type conversion during memory mapping [#164](https://github.com/mun-lang/mun/pull/164)
- Garbage collection methods in Runtime CAPI [#163](https://github.com/mun-lang/mun/pull/163)
- Number type inferencing [#154](https://github.com/mun-lang/mun/pull/154)
- Return `Rc<RefCell<Runtime>>` from `RuntimeBuilder` [#153](https://github.com/mun-lang/mun/pull/153)
- left-shift (`<<` and `<<=`), right-shift (`>>` and `>>=`) operators
- bitwise and (`&` and `&=`), or (`|` and `|=`), xor (`^` and `^=`) operators
- `bool` and (`&&`), or (`||`) operators
- `struct` assignment (`=`) operator
- `bool` assignment (`=`) operator [#144](https://github.com/mun-lang/mun/pull/144)
- `StructRef` can be cloned [#143](https://github.com/mun-lang/mun/pull/143)
- Clarified usage of unsafe code
- Cast fundamental types during `struct` memory mapping [#140](https://github.com/mun-lang/mun/pull/140)
- Unary `!` and `-` operators [#136](https://github.com/mun-lang/mun/pull/136)
- `%` and `%=` operators [#135](https://github.com/mun-lang/mun/pull/135)
- Missing space in `invoke_fn15` function [#132](https://github.com/mun-lang/mun/pull/132)
- Merged `file_ir` and `group_ir` snapshots [#131](https://github.com/mun-lang/mun/pull/131)
- Runtime support for `extern` functions without return type [#127](https://github.com/mun-lang/mun/pull/127)
- `i128` and `u128` integer types [#124](https://github.com/mun-lang/mun/pull/124)
- Use `->` instead of `:` for function return types [#123](https://github.com/mun-lang/mun/pull/123)
- Allow underscores in numeric literals
- Hex, binary, and octal literals
- Typed literals [#122](https://github.com/mun-lang/mun/pull/122)
- `struct` memory mapping [#117](https://github.com/mun-lang/mun/pull/117)
- Retrieve `TypeInfo` and `StructInfo` during calls in a `StructRef` [#109](https://github.com/mun-lang/mun/pull/109)
- Performance benchmarks [#104](https://github.com/mun-lang/mun/pull/104)
- Test for incremental compilation [#102](https://github.com/mun-lang/mun/pull/102)
- Garbage collection using mark & sweep [#99](https://github.com/mun-lang/mun/pull/99)
- Size and alignment of types in ABI [#98](https://github.com/mun-lang/mun/pull/98)
- Heap-allocated object management using pointer indirection [#97](https://github.com/mun-lang/mun/pull/97)
- `extern` functions [#96](https://github.com/mun-lang/mun/pull/96)
- Marshalling of `struct(value)` types [#93](https://github.com/mun-lang/mun/pull/93)
- Restrict symbol generation to `pub` functions [#92](https://github.com/mun-lang/mun/pull/92)
- Integration with [annotate-snippets](https://crates.io/crates/annotate-snippets) crate [#91](https://github.com/mun-lang/mun/pull/91)
- Support for `extern` functions in the dispatch table [#90](https://github.com/mun-lang/mun/pull/90)
- Unit tests for Runtime CAPI
- Marshalling of fields with the `struct` type [#87](https://github.com/mun-lang/mun/pull/87)
- Unit test for `LineIndex::line_str` function [#86](https://github.com/mun-lang/mun/pull/86)
- `MunStructInfo` is appended to `MunTypeInfo` for `struct` types [#84](https://github.com/mun-lang/mun/pull/84)
- Marshalling of `struct` types [#83](https://github.com/mun-lang/mun/pull/83)
- Improved error messages for missing function signatures [#80](https://github.com/mun-lang/mun/pull/80)
- License, homepage, and repository information in README [#71](https://github.com/mun-lang/mun/pull/71)
- Simple binary operation type checking [#70](https://github.com/mun-lang/mun/pull/70)
- Tools for manual generation of ABI & runtime CAPI bindings [#69](https://github.com/mun-lang/mun/pull/69)
- Test UTF-8 validity of compiler-generated `CStr` [#67](https://github.com/mun-lang/mun/pull/67)
- Optimised `CStr::from_ptr(ptr).to_str()` to `from_utf8_unchecked` in ABI [#66](https://github.com/mun-lang/mun/pull/66)
- LLVM install instructions for Arch Linux in README [#65](https://github.com/mun-lang/mun/pull/65)
- ABI support for `struct` types
- `struct` literals
- `struct` declarations [#64](https://github.com/mun-lang/mun/pull/64)
- `while` expression [#63](https://github.com/mun-lang/mun/pull/63)
- `break` expression [#62](https://github.com/mun-lang/mun/pull/62)
- Changed crate authors [#61](https://github.com/mun-lang/mun/pull/61)
- `loop` expression [#60](https://github.com/mun-lang/mun/pull/60)
- Incremental compilation when hot reloading [#49](https://github.com/mun-lang/mun/pull/49)

### Changed

- Removed old snapshots [#170](https://github.com/mun-lang/mun/pull/170)
- Updated badges in README [#162](https://github.com/mun-lang/mun/pull/162)
- Updated code sample in README [#161](https://github.com/mun-lang/mun/pull/161)
- Simplified `MemoryMapper` API [#142](https://github.com/mun-lang/mun/pull/142)
- Split artifact generation and CI tests [#141](https://github.com/mun-lang/mun/pull/141)
- Lock [cbindgen](https://crates.io/crates/cbindgen) dependency [#126](https://github.com/mun-lang/mun/pull/126)
- Updated Arch Linux install instructions in README [#116](https://github.com/mun-lang/mun/pull/116)
- Code coverage using tarpaulin instead of grcov [#100](https://github.com/mun-lang/mun/pull/100)
- Compiled libraries use `munlib` extension [#75](https://github.com/mun-lang/mun/pull/75)
- Use codecov.io instead of coveralls [#59](https://github.com/mun-lang/mun/pull/59)
- Install instructions in README [#55](https://github.com/mun-lang/mun/pull/55)

### Removed

- Removed `float`, `uint`, and `int` types [#157](https://github.com/mun-lang/mun/pull/157)

In addition, there were a lot of bug fixes.

## [0.1.0] - 2019-11-11

### Added

- Support all fundamental types as return types when starting a Mun library from the CLI [#45](https://github.com/mun-lang/mun/pull/45)
- `return` expressions [#38](https://github.com/mun-lang/mun/pull/38)
- Statically link against liblld instead of spawning as process [#37](https://github.com/mun-lang/mun/pull/37)
- Generation and upload of artifacts [#36](https://github.com/mun-lang/mun/pull/36)
- Github actions continuous integration [#30](https://github.com/mun-lang/mun/pull/30)
- Update operators and diagnostics [#29](https://github.com/mun-lang/mun/pull/29)
- Example of hot reloading in the Mun Runtime
- Error reporting
- C++ bindings for the Mun Runtime [#25](https://github.com/mun-lang/mun/pull/25)
- Run clippy on CI and pre-commit
- Diagnostics for mismatching or missing `else`
- `if` expressions code generation
- `if` statement type checking
- `never` type
- Add cargo husky to enable automatic git hooks
- Testing of type inferencing
- Parsing of `if` statements [#24](https://github.com/mun-lang/mun/pull/24)
- Comparison operators [#23](https://github.com/mun-lang/mun/pull/23)
- Automatic generation of C bindings for the runtime [#22](https://github.com/mun-lang/mun/pull/22)
- Trait extension of Result type that allows retrying and waiting for a correct result [#15](https://github.com/mun-lang/mun/pull/15)
- Integrate dispatch table in Mun runtime [#11](https://github.com/mun-lang/mun/pull/11)
- Dispatch table
- Generation of function call IR
- Function call inferencing [#9](https://github.com/mun-lang/mun/pull/9)
- Command-line interface for Mun Compiler and Mun Runtime
- Compiler daemon that detects changed files and recompiles them
- Runtime builder [#6](https://github.com/mun-lang/mun/pull/6)
- Detection of duplicate definition names [#5](https://github.com/mun-lang/mun/pull/5)
- badges & licenses [#1](https://github.com/mun-lang/mun/pull/1)

repository: mun-lang/mun

gha_language: Rust

gha_license_id: NOASSERTION

repo_name: mun-lang/mun


text:
# Mobile Development
This repository contains work completed during Spring 2020 in Dr. Murray's DIG4639: Mobile Development class.

## Structure
The *ice* folder contains in-class exercises.

## About Me
Haley Jundzil

https://www.linkedin.com/in/haley-jundzil-485460184

I would like to become a front-end designer or a content creator.

## Merging
1. Item 1 [Google](https://www.google.com/)
1. Item 2
1. Item 3

## Conflicts
This section represents code on the server that isn't on the local repository.


text:
Origin story
============

The inspiration for __dataset__ grew from the desire to process metadata as
JSON object collections using simple Unix shell utilities and data
pipelines. The core use case evolved at
[Caltech Library](https://library.caltech.edu) working with various
repository systems' API (e.g.
[EPrints](https://en.wikipedia.org/wiki/EPrints) and
[Invenio](https://en.wikipedia.org/wiki/Invenio)). It has allowed the
library to build an aggregated view of heterogeneous content
(see https://feeds.library.caltech.edu) as well as facilitate ad-hoc
analysis and data enhancement for a number of internal library projects.

repository: caltechlibrary/dataset

gha_language: Go

repo_name: caltechlibrary/dataset


text:
# Banking Account Manager

BankingAccountManager is a application to manage bancary account with indication mechanics attached.

The model contains two schemas:

- Client schema responsible to keep client information.
- Account schema  responsible to keep account information.

## Installation and Usage

To run test and coveralls

`$ docker-compose up --build test`

Create database(dev environment)

`$ docker-compose run dev mix do ecto.create, ecto.migrate`

To run dev enviroment

`$ docker-compose up dev`

Run release(prod environment) of the phoenix server:

`$ docker-compose up release`

## Contributing

1. [Fork it!](https://github.com/danielscosta/banking_account_manager/fork)
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request

## Author

Daniel S. Costa (@danielscosta)

## License

BankingAccountManager is released under the MIT License. See the LICENSE file for further details.


text:
Sinatra Authentication Example
==============================
This Sinatra application demonstrates a simple authentication scheme. See [Sinatra Authentication](https://sideprojectsoftware.com/blog/2015/02/22/sinatra-authentication) for a full explanation.

Prerequisites
-------------
The application depends on the following RubyGems:

* [bcrypt](https://github.com/codahale/bcrypt-ruby)
* [sinatra](https://github.com/sinatra/sinatra)
* [sinatra-flash](https://github.com/SFEley/sinatra-flash)

Running
-------
To run the application in development use:

 `ruby app.rb`

and access using [http://localhost:4567](http://localhost:4567)

Alternatively, to run the web application using a [Rackup](http://rack.github.io/) file use:

 `rackup config.ru` (the `config.ru` may be omitted as Rack looks for this file by default)

and access using [http://localhost:9292](http://localhost:9292)

Credentials
-----------
The credentials for signing in to the app are:

* Username: user
* Password: secret123

repository: johntopley/sinatra-authentication

gha_language: Ruby

repo_name: johntopley/sinatra-authentication


text:
---
layout:        concept
permalink:     "/concepts/http-header/Proxy-Authenticate"
title:         "HTTP Header Field: Proxy-Authenticate"
concept-name:  HTTP Header Field
concept-value: Proxy-Authenticate
description: "The \"Proxy-Authenticate\" header field consists of at least one challenge that indicates the authentication scheme(s) and parameters applicable to the proxy for this effective request URI. It MUST be included as part of a 407 (Proxy Authentication Required) response."
---

[The "Proxy-Authenticate" header field consists of at least one challenge that indicates the authentication scheme(s) and parameters applicable to the proxy for this effective request URI. It MUST be included as part of a 407 (Proxy Authentication Required) response.](https://datatracker.ietf.org/doc/html/rfc7235#section-4.2 "Read documentation for HTTP Header Field "Proxy-Authenticate"") (**[RFC 7235: Hypertext Transfer Protocol (HTTP/1.1): Authentication](/specs/IETF/RFC/7235 "The Hypertext Transfer Protocol (HTTP) is an application-level protocol for distributed, collaborative, hypermedia information systems. This document defines the HTTP Authentication framework.")**)

JSON

Return to list of all ( HTTP Header Fields | Web Concepts )

license: Unlicense

repository: dret/webconcepts

branch_name: refs/heads/gh-pages

gha_language: HTML

gha_license_id: Unlicense

repo_name: dret/webconcepts


text:
# Smspoh Notifications Channel for Laravel

[![Latest Version on Packagist](https://img.shields.io/packagist/v/laravel-notification-channels/smspoh.svg?style=flat-square)](https://packagist.org/packages/laravel-notification-channels/smspoh)
[![Total Downloads](https://img.shields.io/packagist/dt/laravel-notification-channels/smspoh.svg?style=flat-square)](https://packagist.org/packages/laravel-notification-channels/smspoh)
[![GitHub Tests Action Status](https://img.shields.io/github/actions/workflow/status/laravel-notification-channels/smspoh/run-tests.yml?style=flat-square)](https://github.com/laravel-notification-channels/smspoh/actions/workflows/run-tests.yml)
[![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square)](LICENSE.md)

This package makes it easy to send notifications using [SmsPoh](https://smspoh.com/) with Laravel and 9.x and 10.x.

## Contents

- [Installation](#installation)
	- [Setting up the smspoh](#setting-up-the-smspoh-service)
- [Usage](#usage)
	- [Available Message methods](#available-message-methods)
	- [ On-Demand Notifications](#on-demand-notifications)
- [Changelog](#changelog)
- [Testing](#testing)
- [Security](#security)
- [Contributing](#contributing)
- [Credits](#credits)
- [License](#license)

## Installation

You can install this package via composer:
``` bash
composer require laravel-notification-channels/smspoh
```

### Setting up the Smspoh service

Add your Smspoh token, default sender name (or phone number) to your config/services.php:

```php
// config/services.php
...
'smspoh' => [
    'endpoint' => env('SMSPOH_ENDPOINT', 'https://smspoh.com/api/v2/send'),
    'token' => env('SMSPOH_TOKEN', 'YOUR SMSPOH TOKEN HERE'),
    'sender' => env('SMSPOH_SENDER', 'YOUR SMSPOH SENDER HERE')
],
...
```

## Usage

You can use the channel in your via() method inside the notification:

```php
use Illuminate\Notifications\Notification;
use NotificationChannels\Smspoh\SmspohMessage;

class AccountApproved extends Notification
{
    public function via($notifiable)
    {
        return ["smspoh"];
    }

    public function toSmspoh($notifiable)
    {
        return (new SmspohMessage)->content("Your account was approved!");
    }
}
```

In your notifiable model, make sure to include a routeNotificationForSmspoh() method, which returns a phone number or an array of phone numbers.

```php
public function routeNotificationForSmspoh()
{
    return $this->phone;
}
```
### On-Demand Notifications
Sometimes you may need to send a notification to someone who is not stored as a "user" of your application. Using the Notification::route method, you may specify ad-hoc notification routing information before sending the notification:

```php
Notification::route('smspoh', '5555555555')
            ->notify(new InvoicePaid($invoice));
```
### Available Message methods

`sender()`: Sets the sender's name. *Make sure to register the sender name at you SmsPoh dashboard.*

`content()`: Set a content of the notification message. This parameter should be no longer than 918 char(6 message parts),

`test()`: Send a test message to specific mobile number or not. This parameter should be boolean and default value is `true`.

## Testing

``` bash
$ composer test
```

## Changelog

Please see [CHANGELOG](CHANGELOG.md) for more information what has changed recently.

## Contributing

Please see [CONTRIBUTING](https://github.com/laravel-notification-channels/smspoh/blob/master/.github/CONTRIBUTING.md) for details.

## Security Vulnerabilities

Please review [our security policy](../../security/policy) on how to report security vulnerabilities.

## Credits

- [Tint Naing Win](https://github.com/tintnaingwinn)
- [All Contributors](../../contributors)

## License

The MIT License (MIT). Please see [License File](LICENSE.md) for more information.

repository: laravel-notification-channels/smspoh

gha_language: PHP

repo_name: laravel-notification-channels/smspoh


text:
---
date: "2021-01-17T00:00:00Z"
external_link: ""
image:
  caption: "*Mastomys natalensis* CC-BY L. Moses"
  focal_point: Smart
links:
- icon: twitter
  icon_pack: fab
  name: PANDORA-ID-net
  url: https://twitter.com/PandoraIDNet?s=20
summary: Primary source of data for my PhD work. This is being conducted with Njala University in Sierra Leone. We have set up a 2 year longitudinal rodent trapping study in several sites to investigate rodent population and species dynamics and potential risk for Lassa transmission
tags:
- Lassa
- Rodent trapping
- Zoonoses
- Epidemiology
- Public Health
- Planetary Health
title: Rodent trapping
url_code: ""
url_pdf: ""
url_slides: ""
url_video: ""
---

A pilot visit took place in November-December 2020. Two study sites were enrolled in the project with rodent trapping taking place for 4 nights at each site. The study protocol has been refined based on this work and the study is due to start in February 2021.

A report has been produced from the initial work for sharing within the project team. It is available [here]({{< ref "post/rodent/index.md" >}}). This is an ongoing piece of work.

gha_language: TeX


text:
# Change Log
All notable changes to this project will be documented in this file.
This project adheres to [Semantic Versioning](http://semver.org/).

## [Unreleased]

### Added

- Nothing

### Changed

- Drop support for Airbrake 3.x
- Drop support for Ruby < 2.1

### Fixed

- Nothing

## [0.0.3]

### Fixed

- Fix one of version constraints for gem `airbrake` fixed from `<= 5` to `< 5`
  Also test against all supported major versions of `airbrake`

## [0.0.2] - 2014-06-03

### Changed

- Allow `airbrake` `4.*` to be used (It only removes JS notifier)

## [0.0.1] - 2014-03-27

### Added

- Initial Release

[Unreleased]: https://github.com/PikachuEXE/execute_with_rescue_with_airbrake/compare/v0.0.3...HEAD
[0.0.3]:      https://github.com/PikachuEXE/execute_with_rescue_with_airbrake/compare/v0.0.2...v0.0.3
[0.0.2]:      https://github.com/PikachuEXE/execute_with_rescue_with_airbrake/compare/v0.0.1...v0.0.2
[0.0.1]:      https://github.com/PikachuEXE/execute_with_rescue_with_airbrake/releases/tag/v0.0.1


text:
![Polymath](Polymath.png)

## Development

## Troubleshoot

- Try to clean your Metamask cache: Settings > Reset Accounts

# Environment variables

You can set the following env vars inside a `.env` file on the package's root

`REACT_APP_NETWORK_KOVAN_WS`: To connect to Kovan locally
`REACT_APP_NETWORK_GOERLI_WS`: To connect to Goerli locally
`REACT_APP_NETWORK_MAIN_WS`: To connect to the Mainnet locally
`REACT_APP_ALLOW_GANACHE_ONLY`: Allows usage of ganache without Metamask when running in local stage

## Running without Metamask

1. Create a `.env` file in `packages/polymath-issuer`
2. Add `REACT_APP_ALLOW_GANACHE_ONLY=true` to the `.env`
3. Make sure you have `mongodb` set up and running
4. Run the following commands:

- `yarn local-blockchain:start`
- `yarn start:offchain`
- `yarn start:issuer`

5. Disable the Metamask extension in your browser if it is enabled

repository: PolymathNetwork/polymath-apps

repo_name: PolymathNetwork/polymath-apps


text:
# Aggregate Event Impact (AEI) from Events

Event data queried from our events endpoint comes in the following form: one row corresponds to a single event. However, in the context of building forecasting models, the most natural way to incorporate information about events is to (first) include data about estimated attendance.

The set of functions simplify the transformation of record level event data into features aggregated by event category.

## Grouping Categories

For an overview of how different types of events are classified, see our [page](https://www.predicthq.com/intelligence/data-enrichment/event-categories) about how we categorize!

## Calculating Impact vs. Summing PHQ Attendance

[`phq_attendance`](https://support.predicthq.com/what-is-phq-attendance) is the _overall_ estimated attendance for an event. So no matter if an event with a `phq_attendance` of 10,000 takes place over the course of 1 day or 1 month, the event will show the same value in both cases. To properly model this information on a daily, calendarized basis, we must split the overall attendance figure into equal chunks over the duration of its start and end dates.

## AEI by Event Category and Log Transforms

Determining the daily `impact` (the proportionate, summed `phq attendance` across all events occurring on a specific day) allows a data scientist to incorporate a value representative of the estimated number of people attending (or affected) by events that day to a machine learning model.

Given the (typically) exponential distribution observed in predicted attendance, we recommend to log transform each of the `impact` figures that are computed. While this typically muddies the interpretation of the value being provided to a forecasting algorithm, this process (especially for linear regressors) tends to improve forecasting performance.

## Additional Packages

This assumes the local usage of `pandas>=0.20.0`.

repository: jamesonl/sdk-py

repo_name: jamesonl/sdk-py


text:
# Freezr

(not another) Library to build your immutable data structure.

[![Build Status](https://travis-ci.org/carlesba/freezr.svg?branch=master)](https://travis-ci.org/carlesba/freezr)

## Concerns

There are lots of libraries to build immutable data but most of them avoid the native interface (dotted and bracket notation) so, on one side we're solving immutability problem, but on the other we get new problems:

- **Loose new language features**. Like *[destructuring](https://babeljs.io/docs/learn-es2015/#destructuring)*.
- **Worring about arguments interface**. Your application cannot deal 100% with *[put_your_immutable_library]*'s data structure so when that function gets two objects you can't be sure how to read its data.
- **Problems when using other libraries**. You'd like to use that lodash method or this redux's middleare but you have to transform your immutable-data to plain objects to do it.
- Because ***Object.freeze*** **it's not enough**. Although we freeze all our data we need to do it every time we want to update an object.

Take a look to the [Docs](./docs/index.md)

## Aproach

- Keep **native interface** for reading data, not for writing.
- Provide methods to work in an immutable way even when the native ones can't (ie: Array.push, delete…).
- All methods will return another immutable object.

## Installation

```
npm install freezr --save-dev
```

## Examples

```js
import {freeze, deepFreeze} from 'freezr'

//
// Frozen Objects
//
var obj = {a: 1, b: 2}

var frozenObj = freeze(obj) // fozenObj is immutable
// Alternatively you could use deepFreeze to parse object deeply

frozenObj.a = 3 // won't change
frozenObj.a === 1 // true

//
// Frozen Arrays.
//
var arr = [1, 2, 3]
var frozenArr = freeze(arr)
frozenArr[2] === 3 // true
frozenArr[2] = 'new value' // won't change
frozenArr[2] === 3 // still true

// And it's still an Array
Array.isArray(frozenArr) // true

//
// you can use native methods for arrays
//
var mapped = frozenArr.map((value, index) => {
  return value + 1
}) // [2, 3, 4]

//
// Array methods return frozen elements
//
mapped[0] = 'mutate the array' // won't change
mapped[0] === 2 // true

//
// Destructuring
//
var {a} = frozenObj
a === 1 // true

//
// With objects you can: merge, set, delete, update
//
var merged = frozenObject.merge({a: 2, c: 8})
frozenObject.a === 1 // true
merged.a === 2 // true
merged.c === 8 // true

frozenObject.set('a', 7) // will return another frozen object with ['a'] === 7
frozenObject.delete('a') // will return another frozen object without 'a'
frozenObject.update('a', (a) => {
  return a + 1
})

// And supports keyPath syntax like ImmutableJS
var nestedObject = {
  a: {
    b: {
      c: 'foo'
    }
  }
}
var nestedFrozen = deepFreeze(nestedObject)
var updatedNested = nestedFrozen.setIn(['a', 'b', 'c'], 'bar')
updatedNested.a.b.c === 'bar' // true
// Or using updater callback
var nestedWithUpdater = nestedFrozen.updateIn(
  ['a', 'b'],
  (bObject) => bObject.set('c', 'newBar')
)
nestedWithUpdater.a.b.c === 'newBar' // true
```

repository: carlesba/freezr

repo_name: carlesba/freezr


text:
# :partly_sunny: Weather Certainty
Analysing weather data to predict the certainty of a 7 day forecast.

## Usage
Written in **Python 3** using **matplotlib** for plotting data.

To run the program in a console with no parameters:
```
python weather_certainty.py
```

repository: jrinconada/weather-certainty

repo_name: jrinconada/weather-certainty


text:
# TinyHttp

---

## What is this

TinyHttp is some kind of toy project for java programming  learning. That is why I choose the MIT LICENSE for it.

## Function list

- [x] Load customed settings from json file.
- [x] Response for basic http GET method. (including brainy files)
- [x] 404 status code support.
- [x] 403 status code support.
- [x] Directory content list.
- [ ] Support for POST method. (Untested now)
- [ ] Add support for Content-Encoding such as gzip, deflate and br.
- [ ] Condition request.
- [ ] Support for dynamic resources requests.

## Dependency

|  name |   version    |
| ----: | :----------: |
| maven | 3.5 or later |
|   jdk |     11+      |

- Then the mvn command will automatically download and import all other dependences the project needs

- For pensonal reason, I have started this project based on jdk-11. Besides, No compatibility tests with jdk-8 has been done.

## Run it

- Compile it

    ```shell
    mvn compile
    ```

- Package into single jar file.

    ```shell
    mvn package
    ```

- Run with sample configure.

    ```shell
    cd $(the root directory of this project)
    java -jar target/tinyhttp-$(version).jar -c resources/test/testWeb.json
    ```

- Test it with your web browser, at port 80.

## Develop it

You can fork it into your github repo, or simply clone it. Then work on your own local git branch.

repository: ChanthMiao/tinyhttp

repo_name: ChanthMiao/tinyhttp