text:
# Changelog

As this project is pre 1.0, breaking changes may happen for minor version bumps. A breaking change will get clearly notified in this log.

## 0.7.4

* Update dependencies.
* Remove unused methods.

## 0.7.3

* Allow hex string in setOptions signers

## 0.7.2

* Updated XDR files

## 0.7.1

* Checking hash preimage length

## 0.7.0

* Support for new signer types: `sha256Hash`, `preAuthTx`.
* `StrKey` helper class with `strkey` encoding related methods.
* Removed deprecated methods: `Keypair.isValidPublicKey` (use `StrKey`), `Keypair.isValidSecretKey` (use `StrKey`), `Keypair.fromSeed`, `Keypair.seed`, `Keypair.rawSeed`.
* **Breaking changes**:
  * `Network` must be explicitly selected. Previously testnet was a default network.
  * `Operation.setOptions()` method `signer` param changed.
  * `Keypair.fromAccountId()` renamed to `Keypair.fromPublicKey()`.
  * `Keypair.accountId()` renamed to `Keypair.publicKey()`.
  * Dropping support for `End-of-Life` node versions.

## 0.6.0

* **Breaking change** `ed25519` package is now optional dependency.
* Export account flags constants.

## 0.5.7

* Fixes XDR decoding issue when using firefox

## 0.5.6

* UTF-8 support in `Memo.text()`.

## 0.5.5

* Make 0 a valid number for transaction fee,
* Fix signer in Operation.operationToObject() - close #82

## 0.5.4

* Fixed Lodash registering itself to global scope.

## 0.5.3

* Add support for ManageData operation.

## 0.5.2

* Moved `Account.isValidAccountId` to `Keypair.isValidPublicKey`. It's still possible to use `Account.isValidAccountId` but it will be removed in the next minor release (breaking change). (af10f2a)
* `signer.address` option in `Operation.setOptions` was changed to `signer.pubKey`. It's still possible to use `signer.address` but it will be removed in the next minor release (breaking change). (07f43fb)
* `Operation.setOptions` now accepts strings for `clearFlags`, `setFlags`, `masterWeight`, `lowThreshold`, `medThreshold`, `highThreshold`, `signer.weight` options. (665e018)
* Fixed TransactionBuilder timebounds option. (854f275)
* Added `CHANGELOG.md` file.

## 0.5.1

* Now it's possible to pass `price` params as `{n: numerator, d: denominator}` object. Thanks @FredericHeem. (#73)

## 0.5.0

* **Breaking change** `sequence` in `Account` constructor must be a string. (4da5dfc)
* **Breaking change** Removed deprecated methods (180a5b8):
  * `Account.isValidAddress` (replaced by `Account.isValidAccountId`)
  * `Account.getSequenceNumber` (replaced by `Account.sequenceNumber`)
  * `Keypair.address` (replaced by `Keypair.accountId`)
  * `Network.usePublicNet` (replaced by `Network.usePublicNetwork`)
  * `Network.useTestNet` (replaced by `Network.useTestNetwork`)
  * `TransactionBuilder.addSigner` (call `Transaction.sign` on build `Transaction` object)

repository: DU-Crypto/jarvis-token

repo_name: DU-Crypto/jarvis-token


text:
# JSON Organizer

![Icon](./images/icon.png)

This extension will help you toggle between JSON and JavaScript object format.

## Usage

Select JSON in a text editor and press `Ctrl+Y` or `Cmd+Y` to switch between Object and JSON formats.

## Demo

Press `CTRL+Y` or `CMD+Y` (in Mac) to switch the selection between Object and JSON formats.

![Demo](./doc/demo.gif)

## Contributing

