text:
# Migrate from 1.18 to 1.19

## Istio

Kyma 1.19 comes with a new Istio version: 1.8.2. See what changes in the [official Istio upgrade notes](https://istio.io/latest/news/releases/1.8.x/announcing-1.8/).

Ensure Istio sidecars for all Pods are in the proper version after the upgrade. See the [troubleshooting guide](https://kyma-project.io/docs/master/components/service-mesh#troubleshooting-incompatible-istio-sidecar-version-after-kyma-upgrade) for more information.

repository: sayanh/kyma

gha_language: Go

repo_name: sayanh/kyma


text:
# An implementation of Quick Sort

[Run Tests](https://ryanbard.github.io/javascript-coding-katas/algorithms/sorting/quicksort/quicksort.html)

This is an implementation of [Quick Sort](https://en.wikipedia.org/wiki/Quicksort) written in ES5 javascript.

license: MIT

repository: RyanBard/javascript-coding-katas

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: RyanBard/javascript-coding-katas


text:
## Examples

examples/tf

### EgoGraph based GNNs examples
For EgoGraph based GNNs, we provide three algorithm examples, ego_sage, ego_gat, ego_bipartite_sage.
- **ego_sage**: homogeneous graph sage, two training examples are provided for supervised node classification and unsupervised i2i recommendation.
- **ego_gat**:homogeneous gat, provides supervised node classification examples.
- **ego_bipartite_sage**: bipartite graph sage, provides training examples for unsupervised u2i recommendation.

The implementation of EgoGraph based GNN generally just needs to compose different `EgoLayers` with different `EgoConv` and then pass them to `EgoGNN`.The construction of the whole model is similar to building blocks, and the difference between different models is mainly the difference of `EgoConv`.  Let's take `EgoGraphSAGE` as an example to illustrate.

#### EgoGraphSAGE

```python
class EgoGraphSAGE(tfg.EgoGNN):
  def __init__(self,
               dims,
               agg_type="mean",
               bn_func=None,
               act_func=tf.nn.relu,
               dropout=0.0,
               **kwargs):
    """ EgoGraph based GraphSAGE.

    Args:
      dims: An integer list, in which two adjacent elements stand for the
        input and output dimensions of the corresponding EgoLayer. The length
        of `dims` is not less than 2. If len(`dims`) > 2, hidden layers will
        be constructed.
        e.g. `dims = [128, 256, 256, 64]`, means the input dimension is 128 and
        the output dimension is 64. Meanwhile, 2 hidden layers with dimension
        256 will be added between the input and output layer.
      agg_type: A string, aggregation strategy. The optional values are
        'mean', 'sum', 'max' and 'gcn'.
    """
    assert len(dims) > 2

    layers = []
    for i in range(len(dims) - 1):
      conv = tfg.EgoSAGEConv("homo_" + str(i),
                             in_dim=dims[i],
                             out_dim=dims[i + 1],
                             agg_type=agg_type)
      # If the len(dims) = K, it means that (K-1) LEVEL layers will be added. At
      # each LEVEL, computation will be performed for each two adjacent hops,
      # such as (nodes, hop1), (hop1, hop2) ... . We have (K-1-i) such pairs at
      # LEVEL i. In a homogeneous graph, they will share model parameters.
      layer = tfg.EgoLayer([conv] * (len(dims) - 1 - i))
      layers.append(layer)

    super(EgoGraphSAGE, self).__init__(layers, bn_func, act_func, dropout)
```

We use `EgoSAGEConv` to compose `EgoLayer` and then pass it to `EgoGNN` to quickly build an `EgoGraphSAGE`.

### SubGraph based GNNs(experimental)
For SubGraph based GNNs, we provide two algorithm examples, sage and seal.Both examples start from edge traversal, perform 1-hop full neighbor sampling and negative sampling, and then use reduce_func to obtain SubGraph. SubGraph currently only supports homogeneous graphs.

- **sage**: GraphSAGE, uses BCE loss. uses default reduce_func
- **seal**: SEAL algorithm for link prediction, using a custom induce_func for node labeling.

See nn/tf/model for the model implementation part of SubGraph.

### Distributed example
In order to facilitate the writing of the distributed training process, we have simply wrapped the distributed training process as `DistTrainer`

#### DistTrainer
[examples/tf/trainer.py](../../../../examples/tf/trainer.py)

```python
class DistTrainer(object):
  """Class for distributed training and evaluation

  Args:
    cluster_spec: TensorFlow ClusterSpec.
    job_name: name of this worker.
    task_index: index of this worker.
    worker_count: The number of TensorFlow worker.
    ckpt_dir: checkpoint dir.
  """
  def __init__(self,
               cluster_spec,
               job_name,
               task_index,
               worker_count,
               ckpt_dir=None)

  # The model definitions must all be placed under the context of DistTrainer
  def context(self)

  # Training process, training epochs times, will print the training speed and the corresponding loss, at the end of training all workers will
  # Use our implementation of SyncBarrierHook to do a synchronous wait.
  def train(self, iterator, loss, learning_rate, epochs=10, **kwargs)

  # The above interface is provided to the worker node of tensorflow, the ps node just needs to execute join
  def join(self)
```
In `DistTrainer` we have simply wrapped a few common functions, you can extend or add new functions to control your own training process.

**Note:**
**TensorFlow distinguishes between ps and worker roles, GraphLearn distinguishes between client and server, the examples we provide are in GraphLearn's server mode.
That is, client and server are distinguished, and generally tf's ps and GraphLearn's server are deployed in the same process, and tf's worker and GraphLearn's client are deployed in the same process.
Therefore, when executing GraphLearn's graph.init, you need to distinguish between different machine roles.**

**DistTrainer provides context interface, model related definitions need to be put under context, in order to place variables to ps automatically. Except the join function, all other functions are provided to worker, please pay attention to the correct use when calling.**

repository: alibaba/graph-learn

repo_name: alibaba/graph-learn


text:
Colden
======

[![Travis](https://img.shields.io/travis/cgm616/compression/master.svg)](https://travis-ci.org/cgm616/compression)
[![License](https://img.shields.io/badge/license-mit-blue.svg)](https://github.com/cgm616/compression/blob/master/LICENSE)

Colden is a compression application that uses a Huffman tree to make files
smaller, losslessly.

Detailed guide
--------------

There are two steps before the application can open: compilation and execution.
After Colden is open, see directions below for use

### Compiling Colden ###

To compile Colden, navigate to the source directory and run

```
> javac *.java
```

This will compile every java file in the directory into class files, allowing
them to be run.

### Running Colden ###

Once you've compiled the source, run Colden by executing

```
> java Main
```

in the source directory. This will open Colden's main window.

### Using Colden ###

After Colden is open, you will be greeted two tabs, "Compress" and "Expand,"
corresponding to the action you want to take.

For compression, navigate to the "Compress" tab by clicking on it. Click the
"Choose file" button next to "Input," which will open a dialog to choose a file.
Select any individual file from the filesystem. Next, click the "Choose file"
button next to "Output." This will open a save dialog, allowing you to select a
new file to be created once Colden is run. After both the input and output file
locations are selected, click "Run Colden" to compress the input file and save
it to the output location. The logs and any errors from the operation will
appear in the text box.

For expansion, navigate to the "Expand" tab and follow the same instructions as
the "Compress" tab. This time, however, instead of compressing the input file,
Colden will expand a compressed file given to it. Note, however, that Colden
only works with files made by Colden. It cannot expand compression formats other
than its own.

During both expansion and compression, select the checkbox next to "Save Huffman
Tree Graph" to output a pdf file displaying the Huffman tree used during program
operation. To set where the file is saved, click the button "Choose file" under
the checkbox. Note that in order for output to work, the `dot` command (part of
graphviz) must be installed and in the path.

To clear any selected file, click the "Clear" button next to that file's path.

Resources
---------

We used the following resources:

 - The javadocs at https://docs.oracle.com/javase/7/docs
 - https://docs.oracle.com/javafx/2/events/handlers.htm
 - https://en.wikipedia.org/wiki/Huffman_coding
 - https://docs.oracle.com/javase/8/javafx/user-interface-tutorial
 - https://en.wikipedia.org/wiki/Tree_traversal#Pre-order_(NLR)
 - https://stackoverflow.com/questions/4439595/how-to-create-a-sub-array-from-another-array-in-java
 - https://stackoverflow.com/questions/1494492/graphviz-how-to-go-from-dot-to-a-graph
 - https://stackoverflow.com/questions/14958346/dot-dash-in-name
 - https://stackoverflow.com/questions/1806870/how-to-add-edge-labels-in-graphviz
 - https://stackoverflow.com/questions/27228972/how-to-get-java-profiling-dump-for-creating-flame-graphs-on-the-mac
 - https://github.com/brendangregg/FlameGraph
 - https://stackoverflow.com/questions/33112560/why-is-a-thread-blocking-my-javafx-ui-thread
 - https://stackoverflow.com/questions/40300089/how-to-catch-the-task-exception-in-java-fx-application

gha_language: Java

gha_license_id: MIT


text:
Tunnel v1.0

      A new automated script for ngrok

## 🔍 ***About Tunnel***:

Tunnel is a bash based script which is made for ngrok users of termux from this tool in just one click you can do lot more. This tool works on both rooted Android device and Non-rooted Android device.

[![Build Status](https://img.shields.io/github/stars/noob-hackers/m-wiz.svg)](https://github.com/noob-hackers/tunnel)
[![Build Status](https://img.shields.io/github/forks/noob-hackers/m-wiz.svg)](https://github.com/noob-hackers/tunnel)
[![License: MIT](https://img.shields.io/github/license/noob-hackers/m-wiz.svg)](https://github.com/noob-hackers/tunnel)
[![Rawsec's CyberSecurity Inventory](https://inventory.rawsec.ml/img/badges/Rawsec-inventoried-FF5050_flat.svg)](https://inventory.rawsec.ml/tools.html#tunnel)
[![Stage](https://img.shields.io/badge/Release-Stable-brightgreen.svg)]()
[![Awesome](https://awesome.re/badge.svg)](https://awesome.re)

![www noob-hackers com](https://user-images.githubusercontent.com/49580304/79551648-91b2b500-80b7-11ea-8b29-8951bdc2052e.jpg)

### 📌 ***Tunnel is available for***:

* Termux

### 📌 ***Installation and usage guide***:
```
$ apt-get update -y
```
```
$ apt-get upgrade -y
```
```
$ pkg install python -y
```
```
$ pkg install python2 -y
```
```
$ pkg install git -y
```
```
$ pip install lolcat
```
```
$ git clone https://github.com/noob-hackers/tunnel
```
```
$ ls
```
```
$ cd tunnel
```
```
$ ls
```
```
$ bash tunnel.sh
```

* Now you need internet connection to continue further process...

* You can select any option by clicking on your keyboard

* Note:- Don't delete any of the scripts included in core files

# 🛡 ***More***:

__Install Ngrok__ :
- From this option you can install Ngrok in termux application without any issue in just one click and the installation can take time upto 10 minutes If Your internet is slow.

__Add to Boot__ :
- From this option you can set ngrok to boot screen of termux and it starts every time when you start new session and to esit from it
click 0 in keboard.

__Move to Script__ :
- From this option you can move this ngrok file to any other script after that you dont need to on hotspot to use ngrok.

__Start Ngrok__ :
- From this option you can start ngrok tunnel by just typing desired 4 digit port.

__Start Hoster__ :
- From this option you can use your custom scripts to run on localhost or over wan and this option creates php session.

__Update script__ :
- From this option you can update tunnel tool if updates are available for that.

__About__ :
- From this option you can read about author.

__Exit__ :
- From this option you can exit from tunnel tool.

## 📌 ***Screenshot*** :

## 📌 ***Full video tutorial***:
[![m-wiz metasploit-franework tool](https://img.youtube.com/vi/8RXVODXMsa8/0.jpg)](https://youtu.be/8RXVODXMsa8)
## 🔗 ***Check this***

### Subscribe our channel on youtube:
https://www.youtube.com/channel/UCV9qe5io3OCZ8vHMu4gnQZQ

### Chekout our webite:
https://hackershub.abhi6722.in

## 👥 ***Join***

### Telegram channel:
https://t.me/officialhackershub

### Facebook page:
https://m.facebook.com/Hackers-Hub-103249834703018/?ref=bookmarks

### Instagram:
https://www.instagram.com/official_hackershub

### Pinterest:
https://in.pinterest.com/abhinav6722cool/

### My GitHub ID link:
https://www.github.com/Abhi6722

### 📢 Warning

***This tool is only for educational purpose. If you use this tool for other purposes except education we will not be responsible in such cases.***


text:
## 424. Longest Repeating Character Replacement
You are given a string s and an integer k. You can choose any character of the string and change it to any other uppercase English character. You can perform this operation at most k times.

Return the length of the longest substring containing the same letter you can get after performing the above operations.

can we summarize the number of maximal existing characters in any substring?

1 <= s.length <= 105
s consists of only uppercase English letters.
0 <= k <= s.length

26...can use some prefix sum for the 26 upper case letters? n^2 seems not acceptable.

How about binary search the length of the answer. still summarize the number of each letter's count as a prefix sum.

If the length is too long => we cannot find any replacement under the k! let try it! (use i,j's maximal count and other words's number)

Holy! AC!

Let me see the std' answer it's an easy slides window..

it's clear that we can move the left to satisfy the k's condition.

Actually, we are enumerating the left points, and move the start to fit in the condition that the maxlength for the start points - maxcount < k. If not, we will move the start.


text:
# cms
Content Management System. This time done right.

## Getting started

1. Clone the repo (default branch is `develop`):
```
git clone https://github.com/stuyspec/cms
```
2. Enter the repo:
```
cd cms
```
3. Install the node packages used in this project with **N**ode **P**ackage **M**anager:
```
npm install
```
4. Build and begin a live reload server on `http://localhost:8080`:
```
gulp
```

## Running the app

To set up the development data server, follow the instructions on our the README of our [API](https://github.com/stuyspec/stuy-spec-api).

## Admin Level

To be an **admin** in the database is to have a `security_level` of greater than 0 (there are only 0 and 1 currently). Only admins can POST, PATCH, and DELETE. Any user can GET. Since every user at creation is given a `security_level` of 0, developers must use `rails console` to change the `security_level` of any user.

The [Rails console](http://guides.rubyonrails.org/command_line.html#rails-console) lets you interact with the Rails API from the command line with Ruby. For instance:
```
> u = User.find_by(first_name: 'Jason')
> u.update(security_level: 1)
```

Accessing `rails console` in a locally hosted API is trivial, but to use it with our production database requires more [instruction](https://github.com/stuyspec/stuy-spec-api#using-elastic-beanstalk).

repository: stuyspec/old-cms

repo_name: stuyspec/old-cms


text:
-   [New haskell-lang.org](https://haskell-lang.org/announcements)

    > This website is aimed at providing modern best practices information for the Haskell programming language, and in particular with providing the best possible new user experience.

-   [Corrode: Automatic semantics-preserving translation from C to Rust](https://github.com/jameysharp/corrode)

    > This program reads a C source file and prints an equivalent module in Rust syntax.

-   [Dive into GHC: Intermediate Forms](https://www.stephendiehl.com/posts/ghc_02.html)

    > This time let's zoom into the pieces that comprise the front end of the compilation pipeline.

-   [Rethinking GHC's approach to managing proposals](https://ghc.haskell.org/trac/ghc/blog/rethinking-proposals)

    > The resulting proposal is strongly inspired by the RFC process in place in the Rust community, the leaders of which have thought quite hard about fostering community growth and participation.

-   [Good way to convert between ad-hoc polymorphic functions and parametric polymorphic ones](https://stackoverflow.com/questions/38326420/good-way-to-convert-between-ad-hoc-polymorphic-functions-and-parametric-polymorp)

    > What are the general techniques for converting between ad-hoc polymorphic functions and parametric ones?

repository: haskellweekly/haskellweekly

branch_name: refs/heads/haskellweekly

extension: markdown

gha_language: Haskell

repo_name: haskellweekly/haskellweekly


repository: djquan/exercism

repo_name: djquan/exercism


text:
# deep-rl
Code snippets from Deep RL Hands-On (2nd edition) book by Maxim Lapan.
Original source code can be found [here](https://github.com/PacktPublishing/Deep-Reinforcement-Learning-Hands-On-Second-Edition).

repository: mohantyk/deep-rl

repo_name: mohantyk/deep-rl


text:
# gomu

gomu is a "reflect" based Go helper package that unpacks slice into map.

[![Go.Dev reference](https://img.shields.io/badge/go.dev-reference-blue?logo=go&logoColor=white)](https://pkg.go.dev/github.com/rosmak/gomu)

## Installation

With a [correctly configured](https://golang.org/doc/install#testing) Go toolchain:

```sh
go get -u github.com/rosmak/gomu
```

## Use case

If we want our rest-api response to be in format:

```json
{
  "uniqueID": {
    "Obj1":{}
  },
  "uniqueID": {
    "Obj2": {}
  }
}
```
Instead of

```go
[
  Obj1,
  Obj2
]
```
## Example

Let's imagine a situation where we have a User who can have multiple Phone Numbers and those Phone Numbers can be connected to multiple Social Media Accounts. So our models would look something like this:

```go
type User struct {
    ID              uuid             `json:"id"`
    Name            string           `json:"name"`
    PhoneNumbers    []PhoneNumber    `json:"phone_numbers"`
}

type PhoneNumber struct {
    ID              uuid             `json:"id"`
    Number          string           `json:"number"`
    Accounts        []Account        `json:"accounts"`
}

type Account struct {
    ID              uuid             `json:"id"`
    Platform        string           `json:"platform"`
}
```

When we are done with our db queries, and and populate all connections we get slices
If we want to turn those slices into maps we need to add our map placeholder field to struct like this:

```go
type User struct {
    ID              uuid               `json:"id"`
    Name            string             `json:"name"`
    PhoneNumbers    []PhoneNumber      `json:"phone_numbers"`
    //important part is to add gomu thag that specify
    //name of field which values would be used
    //this line will say to gomu that "PhoneNumber"
    //values will be used for "PhoneNumberMap" field
    PhoneNumbersMap map[string]Account `json:"phone_num_map" gomu:"PhoneNumbers"`
}

type PhoneNumber struct {
    ID              uuid               `json:"id"`
    Number          string             `json:"number"`
    Accounts        []Account          `json:"accounts"`
    //same here
    AccountMap      map[string]Account `json:"account_map" gomu:"Accounts"`
}

```

To get those map values populated

If we have one user from db, just supply user to gomu function like this:

```go
func main() {
    user := User{}
    err := gomu.MapAll(&user, nil)
    if err != nil {
        //handle error
    }
    //user.PhoneNumbersMap and PhoneNumber.AccountsMap are populated with walues
    //note that user.PhoneNumbers is set to nil, same for PhoneNumber.Accounts
}

```

If we have slice users from db, just supply users to gomu function like this:

```go
func main() {
    users := []User{}
    err := gomu.MapAll(&users, nil)
    if err != nil {
        //handle error
    }
    //fields are populated
}

```

In previous case all field are populated but we are still left with slice of users
To get map of users we add our second argument to function like this:
```go
func main() {
    users := []User{}
    usersMap := make(map[string]User)
    err := gomu.MapAll(&users, &usersMap)
    if err != nil {
        //handle error
    }
    //fields are populated
}

```

## IMPORTANT NOTICE

For now key of map is "ID" field of a struct, so in order to work your struct need to have ID field.
Additionally "ID" type needs to implement Stringer interface, so it could be converted to string.
For only string keys are supported.

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

repository: rosmak/gomu

branch_name: refs/heads/main

repo_name: rosmak/gomu


text:
# rust-bcc

Idiomatic Rust bindings for the BPF compiler collection. The goal is to mimic the
Python BCC bindings in https://github.com/iovisor/bcc in a Rusty way.

The C bcc API (as exposed in `bcc-sys`) is very powerful, but it's fairly nontrivial to try to use
it by itself and manage all the resources it allocates safely.

This crate is currently experimental and has several things in it which are either unsafe or not
particularly idiomatic for Rust. Pull requests very much appreciated.

## Prerequisites

* bcc v0.4.0-v0.23.0

## Static linking

This crate allows for statically linking libbpf/libbcc which enables the creation of tools which
have no runtime dependency on matching versions being present on target systems. To statically link,
you may need to compile several dependencies from source. See the `build/ci.sh` script for how those
dependencies are built and how we build and run statically linked examples in CI.

## Getting Started

The best way to learn about how to use this crate right now is to read the examples. The exciting
thing about these examples is that the Rust version isn't really more verbose than the Python
version. In some ways the Rust code is more legible because it's much more natural to work with C
data structure in Rust than it is in Python.

### Building

This library uses features to allow support for multiple versions of bcc. Depending on what version
of bcc you have installed, you may need to use a feature flag while building the examples in-order
to match the expected version of bcc with the version you have installed on your system.

### Examples

* [examples/strlen.rs](https://github.com/rust-bpf/rust-bcc/blob/master/examples/strlen.rs) uses a BPF hashmap to count frequencies of every string that `strlen` is run on. Port of [strlen_count.py](https://github.com/iovisor/bcc/blob/master/examples/tracing/strlen_count.py) to Rust.
* [examples/opensnoop.rs](https://github.com/rust-bpf/rust-bcc/blob/master/examples/opensnoop.rs) uses perf events to track every time a file is opened on the system. Port of [opensnoop.py](https://github.com/iovisor/bcc/blob/master/tools/opensnoop.py) to Rust.
* [examples/softirq.rs](https://github.com/rust-bpf/rust-bcc/blob/master/examples/softirqs.rs) uses
  kernel tracepoints to report time spent in softirq handlers. Port of [softirqs.py](https://github.com/iovisor/bcc/blob/master/tools/softirqs.py) to Rust.

repository: rust-bpf/rust-bcc

gha_language: Rust

repo_name: rust-bpf/rust-bcc


text:
THIS DOCKER IMAGE IS NO LONGER MAINTAINED
=========================================

Consider using: https://hub.docker.com/r/brucepc/mapguide/

mapguide-base
=============

Docker base image that bundles the latest stable release of [MapGuide Open Source](http://mapguide.osgeo.org)

Included in this image:

 - [MapGuide Open Source](http://mapguide.osgeo.org) 2.6.0
 - [FDO](http://fdo.osgeo.org) 3.9.0
 - Apache httpd 2.4.9
 - PHP 5.5.11
 - [msttcorefonts](http://corefonts.sourceforge.net/)

Use this image as the base of your own MapGuide images.

Usage
-----

Create a Dockerfile that creates an image that is based on this image

	FROM jumpinjackie/mapguide-base
	# Install additional packages, load your MapGuide applications and data, etc.
	#
	EXPOSE 8008
	CMD ["/usr/bin/supervisord"]

Build the docker image

	docker build -t my/mapguide-app .

repository: vickoman/mapguide-centos-docker

repo_name: vickoman/mapguide-centos-docker


text:
# DnsClient.NET
DnsClient.NET is a simple to use, extensible .NET DNS client which targets netstandard1.3 or higher and .Net 4.5.

## Build

[![Build status](https://ci.appveyor.com/api/projects/status/y1nlxim8tkv7w3f4?svg=true)](https://ci.appveyor.com/project/MichaCo/dnsclient-net)

### Download it via NuGet
Package: https://www.nuget.org/packages/DnsClient/

Get beta builds from [MyGet](https://www.myget.org/feed/dnsclient/package/nuget/DnsClient).

## Features
#### General
* Full Async API
* UDP and TCP lookup, configurable if TCP should be used as fallback in case UDP result is truncated (default=true).
* Caching
  * Query result cache based on provided TTL
  * Minimum TTL setting to overrule the result's TTL and always cache the responses for at least that time. (Even verly low value, like a few milliseconds, do make a huge difference if used in high traffic low latency scenarios)
  * Cache can be disabled alltogether
* Supports mulitple dns endpoints to be configured.
* Retry logic in case of timeouts and errors (configurable)
* Audit trail of each response

#### Supported resource records
* PTR for reverse lookups
* A, AAAA, NS, CNAME, SOA, MB, MG, MR, WKS, HINFO, MINFO, MX, RP, TXT, AFSDB, SRV, URI, CAA
* OPT (currently only for reading the supported UDP buffer size, EDNS version)

## Usage examples:
### Simple usage
The following example instantiates a new `LookupClient` without specifying a DNS endpoint.
DnsClient.NET will query the system's network adapters to determine available DNS servers.

``` csharp

var lookup = new LookupClient();
var result = await lookup.QueryAsync("google.com", QueryType.ANY);

var record = result.Answers.ARecords().FirstOrDefault();
var address = record?.Address;

```

### Specify other DNS servers
To explicitly specify a DNS server, there are some overloads:

Create a client using a DNS server on localhost with the default port (53)

``` csharp
var result = new LookupClient(IPAddress.Parse("<IP_ADDRESS>"));
```

Create a client using a DNS server on port 5000:

``` csharp
var endpoint = new IPEndPoint(IPAddress.Parse("<IP_ADDRESS>"), 5000);
var result = new LookupClient(endpoint);
```

### Audit Trail
If enabled, the lookup client adds an audit trail to each result, `result.AuditTrail`. This is a simple text field log information, which can be pretty useful for debugging etc...

```csharp
var lookup = new LookupClient();
lookup.EnableAuditTrail = true;
var result = await lookup.QueryAsync("google.com", QueryType.ANY);
```

The result.AuditTrail will have some value like this now:

```
; (3 server found)
;; Got answer:
;; ->>HEADER<<- opcode: Query, status: No Error, id: 27205
;; flags: qr rd ra; QUERY: 1, ANSWER: 11, AUTORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
google.com.                             IN      ANY

;; ANSWER SECTION:
google.com.                     160     IN      A       <IP_ADDRESS>
google.com.                     152     IN      AAAA    2a00:1450:4016:805::200e
google.com.                     398     IN      MX      30 alt2.aspmx.l.google.com.
google.com.                     398     IN      MX      10 aspmx.l.google.com.
google.com.                     398     IN      MX      40 alt3.aspmx.l.google.com.
google.com.                     398     IN      MX      20 alt1.aspmx.l.google.com.
google.com.                     398     IN      MX      50 alt4.aspmx.l.google.com.
google.com.                     329150  IN      NS      ns1.google.com.
google.com.                     329150  IN      NS      ns4.google.com.
google.com.                     329150  IN      NS      ns2.google.com.
google.com.                     329150  IN      NS      ns3.google.com.

;; Query time: 68 msec
;; SERVER: <IP_ADDRESS>#53
;; WHEN: Sat, 01 Dec 2016 15:10:47 GMT
;; MSG SIZE  rcvd: 263
```

## Examples

The [Samples](https://github.com/MichaCo/DnsClient.NET.Samples) repository will have some solutions to showcase the usage and also to test some functionality.

Also, under [samples](https://github.com/MichaCo/DnsClient.NET/tree/dev/samples) in this repository, there is a great console application which kind of works like the well known "dig".
It doesn't have all the features of course but quite many...

To run it, open a command line windows, navigate to \Samples\MiniDig and run `dotnet run`.

`dotnet run -?` gives you the list of options and commands.

`dotnet run google.com ANY` to query for google.com

If nothing else is specified, it uses the DNS server configured for your local network adapter.
To specify a different server, use the `-s` switch, for example:

`dotnet run -s <IP_ADDRESS> google.com` to use the public google name server.

## Milestones
### 1.1 release
* More testing
* More RRs parsing

## Motivation and Thanks!
I used [Heijden.Dns](https://github.com/ghuntley/Heijden.Dns) as a baseline for my first steps into the world of DNS RFCs. A big thanks to the original author of the code, Alphons van der Heijden and also Geoffrey Huntley who created a great package out of that. This was a great resource to learn from it and start building this API!

In the end, I decided to write my own API to make it easy to use, more robust, extensible and build on dotnet core for xplat support.


text:
# Purging on Akamai
This is using the CCU API.

Get your Account manager to set up the proper API permissions.
## Sample usage:
purge-akamai http://your-full-url/

repository: shalomc/globaldots-purging

repo_name: shalomc/globaldots-purging


text:
# TO-DO-app

## Author : Saleem Diab

## LAB 31 - Context API

## Description :

* ### one way of using global states in React by using context API. that done by creating, providing, wrapping, and consumming the context.

* ### useForm is a custom hook that contains a function that will be called when you click on the submit button, and will handle onSumbit and onchange functions.

##  TO-DO App Phase 1:

### In Phase 1, we’re going to perform some refactoring of the To Do application as built by another team. This application mixes application state and user settings at the top level and passes things around. It was a good proof of concept, but we need to make this production ready.

1. adding a global state by context-API
2. adding a pagination.
3. adding style from BluePrint UI.

## Links and Resources:

* ### [code sand box /Phase 1](https://codesandbox.io/s/agitated-lamport-8xyty)

* ### [lab 31 pull request ](https://github.com/saleem-ux/todo-app/pull/2)

## UML :

![img](./images/lab31.png)

## LAB 32 - Context API - Behaviors

##  TO-DO App Phase 2:

### Description : this phase was refactoring and editing on TO DO App by :

1. converting all class components to functional ones.
2. adding settings to edit and control the context.
3. save the selection to local storage.
4. using React Browser Route

## Links and Resources:

* ### [code sand box /Phase 2](https://codesandbox.io/s/hardcore-goldstine-rucc5)

* ### [lab 32 pull request ](https://github.com/saleem-ux/todo-app/pull/3))

## UML :

![img](./images/lab32.png)

##  TO-DO App Phase 3:

### Description : this phase was refactoring and editing on TO DO App by :

1. As a user, I want to provide a way for other users to create new accounts
2. As a user, I want to provide a way for all users to login to their account
3. As a user, I want to make sure that my To Do items are only viewable to users that have logged in with a valid account.
4. As a user, I want to ensure that only fellow users that are allowed to “create”, based on their user type, can add new To Do Items
5. As a user, I want to ensure that only fellow users that are allowed to “update”, based on their user type, can mark To Do Items complete
6. a user, I want to ensure that only fellow users that are allowed to “delete”, based on their user type, can delete new To Do Items

## Links and Resources:

* ### [code sand box /Phase 3](https://codesandbox.io/s/crazy-tree-edp9d)

* ### [lab 32 pull request ](https://github.com/saleem-ux/todo-app/pull/4)

## UML :

![img](./images/lab33.png)

repository: saleem-ux/todo-app

gha_language: JavaScript

repo_name: saleem-ux/todo-app


text:
# ESP Domotics
Domotics with an esp8266

## Table of Contents
1. [Connect](#connect-to-the-esp8266)
2. [Flash firmware](#flash-firmware)
3. [Communication](#communicate-to-the-esp)
4. [Test](#test-nodemcu)
5. [Upload scripts](#upload-scripts)

## Connect to the esp8266
find usb serial device with `lsusb`. Bus 004 Device 010: ID 067b:2303 Prolific Technology, Inc. PL2303 Serial Port
```
sudo modprobe usbserial vendor=0x067b product=0x2303
```

Connect esp to USB to serial
```
VCC -> 3.3v
GND -> GND
Rx -> Tx
Tx -> Rx
```
For flasing mode connect also
```
GPIO0 -> GND
CH_PD -> 3.3v
```

You should now see that it is now showing as attached by running `dmesg`.
```
[11357.143838] usbserial: USB Serial support registered for pl2303
[11357.143891] pl2303 4-1.2:1.0: pl2303 converter detected
[11357.146034] usb 4-1.2: pl2303 converter now attached to ttyUSB0
```

## Flash firmware
https://nodemcu.readthedocs.io/en/release/getting-started/

Build the nodemcu firmware with site or with docker image
```
git clone --recurse-submodules https://github.com/nodemcu/nodemcu-firmware.git
```

Change the modules in `nodemcu-firmware/app/include/user_modules.h`
Enable `bme280, bme280_math, file, GPIO, I2C, mqtt, net, node, ow, tmr, uart, wifi`. Build the firmware
```
cd nodemcu-firmware
docker run --rm -ti -v `pwd`:/opt/nodemcu-firmware marcelstoer/nodemcu-build build
```

install flash tooling
```
sudo pip3 install esptool
```

flash firmware
```
sudo python3 -m esptool --trace --port /dev/ttyUSB0 --baud 115200 write_flash 0x00000 nodemcu-firmware/bin/nodemcu_float_release_20210105-1953.bin
```

### Problems
when problems with flashing, try connecting, this works when your esp device keeps listening to serial and isn't ready to receive new firmware.
```
GPIO 0 -> GND
RST -> 3.3v
```
try format, remove extra wires and monitor with gtkterm
```
sudo python3 -m esptool erase_flash
```

## Communicate to the ESP
using gtkterm for serial communication
```
sudo gtkterm --port /dev/ttyUSB0 --speed 115200
```

## Test NodeMCU
write hello world or something to test it.
```
file.format()
file.open("init.lua", "w")
file.writeline([[print("init lua node")]])
file.close()

node.restart()
```
## Upload scripts
install tool to upload files to the esp
```
npm install nodemcu-tool -g
```

upload the script to the esp
```
nodemcu-tool upload --port=/dev/ttyUSB0 init.lua
```

after uploading restart the esp. Connect with serial terminal and execute the command
```
node.restart()
```

scripts that use wifi import a credentials.lue. This contains the SSID and password
## Secrets in lua scripts
```
-- Network Credentials
ssid=<insert SSID>
pass=<insert password>
```

repository: mrlauy/esp-domotics

repo_name: mrlauy/esp-domotics


text:
# **Tasky**

The purpose of the application is to manage daily activities, such as daily tasks.

## **Home**
On this page, you can get an overview of the days and their progress.

![HomeScreenShot](https://github.com/GianniMoretti/Tasky/blob/master/AssetREEDME/HomeScreenShot.png)

## **Day**
This page is dedicated to tasks of a single day, on this page the user can overview his tasks and can modify them by using the buttons situated on the right menu.

![DayScreenShot](https://github.com/GianniMoretti/Tasky/blob/master/AssetREEDME/DayScreenShot.png)

## **List**
The list page shows the user description of each task created. This page also allows adjustments to each task just like the Day page.

![ListViewScreenShot](https://github.com/GianniMoretti/Tasky/blob/master/AssetREEDME/ListViewScreenShot.png)

## **Modify**
This page allows the user to edit task settings. The user can change Name, priority, date and description.

![ModifyScreenShot](https://github.com/GianniMoretti/Tasky/blob/master/AssetREEDME/ModifyScreenShot.png)

repository: GianniMoretti/Tasky

repo_name: GianniMoretti/Tasky


text:
# Assimp as Swift Package and CocoaPod

The umbrella header contains both import and export features so takes some time to compile.
A prebuilt binary xcframework (for iOS & Catalyst only) is wrapped as swift package, and works in XCode 12 Beta only.
This approach is experimental and has some issues with code signing.

https://github.com/assimp/assimp

### CocoaPods
```
  pod 'Assimp',  :git => 'https://github.com/ndreca/Assimp.git'
```

### SwiftPackage
```
  .package(name: "Assimp", url: "https://github.com/ndreca/Assimp.git", from: "5.0.2"),
```


text:
# OMP Database Schema

The OMP backend currently is built on a mongodb backend. It consists of five collections: `users`,`customers`, `clusters`, `residencies`, and `groups`. You can see the schemas of these collections below:

* db.users

```
{
    _id: <ObjectId>,
    user_name:  <string>,
    first_name: <string>,
    last_name: <string>,
    expiration_date: <date>,
    email: <string>,
    identity_providers: {
        idm: {
            name: <string>,
            created: <bool>,
            notified: <bool>,
        },
        atlassian: {
            ....
            repetition of above object
            for each identity provider
            that a user assigned to
            ....
        }
    },
    tags: [<string>]
}
```

* db.customers

```
{
    _id: <ObjectId>,
    customer_name: <string>,
    tags: [<string>]
}
```

* db.clusters

```
{
    _id: <ObjectId>,
    logging: <bool>,
    metrics: <bool>,
    size: <string>,
    ha: <bool>,
    ocp_version: <string>,
    hosting_platform: <string>,
    tags: [<string>]
}
```

* db.residencies

```
{
    _id: <ObjectId>,
    start_date: <date>,
    end_date: <date>,
    cluster_ref: <string>,
    source_control: <string>,
    tags: [<string>],
    name: <string>
}
```

* db.groups

```
{
    _id: <ObjectId>,
    group_name: <string>,
    display_name: <string>,
    tags: [<string>]
}
```

repository: bvkin/omp-data-api

repo_name: bvkin/omp-data-api


text:
# Ansible domain-setup role

Will create a branch new domain on a Windows Server. This role is just a
basic bare bones roles to create the domain. No hardening or secure practices
are really included here.

## Requirements

N/A

## Variables

### Mandatory Variables

* `domain_setup__network_name`: The name of the Windows network interface that the domain will set itself as the primary DNS server.
* `domain_setup__domain_name`: The FQDN of the domain to create
* `domain_setup__safe_mode_password`: The password to set as the safe mode admin password when creating the domain
* `domain_setup__username`: A domain account name to create that is a member of the `Domain Admins` group
* `domain_setup__password`: The password for `domain_setup__username`

## Examples

```
- name: create domain controller for the domain domain.local
  hosts: all
  vars:
    domain_setup__network_name: Ethernet
    domain_setup__domain_name: domain.local
    domain_setup__safe_mode_password: Password01
    domain_setup__username: domain-user
    domain_setup__password: Password01
```

repository: ekmixon/ansible-windows

repo_name: ekmixon/ansible-windows


text:
---
comments: true
aliases:
    - my-simple-serverless-journey-part2
slug: My-simple-serverless-journey-part2
title: "The Downside of going serverless"
subtitle: "The making of simpleIP.de - Part 2"
date: 2021-10-27
tags:
    [
        simpleip,
        serverless,
        cloud,
        vercel,
        cloudflare,
        cloudflareworkers,
        ipaddress,
        php
    ]
cover:
    image: /images/2021/2021-10-27_SimpleIP.de.update.png
---

After creating [SimpleIP.de](https://simpleip.de) as a serverless application (see my blog post [My simple serverless journey was not that easy](/en/2021/05/02/My-simple-serverless-journey/)) I was kinda proud. Interesting technology, small and useful website. Nice.

## Reality

But after a while reality kicked in. I was playing around with some IPv6 systems, when it hit me. With the previous design, the site would show only the _primary_ IP-Address of the client. If the client supports both IPv6 **and** IPv4, it would still only show one IP-Address.

I tried a bit around. Eventhough Cloudflare allows DNS Host A (IPv4) and AAAA (IPv6) entries, it wouldn't work as I wanted. Cloudflare needs to proxy the DNS entries, to make Cloudflarer Workers work. And even if you only add one IP Version, it would still proxy for both Internet Protocol versions. So the reality of serverless is: **You only have very limited control over the server that hosts your application.** For some scenarios that might be okay, for others not.

## My Workaround

I wouldn't really call this a fix, just a hacky workaround. I created a subdomain `alt.simpleip.de` that points to a Shared Webhost Account at [Netcup](https://netcup.de). In my Netcup Customer Control Panel, I added two Subdomains (or rather Sub-Subdomains):

-   `v4.alt.simpleip.de`
-   `v6.alt.simpleip.de`

I then added "Let's Encrypt" TLS certificates and put a [small PHP-Script](https://github.com/diecknet/simple-ip-site/blob/8a50cbe079227c6972c3d6b80cc7b5a07c0bfc4e/alt.simpleip.de/index.php) on the server. The script outputs the IP-Address of the client using

```php
print $_SERVER['REMOTE_ADDR'];
```

The trick is, that `v4.alt.simpleip.de` only has a Host A Record - so it only works for IPv4 clients. And `v6.alt.simpleip.de` only has a Host AAAA Record - so it only works for IPv6 clients. Initially I wanted to use `ipv4.alt.simpleip.de` and `ipv6.alt.simpleip.de`, but apparently a bug in the Netcup Plesk Control Panel prevented that 🤔. Weird.

Anyway my API is running. Next step was to add some JavaScript code to the website. The code tries to connect to both of these hostnames. If there is a result, it'll get added to the site. I left the old Cloudflare based approach still in the site. So when a client requests the page, the new program flow is as follows:

1. Cloudflare Workers injects the Client-IP-Address into the HTML and delivers the site (No Client-JS needed).
2. When the HTML Body loads **and** Client-JS is enabled:
    - Client based JavaScript call to **IPv4** endpoint
    - Client based JavaScript call to **IPv6** endpoint

## Conclusion

So it's still _kinda_ serverless, since I don't administer the Webserver at Netcup 😇. It's a Shared Webhost package. When going serverless, there are several obstacles, but there's mostlikely a Workaround. For my use case, I still prefer these workarounds instead of administering a full server.

repository: diecknet/diecknet-blog

gha_language: HTML

repo_name: diecknet/diecknet-blog


text:
# Facebook Messenger for WordPress
[Created with love in Poland by RapidDev](http://rapiddev.pl/)<br />
Facebook Messenger live chat on your website! Very easy to use plugin that adds chat on your WordPress site. It supports language change and is integrated with PolyLang. In addition, you can change the position and display of the chatbox

![Presentation image](https://rapiddev.pl/uploads/2017/12/rd_messenger_for_wordpress.jpg)

### [Download the latest version (1.3.5)](https://github.com/RapidDTC/rd_messenger/releases/1.3.5)

## What does this plugin do?
It makes it easy for you to add a Facebook Messenger live chat to your WordPress site

## How it's working?
All options, description and configuration are available in the Customizer

## What options are available?
- [x] Api ID
- [x] Page ID
- [x] Minimizing chat
- [x] Webhooks
- [x] The ability to change the chat language
- [x] The ability to change the chat position on the site
- [x] The option to disable chat for the mobile version
- [x] Integration with PolyLang

## How to install it?
Method using FTP
1. Upload `social-messenger` folder to the `/wp-content/plugins/` directory
2. Activate the plugin through the 'Plugins' menu in WordPress
3. Add your APP ID and Facebook page ID in Customizer

Method using Plugins Manager
1. Go to Dashboard > Plugins > Add new
2. Select the option to upload to the server
3. Choose the file social_messenger.zip

## Available full language versions
- [x] English
- [x] Polish

## Update history
#### 1.3.5
1. Bug fixes
#### 1.3.4
1. Bug fixes
#### 1.3.3
1. Bug fixes
2. Translations have been improved
3. Change slug and name of the plugin
#### 1.3.2
1. Bug fixes
2. Translations have been improved
#### 1.3.1
1. Bug fixes
2. The way of displaying the options has been changed
#### 1.3.0
1. A new Customizer class has been added
2. Added support for PolyLang
3. The ability to change the live chat language has been added
4. The ability to hide chat on phones has been added
5. The ability to change the chat position live has been added
#### 1.2.0
1. Bug fixes
2. Addition of new translations
#### 1.1.0
1. Bug fixes
#### 1.0.0
1. The plugin was created

repository: NeuralNoise/social-messenger

repo_name: NeuralNoise/social-messenger


text:
# Approach 3: Count Cores
## Intuition
The final sum will be a sum of powers of 2, as every core (a substring (), with score 1) will have it's score multiplied by 2 for each exterior set of parentheses that contains that core.

## Algorithm
Keep track of the balance of the string, as defined in Approach #1. For every ) that immediately follows a (, the answer is 1 << balance, as balance is the number of exterior set of parentheses that contains this core.

## Complexity Analysis
- Time Complexity: O(N)O(N), where NN is the length of S.
- Space Complexity: O(1)O(1).


text:
node-stream-stack
=================
### Filter low-level `Stream` instances into stackable, protocol-based streams.

This module exposes the `StreamStack` interface, which starts off as a node
`Stream` subclass that accepts a "parent" Stream to work with. `StreamStack` is
meant to be subclassed in order to implement the layers of a protocol, or run the
parent Stream's data through some kind of filter (i.e. compression).

By default, a `StreamStack` instance proxies all events downstream (from the
parent stream to the child stream), and proxies all functions calls upstream
(from the child stream to the parent stream).

Keeping the `StreamStack` subclass' implementation independent of the parent
`Stream` instance allows for the backend transport to be easily swapped out
for flexibility and code re-use. For example, storing `netcat` results to a file,
and using `fs.ReadStream` as your parent stream, rather than `net.Stream`, in your
test cases.

Since `StreamStack` inherits from the regular node `Stream`, all it's prototypal
goodies can be used along with your subclass instances. This makes it extremely
easy for you to call `Stream#pipe(writable)`, in order to utilize node's data
transfer philosophies.

A Simple Example
----------------

Here's a simple, kinda silly example:

``` js
var util = require('util');
var StreamStack = require('stream-stack').StreamStack;

// The first argument is the parent stream
function DoubleWrite(stream) {
  StreamStack.call(this, stream);
}
util.inherits(DoubleWrite, StreamStack);

// Overwrite the default `write()` function to call
// write() on the parent stream twice!
DoubleWrite.prototype.write = function(data) {
  this.stream.write(data);
  this.stream.write(data);
}

// How to Use:
var doubleStdout = new DoubleWrite(process.stdout);
doubleStdout.write("this will be printed twice!\n");
```

We've defined a `DoubleWrite` class. It accepts a writable stream, and
whenever `write()` is called on the DoubleWrite instance, then in return
`write()` get called _twice_ on the parent stream. In this example, our
writable stream, `process.stdout`, will get the string printed to it twice.

Known Subclasses
----------------

Check out the [Wiki][] page to see the list of [Known Subclasses][Wiki].

[Wiki]: https://github.com/TooTallNate/node-stream-stack/wiki


text:
### Stock Market

This program “plays” the stock market. You will be given $10,000 and may buy or sell stocks. Stock prices and trends are generated randomly; therefore, this model does not represent exactly what happens on the exchange. (Depending upon your point of view, you may feel this is quite a good representation!)

Every trading day, a table of stocks, their prices, and number of shares in your portfolio is printed. Following this, the initials of each stock are printed followed by a question mark. You indicate your transaction in number of shares — a positive number to buy, negative to sell, or 0 to do no trading. A brokerage fee of 1% is charges on all transactions (a bargain!). Note: Even if the value of a stock drops to zero, it may rebound again — then again, it may not.

This program was created by D. Pessel, L. Braun, and C. Losik of the Huntington Computer Project at SUNY, Stony Brook, N.Y.

---

As published in Basic Computer Games (1978):
- [Atari Archives](https://www.atariarchives.org/basicgames/showpage.php?page=154)
- [Annarchive](https://annarchive.com/files/Basic_Computer_Games_Microcomputer_Edition.pdf#page=166)

Downloaded from Vintage Basic at
http://www.vintage-basic.net/games.html

#### Porting Notes

(please note any difficulties or challenges in porting here)

license: Unlicense

repository: allyn-bottorff/basic-computer-games

repo_name: allyn-bottorff/basic-computer-games


text:
---
id: sensible-data
title: Working with sensible data
---

### Reminder: DSRI restrictions

* Since DSRI can only be accessed when on the physical UM network or using the [UM VPN](https://vpn.maastrichtuniversity.nl/), deployed services will not be available on the public Internet 🔒
* All activities must be legal in basis. You must closely examine and abide by the terms and conditions of any data, software, or web service that you use as part of your work 📜

## Disclaimer

The DSRI administration disclaims all responsibility in the misuse of sensible data processed on the DSRI

We can guarantee you that only you, and 4 administrators are able to access the data (you might need to see with the data owner if that is not a problem)

Feel to ask us more details

repository: MaastrichtU-IDS/dsri-documentation

gha_language: TypeScript

repo_name: MaastrichtU-IDS/dsri-documentation


text:
# hello-world
Wildlife Radio Homing Drone

I am trying to make a UAS (Unmanned Aerial
System, aka drone) that will seek out VHF radio collars on raccoons (wild
raccoons that have been trapped, collared, and released as part of one of my
studies). The drone would carry a device to download GPS
coordinates collected by a GPS receiver on the collar while the animals are
going about their lives. Instead of walking out into the bush to download
the GPS data, I want the drone to do it for me. Therefore the drone needs to find and then
hover over the collar.
Ideally, it would also be nice if
some kind of GPS download feedback could be obtained to let the operator on the
ground know that the data has been acquired.
Hardware: Software Defined Radio dongle, Rasberry Pi 3 or other companion computer.
Code: I don't really know how to program, code, nada. Okay, maybe not nada.
I get the basic idea behind algorithms and understand some commands, but
I am not at all proficient with programming.

repository: kbentler/hello-world

repo_name: kbentler/hello-world


text:
# home-automation-using-google-assistant
Automating your home with a pinch of Google's AI and NLP, powered by NodeJs and Python.

# Description
A home automation project using the strength of google assistant present on Android devices.

``` Run server.js to get started ```


text:
Blink - A high performance web framework and application server in PHP
======================================================================

[![Build Status](https://travis-ci.org/bixuehujin/blink.svg?branch=master)](https://travis-ci.org/bixuehujin/blink)
[![Latest Stable Version](https://poser.pugx.org/blink/blink/v/stable)](https://packagist.org/packages/blink/blink)
[![Latest Unstable Version](https://poser.pugx.org/blink/blink/v/unstable)](https://packagist.org/packages/blink/blink)

Blink is a micro web framework for building long-running and high performance services, the design heavily inspired by Yii2
and Laravel. Blink aims to provide the most expressive and elegant API and try to make the experience of web development
as pleasant as possible.

Besides, Blink is also an application server that can serve requests directly in PHP, without php-fpm or Apache's mod_php.
we use the [Swoole extension](https://github.com/swoole/swoole-src) as the underlying networking library. This can easily make
our PHP application 100% faster in just a blink.

## Why build this?

In php-fpm or mod_php, all resources like objects and database connections only live within a single request,
all these resources will be freed once the request terminates. This works fine with simple applications without
much traffic, but for large scale applications, the performance impact of reallocating resources on every request
is really huge.

Because of this, we are always trying to find a way to reduce unnecessary resources reallocating on every request, and
I'm finally very glad to announce that **Blink** is exactly the answer!

## Features

* Powered by Swoole, serve requests in PHP directly
* Dependency Injection & Service Locator
* Routing for Restful APIs
* Authentication & Authorization abstraction
* Session Management abstraction
* Middleware support for Request and Response
* Plugins support
* PHPUnit integration for unit tests

## Installation

Install the latest version with

```bash
composer create-project --prefer-dist blink/seed your-app
```

## Documentation

Blink is fully documented in both English and Chinese:

 * [English Documentation](https://docs.rethinkphp.com/blink-framework/v0.4/en/)
 * [简体中文文档](https://docs.rethinkphp.com/blink-framework/v0.4/zh-CN/)

For the documentation of v0.3, please visit https://docs.rethinkphp.com/blink-framework/v0.3/

## Related Projects

 * [blink-redis](https://github.com/rethinkphp/blink-redis) A Redis component for the Blink Framework
 * [blink-sentry](https://github.com/bixuehujin/blink-sentry) The Sentry integration for Blink Framework.
 * [notejam_blink](https://github.com/Whyounes/notejam_blink) A notejam demo application for Blink.

## Participating

**Blink is still in active development, so your participation is very welcome!**

You may participate in the following ways:

* [Report issues or Start a design discussion](https://github.com/bixuehujin/blink/issues)
* Develop features or write documentation via [Pull Requests](https://github.com/bixuehujin/blink/pulls)

## Author

Follow me on [Weibo](http://weibo.com/bixuehujin) (Mainland China) to receive news and updates about the framework.

## License

The Blink framework is open-sourced software licensed under the [MIT license](http://opensource.org/licenses/MIT)

repository: bixuehujin/blink

gha_language: PHP

repo_name: bixuehujin/blink


text:
# THOR: step 2 - Supervised learning

The second step of THOR consist in training a ML classification algorithm to find a mapping between accessible variables from climate models like {wind stress curl, SSH, bathymetry, and gradients} and the classes found from step 1

gha_language: Jupyter Notebook


text:
# sails-affiliate-tracker

sails-affiliate-tracker is middleware that can be used to track your application affiliate's by
checking if an affiliate code is present in the URL.

It will assign a cookie '{referral:1234}' to the request, if one does not already exist, based on a user ID found from the username in the URL after a Users.find({username:username}) query.

This is quite a rigid package and will only work if you want your affiliate URL structures in the format of: http://mydomain.com/{unique-affiliate-username} or http://mydomain.com/page1/page2/etc/{unique-affiliate-username}.
It will not work for query strings, although it could be modified quite easily to do so. I just do not have the need to do so.

However, it does have some nifty features for SEO, in that it will NOT perform a redirect to serve the original page. Instead it will modify the req.url to
remove the affiliates username and pass that through behind the scenes - meaning your normal routes apply and controller logic for that page is executed.

One other SEO thing it will do is provide your views with a parameter for canonical links, should it be required. You use it like this in your view files:

    <% if(typeof req.affiliateTracker !== 'undefined' && typeof req.affiliateTracker.canon !== 'undefined'){ %>
	<link rel="canonical" href="<%= sails.getBaseurl() + req.affiliateTracker.canon %>" />
	<% } %>

## Installation

Via git:

    $ git clone git://github.com/mrpetef10/sails-affiliate-tracker.git ~/.node_libraries/sails-affiliate-tracker

Via npm:

    $ npm install sails-affiliate-tracker

## Setup

There are a couple of things you must do to set this up first.

1) Require this in your config/http.js config file and add an entry 'affiliateTracker' after cookieParser:

     middleware: {

		affiliateTracker: require('sails-affiliate-tracker'),

	  /***************************************************************************
	  *                                                                          *
	  * The order in which middleware should be run for HTTP request. (the Sails *
	  * router is invoked by the "router" middleware below.)                     *
	  *                                                                          *
	  ***************************************************************************/

     order: [
		.....,
		.....,
		'cookieParser',
		'affiliateTracker',
		.....,
		.....,
     ],

2) Since I am still new to working with node.js/sails.js I am unsure how to actually pass custom config vars to this middleware (I would welcome anyone to create a pull request with an update to add this in!). Due to that you need to go into the node_modules/sails-affiliate-tracker/index.js file, go to line 42 and change the regex to your specific affiliate URL format. I set mine to use:

	// Will match /page1/user-mrpetef10
	// or /page1/user-anotherusername
	var regex = /^user-[\w]{5,22}$/i;

I set it in this way so that it is easily extractable from URLs and I could still if I want to in future link to my users profile pages without concern of this breaking it.

Not the best way to creating this I know, however it is an initial version that took around 15 mins to put together.


text:
Content diff
------------

[./content_diff](./content_diff) is a simple test which looks for contents differences between Dev, Staging & Production
version of the same page.
At the moment it only compares selected Domestic & International pages.

This test uses:

## General requirements

* Python 3.8+
* [Python Behave](https://pypi.org/project/behave/) to run the tests
* [requests](http://docs.python-requests.org/en/master/) to fetch page contents
* Python's built-in [difflib](https://docs.python.org/3.8/library/difflib.html) to find & generate diff report

## Installation and execution

1. Create a dedicated virtualenv `mkvirtualenv -p python3.8 contentdiff` or use the same one as for other `periodic_tasks`
2. Install dependencies `make requirements_periodic_tasks` (or `pip install -r requirements_load.txt`)
3. Set required env vars using `periodic.sh` script (see [Env Vars](../../../README.md#env-vars) & [Convenience shell scripts](../../../README.md#Convenience-shell-scripts) sections in the main README)
4. Run the test with dedicated make target

### Running the content diff test

In order to run the test you'll need to specify for which site you want to run it and what two environments you want to compare:

```bash
SERVICE=international ENVS_TO_COMPARE=stage_dev \
    make compare_content
```

Possible values:

* SERVICE: `international` or `domestic`
* ENVS_TO_COMPARE:
    * `prod_uat`
    * `prod_stage`
    * `prod_dev`
    * `stage_uat`
    * `stage_dev`

### Report

Once the test is finished, a simple HTML report will be generated and saved in `./reports` directory.
The report contains few metrics:L

* percentage similarity between two version of the page

Below is a an example of a content diff report summary:
![an example content diff report summary](./docs/content-diff-report.png)

And here's an example of a content difference between Dev & Staging version of the same page:
![an example page content diff report](./docs/content-diff-example.png)

repository: uktrade/directory-tests

gha_language: Python

repo_name: uktrade/directory-tests


text:
# FormatConverter(Yaml to Json, Json to Yaml) [![Build Status](https://travis-ci.org/nyango/format-converter.svg?branch=master)](https://travis-ci.org/nyango/format-converter)

Scala wrapper for [MoultingYAML](https://github.com/jcazevedo/moultingyaml) and [Play JSON](https://github.com/playframework/play-json),
in order to convert from yaml to json, and vice versa.

## How to use

When you use it in Scala, add some words as below.

```build.sbt
lazy val yourProject = Project(...

  ).dependsOn(ProjectRef(uri("git://github.com/nyango/format-converter.git#v0.1.1"), "root"))
```

repository: nyango/format-converter

gha_language: Scala

repo_name: nyango/format-converter


text:
# Reject

The `reject` function is the inverse of `filter`. It accepts a predicate function and a list and returns a new list of the items that *do not* satisfy the predicate.

For example, given the predicate function `(x) => x < 4` and the list `[2, 3, 4, 5, 6]`, `reject` should return `[4, 5, 6]` (2 and 3 were rejected since they're less than 4).

Return an empty list if no items remain after running `reject`.

repository: BootcampersCollective/Coders-Workshop

repo_name: BootcampersCollective/Coders-Workshop


text:
---
title: "Escape Standard Library Reference"
slug: scripting-language-stdlib
type: "reference"
toc: true
---

<style>
h2 {
  font-size: 0.8em;
  font-family: mono;
  background: #4B9CD3;
  padding: 5px;
}
</style>

Standard library functions for the [Escape Scripting Language](../scripting-language/)

# Functions acting on integers

## add(y :: integer)

Add two integers

# Unary functions

## timestamp()

Returns a UNIX timestamp

# Functions acting on bool

## and(b2 :: bool)

Logical AND operation

## or(b2 :: bool)

Logical OR operation

## not()

Logical NOT operation

# Functions acting on integer

## lte(i2 :: integer)

Returns true if first argument is less than or equal to the second argument

## gt(i2 :: integer)

Returns true if first argument is greater than second argument

## gte(i2 :: integer)

Returns true if first argument is greater than or equal to second argument

## lt(i2 :: integer)

Returns true if first argument is less than the second argument

# Functions acting on everything

## id(parameter :: *)

Returns its argument

## equals(parameter :: *)

Returns true if the arguments are of the same type and have the same value

# Functions acting on lists

## env_lookup(key :: string)

Lookup key in environment. Usually called implicitly when using '$'

## join(sep :: string)

Join concatenates the elements of a to create a single string. The separator string sep is placed between elements in the resulting string.

## list_index(n :: integer)

Index a list at position `n`. Usually accessed implicitly using indexing syntax (eg. `list[0]`)

## length(n :: integer)

Returns the length of the list

## list_slice(i :: integer, j :: integer)

Slice a list. Usually accessed implicitly using slice syntax (eg. `list[0:5]`)

# Functions acting on strings

## base64_encode()

Encode string to base64

## trim()

Returns a slice of the string s, with all leading and trailing white space removed, as defined by Unicode.

## track_major_version()

Track major version

## track_minor_version()

Track minor version

## split(sep :: string)

Split slices s into all substrings separated by sep and returns a slice of the substrings between those separators. If sep is empty, Split splits after each UTF-8 sequence.

## lower(v :: string)

Returns a copy of the string v with all Unicode characters mapped to their lower case

## read_file()

Read the contents of a file

## concat(v1 :: string, v2 :: string, ...)

Concatate stringable arguments

## track_version()

Track version

## upper(v :: string)

Returns a copy of the string v with all Unicode characters mapped to their upper case

## path_exists()

Returns true if the path exists, false if not

## file_exists()

Returns true if the path exists and if it's not a directory, false otherwise

## dir_exists()

Returns true if the path exists and if it is a directory, false otherwise

## replace(old :: string, new :: string, n :: integer)

Replace returns a copy of the string s with the first n non-overlapping instances of old replaced by new. If old is empty, it matches at the beginning of the string and after each UTF-8 sequence, yielding up to k+1 replacements for a k-rune string. If n < 0, there is no limit on the number of replacements.

## base64_decode()

Decode string from base64

## track_patch_version()

Track patch version

## title(v :: string)

Returns a copy of the string v with all Unicode characters mapped to their title case

repository: ankyra/escape-integration-tests

repo_name: ankyra/escape-integration-tests


text:
# Generate a configuration file

You can generate your configuration file interactively by running `blueoil init` command.

    $ ./blueoil.sh init

`blueoil init` command generates a configuration file to train your new model.

With the `blueoil init` command, you can configure your training configuration interactively.

This is an example of configuration.
```
#### Generate config ####
  your model name ():  test
  choose task type  classification
  choose network  LmnetV1Quantize
  choose dataset format  Caltech101
  training dataset path:  {dataset_dir}/train/
  set validataion dataset? (if answer no, the dataset will be separated for training and validation by 9:1 ratio.)  yes
  validataion dataset path:  {dataset_dir}/test/
  batch size (integer):  64
  image size (integer x integer):  32x32
  how many epochs do you run training (integer):  100
  select optimizer: MomentumOptimizer
  initial learning rate: 0.001
  choose learning rate schedule ({epochs} is the number of training epochs you entered before):  '2-step-decay' -> learning rate decrease by 1/10 on {epochs}/2 and {epochs}-1.
  enable data augmentation?  No
  apply quantization at the first layer: yes

#### how can I change small setting? Or I need to re-run `blueoil init` again?
You don't need to re-run `bluoil init` again.
`blueoil init` just generates a config file in YAML format. You can change some settings, according to comments.

#### data augmentation
You can use various augmentation methods in generated YAML, also you can change augmentation methods's parameter.
Under `commmon.data_augmentation` in generated yaml, augmentation methods are listed and the parameters are nested in each methods.
```

generated yaml:
```
common:
  data_augmentation:
    - Blur:
        - value: (0, 1)
    - Color:
        - value: (0.75, 1.25)
    - Contrast:
        - value: (0.75, 1.25)
    - FlipLeftRight:
        - probability: 0.5
```

Please see the data augmentor reference page, when you want to know about augmentation methods. the all of augmentation methods and parameter are explained, methods name in generated yaml correspond to class name under `lmnet.data_augmentor` in the reference.

#### optimizer

You can choose optimizer from Adam or Momentum. Each optimizer uses TensorFlow implementation. Please see TensorFlow documentation, [AdamOptimizer](https://www.tensorflow.org/api_docs/python/tf/train/AdamOptimizer) and [MomentumOptimizer](https://www.tensorflow.org/api_docs/python/tf/train/MomentumOptimizer).

generated yaml:

```
trainer:
  ...
  # supported 'optimizer' is 'Momentum', 'Adam' currently.
  # Momentum
  #    https://www.tensorflow.org/api_docs/python/tf/train/MomentumOptimizer
  # Adam
  #    https://www.tensorflow.org/api_docs/python/tf/train/AdamOptimizer
  optimizer: Adam
```

Blueoil use optimizers with your input learning rate for both Adam and Momentum, and `momentum=0.9` for Momentum. Other values are TensorFlow default described in TensorFlow documentation.

repository: hariby/blueoil

repo_name: hariby/blueoil


text:
---
layout: post
title: Whats the deal with interfaces?
---

I was recently asked if I could help describe interfaces in c# and how they are used. So this is an attempt to provide some insight on that front. Le me start with...

## What is an interface?

An interface is like a bluprint for a class. Stating the properties and methods that inheriting classes must implement.

For example a car and bike dealership might have an interface that returns the spec on a vehicle:

```
    public interface IVehicle
    {
        string LiscencePlate { get; }

        string ManufacturerName { get; }

        int MaxSpeed { get; }

        int WheelCount { get; }

        string Type { get; }
    }
```

And the different types of vehicle would implement that interface:

```
    public class Car : IVehicle
    {
        public Car(string liscencePlate, string manufacturerName, int maxSpeed)
        {
            LiscencePlate = liscencePlate;
            ManufacturerName = manufacturerName;
            MaxSpeed = maxSpeed;
        }

        public string LiscencePlate { get; private set; }

        public string ManufacturerName { get; private set; }

        public int MaxSpeed { get; private set; }

        public int WheelCount => 4;

        public string Type => "Car";
    }

    public class Bike : IVehicle
    {
        public Bike(string liscencePlate, string manufacturerName, int maxSpeed)
        {
            LiscencePlate = liscencePlate;
            ManufacturerName = manufacturerName;
            MaxSpeed = maxSpeed;
        }

        public string LiscencePlate { get; private set; }

        public string ManufacturerName { get; private set; }

        public int MaxSpeed { get; private set; }

        public int WheelCount => 2;

        public string Type => "Bike";
    }

```

Then code that accepts an interface of vehicle can be passed either a bike or a car and it will work fine.

```
    internal static class ShowRoomService
    {
        internal static int GetNumberOfWheels(IVehicle vehicle)
        {
            return vehicle.WheelCount;
        }

    }
```

gha_language: SCSS


text:
# Create, but don't start, a Container

Docker Documentation References:

[docker create](https://docs.docker.com/engine/reference/commandline/create/)

[docker ps](https://docs.docker.com/engine/reference/commandline/ps/)

[docker rm](https://docs.docker.com/engine/reference/commandline/rm/)

## Intent

The intent of this exercise is to familiarize yourself with creating a container but not starting the container when you do it.

## Overview

In this exercise, will will create a container with a name, but we will not start that container. We will show it in the list of containers. Then we will remove it.

## Kata Steps

### Create Container

**Command**

```bash
docker create --name docker_kata_nginx -p 80:80 nginx:alpine
```

**Output**

```bash
/ # docker create --name docker_kata_nginx -p 80:80 nginx:alpine
a5c285acb74fc12e1f68ad0758587860d062d814dab23c7815d715c474d22e3d
```

### List Containers

**Command**

```bash
docker ps -a
```

**Output**

```bash
/ # docker ps -a
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS               NAMES
a5c285acb74f        nginx:alpine        "nginx -g 'daemon ..."   5 seconds ago       Created                                 docker_kata_nginx
```

### Remove Container

**Command**

```bash
docker rm docker_kata_nginx
```

**Output**

```bash
/ # docker rm docker_kata_nginx
docker_kata_nginx
```

[Previous](32_attach_container.md) | [Index](README.md) | [Next](34_image_history.md)

repository: SrinivasanAgile/DockerKata

repo_name: SrinivasanAgile/DockerKata


text:
# Contribute

* Clone the project

* Install dependencies
```
npm install
```

* Run the project
```
npm start
```
* then open in browser
```
http://localhost:8000/
```

* Make changes and create pull request


text:
# bzaf

**Proof of Concept Repo**

`bzaf` is a Bugzilla Auto Verification Tool.

## General

This tool aims to provide an auto verification framework to Bugzilla bugs.

## Documentation

Visit https://bzaf.readthedocs.io.

## Contribution

Please use https://review.gerrithub.io to submit changes.

repository: rhos-infra/bzaf

repo_name: rhos-infra/bzaf


text:
# Creating graphs

A _graph_ consists of _nodes_ which represent some objects or values and _edges_ which express a
relation between this objects and values. In `graphs` the base type for a graph is therefore
a trait with the type parameters for node and the edge type:

@@snip [Graph.scala](../core/shared/src/main/scala/com/flowtick/graphs/Graph.scala){ #graph }

There is default implementation of a graph which has just one property for its nodes, which is an `id`
to identify the node. Using this default implementation, you can instantly start creating graph instances:

@@snip [SimpleGraphApp.scala](../examples/src/main/scala/SimpleGraphApp.scala)

## Custom Graph Types

Creating a custom graph type is just a matter of extending the core interfaces `Node`, `Graph`, `Edge` with
custom implementations and a graph builder to create instances:

@@snip [CustomGraphApp.scala](../examples/src/main/scala/CustomGraphApp.scala){#custom_graph}

### Arrow-style builder methods

To add some sugar for the graph creation, have a look at tne `NodeOps`-types which allow to define arrow like
builder methods on the node types:

@@snip [CustomGraphApp.scala](../examples/src/main/scala/CustomGraphApp.scala){#custom_graph_builder}

### Default Graph

The default graph implementation shows another example on how to define a simple node type and a bunch of builders for
the different edge types:

@@snip [DefaultGraph.scala](../core/shared/src/main/scala/com/flowtick/graphs/defaults/DefaultGraph.scala)

repository: waffle-iron/graphs

repo_name: waffle-iron/graphs


text:
---
title: Pattern.render()
---

The `Pattern.render()` method will render the pattern to SVG and return
that SVG as a string. It should only be called after calling
[Pattern.draft()](/reference/api/pattern/draft/) first.

## Pattern.render() signature

```js
string pattern.render()
```

## Pattern.render() example

```js
import { Aaron } from "@freesewing/aaron"
import { cisFemaleAdult34 } from "@freesewing/models"

const pattern = new Aaron({
  measurements: cisFemaleAdult34
})

const svg = pattern.draft().render()
```

repository: freesewing/freesewing

branch_name: refs/heads/develop

repo_name: freesewing/freesewing


text:
---
layout: post
title: Indexing Archetype content in Umbraco - Pt II
category: blog
---

While a custom indexer will absolutely get the job done, it's overkill.

There's no real need to spin up a custom indexer for Archetype content, given the exposed events in Umbraco - `OnGatheringNodeData` in particular.

You might be familiar with this event, and how it can be used to manipulate node data before it is pumped into your Examine indexes. Given that an Archetype fieldset is, at its heart, just a data construct, we can use similar logic to parse out the content we require and add it to our index.

The guts of the code is practically the same as it is when using a custom indexer, only we identify the Archetype fieldset slightly differently:

```csharp
private void CustomGatheringNodeDataMethod(object sender, IndexingNodeDataEventArgs nodeData)
{
    if (nodeData.Fields.ContainsKey("archetypeAlias"))
    {
        var archetypes = JsonConvert.DeserializeObject(nodeData["archetypeAlias"]);
        var content = "";

        foreach (var archetype in archetypes)
        {
            //Iterate the archetype objects, add the desired values to the content variable
            if (archetype.Alias == "indexAPropertyOfThisFieldset")
            {
                content += archetype.GetValue("indexThisProperty")
            }
        }
        //Adding the archetype content to the bodytext field to make it searchable
        if (!String.IsNullOrEmpty(content))
        {
            if (nodeData.Fields.ContainsKey("bodyText"))
                nodeData["bodyText"] += content;
            else
                nodeData.Fields.Add("bodyText", content);
            }
        }
    }
}
```

That's just very quick cut at how you could index Archetype data - depending on your content configuration the actual process will be different. You might want to index the Archetype data in specific fields rather than just packing it into a generic field like the example.

The custom indexer approach is much better suited to indexing external data sources - given the Archetype content is just a UI wrapped around simple data, the event system is the better way to manage indexing. Either way though, you'll have searchable Archetype data.

gha_language: CSS


text:
# Change Log

## [v0.1.1](https://github.com/braiden-vasco/lita-substitution/tree/v0.1.1) (2015-10-25)
[Full Changelog](https://github.com/braiden-vasco/lita-substitution/compare/v0.1.0...v0.1.1)

**Merged pull requests:**

- Allow embedded substitutions [\#2](https://github.com/braiden-vasco/lita-substitution/pull/2) ([braiden-vasco](https://github.com/braiden-vasco))
- Add instructions [\#1](https://github.com/braiden-vasco/lita-substitution/pull/1) ([braiden-vasco](https://github.com/braiden-vasco))

## [v0.1.0](https://github.com/braiden-vasco/lita-substitution/tree/v0.1.0) (2015-10-25)

\* *This Change Log was automatically generated by [github_changelog_generator](https://github.com/skywinder/Github-Changelog-Generator)*

repository: kotovalexarian/lita-substitution

repo_name: kotovalexarian/lita-substitution


text:
---
title: Customize Summary Component
description: Extend the summary step component to include the capability to navigate to the next form in the package.
feature: Adaptive Forms
version: 6.4,6.5
kt: 6894
thumbnail: 6894.jpg
topic: Development
role: Developer
level: Experienced
exl-id: fb68579d-241c-414d-92f4-13194f4d1923
---
# Customize summary step

Summary step component is used to display the summary of your form submission with a link to download the signed form. Summary step is typically placed in the last panel of your form.
For the purpose of this use case we have created a new component based on the out of the box Summary component and extended the capability to include custom clientlib.

This component is identified by the label Sign Multiple Form

The following screen shot shows the new component that was created to display the message on completion of the signing ceremony

![summary component](assets/summary.PNG)

The new component is based on the out of the box summary component.
![component-prop](assets/componentprop.PNG)

We have added a button to navigate to the next form for signing
![template-code](assets/template-code.PNG)

The summary.jsp has the following code. It has reference to the client library identified by the category id **getnextform**

```java
<%--
  Guide Summary Component
--%>
<%@include file="/libs/fd/af/components/guidesglobal.jsp"%>
<%@include file="/libs/fd/afaddon/components/summary/summary.jsp"%>
<ui:includeClientLib categories="getnextform"/>

```

## Assets

The custom summary component can be [downloaded from here](assets/custom-summary-step.zip)

## Next Steps

[Get the next form for signing](./create-client-lib.md)


text:
## Cumulative Record - Hyperledger Fabric Sample Application by Chainoid

This Cumulate Record demonstrates the workflow of test records in the studying process: operation between office staff, teachers and students.
In this exercise we will set up the minimum number of nodes required to develop chaincode. It has a single peer and a single organization.

#### Step1
- Add new group into the ledger

![Group screen](../master/images/GroupScreen.png)

#### Step2
- Add new student into the ledger

![Student screen](../master/images/StudentList.png)

#### Step3
- Genarate worksheet for pair group/course

![Generate worksheet](../master/images/GenerateWorksheet.png)

#### Step4
- Teacher use worksheet list and rate every student

![Teacher screen](../master/images/TeacherPage.png)

#### Step5
- Student cumulative record, read only

![Student record](../master/images/StudentCR.png)

This code is based on code written by the Hyperledger Fabric community. Source code can be found here: (https://github.com/hyperledger/fabric-samples).

Also used skeleton from tuna-app code from here: (https://github.com/hyperledger/education).

repository: chainoid/cumulativerecord

repo_name: chainoid/cumulativerecord


text:
# emscripten-cmake
Using CMake Compile WASM Code.

# TS

Failed to fetch compiler version information with command
"'/home/yuzukitsuru/SDK/emsdk/upstream/emscripten/emcc' -v"! Process
returned with error code 1.

repository: YuzukiTsuru/emscripten-cmake

gha_language: CMake

repo_name: YuzukiTsuru/emscripten-cmake


text:
Assignment 3
------------------------

# Introduction #

It turns out that you can modify the concept of a linked list, but have nodes
connected by any topology you like.In this assignment, you will be modifying
your linked list to implement a two-dimensional linked-list (or matrix) by
defining a node as having a north, south, east, and west neighbor as well as a
value. The scaffold for your class should look like:

# Recommended Setup

First build the top row:

```python
Create a headNode
temp = headNode
for i from 0 to numberOfColumns-1:
    temp.east = new Node
    temp.east.west = temp
    temp = temp.east
```

Next, add an additional row below this:

```python
above = headNode
rowhead = above
for j from 0 to numberOfRows-1:
    above = rowhead
    above.south = new Node
    above.sound.north = above
    rowhead = above.south
    temp = above.south
    for i from 0 to numberOfColumns - 1 :
        temp.east = a new Node
        temp.east.west = temp
        above = above.east
        temp.east.north = above
        above.south = temp.east
        temp = temp.east
```

# FAQ #

* Can I change the Node class?

Please do not change the Node class since I will not be able to test to see if
you have built the program correctly.

* What does the default value mean?

When you create a new matrix with a defined dimension, you must specify what
the default value is set to for each Node. Later in the operation of the code,
one can reset the value of the node to be anything he or she wishes.

* Can I use a Python list?

Yes, you can use a Python list, but make sure that you are only temporarily
using it- just for helping you create a new matrix, or to insert new rows or
columns. The actual persistent data for holding the values in the LinkedMatrix
are composed of linked Nodes.


text:
# Bag of Words:
A search engine based on a bag  of words model written in python.
The model takes as input every document in the input folder and a query from the user and creates a vector space.
For each query it returns the most similar document based on vector similarity (dot product).

## Requirements:
* all requirements are saved in envoroment.yml

## Quickstart:
* install [Miniconda](https://docs.conda.io/en/latest/miniconda.html)
* cd into the root directory of this repository
* create a new environment from the environment.yml file
```
conda env create -f environment.yml
```

* activate the new environment
```
conda activate bow
```

## Supported languages:
- German
- English
- Italian

### Stopwords:
Source: https://github.com/stopwords-iso/stopwords-iso

## Use:
place your text files in the input folder and start main.py:
```
$ python search.py de
```


text:
# 201FinalProject
## John Stratton, Ashley Biermann, Mason Fryberger

[*Click Here to Return to the HomePage*](index.html)

### Wireframe visualization for each page

[Home Page](img-assets/home-page-wireframe.PNG)

[About Us](img-assets/about-us-wireframe.PNG)

[Leaderboard](img-assets/leaderboard-wireframe.PNG)

## Synopsis

 Our goal for this project is to provide our users with an entertaining game utilizing `<canvas>` and JavaScript, that invokes a sense of nostalgia hailing back to classic games such as Dig Dug © and MineSweeper ©. Users will also have the option to read about us personally as developers and compare their game scores to a leaderboard. Other developers will have the option to look at our markdown documents and view our sources, references, and libraries.

## Code Example

![canvas-styling](img-assets/example-of-library-use.PNG)

```
var legra = new legra(ctx, 10, {color: 'yellow'});
legra.ctx = ctx;
const unit = 5; // height and width of game "tile";

function playMat(){
  legra.rectangle(0, 0, (unit * 10), (unit * 10), {filled: true, color: '#00cbff'});

}

```

## Motivation

The working Title of the project is “Mine-Hound” and will most strongly resemble classic rogue-like arcade games providing entertainment for users during these trying times of social distancing, and providing a simple example for new programmers to work with canvas, opensource libraries, and data persistence.

## Installation

Developers can view the project on GitHub: [Mine-Hound-Project](https://github.com/johnpstratton/201FinalProject) and from there fork the repository to work with it directly.
front-end testing and gameplay can be done from the home page of the site found here: [HomePage](index.html)

## API/Libraries Reference

In order to get the game to render in canvas with a lego skin we used the Legra.js open-source library published with an MIT liscence. [legra-js-website](https://legrajs.com/)

## Tests

N/A

## Contributors

This project was developed and brought to you by Code Fellows class 201-d62 graduates as thier final project and may be found on GitHub;
[Ashley Biermann](https://github.com/ashleybiermann)
[John Stratton](https://github.com/johnpstratton)
[Mason Fryberger](https://github.com/MasonChance)

## License

Project published to GitHub pages with an MIT open-source liscence. Those wishing to work with the code can contact any of the initial contributers regarding pull requests or create a fork from the repository [here](https://github.com/johnpstratton/201FinalProject)

repository: johnpstratton/Mine-Hound

repo_name: johnpstratton/Mine-Hound


text:
# MNIST example resources

The MNIST example provides the following resources:

    >>> run("guild -C examples/mnist2 resources")
    Limiting resources to 'examples/mnist2' (use --all to include all)
    ./examples/mnist2/mnist-expert:model  Exported expert model
    ./examples/mnist2/mnist-intro:model   Exported intro model
    <exit 0>

The same list after changing directories:

    >>> cd("examples/mnist2")
    >>> run("guild resources")
    Limiting resources to the current directory (use --all to include all)
    ./mnist-expert:model  Exported expert model
    ./mnist-intro:model   Exported intro model
    <exit 0>

And listing all resources with the `-a` option:

    >>> run("guild resources mnist -a")
    ./mnist-expert:model  Exported expert model
    ./mnist-intro:model   Exported intro model
    keras.datasets/...
    <exit 0>

repository: pombredanne/guild

repo_name: pombredanne/guild


text:
# BITTSy-Reporting
Reporting module for analyzing log files generated by BITTSy

See the BITTSy manual for more information: https://ldevumd.gitbook.io/bittsy/data-output/the-reporting-module

repository: umdldev/BITTSy-Reporting

repo_name: umdldev/BITTSy-Reporting


text:
L81: Custom Audience in JWT Access Credentials and Google Default Credentials
----
* Author(s): [Jiangtao Li](https://github.com/jiangtaoli2016), [Yihua Zhang](https://github.com/yihuazhang)
* Approver: markdroth
* Status: Implemented {Draft, In Review, Ready for Implementation, Implemented}
* Implemented in: Core, C++
* Last updated: 2021-06-04
* Discussion at: https://groups.google.com/g/grpc-io/c/MgSP5tNrM0Q

## Abstract

In current gRPC C++ implementation, the audience field of JWT access token is
always set to the service URL. It works for most of the cases. However, there
are use cases where a user wants to override the default audience (service URL)
and uses its own. This gRFC provides a way for an applications to override
the default audience field.

## Background

Consider an application wants to use JWT Access Credentials or Google Default
Credentials to connect to a regional endpoint, e.g.,
`us-dialogflow.googleapis.com`, rather than the global endpoint
`dialogflow.googleapis.com`, the cloud service may reject the JWT because the
auidence field was set to `us-dialogflow.googleapis.com`. In such scenarios,
the application wants the ability to override the default audience field and
set the auidence field of its choice.

### Related Proposals:

NA

## Proposal

We propose to change the following C++ API. If the user_provided_audience
field is empty, then service URL will be used as the auidence field, otherwise,
the user_provided_audience will be used as the audience in the JWT.

When the user_provided_audience field is set in Google Default Credentials,
this field is only used when a service account JWT access credential is
created. This field will be no-op if for example a compute engine credential
is created.

```
/// Builds Service Account JWT Access credentials.
/// json_key is the JSON key string containing the client's private key.
/// token_lifetime_seconds is the lifetime in seconds of each Json Web Token
/// (JWT) created with this credentials. It should not exceed
/// \a kMaxAuthTokenLifetimeSecs or will be cropped to this value.
/// user_provided_audience is an optional field for user to override the
/// auidence in the JWT token. If user_provided_audience is empty, the service
/// URL will be used as the audience.
std::shared_ptr<CallCredentials> ServiceAccountJWTAccessCredentials(
    const grpc::string& json_key,
    long token_lifetime_seconds = kMaxAuthTokenLifetimeSecs,
    const grpc::string& user_provided_audience = "");

/// Builds credentials with reasonable defaults.
/// user_provided_audience is an optional field for user to override the
/// auidence in the JWT token. If user_provided_audience is empty, the service
/// URL will be used as the audience. Note that user_provided_audience will
/// only be used if a service account JWT access credential is created by
/// the application default credentials mechanism.
std::shared_ptr<ChannelCredentials> GoogleDefaultCredentials(
    const grpc::string& user_provided_audience = "");
```

We also propose to change the C core API as follows

```
/** Creates a JWT credentials object. May return NULL if the input is invalid.
   - json_key is the JSON key string containing the client's private key.
   - token_lifetime is the lifetime of each Json Web Token (JWT) created with
     this credentials.  It should not exceed grpc_max_auth_token_lifetime or
     will be cropped to this value.
   - user_provided_audience is an optional field for user to override the
     auidence in the JWT token. If user_provided_audience is empty, the
     service URL will be used as the audience.  */
GRPCAPI grpc_call_credentials*
grpc_service_account_jwt_access_credentials_create(
    const char* json_key, gpr_timespec token_lifetime,
    const char* user_provided_audience);

/** Creates default credentials to connect to a google gRPC service.
   WARNING: Do NOT use this credentials to connect to a non-google service as
   this could result in an oauth2 token leak. The security level of the
   resulting connection is GRPC_PRIVACY_AND_INTEGRITY.

   If specified, the supplied call credentials object will be attached to the
   returned channel credentials object. The call_credentials object must remain
   valid throughout the lifetime of the returned grpc_channel_credentials
   object. It is expected that the call credentials object was generated
   according to the Application Default Credentials mechanism and asserts the
   identity of the default service account of the machine. Supplying any other
   sort of call credential will result in undefined behavior, up to and
   including the sudden and unexpected failure of RPCs.

   If nullptr is supplied, the returned channel credentials object will use a
   call credentials object based on the Application Default Credentials
   mechanism.

   user_provided_audience is an optional field for user to override the
   audience in the JWT token if used. If user_provided_audience is empty,
   the service URL will be used as the audience. Note that
   user_provided_audience will only be used if a service account JWT access
   credential is created by the application default credentials mechanism. Also
   note that user_provided_audience will be ignored if the call_credentials is
   not nullptr.
*/
GRPCAPI grpc_channel_credentials* grpc_google_default_credentials_create(
    grpc_call_credentials* call_credentials,
    const char* user_provided_audience);
```

### Temporary environment variable protection

The proposed change in this gRFC is backward compatible since it is the default
value of user_provided_audience is an empty string, thus the default service
URL is used as the auidence the JWT.

## Rationale

NA

## Implementation

Implementation is straight-forward. We just need to plumb the
user_provided_audience to [jwt_credentials.cc](https://github.com/grpc/grpc/blob/master/src/core/lib/security/credentials/jwt/jwt_credentials.cc),
so that this field can be set as the audience field, if it is not an empty
string.

## Open issues (if applicable)

NA

repository: saifmahamood/proposal

repo_name: saifmahamood/proposal


text:
# Week 8 - Python [📹](https://youtu.be/5aP9Bl9hcqI)

## Note
![note](/Week8/note_week8.jpg)

## Voca
- so to speak : 말하자면
  - Rather, these are inside of a module, __so to speak__...
- immutable : 불변의
  - a string is __immutable__ .
- simultaneously : 동시에
  - if we actually want to assign two values __simultaneously__...
- aesthetic : 미학, 심미적인
- overarching : 모든 것을 포함하는
  - I can kind of come up with a general layout the __aesthetics__ for my __overarching__ website...

## etc
- This week is longest 2h 12m!
- Python Syntax is similar to Swift.
- C, Python를 비교하면서 공부했던 것은 처음이었다. C를 통해 아래 구조가 어떻게 작동하는지 알 수 있었고, 이를 알고 모르고의 차이를 느낄 수 있었다. (과거의 나를 비교하면서)
- Before watching of web servers part, web servers is mystery field to me. But ultimately, I got this concept. (I'm not afraid of it anymore)
- Vocabulary that I don't know is becoming more less than first time.


text:
# Silicon Zucchini Generator

[![Build Status](https://travis-ci.org/killercup/generator-silicon-zucchini.svg?branch=master)](https://travis-ci.org/killercup/generator-silicon-zucchini)

> [SiliconZucchini](https://github.com/killercup/silicon-zucchini)

> [Yeoman](http://yeoman.io) generator

## Getting Started

Install yeoman:

```bash
$ npm install -g yo
```

Install this generator:

```bash
$ npm install -g killercup/generator-silicon-zucchini
```

Finally, initiate the generator:

```bash
yo silicon-zucchini
```

## Features

- Initiate folder structure and example files for Silicon Zucchini
  - Example pages with permalinks
  - Header, footer partials
  - Navigation partials
  - Automatic Styleguide (optional)
- Use SCSS for Stylesheets
  - Optionally includes [bourbon](http://bourbon.io/), [neat](http://neat.bourbon.io/) and [normalize-opentype](https://github.com/kennethormandy/normalize-opentype.css)
- Build using Gulp 4
  - Quick development with live reloading server (`npm start`)
  - Compile assets for production (`npm run compile`) including HTML/CSS minification and asset fingerprinting (add hash to filename and rewriting links to make assets infinitely cacheable)

## TODO

- Workflow for JS assets
- Image optimization (and embedding small images using base64)

## License

MIT

repository: killercup/generator-silicon-zucchini

repo_name: killercup/generator-silicon-zucchini