text:
---
title: Get CampaignBidModifier
order: 2
type: get
entity: CampaignBidModifier
---

### Get a CampaignBidModifier

The `customer.campaignBidModifiers.get(resource_name)` method returns the CampaignBidModifier identified by a resource_name.

> Note: This function is heavily rate-limited by Google, so avoid using it in production.

#### Arguments

- ##### resource_name *required*
    The resource_name of that CampaignBidModifier

#### Returns

Returns that CampaignBidModifier as an object.

repository: eliotik/google-ads-api

repo_name: eliotik/google-ads-api


text:
# Branch Changelog

## Pending

* Changed the style of block invocation, now the outer block accepts an argument, and the `branch` method is to be called on the argument. This allows passing the argument to other blocks.

  Before:

        Branch.new do
          puts "Starting threads"
          branch { sleep 5; puts "Thread 1 finished." }
          branch { sleep 2; puts "Thread 2 finished." }
          branch { sleep 1; puts "Thread 3 finished." }
          puts "All threads started."
        end

  After:

        Branch.new do |b|
          puts "Starting threads"
          b.branch { sleep 5; puts "Thread 1 finished." }
          b.branch { sleep 2; puts "Thread 2 finished." }
          b.branch { sleep 1; puts "Thread 3 finished." }
          puts "All threads started."
        end

## v0.1.0

**August 11, 2014**

* `new` Initial version

license: MIT

repository: lolmaus/branch

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: lolmaus/branch


text:
## Release guide

### Check README.md and build.gradle

Be sure that [build.gradle](build.gradle), [Changelog](../CHANGELOG.md) and [Readme](../README.md) are updated and contain new, to be released version.

### Run static checkers and tests
`./gradlew clean build checkstyleMain checkstyleTest pmdMain pmdTest findbugsMain findbugsTest test`

### Run gradle task

`./gradlew clean build javadoc jar sourceJar`

`./gradlew bintrayUpload -Pbintray_username={yourBintrayUsername} -Pbintray_api_key={bintrayApiKey}`

Replace `{yourBintrayUsername}` with your username on Bintray and `{bintrayApiKey}` with Bintray api key. Api key is available under Edit Profile -> API Key

### Bintray publish