Contributions are very welcome! Just send a pull request. Feel free to contact me or checkout my [Github](https://github.com/rintoj/json-organizer) page.

## Author

**Rinto Jose** (rintoj)

Follow me:
  [Github](https://github.com/rintoj)
| [Facebook](https://www.facebook.com/rinto.jose)
| [Twitter](https://twitter.com/rintoj)
| [Google+](https://plus.google.com/+RintoJoseMankudy)
| [Youtube](https://youtube.com/+RintoJoseMankudy)

## License

```
The MIT License (MIT)

Copyright (c) 2016 Rinto Jose (rintoj)

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

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

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

**Enjoy!**

license: MIT

repository: rintoj/json-organizer

branch_name: refs/heads/master

extension: md

gha_language: TypeScript

gha_license_id: MIT

license_type: permissive

repo_name: rintoj/json-organizer


text:
# BigDL Orca Developer Guide

This is a simple guide for developers to setup their development environment. You do **not** need to read this if you are just using Orca APIs.

## Prerequisite

- Linux OS
- JDK (e.g. `sudo apt-get install openjdk-8-jdk`)
- Maven (e.g. `sudo apt install maven`)
- Conda (Optional)

## Get BigDL source code

```bash
git clone https://github.com/intel-analytics/BigDL.git
```

## Build BigDL scala code

```bash
cd BigDL/scala
./make-dist.sh
```

After running the above code there will be a `BigDl/dist` directory consisting of the built artifact.

## Set up python environment

### PyTorch Development (pytorch_ray_estimator, pytorch_pyspark_estimator, not including pytorch_spark_estimator)

1. Install minimal dependencies

```bash
pip install pyspark==2.4.3 # ./make-dist.sh build against spark 2.4.3 by default
pip install ray==1.9.2
pip install aiohttp==3.7.4 # dependencies introduced by ray, latest version has api changes
pip install aioredis==1.3.1 # dependencies introduced by ray, latest version has api changes
pip install pytest pyarrow pandas
pip install bigdl-math bigdl-tf # dependencies introduced by bigdl-orca
pip3 install torch==1.10.1+cpu torchvision==0.11.2+cpu torchaudio==0.10.1+cpu -f https://download.pytorch.org/whl/cpu/torch_stable.html
```

2. Set a few environment variables

```bash
cd BigDL/python/orca
source dev/prepare_env.sh
```

3. Run tests to verify environment

```bash
cd BigDL/python/orca
pytest test/bigdl/orca/learn/spark/test_pytorch_estimator.py
```

4. Please raise an issue if the above steps does not work

repository: intel-analytics/BigDL

branch_name: refs/heads/main

gha_language: Jupyter Notebook

repo_name: intel-analytics/BigDL


text:
# User Stories

Create at least 10 user stories in VSTS,
divided amongst your two applications.

## What are User Stories?
- Are short, simple, and open for interpretation
- Should clearly communicate the end goal of the user
- Includes Acceptance Testing

## INVEST In Your User Stories
- **Independent**: The user story should be self-contained, in a way that there is no inherent dependency on another user story
- **Negotiable**: user stories, up until they are part of an iteration, can always be changed and rewritten
- **Valuable** to users or Customers: a user story must deliver value to the end user
- **Estimable**: You must always be able to estimate the size of a user story.
- **Small**: User stories should not be so big as to become impossible to plan/task/prioritize  with a certain level of certainty
- **Testable**: the user story or it's related description must provide the necessary information to make test development possible.

## What Does It Look like?
- "As a \<role>, I want \<goal> so that \<benefit>" ("so that ..." is optional if no explanation is needed)
- As a user, I want to search for my customers by their first and last names so that I can quickly navigate to their accounts.
- As a non-administrative user, I want to modify my own schedules but not the schedules of other users.

## Example
- As an administrative user, I want the ability to modify all employee's schedules.

### Features:
- Admin can choose which users schedules to view/edit
- Show the options for all employees schedules
- Select ability to have recurring schedules
- Save schedule changes

### Acceptance:
- Ensure that the employee the admin picked links to the correct schedule
- Ensure the scheduling does not interfere with requested time off
- Ensure that the schedules successfully save into database
- Provide error message and abort transaction if system becomes unavailable

gha_language: C#


text:
# git-training
A short but sweet session on git

# Instructions

### Basics
1. Clone this repo under a custom-named folder
2. Create a file called "test.txt" with any content in it
3. Create a file called "another-file.txt" with any content in it
4. Create a file called "one-more-file.txt" with any content in it
5. Add all files (How many ways do you know?)
6. How do you unstage a file?
7. Add all files
8. Commit with a message of your choosing
9. Push the changes to remote

### Branches
1. Create a new branch in the format yourname-feature/TASK-ID-featurename
2. Check out that branch
3. Create a file called "whatever.txt" with random content inside

repository: wasspds/git-training

repo_name: wasspds/git-training


text:
# Directory Structure

![top-page](https://github.com/GraphicalModelLab/GML_SaaS/blob/master/doc/BigPictureOfGMB.png)

### auth
This directory corresponds to (1) Authentication Service in the above diagram.

This service handles processing about authentication, e.g. Federated Login, issuing Access token, etc.

### gml
This directory corresponds to (2) gml Service in the above diagram.

This service serves requests other than authentication, e.g. search the saved graph models, calculate graph stuff, etc.

### gml_api
This directory is separated from other services for plugins.

When you develop plugins for GML service, you include this dependency to develop your own plugin.

### common
This directory contains some common tools.

# Dependencies

| Dependencies        | Version           | Description |
| ------------- |-------------|-------------|
| Cassandra |  3.0.1 | Used to store all information, e.g. graph information |
| Elastic Search |  6.3.1 | Used to index graph information. Users can search graph by tag search menu in header menus. |

# How to package gmb service

```
cd <Your Path>/gmb
sbt dist
```

After sbt dist command, zip file is generated, which can be unzipped/deployed to the desired directory.
After unzipping the file, bin folder includes shell script to run gmb service.

infra/ansible/roles/gml/template/supervisor/gml-company.conf shows an example about how to start the service

# Encryption Mode
If you want to encrypt data stored in Cassandra (note: not all data is encrypted. Check out the ProdModule to see what implementation of AuthDB is used. AuthDB implemention shows which part of data is encrypted.), enable this mode.

Currently, AuthDBClientEncryptingImpl encrypt data related to credentials, e.g. Google Accesstoken, Facebook AccessToken.

```
[ auth/conf/application.conf ]
# This is ProdMode where some data in Cassandra is encrypted, which uses AuthDBClientEncryptingImpl
play.modules.enabled += "modules.ProdModule"

# This is DevMode where any data in Cassandra is not encrypted, which uses AuthDBClientImpl
#play.modules.enabled += "modules.DevModule"

...
# Encryption Secret key for encrypting data in Cassandra is stored in the below file in ProdMode. In DevMode, this config is ignored.
encryption.secret.write.location="/Users/itomao/gml_auth_secret"

[ gml/conf/application.conf ]
# This is ProdMode where some data in Cassandra is encrypted, which uses AuthDBClientEncryptingImpl
play.modules.enabled += "modules.ProdModule"

# This is DevMode where any data in Cassandra is not encrypted, which uses AuthDBClientImpl
#play.modules.enabled += "modules.DevModule"

...
# Encryption Secret key for encrypting data in Cassandra is read from the below file in ProdMode. In DevMode, this config is ignored.
encryption.secret.read.location="/Users/itomao/gml_auth_secret"

```

auth service generate secret key and write that key into a file located in "encryption.secret.write.location".

Then, gml service load secret key stored by auth service.

We need to make sure that two services are using the same secret key or gml fails to decrypt data in Cassandra.

# How to Debug
If you use IntelliJ IDEA or other stuff like Eclipse, you can create SBT task like the below:

![top-page](https://github.com/GraphicalModelLab/GML_SaaS/blob/master/doc/DebugGMB.png)

# Generate KeyStore and Truststore for Server side (i.e. playframework)
If you want to enable SSL between PHP and gmb services (Auth and GML),
then you need to setup keystore and truststore.

```
# Generate KeyStore with a pair of key
keytool -genkey -keystore serverKeystore.jks -alias server

# Get Public Key
keytool -export -keystore serverKeystore.jks -alias server -file server.cer

# Generate Truststore
keytool -import -file ./server.cer -alias servercer -keystore serverTrustStore.jks

```

```
# Specify Truststore to JVM
-Djavax.net.ssl.trustStore=/Users/itomao/git/gmb/auth/conf/cert/serverTrustStore.jks
```

gha_language: Scala


text:
---
layout: default
---

# 1997-12-16 - Re: hashcash spam prevention & firewalls (fwd)

## Header Data

From: Bill Frantz<EMAIL_ADDRESS>To: Jim Choate<EMAIL_ADDRESS>(Cypherpunks Distributed Remailer)

Message Hash: 8997d60322f639f8fa608cdf1abfc8fe6ac5c1e396d5f6133d5dd2444a36c307

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1997-12-16 08:12:07 UTC

Raw Date: Tue, 16 Dec 1997 16:12:07 +0800

## Raw message

```
{% raw  %}From: Bill Frantz<EMAIL_ADDRESS>Date: Tue, 16 Dec 1997 16:12:07 +0800
To: Jim Choate<EMAIL_ADDRESS>(Cypherpunks Distributed Remailer)
Subject: Re: hashcash spam prevention & firewalls (fwd)
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

At 6:09 AM -0800 12/13/97, Jim Choate wrote:
>Forwarded message:
>
>> Date: Fri, 12 Dec 1997 20:24:59 -0800
>> From: Bill Frantz<EMAIL_ADDRESS>>> Subject: Re: hashcash spam prevention & firewalls
>
>> I think there needs to be a story for mailing lists.  It might be
>> acceptable for the first pass to allow spamming of mailing lists but not of
>> individuals email addresses.  (Apologies in advance to list moderators.)
>
>We have a moderator? This is news to me and I suspect the other CDR
>operators. Who is this person please, I would very much like to discuss a
>couple of issues with them...

This isn't the only mailing list in the world.  Some lists do have moderators.

-------------------------------------------------------------------------
Bill Frantz       | One party wants to control | Periwinkle -- Consulting
(408)356-8506     | what you do in the bedroom,| 16345 Englewood Ave.
<EMAIL_ADDRESS>| the other in the boardroom.| Los Gatos, CA 95032, USA

{% endraw %}
```

## Thread

+ Return to [December 1997](/archive/1997/12)

+ Return to "[Adam Back <aba@dcs.ex.ac.uk>](/authors/adam_back_aba_at_dcs_ex_ac_uk_)"
+ Return to "[Bill Frantz <frantz@netcom.com>](/authors/bill_frantz_frantz_at_netcom_com_)"
+ Return to "[Jim Choate <ravage@ssz.com>](/authors/jim_choate_ravage_at_ssz_com_)"

+ 1997-12-13 (Sat, 13 Dec 1997 21:56:51 +0800) - [Re: hashcash spam prevention & firewalls (fwd)](/archive/1997/12/f49376beb2dc6e2960dc2e992921a7183835f02241ca0684568732d5e95a385a) - _Jim Choate<EMAIL_ADDRESS>  + 1997-12-13 (Sun, 14 Dec 1997 02:07:01 +0800) - [Re: hashcash spam prevention & firewalls (fwd)](/archive/1997/12/140b76b8423c5aa606fec9c733abdeb6b83f832e3c4b5007010e55034855a48a) - _Adam Back<EMAIL_ADDRESS>  + 1997-12-16 (Tue, 16 Dec 1997 16:12:07 +0800) - Re: hashcash spam prevention & firewalls (fwd) - _Bill Frantz<EMAIL_ADDRESS>


text:
# v1.8.0

## Changes

* Added [PDF invoices](../digging-deeper/payments.md#pdf-invoices) and
 ["export as PDF" support for wishlists](../development/wishlist-model.md)

## Required actions

### `Wishlists` Component

A new "Download as PDF" button was added to the `Wishlists` component. If you did override
the `contents.htm` partial manually and wish to offer the PDF download option, make
sure to update your partial.

See [Commit](https://github.com/OFFLINE-GmbH/oc-mall-plugin/commit/b0bfe6a9349c4e049f990f02a4e9c71b442b4df1#diff-a7bdbfca77c921515277424280815187)

repository: OFFLINE-GmbH/oc-mall-plugin

branch_name: refs/heads/develop

gha_language: PHP

repo_name: OFFLINE-GmbH/oc-mall-plugin


text:
# Enumeration: ChangeType

## Table of contents

### Enumeration Members

- [Delete](../../devkit/documents/ChangeType#delete)
- [Insert](../../devkit/documents/ChangeType#insert)

## Enumeration Members

### Delete

• **Delete** = `"Delete"`

---

### Insert

• **Insert** = `"Insert"`

repository: nrwl/nx

repo_name: nrwl/nx


text:
Welcome To The New Evolution In Sauce Labs Testing.
The goal of Sauce Bindings is to make your test automation and integration in Sauce Labs, simple :)
Our fluent API helps you to understand all of the possible browser/OS combinations at design time.
You no longer need to read extensive docs, just let your IDE guide you 😉

## Quick Start with a single line of code
```
WebDriver driver = new SauceSession().start();
//now use the driver to interact with your test in Sauce Labs
driver.findElement("id").click();
```

## Installation

[Installation instructions](https://opensource.saucelabs.com/sauce_bindings/getting-started)

## Building

Make sure you have the common Sauce Bindings [prerequisites](https://github.com/saucelabs/sauce_bindings#getting-started-and-prerequisites) set up, as well as

-  Java 8+ JDK,
-  Maven,
-  Your favorite Java IDE ([IntelliJ](https://www.jetbrains.com/idea/download/index.html) preferred but not required).

The Java Sauce Bindings are designed as a standard Maven project and follow Maven conventions.

## Local development

First clone this project, either directly or from a fork. The following instructions will be based on a local clone of the Sauce Bindings repository.

To create a `.jar` of the Java bindings in their current state in your local repository, run

```bash
mvn package
```

in the `java/` (root) directory. This will create a `.jar` file in the `java/target/` directory which you can them use as you like.

If you'd like to make Sauce Bindings available to other local projects via Maven, run

```bash
mvn install
```

in the `java/` directory. This will allow you to import Sauce Bindings as a Maven dependency in other local projects on your laptop as a snapshot of the state based on the commit that you build from. To add this reference via Maven, add

```xml
<dependency>
    <groupId>com.saucelabs</groupId>
    <artifactId>sauce_bindings</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>
```

to other projects' `pom.xml` file to access Sauce Bindings. Note that adding these coordinates to other Maven projects will get the latest `1.0-SNAPSHOT` version that was built, and so using these coordinates are recommended for development and not for general usage.

## Testing

To execute the test suite, run

```bash
mvn test
```

Tests will also be automatically executed as part of the building process.

## Deploying

#### Prerequisites
1.	Ensure you have access to Sauce Repository on Sonatype: https://issues.sonatype.org/browse/OSSRH-34416
2.	Install gpg2

#### Release
1. Execute in terminal: `mvn release:prepare`
    * This does:
        * Runs the tests to ensure passing
        * Removes the `SNAPSHOT` from the version in the `pom.xml`
        * Commit changes and tags the release
        * Bumps version to next development version with `SNAPSHOT`
        * Commit changes

2. Answer Questions:
    * "What is the release version for "saucebindings"? (com.saucelabs:sauce_bindings) 1.0.1"
        * Major Releases indicate backward incompatible changes
        * Minor Releases indicate new features available in all languages
        * Point Releases are for updates to language specific functionality
    * "What is SCM release tag or label for "saucebindings"? (com.saucelabs:sauce_bindings) sauce_bindings-1.0.1"
        * use format: "java-1.0.1"
    * "What is the new development version for "saucebindings"? (com.saucelabs:sauce_bindings) 1.0.2-SNAPSHOT"
        * hit enter

3. Execute in terminal: `GPG_TTY=$(tty) mvn release:perform`
    * This does:
        * Runs the tests to ensure passing
        * Builds Jar
        * Uploads artifacts to maven profile


text:
# server-deployment-practice

## URL links for Heroku

- dev branch
  [omar-server-deploy-dev](https://omar-server-deploy-dev.herokuapp.com/)

- main branch
  [omar-server-deploy-prod](https://omar-server-deploy-prod.herokuapp.com/)

- Github Pull Request
  [Pull-Request](https://github.com/Omar-Tarawneh/server-deployment-practice/pull/2)

- Action
  [Action](https://github.com/Omar-Tarawneh/server-deployment-practice/actions)

## Data Flow Diagram

![data-flow-diagram](img/Lab01-v2.png)

## Download And Start

- Clone the Repository into your local machine
- Get into the repo directory
  `cd server-deployment-practice`

- Install the dependences for tha app
  `npm install`

- Add your dotenv File and add your PORT
  `touch .env`
  `PORT=3000`

- Test the functionality of the app by typing:
  `npm test`

- If the test are passed start the server by typing:
  `npm start`

gha_language: JavaScript


text:
## Version 2
### 2.1.0 (2015-07-19)
 * Updating dependencies
 * Adding Content Grouping support by @lombo

### 2.0.0 (2015-07-03)
 * Upgrading to Guzzle 6
 * Removing support for PHP 5.4 (use version 1 for that)

## Version 1
### 1.2.0 (2015-07-19)
 * Updating dependencies
 * Adding Content Grouping support by @lombo

### 1.1.5 (2015-07-03)
 * Updating dependencies
 * Creating separate branches to maintain v1 and v2 apart

### 1.1.4 (2015-04-18)
 * Updating dependencies
 * Including Yii 2 integration by @baibaratsky
 * Placing project in CI with PHP 5.6 and 7

### 1.1.3 (2015-03-17)
 * Updating dependencies
 * Using caret for declaring dependencies in Composer, as per author's recommendation

### 1.1.2 (2015-03-07)
 * Creating setAsyncRequest(boolean $isAsyncRequest) method to be used instead of makeNonBlocking(). Its more flexible.
 * makeNonBlocking() is now deprecated, use setAsyncRequest() instead. To be removed in next major release.

### 1.1.1 (2015-02-26)
 * Changing HTTPS endpoint to official one in Google documentation
 * Adding Data Source parameter
 * Adding Geographical Override parameter

### 1.1.0 (2015-02-25)
 * Adding the capability of sending hits to GA in an asynchronous way (non-blocking)

### 1.0.1 (2015-02-03)
 * Minor bug fixes

### 1.0.0 (2015-01-30)

 * First stable release
 * Full implementation of GA measurement protocol (AFAIK, feel free to open issue/pull request)
 * 100% code coverage for unit tests
 * Only missing documentation and integration tests to be added in next minor release

### 0.1.1 (2014-10-01)

  * Fixing bug where ecommerce transaction was not collected because data was being sent as POST body instead
  of URL query parameters

### 0.1.0 (2014-09-25)

  * Added send pageview and event
  * All required parameters for pageview and events implemented
  * Alpha testing of transaction tracking with Enhanced Ecommerce

### 0.1-alpha.0 (2014-09-24)

  * Initial release


text:
---
layout: post
title: Run CUBA on AWS ECS - Part 3
description:
modified: 2016-08-09
tags: [cuba, AWS, ECR, cloud, ECS]
image:
  feature: cuba-on-aws-ecs-part-3/feature.jpg
  feature_source: https://pixabay.com/de/alaska-gletscher-eis-bergen-810433/
---

...

<!-- more -->

### Cloud watch logs for central container logging

Instead of logging into the EC2 instance to get the Docker container logs we will instead use [AWS cloud watch logs](http://docs.aws.amazon.com/AmazonCloudWatch/latest/DeveloperGuide/CWL_GettingStarted.html). ECS has a integration to cloud watch logs. It takes STDOUT and STDERR from the Docker container and pushes it into the logging system, where we can easily retrieve the information from tomcat in a web UI. To get that going the only thing that has to be done is to [create](https://console.aws.amazon.com/cloudwatch/home?region=us-east-1#logs:) a log group in your preferred AWS region. Then you define the name of the log group in the JSON key *awslogs-group*. After that the logs will be send to the central logging system.


text:
---
name: Jason Lally
work_title: Data Services Manager
email<EMAIL_ADDRESS>bio: 'Data Services Manager, City and County of San Francisco'
gravatar: 8614bd4a1d6f6c24c0f6b08a2b9c0335
twitter: synchronouscity
headshot_image_path: /uploads/jason-lally.jpg
instructor: 'Yes'
---

Jason Lally is the Data Services Manager, working with the City’s Chief Data Officer, Joy Bonaguro, to help operationalize the City’s data strategy. Jason comes to the City by way of a Mayor’s Innovation Fellowship that wrapped up in August 2014. Before that, he worked at the intersection of technology and urban planning as Director of the Decision Lab at PlaceMatters in Denver, CO. He came to open government and open data through his work in cities and regions across the country on data-informed, community planning processes. Recognizing a need for more robust information services and platforms to support strong community engagement, Jason is pleased to contribute to making data more accessible and useful at the City. Jason earned his Masters in City and Regional Planning from the University of Pennsylvania.


text:
Leaflet Homework - Visualizing Data with Leaflet

:earth_americas:https://plqualls.github.io/Leaflet-challenge/

Background

We have been hired as a scientists for the United States Geological Survey (USGS) which is responsible for providing scientific data about natural hazards, the health of ecosystems and environment; and the impacts of climate and land use change. The responsibility of the scientists develop new methods and tools to supply timely, relevant, and useful information about the Earth and its processes.

Objective

A new project which consists of building a new set of tools that will allow the visualization of earthquake data.  A massive amount of data has been collected and the ultimate goal is to be able
to visualize the data efficiently and better educate the public and other government organizations on issues facing our planet.

:clipboard:Tasks To Complete

Level 1: Basic Visualization(Required)

Get Data Set: Visit page and pick a data set to visualize. When you click on a data set, for example 'All Earthquakes from the Past 7 Days', you will be given a JSON representation of that data. You will be using the URL of this JSON to pull in the data for our visualization.

Import & Visualize the Data: Create a map using Leaflet that plots all of the earthquakes from your data set.

Data markers should reflect the magnitude of the earthquake by their size and depth of the
earthquake by color. Earquakes with high magnitudes should appear larger and earthquakes
with greater depth should appear darker in color.

Include popups that provide additional information about the earthquake when a marker is clicked.

Create a legend that will provide context for your map data.

Level 2: More Data (Optional)

The company wants us to plot a second data set on the map to illustrate the relationship between tectonic plates and seismic activity.  A second data set is required to visualize it along side the original data set. The second data set will be found at https://github.com/fraxen/tectonicplates

Plot a second data set on the map.

Add a number of base maps to choose from as well as separate out the two different data sets into overlays that can be turned on and off independently.

Add layer controls to the map.

repository: plqualls/Leaflet-challenge

repo_name: plqualls/Leaflet-challenge


text:
---
last_modified_on: "2020-07-13"
$schema: "/.meta/.schemas/highlights.json"
title: "The `splunk_hec` sink does not index fields by default"
description: "This gives you full control over which fields are indexed"
author_github: "https://github.com/binarylogic"
pr_numbers: [1537]
release: "0.7.0"
hide_on_release_notes: false
tags: ["type: breaking change", "domain: sinks", "sink: splunk_hec"]
---

There is no longer a distinction within Vector between explicit and implicit
event fields. All fields are now implicit and therefore the `splunk_hec` sink
will _not_ index any fields by default.

## Upgrade Guide

In order to mark desired fields as indexed you can use the optional
configuration option `indexed_fields`:

```toml title="vector.toml"
 [sinks.my_sink_id]
   type = "splunk_hec"
   inputs = ["my-source-id"]
+  indexed_fields = ["foo", "bar"]
```

repository: alakahakai/vector

repo_name: alakahakai/vector


text:
---
layout: post
title:      "To Infinity and Beyond! !"
date:       2018-08-23 17:45:53 +0000
permalink:  to_infinity_and_beyond
---

[](http://muellerconnect.com/wp-content/uploads/2017/10/05-10-2017_Infinity-1.png)
Loops are very useful. They gives us a way to write code efficiently.
But what's instersting about loops is that on their own they can break out program!
If we aren't careful they can take us to an infinte never ending loop that we cannot get out of.
That's why it's so important to include a break in our loop. This is such a simple subtle part of loop but it is very crucial.
Unless we want to be thrown into the realm of infinity we must not forget the *break*!!

extension: markdown


text:
---
layout: default
title: Arduino USB Serial firmware from scratch
tags: arduino usb serial programming avr atmel studio
comments: true
---
# Arduino USB Serial firmware from scratch

I have need to change the USB descriptors of an Arduino Uno R3 acting as a peripheral to another device. This post describes how I built a [USB Serial firmware](https://github.com/tewarid/arduino-usb-serial) for the ATmega16U2 on an Arduino Uno R3, using Atmel Studio 7 and its LUFA Library extension. It can be flashed using the built-in DFU firmware and Atmel's [FLIP](http://www.microchip.com/developmenttools/productdetails.aspx?partno=flip) tool.

Source files that perform the actual USB/serial proxying are derived from USB to Serial Converter example project for the at90usb1287 (File -> New -> Example Project...). I suggest creating a project based on that example and copying the files over. I have also borrowed code from the official [source code](https://github.com/arduino/ArduinoCore-avr/tree/master/firmwares/atmegaxxu2/arduino-usbserial) at GitHub to enable additional functionality such as allowing a sketch to be uploaded from the Arduino IDE.

![USB to Serial Converter Example Project](/assets/img/atmel-studio-usb-serial-converter.png)

Install LUFA Library extension if not already installed (Tools -> Extensions and Updates...)

![Install LUFA Extension](/assets/img/atmel-studio-install-lufa.png)

Create a new project for the ATmega16U2 (File -> New -> Project...)

![New Atmel Studio Board Project](/assets/img/atmel-studio-new-asf-board-project.png)

![Board Selection](/assets/img/atmel-studio-board-atmega16u2.png)

Use ASF Wizard (ASF -> ASF Wizard) to add LUFA modules and remove the Generic board support (driver) module.

![ASF Wizard](/assets/img/atmel-studio-asf-wizard-lufa.png)

Configure GCC symbols (Project -> Properties). Change `BOARD` to `BOARD_UNO`, and add `F_CPU=16000000UL` and `F_USB=16000000UL`.

![GCC symbols](/assets/img/atmel-studio-symbols-usb-serial.png)

Copy over source files from the example project mentioned earlier. Resolve any build errors.

Flash (Tools -> Device Programming) the firmware using the FLIP tool

![Flash using FLIP](/assets/img/atmel-flip-usb-serial.png)

Reboot the Arduino.

gha_language: Ruby


text:
# Fitness Tracker

## Description
Help keep track of workouts and fitness related statistics

## Table of Contents
If your README is long, add a table of contents to make it easy for users to find what they need.
- [Installation](#installation)
- [Usage](#usage)
- [Credits](#credits)
- [License](#license)
- [Features](#features)
- [Contribute](#contribute)
- [Questions](#questions)

## Installation
deployed link: https://safe-brook-08237.herokuapp.com/

## Usage
Use to save fitness information and get workout summaries

## Credits
Johsua Galvez

## License
MIT License

## Features
Fitness

## Contribute
me

## Questions
Github: https://github.com/joshuagalvez11/fitness-tracker

Email<EMAIL_ADDRESS>


text:
# yyplayer
A video player

## Usage

### Prequisites
- CMake (Version >= 3.1)
- Clang (Version >= 900.0.38)
- FFmpeg (Version >= 3.4.2)

### Install

```bash
mkdir -p build && cd build/
cmake ..
make
```

The binary file will be generated at bin/ , you can directly open the program by

```bash
cd ../bin
./player file_path
```


text:
Android Things user-space drivers
=================================

Sample peripheral drivers for Android Things.

NOTE: these drivers are not production-ready. They are offered as sample
implementations of Android Things user space drivers for common peripherals
as part of the Developer Preview release. There is no guarantee
of correctness, completeness or robustness.

How to use a driver
===================

For your convenience, drivers in this repository are also published to JCenter
as Maven artifacts. Look at their artifact and group ID in their build.gradle
and add them as dependencies to your own project.

For example, to use the `button` driver, version `0.1`, simply add the line
below to your project's `build.gradle`:

```
dependencies {
    compile 'com.google.android.things.contrib:driver-button:0.1'
}
```

Current contrib drivers
-----------------------

Driver | Type | Usage (add to your gradle dependencies) | Sample code
:---:|:---:| --- | ---
[driver-apa102](apa102) | RGB LED strip |`compile 'com.google.android.things.contrib:driver-apa102:<version>'`
[(see latest version)](https://bintray.com/google/androidthings/contrib-driver-apa102/_latestVersion) |[sample](https://github.com/androidthings/drivers-samples/tree/master/apa102)
[driver-bmx280](bmx280) | temperature and pressure sensor |`compile 'com.google.android.things.contrib:driver-bmx280:<version>'`
[(see latest version)](https://bintray.com/google/androidthings/contrib-driver-bmx280/_latestVersion) |[sample](https://github.com/androidthings/drivers-samples/tree/master/bmx280)
[driver-button](button) | push button over GPIO |`compile 'com.google.android.things.contrib:driver-button:<version>'`
[(see latest version)](https://bintray.com/google/androidthings/contrib-driver-button/_latestVersion) |[sample](https://github.com/androidthings/drivers-samples/tree/master/button)
[driver-cap12xx](cap12xx) | capacitive touch buttons |`compile 'com.google.android.things.contrib:driver-cap12xx:<version>'`
[(see latest version)](https://bintray.com/google/androidthings/contrib-driver-cap12xx/_latestVersion) |[sample](https://github.com/androidthings/drivers-samples/tree/master/cap12xx)
[driver-gps](gps) | GPS |`compile 'com.google.android.things.contrib:driver-gps:<version>'`
[(see latest version)](https://bintray.com/google/androidthings/contrib-driver-gps/_latestVersion) |[sample](https://github.com/androidthings/drivers-samples/tree/master/gps)
[driver-ht16k33](ht16k33) | 7-digit alphanumeric segment display |`compile 'com.google.android.things.contrib:driver-ht16k33:<version>'`
[(see latest version)](https://bintray.com/google/androidthings/contrib-driver-ht16k33/_latestVersion) |[sample](https://github.com/androidthings/drivers-samples/tree/master/ht16k33)
[driver-mma7660fc](mma7660fc) | accelerometer sensor |`compile 'com.google.android.things.contrib:driver-mma7660fc:<version>'`
[(see latest version)](https://bintray.com/google/androidthings/contrib-driver-mma7660fc/_latestVersion) |[sample](https://github.com/androidthings/drivers-samples/tree/master/mma7660fc)
[driver-pwmservo](pwmservo) | PWM servo |`compile 'com.google.android.things.contrib:driver-pwmservo:<version>'`
[(see latest version)](https://bintray.com/google/androidthings/contrib-driver-pwmservo/_latestVersion) |[sample](https://github.com/androidthings/drivers-samples/tree/master/pwmservo)
[driver-pwmspeaker](pwmspeaker) | PWM speaker/buzzer |`compile 'com.google.android.things.contrib:driver-pwmspeaker:<version>'`
[(see latest version)](https://bintray.com/google/androidthings/contrib-driver-pwmspeaker/_latestVersion) |[sample](https://github.com/androidthings/drivers-samples/tree/master/pwmspeaker)
[driver-rainbowhat](rainbowhat) | metadriver for the Rainbow HAT |`compile 'com.google.android.things.contrib:driver-rainbowhat:<version>'`
[(see latest version)](https://bintray.com/google/androidthings/contrib-driver-rainbowhat/_latestVersion) |[sample](https://github.com/androidthings/weatherstation)
[driver-ssd1306](ssd1306) | OLED display |`compile 'com.google.android.things.contrib:driver-ssd1306:<version>'`
[(see latest version)](https://bintray.com/google/androidthings/contrib-driver-ssd1306/_latestVersion) |[sample](https://github.com/androidthings/drivers-samples/tree/master/ssd1306)
[driver-tm1637](tm1637) | 4-digit numeric segment display |`compile 'com.google.android.things.contrib:driver-tm1637:<version>'`
[(see latest version)](https://bintray.com/google/androidthings/contrib-driver-tm1637/_latestVersion) |[sample](https://github.com/androidthings/drivers-samples/tree/master/tm1637)

License
-------

Copyright 2016 Google Inc.

Licensed to the Apache Software Foundation (ASF) under one or more contributor
license agreements.  See the NOTICE file distributed with this work for
additional information regarding copyright ownership.  The ASF licenses this
file to you under the Apache License, Version 2.0 (the "License"); you may not
use this file except in compliance with the License.  You may obtain a copy of
the License at

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

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

repository: mangini/contrib-drivers

repo_name: mangini/contrib-drivers


text:
---
title: Platform Abuse
icon: warning
toc: true
---

### Report abusive behavior

The Fielding Townsend App Centre strives to provide an environment where people can feel free to share their creativity. If abusive behavior happens, we want to make it easy for people to report it to us. Multiple apps can be included in the same report, helping us gain better context, while investigating the issues to get them resolved faster.

Note: For specifics about our abusive behavior policy, please read the [AppSplash ToCs](https://compliance.fieldingtownsend.com/appsplash)

To report an application you need some information first:

*   The application's unique ID
*	The publisher's ID

You can find these in the apps **About This App** page.

When you have these details simply send us a message using the contact us form.


text:
# imports-first

By popular demand, this rule reports any imports that come after non-import
statments.

## Rule Details

```js
import foo from './foo'

// some module-level initializer
initWith(foo)

import bar from './bar' // <- reported
```

Providing `absolute-first` as an option will report any absolute imports (i.e.
packages) that come after any relative imports:

```js
import foo from 'foo'
import bar from './bar'

import * as _ from 'lodash' // <- reported
```

TODO: add explanation of imported name hoisting

## When Not To Use It

If you don't mind imports being sprinkled throughout, you may not want to
enable this rule.

repository: msimulcik/eslint-plugin-import

repo_name: msimulcik/eslint-plugin-import


text:
# `extra-spoon`
*Various added features for the Spoonacular recipes API*

---

## Instructions
<!-- In the markdown, numbering each as 1 allows us to not worry about actual ordering. The numbers will display correctly. -->
1. Create an account at RapidAPI.com (you can log in with Github) and get a RapidAPI key.
1. Create a `.env` file at the root of the project and add your api key:
    ```
    # .env
    RAPID_API_KEY=your-rapid-api-key
    ```
1. Run the server
    ```
    $ node ./dist/server.js
    ```

1. In a browser, visit http://localhost:8081/?url=YOUR_RECIPE_URL

   > For example: http://localhost:8081/?url=http://www.melskitchencafe.com/the-best-fudgy-brownies/

1. The server returns a version of the page with the instructions split by sentence.

For example, this:

1. Crack eggs. Mix eggs.
2. Cook eggs.

Becomes this:

1. Crack eggs.
2. Mix eggs.
3. Cook eggs.

To use this newly split-up recipe in your favorite recipe app, visit https://extra-spoon.herokuapp.com/ and provide the
url parameter as above. Note that it doesn't appear that you can do this when running the local server, because AnyList
visits the full url you send to it, and it of course can't access your local host.

## Verified sites

Site | Works | Doesn't Work
--- | --- | --- |
https://www.melskitchencafe.com/the-best-fudgy-brownies/ | X |
https://cooking.nytimes.com/recipes/1020596-vegetarian-mushroom-wellington | X
https://www.gimmesomeoven.com/best-chicken-enchiladas-ever/#tasty-recipes-59596 | X

## About

Spoonacular's `GET /recipes/extract` endpoint is a great resource for parsing an online recipe. I've been working on a
recipe reader app myself, but until that's done I love AnyList, whose Chrome extension makes it super easy to import a
recipe from a website in just two clicks. I suspect that they use the Spoonacular API under the hood.

One thing I'd like to add to the API is a way to make recipe instructions more granular. In a written recipe, a single
numbered step might include many many actions, and when you have an app that focuses on the current step, this feature's
utility is greatly reduced if you then have to focus yourself on a step within the step!

We accomplish this by getting the instructions, splitting them up myself, and replacing them in the two places they
appear on the page:

1. In the text list shown to the user (`<li>` tags)
2. In the script tag that gives all the info about the recipe. we simply replace the value of the `recipeInstructions`
   key with our own object, containing the steps.

I suspect that the second part of that is the only one that's actually important for forwarding the changes on to our
parsing app (e.g., AnyList).

We then simply return the html, which is rendered in the browser, and can then be fed to the AnyList chrome extension,
or what have you.

## Tasks

- [X] ~~Split recipe steps by sentences~~
- [X] ~~Output a resource that can be fed back into the Spoonacular API to be reparsed. This probably means posting an
  HTML page.~~
- [ ] Take Spoonacular out of the equation all together (at least for simply splitting steps). Since we get the
  instructions from the page source, we don't need to get it from Spoonacular.
- [ ] Post the new HTML pages online somewhere when they're created, so that new url can be sent to AnyList instead of
  our local url, so that the full app can run locally.
- [ ] Create a modified Chrome extension that feeds a website through our middleware and then submits the result to the
  AnyList extension.
- [ ] Consider further splits
    - All commas
    - "and"
    - ", then"
- [ ] UI for interacting with the recipe for custom splitting and anything else

repository: tuzmusic/extra-spoon

repo_name: tuzmusic/extra-spoon


text:
# Terracotta

Sculpting your name for eternity as a Proclub member.

## Progress

- [x] initial commit
- [ ] structuring user records
- [ ] setup database with Diesel
- [ ] setup authentication mechanism
- [ ] setup logger middleware
- [ ] setup sentry middleware
- [ ] setup tests

## Maintainers

Currently, [@wisn](https://github.com/wisn) alone.

## License

Licensed under [The MIT License](LICENSE).

repository: helloproclub/terracotta

repo_name: helloproclub/terracotta


text:
# phase-0-gps-1
1.1 GPS

git clone [url] - clones repo from github to our local drive

git add [filename] - adds the file to the staging area

git status - tracks files in the repo & shows their current status (changed, staged, etc.)

git commit -m "[message]" - takes a snapshot of your file, includes a commit message explaining what changed

git push origin [branch_name] - uploads the most recent changes of your repository back to github

git checkout -b [branch_name] - creates and moves you into a new branch

gha_language: HTML


text:
# CoreData - Multiple ManagedObjectContexts

## Minute-by-Minute

| **Elapsed** | **Time**  | **Activity**              |
| ----------- | --------- | ------------------------- |
| 0:00        | 0:05      | Objectives                |
| 0:05        | 0:25      | Overview                  |
| 0:30        | 0:35      | In Class Activity I       |
| 1:05        | 0:10      | BREAK                     |
| 1:15        | 0:15      | Discussion                |
| 1:30        | 0:15      | Wrap Up                   |
| TOTAL       | 1:45      |                           |

## Why you should know this

A managed object context is an in-memory scratchpad for working with your managed objects.

Most apps need only one. This managed object context is associated with the main queue. As apps get more complex, this may cause the UI to fail.

Multiple managed object contexts make apps harder to debug so it's important that you evaluate if you really need it.

Long-running tasks like exporting data, will block the main thread on apps that have one managed object context. This looks like a good place to add another one and we must know how to do this.

## Learning Objectives (5 min)

- Learn about having multiple ManagedObjectContexts.
- Discuss and use child contexts.
- Discuss thread safety with ManagedObjectContexts.

## ManagedObjectContexts & Thread safety

ManagedObjectContexts are not thread safe. This means we can't just dispatch to a background queue and use the same Core Data stack. We have to use them with caution when concurrency is at play.

If we have multiple threads (main and some background thread for example) access the same ManagedObjects, we should have consistent behavior.

A solution is to use a private background queue for long running tasks.

### How?
The PersistentContainer makes dealing with private contexts easy.

The ```performBackgroundTask``` method of the PersistentContainer spins up a new private background context in a closure.

```swift
persistentContainer.performBackgroundTask { (context) in
    for object in objectArray {
        //heavy processing
    }
    do {
      //save context
        try context.save()
    } catch {
        fatalError("Failure to save context: \(error)")
    }
}
```

**Recomended Use of Contexts**

We use the **main context** for interacting with core data on the application's view layer.

But complex operation such as saving multiple ManagedObjects in core data takes a long time and hence will block the main thread(if using main context).

What we want to do is hand off saves to a **background context** so write operations can be performed on the background.

## Fetching ManagedObjects from the main ManagedObjectContext & saving on a background Context

One way we can handle a save in this situation is to change the ManagedObjectContext.
Since fetching from the main context, all objects retrieved will be associated with the main managed object context.

**Option 1: Changing Contexts**
1. Grab the objectID from the ManagedObject.
```swift
let objectID = myManagedObject.objectID
```
2. Fetch the same ManagedObject from the background ManagedObjectContext.
```swift
let myBackgroundManagedObject = coreDataStack.privateContext.object(with: objectID)
```
3. Do any modifications to your ManagedObject
4. Perform a save on the privateContext

**Option 2: Using Child Contexts**

Think of a notes application. We create a new note and make edits, delete text, modify, keep changing the content until we're happy with our text and then we want to hit save. In an app like this, we can simplify how Core Data works by making the changes as the user edits the note. Then we either save the changes or discard them. Depending on the final decision of the user.

Child managed object contexts are temporary scratch pads that we can save or discard. If saved, we send the changes to the parent context.

All managed object contexts have a parent store from which we can retrieve and change managed objects.

The parent store is a persistent store coordinator. But we can also set the parent store to another managed object context, turning it into a child context.

![Contexts](contexts.png)

NOTE: Whenever we save a child context, the changes go up to the parent context. BUT these changes won't be sent to the persistent store coordinator until the parent context is saved.

You can set one ManagedObjectContext as a child to another.

To solve the problem of saving to a background context, we can create a new privateContext and set the main context as the parent.

```swift
privateContext.parentContext = viewContext
```

## In Class Activity

Making the necessary changes in a core data app to use multiple ManagedObjectContexts is not that complicated and it doesn't require many steps.

What's challenging is identifying the need to apply multiple MOC.

[This tutorial](https://www.raywenderlich.com/7586-multiple-managed-object-contexts-with-core-data-tutorial) uses an app that logs entries in a surf journal and rates surf sessions. The starter code can be found [here](https://koenig-media.raywenderlich.com/uploads/2018/09/multiple-managed-ob-ject-contexts-Swift-4.2.zip)

Before starting the tutorial, make sure you are able to run the project. See that there is an export functionality that will take all the contents of the table into a CSV file. Try scrolling the table and then try to export the content. Look out for the main problem we want to solve. What is it?

Go over the tutorial to fix the issue.
There are two main things you should have in the end:
- Created a `ManagedObjectContext` that works in the background.
- Used a child context to make edits in the ManagedObjects before hitting save.

## Discussion questions

- How did the app populated all the data when we fist opened it?
- What was the problem with exporting the data to CSV?
- When is it a good moment to start introducing multiple managed object contexts?
- What is a benefit from doing this?
- What can go wrong?
- What is `performBackgroundTask` doing in the app?
- What is the difference between Private an Main queues?
- What is `childContext.parent = coreDataStack.mainContext` doing for us?
- Why you we to pass the managed object *and* the managed object context to the `detailViewController`?

## Stretch Challenge for the tutorial
Change `SegueListToDetailAdd` to use a child context when adding a new journal entry. You will need to create a child context that has the main context as its parent. And create the new entry on the correct context.

## Additional Resources

- [Slides](https://docs.google.com/presentation/d/1mx-_ELFm5_zCMzEIgTnfM2RhxVgq_pX2k8tAo9bsUB8/edit#slide=id.g514c043897_0_135)
- https://www.raywenderlich.com/7586-multiple-managed-object-contexts-with-core-data-tutorial
- “Core Data by Tutorials.” By Pietro Rea.


text:
# OpenTree: Generate an Org Chart from Workday

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

![alt text](https://img.shields.io/badge/Java%2011.0.1-orange.svg?longCache=true&style=flat-square "Java 11.0.1")
![alt text](https://img.shields.io/badge/Spring%20Boot-2.2.2--RELEASE-brightgreen.svg?longCache=true&style=flat-square "Spring Boot 2.2.2 RELEASE")
![alt text](https://img.shields.io/badge/MariaDB-10.3-yellow.svg?longCache=true&style=flat-square "MariaDB 10.3")
![alt text](https://img.shields.io/badge/Hibernate-5.3.7--Final-red.svg?longCache=true&style=flat-square "Hibernate 5.3.7 Final")

![opentree screenshot](src/main/resources/static/img/screenshot.png)

## Purpose
tl;dr Generate and render your company's org chart based on Workday data (or any flat, row-based dataset which uses identifiers to link child nodes to single parents).

Blog post [here](https://tech.shutterstock.com/2018/12/11/opentree-visualizing-organizations).

Individuals who use [Workday](https://workday.com) can view the supervisory org that they manage or that they're part of, and can otherwise navigate stepwise up and down the org, but there is no built-in capability within Workday to view a company-wide, comprehensive org chart. Visibility into an organization's overall structure is a valuable resource for employees across a company. This project uses Workday data and generates a hierarchical org chart rendered on a web page.

The application provides filtering options to view subtrees and filter by location, department (cost center), and title.

## Prerequisites
### Running Locally
* Java 9+
* Maven
* MariaDB 10.3

### Running in Docker
* Docker

## Run With Sample Data
To run on your local machine, you'll have to have MariaDB 10.3 installed, the [schema](src/main/resources/schema.sql) created, and username/password set (these must match the `spring.datasource.username` and `spring.datasource.password` fields in [`application.properties`](src/main/resources/application.properties)).
```shell
%> mysql -u opentree -p opentree < schema.sql  # assumes username 'opentree' and data load into a schema called 'opentree'
%> mysql.server start  # the command to start the database will vary depending on your platform
%> git clone https://github.com/shutterstock/opentree.git
%> cd opentree
%> mvn package
%> mvn spring-boot:run
```

Running the application in Docker is totally self-contained, so outside of having Docker installed, no additional setup is required:
```shell
%> docker build . -t opentree
%> docker run -p 8080:8080 opentree
```

In both cases, once startup is complete, browse to [`http://localhost:8080`](http://localhost:8080) to view the application.

## Architecture
This application is based on Spring Boot (MVC) and follows a standard 3-tier architecture.

The backend uses a MariaDB relational database running on `localhost`. This can be configured in [`application.properties`](src/main/resources/application.properties). If running in Docker, you'll need to update the [`Dockerfile`](Dockerfile) to correctly reflect database location and user information.

The middle-tier is Spring and governed through [models](src/main/java/com/shutterstock/oss/opentree/model/entity) and [controllers](src/main/java/com/shutterstock/oss/opentree/web/controller).

The views use the [Thymeleaf templating engine](https://www.thymeleaf.org/) and [d3.js](https://d3js.org).

## Setup
A custom report endpoint must be setup in Workday to generate a CSV report with the desired fields you wish to render on the front-end. By default, the following fields are used and displayed in the front-end:
* `EmployeeID`: used as the unique identifier for a given employee. This field *must* be unique for the tree to link nodes and build correctly. Matrix reporting (where an Employee has multiple records in the CSV report, each with a distinct `ManagerID`) is not supported
* `Name`: full name of the employee
* `ManagerID`: the `EmployeeID` of the employee's manager
* `ManagerName`: full name of the manager
* `Location`: work location
* `Title`: official title
* `WorkEmail`: work email
* `Type`: typically `Employee` or `Contingent`; this is used to filter out non-FT employees from the main view
* `CostCenter`: cost center
* `CostCenterHierarchy`: department

Fields can be configured in the [`Employee` model](src/main/java/com/shutterstock/oss/opentree/model/entity/Employee.java). For a given field in the CSV which is to be available on the front-end, the CSV column headers for those fields *MUST* be mapped to the model. [opencsv](http://opencsv.sourceforge.net/) is used to automatically map CSV fields to `Employee` fields via annotations (`@CsvBindByName`).

Though employee images in Workday can be exposed in reports as base64-encoded strings, as of this time, cropped thumbnails are not. As a result, this application does not display employee images of any kind.

The dummy [CSV data set](src/main/resources/employees.csv) provides an example for the structure of the Workday report required to generate a hierarchical tree.

Once the report endpoint and authorized credentials have been created, update the Workday configuration attributes in [`application.properties`](src/main/resources/application.properties), specifically the following:
* `wd.endpoint`: full URL of the report endpoint
* `wd.username`: username of authorized account
* `wd.password`: password of authorized username account

## Customizing OpenTree
If you want to customize the application with your company's brand, start here:
* company details in [`application.properties`](src/main/resources/application.properties)
  * `opentree.company.name`: set your company's name
  * `opentree.email.domain`: set your company's email domain, e.g. superbigmegacorp.com
  * `opentree.web.fonts`: choose alternative Google fonts for rendering display/body text; you'll need to update CSS files to reference alternative font types specified here
  * `opentree.report-issue-url`: set the URL for submitting Github issues
* logo: replace [`logo.png`](src/main/resources/static/img/logo.png) with your brand's logo
* favicons: create favicons and save them in the [`resources/static/img/`](src/main/resources/static/img) directory and reference those files in [`head.html`](src/main/resources/templates/fragments/head.html)

## Running in Production
A Workday endpoint that generates and returns a CSV report with the appropriate data must be set up before you can enable `opentree.production` mode (at which point the application will begin calling the configured Workday endpoint).

Authentication credentials for Workday (`wd.username` and `wd.password`) and the database (`spring.datasource.username` and `spring.datasource.password`) should be externalized into a secure store like [Vault](https://github.com/hashicorp/vault). Implementation of this is outside the scope of this project.

The default logging configuration is set to `debug`&mash;in production, you will likely want to decrease the logging level for less verbosity. Update the `level` for the `com.shutterstock.oss.opentree` `Logger` in [`log4j2.xml`](/src/main/resources/log4j2.xml).

## Administrative Functions
Several URL mappings exist to provide light, administrative functionality, managed by the [`AdminController`](src/main/java/com/shutterstock/oss/opentree/web/controller/AdminController.java):
* `/admin/refresh`: the default TTL for the cache is 24 hours (defined in `application.properties` as `opentree.cache.ttl-hours`), so hitting this route will force a new fetch of data from Workday
* `/admin/updates`: (view: [`updates.html`](src/main/resources/templates/updates.html)) this will display employee data updates (since the database was first created and populated)
* `/admin/dumpdb`:  (view: [`dump.html`](src/main/resources/templates/dump.html)) this will dump the raw contents of the database in an HTML table in CSV format
* `/admin/dumpcache`: this will dump the contents of the cache as a hierarchical JSON document
* `/admin/morgue`: (view: [`morgue.html`](src/main/resources/templates/morgue.html)) this will display a list of all employees who are no longer with the company (since the database was first created and populated)
* `/admin/roots`: (view: [`roots.html`](src/main/resources/templates/roots.html)) this will display a list of all employees who report into themselves. This is useful to debug cases when Workday data has been misconfigured and the tree is not displaying in its entirety.

As state is managed by the database, any drops or restarts in the Docker container will result in loss of historical state (e.g. updates, attrition). This will happen by default each time it is restarted if the database pre-configured with the Docker image is not replaced with an externalized database. However, this has no impact on its ability to display the current org chart.

## License
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)

repository: shutterstock/opentree

gha_language: Java

repo_name: shutterstock/opentree


text:
# Student project: Replication of Chen et. al. (2020)

This is the final project of the OSE data science course summerterm 2021 by Mengxi Wang.

## Project overview

This repository contains my replication of the main results from [Chen, T., Kung, J. K. S., & Ma, C. (2020)](https://doi.org/10.1093/ej/ueaa043). Long Live Keju! The Persistent Effects of China’s Civil Examination System. The Economic Journal, 130(631), 2030–2064.

Chen et al. (2020) offered an ingenious design and an interesting application of instrumental variables. This observation of a strong, positive relationship between prefectures with a strong historical tradition of exam success and current years of schooling enabled Chen et al. (2020) to contribute important insights to the persistent impact of a remarkably long-lived institution — imperial China’s civil service examination system — methods of selecting candidates or current educational attainment. Moreover, Chen et al. (2020) further demonstrated that this relationship is causal by using the average river distance to a prefecture’s nearest pine and bamboo forests as an instrument, which produced the main tools for printing.

This notebook successfully replicates Chen et al. (2020)’s main results. A causal relationship between the keju and current methods of selecting candidates has been verified. The main results were precisely reproduced in Section 4. In addition, the notebook contains a test of weak instruments and an examination of keju's impacts on populations with distinct levels of educational achievement in 2010 as an extension of Chen et al. (2020)’s findings in Section 5.

## Reproducibility

To ensure the reproducibility of the project, the repository is supported by a GitHub Actions Continuos Integration (CI). The state of my workflow can be found here:

[![Continuous Integration](https://github.com/OpenSourceEconomics/ose-data-science-course-project-Mengxi-20/actions/workflows/ci.yml/badge.svg)](https://github.com/OpenSourceEconomics/ose-data-science-course-project-Mengxi-20/actions/workflows/ci.yml)

The code presenting Table 10, Table 11 and Table 12 is not able to run on GitHub Actions CI, probably because the package ([FixedEffectModel](https://pypi.org/project/FixedEffectModel/)) that used in this part is a very specific package and was only updated last month. Therefore, I marked # before every line of related code for Table 10, Table 11 and Table 12, and then loaded the results in form of image to make them readable.

## Sources

* Chen, T., Kung, J. K. S., & Ma, C. (2020). Long Live Keju! The Persistent Effects of China’s Civil Examination System. *The Economic Journal*, 130(631), 2030–2064. https://doi.org/10.1093/ej/ueaa043

* Jeffrey M Wooldridge. Econometric analysis of cross section and panel data. MIT press, 2010.

* Jing, X., & Liu, L. (2019). The Equity of Gaokao (National University/College Entrance Examination) in China. *Review of Educational Theory*, 2(3), 29. https://doi.org/10.30564/ret.v2i3.881

* Kuaishou DA Ecology. FixedEffectModel: A Python Package for Linear Model with High Dimensional Fixed Effects.https://github.com/ksecology/FixedEffectModel,2020.Version 0.x

* Semykina & Wooldridge (2010). Estimating panel data models in the presence of endogeneity and selection. *Journal of Econometrics*, 157(2): pp. 375-380. https://doi.org/10.1016/j.jeconom.2010.03.039


text:
---
breadcrumbs:
- - /nativeclient
  - Native Client
- - /nativeclient/how-tos
  - '2: How Tos'
page_name: exception-handling-interface
title: Exception Handling Interface
---

## Introduction

Hardware exceptions (invalid memory accesses, division by zero and etc) can not
be caught in the standard C/C++. Different OS provide different mechanisms to
catch hardware exception. POSIX standardizes hardware exception handling via
signals. Native Client doesn't support signals but it provides somewhat similar
interface. The main difference is that Native Client doesn't allow to resume
execution from the failed instruction. Note, that exception handling is disabled
for PNaCl because exception handling interface uses platform-dependent register
context.

## Retrieving Hardware Exception Handling Interface

#include <irt.h>

struct nacl_irt_exception_handling exception_handling_interface;

size_t interface_size = nacl_interface_query(

NACL_IRT_EXCEPTION_HANDLING_v0_1,

&exception_handling_interface,

sizeof(exception_handling_interface));

if (interface_size != sizeof(exception_handling_interface)) {

/\* error \*/

}

## Using nacl_exception Library

An alternative way to access hardware exception handling interface is via
nacl_exception library (it is part of libc). Add -lnacl_exception flag and use
functions from `nacl/nacl_exception.h` header. They have the same parameters and
their names are just prefixed with `nacl_exception`.

## Handling Hardware Exceptions

Hardware exception handlers are declared as

`typedef void (*NaClExceptionHandler)(struct NaClExceptionContext *context);`

in irt.h. They receive platform-dependent hardware exception context which
contains the register state. This function should not return since there is
nowhere to return to. Once exception handler is called, the exception handling
is disabled on this thread. You must call

`int exception_clear_flag(void);`

if you need to reenable it (you want to handle hardware exceptions inside
hardware exception handler for example). This function returns 0 on success and
error code on error (exception handling is disabled). If hardware exception
happens on a thread where exception handling is disabled, the whole NaCl process
is terminated.

The definition of `NaClExceptionContext` can be found in `nacl/nacl_exception.h`
header.

NaCl supports only one exception handler per process. The exception handler is
set with

`int exception_handler(NaClExceptionHandler handler,`

` NaClExceptionHandler *old_handler);`

This function returns 0 on success, or error code on error (exception handling
is disabled, handler is not aligned to the bundle size or outside of code
region, exception handler thread is failed to start). Old exception handler is
returned via old_handler parameter. In order to disable exception handling, pass
`NULL` exception handler.

Exception handler is called on current thread stack by default. If you want to
set alternative stack (to handle stack overflows for example) for exception
handler, use

`int exception_stack(void *stack, size_t size);`

The alternative stack is set per thread. The function returns 0 on success and
error code on error (stack location is outside of NaCl address space). If you
want to disable alternative stack, call this function with `NULL` stack pointer
and zero size.

repository: iridium-browser/iridium-browser

repo_name: iridium-browser/iridium-browser


text:
## R :o:

|          |                           |
| -------- | ------------------------- |
| title    | R                         |
| status   | 90                        |
| section  | Application and Analytics |
| keywords | Application and Analytics |

R, a GNU project, is a successor to S, a statistical programming
language. It offers a range of capabilities including

> ``programming language, high level graphics, interfaces to other
> languages and debugging.  R is an integrated suite of software
> facilities for data manipulation, calculation and graphical
> display''.

The statistical and graphical techniques provided by R make it popular
in the statistical community. The statistical techniques provided
include linear and nonlinear modelling, classical statistical tests,
time-series analysis, classification and clustering to name a few
[@www-R]. The number of packages available in R has made it popular
for use in machine learning, visualization, and data operations tasks
like data extraction, cleaning, loading, transformation, analysis,
modeling and visualization. It's strength lies in analyzing data using
its rich library but falls short when working with very large datasets
[@book-R].


text:
# eduroam-iwd
Script of make setting file of eduroam for iwd

If you want to use eduroam wifi with iwd, this script may help you

必要環境/Need
-------------
sudo
iwd

使い方/How To Use
-------------
*STEP1:*

Download

	mkdir ~/tmp && cd ~/tmp
	wget https://raw.githubusercontent.com/Hebereke555/eduroam-iwd/main/eduroam-iwd.sh
	chmod a+x eduroam-iwd.sh

*STEP2:*

Execution

get your id and pass (ex. https://wifi.keio.jp/eap/register)

	bash ~/tmp/eduroam-iwd.sh

*STEP3:*

Restart iwd

	systemctl restart iwd

if you need

	systemctl enable iwd


text:
---
title: "May and June Matches"
layout: article
categories: Announcements
---

In May we have the IDPA match which will be a full 10 stage match with extras. Early June is the Berrys Cedar Valley Multigun match and late June is the newest match format, a Black Rifle match.

## May 27th IDPA match

This is a normal Tier 1 match but we will have some extras. Certificates will be handed out for those that place and there will be random prize drawings as well. It's 10 stages, about 150 rounds, and there are lots of spots available still. A [preliminary course of fire can be seen here](https://docs.google.com/presentation/d/1kXyOUv65KcOCTOf8NL8kcLCp-vQ7YX51wSkcVhwGAs4/edit#slide=id.g21ad449e14_1_90)

[Register for IDPA Match](https://practiscore.com/udpl-2017-may-idpa/register)

### June 3rd and 4th Berrys Cedar Valley Multigun

This is a two day match, Saturday and Sunday June 3-4. Staff shoot Friday June 2nd. We will need help all week prior setting up so come out to the range and help if you can.

Match fee is $100 and there will be 10 stages of fast paced multi-gun action, running the same format as the Expedition multi-gun in Las Vegas. We will be running the new rule and divisions found [here](https://docs.google.com/document/d/1i7rn0rwTHmQM4jsJ9md0870yVp0Xqst96MFLLi1WdOk)

Divisions: Tac, Limited, Heavy , Open, PCC (shooting the entire match with 1 PCC gun), 2 Gun (shoot the entire match Rifle/Pistol) and 2X4 (using Rifle, Pistol, Shot Gun and PCC. Must use 2 guns per stage, shooters choice. All open rules)

Rather than a prize table after the match, we will do a quick awards with some random draw prizes mixed in. Through out the match the prize patrol will be roving around to each squad with give away's and a drawing for a substantial prize or two.

[Register for Berrys Cedar Valley Multigun](https://practiscore.com/berrys-cedar-valley-multigun/register)

### June 24th Black rifle match

This is a new format that uses only a semi-automatic rifle. No pistol needed. Ideally an AR-15 or AK-47 should be your choice but any semi-automatic rifle will work. There are also divisions for Pistol Caliber Carbines and rimfire rifles. You'll engage targets from 5 to 150 yards from a variety of positions. Plan on 200 rounds of ammo and like all rifle matches the **bullet must not be steel**. If it sticks to a magnet you can't shoot it. [Register on Practiscore](https://practiscore.com/udpl-june-black-rifle-match/register)

## Funshoots

As always we have the Rangemasters Funshoot twice during the month. Details are in the [schedule](http://www.udpl.net/schedule/).

repository: leaberry/jekyll-udpl

repo_name: leaberry/jekyll-udpl


text:
# hackathon81_configmodel
NANOG 81 Hackathon - Configuration Modeling

This is a sample project to serve as a basic configuration modeling and software design tutorial.

The code is intended for educational purposes only and is in no way intended for production use.

## What's in this repository?
### hack
The [hack](./hack) directory contains a skeleton to get you started.  We'll do a tutorial during the hackathon for people who need a hand getting started with something.  We'll work in this directory to build to a basic, working system.

### basic-working
The [basic-working](./basic-working) directory contains a basic, working system.  If you're having trouble coming up with a project idea, you might want to look at this for inspiration, or even expand upon it.


text:
### Kolori - Game Jam Plus 2021
A small game made as part of the 1st phase in Game Jam Plus 2021.
***
Goal of the game is for the player (blob) to survive for the longest time while avoiding the Erasers. Throughout the game the player can pick up buckets of various colors (purple, blue, green, yellow, and red) and gain power ups as well as change the players color and paint trail. Some of the bucket power ups can kill the Erasers that respawn over time. Paint bar depletes when the player takes damage, the player uses the current power up and over time for a small amount.

- **Blue bucket** - Projectile blast, player shoots blue at the direction of the curser, killing erasers
- **Purple bucket** - Teleportation, player teleports to the cursor's location
- **Red bucket** - bomb blast, player makes a red splash with a large AoE killing erasers around the player
- **Green bucket** - player can dash
- **Yellow bucket** - player slows down movement for erasers

# Game mechanics

Player movement is done using the [W, A, S, D] keys. All power ups can be activated multiple times at the press of [SPACE] key, for as long as there is paint left in the pain bar. Killing an eraser and picking up power ups increments the players score. Player can pause the game anytime with the [ESC] key.

Made with Monogame, Aseprite and FL Studio.
# Authors:

LordDeatHunter
martinkozle
BananaMe
AnixDrone
zodiuxus


text:
[![pipeline status](https://gitlab.com/databand-ai/dbnd/badges/master/pipeline.svg)](https://gitlab.com/databand-ai/dbnd/pipelines)

![PyPI - Downloads](https://img.shields.io/pypi/dm/dbnd) ![PyPI](https://img.shields.io/pypi/v/dbnd)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/dbnd) ![PyPI - License](https://img.shields.io/pypi/l/dbnd)
![Code style: ](https://img.shields.io/badge/code%20style-black-000000.svg)

# DBND

DBND an open source framework for building and tracking data pipelines. DBND is used for processes ranging from data ingestion, preparation, machine learning model training and production.

DBND includes a Python library, set of APIs, and CLI that enables you to collect metadata from your workflows, create a system of record for runs, and easily orchestrate complex processes.

DBND simplifies the process of building and running data pipelines
from dbnd import task

```python
from dbnd import task

@task
def say_hello(name: str = "databand.ai") -> str:
    value = "Hello %s!" % name
    return value
```

And makes it easy to track your critical pipeline metadata

```python
from dbnd import log_metric, log_dataframe

log_dataframe("my_dataset", my_dataset)
log_metric("r2", r2)
```

## Getting Started

See our [documentation](https://docs.databand.ai/docs) with examples and quickstart guides to get up and running with DBND.

## The Latest and Greatest

For using DBND, we recommend that you work with a virtual environment like [Virtualenv](https://virtualenv.pypa.io/en/latest/) or [Conda](https://docs.conda.io/en/latest/). Update to the latest and greatest:

```shell script
pip install dbnd
```

If you would like access to our latest features, or have any questions, feedback, or contributions we would love to here from you! Get in touch through<EMAIL_ADDRESS>

repository: databand-ai/dbnd

gha_language: Python

repo_name: databand-ai/dbnd


text:
---
layout: default
---

# 1998-10-13 - IRS wants cypherpunks archives

## Header Data

From: Adam Back<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 179520e60201f81db8c4c0ccfab0b95f23f0d004b759c70ea0830f665274946d

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1998-10-13 21:16:42 UTC

Raw Date: Wed, 14 Oct 1998 05:16:42 +0800

## Raw message

```
{% raw  %}From: Adam Back<EMAIL_ADDRESS>Date: Wed, 14 Oct 1998 05:16:42 +0800
To<EMAIL_ADDRESS>Subject: IRS wants cypherpunks archives
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Jeff, and fellow agents seem to be interested in cypherpunks archives
(as evidenced by asking Jim Choate who operates one of the mailing
list nodes, but who does _not_ offer archived list traffic).  Jeff is
Cc'd on this post to be helpful (who says cypherpunks aren't helpful
-- you only have to ask).

This archive seems to be operational:

	http://www.inet-one.com/cypherpunks/

And looks to cover the last year or so at least.

The one at minder.net says 0 items available:

	http://www.minder.net/cgi-bin/lwgate.cgi/CYPHERPUNKS/archives/

so something appears wrong with that one (Brian?)

and Ryan's sof.mit.edu archive is down still since the disk crash.

Are there any others?

I do have a reasonable set of archives going back to May '96 in RMAIL
format, but am not too keen on mailing them due to bandwidth -- would
take a few hours at 28.8k baud.  (Also there seem to be some older
archives on Remo Pini's crypto CD, but I think they are too old to be
of interest to IRS).

Adam
--
print pack"C*",split/\D+/,`echo "16iII*o\U@{$/=$z;[(pop,pop,unpack"H*",<>
)]}\EsMsKsN0[lN*1lK[d2%Sa2/d0<X+d*lMLa^*lN%0]dsXx++lMlN/dsM0<J]dsJxp"|dc`

{% endraw %}
```

## Thread

+ Return to [October 1998](/archive/1998/10)

+ Return to "[Adam Back <aba@dcs.ex.ac.uk>](/authors/adam_back_aba_at_dcs_ex_ac_uk_)"

+ 1998-10-13 (Wed, 14 Oct 1998 05:16:42 +0800) - IRS wants cypherpunks archives - _Adam Back<EMAIL_ADDRESS>


text:
App Engine application for the Udacity training course.

## Products
- [App Engine][1]

## Language
- [Python][2]

## APIs
- [Google Cloud Endpoints][3]

## Setup Instructions
1. Update the value of `application` in `app.yaml` to the app ID you
   have registered in the App Engine admin console and would like to use to host
   your instance of this sample.
1. Update the values at the top of `settings.py` to
   reflect the respective client IDs you have registered in the
   [Developer Console][4].
1. Update the value of CLIENT_ID in `static/js/app.js` to the Web client ID
1. (Optional) Mark the configuration files as unchanged as follows:
   `$ git update-index --assume-unchanged app.yaml settings.py static/js/app.js`
1. Run the app with the devserver using `dev_appserver.py DIR`, and ensure it's running by visiting your local server's address (by default [localhost:8080][5].)
1. (Optional) Generate your client library(ies) with [the endpoints tool][6].
1. Deploy your application.

[1]: https://developers.google.com/appengine
[2]: http://python.org
[3]: https://developers.google.com/appengine/docs/python/endpoints/
[4]: https://console.developers.google.com/
[5]: https://localhost:8080/
[6]: https://developers.google.com/appengine/docs/python/endpoints/endpoints_tool

API explorer link:
https://apis-explorer.appspot.com/apis-explorer/?base=https://preveyj-fswdnd-project4.appspot.com/_ah/api#s/conference/v1/

AppEngine App ID:
preveyj-fswdnd-project4

Developer explanations:

Task 1:

I implemented Session as a full class according to the requirements, and as a
'child' of Conference.  A session name is required, but nothing else is.  All
properties except Duration, Start Date, and Start Time are string properties.
Duration is an integer, Start Date is a plain date, and Start Time is a
DateTime.  I chose to implement Speaker as a plain string because nothing else
in the requirement documents ascribe any other properties to speaker besides
their name.  Other than that, where possible I made design decisions based on
expediency.

Task 3:

I implemented getConferencesByCity() and getConferencesByExactTopic(), to
provide additional search options for conferences.  getConferencesByCity()
can be used to find conferences taking place in a particular city, and
getConferencesByExactTopic() can be used to find conferences covering a
particular topic.

Task 4:

For the "non-workshop sessions before 7PM" problem, we could implement a
specific query to handle that: find sessions excluding the given type, and
begin before the given time.  The problem is that this is a highly specific
query that doesn't have a lot of reusability outside of this problem, and that
only session start times and durations are stored; what if the user wants
sessions that don't go past 7 PM instead of just starting before then?
Solving the time problem should be relatively easy; just take the given time,
and run a search for sessions whose starting time plus duration in minutes are
less than the given time cutoff:
    ((StartTime + durationInMinutes) <= CutoffTime).

The solution to the specificity problem might be to just provide an enpdoint
that takes whatever query criteria the client provides, validates it, and
returns the results.  Something like Microsoft's OData could be ideal too, but
I don't know enough about Python or the Google endpoint API to identify
anything similar to the IQueryable object that Microsoft uses to provide that
functionality.  There are two libraries for Python listed at
http://www.odata.org/libraries/ , but I haven't looked at either one to see
how they'd interact with the Google endpoints API.


text:
# How to contribute to the Ark project

## Introduction

Hello there ! Thinking about contributing to the Ark Ecosystem ? You're in the right place.

Everyone is welcome to contribute with his own set of skills. Don't worry of you're not a crypto specialist or a developer : we can always find something for you 😉

This guide will first detail the current bounty programs, then help you get started so you can contribute right away. So let's go !

## Bounty programs

### Pull request

Every pull request you submit and is accepted will be rewarded.

#### Amount
$10 for each accepted pull request.

#### Accepted types of PR
-   Refactoring
-   Tests
-   Bug fixes
-   New features
-   Documentation
-   Translations or typos (but will be rewarded only once per month)

If you want to implement a new feature, **please first ask the team** : you can create an issue in GitHub or join the [Slack channel](https://ark.io/slack) to talk about it. It will save you time if the feature could not be accepted as is.

#### Eligible repositories
-   [ark-mobile](https://github.com/ArkEcosystem/ark-mobile)
-   [ark-desktop](https://github.com/ArkEcosystem/ark-desktop)
-   [ark-rpc](https://github.com/ArkEcosystem/ark-rpc)
-   [ark-deployer](https://github.com/ArkEcosystem/ark-deployer)
-   [ark-qrcode](https://github.com/ArkEcosystem/ark-qrcode)
-   [ark-js](https://github.com/ArkEcosystem/ark-js)
-   [ark-kotlin](https://github.com/ArkEcosystem/ark-kotlin)
-   [arky](https://github.com/ArkEcosystem/arky)
-   [ark-java](https://github.com/ArkEcosystem/ark-java)
-   [ark-explorer](https://github.com/ArkEcosystem/ark-explorer)
-   [ark-client](https://github.com/ArkEcosystem/ark-client)
-   [ark-node](https://github.com/ArkEcosystem/ark-node)
-   [ark-lite-wallet](https://github.com/ArkEcosystem/ark-lite-wallet)
-   [ark-net](https://github.com/ArkEcosystem/ark-net)
-   [ark-paperwallet](https://github.com/ArkEcosystem/ark-paperwallet)
-   [ARKcommander](https://github.com/ArkEcosystem/ARKcommander)
-   [ark-ts](https://github.com/ArkEcosystem/ark-ts)
-   [ark-ios-monitor](https://github.com/ArkEcosystem/ark-ios-monitor)
-   [ark-go](https://github.com/ArkEcosystem/ark-go)
-   [ark-ledger](https://github.com/ArkEcosystem/ark-ledger)
-   [nucleid](https://github.com/ArkEcosystem/nucleid)

#### Examples
- You got 3 accepted translation PRs in a month, you will get $10
- You got 3 accepted bug fix PRs and 1 translation PR, you will get $40

### Monthly bounties

At the end of each month, the month's top contributors will be rewarded.

#### Amount
- $2000 for 1st place
- $1500 for 2nd
- $1000 for 3rd
- $250 for 4 to 6th
- $50 for the other contributors

#### Conditions
- Have at least 1 merged PR in the month (only accepted and merged PRs count, pending PRs do not)

#### Examples
- You got 2 merged PRs in the month, 1 is a bug fix and 1 is a typo. You have been selected for the 5th place for the month : you will get $250, in addition to your $20 for your 2 merged PRs.

### Security bounty

The security bounty rewards you for finding bugs or errors in the core code (ark-node) that could lead to security issues.

#### Amount (depends on the criticity)
- Low : $200
- Medium : $1000
- Critical : $2000
- Doomsday : custom - contact the team

You will also get an additional 50% if you provide a fix for the vulnerability you found.

#### Conditions
- Never disclose any exploit or vulnerability
- Never maliciously initiate an exploit on the main network
- Send an in-depth explanation mail to<EMAIL_ADDRESS>with steps to reproduce

### Documentation bounty

The documentation bounty rewards you for contributing to the ArkEcosystem [docs repository](https://github.com/ArkEcosystem/docs).

#### Amount
- $10 to $30 per 100 written words, depending on the complexity and quality of the writing

#### Conditions :
- Write in English
- Follow the workflow described in the next section *How to get started / Documentation*
- Don't plagiarize : we take this seriously. It could get you excluded from participating in this or others bounties.

### Custom projects

If you didn't find something for you, but you have another idea, get in contact with **boldninja** on [Slack](https://ark.io/slack) to talk about it.

It can be (almost) anything : from an Ark-related app to a Ark design project or educational video... Your imagination is the limit !

If your project is accepted, you will get a funding so that you can work on it.

## How to get started

### Development

So you want to start contributing to the ArkEcosystem repositories. You must have favorites programming languages / frameworks : go to the [ArkEcosystem](https://github.com/ArkEcosystem) organization page and browse the repositories looking for the one(s) that fits you.

Now that you have chosen one or more repos, here is what you can do to get started :
- Check the open issues. If you find something you would be comfortable developing, go for it. If not :
- Set up your development environment, and start using the product : go through the use cases, test it. You might find a bug or something you can improve.
- You can also check the closed issues to see what's been done : it can give you some ideas on what to do next.

When you've found something to work on, check and follow the GitHub workflow in the next section.

### Documentation

The documentation topics are organized in the Github [project page](https://github.com/ArkEcosystem/docs/projects/1) : you can go there and check the ones that are in status "Open".

If there's one topic you want to write, contact **boldninja** on [Slack](https://ark.io/slack) and ask him if you can take it. If you have examples of things you wrote (a blog, a doc on GitHub, ...), send it to him.

When you have confirmation that you can work on a subject, you can start and follow the GitHub workflow (link).

Remember that quality is key if you want to get your writing approved.

## Github workflow

To go through this workflow, you must have a GitHub account. You must also have Git installed on your computer.

### Fork the repository

To fork the repository, go to its GitHub page and click on the "Fork" button that is in the upper right :

![Github Fork button](./assets/img/GithubForkButton.png)

It should take a few seconds for your fork to be ready !

So now you have your own repository you can work on.

### Git clone to get the files locally

To get your local copy of your repository, you have to run the Git clone command :

    git clone https://github.com/<your-username>/<your-repo>.git

   This will get you the files from the repository in a local folder.

### Have a look at ARK Development Guidelines

We've written [development guidelines](https://github.com/ArkEcosystem/ARK-Development-Guidelines/) with some of our recommendations. Guidelines are not an absolute requirement or need to be enforced by tools, but they are recommendations based on what we have been doing in our projects.

**Current style guides:**

- [JavaScript](https://github.com/ArkEcosystem/ARK-Development-Guidelines/blob/master/JavaScript/README.md)
- [Python](https://github.com/ArkEcosystem/ARK-Development-Guidelines/blob/master/Python/README.md)

### Work locally and push changes to your repo

Now you can work, create and modify files.

And push your changes :

    git push

### Submit your changes : PR request

Before you make a PR request, please (if applicable) check that :
- Tests are passing : run `yarn test`
- The code follows the coding standards : run `yarn lint`

Finally, to submit your PR, go to the Ark repository on GitHub.

GitHub might auto detect that you want to create a pull request and suggest it to you :

![Github PR suggestion](./assets/img/GithubPRSuggestion.png)

If not you can do it manually : go to the "Pull requests" tab and click on the "New pull request" button.

![Github manual PR](./assets/img/GithubNewPR.png)

You will then be able to compare your changes between the Ark master branch and your own branch (click on the link "compare accross forks").

![Github PR compare changes](./assets/img/GithubPRCompare.png)

If you're satisfied with the changes, then you can add a clear title and description to your PR and submit it !

### Additional tips

#### Keep your fork synced

The Ark repositories are updated on a regular basis with new PRs. So you need to keep your fork synced in order to have the latest changes.

To do that, please follow this Github doc : [Syncing a fork](https://help.github.com/articles/syncing-a-fork/).

## Conclusion

Now you're up and ready to contribute to the Ark repositories !

If you have any doubt or questions, talk about it in the [Slack](https://ark.io/slack) channels. There are always people ready to help you.

Welcome to the Ark Ecosystem, and have fun contributing 😀

----------------
[contributor information](./assets/info.md)

repository: reConNico/docs

repo_name: reConNico/docs


text:
+++
# About/Biography widget.
widget = "about"
active = true
date = 2016-04-20T00:00:00

# Order that this section will appear in.
weight = 5

# List your academic interests.
# [interests]
#   interests = [
#     "Phylogenetics",
#     "Bioinformatics"
#   ]

# List your qualifications (such as academic degrees).
# [[education.courses]]
#   course = "PhD in Ecology"
#   institution = "University of California, Davis"
#   year = 2008
#
# [[education.courses]]
#   course = "AB in Biology"
#   institution = "Bryn Mawr College"
#   year = 2001

+++

# About the lab

We are a dry lab focused on computational evolutionary genetics. We develop methods and software to understand evolutionary history, with a particular focus on large genomics datasets. Researchers in the lab come from the fields of computer science, math, and evolutionary biology.

We also work to make our research reproducible and teach research skills to students and other researchers.

Interested in joining the lab as a postdoc, grad student, or undergraduate? See [available positions]({{< ref "positions.md" >}}).

repository: YanaHrytsenko/academic-kickstart

repo_name: YanaHrytsenko/academic-kickstart


text:
A package to bridge actions between ROS1 and ROS2.

**NOTE:**
- Currently supports forwarding goals from ROS1 (noetic) action client to ROS2 (galactic) action server
- As an example, implemented interfaces for the action bridge for FibonacciAction
  and FollowJointTrajectoryAction

**Prerequisites:**

(*rosdep does not work properly with mixed ROS1 and ROS2 dependencies*)

```
sudo apt install ros-noetic-actionlib ros-noetic-actionlib-tutorials ros-noetic-control-msgs ros-noetic-roscpp ros-galactic-control-msgs ros-galactic-example-interfaces ros-galactic-rclcpp ros-galactic-rclcpp-action
```

**How to build:**

Clone the repository in the `src` folder of your ROS2 workspace.
```
git clone git@github.com:ipa-hsd/action_bridge.git
```
Since the package provides a bridge for `FollowJointTrajectoryAction`, which is part of the `control_msgs`, clone the package modified for ROS2.
```
git clone -b galactic-devel git@github.com:ros-controls/control_msgs.git
```

Since `action_bridge` package depends on both ROS1 and ROS2, source both workspaces.
```
source /opt/ros/noetic/local_setup.bash
source /opt/ros/galactic/local_setup.bash
colcon build
```
Now you are ready to run the `action_bridge`!
Source this workspace to use the executeables built in the previous step.
```
source <path-to-workspace>/install/local_setup.bash
```
2 example executables are available:
- `action_bridge_fibonacci_node` and
- `action_bridge_follow_joint_trajectory_node`
You can start one of these nodes in the following manner:
```
ros2 run action_bridge action_bridge_fibonacci_node
```
OR
```
ros2 run action_bridge action_bridge_follow_joint_trajectory_node
```


text:
#ScreenToGif

This is the current project of ScreenToGif.

VS 2015 and .Net 4.6.1 required.

Version 2.4:

• Drag and drop files from the encoder.
• Context menu for each completed encoding, providing some clipboard operations.
• License information available on the "About page".
• Error messages are now more user-friendly.
• You can now configure the location of the logs folder.
• The playback buttons are now disabled during the opening of a side panel.
• Now it remembers the clipboard paste behavior (Clipboard > Paste behavior).
• Updated Danish, Chinese (simplified) and Russian translations.
•

Fixed:

♦ If an action (from a panel such as "Save as") failed because of some validation or when closing with the top-right X button, the playback buttons would stay disabled.
♦ Undoing a transition left a frame that should be deleted.
♦ PageDown and PageUp jumps among various frames instead of one by one.
♦ Clipboard list was not being cleared after resetting.
♦ Color picker: While returning to the initial color, the numbers were not replaced with the selected color.
♦ The validation of negative numbers for numeric inputs.
♦ Error while pasting and undoing the paste of frames (quickly).

Known bugs:

♠ OutOfMemory exception when importing videos.
♠ The crop feature fails when cropping a board recording (with high DPI);

Todo:

♣

license: MS-PL

repository: Chamuth/ScreenToGif

repo_name: Chamuth/ScreenToGif


text:
# Release process

- See if there are any PRs worth squeezing into release.
- Go through the changes since last release, add them to changelog.
- Add any new authors to the AUTHORS file.
- Bump version for release
- Open PR against develop with these changes.
- Once the above PR is merged, open a PR against master with the changes from develop
- Add a commit on that PR for updating the .sha256 files
- Once the PR against master is merged, update shasums on README on the develop branch
- Open a PR against salt with the new stable release.
- Open a PR against kitchen-salt with the new stable release.

repository: furlongm/salt-bootstrap

gha_license_id: NOASSERTION

repo_name: furlongm/salt-bootstrap


text:
# Resource Server: Organizer (ASP.NET Web API)

## Configuration

Before running this sample you must first define the Resource Server in Auth0:

```
curl -XPOST 'https://AUTH0_DOMAIN/api/v2/resource-servers' -H "Authorization: Bearer AUTH0_API2_TOKEN" -H "Content-Type: application/json" -d '{
  "identifier": "urn:organizer-api",
  "scopes": [
      { "value": "contacts", "description": "Manage your contacts" },
      { "value": "appointments", "description": "Manage your appointments" },
      { "value": "tasks", "description": "Manage your tasks" }
  ]
}'
```

More information is available [here](https://auth0.com/docs/api-authn-authz#tutorials).

## Running the sample

 1. Update the `web.config` file with your own settings
 2. Start the project
 3. The API will be listening on http://localhost:7001
 4. Now use one of the clients to connect to the API


text:
# Split navigations in Vim

Create a vertical split using `:vsp` and horizontal with `:sp`

You can specify the new split height by prefixing with a number

```
:60vsp ~/.vimrc
```

Beside we can use different key mapping for travel navigation between splits.

repository: dangvanthanh/til

repo_name: dangvanthanh/til


text:
Change log for award.json
=========================

Schema version 2
----------------

* Default values of '' were removed. You can no longer submit a blank url (url='')

* *status* was brought into line with other objects that are shared. Disabled grants with rfa in ['ENCODE2', 'ENCODE2-Mouse']:

        "enum" : [
            "current",
            "deleted",
            "replaced",
            "disabled"
        ]

repository: ENCODE-DCC/snovault

branch_name: refs/heads/dev

repo_name: ENCODE-DCC/snovault


text:
---
id: 4640
title: Leek group guide to reading scientific papers
date: 2016-02-09T13:59:53+00:00
author: Jeff Leek
al2fb_facebook_link_id:
  -<PHONE_NUMBER>05421_921733264549197
al2fb_facebook_link_time:
  - 2016-02-09T19:00:02+00:00
al2fb_facebook_link_picture:
  - post=http://simplystatistics.org/?al2fb_image=1
pe_theme_meta:
  - 'O:8:"stdClass":2:{s:7:"gallery";O:8:"stdClass":3:{s:2:"id";s:2:"-1";s:5:"width";s:0:"";s:6:"height";s:0:"";}s:5:"video";O:8:"stdClass":1:{s:2:"id";s:2:"-1";}}'
dsq_thread_id:
  -<PHONE_NUMBER>
categories:
  - Uncategorized
slug: "leek-group-guide-to-reading-scientific-papers"
---
The other day on Twitter Amelia requested a guide for reading papers

    I love @jtleek’s github guides to reviewing papers, writing R packages, giving talks, etc. Would love one on reading papers, for students.

    — Amelia McNamara (@AmeliaMN) February 5, 2016

So I came up with a guide which you can find here: [Leek group guide to reading papers](https://github.com/jtleek/readingpapers). I actually found this to be one that I had the hardest time with. I described how I tend to read a paper but I'm not sure that is really the optimal (or even a very good) way. I'd really appreciate pull requests if you have ideas on how to improve the guide.

repository: rbind/simplystats

repo_name: rbind/simplystats