text:
<!---
No Title
-->

## Courses

### Skills

* CAD- Solidworks, Fusion 360,
* Programming languages- Matlab, C++,
* Experimentation- Digital Microscopy, tensile testing, Hardness testing, Impact testing, Fractography
* 3D printers- Form 2, Lulzbot,
* Additive Software- Meshmixer, Catalyst EX, Cura,

### New Summary (Linked-In)
Currently in my last semester (hopefully)

### North Carolina State University

* MAE 533 Finite Element Analysis I
* MAE 589 Digital Manufacturing
| *(Spring 2019)*

### VIT University - Vellore Institute of Technology

* Abc

### Massive Open Online Courses (MOOCs)

* TenarisUniversityX: CNC.ETRRx Introduction to Computer Numerical Control
| edX
| October 2018 – Present

Update Profile Picture
Update softwares and skills- nTopology
Check Danfoss DfAM project dates
Check screenshots/Google Keep for SUMMARY motivations
"Working towards my Lean Six Sigma Yellow belt and identifying key areas of interest that I can work on right away"
Passion Projects in Index page - Laser diffracted PSD analysis, 3D Visulaization of line length differences and hatch rotations along the build height
MOOCs
Links- Reliawiki, Slocum, acmUK, Fictiv, Zeiss, InsideSkunkWorks, Working in Teams, Interesting articles
     - Lab links- MET ReasearchGate, AMRL, CAMAL/CPAC, ORCID, ResearchGate.


text:
# Riddlestone ZF-Gulp