Manually go to [Bintray page](https://bintray.com/infinum/android), check that all 8 files are there and publish them if everything is OK.


text:
# Quadruped Robot 12dof v1.1

*Quadruped Robot 12dof v1.1 - Autonomy Upgrade - Weight: 2,8kg*

## Description

* this page describes the autonomy upgrade for the [Quadruped 12dof v1 Robot](../quadruped_robot_12dof_v1/README.md#quadruped-robot-12dof-v1)
* onboard batteries and wireless communication will enable the robot to operate without power and ethernet wires
* using the onboard imu for state estimation will enable the robot to operate outside of the motion capture area
* the robot will carry two lithium polymer batteries - one battery pack in the front and one battery pack in the back of the robot
* the custom power management board will enable safe operation of the batteries, e-stop handling and real-time current and battery voltage measurements
* there is a status led ring with 12 RGB leds on the top of the robot
* there are two payload interfaces with mounting holes to attach additional components to the top or the bottom of the robot
* the estimated weight increase for this upgrade is about 300g
* the components that were upgraded are marked red in the screenshot below

*Quadruped 12dof v1.1 Overview - the updated components are marked in red.*

*Quadruped Robot 12dof v1.1 - Top View*

*Quadruped Robot 12dof v1.1 - Front View
Sitting - dimensions: 46cm x 31cm x 6cm
Folded - dimensions: 46cm x 22cm x 9cm*

---
## Electronics

*Electronic Components Overview - weight: 463g*

### Power Management Board

*Power Management Board - weight: 16g*

* this custom Power Management Board is being developed by [Thomas Flayols](https://github.com/thomasfla)
* Documentation: [Power Board GitHub Page](https://github.com/open-dynamic-robot-initiative/power-board)
* monitors battery voltage and current
* reads on/off switch and e-stop
* cuts battery power if the e-stop is activated
*	inrush current limitation
*	SPI interface for communication with the Master Board
*	8 x XT30 output connectors
* dimensions: 65mm x 35mm
* mounting holes: ø 2,1mm / spacing 61mm x 31mm
* weight: 16g

## Off-the-shelf Components

### Lithium Polymer Batteries

*Lithium Polymer Batteries - weight: 68g each*

* SLS X-Cube 850mAh lithium polymer batteries
* 3S1P / 11,1V / 30C continous / 60C burst
* weight: 68g
* dimensions: 60mm x 30mm x 21mm
* power connector: XT 30
* balancer connector: XH
* don't use the lipo batteries without a power management board!
* Ordering information [below](#bill-of-materials---upgrade-quadruped-robot-12dof-v11)

### Switches

*Push Button Switches - weight: 3,5g each*

* E-Stop Switch: red button - normally closed - momentarily open while pushed
* On-Off Switch: green button - normally open - momentarily closed while pushed
* ø13,6mm / weight: 3,5g
* Ordering information [below](#bill-of-materials---upgrade-quadruped-robot-12dof-v11)

### Status Led Ring

*Status Led Ring - weight: 3,3g*

* Status Led Ring with 12 Neopixel RGB leds
* dimensions: OD: 36,9mm / ID: 23,3mm
* weight: 3,3g
* Ordering information [below](#bill-of-materials---upgrade-quadruped-robot-12dof-v11)
---
## 3D Printed Parts

* All the STL files for 3d printing the parts below can be found here: [STL Files](stl_files).

`The recommended printing direction for all the parts below is the positive z direction of the stl files.`

---

* [Body Structure Center Payload - STL file](stl_files/body_structure_center_payload.STL)

* this part can be used on the top and the bottom side of the robot
* weight: 31g
---

* [Body Structure Front Batterie Lid - STL file](stl_files/body_structure_front_batterie_lid.STL)

* weight: 11g
---

* [Body Structure Front Batterie - STL file](stl_files/body_structure_front_batterie.STL)

* weight: 18g

---

* [Body Structure Top IMU Leds - STL file](stl_files/body_structure_top_imu_leds.STL)

* weight: 15g
---

* [Body Structure Top Master Power Board - STL file](stl_files/body_structure_top_master_power_board.STL)

* weight: 15g
---

* [Mount Switches - STL file](stl_files/mount_switches.STL)

* weight: 4g
---

* [Neo Pixel Cover - STL file](stl_files/neo_pixel_cover.STL)

* weight: 0,3g
---

## Bill of Materials - Upgrade Quadruped Robot 12dof v1.1

| Part Name | Quantity | Ordering Information | Comments |
| --- | --- | --- | --- |
|Power Management Board|1|[Power Board GitHub Page](https://github.com/thomasfla/power-board)|Custom Electronics|
|LiPo Battery SLS X-Cube 850mAh|2|[SLS Product Page](https://www.stefansliposhop.de/en/batteries/sls-x-cube/sls-x-cube-30c/sls-x-cube-850mah-3s1p-11-1v-30c-60c::1534.html)
SLSCUX08503130|[Charging and Safey Accessories](../../electronics/details/details_components.md#batteries-and-charging-accessories)|
|E-Stop Switch|1|RS 820-7587|Red Push Button Switch|
|On-Off Switch|1|RS 820-7593|Green Push Button Switch|
|Status Led Ring|1|Adafruit 1643
Mouser 485-1643
Conrad 1516560|NeoPixel Ring RGB LED 12 x WS2812|
|Body Structure Center Payload|2|[STL File](stl_files/body_structure_center_payload.STL)|3d printed part|
|Body Structure Front Batterie Lid|2|[STL File](stl_files/body_structure_front_batterie_lid.STL)|3d printed part|
|Body Structure Front Batterie|2|[STL File](stl_files/body_structure_front_batterie.STL)|3d printed part|
|Body Structure Top IMU Leds|1|[STL File](stl_files/body_structure_top_imu_leds.STL)|3d printed part|
|Body Structure Top Master Power Board|1|[STL File](stl_files/body_structure_top_master_power_board.STL)|3d printed part|
|Mount Switches|1|[STL File](stl_files/mount_switches.STL)|3d printed part|
|Neo Pixel Cover|1|[STL File](stl_files/neo_pixel_cover.STL)|3d printed part|
|Fastener M2 x 6 SHCS|8||Power Board and Master Board|
|Fastener M2,5 x 6 SHCS|1||Switch Mount Back|
|Fastener M2,5 x 8 SHCS|1||Switch Mount Front|
|Fastener M3 x 6 SHCS|4||Batterie Lid|
|Helicoil M2,5 x 3,75mm|10|||
|Helicoil M3 x 4,5mm|20|||

---
## Preparing the 3D Printed Parts

## Wiring Documentation
### Power Board and Master Board

*Power Board, Master Board and Switches on Mounting plate - weight: 67g*

| Description | Quantity | Wire Length | Comments |
| --- | --- | --- | --- |
|Power Wire|1|8cm|[XT30](../../electronics/details/details_components.md#power-connectors) to [2pin Hirose](../../electronics/details/details_components.md#hirose-df13-sockets)|
|SPI Wire|1|5cm|[SPI Wiring Documentation](../../electronics/details/details_wiring.md#spi-wires)|
|Switch Wire|1||Pin assignment below.|

*Wiring On/Off and E-Stop Switch*

### Front Micro Driver Stack

*Front Micro Driver Stack - fully wired - weight: 112g*

| Description | Quantity | Wire Length | Comments |
| --- | --- | --- | --- |
|Motor Phase Wires |18|8cm|[Micro Driver Board Wiring Documentation](../../electronics/details/details_wiring.md#micro-driver-board-wiring)|
|Power Supply Wires|3|30cm|[Micro Driver Board Wiring Documentation](../../electronics/details/details_wiring.md#micro-driver-board-wiring)|
|SPI Wires|3|34cm|[SPI Wiring Documentation](../../electronics/details/details_wiring.md#spi-wires)|

### Hind Motor Driver Stack

*Hind Motor Driver Stack - fully wired - weight: 98g*

| Description | Quantity | Wire Length | Comments |
| --- | --- | --- | --- |
|Motor Phase Wires |18|8cm|[Micro Driver Board Wiring Documentation](../../electronics/details/details_wiring.md#micro-driver-board-wiring)|
|Power Supply Wires|3|16cm|[Micro Driver Board Wiring Documentation](../../electronics/details/details_wiring.md#micro-driver-board-wiring)|
|SPI Wires|3|18cm|[SPI Wiring Documentation](../../electronics/details/details_wiring.md#spi-wires)|

### Inertia Measurement Unit

*Inertia Measurement Unit - weight: 18g*

| Description | Quantity | Wire Length | Comments |
| --- | --- | --- | --- |
|Interface Wire |1|40cm|[IMU Wiring Documentation](../../electronics/details/details_wiring.md#imu-wire)|

### Neo Pixel Led Ring

*Neo Pixel Led Ring with Mounting Plate - weight: 22g*

| Description | Quantity | Wire Length | Comments |
| --- | --- | --- | --- |
|Interface Wire |1|34cm|Pin assignment below.|

*Neo Pixel Interface Wire*

### Battery Wire

*Battery Wire - weight: 12g*

*Battery wire - the batteries are connected in series.*

## More Information
[Open Dynamic Robot Initiative - Webpage](https://open-dynamic-robot-initiative.github.io)
[Open Dynamic Robot Initiative - YouTube Channel](https://www.youtube.com/channel/UCx32JW2oIrax47Gjq8zNI-w)
[Open Dynamic Robot Initiative - Forum](https://odri.discourse.group/categories)
[Open Dynamic Robot Initiative - Paper](https://arxiv.org/pdf/1910.00093.pdf)
[Hardware Overview](../../README.md#open-robot-actuator-hardware)
[Software Overview](https://github.com/open-dynamic-robot-initiative/open-dynamic-robot-initiative.github.io/wiki)

## Authors
Felix Grimminger

## License
BSD 3-Clause License

## Copyright
Copyright (c) 2019-2021, Max Planck Gesellschaft and New York University


text:
# ROS-enabled drone passport agent
Example of drone passport registration mechanism based on web3 technologies - Ethereum, IPFS and Robonomics network.

Watch demo on Youtube: [Drone Passport dapp on Ethereum Blockchain](https://youtu.be/LFE_ZJdZCmo) or [Drone Passport agent in action. Terminal view](https://youtu.be/yxGTOkGkBJ8)

## About Distributed Sky project
In order to organize drone operations efficiently, we need to make sure that vehicles have a trusted environment to exchange data and record transactions.

Drone registration agent. It receives the following fields from [the Dapp](https://drone-employee.com/):

* Contact email
* Full name
* Pilot ID
* Serial number of a drone
* Registration number
* Generic type of the drone
* Manufacturer of the drone
* Model of the drone

## ROS package details
### Pre-setup

In `launch/agent.launch` fill in an email and a password
```
...
<param name="login" value="" /> <!-- Gmail account login -->
<param name="email_from" value="" /> <!-- if it's empty, email_from is equal to login -->
<param name="email_password" value="" /> <!-- Gmail account password -->
...
```
You can specify some addresses in the `launch/composer.launch` file

### Build

```
$ nix build -f release.nix
```

### Launch

To launch main agent run:
```
$ source ./result/setup.zsh (bash)
$ roslaunch drone_passport_agent agent.launch
```

The composer node is launched via:
```
$ roslaunch drone_passport_agent composer.launch
```

### NixOS Service

To start the service as a system service add the following to `/etc/nixos/configuration.nix`:

```
systemd.services.de_direct = {
      requires = [ "roscore.service" ];
      after = ["roscore.service" ];
      wantedBy = [ "multi-user.target" ];
      script = ''
        source /root/de_direct/result/setup.bash \
        && roslaunch de_direct agent.launch
      '';
      serviceConfig = {
        Restart = "on-failure";
        StartLimitInterval = 0;
        RestartSec = 60;
        User = "root";
      };
    };
```

and run
```
# nixos-rebuild switch
```

To test the service is up and running:
```
# systemctl status de_direct
```

gha_language: Python


text:
# Single Instances library

Simple tiny library for organize your working with global instances (with application scope) in android project.
More info you can find<EMAIL_ADDRESS>
## How to use it
### Gradle
```java
compile 'com.github.programmerr47:single-instances:1.0.0'
```

### Maven
```html
<dependency>
  <groupId>com.github.programmerr47</groupId>
  <artifactId>single-instances</artifactId>
  <version>1.0.0</version>
  <type>pom</type>
</dependency>
```


text:
---
layout: default
---

# 1992-11-14 - Rander

## Header Data

From<EMAIL_ADDRESS>(John Draper)

To<EMAIL_ADDRESS>Message Hash: 65b41617eb5436b415c57c7a259b6e85399b952af9960c8a5502a2609458e1ae

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1992-11-14 09:23:48 UTC

Raw Date: Sat, 14 Nov 92 01:23:48 PST

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(John Draper)
Date: Sat, 14 Nov 92 01:23:48 PST
To<EMAIL_ADDRESS>Subject: Rander
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Tom Jennings writes:

>Using serial ports is probably not a good idea on PC clones. The IBM
>hardware design limits a machine to two ports comfortably, four
>practical maximum. Any machine that uses telecomm. (BBSs, etc) will
>have to consume the serial hardware, and will interfere with whatever
>you have to do.

>A good choice would be a parallel port, ie. a printer port. The IBM
>design allows 4 or more easily, and rarely do you see a pclone with
>more than two printers attached. If there isn't a spare port
>available, Fry's sells printer adapters for $19.95. Late-model printer
>adapters are 8 bit in and out, and are capable of Ethernet speeds.
>The parallel port uses standard busy/done and TTL levels.

I already thought of that,   but it would make it difficult to
work on other platforms.   Tom also writes:

>A simple driver could simply have say 10,000 bits, and continuously
>overwrite the oldest (wrap around the buffer...)

This was (and probably still is) my overall intention.

{% endraw %}
```

## Thread

+ Return to [November 1992](/archive/1992/11)

+ Return to<EMAIL_ADDRESS>(John Draper)](/authors/crunch_at_netcom_com_john_draper_)"

+ 1992-11-14 (Sat, 14 Nov 92 01:23:48 PST) - Rander -<EMAIL_ADDRESS>(John Draper)_

gha_license_id: MIT


text:
---
layout:     post
title:      Simple hard drive mirroring in Linux
date:       11-08-2015 11:00:00
summary:    Automatically mirroring two external hard drives with rsync and cron

---

I recently bought two 3TB external hard drives to temporarily store lots of data
for work locally while waiting for a more permanent solution. I used `rsync` to
mirror one external hard drive to the other and
[cron](https://en.wikipedia.org/wiki/Cron) to automate this process.

You might want to run this in a terminal first to see if it works:

`rsync -xavHl --delete /media/first-hard-drive-here /media/second-hard-drive-here`

I then automated the process by running it as a daily cron job. Run `crontab -e`
in a terminal and add the following lines to the bottom of the file:

<EMAIL_ADDRESS>
`5 0 * * * rsync -xavHl --delete /media/sb00682400/BIG /media/sb00682400/DATA > /dev/null`

This will run at 5 minutes past midnight daily. The `>` at the end deletes
STDOUT (i.e. a successful run). STDERR (i.e. a failed run) will notify you via
`mail`. It is quite useful to have these notifications
[emailed to you](http://www.webupd8.org/2009/11/use-gmail-to-send-emails-from-terminal.html).

Bad things can happen if you a cron job hasn't finished executing and it runs
again. For example, if this job runs every minute mirroring 1TB of data would
fail (it would take longer than a minute for the job to complete).

This was put together after reading the following sources:

* [http://ubuntuforums.org/showthread.php?t=1760718](http://ubuntuforums.org/showthread.php?t=1760718)
* [http://serverfault.com/questions/54152/how-to-get-e-mail-from-failed-cron-jobs-in-ubuntu](http://serverfault.com/questions/54152/how-to-get-e-mail-from-failed-cron-jobs-in-ubuntu)


text:
---
layout: default
published: true
permalink: /v3/en/arrest/KGZ/
lang: en
---

When asked to provide more context about who was especially vulnerable to arbitrary or political arrest and detention by government agents in 2018, our respondents mentioned all of the following:
-	Human rights defenders
-	People who openly criticise the authorities
-	Political opponents
-	Human rights defenders
-	Ethnic Uzbeks
-	LGBTQIA+ people
-	Sex workers
-	Drug users
-	People living with HIV
-	People with certain religious and political beliefs, such as Hizb-ut-Tahrir
-	People with low socioeconomic status
-	People with low educational attainment
-	Supporters and relatives of the ex-president
-	People accused of crimes, especially extremism and terrorism
-	People invited as witnesses to crimes
-	People with low income
-	Women with special needs
-	Protesters
-	Internal migrants
-	Ethnic minorities
-	Political prisoners

gha_language: HTML


text:
# Backend

The backend module is responsible for the scraping, feature decomposition and metric extraction for each article.

Top down description of arcitecture:

1. Each stroy is a word cloud, a bag of words with weights.
2. Stories get disected for teh following metrics:
  1. The amount of headline (property on page)
  2. position on page
  3. Normalized font size
  4. Number of pictures attached
  5. Number of link to
  6. Number of links from
3.

Internal importance:
# using phantom.js
Calculate the size of the story div on the front page
stroy_height * story_width
and normalize by size of the homepage:
document.body.scrollHeight * document.body.scrollWidth

Notes:
No regard to font size, position, related media (links, images, video etc)

repository: Spyyn/Backend

repo_name: Spyyn/Backend


text:
Mayb
====

Mayb is context-aware image recommendation system specified on the [pinterest](http://pinterest.com/). This system proposes related images in addition to similar images on the basis of repins of pinterest users. The point is to make use of context associated with image without analysing image itself.

**Crawler is not working correctly now, because the specification of pinterest has changed. Fortunately, I seem to be able to fix it. Thanks. See you later.**

<img src="https://raw.github.com/after12am/Mayb/master/doc/Mayb.png"/>

## strategy

There is variation in the way of users's classification of images. It is pinned to the different board even in the same image. This feature can be used to find related images using pearson's correlation.

## Require

Maby is depend on these libraries. You have to install those with easy_install.

* lxml 2.3.5
* chardet

```
$ sudo easy_install "lxml==2.3.5"
$ sudo easy_install chardet
```

## Usage

In the beginning of recommending images, we have to setup database.

```
$ cd /path/to/src
$ python mayb.py setup
```

option to crawle pinterest is:

```
$ cd /path/to/src
$ python mayb.py crawle
```

option to cluster pins we got is:

```
$ cd /path/to/src
$ python mayb.py train
```

In the end, run the following command in your new terminal and visit at `http://localhost:8000/`.
The images which is displayed on are ones that Mayb could recommend to you. If you click any image,
Mayb would shows you similar images which has strong relationship with that you select.

```
$ cd /path/to/www;
$ python -m CGIHTTPServer
```

## Notes

* run `python mayb.py crawle` before run `python mayb.py train`.


text:
# Monster Train Modding Resources

This repo holds a bunch of sample code regarding modding Monster Train. Feel free to use, reference, modify, pilfer, or otherwise utilize it as you like.

The various examples are not meant to be played with and will not result in enjoyable gameplay. They exist solely for the benefit of up-and-coming Monster Train modders.

## License
[MIT](https://choosealicense.com/licenses/mit/)

repository: KittenAqua/MonsterTrainSampleMod

repo_name: KittenAqua/MonsterTrainSampleMod


text:
# AWS API client for AWS Config

**Generated Dart library from API specification**

*About the service:*
Config provides a way to keep track of the configurations of all the Amazon
Web Services resources associated with your Amazon Web Services account. You
can use Config to get the current and historical configurations of each
Amazon Web Services resource and also to get information about the
relationship between the resources. An Amazon Web Services resource can be
an Amazon Compute Cloud (Amazon EC2) instance, an Elastic Block Store (EBS)
volume, an elastic network Interface (ENI), or a security group. For a
complete list of resources currently supported by Config, see Supported
Amazon Web Services resources.

## Links

- [Other AWS libraries](https://github.com/agilord/aws_client/tree/master/generated).
- [Issue tracker](https://github.com/agilord/aws_client/issues).
- [AWS API definitions](https://github.com/aws/aws-sdk-js/tree/master/apis).

gha_language: Dart


text:
# Pre-work - *Memory Game*

**Memory Game** is a Light & Sound Memory game to apply for CodePath's SITE Program.

Submitted by: Anna Howell

Time spent: **11** hours spent in total

Link to project: https://glitch.com/edit/#!/sugared-rigorous-watchmaker

## Required Functionality

The following **required** functionality is complete:

* [X] Game interface has a heading (h1 tag), a line of body text (p tag), and four buttons that match the demo app
* [X] "Start" button toggles between "Start" and "Stop" when clicked.
* [X] Game buttons each light up and play a sound when clicked.
* [X] Computer plays back sequence of clues including sound and visual cue for each button
* [X] Play progresses to the next turn (the user gets the next step in the pattern) after a correct guess.
* [X] User wins the game after guessing a complete pattern
* [X] User loses the game after an incorrect guess

The following **optional** features are implemented:

* [X] Any HTML page elements (including game buttons) has been styled differently than in the tutorial
* [X] Buttons use a pitch (frequency) other than the ones in the tutorial
* [X] More than 4 functional game buttons
* [ ] Playback speeds up on each turn
* [X] Computer picks a different pattern each time the game is played
* [ ] Player only loses after 3 mistakes (instead of on the first mistake)
* [X] Game button appearance change goes beyond color (e.g. add an image)
* [X] Game button sound is more complex than a single tone (e.g. an audio file, a chord, a sequence of multiple tones)
* [ ] User has a limited amount of time to enter their guess on each turn

The following **additional** features are implemented:

- [X] Made all elements scalaable to size of web page
- [X] Added a sound when the game ends
- [X] Made the game go on until the player loses
- [X] Added notification of the level when the player loses
- [X] Added different colors when the button is hovered over and a shadow to the buttons

## Video Walkthrough

https://recordit.co/4hUR4EfFKw

## Reflection Questions
1. If you used any outside resources to help complete your submission (websites, books, people, etc) list them here.
I consulted stackoverflow and w3schools as well as my prior knowledge of HTML/CSS.

2. What was a challenge you encountered in creating this submission (be specific)? How did you overcome it? (recommended 200 - 400 words)
I added different audios as the sounds for this project, and when I did that I needed to figure out how to play the audios instead of frequencies. In order to do this I made the audios constants and then added them to the map, and then used the play method to play the audios instead. I originally had a bit of difficulty understanding why the audio that I was playing was overlapping. I realized that I needed to change the times in between the audio.

3. What questions about web development do you have after completing your submission? (recommended 100 - 300 words)
I am most interested in learning about how to properly structure a webpage. I found that making sure things were sized and centered was a bit finnicky and my reading didn't really help me to understand why. I also would like to learn how to add elements to a page after the page has already been loaded.

4. If you had a few more hours to work on this project, what would you spend them doing (for example: refactoring certain functions, adding additional features, etc). Be specific. (recommended 100 - 300 words)
I was trying to make it so that the button was only pressed to the amount of time that the audio was playing, but the audios are different lengths and I would have to refactor certain functions to account for the fact that different buttons have different audio lengths. I also would've liked to add a level counter at the bottom of the webpage that lets you know your current progress in the game. I would also like to try to figure out how to include a high score table, and maybe make some additional stylistic chocies about the layout of the webpage.

## License

    Copyright Anna Howell

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

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

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

repository: annalynnhowell/codepath-prework

branch_name: refs/heads/main

repo_name: annalynnhowell/codepath-prework


text:
# laravel-invoices

> *NOTE: The package is currently under construction and has not yet been released with a stable version*

Laravel invoices is a laravel package that will give you the ability to create and save invoices for your platform.

repository: jgabboud/laravel-invoices

gha_language: PHP

repo_name: jgabboud/laravel-invoices


text:
# Changelog

## v1.3.0 (2021-08-23)

### Features

 * Calculate arbitrary observables

## v1.2.3 (2021-08-12)

### Bug Fixes and Other Changes

 * Calculate exact statistics from trace

### Documentation Changes

 * Doc corrections

## v1.2.2 (2021-08-06)

### Bug Fixes and Other Changes

 * Reconcile supported operations with managed format

## v1.2.1 (2021-05-26)

### Bug Fixes and Other Changes

 * Fix perf tests

## v1.2.0 (2021-05-24)

### Features

 * Density matrix simulator

### Testing and Release Infrastructure

 * Use GitHub source for tox tests

## v1.1.1.post2 (2021-03-19)

### Testing and Release Infrastructure

 * Run unit tests for dependent packages

## v1.1.1.post1 (2021-03-11)

### Testing and Release Infrastructure

 * Add Python 3.9

## v1.1.1.post0 (2021-03-03)

### Testing and Release Infrastructure

 * Add team to CODEOWNERS
 * Use main instead of PyPi for build dependencies

## v1.1.1 (2021-01-27)

### Bug Fixes and Other Changes

 * Make tensor products more efficient

## v1.1.0.post2 (2021-01-12)

### Testing and Release Infrastructure

 * Enable Codecov

## v1.1.0.post1 (2020-12-30)

### Testing and Release Infrastructure

 * Add build badge
 * Use GitHub Actions for CI

## v1.1.0.post0 (2020-12-04)

### Testing and Release Infrastructure

 * Change tox basepython to python3

## v1.1.0 (2020-11-26)

### Features

 * Always accept identity observable factors

## v1.0.1.post0 (2020-10-30)

### Testing and Release Infrastructure

 * updating CODEOWNERS

## v1.0.1 (2020-10-29)

### Bug Fixes and Other Changes

 * Enable simultaneous measurement of observables with shared factors

## v1.0.0.post2 (2020-09-09)

### Documentation Changes

 * Add README badges
 * Get Read the Docs working
 * add readthedocs link

### Testing and Release Infrastructure

 * Add CHANGELOG.md
 * Update formatting to follow new black rules
 * Automatically publish to PyPi
 * add stale workflow and labels to issues templates

## v1.0.0.post1 (2020-08-14)

The only way to update a description in PyPi is to upload new files;
however, uploading an existing version is prohibited. The recommended
way to deal with this is with
[post-releases](https://www.python.org/dev/peps/pep-0440/#post-releases).

## v1.0.0 (2020-08-13)

This is the public release of the Amazon Braket Default Simulator!

The Amazon Braket Default Simulator is a Python open source library that provides an implementation of a quantum simulator that you can run locally.


text:
Hi FullStory Team,

Thank you for giving me this wonderful opportunity to take such an interesting coding challenge.
I implemented 2 of the 3 questions which were mentioned in the challenge, as I found both of the
questions equally interesting.

In the repository, you will find a main file and mapper folder. The mapper folder has the implementation
of the hash based data structure. Associated tests are also included respectively.

Some of the points I considered for the hash map datastructure:
1. I wanted to created a map structure which allows custom hash function which is currently not
supported by golang
2. I have tried to optimize the data structure for space, preallocating the memory beforehand rather than
   using slice at startup.
3. Some of the other optimization can be made based on the access pattern of the users, for e.g. swapping
   the latest queried element in map to the start of the list in their bucket, so that next time it is available
   faster.

Regarding the elegance question, I believe the code is elegant if it is stateless, maintainable and readable.
Sometimes elegance comes at cost of performance, so one needs to make the tradeoff when to go for elegance and when
to go for performance.

Would love to hear back your thoughts wherever there is an room for improvement.

Looking forward to hearing from you.

repository: rahulpshah/FullStory

repo_name: rahulpshah/FullStory


text:
# Testing

- setup environment

```bash
    python3 -m venv env
    source env/bin/activate
```

- install requirements

```bash
    pip install -r req.txt
```

- set SecretKey

```bash
    export STRIPE_API_KEY="12345"
```

- set to DEBUG (optional)

```bash
    export FLASK_ENV=development
```

- create Database

```python
    python
    from app import *
    db.create_all()
```

- start app

```bash
  python app.py
```

## API Testing

- export postman file from testing folder
- test all api from here
  - JWT Auth is used
  - Test conditions which can break program like unauthorized access, asking detail of user that doesn't exsist

## Sockets Testing (Pull Request 2)

- open index.html from Testing folder twice
- open index2.html once
- open console for all three
- give attendence now, valid and invalid

### Expected Behaviour

- both index.html file when given same valid otp(event) will group them
and start showing on both of them (notice in console)

### !YouAreDoingWrong

- update index.html and index.html2 with valid JWT token before you start
- Understand how different event users are getting grouped event wise so to test more breifly

repository: Nirmitjatana/AttendanceApp-Backend

repo_name: Nirmitjatana/AttendanceApp-Backend


text:
Beware when using it, and expect significant future changes. To instead add a snapshot of columns to a dataset, see the "Extend" feature guide. This feature is more stable than the dynamic join described here.
</aside>

### Catalog

`/datasets/{id}/joins/`

A GET on this resource returns a Shoji Catalog enumerating the joins present in the Dataset. Each tuple in the index includes a "left_key" and a "right_key" member, each of which MUST be a variable URI. The left_key MUST be a variable in the current dataset, and the right_key SHOULD be a variable in another dataset. Both variables MUST be unique, and should be values taken from the same domain. For example, you might have a principal dataset which is a survey, with a respondent_id variable as a unique key. If you join a separate demographic dataset that has a unique column of the same respondent ids, you might see:

```json
{
    "element": "shoji:catalog",
    "self": "https://app.crunch.io/api/datasets/837498a/joins/",
    "index": {
        "https://app.crunch.io/api/datasets/837498a/joins/demo/": {
            "left_key": "https://app.crunch.io/api/datasets/837498a/variables/1ef71d/",
            "right_key": "https://app.crunch.io/api/datasets/de3095/variables/19471d/"
        }
    }
}
```

A PATCH to this resource may add joins (by including new index members), alter existing joins (by replacing existing index members), or deleting joins (by setting existing members to null). A 204 indicates success. As with any Shoji Catalog, the URI of each entity in the index is the key.

Variables in joined datasets may then be used in analyses as if they were part of the principal dataset, simply by using their URI in this join's variables catalog (see below). The joined dataset includes one row for each row in the principal dataset, by taking the key in the principal and looking up the corresponding key and row in the subordinate dataset. Rows in the principal which have no corresponding row in the subordinate are filled with the "No Data" missing value.

In order to create or alter a new join, the authenticated user will need to have reading access to the right dataset otherwise the server will respond with a 400 error.

The variable url sent for the left key must be a valid url for the current dataset. It is not allowed to use a different dataset as a left table.

### Entity

`/datasets/{id}/joins/{id}/`

A GET on this resource returns a Shoji Entity describing the join, and a link to its Crunch Table (see next). Currently, the Join entity only contains the batch_id for its frame, and therefore isn't very useful for clients. The entity resource is not editable; PATCH the joins catalog instead.

### Joined variables catalog

`/datasets/{id}/joins/{id}/variables/`

A variables catalog which describes variables in the subordinate dataset. See [Variables](#variables) for more details.

repository: Crunch-io/apidocs

gha_language: JavaScript

repo_name: Crunch-io/apidocs


text:
# ds-demo-heroku
Deploy a deepstream.io server on heroku.

This repo was created in combination with a tutorial. You can find the tutorial below.

## Local setup

```
npm install
```

In order to use the storage and cache connectors you need to provide these environment variables:

##### `MONGODB_URI`

##### `REDISCLOUD_URL`

---

# Tutorial

In this tutorial you'll see how easy it is to setup a deepstream server on heroku including
a MongoDB storage layer and a redis cache layer.

## Starting from scracth
Let's start from scratch with an empty directory:

```shell
mkdir ds-demo-heroku
cd ds-demo-heroku
```

Currently there is no heroku add-on or buildpack for deepstream,
so we're going to use a heroku buildpack which based on Node.js.

To create a _package.json_ file we can just run this command:

```shell
npm init
```

If you don't have Node.js (and npm) installed you can also use the package.json at the end of this article.

Now deepstream server can be installed via

```shell
npm install deepstream --save
```

Heroku provides different versions of Node.js which can be specified in the package.json.
So let's add a property to the _package.json_ which defined to use the latest stable Node.js version:

```javascript
  //...
  "engines": {
    "node": "4.4.7"
  },
  //...
```

Heroku applications needs also a [Procfile](https://devcenter.heroku.com/articles/procfile) in the root directory which contains application type and command.
Since deepstream is a server it need to be defined as a `web` type.

```
web: npm start
```

Now lets create the npm start script in the _package.json_:

```javascript
  //..
  "scripts": {
    "start": "deepstream start"
  },
  //..
```

On heroku you can't expose a port directly. Instead heroku will set an environment
variable (`PORT`) which you need to use for your server. This means we need to overwrite
the default deepstream port. We can do this in the deepstream configuration file.
Let's copy the default configuration files to our project directory:

```shell
cp -r node_modules/deepstream.io/conf .
```

Now we need to change the port in the _conf/config.yml_:

```yaml
port: ${PORT}
```

__NOTE__

If you want to access a heroku app from an external network you need to use port
**80**, because all connections will be automatically redirecteed to the internal
port of the environment variable.

## Create a git repository

Deployment with heroku is based on git repositories. So we need to inizialize
the current directory as a git repository via `git init`.

Then we need to ignore the *node_modules* by add this line to a _.gitignore_ file:

```
node_modules
```

Now we need to commit all other files in the current directory:

```shell
git commit -a -m "init commit"
```

Fore more details how to use git, here is a [beginner guide](https://rogerdudler.github.io/git-guide)

## Creating a heroku app and deploy it

If you're not logged in already with the heroku CLI then download
the [heroku toolbelt](https://toolbelt.heroku.com/)
and login with your heroku credentials via `heroku login`.

In the next step we create a heroku app. You should consider to choose a [region](https://devcenter.heroku.com/articles/regions) to avoid unnecessary bigger network delays if most of the connection will come not from the United States which is the default value (us).

This command creates an app with the name **deepstream-test** in Europe:

```shell
heroku apps:create deepstream-test --region eu
```

A git remote (heroku) is also created and associated with your local git repository.
You can see it in your _.git/config_ file.

Now we can push the code (from our local repository) to the remote repository at heroku:

```shell
git push heroku master
```

After ths process is finished we can check the logs on heroku via:

```
heroku logs -t
```

You might notice that the deepstream logo is broken in the logs. This
is because the stdout is streamed asynchronously, so just ignore it ;)

[![asciicast](https://asciinema.org/a/1vu68mmlip64a408i7mxzryis.png)](https://asciinema.org/a/1vu68mmlip64a408i7mxzryis)

## Connect to the deepstream server

To connect the the server you can open this [codepen example](http://codepen.io/timaschew/pen/RRrzjg?editors=1010) and change the `DEEPSTREAM_HOST` to your own host.

You can play around with the codepen and uncomment the `record.set` line and change
the value. If you comment out that line again you should still get the same output.

But if you deploy some code changes or your [heroku dyno goes sleeping](https://devcenter.heroku.com/articles/free-dyno-hours) and waked up again the record data
will be lost. To avoid lossing any data we need to add a storage connector.

## Add a deepstream storage connector

Heroku provides [free addons](https://elements.heroku.com/addons) for databases, logging
and more. We choose a free plan of
[mongolab](https://elements.heroku.com/addons/mongolab) which provides a MongoDB
instance in the cloud. The heroku CLI provides a way do to the whole setup for you,
so you don't to create an account nor you need to care about the credentials,
which are automatically added to your heroku app via a environment variable
(`MONGODB_URI`).

```shell
heroku addons:create mongolab:sandbox
```

You need to verify your account on heroku to use this addon. Otherwise you can
setup the account on mongolab by yourself and set the `MONGODB_URI` environment variable
to your heroku app.

Now let's install the MongoDB connector for deepstream:

```shell
npm install deepstream.io-storage-mongodb --save
```

and add a storage connector configuration snippet to the _conf/config.yml_:

```yaml
plugins:
  storage:
    name: mongodb
    options:
      connectionString: ${MONGODB_URI}
      database: someDb
      defaultTable: someTable
      splitChar: "/"
```

That's it, now we need to add the changes to master branch via

```shell
git commit -a -m "add mongodb connector"
git push heroku master
```

Now all the record data will be persisted (if you add and change them via the codepen example). Even if you stop or restart your heroku app.

## Add a deepstream cache connector

Databases are sometimes to slow for realtime requirements. The focus of a database
is to store data. So if you want to speedup your app you can add a cache layer.
We're going to use another addon on heroku: [rediscloud service](https://elements.heroku.com/addons/rediscloud) provides a free redis server for you heroku apps.
The credentials will be saved in the `REDISCLOUD_URL` environment variable:

```shell
heroku addons:create rediscloud:30
```

and install the redis cache connector for deepstream:

```shell
npm install deepstream.io-cache-redis --save
```

To enable redis with deepstream we need the redis configuraiton to the plugins
object in the _conf/config.yml_:

```yaml
plugins:
  storage:
    name: mongodb
    options:
      connectionString: ${MONGODB_URI}
      database: someDb
      defaultTable: someTable
      splitChar: "/"
  cache:
    name: redis
    options: ${REDISCLOUD_URL}?dropBufferSupport=true
```

In your logs you should see these two lines which indicates that the storage and cache layer are enabled:

```
INFO | cache ready
INFO | storage ready
```

## Resources

Here is the final _package.json_ in case you could not or don't want to use npm
on your local machine:

```json
{
  "name": "ds-demo-heroku",
  "version": "1.0.0",
  "description": "Deploy a deepstream.io server on heroku",
  "main": "index.js",
  "scripts": {
    "start": "deepstream start"
  },
  "engines": {
    "node": "4.4.7"
  },
  "author": "Your Name",
  "license": "ISC",
  "dependencies": {
    "deepstream.io": "github:deepstreamio/deepstream.io",
    "deepstream.io-cache-redis": "^1.0.0",
    "deepstream.io-storage-mongodb": "^1.0.1"
  }
}
```

You can also checkout the final source code on GitHub: https://github.com/deepstreamIO/ds-demo-heroku

license: ISC


text:
### HTML

No changes.

### SCSS

The `_tabs.scss` file is now located at __src/components/tabs/_tabs.scss__. You will need to update any `@import` statements for this file to reflect this change.

```scss
@import 'path_to_node_modules/@console/bluemix-components/src/components/tabs/tabs';
```

No class changes.

### JavaScript

All methods for Tab class have been changed to private methods.

repository: niilante/carbon-components

repo_name: niilante/carbon-components


text:
QuickSort
=========

Implementations and Performance evaluations of different QuickSort algorithms using Java Generics.

Versions of QuickSort currently implemented:
1. Basic QuickSort (Tony Hoare version)
2. Dijkstra 3-Qay Quicksort

Using the Algos
---------------

**Create an Instance passing in your data to be sorted**

Initialize the Algorithms passing in the type of object you need to sort

```Java
QuickSort<Type> sort1 = new QuickSort<>(items);   // For Basic Quicksort
Dijkstra3WayQuickSort<Type> sort2 = new Dijkstra3WayQuickSort<>(items);  // For Dijkstra's method

/* eg: For Integer sorting */
QuickSort<Integer> sort1 = new QuickSort<>(items);   // For Basic Quicksort
Dijkstra3WayQuickSort<Integer> sort2 = new Dijkstra3WayQuickSort<>(items);  // For Dijkstra's method
```
Note that your input must be comparable, meaning that it must implement Java's Comparable interface.

**Simply call sort**
```Java
sort1.sort();
sort2.sort();
```

Performance Evaluations
-----------------------
Here is the output of some performance evaluations I have carried out. The timings are measured in nanoseconds.

**Test 1**

https://github.com/JoshuaKissoon/QuickSort/blob/master/src/quicksort/tests/IntegerArrayTest.java

Sorting a randomly popluated Integer array of 10 million items. Test ran 10 times.  Test ran 10 times.

repository: JoshuaKissoon/QuickSort

repo_name: JoshuaKissoon/QuickSort


text:
# Extreme Falcon Adventure
> Springboot webapp developed using agile methodologies as part of a uni project.

### Installation and Deployment

>The program is docker-compatible and that is the suggested deployment method.

Navigate over to the program directory and run:
```
docker build -t adventurexp --build-arg FALCON_JDBC_URL .
```
For raspberry Pi and ARM architecture compatibility use **Dockerfile-arm** file
```
docker build -t adventurexp --build-arg FALCON_JDBC_URL -f Dockerfile-arm .
```

This will compile the project and create an image.
The `--build-arg FALCON_JDBC_URL` is used to add an environment variable during building of the project.

After that you can start the image with:
 ```
 docker run --name adventurexp -e FALCON_JDBC_URL -dp 80:8080 adventurexp
```
The port 80 can be changed to whichever port you use to access the website.
Hint: Easy raspberry Pi deployment without any router port forwarding can be achieved with usage of Dataplicity's Wormhole service

*Make sure to you have the environment variables setup with exactly matching names, otherwise the build/run will fail.*
*The url follow a format of*

`jdbc:mysql://username:password@minecraft.net:3306/schemaName?serverTimezone=UTC`

### Technologies Used
- Java 11
- Springboot
- SLF4j & Logback
- Maven

### License
This Software is released under an [MIT license](https://opensource.org/licenses/MIT)

repository: Kwandes/AdventureXP

gha_language: Java

repo_name: Kwandes/AdventureXP


text:
# Tags

## Tags Object
Attribute Name      | Type    | Description
------------------- | ----    | -----------
id                  | number  | Unique identifier for tag
name                | string  | User-defined name of tag
description         | string  | User-defined description of tag

## Get All Tags
Use this endpoint to get a list of all tags associated with the user's account.

```json
[
    {
        "id": 1807,
        "name": "Wedding",
        "description": "All wedding-related expenses"
    },
    {
        "id": 1808,
        "name": "Honeymoon",
        "description": "All honeymoon-related expenses"
    }
]
```

### HTTP Request

`GET https://dev.lunchmoney.app/v1/tags`

---


text:
# Professor! It is different!!
## Description
Auto reaction script for Slack

## How to use
Please edit your token, reaction target user id and reaction name for main.rb.

### Example
Please edit the eighth line from the sixth line of main.rb.

```
token = "EXAMPLE TOKEN"
userID = "EXAMPLE USER ID"
reactionName = "EXAMPLE REACTION NAME"
```


text:
# Android-RandomNumberGenerator
A simple random number generator app for Android. Supports Android 6.0+. Written in Kotlin using Android Server.

The app was built following this tutorial: https://codelabs.developers.google.com/codelabs/build-your-first-android-app-kotlin/index.html#7

repository: jaaywags/Android-RandomNumberGenerator

repo_name: jaaywags/Android-RandomNumberGenerator


text:
[![codecov](https://codecov.io/gh/RicardoMiguel/url-shortener/branch/master/graph/badge.svg)](https://codecov.io/gh/RicardoMiguel/url-shortener)
[![Build Status](https://travis-ci.com/RicardoMiguel/url-shortener.svg?branch=master)](https://travis-ci.com/RicardoMiguel/url-shortener)

# Architecture

![aws-serverless-image](./docs/aws-serverless-image.png)

##Production endpoint:
https://uz6d34jo34.execute-api.eu-central-1.amazonaws.com/production

## REST API:
* GET /url?hash=${hash} -> Get url based on hash
* POST /url { "url": "string" }-> create/update a shortened url based on uri
* GET /url/stats -> Get all shortened urls created for a uri

## TODOs:
* Set-up network configurations: VPC, private subnets, permissions
* Blacklist all incoming requests to database besides those which come from VPC peering
* Cron configuration is not working (created manually)

repository: RicardoMiguel/url-shortener

gha_language: TypeScript

repo_name: RicardoMiguel/url-shortener


text:
![λ#](../../../Docs/LambdaSharp_v2_small.png)

# LambdaSharp CLI - New Resource Command

The `new resource` command is used to add a resource to an existing module. The command creates a `Resource` item and generates a skeleton definition using the CloudFormation specification. Required properties are annotated with a corresponding comment. The value of the attributes are the expected type (e.g. `String`, `Json`, etc.).

## Arguments

The `new resource` command takes two arguments: the resource name and the resource type.

```bash
lash new resource MyResource AWS::SNS::Topic
```

## Options

The command has no options.

## Examples

### Create a new module in the current folder

__Using PowerShell/Bash:__
```bash
lash new resource MyResource AWS::SNS::Topic
```

Output:
```
LambdaSharp CLI (v0.5) - Create new LambdaSharp module, function, or resource
Added resource 'MyResource' [AWS::SNS::Topic]

Done (finished: 1/31/2019 9:27:27 PM; duration: 00:00:00.3311624)
```

Module:
```yaml
- Resource: MyResource
  Description: TODO - update resource description
  Scope: [ ]
  Type: AWS::SNS::Topic
  Allow: [ ]
  Properties:
    DisplayName: String
    KmsMasterKeyId: String
    Subscription:
      - Endpoint: String # Required
        Protocol: String # Required
    TopicName: String
```

repository: awesomedotnetcore/LambdaSharpTool

repo_name: awesomedotnetcore/LambdaSharpTool


text:
VisualNeuralNetwork
===================

A simple but pluggable artificial neural network implementation in C# / WinForms, with a class structure that makes the concept a bit explanatory. The application has a visual representation of the path strengths:

For learning purposes only
```c#
// Create a network with 3 layers of 8 input, 7 hidden and 3 output neurons.
var network = NetworkBuilder.Build("MyNetwork", NetworkBuilder.Link, 8, 7, 3);
```
![Graph](https://raw.githubusercontent.com/mharthoorn/VisualNeuralNetwork/master/ExampleGraph.png)

repository: mharthoorn/VisualNeuralNetwork

repo_name: mharthoorn/VisualNeuralNetwork


text:
Apache SkyWalking Rust Agent
==========

<img src="http://skywalking.apache.org/assets/logo.svg" alt="Sky Walking logo" height="90px" align="right" />

[![Twitter Follow](https://img.shields.io/twitter/follow/asfskywalking.svg?style=for-the-badge&label=Follow&logo=twitter)](https://twitter.com/AsfSkyWalking)

![CI](https://github.com/apache/skywalking-nginx-lua/workflows/CI/badge.svg?branch=master)

[**SkyWalking**](https://github.com/apache/skywalking) Rust Agent provides observability capability for Rust App and Library,
including tracing, metrics, topology map for distributed system and alert.
It uses SkyWalking native formats and core concepts to keep best compatibility and performance.

# Concepts
All concepts are from the official SkyWalking definitions.
## Span
Span is an important and common concept in distributed tracing system. Learn Span from Google Dapper Paper.
For better performance, we extend the span into 3 kinds.

1. EntrySpan EntrySpan represents a service provider, also the endpoint of server side. As an APM system, we are targeting the application servers. So almost all the services and MQ-consumer are EntrySpan(s).
2. LocalSpan LocalSpan represents a normal Java method, which does not relate to remote service, neither a MQ producer/consumer nor a service(e.g. HTTP service) provider/consumer.
3. ExitSpan ExitSpan represents a client of service or MQ-producer, as named as LeafSpan at early age of SkyWalking. e.g. accessing DB by JDBC, reading Redis/Memcached are cataloged an ExitSpan.

Tag and Log are similar attributes of the span.
- Tag is a key:value pair to indicate the attribute with a string value.
- Log is heavier than tag, with one timestamp and multiple key:value pairs. Log represents an event, typically an error happens.

## TracingContext
TracingContext is the context of the tracing process. Span should only be created through context, and be archived into the
context after the span finished.

## Injectable
Injectable is used(optional) when the exit span creates. This Injectable received the notification from tracing context,
including the key and value for tracing context across process propagation. Typically, Injectable implementation would
manipulate the RPC header/metadata to make the key/value sent to the server side.

## Extractable
Extractable is used(optional) when the entry span creates. The Extractable fetches the value of the given key from the propagated
context. Typically, Extractable implementation would read the RPC header/metadata, which sent from the client side.

# APIs
## High-Level APIs
High level APIs are targeting convenient usages. These APIs use the ThreadLocal to propagate the context, so users could
create span at any moment, and the context will finish automatically once the first created span of this thread stopped.

```rust
ContextManager::tracing_entry("op1", Some(&injector), |mut span| {
    // Use span freely in this closure
    // Span's start/end time is set automatically with this closure start/end(s).
    span.tag(Tag::new(String::from("tag1"), String::from("value1")));

    ContextManager::tracing_exit("op2", "<IP_ADDRESS>:8080", Some(&extractor), |mut span| {
        span.set_component_id(33);
    });

    ContextManager::tracing_local("op3", |mut span| {});
});
```

## Low-Level Core APIs
Tracing core APIs are 100% manual control tracing APIs. Users could use them to trace any process by following SkyWalking
core concepts.

Low Level APIs request users to create and hold the context and span by the codes manually.

```rust
let mut context = TracingContext::new(reporter.service_instance_id()).unwrap();
let span1 = context.create_entry_span("op1", None, Some(&dyn injector));
{
    assert_eq!(span1.span_id(), 0);
    let mut span2 = context.create_local_span("op2", Some(&span1));
    span2.tag(Tag::new(String::from("tag1"), String::from("value1")));
    {
        assert_eq!(span2.span_id(), 1);
        let mut span3 = context.create_exit_span("op3", Some(&span2), "<IP_ADDRESS>:8080", Some(&dyn extractor));
        assert_eq!(span3.span_id(), 2);

        context.finish_span(span3);
    }
    context.finish_span(span2);
}
context.finish_span(span1);

reporter.report_trace(context);
```

# License
Apache 2.0

repository: yejiayu/skywalking-rust

repo_name: yejiayu/skywalking-rust


text:
---
title: Better way to see info using git log alias
author: Mohit Jain
layout: post
comments: true
permalink: /2012/12/better-way-to-see-info-using-git-log-alias/

categories: Git tips-and-tricks
---

I am big fan of  git log command. Tells me lot of information, but I not impressed with the way it shows the information. I got a pretty big alias to improve and which makes things much better.

## Result

![Git log alias](/wp-content/uploads/2012/12/Screen-Shot-2012-12-09-at-12.50.56-AM.png)
Git log alias

Just gimme one liner:

{% highlight ruby %}
git config --global alias.lg "log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)%Creset' --abbrev-commit --date=relative"
{% endhighlight %}
And now just type

{% highlight ruby %}
git lg
{% endhighlight %}
to see the result as the command will create a git log alias. See this [stackoverflow][3] question for more info on git log alias.

 [3]: http://stackoverflow.com/questions/1057564/pretty-git-branch-graphs "Git log Alias"

For more colors add this code in your .gitconfig in home directory.
{% highlight ruby %}
    [color]
        ui = auto
        interactive = auto
{% endhighlight %}

## New Output

![Better Git log alias](/wp-content/uploads/2012/12/Screen-Shot-2012-12-09-at-1.50.47-AM.png?fit=950,658)


text:
# [ScalaLoci](http://scala-loci.github.io)

ScalaLoci is a distributed programming language embedded into Scala.
The language provides a coherent model based on placement types that enables
reasoning about distributed data flows, supporting multiple software
architectures via dedicated language features and abstracting over low-level
communication details and data conversions. ScalaLoci simplifies developing
distributed systems, reduces error-prone communication code and favors early
detection of bugs.

## Getting ScalaLoci

1. Enable support for macro annotations in your `build.sbt`

   * for Scala 2.13

     ```scala
     scalacOptions += "-Ymacro-annotations"
     ```

   * for Scala 2.11 or 2.12 ([Macro Paradise Plugin](http://docs.scala-lang.org/overviews/macros/paradise.html))

     ```scala
     addCompilerPlugin("org.scalamacros" % "paradise" % "2.1.1" cross CrossVersion.patch)
     ```

2. Add the resolver for the ScalaLoci dependencies to your `build.sbt`

   ```scala
   resolvers += Resolver.bintrayRepo("stg-tud", "maven")
   ```

3. Add the ScalaLoci dependencies that you need for your system to your `build.sbt`

   1. ScalaLoci language (always required)

      ```scala
      libraryDependencies += "de.tuda.stg" %% "scala-loci-lang" % "0.4.0"
      ```

   2. Transmitter for the types of values to be accessed remotely
      (built-in Scala types and standard collections are directly supported without additional dependencies)

      * [REScala](http://www.rescala-lang.com/) reactive events and signals

        ```scala
        libraryDependencies += "de.tuda.stg" %% "scala-loci-lang-transmitter-rescala" % "0.4.0"
        ```

   3. Network communicators to connect the different components of the distributed system

      * TCP [*JVM only*]

        ```scala
        libraryDependencies += "de.tuda.stg" %% "scala-loci-communicator-tcp" % "0.4.0"
        ```

      * WebSocket (using [Akka HTTP](http://doc.akka.io/docs/akka-http/) on the JVM) [*server: JVM only, client: JVM and JS web browser APIs*]

        ```scala
        libraryDependencies += "de.tuda.stg" %% "scala-loci-communicator-ws-akka" % "0.4.0"
        ```

      * WebSocket ([Play](http://www.playframework.com) integration) [*server: JVM only, client: JVM and JS web browser APIs*]

        ```scala
        libraryDependencies += "de.tuda.stg" %% "scala-loci-communicator-ws-akka-play" % "0.4.0"
        ```

      * WebSocket (using [Javalin](http://javalin.io) on the JVM) [*server: JVM only, client: JS web browser APIs*]

        ```scala
        libraryDependencies += "de.tuda.stg" %% "scala-loci-communicator-ws-javalin" % "0.4.0"
        ```

      * WebRTC [*JS web browser APIs only*]

        ```scala
        libraryDependencies += "de.tuda.stg" %% "scala-loci-communicator-webrtc" % "0.4.0"
        ```

   4. Serializer for network communication

      * [µPickle](http://www.lihaoyi.com/upickle/) serialization

        ```scala
        libraryDependencies += "de.tuda.stg" %% "scala-loci-serializer-upickle" % "0.4.0"
        ```

      * [Circe](http://circe.github.io/circe/) serialization

        ```scala
        libraryDependencies += "de.tuda.stg" %% "scala-loci-serializer-circe" % "0.4.0"
        ```

## Using ScalaLoci network communication as a library

ScalaLoci’s underlying network communication library abstracting over different
network protocols can be used directly without ScalaLoci’s language
abstractions. The library provides pluggable *communicators* for different
network protocols and *transmitters* implementing the remote transmission
semantics for values of different types.

1. Add the resolver for the ScalaLoci dependencies to your `build.sbt` (same as [above](#getting-scalaloci))

2. Add the ScalaLoci dependencies that you need for your system to your `build.sbt`

   1. ScalaLoci communication library (always required)

      ```scala
      libraryDependencies += "de.tuda.stg" %% "scala-loci-communication" % "0.4.0"
      ```

   2. Transmitter for the types of values to be accessed remotely
      (built-in Scala types and standard collections are directly supported without additional dependencies)

      * [REScala](http://www.rescala-lang.com/) reactive events and signals

        ```scala
        libraryDependencies += "de.tuda.stg" %% "scala-loci-transmitter-rescala" % "0.4.0"
        ```

   3. Network communicators to connect the different components of the distributed system (same as [above](#getting-scalaloci))

   4. Serializer for network communication (same as [above](#getting-scalaloci))

## Examples and Case Studies

* Examples

  [Simple](http://github.com/scala-loci/examples-simple): Simple showcases of ScalaLoci using small examples

  [Variants](http://github.com/scala-loci/examples-variants): More complete examples implemented in different variants

* Case Studies

  [Flink](http://github.com/scala-loci/case-study-flink): Reimplementation of the task distribution system of [Apache Flink](http://flink.apache.org) in ScalaLoci

  [Gearpump](http://github.com/scala-loci/case-study-gearpump): Reimplementation of the worker assignment logic of [Apache Gearpump](http://gearpump.apache.org/) in ScalaLoci

  [Play Scala.js](http://github.com/scala-loci/case-study-play-scalajs): Reimplementation of the [Play Framework with Scala.js Showcase](http://github.com/hussachai/play-scalajs-showcase) in ScalaLoci

repository: DerDrodt/scala-loci

repo_name: DerDrodt/scala-loci


text:
# This project is deprecated — Svelte can compile directly to custom elements as of version 1.37 (see [sveltejs/svelte#797](https://github.com/sveltejs/svelte/issues/797) for more info)

---

# svelte-custom-elements

Register Svelte components as custom elements.

## Installation and usage

First, you need to be familiar with [Svelte](https://svelte.technology). Read the [guide](https://svelte.technology/guide) if you haven't already, then come back here!

Install svelte-custom-elements to your project...

```bash
npm install -S svelte-custom-elements
```

...then use it in your app like so:

```js
import Counter from './Counter.html';
import { register } from 'svelte-custom-elements';

register( 'my-component', Counter, [ 'value' ] );

document.body.innerHTML = '<my-component value="42"></my-component>';
```

The `register` function takes three arguments:

1. The tag name you wish to use
2. A Svelte component constructor
3. An optional list of 'observed attributes'. Any properties that you want to get or set (i.e. `component.thing = 'foo'`) must be included in this list.

## Demo

### [Link](https://svelte-custom-elements.surge.sh/) / [Source](https://github.com/sveltejs/svelte-custom-elements/tree/master/demo)

![svelte-custom-elements demo](demo/demo.gif)

## License

MIT


text:
# Cantaloupe Image Server

This RFC addresses the possibility of replacing the image-server used for the DLCS. As of January 2022 [IIPImage](https://iipimage.sourceforge.io/) is the image-server of choice, with [Cantaloupe](https://cantaloupe-project.github.io) being considered as a replacement.

Cantaloupe offers a plethora of configuration options and that could lead to alternative handling of orchestration and image-serving.

> A note on terminology: `orchestrator` is a dotnet reverse-proxy service and "orchestration", or to "orchestrate", is the act of copying a file from A to B, ready for fulfilling a request.

## IIPImage Docker Images

For a point of reference, there are 2 Docker images that are used for DLCS deployments.

The [iipsrv-openjpeg](https://github.com/dlcs/image-server-node-iipsrv-openjpeg) Dockerfile builds [OpenJPEG](https://www.openjpeg.org/) 2.4.0 and includes it in the final Docker image.

The [iipsrv-kakadu](https://github.com/dlcs/image-server-node-docker) Dockerfile entrypoint is a shell script that downloads, extracts and uses [Kakadu](https://kakadusoftware.com/) compiled binaries from a specified S3 location.

## IIIF Support

| Image Server | Image API 2.x                                                                                | Image API 3.0                                             |
|--------------|-----------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------|
| IIPImage     | Full level 1 + level 2 compliance with the exception of PNG export for [Image API 2.0](https://iiif.io/api/image/2.0/compliance/) | not-supported                                             |
| Cantaloupe   | Processor dependant, most are [level 2] for [Image API 2.1](https://iiif.io/api/image/2.1/compliance/)                            | [Full level 2](https://iiif.io/api/image/3.0/compliance/) |

Cantaloupe supports multiple different versions of the IIIF Image API, available on different paths (`/iiif/2/` and `/iiif/3/`).

`Orchestrator` supports generating IIIF 2.1 and 3.0 manifests (for [single item manifests](https://github.com/dlcs/protagonist/issues/183) and [named queries](https://github.com/dlcs/protagonist/issues/175)) on different paths as well as a canonical path that will return either v2.1 or v3.0 depending on configuration.

This same path structure and configuration could be used to ensure that the ImageAPI matches the PresentationAPI version. See [#248](https://github.com/dlcs/protagonist/issues/248) and [#247](https://github.com/dlcs/protagonist/issues/247).

## Optimisations

The `orchestrator` is ultimately a glorified reverse-proxy. It parses incoming IIIF Image requests and attempts to shortcut the image-serving by using various optimised services like `thumbs` or the `special-server`.

The request is only handed off to the image-server if it cannot be served by other, more optimised, means. Before handing off, the source image (e.g. JPEG2000) needs to be copied from "slow" object storage to "fast" local storage (ie _orchestrated_). This adds some complexity to the `orchestrator` (holding up requests, managing disk space, monitoring which files are orchestrated etc) so we endeavour to do it as seldom as possible.

Cantaloupe has configurable [sources](https://cantaloupe-project.github.io/manual/5.0/sources.html) and [caches](https://cantaloupe-project.github.io/manual/5.0/caching.html) that specify where source images are to be found, and how they are to be cached.

These properties are of interest to the DLCS as it could allow for multiple, different flavours of image-server. We envisage there being 2 configurations initially, these are outlined more below:

* Cantaloupe instance(s) for `/full/` requests that don't have a matching thumbnail.
* Cantaloupe cluster for serving tiles requests.

### `/full/` Requests

When a `/full/` image request is received we will try to use a pre-generated thumbnail from S3 if it is for a matching size.

If we don't have a pre-generated thumbnail, but the request is within a configurable threshold of a size we _do_ have - then we can resize an existing thumbnail on the fly (e.g. we have a `/!200,200/` thumbnail and the request is for `/!180,180/`).

Both of these approaches avoid orchestrating an image. Now we can add fallback handling for `/full/` requests to a specially configured instance(s) of Cantaloupe.

This would use an [`S3Source`](https://cantaloupe-project.github.io/manual/5.0/sources.html#S3Source) as this avoids the need to orchestrate the image. We plan to use OpenJPEG for decoding JPEG2000 image sources, however it doesn't [support streaming](https://cantaloupe-project.github.io/manual/5.0/processors.html#Supported%20Features) (therefore it can't stream the result directly from S3).

Finding the exact configuration to use will involve some testing as we'll need to identify which combination of processor and [`RetrievalStrategy`](https://cantaloupe-project.github.io/manual/5.0/processors.html#Retrieval%20Strategies) to use. e.g.

* Use a "download" or "cache" retrieval strategy (these differ in that the former deletes the source file immediately after serving the request, whereas the latter caches it) with OpenJPEG.
* Use a less performant processor that supports streaming (e.g. [Java2D](https://cantaloupe-project.github.io/manual/5.0/processors.html#Java2dProcessor) which uses native-Java processing).
* Use Kakadu, which supports streaming but has a high licensing cost.

### Tile Requests

It is expected that tile requests will continue to be handled by the DLCS "orchestrating" the source image and handing the request off to a cluster of Cantaloupe servers using a [`FileSystemSource`](https://cantaloupe-project.github.io/manual/5.0/sources.html#FilesystemSource) and OpenJPEG. This is what currently happens with IIPImage.

#### Orchestrate with Cantaloupe

It may be worth investigating how performant Cantaloupe can be with an `S3Source` and plenty of diskspace for a [`DerivativeCache`](https://cantaloupe-project.github.io/manual/5.0/caching.html#Derivative%20Cache). This would remove the need to copy images via the `orchestrator` service - allowing that to handle reverse proxying requests only.

The advantages to Cantaloupe handling the "orchestration" is that:

* It would remove complexity from the dotnet code and let it purely focus on reverse proxy behaviour.
* Would reduce the number of moving part. No need for scavenger service as we can use Cantaloupe cache workers.
* Removes the need to have the Orchestrator and Cantaloupe servers co-located on same hardware or sharing a NAS.

The disadvantages are:

* Could remove some potential optimisations, like `"OrchestrateOnInfoJson"` optimisation (although this could be accomplished by alternative means).
* Cache invalidation - if a source image is updated then Cantaloupe cache would need to be cleared. This is not fully solved via Orchestrator approach, see [#233](https://github.com/dlcs/protagonist/issues/233)

Ticket [#241](https://github.com/dlcs/protagonist/issues/241) will look at multiple different setups to decide on most appropriate configuration.

### Info.json

IIPImage uses a set 256x256 tile size. This fact makes it quick and easy for the DLCS to serve info.json requests from templates.

Cantaloupe has logic to return the tiles sizes that will be most efficiently delivered. Tile delivery should be faster but it means that the dotnet code will need to proxy info.json requests to Cantaloupe.

Info.json responses are highly cacheable, however the basic info.json generated by Cantaloupe will need to be augmented with some DLCS specific services and identifiers.

We will need to experiment to see how best to augment the info.json but it seems to make sense to happen at the dotnet level as that has access to all required information.

Ticket [#246](https://github.com/dlcs/protagonist/issues/246) addresses this issue of leveraging Cantaloupes built in logic while still efficiently delivering info.json files.

## Future Developments

Cantaloupe has the ability to render individual PDF pages or single frames of a video file. This could lead to some powerful future developments such as [thumbnail services for AV + PDFs](https://github.com/dlcs/protagonist/issues/73) (see [#249](https://github.com/dlcs/protagonist/issues/249)).

## Other Considerations

If not orchestrating we may need to change how we're storing images to help with Format Inference, dependant on source.

Cantaloupe has a [delegate system](https://cantaloupe-project.github.io/manual/5.0/delegate-system.html) that allows it to be extended with custom Java code. This is a powerful feature but should be used sparingly to avoid tying the DLCS to this image-server implementation.

## Further Reading

* [Storage and Orchestration RFC](https://github.com/dlcs/protagonist/blob/master/docs/rfcs/002-storage-and-orchestration.md#orchestration).
* [`image-server`](https://github.com/dlcs/protagonist/labels/image-server) tagged issues.

repository: dlcs/protagonist

gha_language: C#

repo_name: dlcs/protagonist


text:
## Synapse
1. Create and start Synapse instance with remote access. See the Synapse documentation [here](https://synapse.docs.vertex.link/en/latest/synapse/quickstart.html).
2. Configure the **Server URL** to match that of your remote cortex instance.
3. Configure the **port** that was used for the REST API (default is `:4443`).
4. Use your **username** and **password** for remote authentication.
5. Set **use_optic** if your instance is running Synapse Optic.

repository: crestdatasystems/content

repo_name: crestdatasystems/content


text:
# Terraform::AWS::VpcPeeringConnection

Provides a resource to manage a VPC peering connection.

~> **NOTE on VPC Peering Connections and VPC Peering Connection Options:** Terraform provides
both a standalone [VPC Peering Connection Options](vpc_peering_options.html) and a VPC Peering Connection
resource with `Accepter` and `Requester` attributes. Do not manage options for the same VPC peering
connection in both a VPC Peering Connection resource and a VPC Peering Connection Options resource.
Doing so will cause a conflict of options and will overwrite the options.
Using a VPC Peering Connection Options resource decouples management of the connection options from
management of the VPC Peering Connection and allows options to be set correctly in cross-account scenarios.

-> **Note:** For cross-account (requester's AWS account differs from the accepter's AWS account) or inter-region
VPC Peering Connections use the `Terraform::AWS::VpcPeeringConnection` resource to manage the requester's side of the
connection and use the `Terraform::AWS::VpcPeeringConnectionAccepter` resource to manage the accepter's side of the connection.

## Properties

`PeerOwnerId` - (Optional) The AWS account ID of the owner of the peer VPC.
Defaults to the account ID the [AWS provider][1] is currently connected to.

`PeerVpcId` - (Required) The ID of the VPC with which you are creating the VPC Peering Connection.

`VpcId` - (Required) The ID of the requester VPC.

`AutoAccept` - (Optional) Accept the peering (both VPCs need to be in the same AWS account).

`PeerRegion` - (Optional) The region of the accepter VPC of the [VPC Peering Connection]. `AutoAccept` must be `false`,
and use the `Terraform::AWS::VpcPeeringConnectionAccepter` to manage the accepter side.

`Tags` - (Optional) A mapping of tags to assign to the resource.

## Return Values

### Fn::GetAtt

`Id` - The ID of the VPC Peering Connection.

`AcceptStatus` - The status of the VPC Peering Connection request.

## See Also

* [aws_vpc_peering_connection](https://www.terraform.io/docs/providers/aws/r/vpc_peering_connection.html) in the _Terraform Provider Documentation_


text:
# Design Notes for my DYI Eletric Longboard
Here are my design notes and the parts and resources I used to build my electric longboard

## Drivetrain
Recommended parts: http://www.electric-skateboard.builders/t/new-builder-list-of-known-and-commonly-used-parts/2983

## Sizing Estimates + Calculations
http://www.elektro-skateboard.de/wiki/wissenswertes/strom-spannung-reichweite-vii
http://calc.esk8.today

## Drivetrain Calculations
* 6S, 245kV (SK3), 70mm, 36t/15t → 29.1 km/h @ 15.4A
* 6S, 245kV (SK3), 80mm, 36t/15t → 33.3 km/h @ 21.8A
* 6S, 245kV (SK3), 90mm, 36t/15t → 38.4 km/h @ 32.2A
* 8S, 245kV (SK3), 70mm, 36t/15t → 38.8 km/h @ 24.8A
* 8S, 245kV (SK3), 80mm, 36t/15t → 44.3 km/h @ 35.8A
* 10S, 245kV (SK3), 70mm, 36t/15t → 48.5 km/h @ 36.8A
* 10S, 245kV (SK3), 80mm, 36t/15t → 55.4 km/h @ 53.7A

## Ideal Motor kV
Forum recommends max 60k eRPM on VESC (8571 motor RPM with a 14 pole). 8571/pack voltage gives ideal motor kV. LiPos under load are at 3.8V for the longest time of discharge.
* 6S:   8571 / (6*3.8) = 376 kV
* 8S:   8571 / (8*3.8) = 282 kV
* 10S: 8571 / (10*3.8) = 225 kV

## Motor
https://hobbyking.com/de_de/turnigy-aerodrive-sk3-6364-245kv-brushless-outrunner-motor.html
* 245kV
* 2700W
* 10S
* 8mm shaft
Not sensored! But OK for most (says forum), especially with VESC
Dimensions: https://hobbyking.com/media/file/s/k/sk3-6364_dt5035-14p_motor_edited__2.pdf

## ESC
https://www.banggood.com/FVT-CBWI120A-ESC-Brushless-Speed-Controller-For-110-and-18Series-RC-Cars-Skateboard-ESC-p-985970.html
* Has skateboard firmware, programmable with set key/led flashes

Manuals:
* http://img.banggood.com/file/products/20151109031117FVT%20ESC%20Manual_141227.pdf
* http://img.banggood.com/file/products/20151109031144Car%20ESC%20set%20button-1%20(FVT).doc

USB Programmer (7,50€)
* https://www.banggood.com/RC-Car-Program-Card-For-FTV-Series-Car-Brushless-ESC-USB-Link-Card-p-985974.html

Skateboard firmware:
* http://www.electric-skateboard.builders/t/has-anybody-had-issues-with-their-120a-fvt-escs/829/18
* recommends 161214 fw (brakeLine / linear brake...) from http://szfvt.com/en/download-25-5-6-6.html
* attention: skateboard firmware on banggood site is 160406 (brakeStrong...)
* More info: http://makertuts.com/build-electric-longboard-tutorial/#tab-1501905592008-2-2
* https://www.youtube.com/watch?v=Nu4t1w3NTsM (settings + test)

### Max Current for FVT 120A ESC
According to datasheet, each MOSFET can sustain 100A continuous at max 100 °C. Max temperature is 150 °C. Pulsed drain current can be up to 400A . MOSFETs on the board are IRFH5301. Datasheet: https://www.infineon.com/dgdl/irfh5301pbf.pdf?fileId=5546d462533600a40153561b477b1ebe

## Truck mounting kit and Gear ratio
Note: Aliendrive gear ratio is 2! (32t / 15t)

15mm belt, 8mm shaft. Gears: 15 (drive), 36 (wheel)
* https://hobbyking.com/en_us/catalog/category/view/s/electric-skateboard-conversion-kit/id/7590/?wrh=7
* Set also has truck, assuming best fitment, least hassle
* Gears are for 8mm shaft
* Gear ratio: 36/15 = 2.4

## Battery Pack
DYI, 6s4p + 4s4p, from old laptop 18650 cells, with ebay 18650 holders

### Cell datasheet
Panasonic NCR18650:
* <IMG height="150" src="http://www.dampfakkus.de/akkubilder/121.jpg" />
* https://engineering.tamu.edu/media/4247819/ds-battery-panasonic-18650ncr.pdf
* https://na.industrial.panasonic.com/sites/default/pidsa/files/ncr18650.pdf
* Capacity: 2900mAh
* Discharge: 2C max (5.5A)
* Standard Charge: 4.2V @ 0.3C (825mA), max 0.7C (1900mA)
* Cut-off voltage: 2.5V
* 5A discharge curve: http://www.dampfakkus.de/akkutest.php?id=121&a=5
* Chemistry: NCA
* https://batterybro.com/blogs/18650-wholesale-battery-reviews/18880255-battery-chemistry-finally-explained

### Max Power Draw Estimate
vedder.se data logging videos show max 50A (clamped, VESC feature. Car ESCs don't clamp!), 37 km/h, 1200W draw during hardest acceleration: https://youtu.be/nGb-zt2Jp9k

## Continuous Power Draw
Battery pack
* 4P: max rated current per pack is 2C, 5.5A/cell → max 22A continuous draw
* 7P: max rated current per pack is 2C, 5.5A/cell → max 38.5A continuous draw

Estimated cell draw amps, assuming 50A combined draw from pack (hill climb)
4P pack
* 50A / 4 = 12.5A per cell, Cell max: 5.5A → 2.3x above datasheet max!
7P pack
* 50A / 7 = 7.1A per cell, Cell max: 5.5A → 1.3x above datasheet max

## Charger
Imax B6AC V2 (max 6s), balancing charger

## Capacity and Voltage Display
http://www.ebay.de/itm/LY6-8V-63V-Lithium-Battery-Capacity-Tester-12V-48V-Lead-acid-Indicator-BI665/322503659312?_trkparms=aid%3D555018%26algo%3DPL.SIM%26ao%3D2%26asc%3D20140117130753%26meid%3D42048d9cc1e44a9b8ee9989d608406a0%26pid%3D100005%26rk%3D3%26rkt%3D6%26sd%3D291565640012&_trksid=p2047675.c100005.m1851

## Wheels
https://www.ebay.com/itm/Cal-7-90mm-78A-Longboard-Flywheel-Skateboard-Orange-Wheel-Free-Bearings/362080921175?hash=item544db46657:g:jtEAAOSwxh1ZoFzs

## Accessories
Anti-spark connectors, as battery connector + main power switch
* https://hobbyking.com/de_de/xt90-s-anti-spark-connector-2pairs-bag.html
Power switch
* http://www.ebay.de/itm/19mm-12V-KFZ-Schalter-Drucktaster-Taster-Druckschalter-LED-Beleuchtet-Blau-HY/371932020013?_trkparms=aid%3D888007%26algo%3DDISC.MBE%26ao%3D1%26asc%3D46153%26meid%3D2c555a946659458cb913be5bcba83c6c%26pid%3D100009%26rk%3D1%26rkt%3D1%26sd%3D291925934926&_trksid=p2047675.c100009.m1982
Cables + Connectors
* 10AWG wire, 22 AWG wire
* Balancer plug
* Solid copper wire for battery holder

## Deck, Trucks
https://www.amazon.de/Osprey-Longboard-Twin-flameskull-TY5252/dp/B009FUN54Y

## Remote
https://www.amazon.de/gp/aw/d/B073GX83NH/ref=pd_aw_fbt_200_img_2?ie=UTF8&psc=1&refRID=ZVD71XJBYTE2EMCK0ZE0

## Enclosure
DYI, 2mm aluminium sheet

Aluminum, custom size (length x height) possible, use 1.5mm width
http://www.ebay.de/itm/Alublech-0-5-4-mm-Aluminiumblech-ALMg3-Zuschnitt-Format-nach-Mas-Alu-Neu-/171747996796?var=&hash=item27fcfa747c:m:mc2T-lqpOOlLfsBUaAyTSzg

## Fuse
Datasheet: http://www.mta.it/flex/cm/pages/ServeAttachment.php/L/EN/D/2%252Fb%252F6%252FD.cf85c11584525294b9b5/P/BLOB%3AID%3D39/E/pdf

80A should be enough. This one breaks at 120A after 100s. (5s at 200A).


text:
# README Generator
![GitHub license](https://img.shields.io/badge/license-Unlicense-blue.svg)

## Table of Contents
* [Description](#description)
* [Installation](#installation)
* [Usage](#usage)
* [Example](#example)
* [Link](#link)
* [License](#license)

## Description
This application creates a high-quality README for the user's application. This includes prompts for the user to provide a description of the app, installation instructions, contribution information, tests, and contact information if there are questions. The user can also select from options of licenses. the application uses the command line to prompt the user and retrieve inputs.

## Installation
The application uses the [Inquirer package](https://www.npmjs.com/package/inquirer)

Install Inquirer package using the following command:
```bash
npm i
```

## Usage
Invoke the application by using the following command:
```bash
node index.js
```
The user will then be prompted for inputs through the command line. See video for walkthrough:

[![README Walkthrough](./assets/README_Generator_Walkthrough.gif)](https://drive.google.com/file/d/171IC3DSebE4sw0wJTJ3NFnrrcKF-ey3-/view)

## Example
Example of README output, click to see full README output example:

[![Example README](./assets/readme_example.jpg)](./assets/README_OUTPUT.md)

## Link
[Github Link](https://github.com/SeattleSal/readme_generator)

## License
MIT License
Copyright (c) [2020] [Sally Perez]

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.

license: MIT,Unlicense

detected_licenses: MIT Unlicense


text:
# ReorderableGridView

Copy from official ReorderableListView

# Usage:
```
dependencies:
  reorderable_grid_view: ^1.2.0-alpha.1
```

# Example
<img src="https://github.com/huhuang03/reorderable_grid_view/blob/master/example/gifs/example.gif?raw=true" width="360" title="Sceenshot">

``` dart
class _MyHomePageState extends State<MyHomePage> {
  final data = [1, 2, 3, 4, 5];

  @override
  Widget build(BuildContext context) {
    Widget buildItem(String text) {
      return Card(
        key: ValueKey(text),
        child: Text(text),
      );
    }

    return Scaffold(
      appBar: AppBar(
        title: Text(widget.title),
      ),

      body: Center(
        child: ReorderableGridView(
          crossAxisSpacing: 10,
          mainAxisSpacing: 10,
          crossAxisCount: 3,
          children: this.data.map((e) => buildItem("$e")).toList(),
          onReorder: (oldIndex, newIndex) {
            setState(() {
              final element = data.removeAt(oldIndex);
              data.insert(newIndex, element);
            });
          },
          footer: [
            Card(
              child: Center(
                child: Icon(Icons.add),
              ),
            ),
          ],
        ),
      ),
    );
  }
}
```

# Important
as issue #17 says. There's some broke api in MultiDragGestureRecognizer. So if you have some issue relative to MultiDragGestureRecognizer.

Please try both 1.1.x and 1.2.x version.

# Notes
For now, I only test for the child all same size item. If not, please test yourself.


text:
### [CVE-2002-0619](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2002-0619)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

The Mail Merge Tool in Microsoft Word 2002 for Windows, when Microsoft Access is present on a system, allows remote attackers to execute Visual Basic (VBA) scripts within a mail merge document that is saved in HTML format, aka a "Variant of MS00-071, Word Mail Merge Vulnerability" (CVE-2000-0788).

### POC

#### Reference
- http://marc.info/?l=bugtraq&m=102139136019862&w=2

#### Github
No PoCs found on GitHub currently.

repository: trickest/cve

repo_name: trickest/cve


text:
=======
dmptool
=======

**Project moved to Github in June 2014.**

**Helpful information for installing and running DMPTool for your environment:**

DMPTool is a standard database-driven app using Rails v4.x conventions with a few number of dependencies on other tools.

The application is configured and requires OmniAuth to authenticate to LDAP server and/or a Shibboleth IdP.  In order to use the tool as is, you must configure with one of these 2 authentication providers.

**Configuration files**  - Required to run the application.  There are template versions of this in the repository.

* config/database.yml - contains credential information for your database.
* config/shibboleth.yml - contains information for attributes received from shibboleth
* config/ldap.yml - contains credential information for accessing the LDAP servers

**Roles**
There are 6 roles associated with the application which give access to different areas of functionality of the application.

* DMP Admin - super user role - this user has access to all functionality of the application and all roles.
* Institutional Admin - administrator for a particular institution.  Has visibility within a particular institution,  assigns roles to users within their institution and maintains institution information.  Assumes template and resource editor roles.
* Template editor - user which can create and edit templates
* Resource Editor - user which can create and edit resources for templates providing information specific to their institution.
* Reviewer - can review plans within their institution
* Researcher - default role.  i.e. all users assume this role.  Can create and edit plans

**DMPTool provides 5 main areas of functionality.**

* User  - user maintains profile information
* Institution - information about a particular institution, logo, shibboleth endpoints (optional), contact info.  Maintained by institutional or DMP Admin.
* DMP Templates - allows template editors ability to create, edit, and copy DMP Templates.  These are the questions that plans are created from.
* DMP Customizations - allows a resource editor ability to create and edit resouces (links, help text, guidance, example or suggested responses) for particular template
* DMP - data management plans - allows user to create new plans, collaborate with others, print, and export

**Visibility** of information in the tool can be either private, viewable for users within an institution or public (open to everyone).


text:
# Contributing
If you want to contribute to this project please read this.
## General
You are welcome to contribute to this project, but make sure to read the following points to make sure there won't be any complications.
## Development
### Documentation
If you want to develop this project please document your code well. Use the same schema as I used for documentation.
```java
/** Short description
 * <br>
 * Long description
 *
 * @param x If params given describe them here.
 * @param y If params given describe them here.
 * @return Type and description of the returned object.
 *
 * @see If needed mention objects here
 *
 * @since current version
 */
public HashMap<String, String> example(String x, String y) {
	return new HashMap<>(){{
	put("x", x);
	put("y", y);
	}};
}
```
Also make sure you quote yourself as author in the respective class. e.g.:
```java
package com.github.drainyyy.manageStream.core;

/**
 * @author yourGitHubName
 * https://github.com/yourGitHubName
 */
public class ExampleClass {
	public static void exit() {
		System.out.println("exit");
	}
}
```
### Code
The goal of every project (at least for me) is human readability.
So please try not to write a mess and if you find a mess in my code (and sometimes my code is a really big mess) you can message me (or you can clean it up for me lol).
## Issues & Bugs
If you found a bug please report it to the issues page for this project and label it with the bug label.
The issue page can be found [here](https://github.com/drainyyyy/manageStream/issues).

If you found an issue that you want to fix please comment below it that you'll try to fix it.
When you fixed it just create a pull request.

repository: Drainyyyy/manageStream

repo_name: Drainyyyy/manageStream


text:
# Globe - [Demo](https://nenadv91.github.io/Threejs-globe/)
Particles globe with countries in threejs

- Created with Three.js

### Preview
---
![Preview](https://raw.githubusercontent.com/nenadV91/Threejs-globe/master/previews/preview.png?raw=true "Home preview 1")

## Author
Nenad Vracar

## License
Licensed under MIT

repository: dabiaoluo/Threejs-globe

repo_name: dabiaoluo/Threejs-globe


text:
# Eddystone
Eddystone on Nordic PCA10028 device

##Overview of Operation
This Eddystone implementation operated in two modes.  Upon power-on or reset, the device will advertise in "connectable" phase.  After an advertisement timeout (currently 30 seconds), the device is reconfigured to run in standard eddystone "non-connectable" phase for remainder of the power-on cycle.

During the initial "connectable" phase, the device offers only the Nordic "DFU" service.  So, for example, you can connect to the device with the Android app "Nordic Master Control Panel (MCP)" and start a DFU (Device Firmware Update). This triggers the device to return to the Bootloader where the actual DFU processing will take place.

Once the Bootloader is in control, it will advertise itself as "DfuTarg".  You may need rescan with the MCP app to see this new advertised name.

##Building the Firmware

###Requirements
It is assumed that you are able to build the Nordic SDK examples at this point.
Additional requirement are --

* Recent version of GCC toolchain.
* Python 2.7 (2.6 may be ok).
* intelhex which includes hexmerge: "sudo pip install intelhex".
* Segger JLink utilities: version V4.98e or later (slighly earlier versions may work too).

###Project Placement
This project is arranged to expect to be placed (cloned) into the Nordic nRF51 SDK folder on a peer level with the "component", "example", etc. subfolders.

```
  .
  ├── components
  ├── eddystone
  │   ├── README.md
  │   ├── android
  │   │   └── EddystoneValidator
  │   ├── fw
  │   │   ├── app
  │   │   ├── bootloader
  │   │   └── builder
  │   └── ios
  │       └── ios-eddystone-scanner-sample
  └── examples
```

##Building Eddystone

###Building with "Builder"
The easiest way to start is by building and installing the firmware via the "builder" procedure.
Please read the README.md and EXAMPLE.md files under the ./fw/builder directory.

###Developer builds
Enter the component directory you wish to build: app or firmware.
Within this directory there is a subdirectory "gcc"; enter it.
This gcc directory will be where you run the makefile.
The makefile supports two build types: debug and release, which release being the default. Examples are given below.

```
  $ make clean
  $ make debug
```
or
```
  $ make clean
  $ make
```

##OTA-DFU support
This project incorporates OTA-DFU support (Over-The-Air Device-Firmware-Update).
See the HOWTO_DFU.md file under the ./fw/app directory for details.

repository: foldedtoad/eddystone

repo_name: foldedtoad/eddystone