A [Zend Framework 2](https://github.com/zendframework) module for [Gulp](https://gulpjs.com/) configuration

> ## Repository archived 2020-02-06
>
> This repository has been replaced with [riddlestone/brokkr-gulpfile](https://github.com/riddlestone/brokkr-gulpfile).
>
> Note that the new package is much simpler, so some work will be involved in switching to use it.

## Installation

Installation of this module uses composer. For composer documentation, please refer to
[getcomposer.org](http://getcomposer.org/).

```sh
composer require riddlestone/zf-gulp
```

## Usage

To include your Gulp pipeline in the generated configuration file, create a `Riddlestone\ZF\Gulp\ProviderInterface`
implementation, and add it to your module's config file:

```php
<?php
return [
    'gulp' => [
        'providers' => [
            'My\\GulpProvider',
        ],
    ],
    'service_manager' => [
        'factories' => [
            'My\\GulpProvider' => 'My\\GulpProviderFactory',
        ],
    ],
];
```

Have the provider return an array of `Riddlestone\ZF\Gulp\PipelineInterface` objects.

You can then generate `gulpfile.js` using the console command :
```sh
vendor/bin/console gulp
```

## Get Involved

File issues at https://github.com/riddlestone/zf-gulp/issues

repository: riddlestone/zf-gulp

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: riddlestone/zf-gulp


text:
# **Advanced Lane Finding Project**

Code is under the folder `code`
Output images are under `output_images`
Output video is under `output_videos`

### The goals / steps of this project are the following:

* Compute the camera calibration matrix and distortion coefficients given a set of chessboard images.
* Apply a distortion correction to raw images.
* Use color transforms, gradients, etc., to create a thresholded binary image.
* Apply a perspective transform to rectify binary image ("birds-eye view").
* Detect lane pixels and fit to find the lane boundary.
* Determine the curvature of the lane and vehicle position with respect to center.
* Warp the detected lane boundaries back onto the original image.
* Output visual display of the lane boundaries and numerical estimation of lane curvature and vehicle position.

**Original Image**
![Original Image](./test_images/test6.jpg)

**Undistorted Image**
![Undistorted Image](./output_images/calibrated_image.jpg)

**Gradient Image**
![Gradient Image](./output_images/gradient_image.jpg)

**Top view Image**
![Top view Image](./output_images/top_view_image.jpg)

**Fit lines Image**
![Fit lines Image](./output_images/lines_top_view_image.jpg)

**Output Image**
![Output Image](./output_images/test6.jpg)

**Output Video**
![Output Video](./output_videos/project_video.mp4)

## [Rubric](https://review.udacity.com/#!/rubrics/571/view) Points

### Here I will consider the rubric points individually and describe how I addressed each point in my implementation.

---

### Writeup / README

#### 1. Provide a Writeup / README that includes all the rubric points and how you addressed each one.  You can submit your writeup as markdown or pdf.  [Here](https://github.com/udacity/CarND-Advanced-Lane-Lines/blob/master/writeup_template.md) is a template writeup for this project you can use as a guide and a starting point.

You're reading it!

### Camera Calibration

#### 1. Briefly state how you computed the camera matrix and distortion coefficients. Provide an example of a distortion corrected calibration image.

Using the camera calibration images (chessboard images), I used the method `cv2.findChessboardCorners` to get the corners of the chessboard. This will match the corner points on the image and where there suppouse to be in the 2d image.
Having the points on the camera world (3d) and the position they should be on the 2d world/image plane, I can use `cv2.calibrateCamera` to get the calibration matrix, that will calibrate the camera/ remove the distortion (`cv2.undistort`). Although these camera images had an small distortion.

**Original Image**
![Original Image](./test_images/test6.jpg)

**Undistorted Image**
![Undistorted Image](./output_images/calibrated_image.jpg)

#### 2. Describe how (and identify where in your code) you used color transforms, gradients or other methods to create a thresholded binary image.  Provide an example of a binary image result.

I transformerd the image to HLS, to get a better understanding of the shadows, this was explained on the lesson, and the results working with the shadow output is much better than the other two values. To this "shadow image", I did apply a threshold to get the values between two numbers, I did play a bit with these number I found that 130 and 2500 worked fine for detecting the lines. Also applied Sobel to the "light image", getting the X absolute X values, to filter lines with accenture on the X axis. An merging both result into one image.

**Gradient Image**
![Gradient Image](./output_images/gradient_image.jpg)

#### 3. Describe how (and identify where in your code) you performed a perspective transform and provide an example of a transformed image.

I did get the  region o interes, as always this was kind of tricky, sinse the straight_lines images had different region than the test images (or at least I found better results changing it). Having a region of interest I was able to understand the position of 4 points in image plane, that I wanted to look on the top view image (polygon to square). I used `cv2.warpPerspective` to transform those 4 points (corners of the regiong of interest) to an square, and this gave me the top view. I used a debug function to draw an actual square to understand of my region was right + the curvature of the lines or in case of an straight line validate that their were actually straight.

This resulted in the following source and destination points:

```
width = 1280
height = 720
horizon = (height/2)+90
mid_point = (width/2) + 20
multiplier = 50
left_margin = 190 - multiplier
right_margin = width - 160  + multiplier
finish = height
mid_point_left = 63 + 10
mid_point_right = 65 + 10
margin = 100
```
| Source        | Destination   |
|:-------------:|:-------------:|
| mid_point - mid_point_left, horizon		| margin, margin							|
| mid_point + mid_point_right, horizon  | width - margin, margin      |
| right_margin, finish									| width-margin, height-margin |
| left_margin,finish										| margin, height-margin       |

**Top view Image**
![Top view Image](./output_images/top_view_image.jpg)

#### 4. Describe how (and identify where in your code) you identified lane-line pixels and fit their positions with a polynomial?

On the top view image, I did get the histogram to get the two starting points (on the images, on the video I use the previous line as starting points), having them I define a set of windows, these are going to be the areas in which I'll look for points/lines inside them (I used the values from the lessong because I didn;t have any issues with them). I start adding the non_zero values to an array, these are going to be the lines, with the mean of them (center point) I calculate the next window.  With the line points I calculate the resultant lines using `np.polyfit` and plot them/ plot the area between lines

**Fit lines Image**
![Fit lines Image](./output_images/lines_top_view_image.jpg)

#### 5. Describe how (and identify where in your code) you calculated the radius of curvature of the lane and the position of the vehicle with respect to center.

Having the polynomial values of the curvature of each line, I move them to meters (multiply by the default values of pixel by meters, I used the one that we used on the lesson), with the line on meters I used the formula to get the radius of the curvature :
```
Rcurve=((1+(2Ay+B)**2)**1.5)/ abs(2*A)
```

#### 6. Provide an example image of your result plotted back down onto the road such that the lane area is identified clearly.

To get the plotted lines back to the image, what I did is to invert the points order on the same function used to get the top view (probably using the same matrix inverted will work but I just prefered to do this). This means use the square top view points as starting point and the 3d polygon points as resultant position.

**Output Image**
![Output Image](./output_images/test6.jpg)

---

### Pipeline (video)

For the video I found that the curvature radius was changing super fast so I start using the mean of the last 60 frames = 1 second, this makes the numbers change more smoothly (now is posible to read them), + the changes makes more sense, and there is less noise. Also found that I had to increase the region of interest, with a higher horizon line to capture more line points in order to have a more accurated curvature.

**Output Video**
![Output Video](./output_videos/project_video.mp4)

---

### Discussion

#### 1. Briefly discuss any problems / issues you faced in your implementation of this project.  Where will your pipeline likely fail?  What could you do to make it more robust?

I'm not sure about the possion of the car in relation with the lines, it's hard to know if the messurements are right or not, I saw that it start a bit higher and durint the video that value gets smaller which perhaps makes sense.
Also found that writing the video was suuuuuuper slow, which made a bit hard to debug it, but probably playing a bit more with the horizon (a value like `horizon = (height/2)+90` will probably work better) + the threshold for the binary image, although at least with the project video these numbers did work really well, I found only 1 or 2 parts of the video where the noise made the left line to get a bit off, but probably changing the horizon that should be fixed.

license: MIT


text:
# Release Process

This project is released on an as-needed basis following the procedure indicates below.

### Notable branches

- **dev** development branch.
- **master** production branch, containing the last released release.
- **release/vX.X.X** release branch for version X.X.X.

### Release steps

1. Checkout `dev` branch.
1. Make all the pre-release adjustments needed.
1. Update `CHANGELOG.md` including under the new release section all the cards You are bringing in production, moving
them from the *Unreleased* section. How to keep the changelog is described into the related file.
1. `git add` every change You need, including `CHANGELOG.md`.
1. From project root run `yarn version`, providing the version indicated before in changelog for this release.
1. A new commit titled *Released vX.X.X* should have been created by yarn, and tagged with the version provided.
1. Push dev branch.
1. Create a new release branch named `release/vX.X.X` using `git checkout -b release/vX.X.X`.
1. Push release branch and release tag using `git push origin release/vX.X.X && git push origin vX.X.X`.
1. Rebase release branch into **master**, then push it.

repository: eidoo/ethapi-lib

branch_name: refs/heads/dev

gha_language: JavaScript

gha_license_id: MIT

repo_name: eidoo/ethapi-lib


text:
# AI-based Remote Job Search

**Find your next remote job using a little bit of Python and machine learning!**

This tool is based on RemoteOK API and makes it possible to get job recommendations based on your preferences.

This is a study application, you will need to improve it for it to really shine!

Read the article: [Finding Remote Work with Python and AI](https://stribny.name/blog/python-job-search/)

## Installation

Use Poetry to install and run commands:

```
poetry install
poetry shell
```

## Usage

The program is a CLI application that exposes `fetch-new`, `label`, `train` and `recommend` commands:

```
# fetch new job posts from RemoteOk
python main.py fetch-new

# start data labelling
python main.py label

# train classifier on labeled data
python main.py train

# display recommended jobs
python main.py recommend
```

## Licence

Author: [Petr Stříbný](http://stribny.name)

License: The MIT License (MIT)

repository: stribny/python-jobsearch

repo_name: stribny/python-jobsearch


text:
Digital Zoo

Digital Zoo is a small demo application based on MVVM architecture. Also features fetching data from the network, caching the data in the database via repository pattern and uses [this](https://github.com/k-arabadzhiev/Digital-Zoo-REST-API) repo as a backend service.

# 🛠 Tech stack & Open-source libraries
- Minimum SDK level 21
- [Kotlin](https://kotlinlang.org/), [Coroutines](https://github.com/Kotlin/kotlinx.coroutines) and [Flow](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/)
- [Hilt](https://dagger.dev/hilt/) for dependency injection.
- JetPack
  - Lifecycle - dispose of observing data when lifecycle state changes.
  - [ViewModel](https://developer.android.com/topic/libraries/architecture/viewmodel) - UI related data holder, lifecycle aware.
  - [LiveData](https://developer.android.com/topic/libraries/architecture/livedata) - lifecycle-aware observable data holder class.
  - [Room](https://developer.android.com/jetpack/androidx/releases/room) Persistence - abstraction layer for local SQLite database.
  - [DataStore](https://developer.android.com/topic/libraries/architecture/datastore) - store user settings asynchronously with Kotlin Coroutines and Flow.
- Architecture
  - MVVM (Model - ViewModel - View) Architecture
  - Repository pattern
- [Retrofit2](https://github.com/square/retrofit) - Type-safe HTTP client used to connect to the backend API.
- [Moshi](https://github.com/square/moshi/) - JSON parser.
- [Glide](https://github.com/bumptech/glide) - loading images from the network.

# 🎬 Preview

### 📅 TODO 🐌
- Add unit tests
- Improve logged-in user experience
- Disable collapsing toolbar expansion on details screen, but keep hide on scroll behaviour
- Pre-selected species & diet on update animal screen.

# 📝 License
```
MIT License

Copyright (c) 2021 Kostadin Arabadzhiev

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.

repository: k-arabadzhiev/Digital-Zoo

repo_name: k-arabadzhiev/Digital-Zoo


text:
---
description: This template allows you to deploy a simple VM Scale Set of Windows VMs using the latest patched version of Windows 2008-R2-SP1, 2012-Datacenter, or 2012-R2-Datacenter. These VMs are behind a load balancer with NAT rules for RDP connections. They also have Auto Scale integrated
page_type: sample
products:
- azure
- azure-resource-manager
urlFragment: vmss-windows-autoscale
languages:
- json
- bicep
---
# Deploy a VM Scale Set with Windows VMs and Auto Scale

![Azure Public Test Date](https://azurequickstartsservice.blob.core.windows.net/badges/quickstarts/microsoft.compute/vmss-windows-autoscale/PublicLastTestDate.svg)
![Azure Public Test Result](https://azurequickstartsservice.blob.core.windows.net/badges/quickstarts/microsoft.compute/vmss-windows-autoscale/PublicDeployment.svg)

![Azure US Gov Last Test Date](https://azurequickstartsservice.blob.core.windows.net/badges/quickstarts/microsoft.compute/vmss-windows-autoscale/FairfaxLastTestDate.svg)
![Azure US Gov Last Test Result](https://azurequickstartsservice.blob.core.windows.net/badges/quickstarts/microsoft.compute/vmss-windows-autoscale/FairfaxDeployment.svg)

![Best Practice Check](https://azurequickstartsservice.blob.core.windows.net/badges/quickstarts/microsoft.compute/vmss-windows-autoscale/BestPracticeResult.svg)
![Cred Scan Check](https://azurequickstartsservice.blob.core.windows.net/badges/quickstarts/microsoft.compute/vmss-windows-autoscale/CredScanResult.svg)

![Bicep Version](https://azurequickstartsservice.blob.core.windows.net/badges/quickstarts/microsoft.compute/vmss-windows-autoscale/BicepVersion.svg)

[![Deploy To Azure](https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/1-CONTRIBUTION-GUIDE/images/deploytoazure.svg?sanitize=true)](https://portal.azure.com/#create/Microsoft.Template/uri/https%3A%2F%2Fraw.githubusercontent.com%2FAzure%2Fazure-quickstart-templates%2Fmaster%2Fquickstarts%2Fmicrosoft.compute%2Fvmss-windows-autoscale%2Fazuredeploy.json)
[![Deploy To Azure US Gov](https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/1-CONTRIBUTION-GUIDE/images/deploytoazuregov.svg?sanitize=true)](https://portal.azure.us/#create/Microsoft.Template/uri/https%3A%2F%2Fraw.githubusercontent.com%2FAzure%2Fazure-quickstart-templates%2Fmaster%2Fquickstarts%2Fmicrosoft.compute%2Fvmss-windows-autoscale%2Fazuredeploy.json)
[![Visualize](https://raw.githubusercontent.com/Azure/azure-quickstart-templates/master/1-CONTRIBUTION-GUIDE/images/visualizebutton.svg?sanitize=true)](http://armviz.io/#/?load=https%3A%2F%2Fraw.githubusercontent.com%2FAzure%2Fazure-quickstart-templates%2Fmaster%2Fquickstarts%2Fmicrosoft.compute%2Fvmss-windows-autoscale%2Fazuredeploy.json)

This template deploys a Windows VM Scale Set integrated with Azure autoscale.

The template deploys a Windows VMSS with a desired count of VMs in the scale set. Once the VM Scale Sets is deployed, user can deploy an application inside each of the VMs (either by directly logging into the VMs or via a custom script extension)

The Autoscale rules are configured as follows

- sample for CPU (\\Processor\\PercentProcessorTime) in each VM every 1 Minute
- if the Percent Processor Time is greater than 50% for 5 Minutes, then the scale out action (add more VM instances, one at a time) is triggered
- once the scale out action is completed, the cool down period is 1 Minute

`Tags: Microsoft.Network/virtualNetworks, Microsoft.Network/publicIPAddresses, Microsoft.Network/loadBalancers, Microsoft.Compute/virtualMachineScaleSets, Microsoft.Insights/autoscalesettings, ChangeCount`

repository: Azure/azure-quickstart-templates

gha_language: Bicep

repo_name: Azure/azure-quickstart-templates


text:
# node-schematron

This is an Schematron minimal syntax implementation for front- and back-end Javascript. It can be used as
a NodeJS dependency as well as in the browser (ie. wrapped by Webpack). It returns a JSON object with the (resolved)
messages of your assertions.

## To use programmatically

To use programmatically, install to your project like any other npm module: `npm install node-schematron`

```js
const { Schema } = require('node-schematron');

const schema = Schema.fromString(`<schema xmlns="http://purl.oclc.org/dsdl/schematron">
	<pattern>
		<rule context="thunder">
			<let name="lightning"/>
			<report test="$lightning/@foo = 'bar'">
				Skeet boop <value-of select="$lightning/@foo" />
			</report>
		</rule>
	</pattern>
</schema>`);

const results = schema.validateString(
	`<xml foo="err">
	<thunder foo="bar" />
</xml>`,
	{ debug: true }
);

// results === [
//   {
//      isReport: true,
//      context: <thunder foo="bar" />,
//      message: '\n\t\t\t\tSkeet boop bar\n\t\t\t'
//   }
// ]
```

## To use from command line

To use as a command in your terminal, install globally like: `npm install -g node-schematron`. Alternatively, you can
use `npx` to run it.

The `node-schematron` command has two parameters, the last one of which is optional:

1. `schematronLocation`, required, an absolute path or relative reference to your schematron XML. For example
   `my-schema.sch`.
2. `globPattern`, optional, a globbing pattern for documents. For example `*.{xml,dita}` (all .xml and .dita files).
   Defaults to `*.xml` (all .xml files in the current working directory).

```sh
/Users/Wybe/Docs/schematron-test:
  node-schematron my-schema.sch
  # Gives the results for all "*.xml" files in this directory
```

```sh
/Users/Wybe/Docs/schematron-test:
  node-schematron my-schema "docs/**/*.xml"
  # Gives the results for all "*.xml" files in the docs/ directory and all subdirectories
```

Besides that you can give it a fair amount of options:

| Long name     | Short | Description                                                                                |
| ------------- | ----- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `--reporters` | `-r`  | The reporter(s) to use. Zero or many of `npm` or `xunit`, space separated.                                                                                |
| `--ok`        | `-o`  | Do not exit process with an error code if at least one document fails a schematron assertion.                                                                                |
| `--debug`     | `-D`  | Display extra stack trace information in case of XPath errors                                                                                |
| `--files`     | `-f`  | A list of files, in case you can't use the globbing parameter.                                                                                |
| `--batch`     | `-b`  | The number of documents to handle before opening the next child process. Defaults to `5000`.                                                                                |
| `--phase`     | `-p`  | The schematron phase to run. Defaults to `#DEFAULT` (which means the `@defaultPhase` value or `#ALL`.                                                                               |
| `--log-level` | `-l`  | The amount of stuff to log. Only used if `-r` includes `npm`. Value must be one of `silly`, `info`, `report`, `pass`, `assert`, `fail`, `fileError` or `error`. Defaults to `info`. |

```sh
/Users/Wybe/Docs/schematron-test:
  node-schematron my-schema.sch "**/*.xml" --phase publication --log-level fail
  # Validates the "publication" phase and logs only the paths of documents that fail
```

```sh
/Users/Wybe/Docs/schematron-test:
  node-schematron my-schema.sch "**/*.xml" -r xunit > test-reports/test-report.xml
  # Validates the "publication" phase and writes an XUnit XML report to file
```

## Custom functions

XSLT functions (`<xsl:function>`) are not supported. There is a feature branch (`xslt-functions`)
with a naive implementation that unfortunately got stuck. More about that problem in
[this closing comment in a related ticket](https://github.com/wvbe/node-schematron/issues/1#issuecomment-873554478).

To define custom XPath functions via Javascript, import `registerCustomXPathFunction`:

```js
const { registerCustomXPathFunction } = require('node-schematron');

registerCustomXPathFunction(
	{
		localName: 'is-foo',
		namespaceURI: 'http://example.com'
	},
	['xs:string?'],
	'xs:boolean',
	(domFacade, input) => input === 'foo'
);
```

The `registerCustomXPathFunction` is an alias for the same function in `fontoxpath`. See the
[fontoxpath "global functions" documentation](https://github.com/FontoXML/fontoxpath#global-functions) for more
information.

## Compliance

As for features, check out the unit tests in `test/`. I've mirrored them to the text of [ISO/IEC 19757-3 2016](./docs/c055982_ISO_IEC_19757-3_2016.pdf) in order to clearly assert how far `node-schematron` is up to spec.
I've also noticed there's different ways you can read that text, so please file an issue if you feel `node-schematron`
behaves in a non-standard or buggy way.

| Section | Thing          | Status         |
| ------- | -------------- | -------------- |
| 5.4.1   | `<active />`   | Tests OK       |
| 5.4.1   | `<active />`   | Tests OK       |
| 5.4.2   | `<assert />`   | Tests OK       |
| 5.4.3   | `<extends />`  | Not on roadmap |
| 5.4.4   | `<include />`  | Not on roadmap |
| 5.4.5   | `<let />`      | Tests OK       |
| 5.4.6   | `<name />`     | Tests OK       |
| 5.4.7   | `<ns />`       | Experimental   |
| 5.4.8   | `<param />`    | Tests OK       |
| 5.4.9   | `<pattern />`  | Tests OK       |
| 5.4.10  | `<phase />`    | Tests OK       |
| 5.4.11  | `<report />`   | Tests OK       |
| 5.4.12  | `<rule />`     | Tests OK       |
| 5.4.13  | `<schema />`   | Tests OK       |
| 5.4.14  | `<value-of />` | Tests OK       |

Not supported attributes are `@abstract`, `@diagnostics`, `@icon`, `@see`, `@fpi`, `@flag`, `@role` and `@subject`.

## Support

-   Every pull request will be considered and responded to.
-   The schematron query language is XPath 3.1, implemented by [fontoxpath](https://www.npmjs.com/package/fontoxpath). It
    is [not yet feature complete](https://documentation.fontoxml.com/editor/latest/xpath-25591894.html).

## License

Copyright (c) 2019 Wybe Minnebo

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.**

repository: wvbe/node-schematron

gha_language: TypeScript

repo_name: wvbe/node-schematron


text:
---
layout: default
title: "Understanding CSS Selectors"
permalink: /2005/08/24/Understanding-CSS-Selectors/
---

One again, JuicyStudio has some good info on styling content with CSS. The article is titled Div Mania but soon moves onto discussing Selector Specificity which is really interesting and helpful in understanding applying CSS.


text:
# Visualizing-CNNs
A python script to put in your project file to run visualizations on what your CNN filters are learning.
(Ongoing)


text:
# PyLedger

Python script that reads a ledger and gets the account balance for a given user and for a specific date.

### Requirements

- Docker (https://www.docker.com)

### Installation
1. `$ docker-compose build`
2. `$ docker-compose up -d`
3. `$ docker exec -ti pyledger-app sh`

### Usage

Run the python REPL and use the following example:

```
from src.ledger import Ledger

ledger = Ledger('data/ledger.csv')
# get account balance for an account id to current date
ledger.get_account_balance('john')
# get account balance for an account id for a certain day
ledger.get_account_balance('mary', '2015-01-24')
```

### Run tests

From the docker shell (`docker exec -ti pyledger-app sh`) run the following command:

`py.test`

repository: cdragos/pyledger

repo_name: cdragos/pyledger


text:
# Hello World

The classical introductory exercise. Just say "Hello, World!".

["Hello, World!"](http://en.wikipedia.org/wiki/%22Hello,_world!%22_program) is
the traditional first program for beginning programming in a new language
or environment.

The objectives are simple:

- Write a function that returns the string "Hello, World!".
- Run the test suite and make sure that it succeeds.
- Submit your solution and check it at the website.

If everything goes well, you will be ready to fetch your first real exercise.

 Check it out for tips and
assistance!

## Setup

Go through the setup instructions for Kotlin to install the necessary
dependencies:

[https://exercism.io/tracks/kotlin/installation](https://exercism.io/tracks/kotlin/installation)

## Making the test suite pass

Execute the tests with:

```bash
$ gradlew test
```

> Use `gradlew.bat` if you're on Windows

In the test suites all tests but the first have been skipped.

Once you get a test passing, you can enable the next one by removing the
`@Ignore` annotation.

## Source

This is an exercise to introduce users to using Exercism [http://en.wikipedia.org/wiki/%22Hello,_world!%22_program](http://en.wikipedia.org/wiki/%22Hello,_world!%22_program)

## Submitting Incomplete Solutions

It's possible to submit an incomplete solution so you can see how others have
completed the exercise.

repository: TGITS/programming-workouts

gha_language: HTML

repo_name: TGITS/programming-workouts


text:
# scopehal-cmake
CMake build wrapper for scopehal and scopehal-apps

## How to build the host software on Linux:

### Prerequisites for GNU/Linux (Debian/Ubuntu):

`sudo apt-get install build-essential cmake pkg-config libglm-dev libgtkmm-3.0-dev libsigc++-2.0-dev`

#### Build and Install FFTS (required for scopehal-cmake)
`cd ~`

`git clone https://github.com/anthonix/ffts.git`

`cd ffts`

`mkdir build`

`cd build`

`cmake ../`

`sudo make install`

### Build host software on Linux:

`cd ~`

`git clone https://github.com/azonenberg/scopehal-cmake.git --recurse-submodules`

`cd scopehal-cmake`

`cmake ./`

`make`

`sudo make install`

#### Run glscopeclient

`cd ~/scopehal-cmake/src/glscopeclient/`

Example with Lecroy Oscilloscope available on network waverunner.mynetwork.net:

`./glscopeclient --debug WR8:lecroy_vicp:waverunner.mynetwork.net`

repository: bvernoux/scopehal-cmake

repo_name: bvernoux/scopehal-cmake


text:
# ijk
> Transforms arrays into virtual DOM trees

[![Build Status](https://travis-ci.org/lukejacksonn/ijk.svg?branch=master)](https://travis-ci.org/lukejacksonn/ijk)
[![codecov](https://codecov.io/gh/lukejacksonn/ijk/branch/master/graph/badge.svg)](https://codecov.io/gh/lukejacksonn/ijk)

Find `h` a bit repetitive? Not a huge fan of JSX? Love LISP? Code as data and data as code?

This is a tiny recursive factory function that allows you to write terse, declarative representations of virtual DOM trees. It does not try mimic HTML or JSON syntax but instead a series of nested arrays to represent user interfaces.

```js
const tree = h('x', 'y', 'z')
(
  ['main', [
    ['h1', 'Hello World'],
    ['input', { type: 'range' }],
    ['button', { onclick: console.log }, 'Log Event'],
  ]]
)
```

The above call to `h` returns a virtual DOM tree with named attributes that respect the provided schema. Expected output here, would be of the shape `{ x: 'main', y: {}, z: [...] }`. A tree like this can be passed as a node to patch, diff and render algorithms exposed by libraries like [Hyperapp](https://github.com/hyperapp/hyperapp), [Ultradom](https://github.com/jorgebucaran/ultradom) or [Preact](https://github.com/developit/preact).

### Schemas

- **Hyperapp** / **Ultradom** / **Preact:** `h('nodeName','attributes','children')`

## Signature

A call to `h(x,y,z)` returns a build function that expects a node of type `[0,1,2]` where:

- Index `0` contains a `string` used as the elements tag name (required)
- Index `1` contains an `object` containing element attributes (optional)
- Index `2` contains an `string|array` of content or children (optional)

Children are flattened and falsey children are excluded. Numbers passed as children get converted to strings.

## Installation

```
npm i ijk
```

## Usage

Here is a demo with [Hyperapp](https://codepen.io/lukejacksonn/pen/BJvXvg?editors=0010) and [Preact](https://codepen.io/lukejacksonn/pen/ZvwKva?editors=0010).

```js
import { h } from 'ijk'

const tree = h('nodeName', 'attributes', 'children')(
  ['main', [
    ['h1', 'Hello World'],
    ['input', { type: 'range' }],
    ['button', { onclick: console.log }, 'Log Event'],
    ['ul', [
      ['li', 1],
      ['li', 2],
      ['li', 3]
    ]],
    false && ['span', 'Hidden']
  ]]
)
```

## Comparison

ijk is essentially `h` but with optional props and you only have to call `h` once; not every time you want to represent an element in the DOM. This generally means less repetition and one less import in your view files.

```js
const h =
  h('main', {}, [
    h('h1', {}, 'Hello World'),
    h('input', { type: 'range' }),
    h('button', { onclick: console.log }, 'Log Event'),
    h('ul', {}, [
      h('li', {}, 1),
      h('li', {}, 2),
      h('li', {}, 3),
    ]),
    false && h('span', {}, 'Hidden')
  ])
```

The main advantages over using JSX is less repetition of tag names and no build step is required.

```jsx
const jsx =
  <main>
    <h1>Hello World</h1>
    <input type='range' />
    <button onclick={ console.log }>Log Event</button>
    <ul>
      <li>1</li>
      <li>2</li>
      <li>3</li>
    </ul>
    {false && <span>'Hidden'</span>}
  </main>
```

## Advanced

Here is an example that takes advantage of most features and demonstrates components.

```js
import { h } from 'ijk'

const Item = data => ['li', data]
const Article = ({ title, story, related }) => [
  'article',
  [
    ['h2', title],
    ['hr'],
    ['p', story],
    related.map(Item),
  ]
]

const Main =
  ['main', [
    ['h1', 'Hello World'],
    ['input', { type: 'range' }],
    ['ul', [
      ['li', 1],
      ['li', 2],
      ['li', 3],
    ]],
    ['button', { onclick: console.log }, 'Log Event'],
    false && ['span', 'Hidden'],
    Article({
      title: 'Some News',
      story: 'lorem ipsum dolor sit amet',
      related: [4,5],
    })
  ]]

const tree = h('nodeName', 'attributes', 'children')(Main)
```


text:
---
layout: post
title: "Powershell: How to create a Standard Library Binary Module"
date: 2018-08-04
tags: [PowerShell,Modules]
share-img: "/img/share-img/2018-08-04-Powershell-Standard-Library-Binary-Module.png"
---

I recenty had an idea for module that I wanted to implement as a binary module. I have yet to create one using the [PowerShell Standard Library](https://github.com/PowerShell/PowerShellStandard) so this felt like a good opportunity. I was able to use the [Creating a cross-platform binary module](https://github.com/PowerShell/PowerShell/blob/master/docs/cmdlet-example/command-line-simple-example.md) guide to create this module without any roadblocks. We are going to walk that same process and I'll add a little extra commentary along the way.

--Update:-- I found an easier way to do a few of the binary module steps and I added them to the end of the article.

# Index

* TOC
{:toc}

# What is the PowerShell Standard Library?

The PowerShell Standard Library allows us to create cross platform modules that work in both PowerShell Core and with Windows PowerShell 5.1 (or 3.0).

# Planning our module

The plan for this module is to create a `src` folder for the C# code and structure the rest of the module like I would for a script module. This includes using a build script to compile everything into an `output` folder. The folder structure will look like this:

    MyModule
    ├───src
    ├───Output
    │   └───MyModule
    ├───MyModule
    │   ├───Data
    │   ├───Private
    │   └───Public
    └───Tests

# Getting Started

I normally use a Plaster template but my current template does not have any binary module support yet. Not a big deal, I'll create this one by hand this time.

First I need to create the folder and create the git repo. I will be using `$module` as a place holder for the module name. This should make it easier for you to reuse these examples if needed.

``` posh
    $module = 'MyModule'
    New-Item -Path $module -Type Directory
    Set-Location $module
    git init
```

Then create the root level folders.

``` posh
    New-Item -Path 'src' -Type Directory
    New-Item -Path 'Output' -Type Directory
    New-Item -Path 'Tests' -Type Directory
    New-Item -Path $module -Type Directory
```

## Binary module setup

The focus of this will be on the binary module so that is where we will start. This section pulls examples from the [Creating a cross-platform binary module](https://github.com/PowerShell/PowerShell/blob/master/docs/cmdlet-example/command-line-simple-example.md) guide. Please review that guide if you need more details or have any issues.

First thing we want to do is check the version of the [dotnet core SDK](https://www.microsoft.com/net/download/core) that we have installed. I am using 2.1.4, but you should have 2.0.0 or newer before continuing.

    PS:> dotnet --version
    2.1.4

I will be working out of the `src` folder for this section.

``` posh
    Set-Location 'src'
```

Using the dotnet command, create a new class library.

``` posh
    dotnet new classlib --name $module
```

This created the library project in a subfolder but I don't want that extra level of nesting. I am going to move those files up a level.

``` posh
    Move-Item -Path .\$module\* -Destination .\
    Remove-Item $module -Recurse
```

Set the .net core SDK version for the project. I have the 2.1 SDK so I am going to specify 2.1.0. Use 2.0.0 if you are using the 2.0 SDK.

    dotnet new globaljson --sdk-version 2.1.0

Add the [PowerShell Standard Library](https://www.nuget.org/packages/PowerShellStandard.Library/) package to the project. Make sure you use the most recent version available for the level of compatibility that you need. I would default to version `5.1.0-preview-05` but I don't think this module will leverage anything newer than what PS 3.0 provides.

    dotnet add package PowerShellStandard.Library --version 3.0.0-preview-02

We should have a src folder that looks like this:

    PS:> Get-ChildItem
        Directory: \MyModule\src

    Mode                LastWriteTime         Length Name
    ----                -------------         ------ ----
    d-----        7/14/2018   9:51 PM                obj
    -a----        7/14/2018   9:51 PM             86 Class1.cs
    -a----        7/14/2018  10:03 PM            259 MyModule.csproj
    -a----        7/14/2018  10:05 PM             45 global.json

We are now ready to add our own code to the project.

### Building a binary cmdlet

We need to update the `src\Class1.cs` to contain this starter cmdlet:

``` csharp
    using System;
    using System.Management.Automation;

    namespace MyModule
    {
        [Cmdlet( VerbsDiagnostic.Resolve , "MyCmdlet")]
        public class ResolveMyCmdletCommand : PSCmdlet
        {
            [Parameter(Position=0)]
            public Object InputObject { get; set; }

            protected override void EndProcessing()
            {
                this.WriteObject(this.InputObject);
                base.EndProcessing();
            }
        }
    }
```

We will rename the file to match the class name.

``` posh
    Rename-Item .\Class1.cs .\ResolveMyCmdletCommand.cs
```

Then we can build our module.

    PS:> dotnet build

    Microsoft (R) Build Engine version <IP_ADDRESS>428 for .NET Core
    Copyright (C) Microsoft Corporation. All rights reserved.

    Restore completed in 18.19 ms for C:\workspace\MyModule\src\MyModule.csproj.
    MyModule -> C:\workspace\MyModule\src\bin\Debug\netstandard2.0\MyModule.dll

    Build succeeded.
        0 Warning(s)
        0 Error(s)

    Time Elapsed 00:00:02.19

We can call `Import-Module` on the new dll and it will load our new CMDlet.

    PS:> Import-Module .\bin\Debug\netstandard2.0\$module.dll
    PS:> Get-Command -Module $module

    CommandType Name                    Version Source
    ----------- ----                    ------- ------
    Cmdlet      Resolve-MyCmdlet        <IP_ADDRESS> MyModule

If the import fails on your system, try updating .Net to 4.7.1 or newer. The [Creating a cross-platform binary module with the .NET Core command-line interface tools](https://github.com/PowerShell/PowerShell/blob/master/docs/cmdlet-example/command-line-simple-example.md) guide goes into more details on .Net support and compatibility for older version of .Net.

## Module manifest

It's cool that we can import the dll and have a working module. I like to keep going with it and create a module manifest. We will need this if we want to publish to the PSGallery later.

From the root of our project, we can run this command to create the module manifest that we need.

``` posh
    $manifestSplat = @{
        Path              = ".\$module\$module.psd1"
        Author            = 'Kevin Marquette'
        NestedModules     = @('bin\MyModule.dll')
        RootModule        = "$module.psm1"
        FunctionsToExport = @('Resolve-MyCmdlet')
    }
    New-ModuleManifest @manifestSplat
```

I'm also going to create an empty root module for future PowerShell functions.

``` posh
    Set-Content -Value '' -Path ".\$module\$module.psm1"
```

This allows me to mix both normal PowerShell functions and binary Cmdlets in the same project.

## Building the full module

I compile everything together into an output folder. We need to create a build script to do that. I would normally add this to an `Invoke-Build` script, but we can keep it simple for this example. Add this to a `build.ps1` at the root of the project.

``` posh
    $module = 'MyModule'
    Push-Location $PSScriptroot

    dotnet build $PSScriptRoot\src -o $PSScriptRoot\output\$module\bin
    Copy-Item "$PSScriptRoot\$module\*" "$PSScriptRoot\output\$module" -Recurse -Force

    Import-Module "$PSScriptRoot\Output\$module\$module.psd1"
    Invoke-Pester "$PSScriptRoot\Tests"
```

This will build our DLL and place it into our `output\$module\bin` folder. It will then copy the other module files into place.

    Output
    └───MyModule
        │   MyModule.psd1
        │   MyModule.psm1
        │
        └───bin
                MyModule.deps.json
                MyModule.dll
                MyModule.pdb

At this point, we are able to import our module with the psd1 file.

``` posh
    Import-Module ".\Output\$module\$module.psd1"
```

From here, we can drop the `.\Output\$module` folder into our `$env:PSModulePath` directory and it will auto-load our command whenever we need it.

# Important details

Before we end this article, here are a few other details worth mentioning.

## Unloading DLL's

Once a binary module is loaded, you can't really unload it. The DLL file will be locked until you unload it. This can be annoying when developing because every time you make a change and want to build it, the file will often be locked. The only reliable way to resolve this is to close the PowerShell session that loaded the DLL.

### VSCode reload window action

I do most of my PowerShell dev work in [VSCode](https://code.visualstudio.com). When I am working on a binary module (or a module with classes), I have gotten myself into the habit of reloading VSCode every time I build. `Ctrl + Shift + P` will pop the command window and `Reload Window` is always at the top of my list.

### Nested PowerShell sessions

One other option is to have good Pester test coverage. Then you can adjust the build.ps1 script to start a new PowerShell session, perform the build, run the tests, then close the session.

### Updating installed modules

This locking can be annoying when trying to update your locally installed module. If any session has it loaded, you have to go hunt it down and close it. This is less of an issue when installing from a PSGallery because module versioning places the new one in a different folder.

You can set up a local PSGallery and publish to that as part of your build. Then do your local install from that PSGallery. This sounds like a lot of work, but this can be as simple as starting a docker container. I cover a way to do that in my post on [Using a NuGet server for a PSRepository](/2018-03-03-Powershell-Using-a-NuGet-server-for-a-PSRepository/?utm_source=blog&utm_medium=blog&utm_content=standardlibrary).

# Why binary modules?

I jumped right into how to make a binary module and didn't mention why you would want to make one. In reality, you are writing C# and give up easy access to PowerShell Cmdlets and functions. That is a big reason why I have not shifted to binary modules sooner.

But if you are creating a module that does not depend on a lot of other PowerShell commands, the performance benefit can be quite large. By dropping into C#, you get to shed the overhead added by PowerShell. PowerShell was optimized for the administrator, not the computer and that adds a little overhead.

At work, we have a critical process that does a lot of work with JSON and Hashtables. We optimized the PowerShell as much as we could but this process was still running for 12 minutes. The module already contained a lot of C# style PowerShell. This made the conversion to a binary module very clean and easy to do. Our conversion cut that process down from over 12 minutes to under 4 minutes. That opened my eyes a little bit.

## Hybrid modules

You can mix binary Cmdlets with PowerShell advanced functions. That is exactly what I am doing in this guide. You can take everything you know about script modules and it all applies the same way. The empty `psm1` file that I created today is there just so you can drop in other PowerShell functions later.

Almost all of the compiled cmdlets that we created started out as a PowerShell function first. All of our binary modules are really hybrid modules.

## Build scripts

I kept the build script simple here. I generally use a large `Invoke-Build` script as part of my CI/CD pipeline. It does more magic like running Pester tests, running PSSciptAnalyzer, managing versioning, and publishing to the PSGallery. Once I started using a build script for my modules, I was able to find lots of things to add to it.

# Final thoughts

Binary modules are very easy to create. I didn't touch on the C# syntax for creating a Cmdlet, but there is plenty of documentation on it. [Windows PowerShell SDK](https://docs.microsoft.com/powershell/scripting/developer/windows-powershell-reference). It is definitely something worth experimenting with as a stepping stone into more serious C#.

# Update: dotnet new PSModule

I learned that there is a `PSModule` `dotnet new` template.

It's worthwhile adding that dotnet new recently added templating for PS:
dotnet new -i Microsoft.PowerShell.Standard.Module.Template
dotnet new psmodule
(taken from @TylerLeonhardt : https://t.co/RGLVcjGXUF)
— Chris Bergmeister [MVP] (@CBergmeister) August 5, 2018

All the steps that I outlined above are still valid, but this template cuts a lot of them out. It is still a fairly new template that is still getting some polish placed on it. Expect it to keep getting better from here.

This is how you use install and use the PSModule template.

``` posh
    dotnet new -i Microsoft.PowerShell.Standard.Module.Template
    dotnet new psmodule
    dotnet build
    Import-Module "bin\Debug\netstandard2.0\$module.dll"
    Get-Module $module
```

This minimal viable template takes care of adding the .Net SDK, PowerShell Standard Library, and creates an example class in the project. You can build it and run it right away.


text:
---
layout: default
modal-id: 1
date: 2015-09-01
img: instanote.png
alt: image-alt
project-date: Sep 2015
source: GitHub
link: https://github.com/lisalisadong/InstaNote
category: Java, Android SDK, Tess-Two, SQLite
description:
Mobile Notetaking App based on OCR

Developed an app that allows users to take notes without typing. Swipe-selected text in images will be transformed into a plaintext note.

Implemented five activities enabling users to sort, add, edit, favorite, delete, and share notes. Integrated with Google maps to associate locations with notes.

Applied and customized Tess-Two open source OCR library. Integrated SQLite database to store notes and other metadata.

Applied Android material design at the frontend. Implemented UI elements such as floating action buttons, data/time picker, and swipe-to-delete.

img0: instanote0.png
img1: instanote1.png
img2: instanote2.png
img3: blank.png
img4: blank.png

demo: NA

---

extension: markdown


text:
# Contribute to GitLab CI

This guide details how contribute to GitLab CI.

### Issue tracker guidelines

**[Search the issues](https://gitlab.com/gitlab-org/gitlab-ci/issues)** for similar entries before submitting your own, there's a good chance somebody else had the same issue. Show your support with `:+1:` and/or join the discussion. Please submit issues in the following format (as the first post):

1. **Summary:** Summarize your issue in one sentence (what goes wrong, what did you expect to happen)
2. **Steps to reproduce:** How can we reproduce the issue
3. **Expected behavior:** Describe your issue in detail
4. **Observed behavior**
5. **Relevant logs and/or screenshots:** Please use code blocks (\`\`\`) to format console output, logs, and code as it's very hard to read otherwise.
6. **Possible fixes**: If you can, link to the line of code that might be responsible for the problem

## Merge requests

We welcome merge requests with fixes and improvements to GitLab code, tests, and/or documentation. The features we would really like a merge request for are listed with the [status 'accepting merge/merge requests' on our feedback forum](http://feedback.gitlab.com/forums/176466-general/status/796455) but other improvements are also welcome.

### Merge request guidelines

If you can, please submit a merge request with the fix or improvements including tests. If you don't know how to fix the issue but can write a test that exposes the issue we will accept that as well. In general bug fixes that include a regression test are merged quickly while new features without proper tests are least likely to receive timely feedback. The workflow to make a merge request is as follows:

1. Fork the project on GitLab Cloud
1. Create a feature branch
1. Write tests and code
1. Add your changes to the [CHANGELOG](CHANGELOG)
1. If you have multiple commits please combine them into one commit by [squashing them](http://git-scm.com/book/en/Git-Tools-Rewriting-History#Squashing-Commits)
1. Push the commit to your fork
1. Submit a merge request (MR)
1. The MR title should describes the change you want to make
1. The MR description should give a motive for your change and the method you used to achieve it
1. If the MR changes the UI it should include before and after screenshots
1. Link relevant [issues](https://gitlab.com/gitlab-org/gitlab-ci/issues) and/or [feedback items](http://feedback.gitlab.com/) from the merge request description and leave a comment on them with a link back to the MR
1. Be prepared to answer questions and incorporate feedback even if requests for this arrive weeks or months after your MR submittion

Please keep the change in a single MR as small as possible. If you want to contribute a large feature think very hard what the minimum viable change is. Can you split functionality? Can you only submit the backend/API code? Can you start with a very simple UI? The smaller a MR is the more likely it is it will be merged, after that you can send more MR's to enhance it.

We will accept merge requests if:

* The code has proper tests and all tests pass (or it is a test exposing a failure in existing code)
* It can be merged without problems (if not please use: `git rebase master`)
* It does not break any existing functionality
* It's quality code that conforms to the [Ruby](https://github.com/bbatsov/ruby-style-guide) and [Rails](https://github.com/bbatsov/rails-style-guide) style guides and best practices
* It is not a catch all merge request but rather fixes a specific issue or implements a specific feature
* It keeps the GitLab code base clean and well structured
* We think other users will benefit from the same functionality
* It is a single commit (please use `git rebase -i` to squash commits)

repository: mfittko/gitlab-ci

repo_name: mfittko/gitlab-ci


text:
# d-cent prototype

## Getting Started

###Local setup
To start the development VM you will need to install
- Vagrant + Virtualbox (see https://www.vagrantup.com/downloads.html, https://www.virtualbox.org/wiki/Downloads)
- Ansible (see http://docs.ansible.com/intro_installation.html)

```git clone git@github.com:ThoughtWorksInc/objective8.git
cd objective8/ops/```

### Working on the VM
####To get started:

```vagrant up
# type 'vagrant' when asked for a sudoers password
vagrant ssh
cd /var/objective8
lein ragtime migrate```

####Running the tests

```lein midje```

####Running the app

######Build sass using:
```./pre-push.sh```

######Running the app with a fake twitter (used for Sign-in)
```lein repl
(reset :stub-twitter)```

###### Running the app with your own twitter app credentials
create a task (for example ```start_with_twitter_credentials.sh```with the following content:
```
TWITTER_CONSUMER_TOKEN=<obtain this from twitter when registering the application to allow sign-in via twitter> \
TWITTER_CONSUMER_SECRET_TOKEN=<as above> \
BASE_URI=<either localhost or VM ip address and :APP_PORT> \
APP_PORT= <> \
DB_PORT= <> \
lein repl $*
```
then run the task and start the app using:
```(reset :default)```

##Deployment

To deploy, you need to set some environment variables:
```
export APP_PORT=<port on which the applicaton will be served, defaults to 8080>
export BASE_URI=<the base uri at which the application is served, including the port, defaults to 'localhost:8080'>
export TWITTER_CONSUMER_TOKEN=<obtain this from twitter when registering the application to allow sign-in via twitter>
export TWITTER_CONSUMER_SECRET_TOKEN=<as above>
```
## Docker

With root privileges:
```
docker build -t objective8 .
docker run -it -p 8080:8080 --rm --name objective8-live objective8
```


text:
# A JSON-over-UDP example in Rust

## Setup

Install Rust and netcat

## Usage

Open the terminal and type:

    cargo run

Then in another terminal type:

    echo -n '{"recipient":"lauri","content":"foo"}' | nc -u <IP_ADDRESS> 34254 # nc is netcat

After entering the above JSON string, press `enter`. That will send the JSON
over the wire to our example program. Our example program will reply to you in
JSON.

## License

MIT


text:
# react-native-braintree

A react native interface for integrating payments using [Braintree's v.zero SDK](https://developers.braintreepayments.com/start/overview).
![Accepts Credit/Debit Cards](/Screenshots/vzero.png)

## Sample
Full Client + Server sample can be found here:
[https://github.com/alawong/BTRNSample](https://github.com/alawong/BTRNSample)

## Usage

### Setup
```js
var BTClient = require('react-native-braintree');
BTClient.setup(<token>);
```
You can find a demo client token [here](https://developers.braintreepayments.com/start/hello-client/ios/v3).

### Show Payment Screen
v.zero
```js
BTClient.showPaymentViewController().then(function(nonce) {
  //payment succeeded, pass nonce to server
})
.catch(function(err) {
  //error handling
});
```

PayPal only
```js
BTClient.showPayPalViewController().then(function(nonce) {
  //payment succeeded, pass nonce to server
})
.catch(function(err) {
  //error handling
});
```

## Custom Integration
If you only want to tokenize credit card information, you can use the following:
```js
BTClient.getCardNonce("4111111111111111", "10", "20").then(function(nonce) {
  //payment succeeded, pass nonce to server
})
.catch(function(err) {
  //error handling
});
```

### One Touch
To take advantage of [One Touch](https://developers.braintreepayments.com/guides/one-touch/overview/ios/v3), there are additional setup required:

1. Register a URL scheme in Xcode (should always start with your Bundle ID)
  ![Register URL Scheme](/Screenshots/urlscheme.png)

2. Use setupWithURLScheme instead, passing the url scheme you have registered in previous step
  ```js
  var BTClient = require('react-native-braintree');
  BTClient.setupWithURLScheme(<token>, <url scheme>);
  ```

3. Add this delegate method (callback) to your AppDelegate.m
  ```objc
  #import <RNBraintree.h>

  - (BOOL)application:(UIApplication *)application openURL:(NSURL *)url sourceApplication:(NSString *)sourceApplication annotation:(id)annotation {
    return [[RNBraintree sharedInstance] application:application openURL:url sourceApplication:sourceApplication annotation:annotation];
  }
  ```

4. Optionally, install the [fake PayPal wallet app](https://github.com/braintree/fake-wallet-app-ios) in your simulator to simulate and test responses

## Installation
1. `react-native init BTRNSample` (skip for existing projects)
2. Run `npm install react-native-braintree --save` to add the package
3. Inside the ``ios/`` directory, create a Podfile:

  ```ruby
  # Podfile for cocoapods 1.0
  source 'https://github.com/CocoaPods/Specs.git'
  target 'yourAppTarget' do
    pod 'React', :path => '../node_modules/react-native', :subspecs => [
      'Core',
      'RCTImage',
      'RCTNetwork',
      'RCTText',
      'RCTWebSocket'
    ]
    pod 'react-native-braintree', :path => '../node_modules/react-native-braintree'
  end
  ```

  Or if you use an older CocoaPods version:
  ```ruby
  source 'https://github.com/CocoaPods/Specs.git'
  pod 'React', :path => '../node_modules/react-native', :subspecs => [
    'Core',
    'RCTImage',
    'RCTNetwork',
    'RCTText',
    'RCTWebSocket'
  ]
  pod 'react-native-braintree', :path => '../node_modules/react-native-braintree'
  ```

4. Run `pod install`.  This installs the Braintree iOS SDK and a new workspace is created.

5. Open `BTRNSample.xcworkspace`

6. Under your app target -> build settings, look for `Other Linker Flags` and add `$(inherited)`

  ![Accepts Credit/Debit Cards](/Screenshots/linker.png)

7. Build and run project!  If it fails the first time, clean and rebuild.

Because React Native's iOS code is now pulled in via CocoaPods, you also need to remove the ``React``, ``RCTImage``, etc. subprojects from your app's Xcode project.

![Remove Libraries](/Screenshots/removeLibraries.png)

## Requirements

Tested with:
* Node 4.1.0
* npm 2.14.3
* react-native 0.8.0

## License

react-native-braintree is available under the MIT license. See the LICENSE file for more info.

repository: alanhhwong/react-native-braintree

gha_language: Objective-C

repo_name: alanhhwong/react-native-braintree


text:
# QueryTopicRouteTable {#reference_n4w_fjd_xdb .reference}

Call this operation to query the target topics that subscribe to a specified source topic. This process is known as querying the route table for the specified source topic. The operation is only used to query user topics.

## Request Parameters {#section_atq_ln5_xdb .section}

|Parameter|Type|Required|Description|
|:--------|:---|:-------|:----------|
|Action|String|Yes|The operation that you want to perform. Set the value to QueryTopicRouteTable.|
|Topic|String|Yes|The source topic, which publishes messages.|
|Common Request Parameters|-|Yes|See [Common parameters](intl.en-US/Developer Guide (Cloud)/API reference/Common parameters.md#).|

## Response parameters {#section_rsm_sn5_xdb .section}

|Parameter|Type|Description|
|:--------|:---|:----------|
|RequestId|String|The globally unique ID generated by Alibaba Cloud for the request.|
|Success|Boolean|Indicates whether the call is successful. A value of true indicates that the call is successful. A value of false indicates that the call has failed.|
|ErrorMessage|String|The error message returned when the call fails.|
|Code|String|The error code returned when the call fails. For more information about error codes, see [Error codes](intl.en-US/Developer Guide (Cloud)/API reference/Error codes.md#).|
|DstTopics|List|The list of target topics returned when the call is successful.|

## Examples {#section_y2t_yn5_xdb .section}

**Request example**

```
https://iot.cn-shanghai.aliyuncs.com/?Action=QueryTopicRouteTable
&Topic=%2Fx7aWKW94bb8%2FtestDataToDataHub%2Fupdate
&Public Request Parameters
```

**Response example**

```
{
    "RequestId":"FCC27691-9151-4B93-9622-9C90F30542EC",
    "Success":true,
    "DstTopics":["/CXi4***/device2/get","/CXi4***/device3/get"]
}
```

repository: WangJieJason/iot

path: /intl.en-US/Developer Guide (Cloud)/API reference/Manage Topics/QueryTopicRouteTable.md

repo_name: WangJieJason/iot


text:
# Jokes service
> Daily jokes for IOS

### Dependencies
* [Python 3.6](https://www.python.org/)
* [bottlepy](https://bottlepy.org/docs/dev/)

To connect to the database, you must pass the path to the settings file to the PropertyReader class.
To do this, specify the parameter db "path" when starting the service.

Sample file:
```ini
host=localhost
database=jokes
user=user
password=pass
```

Example run service:
```python
python JokesServer.py -db "path"
```

repository: bisirkin-pv/jokes

repo_name: bisirkin-pv/jokes


text:
# DiffConfig
`DiffConfig` represents a reusable set of configuration variables that allow a user to easily setup instances of `DiffMapper` and `DiffLinker`. The configuration variables represent the shared information between both projects. `DiffConfig` includes a method of parsing Command Line Interface (CLI) arguments to setup a config options. `DiffConfig` also includes the ability to setup a config object by passing in a JSON file. The format of the json file is specified below.

## Purpose
When performing differencing of L-SAP results, it becomes clear that there are several shared pieces of data between the `DiffMapper` and `DiffLinker` projects. This means that we would be potentially having to specify the same settings twice, which could lead to errors if they are not setup to be the same. The `DiffConfig` object intends to package the shared settings together and provide meaningful defaults so users only have to specify the settings they want to change.

## Overview
`DiffConfig` uses the [builder pattern](https://en.wikipedia.org/wiki/Builder_pattern) to construct a `DiffConfig` object. This allows the user to specify the changes to the configuration they want and leave all other settings default. Further, a user can clone an existing `DiffConfig` object and override only one or two settings, making the construction of `DiffConfig` objects very flexible.  `DiffConfig` supports the following options:

- `old_tag`: The name of the tag representing the base version of the Linux Kernel to start tracking differences (e.g. `"v3.18-rc1"`)
- `new_tag`: The name of the tag representing the target version of the Linux Kernel to end tracking differences (e.g. `"v3.19-rc1"`)
- `diff_test_dir`: The directory where the instance maps from [InstanceTracker](InstanceTracker.md) are stored and the final output is generated
- `kernel_dir`: The directory where the Linux Kernel source code lives.
- `result_dir`: The directory where L-SAP results are stored.
- `types`: An array of the types that should be tracked for differencing (currently not supported)[^1]

## Usage
As stated earlier `DiffConfig`'s can be built through a number of options. `DiffConfig` is available for use through an API and does not include a standalone jar, but instead is packaged within other projects. For example, see [DiffMapper](DiffMapper.md) for an overview on how `DiffConfig` is used within it.

### API
The `DiffConfig` API is as follows:

#### Builders
`DiffConfig` objects are not constructed, but rather built by first getting a `builder` object. There are several options for specifying a starting point for the builder. All builders must then call the `build()` to return the constructed `DiffConfig` object.

##### Default
Method: `DiffConfig.builder()`

Usage:
```Java
DiffConfig config = DiffConfig.builder().build();
```

Description:

Construct a `DiffConfig` object with default options. The following options are used by default:
- `old_tag`: `"v3.17-rc1"`
- `new_tag`: `"v3.18-rc1"`
- `diff_test_dir`: `"./diffmap/"` (where `.` is the current working directory)
- `kernel_dir`: `"./kernel/"` (where `.` is the current working directory)
- `result_dir`: `"./diffmap/prev_result/"` (where `.` is the current working directory)
- `types`: `["mutex", "spin"]`

##### From an existing builder
Method: `DiffConfig.builder(DiffConfigBuilder base)`

Usage:
```Java
DiffConfigBuilder baseBuilder = DiffConfig.builder();
DiffConfig base = builder.build();
DiffConfig changed = DiffConfig.builder(baseBuilder).setOldTag("v3.5").build();
```

Description:

Construct a `DiffConfig` object using the config options from a previous builder as a base.

##### From an file
Method: `DiffConfig.builder(String fileName)`

Usage:
```Java
DiffConfig config = DiffConfig.builder("config.json").build();
```

Description:

Constructs a `DiffConfig` object using the options specified in a JSON file. An example `config.json` file is provided:
```json
{
  "old_tag": "v3.17-rc1",
  "new_tag": "v3.18-rc1",
  "diff_test_dir": "diffmap/",
  "kernel_dir": "kernel/",
  "result_dir": "diffmap/prev_result/",
  "types": [
    "mutex",
    "spin"
  ]
}
```

##### From command line
Method: `DiffConfig.builder(String[] args)`

Usage:
```Java
public static void main(String[] args) {
  DiffConfig config = DiffConfig.builder(args).build();
  // Use config object
  ...
}
```

Description:

Constructs a `DiffConfig` object using the options provided from the command line. In this mode, there are command line options for specifying a file, or specifying individual settings. The following help method will be printed when the `-h` flag is used:
```
usage: java -jar <jarfile> [OPTIONS]
 -c,--config-file <file>   The JSON configuration file to use
 -D <property=value>       use value for given property
 -h,--help                 Display this help menu
 -n,--dry-run              See a summary of what the DiffMapper will do.
                           No action will be performed.
```
The `-D` flag allow for individual settings to be specified. They use the format `-D <property=value>`, where `property` is the key for the setting you want to change (see the `config.json` example above for key names).
> Note: Command Line options using the -D flag will override options from a config file if one is specified using the -c flag.

#### Setting your own options
After a builder has been constructed, you can chain one or more setters to specify an individual setting before calling the `build()` method. The same setter can appear multiple times, but only the value from the last time a setter was called will used.

##### Set Old Tag
Method: `setOldTag(String old_tag)`

Usage:
```Java
DiffConfig config = DiffConfig.builder().setOldTag("v4.13").build();
```

Description:

Set the `DiffConfig`'s old tag setting.

##### Set New Tag
Method: `setNewTag(String new_tag)`

Usage:
```Java
DiffConfig config = DiffConfig.builder().setNewTag("v4.15").build();
```

Description:

Set the `DiffConfig`'s new tag setting.

##### Set Diff Test Directory
Method: `setDiffTestDir(String diff_test_dir)`

Usage:
```Java
DiffConfig config = DiffConfig.builder().setDiffTestDir("/new/path/").build();
```

Description:

Set the `DiffConfig`'s diff test directory setting.

##### Set Kernel Directory
Method: `setKernelDir(String kernel_dir)`

Usage:
```Java
DiffConfig config = DiffConfig.builder().setKernelDir("/path/to/kernel/").build();
```

Description:

Set the `DiffConfig`'s kernel directory setting.

##### Set Result Directory
Method: `setResultDir(String result_dir)`

Usage:
```Java
DiffConfig config = DiffConfig.builder().setResultDir("/path/to/result/").build();
```

Description:

Set the `DiffConfig`'s result directory setting.

##### Set Types
Method: `setTypes(String[] types)`

Usage:
```Java
DiffConfig config = DiffConfig.builder().setTypes(new String[] {"mutex"}).build();
```

Description:

Set the `DiffConfig`'s types setting.

##### Example
```Java
DiffConfig config = DiffConfig.builder()
    .setOldTag("v4.13")
    .setNewTag("v4.15")
    .setDiffTestDir("/new/path/")
    .setKernelDir("/path/to/kernel/")
    .setResultDir("/path/to/result/")
    .setTypes(new String[] {"mutex"})
    .build();
```

[^1]: This will be supported in an upcoming update

repository: kcsl/lsap-frontend

repo_name: kcsl/lsap-frontend


text:
<!---
Group:general
Name:G10 Find parents for a given concept
Author:Patrick Ryan
CDM Version: 5.3
-->

# G10: Find parents for a given concept

This query accepts a concept ID as the input and returns all concepts that are its immediate parents of that concept. Parents are concepts that have a hierarchical relationship to the given concepts. Hierarchical relationships are defined in the relationship table.
The query returns only the immediate parent concepts that are directly linked to the input concept and not all ancestors.

## Query
```sql
SELECT
  a.concept_id       AS parent_concept_id,
  a.concept_name     AS parent_concept_name,
  a.concept_code     AS parent_concept_code,
  a.concept_class_id AS parent_concept_class_id,
  a.vocabulary_id    AS parent_concept_vocab_id
FROM @vocab.concept_ancestor ca
  JOIN @vocab.concept a ON ca.ancestor_concept_id = a.concept_id
  JOIN @vocab.concept d ON ca.descendant_concept_id = d.concept_id
WHERE
  ca.min_levels_of_separation = 1 AND
  ca.descendant_concept_id = 192671 AND
  a.invalid_reason IS NULL
;
```
## Input

|  Parameter |  Example |  Mandatory |  Notes |
| --- | --- | --- | --- |
|  Concept ID |  192671 |  Yes | Gastrointestinal hemorrhage |

## Output

|  Field |  Description |
| --- | --- |
|  Parent_Concept_ID |  Concept ID of parent concept |
|  Parent_Concept_Name |  Name of parent concept |
|  Parent_Concept_Code |  Concept Code of parent concept |
|  Parent_Concept_Class |  Concept Class of parent concept |
|  Parent_Concept_Vocab_ID |  Vocabulary parent concept is derived from as vocabulary code |

## Example output record

|  Field |  Value |
| --- | --- |
|  Parent_Concept_ID |  4000610 |
|  Parent_Concept_Name |  Disease of gastrointestinal tract |
|  Parent_Concept_Code |  119292006 |
|  Parent_Concept_Class |  Clinical finding |
|  Parent_Concept_Vocab_ID |  SNOMED |

## Documentation
https://github.com/OHDSI/CommonDataModel/wiki/CONCEPT_ANCESTOR

repository: IulianD/QueryLibrary

repo_name: IulianD/QueryLibrary


text:
# Cogol

[![Go Reportcard](https://goreportcard.com/badge/github.com/kyeeego/cogol)](https://goreportcard.com/report/github.com/kyeeego/cogol)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Release](https://img.shields.io/github/release/kyeeego/cogol.svg)](https://github.com/kyeeego/cogol/releases/latest)
[![Build](https://github.com/kyeeego/cogol/actions/workflows/cogol.yml/badge.svg)](https://github.com/kyeeego/cogol/actions/workflows/cogol.yml/badge.svg)

![Cogol](./assets/cogol-logo.png)

# Why Cogol?

Cogol is a beautiful, easy-configurable tool for writing unit-tests in ```Go``` programming language.

# Getting started

Install ```Cogol``` by running

```bash
$ go get github.com/kyeeego/cogol
```

Next, create typical ```*_test.go``` file and copy and paste the following code inside it.

```go
package test

import (
	"github.com/kyeeego/cogol"
	"testing"
)

func TestSomething(t *testing.T) {
	cgl := cogol.Init(t)

	g := cgl.Group("test")
	{
		g.T("Adds two numbers", func(c *cogol.Context) {
			c.Expect(2 + 2).ToBe(4)
		})
	}

	cgl.Process()
}
```

Run it with
```bash
$ go test
```

and get the following output

![Cogol test results](./assets/cogol-result.png)

**You successfully wrote your first test with Cogol!**

# Documentation

* [Getting started](./examples/getting_started)
* [Assertions](./examples/assertions)
* [Storage](./examples/storage)
* [Logger](./examples/logger)
* [Achieving best performance](./examples/performance)

repository: kyeeego/cogol

repo_name: kyeeego/cogol


text:
# Continuous Integration
Fairwinds Insights can do more than just scan and audit a live Kubernetes Cluster. It can also
help you spot issues _before_ they make it into production.

By adding Fairwinds Insights into your Continuous Integration process, you can catch image
vulnerabilities and Kubernetes misconfigurations early in the development process. Insights
can scan changes the changes in each pull request, notifying developers or breaking the build
whenever security, efficiency, or reliability issues are found.

# Setup
To get started, visit your organization's **Repositories** tab, and click **Add Repo**

<img :src="$withBase('/img/add-repo.png')" alt="Adding a repository">

Following the instructions there, add a `fairwinds-insights.yaml` configuration to the base
of your repository. Here's a minimal example:

> Be sure to replace `acme-co` with your organization's name in Insights.
```yaml
options:
  setExitCode: true
  organization: acme-co

images:
  docker:
  - nginx:1.18-alpine
  - quay.io/acme-co/my-app:$CI_HASH

manifests:
  yaml:
  - ./deploy/mainfests/
  - ./main.deployment.yaml
  helm:
  - name: prod
    path: ./deploy/chart
    values:
      foo: bar
```

Next, you'll need to add the `FAIRWINDS_TOKEN` environment variable to your CI environment. This
token can be found in the CI instructions in Insights, or on your organization's settings page. Note that
most CI platforms provide a way to specify secrets in your environment variables.

Last, you'll need to execute the Insights CI script within your CI pipeline.
You may want to download, inspect, and store a copy of the script in your repository.
```
curl https://insights.fairwinds.com/static/insights-ci.sh | bash
```

Your repository will show up in the Insights UI once that script has been successfully run.

## fairwinds-insights.yaml
Here's a full list of options available in fairwinds-insights.yaml:

### Options
These are high-level options for the Insights CI integration.
* `options.organization` - the name of your organization in Insights
* `options.setExitCode` - set a non-zero exit code if issues are found. Default `false`
* `options.baseBranch` - the branch to compare results to. Default `master`
* `options.newActionItemThreshold` - the maximum number of new action items that can appear for a passing test. Default `0`
* `options.severityThreshold` - if _any_ action item hits this threshold, the test will fail. Default `danger`
* `options.junitOutput` - if specified, Insights will print JUnit XML results here
* `options.repositoryName` - the name of the repository. Must match the name in GitHub if using the GitHub integration. Defaults to the output of `git remote -v`
* `options.tempFolder` - a temporary directory to store files in. Default `./_insightsTemp/`
* `options.hostname` - the host of the Insights instance to send results to. Default `https://insights.fairwinds.com`

### Images
Specify any images you'd like Insights to scan for vulnerabilities. These images must be available
locally in your CI environment, either through running `docker build` or `docker pull`.

* `images.docker` - an array of image names and tags to scan
* `images.folder` - path to a folder containing exported docker images as .tgz files.

Note that you can include environment variables in your image names and tags. This is helpful
if you set your image tag based on things like the current Git branch, tag, or commit SHA.

### Manifests
Specify any YAML or Helm manifests you'd like Insights to scan for configuration issues.
Helm files can be templated using a variables file, or by specifying variables directly
in your fairwinds-insights.yaml

* `manifests.yaml` - an array of directories or files containing Kubernetes YAML manifests to scan
* `manifests.helm` - an array of helm charts to template and scan
* `manifests.helm[].name` - a name to give this templated chart
* `manifests.helm[].path` - the path to the directory containing `Chart.yaml`
* `manifests.helm[].values` - values to pass to the chart when templating
* `manifests.helm[].valuesFile` - a YAML file containing values to pass to the chart when templating

## Connect to GitHub
> You can still use the Continuous Integration feature without GitHub.
>
> Using Gitlab, Bitbucket, or another Git host? Let us know!

Connecting Insights to your GitHub repository will help you get the most out of the CI integration.
To get started, click the **Install Now** link on your organization's repositories tab.

Then, in the GitHub UI, choose which repositories you'd like to link to Insights:
<img :src="$withBase('/img/github-add-repo.png')" alt="Add repo in GitHub">

Once your repository is linked, you'll start seeing a Fairwinds Insights status on each of your
pull requests.
<img :src="$withBase('/img/github-status.png')" alt="Check GitHub status">

We recommend setting `options.setExitCode: false` in your fairwinds-insights.yaml, since
this check will now fail in place of your CI pipeline.

## Viewing the Results
The **Repositories** tab will show you a list of all repositories that have been connected to Insights.
Next to each repo, you can see the number of `danger` and `warning` items currently found in the main
branch.
<img :src="$withBase('/img/repos-list.png')" alt="List of all repos">

When you click on a particular repository, the first thing you'll see is a list of action items
affecting the main branch.
<img :src="$withBase('/img/repo-main-branch.png')" alt="Action items for the main branch">

Below that, you'll see a section for each branch, along with a list of action items that have
been created or fixed in that branch.

For example, here's a branch that creates some security issues in `passing.yaml`:
<img :src="$withBase('/img/repo-failing-branch.png')" alt="Action items for a failing branch">

And here's a branch that fixes some security issues in `failing.yaml`:
<img :src="$withBase('/img/repo-passing-branch.png')" alt="Fixed action items for a passing branch">


text:
# 138. Copy List with Random Pointer

Difficulty: Medium

https://leetcode.com/problems/copy-list-with-random-pointer/

A linked list is given such that each node contains an additional random pointer which could point to any node in the list or null.

Return a deep copy of the list.

The Linked List is represented in the input/output as a list of n nodes. Each node is represented as a pair of [val, random_index] where:

* val: an integer representing Node.val
* random_index: the index of the node (range from 0 to n-1) where random pointer points to, or null if it does not point to any node.

**Example 1:**
![ex1](e1.png)
```
Input: head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
Output: [[7,null],[13,0],[11,4],[10,2],[1,0]]
```

**Example 2:**
![ex2](e2.png)
```
Input: head = [[1,1],[2,1]]
Output: [[1,1],[2,1]]
```

**Example 3:**
![ex3](e3.png)
```
Input: head = [[3,null],[3,0],[3,null]]
Output: [[3,null],[3,0],[3,null]]
```

**Example 4:**
```
Input: head = []
Output: []
Explanation: Given linked list is empty (null pointer), so return null.
```

**Constraints:**

* -10000 <= Node.val <= 10000
* Node.random is null or pointing to a node in the linked list.
* Number of Nodes will not exceed 1000.

url: https://raw.githubusercontent.com/jiadaizhao/LeetCode/4ddea0a532fe7c5d053ffbd6870174ec99fc2d60/0101-0200/0138-Copy List with Random Pointer/README.md

repository: jiadaizhao/LeetCode

repo_name: jiadaizhao/LeetCode


text:
# Exercise - Speech Service Environment Setup

For you to be successful in completing the exercises for this module, you must have the proper resources in place on Azure. The following steps outline creating an Azure subscription, or using a trial key.  Creating the Speech Service resources on Azure is required for the exercises to work successfully for synthesizing text to speech.  Complete this section before moving on to the remaining exercises.

## Create an azure speech resource

You will require an Azure subscription in order to complete this exercise.  With the Azure subscription, you can create the necessary Speech Service resource. If you do not have an Azure subscription, [create one here](https://azure.microsoft.com/free).

### Using an azure subscription

1. Sign in to the [Azure portal](https://portal.azure.com?azure-portal=true).

1. Select **+ Create a resource**. In the **Search the Marketplace** box, type **speech** and press Enter.

1. In the **Results** list, select **Speech**. In the **Speech** pane, select **Create**.
1. Enter a unique name for your Speech Service resource.
1. Select an appropriate subscription.
1. Choose a location to host the resource.  This is typically the region where the resource will be used.
1. For **Pricing tier**, select a tier.  The tiers may change but currently, you can select F0 or S0.  For testing, we selected F0.
1. Create a new resource group (RG) named **mslearn-speechapi** to hold your resources.  You can also choose an existing RG if you wish
1. Select **Create** to create a subscription to the Speech Translation API.

After a short delay, your new Speech Translation API subscription will be available, and new API keys will be generated for programmatic use.

> [!TIP]
> If you miss the notification that your resource is published, select the notification icon in the top bar of the portal, and then select **Go to resource**, as shown in the following figure:

   ![Selecting "Go to resource" from the notification icon](media/3-subscribe-speech-translation-go-resource.png)

### View the subscription keys and endpoint

To access your Speech Service from an application, you will need to get two pieces of information from the Azure portal:

- A *subscription key* that's passed with every request to authenticate the call.
- The *endpoint* that exposes your service on the network.

You will need the subscription key when using the Speech SDK or the REST APIs but the endpoint will only be required for the REST API access.   Using the Speech SDK in an application uses the key, but also requires a region.  You will see the use of the key and region information in the exercise later in the module.

1. In the left menu of the portal, select **Resource groups**, and then select the **mslearn-speechapi** resource group that you created for the Speech Translation API.
1. Select the Speech Translation subscription name (such as **SpeechTranslation**).
1. There are two locations that will display your endpoint and at least one key.
1. Under the **RESOURCE MANAGEMENT** group, select the **Quick start** option to display **Key1** and **Endpoint** values.
1. The second option is used to view a second key for the service. Under the **RESOURCE MANAGEMENT** group, select **Keys and Endpoint** to view the Service name, the endpoint, and two API keys.
1. Copy the value of **KEY 1** or **KEY 2** to the clipboard for use in an application.

branch_name: refs/heads/main


text:
Due to my current work at [Google Summer of Code 2010](https://wiki.duraspace.org/display/GSOC/GSOC10+-+Add+Unit+Testing+to+Dspace) I've been setting up a small CI system for my personal use. Yes, it is an overkill, but I wanted to test it and, truth be told, the statistics provided by tools like [Sonar](http://www.sonarsource.org/) and [Hudson](http://hudson-ci.org/) are priceless, they show you many potential errors you may have in the code, coverage you are missing... to express it in my native tongue: "és la óstia nen"

I asked my friend Google for a guide on how to set them up together and it came up with this one. Easy five steps to set them up (check the link for more detail):

* **Step 1**: Download, install and start the Sonar Server.
* **Step 2**: Install and Configure Sonar plugin on Hudson.
  Easy. Simple. Powerful. And useful!

I recommend you to use the following Sonar plugins:

+ [Eclipse Plugin][1]
+ [Tag List Plugin][2]
+ [Total Quality Plugin][3]
+ [SCM Activity Plugin][4]
+ [Sonar PDF Plugin][5]
+ [Motion Chart Plugin][6]
+ [Build Breaker][7]

With them you will get some extra data in your reports, you will be able to access them from your IDE (more useful for developers) and the builds will generate a handy pdf report for your project manager. Many benefits for a few customizations. You don't even need to change the default settings for any standard project.

  [1]: http://docs.codehaus.org/display/SONAR/Installing+Sonar+in+Eclipse
  [2]: http://docs.codehaus.org/display/SONAR/Taglist+Plugin
  [3]: http://docs.codehaus.org/display/SONAR/Total+Quality+Plugin
  [4]: http://docs.codehaus.org/display/SONAR/SCM+Activity+Plugin
  [5]: http://docs.codehaus.org/display/SONAR/Sonar+PDF+Plugin
  [6]: http://docs.codehaus.org/display/SONAR/Motion+Chart+plugin
  [7]: http://docs.codehaus.org/display/SONAR/Build+Breaker+Plugin

repository: pvillega/personal-page

repo_name: pvillega/personal-page


text:
User Mangement Commands
-----------------------

A set of commands can be run from the command line in order to manage
local users in the system.  If arguments are missing then the command
will prompt for the values.

- **salt:org:add**

  This command will create an organization in the database.

  `./core/bin/console salt:org:add [--no-interaction] [<organization name>]`

- **salt:user:add**

  This command will create a local user in the database.

  `./core/bin/console salt:user:add [--no-interaction] [--password=<password>] [--role=<role>] [<username>]`

- **salt:user:add-role**

  This command will add a role to a local user in the database.

  `./core/bin/console salt:user:add-role [<username>] [<role>]`

- **salt:user:remove-role**

  This command will remove a role from a local user in the database.

  `./core/bin/console salt:user:remove-role [<username>] [<role>]`

- **salt:user:set-password**

  This command will set the password for a local user in the database.
  If a password is not provided then one will be generated.

  `./core/bin/console salt:user:set-password [<username>] [<password>]`

repository: opensalt/opensalt

branch_name: refs/heads/develop

gha_language: PHP

repo_name: opensalt/opensalt