text:
---
title: Linux Installation
menu: Linux
weight: 20
---

## Install Fluvio CLI

The Fluvio CLI (_command-line interface_) is an all-in-one tool for setting up, interacting, and managing with Fluvio clusters.

Install the Fluvio CLI by running the following command:

%copy first-line%
```bash
curl -fsS https://packages.fluvio.io/v1/install.sh | bash
```

## Setting up a Fluvio cluster on Kubernetes

With CLI, you can create and manage fluvio clusters on Kubernetes.  Before you can create a Fluvio cluster, you need to have a Kubernetes cluster up and running.

## Installing Kubernetes cluster

Either you can create a cluster on your local machine or you can deploy it to a cloud provider.

For installing on your local machine, here are suggested Kubernetes installation options:

1) [K3d](https://k3d.io)
2) [Kind](https://kind.sigs.k8s.io)
3) [Minikube](https://minikube.sigs.k8s.io/docs/start/)

After installing Kubernetes, you can run the following command to check if your Kubernetes cluster is up and running:

%copy first-line%
```bash
$ kubectl config current-context
minikube
```

Some of Kubernetes installation will install `kubectl` and `helm`.  You can check it by:

%copy first-line%
```bash
$ kubectl version
Client Version: version.Info{Major:"1", Minor:"21", GitVersion:"v1.21.3", GitCommit:"ca643a4d1f7bfe34773c74f79527be4afd95bf39", GitTreeState:"clean", BuildDate:"2021-07-15T21:04:39Z", GoVersion:"go1.16.6", Compiler:"gc", Platform:"linux/amd64"}
Server Version: version.Info{Major:"1", Minor:"21", GitVersion:"v1.21.2", GitCommit:"092fbfbf53427de67cac1e9fa54aaa09a28371d7", GitTreeState:"clean", BuildDate:"2021-06-16T12:53:14Z", GoVersion:"go1.16.5", Compiler:"gc", Platform:"linux/amd64"}
```

%copy first-line%
```bash
$ helm version
version.BuildInfo{Version:"v3.6.2", GitCommit:"ee407bdf364942bcb8e8c665f82e15aa28009b71", GitTreeState:"clean", GoVersion:"go1.16.5"}
```

If you didn't install `kubectl` and `helm`, you can install them in the following way:

### Install Kubectl

`kubectl` is the Kubernetes command-line tool. It is used to run commands against Kubernetes clusters.

Follow the instructions at the [kubectl installation page] and follow the instructions to download and install `kubectl` on Linux.

[kubectl installation page]: https://kubernetes.io/docs/tasks/tools/install-kubectl-linux/

### Install Helm

Helm is the package manager for Kubernetes.

Follow the instructions at the [helm installation page] and follow the instructions to download and install `helm` on Linux.

[helm installation page]: https://v3.helm.sh/docs/intro/install/

## Start Fluvio cluster on Kubernetes

You can start a Fluvio cluster by running `fluvio cluster start`.

%copy first-line%
```bash
$ fluvio cluster start
📝 Running pre-flight checks
     ✅ Kubernetes config is loadable
     ✅ Supported helm version is installed
     ✅ Fixed: Missing Fluvio system charts.
     ✅ Previous fluvio installation not found
🛠  Installing Fluvio
     ✅ Fluvio app chart has been installed
🔎 Found SC service addr: <IP_ADDRESS>:30814
👤 Profile set
🤖 SPU group launched (1)
     ✅ All SPUs confirmed
🎯 Successfully installed Fluvio!
```

### Verify cluster is running

You can start a Fluvio cluster by running:

%copy first-line%
```bash
$ fluvio version
Fluvio CLI           : 0.9.0
Fluvio CLI SHA256    : 170c6d4bad98e961b1f14d0fd052900dcbc92d736757bad3c7dcae2095151861
Fluvio Platform      : 0.9.0 (minikube)
Git Commit           : 5ff06169660c2f111bde3bdfcab9b83f569f9960
OS Details           : Ubuntu 18.04 (kernel 5.4.0-1054-aws)
=== Plugin Versions ===
Fluvio Cloud CLI (fluvio-cloud) : 0.1.5
Fluvio Runner (fluvio-run)     : 0.2.1
```

## Hello, Fluvio!

Congratulations, you've successfully installed Fluvio on your local machine!

Let's use the Fluvio CLI to play with some basic functionality.

The first thing we need to do is create a [topic].

%copy first-line%
```bash
$ fluvio topic create greetings
topic "greetings" created
```

Now that we have a topic, we can [produce] some messages!

Use the following command to send a message to the `greetings` topic:

%copy first-line%
```bash
$ echo "Hello, Fluvio" | fluvio produce greetings
```

Finally, we can [consume] messages back from the topic

%copy first-line%
```bash
$ fluvio consume greetings -B -d
Consuming records from the beginning of topic 'greetings'
Hello, Fluvio
```

Way to go! You're well on your way to writing real-time distributed apps with Fluvio!

Next, check out our [Tutorials page] to see real-world examples of Fluvio in action.

[topic]: {{< ref "/cli/commands/topic.md" >}}
[produce]: {{< ref "/cli/commands/produce.md" >}}
[consume]: {{< ref "/cli/commands/consume.md" >}}
[Tutorials page]: https://www.infinyon.com/tutorials

#### Related Topics
----------------

- ["Hello World" in Java](https://www.infinyon.com/tutorials/java/hello-world/)
- ["Hello World" in Node.js](https://www.infinyon.com/tutorials/node/hello-world/)
- ["Hello World" in Python](https://www.infinyon.com/tutorials/python/hello-world/)
- ["Hello World" in Rust](https://www.infinyon.com/tutorials/rust/hello-world/)

---

If you run into any problems along the way, make sure to check out our [troubleshooting]
page to find a fix.

[troubleshooting]: {{< ref "/docs/operations/troubleshoot.md" >}}

repository: mtekp/fluvio-website

repo_name: mtekp/fluvio-website


text:
---
layout: default
---

# 1995-08-14 - Re: Bet e$ on how long it will take for PGPFone to make it overseas!

## Header Data

From: Mike Bailey<EMAIL_ADDRESS>To: Lucky Green<EMAIL_ADDRESS>Message Hash: e3d43422c19706699daa74a835424f8da5b31bae4c84a79a600c5086e837a447

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1995-08-14 20:47:37 UTC

Raw Date: Mon, 14 Aug 95 13:47:37 PDT

## Raw message

```
{% raw  %}From: Mike Bailey<EMAIL_ADDRESS>Date: Mon, 14 Aug 95 13:47:37 PDT
To: Lucky Green<EMAIL_ADDRESS>Subject: Re: Bet e$ on how long it will take for PGPFone to make it overseas!
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

On Sun, 13 Aug 1995, Lucky Green wrote:

> -----BEGIN PGP SIGNED MESSAGE-----
>
> To loosen up the often so serious discussions on the list, I propose a
> little game. PGPFone's release is about a week away. PRZ is trying his
> hardest to keep it from being exported. Still, I have the feeling that
> some irresponsible cyphercriminal will break US law and export PGPFone
> anyway. Let us bet cyberbucks on how long it will take for this crime to
> happen. Here is my initial offer:
>
> I bet e$50 that PGPFone will have been exported 24 hours after its final
> release has been announced to this list. Who is willing to take the bet?
> Perhaps someone is willing to bet at less time?
>
> Have fun,
>

This is a sucker bet ... more appropriate would be that you bet it will
take longer than X amount of time. Verification would be tricky too.

-Mike

**************************************************************************
*       Mike Bailey                     (hm)214-252-3915                 *
*       AT&T Capital Corporation.       (wk)214-456-4510                 *
*       email<EMAIL_ADDRESS>     host bambam.computek.net         *
*   "Remember you can tune a piano but you can't tuna fish -Joe Walsh"   *
*                http://www.computek.net/public/bailey                   *
**************************************************************************

{% endraw %}
```

## Thread

+ Return to [August 1995](/archive/1995/08)

+ Return to "[Censored Girls Anonymous <carolab@censored.org>](/authors/censored_girls_anonymous_carolab_at_censored_org_)"
+ Return to<EMAIL_ADDRESS>(James Caldwell)](/authors/jcaldwel_at_iquest_net_james_caldwell_)"
+ Return to "[Jiri Baum <jirib@sweeney.cs.monash.edu.au>](/authors/jiri_baum_jirib_at_sweeney_cs_monash_edu_au_)"
+ Return to "[Mike Bailey <bailey@computek.net>](/authors/mike_bailey_bailey_at_computek_net_)"
+ Return to "[Ray Arachelian <sunder@escape.com>](/authors/ray_arachelian_sunder_at_escape_com_)"
+ Return to<EMAIL_ADDRESS>(Lucky Green)](/authors/shamrock_at_netcom_com_lucky_green_)"

+ 1995-08-14 (Sun, 13 Aug 95 18:23:16 PDT) - [Bet e$ on how long it will take for PGPFone to make it overseas!](/archive/1995/08/c7cddebd5618c99477b2d4a02ae196d0574368830dda4fb3719e5182ddcc1188) -<EMAIL_ADDRESS>(Lucky Green)_
  + 1995-08-14 (Sun, 13 Aug 95 22:11:42 PDT) - [Why break ITAR? (was: Bet e$ on how long it will take for PGPFone to make it overseas!)](/archive/1995/08/b85b08cc51b78952c044bc2c129b99b14ca2a4cbf60c4e7459be4a0b90915c2e) - _Jiri Baum<EMAIL_ADDRESS>  + 1995-08-14 (Mon, 14 Aug 95 03:05:37 PDT) - [Re: Bet e$ on how long it will take for PGPFone to make it overseas!](/archive/1995/08/3ee2cd57a207b6cb723341ec240c0d8ea83145307d729f2ccf5dcc6655834f5c) -<EMAIL_ADDRESS>(James Caldwell)_
  + 1995-08-14 (Mon, 14 Aug 95 13:47:37 PDT) - Re: Bet e$ on how long it will take for PGPFone to make it overseas! - _Mike Bailey<EMAIL_ADDRESS>  + 1995-08-28 (Mon, 28 Aug 95 08:30:39 PDT) - [Re: Bet e$ on how long it will take for PGPFone to make it overseas!](/archive/1995/08/f64a16ab465f40d38ce67f8ce6505de2d75111bc49a055c658c0337587f58117) - _Ray Arachelian<EMAIL_ADDRESS>    + 1995-08-28 (Mon, 28 Aug 95 09:07:01 PDT) - [Re: Bet e$ on how long it will take for PGPFone to make it overseas!](/archive/1995/08/912e0455e02f0d0e3bfb3dd94fc66b2eaa85d33bb503dfd05be3c5ebde1cb685) - _Censored Girls Anonymous<EMAIL_ADDRESS>

license: MIT

branch_name: refs/heads/master

extension: md

gha_license_id: MIT

license_type: permissive


text:
---
layout: intros/intro_with_nav
category: Digital Service Standard
subtitle: Ensure the service is accessible to all users regardless of their ability and environment.
---

## [3]Why it's in the Standard

You need to make sure everyone who needs your service can use it. This includes people with disability and older people, and people who can’t use, or struggle with, digital services.

Your service must be accessible to users regardless of their digital confidence and access to a digital environment. This includes users in remote areas and users with different devices.

You also have a legal requirement to ensure your service is usable and accessible to people with disabilities (see the [Disability Discrimination Act 1992](https://www.humanrights.gov.au/dda-guide-whats-it-all-about)). Australian Government agencies are required to meet the Web Content Accessibility Guidelines (WCAG) 2.0 Level AA, which includes Level A (see mandate in  [Web Accessibility National Transition Strategy](https://www.finance.gov.au/archive/publications/wcag-2-implementation/)). You are strongly encouraged to meet WCAG 2.1 Level AA which will provide a more accessible experience. Conforming to WCAG 2.1 means you also conform with 2.0.

repository: govau/service-manual

gha_language: JavaScript

repo_name: govau/service-manual


text:
---
layout: subsite-galaxy
---

<br/>

Welcome to **Galaxy GraphClust** -- a webserver to process and analyse structural clustering of RNA secondary structures.

Galaxy-GraphClust is a web-based workflow for structural clustering of RNA secondary structures developed as an instance of [GraphClust](http://www.bioinf.uni-freiburg.de/Software/GraphClust) Perl pipeline inside the Galaxy framework. It consists of a set of integrated Galaxy tools and different flavors of clustering workflows built upon these tools.

1. TOC
{:toc}

# Get started

Are you new to Galaxy, or returning after a long time, and looking for help to get started? Take [a guided tour](https://metagenomics.usegalaxy.eu/tours/core.galaxy_ui){:target="_top"} through Galaxy's user interface.

### Video tutorial

[This video tutorial](https://www.youtube.com/watch?v=fJ6tUt_6uas) can be helpful to get a visually comprehensive introduction on setting-up and running Galaxy-GraphClust.

[![IMAGE ALT TEXT HERE](/assets/media/graphclust_video-thumbnail.png)](https://www.youtube.com/watch?v=fJ6tUt_6uas){:target="_top"}

### Interactive tours
Interactive Tours are available for Galaxy and Galaxy-GraphClust. To run the tours please on top panel go to **Help→Interactive Tours** and click on one of the tours prefixed **GraphClust workflow**. You can check the other tours for a more general introduction to the Galaxy interface.

### Import or upload a workflow

To import or upload an existing workflow, on the top panel go to **Workflow** menu. On top right side of the screen click on **Upload or import workflow** button. You can either upload workflow from your local system or by providing the URL of the workflow. To have an access to workflow menu you must be logged in. You can download workflows from the following links

  * MotifFinder: [GraphClust-MotifFinder](https://graphclust.usegalaxy.eu/u/graphclust2/w/graphclust2--motiffinder)
  * Workflow main: [GraphClust_1r](https://graphclust.usegalaxy.eu/u/graphclust2/w/graphclust2--main-1r)
  * Workflow main, preconfigured for two rounds : [GraphClust_2r](https://graphclust.usegalaxy.eu/u/graphclust2/w/graphclust2--main-2r)

GraphClust pipeline overview
===============================

GraphClust pipeline for clustering similar RNA sequences together is a multi-step rather complex pipeline. Overall it consists of three major phases: a) sequence based pre-clustering b) encoding predicted RNA structures as graph features c) iterative fast candidate clustering then refinement

<!-- ![GraphClust pipeline overview (Heyne et al. 2012)](./assets/img/graphclust_pipeline.png)

*GraphClust pipeline overview (Heyne et al. 2012)*
 -->
![GraphClust-2 workflow overview](https://github.com/BackofenLab/GraphClust-2/blob/master/assets/img/figure-pipeline_zigzag.png)

Below is a coarse-grained correspondence list of GraphClust2 tool names with each step:

|   Stage  | Galaxy Tool Name | Description|
| :--------------------: | :--------------- | :----------------|
|1 | [Preprocessing](https://graphclust.usegalaxy.eu/root?tool_id=toolshed.g2.bx.psu.edu/repos/rnateam/graphclust_preprocessing/preproc/0.5){:target="_top"} | Input preprocessing (fragmentation)|
|2 | [fasta_to_gspan](https://graphclust.usegalaxy.eu/root?tool_id=toolshed.g2.bx.psu.edu/repos/rnateam/graphclust_fasta_to_gspan/gspan/0.4){:target="_top"} | Generation of structures via RNAshapes and conversion into graphs|
|3 | [NSPDK_sparseVect](https://graphclust.usegalaxy.eu/root?tool_id=toolshed.g2.bx.psu.edu/repos/rnateam/graphclust_nspdk/nspdk_sparse/9.2.3){:target="_top"} | Generation of graph features via NSPDK |
|4| [NSPDK_candidateClusters](https://graphclust.usegalaxy.eu/root?tool_id=toolshed.g2.bx.psu.edu/repos/rnateam/graphclust_nspdk/NSPDK_candidateClust/9.2.3){:target="_top"} | min-hash based clustering of all feature vectors, output top dense candidate clusters|
|5| [PGMA_locarna](https://graphclust.usegalaxy.eu/?tool_id=toolshed.g2.bx.psu.edu/repos/rnateam/graphclust_prepocessing_for_mlocarna/preMloc/0.4){:target="_top"},[locarna](https://graphclust.usegalaxy.eu/tool_runner?tool_id=toolshed.g2.bx.psu.edu/repos/rnateam/graphclust_mlocarna/locarna_best_subtree/0.4){:target="_top"}, [CMfinder](https://graphclust.usegalaxy.eu/?tool_id=toolshed.g2.bx.psu.edu/repos/rnateam/graphclust_cmfinder/cmFinder/0.4){:target="_top"} | Locarna based clustering of each candidate cluster, all-vs-all pairwise alignments, create multiple alignments along guide tree, select best subtree, and refine alignment.|
|6| [Build covariance models](https://graphclust.usegalaxy.eu/root?tool_id=toolshed.g2.bx.psu.edu/repos/bgruening/infernal/infernal_cmbuild/<IP_ADDRESS>){:target="_top"} |  create candidate model |
|7| [Search covariance models](https://graphclust.usegalaxy.eu/root?tool_id=toolshed.g2.bx.psu.edu/repos/bgruening/infernal/infernal_cmsearch/<IP_ADDRESS>){:target="_top"} | Scan full input sequences with Infernal's cmsearch to find missing cluster members |
|8,9| [Report results](https://graphclust.usegalaxy.eu/?tool_id=toolshed.g2.bx.psu.edu/repos/rnateam/graphclust_postprocessing/glob_report/0.5) and [conservation evaluations](https://graphclust.usegalaxy.eu/?tool_id=toolshed.g2.bx.psu.edu/repos/rnateam%2Fgraphclust_aggregate_alignments/graphclust_aggregate_alignments/0.1) | Collect final clusters and create example alignments of top cluster members|
{: .table.table-striped}

### Input:
The input to the workflow is a set of putative RNA sequences in FASTA format. Inside the `sample_data` directory you can find examples of the input format. In this case the data is from a benchmark set based on Rfam 12.0 and additionally is optionally labeled with reference Rfam family members.

### Configuring the workflows:
Please proceed with the interactive tour named `GraphClust workflow step by step`, available under `Help->Interactive Tours`
Check FAQs for understanding the frequently important parameters.

### Output:
The output contains the predicted clusters, where similar putative input RNA sequences form a cluster. Additionally overall status of the clusters and the matching of cluster elements is reported for each cluster.

Please check the interactive tours and GraphClust [README](http://www.bioinf.uni-freiburg.de/Software/GraphClust/README) for more information about the reported info and files.

# Support & Bug Reports

You can file an [github issue](https://github.com/BackofenLab/docker-galaxy-graphclust/issues) or ask us on the [Galaxy development list](http://lists.bx.psu.edu/listinfo/galaxy-dev).

# References

{% bibliography --cited --prefix index-metagenomics --group_by none %}

repository: nsoranzo/website

repo_name: nsoranzo/website


text:
# k8s-coredump-detector

----

 K8s-coredump-detector is an open source tool for managing core dump feature in kubernetes.
 It enables stable, controllable core dump feature when jobs inside k8s containers were crashed.
 This feature mainly generate, store, distribute core files which generated by the apps inside pods,
 it could ease investigation of crashed application in multi-tenancy k8s environment. And tenant
 could download this core files like they are using any other original k8s functions.

----
## Motivation and Goals

As we know, bugs are inevitable in software development, some bugs could be solved by investigating app logs, but some serious bugs like deep null point exception is very hard to debug without core files.However, Kubernetes has no mechanism to manage core files when job inside pods crashed.

This feature mainly collects, stores, distributes core files which generated by the apps inside pods. It supports any filesystem storage as backend storage, and it embeds the K8s' own authorization mechanism like RBAC to control tenant authorities. Tenants could download those core files they want like they are using any other original K8s resources.

## Design

### Components

#### Backend storage

The bakcend storage is an independent filesystem storage to store core files. This storage could be either ceph filesystem storage,
nfs storage or any other filesystem storage.
For test purpose, you can also use local host[https://kubernetes.io/docs/concepts/storage/volumes/#hostpath] storage to store core files.

#### Coredump DaemonSet

To control core files generation behavior, a DaemonSet is necessary which would launch each node an Admin-Pod. Those pods make sure everything will go as we expected when job crashed in other work pods. Each Pod will execute following steps:

a. Copy a exectuable file called "kcdt" to host, it is a coredump handler and will be invoked when any process crashed in that host. It will distinguish if the crashed job was from a Pod. If so, it collects related information and stores the core files to backend storage.

b. Modify && maintain `core_pattern` settings on each node which usually exist as a file located in `/proc/sys/kernel/core_pattern`. This setting is for control the behavior when process crashed. In our case, the Admin-Pod will modify it so the handler will be invoked.

For detail information, please see https://github.com/fenggw-fnst/coredump-node-detector

#### Coredump Apiserver

This component is the bridge between backend storge and users. In nature it is a [aggregation api layer](https://kubernetes.io/docs/concepts/extend-kubernetes/api-extension/apiserver-aggregation/) which is an offical mechanism to implement users’ own business logical. It contains service, self-defined api-server running in Pod and etcd storage. It will register APIs and Objects to k8s cluster. Users should download core files by those APIs and Objects.

| Group                | Version  | Kind             | Subresource |
|----------------------|----------|------------------|-------------|
| coredump.fujitsu.com | v1alpha1 | CoredumpEndpoint | dump        |

Before downloading core files, there must be a coredumpendpoint associated to the Pod where core dump occured. The coredumpendpoint can be automatically created by setting label `coredumpendpoint: auto` to the Pod, also can be manually created via yaml file (See [coredumpendpoint_template.yaml](test/coredumpendpoint_template.yaml)).

For a typical case, user wants to download all core files generated by the container `test-container` of a Pod through the associated coredumpendpoint `test-coredumpendpoint` in namespace `test-namespace`, user should do like this:

```
kubectl get --raw=/apis/coredump.fujitsu.com/v1alpha1/namespaces/test-namespace/coredumpendpoints/test-coredumpendpoint/dump?container=test-container>coredump.tar.gz

tar -zxvf coredump.tar.gz -C ./coredump-files
```

If everyting works as expected, user could observe all core files in coredump-files.

### Flow

#### Core file generation

The core file generation part generates core files when job inside containers crashed. In each node that supports core dump feature,
 a Admin-Pod will be deployed by DaemonSet to handle this job. Each Admin-Pod inject an executable file  called handler into node,
 it also modifies[core-pattern] to let kernel call that handler to store core files into backend storage.

#### Downloding core files

An aggregation api layer will register a self-defined API called `coredump.fujitsu.com`. This api is a bridge between backend storage
 and users. User could download core files by this api. Admin can control users' access to core files by native way like RBAC, ABAC.

### Warning

The `core_pattern` would be modified to let our components handle core dump events.

The k8s cluster must boot with `allow-privileged` option enabled.

## Deployment

### From script

Please See [deploy.md](deploy/deploy.md)

### From source code

TBD

### Test

After deploying all the components successfully, you could test the function is working by [test script](test/run-test.sh)

## Download core files

This section gives examples of how to download coredump files. The [coredumpendpoint_template.yaml](test/coredumpendpoint_template.yaml) file under test floder will be used.

Suppose we want to download core files dumped by a container called `test-container` in Pod `default/test-pod` with the Pod uid is `1234-5678`, then we need two steps:

Firstly, make sure there is a coredumpendpoint associated with the Pod, suppose it is called `test-coredumpendpoint`.
If it has already been automatically created, then we just goto step two, otherwise we need create it manually:
```
cat test/coredumpendpoint_template.yaml | sed "s/__NAMESPACE__/default/g" | sed "s/__CNAME__/test-coredumpendpoint/g" | sed "s/__PNAME__/test-pod/g" | sed "s/__UID__/1234-5678/g" | kubectl create -f -
```
Note: If the Pod still exists, then it is not necessary to provide `poduid`, it can be retrieved by `podname` when creating.

Secondly, download the core files:
```
kubectl get --raw=/apis/coredump.fujitsu.com/v1alpha1/namespaces/default/coredumpendpoints/test-coredumpendpoint/dump?container=test-container>coredump.tar.gz
```


text:
# Java Quicksort
Quicksort algorithm optimized implementation in Java and performance comparison with Java utils Collections.sort().

Exercise of Java programming with generics, trying to get a high performance implementation of the quicksort algorithm for lists with some tests and comparisons with the default Collections.sort() method.

## Some comparisons
### Integers

	Statistics on 100000 sorts of lists of 1000 random Integer
	Collections	avg : 0.0915174 ms	 Std Deviation: 2.52494e-05 ms
	QuickSort	avg : 0.0783190 ms	 Std Deviation: 0.000146805 ms

	Statistics on 1000 sorts of lists of 100000 random Integer
	Collections	avg : 15.6007 ms	 Std Deviation: 0.00275111 ms
	QuickSort	avg : 13.6509 ms	 Std Deviation: 0.0166620 ms

	Statistics on 100 sorts of lists of 1000000 random Integer
	Collections	avg : 239.706 ms	 Std Deviation: 1.72933 ms
	QuickSort	avg : 215.788 ms	 Std Deviation: 1.90205 ms

### Doubles

	Statistics on 100000 sorts of lists of 1000 random Double
	Collections	avg : 0.0966663 ms	 Std Deviation: 1.15717e-05 ms
	QuickSort	avg : 0.0774790 ms	 Std Deviation: 5.23372e-06 ms

	Statistics on 1000 sorts of lists of 100000 random Double
	Collections	avg : 16.3122 ms	 Std Deviation: 0.0161096 ms
	QuickSort	avg : 14.3338 ms	 Std Deviation: 0.0156966 ms

	Statistics on 100 sorts of lists of 1000000 random Double
	Collections	avg : 280.959 ms	 Std Deviation: 2.09132 ms
	QuickSort	avg : 247.493 ms	 Std Deviation: 1.72578 ms

## Strings
Testing with Strings of 250 random chars

	Statistics on 1000 sorts of lists of 1000 random String
	Collections	avg : 0.157401 ms	 Std Deviation: 0.000823811 ms
	QuickSort	avg : 0.158797 ms	 Std Deviation: 0.000390629 ms

	Statistics on 1000 sorts of lists of 10000 random String
	Collections	avg : 2.23195 ms	 Std Deviation: 0.00493961 ms
	QuickSort	avg : 2.55720 ms	 Std Deviation: 0.0100697 ms

	Statistics on 100 sorts of lists of 100000 random String
	Collections	avg : 42.8703 ms	 Std Deviation: 0.697318 ms
	QuickSort	avg : 40.7592 ms	 Std Deviation: 0.0938920 ms

repository: glumia/JavaQuicksort

repo_name: glumia/JavaQuicksort


text:
# muCNV

Multi-sample SV genotyper for large-scale WGS data

Version 1.0.0
Last edited: July 9, 2020, (c) Goo Jun

muCNV uses multiple steps for multi-sample SV genotyping, to handle large number of samples and to enable efficient parallelization:

0. Generate binary interval file from input VCF
1. Generate *pileups* from CRAM/BAM files using candidate list of SVs
2. Merge individual pileups to generate 'merged' pileups
3. Multi-sample genotyping from merged pileups

* The 'merging' step is optional, but is recommended for ~ >500 samples.
* By default, merging will create pileups separated by chromosomes.
* When genotyping merged pileups, do not add 'chr' postfixes in your 'list' file

## Installation
Required: g++ compiler environment and HTSlib (https://github.com/samtools/htslib).
If HTSlib is not installed system-wide, please manually add -I(HTSlib include directory) and -L(HISlib library directory) to Makefile.
```
$ make
```

To test,
```
$ bin/muCNV
```
You can copy muCNV binary to one of your $PATH locations (e.g. /usr/local/bin).

## Basis usage:
```
$ mucnv [command] [options]
$ mucnv [command] --help
```

# Use-case Example
0. Process reference file for GC-content indexing
Fasta file should also have .fai file in the same path. (If not, run samtools faidx)
Pre-generated files for GRCh37 and GRCh38 exist under resource/ directory.
```
$ muCNV gcidx -f [path_to_fasta] -o [output_gcidx_filename]
```

1. Input files
- BAM or CRAM files
```
sample1.cram
sample2.cram
sample3.cram
...
sample10.cram
```
- VCF file containing candidate SV variants
```
candidate_sv.vcf
```

2. Generate 'interval' file from VCF
```
$ muCNV vcf2int -v candidate_sv.vcf -i candidate_sv.interavls
```

3. Generate pileup from each CRAM file
Assuming muCNV source directory is at /home/user1/muCNV and pileup files are being created under $(pwd)/pileup
```
$ mkdir pileup
$ muCNV pileup -s sample1 -V candiate_sv.intervals -f /home/user1/muCNV/resource/GRCh38.v3.gc -o pileup/sample1
$ muCNV pileup -s sample2 -V candiate_sv.intervals -f /home/user1/muCNV/resource/GRCh38.v3.gc -o pileup/sample2
...
$ muCNV pileup -s sample10 -V candiate_sv.intervals -f /home/user1/muCNV/resource/GRCh38.v3.gc -o pileup/sample10
```
You can simplify/parallelize pileup step by using GNU Parallel or GNU Make.

4. Genotype candidate SVs from pileup data
Make a text file containing the base names of each pileup file, say, pileup.list
```
$ cat pileup.list
pileup/sample1
pileup/sample2
...
pileup/sample10
```
Then run genotyping step to create the output file, genotyped.vcf:
```
$ muCNV genotype -V candidate_sv.intervals -i pileup.list -o genotyped.vcf -f /home/user1/muCNV/resource/GRCh38.v3.gc
```

# Commands in more details
## Generating variant list from input VCF
```
$ muCNV vcf2int -v <VCF> -i <interval file> -p

-i, --interval
  Name of the interval file to be created

-v, --vcf
  Name of the input VCF file

-p, --print
  Optional flag to print out list of SVs to stdout
```
## Pileup
```
$ muCNV pileup -s <sample ID> -v <VCF> -V <Interval> -f <GRCh file> -b <BAM/CRAM file> -o <output prefix>

   -o <string>,  --outdir <string>
     Output directory, current directory if omitted

   -s <string>,  --sample <string>
     (required)  Sample ID, also used for output filenames (.pileup, .var,
     .idx)

   -f <string>,  --gcFile <string>
     File containing GC content information (default: GRCh38.gc)

   -V <string>,  --interVal <string>
     Binary interval file containing candidate SVs

   -v <string>,  --vcf <string>
     VCF file containing candidate SVs

   -b <string>,  --bam <string>
     (required)  Input BAM/CRAM file name
```

 - GC content file for human reference genome build 38 is provided in resources/GRCh38.v3.gc
 - Either VCF file (-v) or binary interval file (-V) is required

## Merge
```
$ muCNV merge -I [input.list] -o [output_name] -f GRCh38.gc

   -V <string>,  --interVal <string>
     (required)  Binary interval file containing candidate SVs

   -o <string>,  --output <string>
     (required)  Output base filename for merged pileup

   -i <string>,  --index <string>
     (required)  Text file containing list of pileup samples

   -f <string>,  --gcFile <string>
     (required)  File containing GC content information
```

## Genotype
```
$ muCNV genotype [-i <string>] [-f <string>] [-V <string>] [-v <string>] [-o <string>] [-l] [-n <integer-integer>]

   -p <number(0-1.0)>,  --pmax <number(0-1.0)>
     Maximum overlap between depth clusters

   -x <string>,  --exclude <string>
     List of sample IDs to be excluded from genotyping

   -n <integer-integer>,  --numbers <integer-integer>
     variants in range (from-to) only from the binary SV index file

   -r <chr:startpos-endpos>,  --region <chr:startpos-endpos>
     Genotype specific genomic region

   -c <integer (1-24)>,  --chr <integer (1-24)>
     Chromosome number (1-24) if pileup contains only a single chromosome (default for merged)

   -i <string>,  --index <string>
     Text file containing list of pileups (required)

   -f <string>,  --gcFile <string>
     File containing GC content information

   -V <string>,  --interVal <string>
     Binary interval file containing candidate SVs

   -v <string>,  --vcf <string>
     VCF file containing candidate SVs

   -o <string>,  --out <string>
     Output filename

   -l,  --lessheader
     Do not print header in genoptyed VCF

   -a,  --all
     Include all variants that failed genotyping in the output VCF
```
 - GC content file for human reference genome build 38 is provided in resources/GRCh38.v3.gc
 - Either VCF file (-v) or binary interval file (-V) is required
 - GRCh38 and Interval file should be the same to the ones used for pileup and merging

repository: gjun/muCNV

repo_name: gjun/muCNV


text:
# Language Server Clients

This directory contains LS clients for IDEs that
will work with the AWS Documents Language Server.

This will enable you to easily test changes to the
language server as if it were an extension.

## Jetbrains

To setup the jetbrains sample client you must update LspPreloadingActivity to point to the server.js file from the server.

repository: aws/aws-toolkit-common

branch_name: refs/heads/main

gha_language: C#

repo_name: aws/aws-toolkit-common


text:
**PROJECT TITLE**

The project title should be "Name of the Algorithm" or "Name of the Tutorial you'll showcasing about

**GOAL**

Write the main goal of this project and what's the purpose of it

**PURPOSE**

What's the purpose of this "Title Taken"

**DATASET** (if applicable)

Add a link to dataset and from where it's taken.

**DESCRIPTION**

Short description about the idea and approach you had gone with

**WHAT I HAD DONE**

What have you worked on for this issue should be stated using points.

**WORKFLOW OF YOUR PROJECT FILES**

Add the workflow of the script point by point to get good understanding of the concept

**DIAGRAMS**

Showcase various diagrams or flowcharts to get good understanding of this concept in an explanatory manner. Visual reprsentations makes things more clear.

Why had you choose this approach and what is your understanding from your work you had done.

What did you learn while working on this issue.

Why have you choosed this methodology should also be stated.

**DETAILED EXPLANATION OF SCRIPT, IF APPLICABLE**

Provide detailed explanation of the script in elaborative manner using points

**USAGE**

Why have you choosed this issue specifically should be stated

**USE CASES**

Explain few examples where this can work in an explanatory way to provide good efficiency and optimum results

**LIBRARIES USED**

Add all the libraries you had used to explain this concept

**ADVANTAGES**

Advantages of this issue for one to choose this concept

**DISADVANTAGES**

Disadvantages of this concept and where this can't be implied should be stated here

**APPLICATIONS**

List out all the applications where this concept can be useful

**RESEARCH**

Have you done any research on this issue, if so describe more on it

**SCREENSHOTS**

Add screenshots of the output or visualizations or anything related to your script to show it works

**CONCLUSION**

What's the conclusion of this concept. It should be clear and precise.
Also showcase the appropriate results derived if it's applicable. Be briefer.

**REFERENCES**

Add all the references you had referred to provide good understanding on this concept.
Add all the references beginner should refer to clear their concepts.

**YOUR NAME**

Add your full name, also can add your social media links if any.

**DISCLAIMER, IF ANY**

Use this section to mention if any particular disclaimer is required


text:
   - A newsletter service

[![Github](https://img.shields.io/github/stars/ckbhatia/ck_newsletter?style=social)]

This service aims to aid small and mid-sized bloggers to automate the process of delivering newsletters to subscribers. Blogger needs to hook two requests to their blog code and focus on writing amazing blogs. Your subscribers are going to receive the newsletters when you publish a new.

This is a BE repo of the Ck newsletter project. Front End repo: https://github.com/Ckbhatia/ck_newsletter_front_end

## Table of contents:

- How to create an account?
- How to create a project?
- How to activate newsletter service?
- Set-up the subscribe.
- Set-up the push newsletters.

### How to create an account?

1. Open the cknewsletter.herokuapp.com
2. Sign up with your email account.

### How to create a project?

1. Sign In with your account credentials.
2. Click on new to create a new project.

3. Fill details about your project.

   - Optionally, you can set-up your custom ( HTML ) newsletter template.

4. Submit it.

### How to activate newsletter service?

These email credentials will be used to send newsletters to your subscribers.

1. You need to go to the profile page.
2. Put your email and password credential to the relative input fields.
3. Select your email service.

4. Save it.

### Set-up the subscribe!

1. Create a fetch request with PATCH method.
2. Need to put two properties into the payload ( body ).
```
  {
   "subscriber"<EMAIL_ADDRESS>   "apiKey": "15870449476249g9uo****"
  }
```

   - The subscriber should be dynamic. It should be your subscriber's email.
   - The apiKey should be your project's API Key.

3. Now you can make a patch request with these data on this endpoint: https://cknewsletter.herokuapp.com/api/v1/projects/subscribe
4. Your subscribers will be stored in this project's data.
5. Place this code in your blog's code where it will be invoked whenever your user submit the subscribe form.

### Set-up the push newsletters!

1. Create a fetch request with PATCH method.
2. Need to put two properties into the payload ( body ).

```
  {
    "slug": "get-started-with-vue",
    "apiKey": "15870449476249g9uo\*\*\*\*"
  }
```

   - Replace the apiKey with your project's API key.
   - Slug should be dynamic. Your article slug or id should be the value of slug key.

3. Notice that your slug will be used to create the link to your article. For Ex: "https://myblog.com/blog/get-started-with-vue"
4. Now you can make a patch request with these data on this endpoint: https://cknewsletter.herokuapp.com/api/v1/projects/slug
5. Place this patch request code to your blog code where it makes this request every time whenever you publish a new article.
6. It will push the newsletter to your subscribers of particular project.

**Voila, You are done now. Now write the best and keep your subscribers in sync with your latest articles.**

## Support

Feel free to reach out to me on<EMAIL_ADDRESS>
# License

This project is **MIT licensed** unless otherwise specified.


text:
[![Follow on Twitter](https://img.shields.io/twitter/follow/opendevsecops.svg?logo=twitter)](https://twitter.com/opendevsecops)
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/5815b10c6daf46b0a3e6606ce812898e)](https://www.codacy.com/app/OpenDevSecOps/terraform-aws-scanner?utm_source=github.com&utm_medium=referral&utm_content=opendevsecops/terraform-aws-scanner&utm_campaign=Badge_Grade)

# AWS Scanner Terraform Module

This terraform module provides easy to configure AWS environment for running automated security scanning solutions at scheduled intervals. You configure it. AWS will run it at minimal cost.

Running various types of scanners as part of your DevOps process is esential to keep on top of vulnerabilities. Ofthen this task is perfect by standalone tools such as Nessus, Nexpose, OpenVAS or even Qualys. However, all of these tools have their own blindspots and are not very DevOps-friendly. This module provides you a good starting point to improve your automated scanning infrastructure once and for all.

## Getting Started

Getting started is easy. All resources such as the designated ECS cluster, VPCs, and task definitions are provisioned out of the box. Here is a complete example how to setup the Cohesion web security scanner:

```terraform
module "scanner" {
  source = "opendevsecops/scanner/aws"
}

module "scanner_cohesion" {
  source = "opendevsecops/scanner/aws//modules/cohesion"

  schedule = "rate(24 hours)"

  target = "http://target"

  trigger_arn = "${module.scanner.trigger_arn}"
}
```

Scanners outputs are available in the designated CloudWatch groups.

This module is automatically published to the Terraform Module Registry. More information about the available inputs, outputs, dependencies, and instructions on how to use the module can be found at the official page [here](https://registry.terraform.io/modules/opendevsecops/scanner).

## Supported Scanners

The following scanners are currently supported. More scanners can be easily added as long as they are packaged as docker containers:

  * Cohesion - Dynamic Web Application Security Scanner
  * Pown - Offensive security tooling
  * WPScan - Wordpress Security Scanner
  * Nmap - Network Security Scanner
  * GitLeaks - Git Security Scanner
  * Amass - Domain Enumeration
  * Nikto - Web Application Security Scanner

### Cohesion

  * Image: https://github.com/opendevsecops/docker-cohesion
  * URL: https://secapps.com/cohesion
  * Default CloudWatch LogGroup: /ecs/opendevsecops_scanner_cohesion

```
module "scanner_cohesion" {
  source = "opendevsecops/scanner/aws//modules/cohesion"

  schedule = "rate(24 hours)"

  target = "http://target"

  trigger_arn = "${module.scanner.trigger_arn}"
}
```

### Pown

  * Image: https://github.com/opendevsecops/docker-pown
  * URL: https://pownjs.com
  * Default CloudWatch LogGroup: /ecs/opendevsecops_scanner_pown

```
module "scanner_pown" {
  source = "opendevsecops/scanner/aws//modules/pown"

  schedule = "rate(24 hours)"

  args = ["recon", "transform", "ghlm", "target"]

  trigger_arn = "${module.scanner.trigger_arn}"
}
```

### WPScan

  * Image: https://github.com/opendevsecops/docker-wpscan
  * URL: https://wpscan.org
  * Default CloudWatch LogGroup: /ecs/opendevsecops_scanner_wpscan

```
module "scanner_wpscan" {
  source = "opendevsecops/scanner/aws//modules/wpscan"

  schedule = "rate(24 hours)"

  target = "http://target"

  trigger_arn = "${module.scanner.trigger_arn}"
}
```

### Nmap

  * Image: https://github.com/opendevsecops/docker-nmap
  * URL: https://nmap.org
  * Default CloudWatch LogGroup: /ecs/opendevsecops_scanner_nmap

```
module "scanner_nmap" {
  source = "opendevsecops/scanner/aws//modules/nmap"

  schedule = "rate(24 hours)"

  target = "<IP_ADDRESS>/24"
  flags = ["-sS"]

  trigger_arn = "${module.scanner.trigger_arn}"
}
```

### GitLeaks

  * Image: https://github.com/opendevsecops/docker-gitleaks
  * URL: https://github.com/zricethezav/gitleaks
  * Default CloudWatch LogGroup: /ecs/opendevsecops_scanner_gitleaks

```
module "scanner_gitleaks" {
  source = "opendevsecops/scanner/aws//modules/gitleaks"

  schedule = "rate(24 hours)"

  target = "https://github.com/target/target.git"

  trigger_arn = "${module.scanner.trigger_arn}"
}
```

### Amass

  * Image: https://github.com/opendevsecops/docker-amass
  * URL: https://github.com/caffix/amass
  * Default CloudWatch LogGroup: /ecs/opendevsecops_scanner_amass

```
module "scanner_amass" {
  source = "opendevsecops/scanner/aws//modules/amass"

  schedule = "rate(24 hours)"

  target = "target"

  trigger_arn = "${module.scanner.trigger_arn}"
}
```

### Nikto

  * Image: https://github.com/opendevsecops/docker-nikto
  * URL: https://github.com/sullo/nikto
  * Default CloudWatch LogGroup: /ecs/opendevsecops_scanner_nikto

```
module "scanner_nikto" {
  source = "opendevsecops/scanner/aws//modules/nikto"

  schedule = "rate(24 hours)"

  target = "target"

  trigger_arn = "${module.scanner.trigger_arn}"
}
```

## Contribute

Fork the project. Create a scanner definition in the modules subfolder. Use Cohesion, Nmap or any other scanner as an example. Once you are happy with your changes, create a pull request. We will review and if the submissison is good we will accept it as part of the official module distribution.


text:
A simple RPC-over-WebSockets server

## Installation

    npm i rpc-over-ws

## Usage

    require('rpc-over-ws')({
      greet: function ({name}) {
        return new Promise(resolve => resolve(`Hello, ${name || 'anon'}`))
      }
    })

---

    $ wscat -c ws://localhost:8080
    > {"id": 0, "rpc": "greet", "args": { "name": "brian" } }
    < {"id":0,"rpc":"greet","result":"Hello, brian"}

## API

    const createServer = require('rpc-over-ws')

    const { server, emitter, clients } = createServer(handlers, options)

      handlers = {
        $rpc: function (args, { server, clients, id, rpc }) -> Promise<result>
      }

      options = {
        port: int,            default: 8080
        pingTimeout: int,     default: 29000
        maxPings: int         default: 3
      }

"this" to a handler is the client WebSocket making the request.

If you wish to lookup other connected clients by some identifier,
set `this.clientId` to something unique in one of your handlers
and the client will be tracked in `clients`.

"result" must be encodable as JSON.

## Events

- 'server-ready' (server)
- 'server-error' (error))
- 'client-connect' (client)
- 'client-disconnect' (client)
- 'client-protocol-error' (client, error)
- 'client-raw-message' (client, message)
- 'client-io-error' (client, error)
- 'client-identity' (client, clientId)

## Protocol

Clients send JSON-encoded text frames of the form:

    { id: any, rpc: string, args: any }

The client creates the request `id`.

---

The request is routed to a handler.

---

The client is sent

    { id: same, rpc: same, result: any }

or

    { id: same, rpc: same, error: string }

The server matches the same request `id` so the client
can route the result/error to a client-local callback.

repository: fictorial/rpc-over-ws

repo_name: fictorial/rpc-over-ws


text:
# Extract images from a pdf

This package provides a class to extract images from a pdf.

```php
use Viterbit\PdfImagesExtractor\Pdf;

$images = Pdf::getImages('book.pdf'); //returns a FilesystemIterator
```

## Requirements

Behind the scenes this package leverages [pdfimages](https://en.wikipedia.org/wiki/Pdfimages). You can verify if the binary installed on your system by issuing this command:

```bash
which pdfimages
```

If it is installed it will return the path to the binary.

To install the binary you can use this command on Ubuntu or Debian:

```bash
apt-get install poppler-utils
```

On a mac you can install the binary using brew

```bash
brew install poppler
```

If you're on RedHat or CentOS use this:

```bash
yum install poppler-utils
```

## Installation

You can install the package via composer:

```bash
composer viterbit/pdfimages-extractor
```

## Usage

Getting images from a pdf is easy.

```php
$images = (new Pdf())
    ->setPdf('book.pdf')
    ->images();
```

Or easier:

```php
$images = Pdf::getImages('book.pdf');
```

By default the package will assume that the `pdftoimages` command is located at `/usr/bin/pdftoimages`.
If it is located elsewhere pass its binary path to constructor

```php
$images = (new Pdf('/custom/path/to/pdftoimages'))
    ->setPdf('book.pdf')
    ->images();
```

or as the second parameter to the `getImages` static method:

```php
echo Pdf::getText('book.pdf', '/custom/path/to/pdftoimages');
```

Sometimes you may want to use [pdfimages options](https://linux.die.net/man/1/pdfimages). To do so you can set them up using the `setOptions` method.

```php
$images = (new Pdf())
    ->setPdf('book.pdf')
    ->setOptions(['j', 'f 1'])
    ->images()
;
```

or as the third parameter to the `getImages` static method:

```php
$images = Pdf::getImages('book.pdf', null, ['j', 'f 1']);
```

Please note that successive calls to `setOptions()` will overwrite options passed in during previous calls.

If you need to make multiple calls to add options (for example if you need to pass in default options when creating
the `Pdf` object from a container, and then add context-specific options elsewhere), you can use the `addOptions()` method:

 ```php
$images = (new Pdf())
     ->setPdf('book.pdf')
     ->addOptions(['f 1'])
     ->images()
 ;
 ```

## Change log

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

## Contributing

Please see [CONTRIBUTING](CONTRIBUTING.md) for details.

## Security

If you discover any security related issues, please email<EMAIL_ADDRESS>instead of using the issue tracker.
design agency based in Antwerp, Belgium. You'll find an overview of all our open source projects [on our website](https://spatie.be/opensource).

## License

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

repository: viterbit/pdfimages-extractor

repo_name: viterbit/pdfimages-extractor


text:
# Task-Equivariant Graph Few-shot Learning

```
@inproceedings{teg_kdd23,
title = {Task-Equivariant Graph Few-shot Learning},
author = {Kim, Sungwon and Lee, Junseok and Lee, Namkyeong and Kim, Wonjoong and Choi, Seungyoon and Park, Chanyoung},
booktitle = {Proceedings of the 29th ACM SIGKDD Conference on Knowledge Discovery and Data Mining (KDD)},
pages = {1120--1131},
year = {2023}
}
```

links
- [acm](https://dl.acm.org/doi/10.1145/3580305.3599515)

gha_language: Jupyter Notebook


text:
# CRTS

The Cognitive Radio Test System (CRTS) provides a framework for software
defined radios (SDRs) with interfaces from the web.

# Development Status

This software package is not ready for general public use.

## Ports

Currently developing on:
  - Debian GNU/Linux 9.3 (stretch)
  - Ubuntu 16.04, 18.04

## Dependencies

```
apt install libjansson libreadline-dev dia
```

See README in dependencies/ subdirectory.  Installing the dependencies is
more involved than installing CRTS, so we provide a separate dependencies
directory.

If you are using this source code from a git repository there is a git
submodule, webtop, https://github.com/vtwireless/webtop.git, that is
software depends on.  Webtop can be downloaded by running the included
*bootstrap* script.

## Building and Installing CRTS (this package)

Then run
```
  ./bootstrap
  ./configure --prefix /usr/local/my_CRTS
  make
  make install
```

where you pick a better prefix than */usr/local/my_CRTS*.

Running *./configure* will generate the file *config.make*,
you can edit this file, uncomment some make build options.

## "make download" for code re-usability

Not unique to CRTS, we introduce the idea of downloading all the files
needed, before starting to build the software, so we have a "download"
make target as in running *make download* as you'll see below.

Currently the *bootstrap* script will run *make download* which
does not require configuration.

## TODO

- Add --add_directory as option to bin/crts_contestWebServer to add
  a static files to the we server.  It would make it so that there is
  effectively a symlink to a directory from the htdocs/ servers static
  root directory; so  for example:
  ```
    crts_contestWebServer --add_directory my_demo
  ```
  would add the directory my_demo to URLs like
  *https://servername.com/my_demo/*
  to the server that it runs.  The files in my_demo/ can then
  access all the files in the document root with a relative path
  in URLs in the files in my_demo/.  Currently we are using symlinks
  in htdocs/ to do this.

## Up grading Firmware and FPGA Images with Pre-built Images

With a browser go to relative to your UHD installation prefix
installation directory, UHD_PREFIX

```
  $UHD_PREFIX/share/doc/uhd/doxygen/html/page_images.html
```

Download files by running:

```
  $UHD_PREFIX/bin/uhd_images_downloader
```

This will download files to:
```
  $UHD_PREFIX/share/uhd/images/
```

Read some more on the web pages.  In my case I had a USRP N210 and I ran:
```
  uhd_image_loader --args="type=usrp2,addr=<IP_ADDRESS>"
```

In my case the output on the terminal where I ran that was:
```
[INFO] [UHD] linux; GNU C++ version 6.3.0 20170516; Boost_106200; UHD_<IP_ADDRESS>-0-4e672fab
Unit: USRP N210 r4 (F44901, <IP_ADDRESS>)
Firmware image: /usr/local/encap/uhd/share/uhd/images/usrp_n210_fw.bin
-- Erasing firmware image...successful.
-- Writing firmware image...successful.
-- Verifying firmware image...successful.
FPGA image: /usr/local/encap/uhd/share/uhd/images/usrp_n210_r4_fpga.bin
-- Erasing FPGA image...successful.
-- Writing FPGA image...successful.
-- Verifying FPGA image...successful.
```

For the X310

$UHD_PREFIX/utils/uhd_images_downloader.py

$UHD_PREFIX/bin/uhd_image_loader" --args="type=x300,addr=<IP_ADDRESS>"

For USB USRP devices
https://files.ettus.com/manual/page_transport.html#transport_usb_udev

## Development notes

If you are developing using a git repository, run

*git add htdocs/webtop && git commit -m "upgraded version of webtop"*

to upgrade the webtop git submodule to your current checkout of
crts.

### on git submodules
How can I specify a branch/tag when adding a Git submodule?
https://stackoverflow.com/questions/1777854/how-can-i-specify-a-branch-tag-when-adding-a-git-submodule

If you want to move the submodule to a particular tag:
```
  cd submodule_directory
  git checkout v1.0
  cd ..
  git add submodule_directory
  git commit -m "moved submodule to v1.0"
  git push
```
Then, another developer who wants to have submodule_directory changed to that tag, does this
```
  git pull
  git submodule update --init
```

repository: vtwireless/crts

repo_name: vtwireless/crts


text:
# cri-tools

CLI and validation tools for Kubelet Container Runtime Interface (CRI) .

[![Build Status](https://travis-ci.org/kubernetes-incubator/cri-tools.svg?branch=master&maxAge=2592000)](https://travis-ci.org/kubernetes-incubator/cri-tools)
[![Go Report Card](https://goreportcard.com/badge/github.com/kubernetes-incubator/cri-tools)](https://goreportcard.com/report/github.com/kubernetes-incubator/cri-tools)

## What is the scope of this project?

cri-tools aims to provide a series of debugging and validation tools for Kubelet CRI, which includes:

- crictl: CLI for kubelet CRI.
- critest: validation test suites for kubelet CRI.

## What is not in scope for this project?

* Building a new kubelet container runtime based on CRI.
* Managing pods/containers for CRI-compatible runtimes by end-users, e.g. pods created by crictl may be removed automatically by kubelet because of non-exist on the kube-apiserver.

## Roadmap

* Basic sandbox/image/container lifecycle operations
* Handle streaming APIs (exec/attach/port-forwarding)
* Reading logs of containers.
* Validation test suites.

## Community, discussion, contribution, and support

Learn how to engage with the Kubernetes community on the [community page](http://kubernetes.io/community/).

You can reach the maintainers of this project at:

- Slack: #sig-node
- Mailing List: <https://groups.google.com/forum/#!forum/kubernetes-sig-node>

## Kubernetes Incubator

This is a [Kubernetes Incubator project](https://github.com/kubernetes/community/blob/master/incubator.md). The incubator team for the project is:

- Sponsor: Dawn Chen (@dchen1107)
- Champion: Yu-Ju Hong (@yujuhong)
- SIG: sig-node

### Code of conduct

Participation in the Kubernetes community is governed by the [Kubernetes Code of Conduct](code-of-conduct.md).

## Getting started

### Build cri-tools

```bash
go get github.com/kubernetes-incubator/cri-tools/cmd/critest
go get github.com/kubernetes-incubator/cri-tools/cmd/crictl
```

### critest

 Validation test suites for kubelet CRI

#### Commands

- `benchmark`,`b`:Benchmark test suite for CRI.

- `validation`,`v`:Validation test suite for CRI

#### Global flags

- `--runtime-endpoint`, `-r`:CRI runtime server endpoint. Default is /var/run/dockershim.sock.

- `--image-endpoint`, `-i`:CRI server image endpoint, default same as runtime endpoint.

- `--compile`, `-c`:If we don't need to build dependencies, we can add this flag `--compile=false` or `-c=false`.

- `--ginkgo-flags`,`-g`:Space-separated list of arguments to pass to Ginkgo test runner.

- `--focus`,`-f`:CRI test will only run the test that match the focus regular expression.

- `--skip`,`-s`:CRI test will not run the test that match the focus regular expression.

### crictl

CLI for kubelet CRI

#### Commands

- `info`: Get version information of runtime

- `sandbox`, `sb`: Manage lifecycle of podsandbox

- `container`, `ctr`:Manage lifecycle of container

- `status`:Get the status information of runtime

- `attach`:Attach a running container

- `image`:Manage image

- `exec`:Exec(exec, syncexec) a command in a running container

- `portforward`:Forword ports(localport:remoteport) from a sandbox

- `help`, `h`:Shows a list of commands or help for one command

#### Global flags

- `--config-file`:Config file (default: "`/etc/crictl.yaml`"). Overrided by flags or  environment variables.
```
# cat /etc/crictl.yaml
runtime-endpoint: /var/run/dockershim.sock
image-endpoint: /var/run/dockershim.sock
timeout: 10
debug: true
```

- `--runtime-endpoint`:CRI server runtime endpoint (default: "/var/run/dockershim.sock").The default server is dockershim. If we want to debug other CRI server such as frakti, we can add flag `--runtime-endpoint=/var/run/frakti.sock`

- `--image-endpoint`:CRI server image endpoint, default same as runtime endpoint.

- `--timeout`:Timeout of connecting to server (default: 10s)

- `--debug`:Enable debug output

- `--help`, `-h`:show help

- `--version`, `-v`:print the version information of crictl

#### Examples

- Run sandbox with config file

```
# cat sandbox-config.json
{
    "metadata": {
        "name": "nginx-sandbox",
        "namespace": "default",
        "attempt": 1,
        "uid": "hdishd83djaidwnduwk28bcsb"
    },
    "linux": {
    }
}
# crictl sandbox run sandbox-config.json
9b542bfe8f93eb2d726d0f7b619f253c18858006aa53023e392e138b0be6301c
```

- Create container in a sandbox with config file

```
# cat sandbox-config.json
{
    "metadata": {
        "name": "nginx-sandbox",
        "namespace": "default",
        "attempt": 1,
        "uid": "hdishd83djaidwnduwk28bcsb"
    },
    "linux": {
    }
}
# cat container-config.json
{
  "metadata": {
      "name": "busybox"
  },
  "image":{
      "image": "busybox"
  },
  "command": [
      "top"
  ],
  "linux": {
  }
}
# crictl container create 9b542bfe8f93eb2d726d0f7b619f253c18858006aa53023e392e138b0be6301c container-config.json sandbox-config.json
bf642f55ecf54345354a86a42c08fb0d66e55e90c855973495f31e991c2bf725
```

* Start container

```
# crictl container start bf642f55ecf54345354a86a42c08fb0d66e55e90c855973495f31e991c2bf725
bf642f55ecf54345354a86a42c08fb0d66e55e90c855973495f31e991c2bf725
```

* Exec a command in container

```
# crictl exec -i -t bf642f55ecf54345354a86a42c08fb0d66e55e90c855973495f31e991c2bf725 sh
```

repository: xlgao-zju/cri-tools

repo_name: xlgao-zju/cri-tools


text:
# Using a plugin

You can use a plugin by simply installing it using `npm`.

```sh
npm i @chitchatjs/plugin-ax-common
```

and then, importing it into the state where you want to add that experience in your skill.

```ts
import { common } from "@chitchatjs/plugin-ax-common";

let state1 = ax
  .state()
  .block(
    ax
      .compound()
      .add(ax.say("This is plugin usage example"))
      .add(common.defaultHandlers()) // from common plugin
      .build()
  )
  .build();
```

repository: chitchatjs/chitchatjs-docs

repo_name: chitchatjs/chitchatjs-docs


text:
# Range

A [Range](http://crystal-lang.org/api/Range.html) is typically constructed with a range literal:

```crystal
x..y  # an inclusive range, in mathematics: [x, y]
x...y # an exclusive range, in mathematics: [x, y)
```

An easy way to remember which one is inclusive and which one is exclusive it to think of the extra dot as if it pushes *y* further away, thus leaving it outside of the range.

repository: crystal-french/fr-crystal-book

gha_language: Shell

repo_name: crystal-french/fr-crystal-book


text:
# Update Portfolio 2

![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)

## Description

Updated portfolio featuring projects 1 and 2 and at least four exemplary homework assignments.

## Portfolio Screenshots:

![Portfolio Homepage](./assets/images/home.png)
![Portfolio Projects](./assets/images/portfolio.png)
![Portfolio Resume](./assets/images/resume.png)

## Contributing

https://github.com/cynmojica1231/updatedportfolio2

## License

This project is licensed under the MIT license.


text:
---
layout: page
title: "Presentations"
comments: yes
---

## Contents
{:.no_toc}

* Will be replaced with the ToC, excluding the "Contents" header
{:toc}

### 2015

* **International Conference on Educational Data Mining** _Madrid, Spain_
[DALITE: An Analysis of Peer Written and Peer Reviewed Rationales](http://www.slideshare.net/sameerbhatnagarpolymtl/edm2015presentation-49850960)


text:
nglpy
=====

A Python wrapped version of the [Neighborhood Graph Library
(NGL_) developed by Carlos Correa and Peter Lindstrom.

http://www.ngraph.org/

NGLPY but modified to generate relative neighborhood graphs in a python environment.

Modified Installation
============

Must get the most up-to-date xcode and commandline tools

    sudo rm -rf /Library/Developer/CommandLineTools

    xcode-select --install

    sudo installer -pkg /Library/Developer/CommandLineTools/Packages/macOS_SDK_headers_for_macOS_10.14.pkg -target /

    pip install .

Usage
=====

Then you can use the library from python such as the example below::

    import nglpy
    import numpy as np

    point_set = np.random.rand(100,2)
    max_neighbors = 9
    beta = 1

    # TODO: Make this an enum, remove hard-coding
    graph_type = 'beta skeleton'

    aGraph = nglpy.Graph(point_set, graph_type, max_neighbors, beta)

    aGraph.neighbors()

gha_license_id: NOASSERTION


text:
---
title: "Overview"
date: 2020-03-06T19:38:56Z
draft: false
group: scale
weight: 701
---

Replicante Core is designed as a distributed system meant to scale with user demand.

{{% notice class="info" %}}
Scaling is an advanced topic that requires time and effort put into.

To achieve optimal value for money when considering the size of the cluster and number of tasks,
a degree of familiarity with each replicante component is required.
{{% /notice %}}

{{% notice class="warning" %}}
Replicante Core is at the early stages of development.

While scaling is a core feature of the platform, the limitations and requirements are not yet known.
Evolution of the system is likely to lead to changes in the scaling needs and configurations.
{{% /notice %}}

## Replicante Core
Replicante Core stores its state out of process and using existing technologies
designed to scale state storage (databases, messaging systems, etcetera ...).
Process coordination also ensures that exclusive operations are performed safely
regardless of the number of processes running.

As a result Replicante Core processes themselves are stateless and can generally
be scaled by increasing the number of processes running.

The desired number of processes depends on the user's
[deployment configuration]({{< ref "../admin/deployments.md" >}}) and their needs from the cluster.

Signals of the need to scale vary for each component.
The list below provides suggestions of what to look at for each component.

  * API components (this includes `components.grafana` and `components.webui`):
      look at the number of HTTP requests and their duration.
      Long running HTTP requests are an indication that something is not well.
      If other components and the datastores are healthy, long running HTTP requests may indicate
      a need to scale the API components.
  * Coordination/scheduling components (this includes `components.discovery`):
      these components only need a single instance running at any given time.
      To ensure all functionality remains available more then one instance of each service
      should be deployed so if the active instance fails another can take its place.
      Running 3 instances of each component should be the best form most situations.
  * Event consumers:
      event streams backup (rate of incoming events is higher then events processing rate).
      These components are similar to tasks (below) but must process events in order.
      Scaling the number of event consumers is as easy as running more instances.
      The complication may be with scaling the [streaming platform]({{< ref "./streams.md" >}}).
  * Task workers (`components.workers`):
      task queue backup (rate of incoming tasks is higher then task processing rate).
      Scaling the number of task workers is as easy as running more instances.
      If scaling the worker instances is not enough users may need to scale the
      [task queues system]({{< ref "./tasks.md" >}}).

## External systems
The more complex aspect of scaling tends to be at the state layer.

In most cases this means that the documentation of the dependencies will be the primary
source of information but some replicante-specific details are presented in these pages:

  * [Primary Store]({{< ref "./stores.md" >}}): where the current state of the system is stored.
  * [Tasks]({{< ref "./tasks.md" >}}): for asynchronously processing data and performing tasks.
  * [Streams]({{< ref "./streams.md" >}}): for ordered events occurring across the system.
  * [Coordinator]({{< ref "./coordinator.md" >}}): for all processes to agree on work being done.

gha_language: HTML


text:
# Simple Mixture Model

This repo implement the code for [Deep Learning with Jax and Elegy]().

## Instalation

With pip:

```bash
pip install -r requirements.txt
```
With poetry:

```bash
poetry install
```

## Running the code
```python
python main.py
```

repository: cgarciae/simple-mixture-models

repo_name: cgarciae/simple-mixture-models


text:
# spotifynewmusicfilter
Simple app that filters Official Spotify Playlist and creates a new Playlist based on genre.

### Description
How the app works.

### Original Idea
Inspired by this project.
https://github.com/mileshenrichs/spotify-playlist-generator

repository: katyajer/spotifynewmusicfilter

repo_name: katyajer/spotifynewmusicfilter


text:
+++
title = "Life with Low-end Hardware"
date = 2020-09-20

[taxonomies]
tags = ["hardware"]
+++

I am 28, and I have only owned two personal computers in my lifetime.

Excluding workstations, I have had one desktop and one laptop.

## Desktop (2007–2015)

This one had a CRT monitor, a single-core AMD Sempron processor, an 80 GB hard drive and 256 MB of RAM, later upgraded to 1.25 GB. It was my high school machine and my father’s occasional taxation machine.

It came with Windows XP, which I later replaced with various Linux distributions.

Now decommissioned and sold, I thank it for sparking in me the curiosity about computer science, programming and open source.

## Dell Vostro 2520 (2013–present)

The laptop has a 15.6″ 1366×768 display, a dual-core 3rd generation i5, no dedicated graphics and 4 GB of RAM. I upgraded the 500 GB spinning hard drive to a 480 GB SSD last year.

It is a clunky box with ancient tech: a DVD drive, an RJ45 port, a VGA port and (by today’s standards) an HDMI port. Forget Type-C, it does not even have USB 3.0. There are three USB 2.0 ports, supported well even today.

I bought it with Ubuntu, then [distrohopped](https://www.urbandictionary.com/define.php?term=distrohopper) for a bit before settling down with [elementary OS](https://elementary.io/).

This has been my primary machine for seven years and counting.

In 2020, this might sound like weak, barely running hardware, and you won’t be entirely wrong. Yet, I haven’t felt the need to replace it, even though I can afford it.

Let me tell you why this machine is brilliant.

### It is economic.

I got it for ₹33,000 (about $450). Then I made two screen replacements, two battery replacements and one SSD upgrade. The total cost including purchase has been less than ₹65,000 (about $885).

### The keyboard is excellent.

The keys are neither as flimsy as MacBook’s butterfly keyboard nor as hard as a mechanical keyboard. They are “Goldilocks” easy to press.

### It works.

It serves all my needs without breaking a sweat.

Without the fans going off, it can:

- [emulate](https://citra-emu.org/) Nintendo 3DS games at 100% speed
- run Firefox, [VSCodium](https://vscodium.com/) and a Node.js server with no lag
- compile Vala apps in seconds
- build my website in milliseconds

I realize that a lot of this is thanks to the SSD and would not have been so impressive before the upgrade. But as mentioned before, it is economic.

### But it’s growing old.

It’s not all rainbows and butterflies. The device’s age shows in a few areas:

- The 1366×768 resolution is fine, but I am spoilt by my HiDPI workstation.
- The touchpad is tiny. (Again, spoilt by workstation, but I have a mouse).
- The camera applies funky filters to your image unless you pinch the bezel.

There’s this balance of good and bad things about it, and it is inevitably approaching a tipping point where the bad outweighs the good. That being said, my old buddy can pull off a few months to a year before I need an upgrade.

## Final thoughts

The bottom line is that it is okay to be conservative about hardware purchases. Quality hardware will last several years without needing a replacement.

branch_name: refs/heads/sacred-timeline


text:
# Boston Housing Prediction
> Predict Housing prices in boston with different Models. This repository is mainly for learning purpose and NOT for comercial-use.

[![License][license-badge]][license-url]
[![Codacy Badge][codacy-badge]][codacy-url]
[![Build Status][travis-badge]][travis-url]
![Lines of Code][lines-codes-badge]
Boston Housing Prediction is a python script that can predict the housing prices in boston with different models, the user can choose from.

## Installation
You need to have `python >= 3.5` installed.

To install the the script do:

```sh
$ pip install boston_housing_prediction
```

## Usage example

You can run the programm with:
```sh
$ python -m boston_housing_prediction model_name
```
To see the help(for extra options) do:
```sh
$ python -m boston_housing_prediction -h
```

## More Infomation

For more information please visit my github repository:
[My Github](https://github.com/LuposX/BostonHousingPrediction/)

<!-- Markdown link & img dfn's -->
[codacy-badge]: https://api.codacy.com/project/badge/Grade/089e59afa6a44e629b1267f8abaad038
[codacy-url]:https://app.codacy.com/manual/LuposX/BostonHousingPrediction/dashboard
[license-badge]: https://img.shields.io/github/license/LuposX/sentdex_fixed_market_stock
[license-url]: https://github.com/LuposX/BostonHousingPrediction/blob/master/LICENSE
[travis-url]: https://travis-ci.com/LuposX/BostonHousingPrediction
[travis-badge]: https://travis-ci.com/LuposX/BostonHousingPrediction.svg?branch=master
[lines-codes-badge]: https://tokei.rs/b1/github/LuposX/BostonHousingPrediction?category=code

repository: LuposX/BostonHousingPrediction

gha_language: Python

repo_name: LuposX/BostonHousingPrediction


text:
# How GitHub CoPilot 🤖 is helping in my daily work at Microsoft

![How GitHub CoPilot 🤖 is helping in my daily work at Microsoft](img/CopilotSessionSeriesHeader.gif)

March is our Artificial Intelligence and Machine Learning month in the **Microsoft Reactor Network**.

This is the perfect time to share developer experiences working with **Visual Studio Code** and **GitHub CoPilot**.

That’s why on March we will host 5 different 30-minutes sessions, with  experiences working with:

    - Python
    - C++
    - C#
    - Markdown
    - Using CoPilot to control a Roomba vacuum cleaner 🤖 !

Happy coding!

## Sessions Registration
- [March 1st : Episode 1/5 | 🐍 Python](https://www.meetup.com/Microsoft-Reactor-Toronto/events/283606946/)
- [March 8th : Episode 2/5 | C#](https://www.meetup.com/Microsoft-Reactor-Toronto/events/283607101/)
- [March 15th : Episode 3/5 | C++](https://www.meetup.com/Microsoft-Reactor-Toronto/events/283607295/)
- [March 22nd : Episode 4/5 | MarkDown](https://www.meetup.com/Microsoft-Reactor-Toronto/events/283607390/)
- [March 29th : Episode 5/5 | Controlling a Roomba](https://www.meetup.com/Microsoft-Reactor-Toronto/events/283607416/)

## Sessions Description

    GitHub Copilot works with a broad set of frameworks and languages. Currently Copilot supports Python, JavaScript, TypeScript, Ruby, Java, and Go. However, I also used it with other languages like C++ and C#; and even while I’m writing documentation with MarkDown.
    I’m always in charge. Cycling through Copilot suggestions and manually editing the suggested code is an amazing flow. What I really like is that GitHub Copilot adapts to my own code style.
    During this series, we will review how Copilot works with Python, C++, C# and Markdown. We will also run Copilot in different coding environments like Visual Studio Code or GitHub Codespaces.
    At the end of the series, we will use Copilot suggestions to perform a cool activity: connect and control a Roomba Vacuum cleaner.

## Additional Resources

- [GitHub Copilot](https://copilot.github.com/)
- [Visual Studo Code](https://code.visualstudio.com/)
- [Microsoft Learn - Scale AI in your organization](https://aka.ms/Mar1ScaleAI)
- [Microsoft Docs - An introduction to the Azure OpenAI Service](https://aka.ms/Mar1IntrotoOpenAI)
- [Microsoft Azure - OpenAI Service (PREVIEW)](https://aka.ms/Mar1OpenAIService1)

## Speaker and Co-Host

👤 **[Bruno Capuano](http://aka.ms/elbruno)**

* Blog: https://elbruno.com
* Twitter: [@elbruno](https://twitter.com/elbruno)
* Github: [@elbruno](https://github.com/elbruno)
* LinkedIn: [@elbruno](https://linkedin.com/in/elbruno)

repository: microsoft/Reactors

repo_name: microsoft/Reactors


text:
## Introducing Rye
Rye is a one-page template designed specifically for hosting on [GitHub Pages](http://pages.github.com) and serving locally using [Jekyll](http://jekyllrb.com).

## Prerequisites
Rye requires the minimum versions of Node and Ruby below.

* [Node 0.10.30](http://nodejs.org/download)
* [Ruby 2.0](http://www.ruby-lang.org/en/installation)

Run the commands below to determine which versions are currently installed.

~~~bash
# each command returns a version number
$ node --version
$ ruby -v
~~~

## Install Rye
Clone Rye from the `gh-pages` branch on GitHub and go into its directory.

~~~
$ git clone -b gh-pages https://github.com/caleorourke/rye.git
$ cd rye
~~~

Install Grunt and dev dependencies for Node.

~~~bash
$ sudo npm install -g grunt-cli
$ sudo npm install
~~~

Install Jekyll and other Ruby runtime dependencies.

~~~bash
$ sudo grunt install
~~~

## Start Using Rye
Rye leverages [Grunt](http://gruntjs.com) as a harness for installing Node and Ruby dependencies, in addition to serving the site locally.

### Commands
Run any of these commands to initiate a task.

* `$ grunt build`
* `$ grunt install`
* `$ grunt serve`
* `$ grunt test`

#### $ grunt build

1. Bundles and minifies `*.less` files to `*.css` using [RECESS](http://twitter.github.io/recess)
2. Bundles and minifies `*.js` files using [UglifyJS](https://www.npmjs.com/package/grunt-contrib-uglify)

#### $ grunt install

1. Updates RubyGems
2. Runs `gem install github-pages`

#### $ grunt serve

1. Bundles and minifies `*.less` files to `*.css` using [RECESS](http://twitter.github.io/recess)
2. Bundles and minifies `*.js` files using [UglifyJS](https://www.npmjs.com/package/grunt-contrib-uglify)
3. Builds the site locally in the `_site` directory
4. Starts a local environment on `http://localhost:4000`
5. Regenerates a new `_site` directory whenever a file is modified (except `.less` and `.js` assets)

> Serve mode lasts forever. It will not timeout after a period of non-usage. In order to stop it, press `CTRL+C`.

#### $ grunt test

1. Builds the website locally in the `_site` directory
2. Spits out any errors found during the build process

## Updating Rye
Dependencies are updated often by their original authors. To install the most recent versions, run `sudo npm update`.

If this fails for whatever reason, run the following commands to delete the original `node_modules` directory and build a new one.

~~~bash
$ sudo rm -r node_modules
$ sudo npm install
~~~

## License

Code and documentation licensed under the MIT license.

repository: caleorourke/exhibit

repo_name: caleorourke/exhibit


text:
# Network Common

In order to keep Tornado independent from the network layer, the _'tornado_network_common'_ crate contains
high level traits not bound to any specific technology. These traits define the API for sending
and receiving Events and Actions across the network.

repository: WuerthPhoenix/tornado

branch_name: refs/heads/develop

gha_language: Rust

repo_name: WuerthPhoenix/tornado


text:
# Night Mode plugin for NodeBB

Adds a lightbulb icon to your persona theme's header to toggle a dark skin.

Thanks to https://community.nodebb.org/user/a_5mith for the original snippet.

repository: psychobunny/nodebb-plugin-night-mode

repo_name: psychobunny/nodebb-plugin-night-mode


text:
[![GitHub issues](https://img.shields.io/github/issues/paulmartins/hugo-digital-garden-theme?style=flat-square&logo=appveyor)](https://github.com/paulmartins/hugo-digital-garden-theme/issues)
[![GitHub forks](https://img.shields.io/github/forks/paulmartins/hugo-digital-garden-theme?style=flat-square&logo=appveyor)](https://github.com/paulmartins/hugo-digital-garden-theme/network)
[![GitHub stars](https://img.shields.io/github/stars/paulmartins/hugo-digital-garden-theme?style=flat-square&logo=appveyor)](https://github.com/paulmartins/hugo-digital-garden-theme/stargazers)
[![license](https://img.shields.io/github/license/paulmartins/hugo-digital-garden-theme?style=flat-square&logo=appveyor)](https://github.com/paulmartins/hugo-digital-garden-theme/blob/main/LICENSE)

# Digital Garden Theme for Hugo

A simple Hugo theme for your digital garden, inspired by Maggie Appleton [website](https://maggieappleton.com/)

[**DEMO**](https://hugo-digital-garden-demo.netlify.app/)

This theme includes:
* a digital garden / blog
* a projects portfolio
* library notes

![Home](https://github.com/paulmartins/hugo-digital-garden-theme/blob/main/images/screenshot.png)

## Getting started

1. Install hugo and create a new website: [https://gohugo.io/getting-started/quick-start/](https://gohugo.io/getting-started/quick-start/)
2. Add the theme to your website
You can either use git submodule or clone the repo in your theme folder

    ```bash
    git submodule add https://github.com/paulmartins/hugo-digital-garden-theme.git themes/digital-garden
    ```

    ```bash
    cd themes
    git clone https://github.com/paulmartins/hugo-digital-garden-theme.git
    ```

3. Customize your site in your `config.toml`. An example is given in the theme folder: `themes/digital-garden/exampleSite/config.toml`

4. Run the server and check your [localhost:1313](http://localhost:1313)
    ```bash
    hugo server
    ```

## Update to the latest version of the theme

If you used git submodule to add the theme (see Getting started) do

```bash
git submodule update --remote --rebase
```

If you clone the theme, just go in the theme folder and `pull`

```bash
cd themes/digital-garden
git pull
```

[![Twitter](https://img.shields.io/twitter/url?style=social&url=https%3A%2F%2Fgithub.com%2Fpaulmartins%2Fhugo-digital-garden-theme)](https://twitter.com/intent/tweet?text=Wow:&url=https%3A%2F%2Fgithub.com%2Fpaulmartins%2Fhugo-digital-garden-theme)


text:
# Node JS SOAP Client V1.0.2
This is a little Node JS SOAP client example project.

## Installation:
```
git clone https://github.com/omermoreno78/node-soap-client.git
cd node-soap-client
npm install
```

## Run:
```
npm start
```

## Debug:
```
npm run debug
```

## Test:
1. Import the Postman collection to Postman:
   **extras\postman\node-soap-client.postman_collection.json**
2. Open the **Test** request and execute.


text:
##NYC Taxi Data 2013##

Using the New York Freedom of Information Law, Chris Whong managed to obtain 173 million records for New York City Taxi rides in 2013.  This data has been made available in many formats including Google BigTable.

http://chriswhong.com/open-data/foil_nyc_taxi/
http://www.reddit.com/r/bigquery/comments/28ialf/173_million_2013_nyc_taxi_rides_shared_on_bigquery/

repository: dennisobrien/PublicNotebooks

repo_name: dennisobrien/PublicNotebooks


text:
# 06-hello-sails
> introducing Sails MVC framework

The term framework is overloaded and means different things to different people. In Node.js you can call any framework *module* and you will never get it wrong.

However, it's a good thing to establish some basic concepts:

+ **API Framework** — a library for building web APIs, backed by a framework that helps to structure the application.
+ **HTTP server library** — libraries that help you build applications that are based around HTTP verbs and routes (anything based on Express falls into this category).
+ **HTTP server framework** — a framework for building modular servers that speak HTTP.
+ **Web MVC framework** — model-view-controller frameworks
+ **Full-stack framework** — a library that uses JavaScript on both the server and the browser and are able to share code between both ends.

## Description
Sails is an MVC framework that comes with an ORM, REST API support and some other interesting features like WebSocket support.

| Fact Sheet              |                                                                  |
------------------------- | ---------------------------------------------------------------- |
| **Library Type**        | Web MVC Framework                                                |
| **Features**            | MVC with Database support, REST API generation, WebSockets       |
| **Suggested Uses**      | MVC apps                                                         |
| **Plugin Architecture** | Express Middleware                                               |
| **Documentation**       | http://sailsjs.org                                               |
| **License**             | BSD 3                                                            |

*Sails* is a bit different from other frameworks, in the sense that it comes with its own generator. In order to create a new project you have to run:
```bash
$ ./node_modules/.bin/sails new sails-app
```

Once created, cd into the newly created directory and run
```bash
$ ./node/modules/.bin/sails lift
```

repository: sergiofgonzalez/nodejs-in-action

repo_name: sergiofgonzalez/nodejs-in-action


text:
# Python-Windows-Service-Example
Example of a Windows service implemented in Python

The service should be built in a Python environment that includes the
`pywin32` and `pyinstaller` packages. Note that as of this writing
(2016-03-37), PyInstaller supports Python versions only through 3.5.

The command for building the service is:

        pyinstaller example_service.spec

and should be issued from the root repo directory. PyInstaller will
place the built service in the directory `build\example_service`.

To install and start the service, issue the commands:

        example_service.exe install
        example_service.exe start

from the `build\example_service` directory. *Note that the commands
must be issued from a command prompt that was run as administrator.*

To stop and remove the service, issue the commands:

        example_service.exe stop
        example_service.exe remove

As above, the commands must be issued from the `build\example_service`
directory and from an administrator command prompt.


text:
# Lua Aseprite Export Defaults

[![The MIT License](https://img.shields.io/badge/license-MIT-orange.svg?style=flat-square)](http://opensource.org/licenses/MIT)

## Installation

https://community.aseprite.org/t/aseprite-scripts-collection/3599

## Features

Saves the currently open .ase file as a spritesheet .png

-   If you have don't have a file open, it displays a cancel dialog
-   Otherwise, it displays a dialog telling you where it will save your file
-   Click export temporarily opens a new tab using whatever your default Sprite Export settings are
-   Then saves the file in the same folder on your computer, with the same filename as the .ase file, but as a .png
-   Then closes the temporary tab

## License

This project is licensed under the MIT License.

repository: Swiftaff/lua-aseprite-exportdefaults

repo_name: Swiftaff/lua-aseprite-exportdefaults


text:
# NativeToolbar API

The NativeToolbar methods let you create and remove toolbars at runtime. Refer to [Native Toolbar Control in User Interface](../rhodes/ui#native-toolbar-control) for a discussion and examples, and to [NativeToolbarTest in Rhodes-System-Api-Samples](https://github.com/rhomobile/rhodes-system-api-samples/tree/master/app/NativeToolbarTest/) for sample code.

## create

Creates a toolbar.

	:::ruby
	Rho::NativeToolbar.create(toolbar-elements)

	toolbar-elements
	Name/value array for the tabbar, such as {:label => 'Main page',  :action => '/app', :icon => '/public/images/bar/colored_btn.png', :reload => true}

The toolbar-elements parameter is a list of name/value pairs from the following list of toolbar elements.

	:label
	Visible label to display instead of an icon.

	:action
	Path to your rhodes action (i.e. '/app/Account' would load the Account index action). Either :icon or :label must be specified: if both are omitted, Rhodes will not add the button to the toolbar. If both are specified, :icon is drawn and :label is discarded.

	:icon
	Relative path to toolbar item icon in your rhodes app (typically located in /public/images/). iPhone and Android: Icons must be no more than 30x30 pixels and must be in .png format. Windows Mobile: Icons can be any size, but all icons should have same size (default – 48x48).

	:colored_icon
	(optional) true or false; true tells rhodes to use color icon in toolbar on iPhone instead of standard monochrome white icon (prepared from image alpha).

	:width
	(optional) For Windows Mobile, define width in pixels for separator element.

## remove

Removes the toolbar.

	:::ruby
	Rho::NativeToolbar.remove

repository: rhomobile/rhomobile-docs

gha_language: Ruby

repo_name: rhomobile/rhomobile-docs


text:
# Hello world for Padauk PMS132B

This project is a simple hello world application that should run on the Padauk PMS132B or 5S-I-S01 ICE.
Its only purpose is to send a PWM signal at approximately 15 KHz on pin PA3 with a varying duty cycle.

Tested with the Padauk 5S-I-S01 ICE and compiled using the Padauk IDE 0.88.


text:
# VTools for Visual Studio Code

Extension install page: <https://marketplace.visualstudio.com/items?itemName=venryx.vscode-vtools>

## Features

### Auto-hide side-bar
Causes the side-bar to be hidden whenever the user clicks outside of it. (technically, when the user changes the text-editor selection)

![Auto-hide side-bar](Images/Features/AutoHideSideBar.gif)

### Auto-hide bottom-bar
Same thing as above, except for the bottom-bar (output, terminal, etc.).

## Settings

* `vtools.autoHideSideBar`: Causes the side-bar to be hidden whenever the user clicks outside of it. [boolean, default: `false`]
* `vtools.autoHideBottomBar`: Causes the bottom-bar (output, terminal, etc.) to be hidden whenever the user clicks outside of it. [boolean, default: `false`]
* `vtools.autoHideDelay`: How many milliseconds to wait before hiding the side/bottom bars, after clicking outside of them. (helps solve the unintended-selection issue -- especially when scrolled to the right) [number, default: `300`]

## Alternatives

The open-source ecosystem works best when software alternatives are easy to find.

The below are plugins providing functionalities similar to...
* **Auto-hide side-bar:** [Auto Hide](https://github.com/sirmspencer/vscode-autohide)
* **Auto-hide bottom-bar:** [Auto Hide](https://github.com/sirmspencer/vscode-autohide)

## Developing

1) Clone/download repo: https://github.com/Venryx/vscode-vtools.git
2) Make code changes in "src" folder.
3) Run "npm run compile". (this will start compiler in watch mode) [if editing in vscode, Ctrl+Shift+B also works]
4) Not sure what command to use in the command-line. In vscode, I open the Debug panel and launch the extension from there.

## Publishing

1) Increment the version number in package.json.
2) Add an entry to the changelog for the new version.
3) Run "npm publish". (this publishes to npm, and runs "vsce publish", which adds the new version to the vscode marketplace)

Note: If "vsce" doesn't exist, run "npm i -g vsce". If login not-set/invalid (or PAT expired), run "vsce login [your publisher name]", and supply a non-expired PAT.

repository: Venryx/vscode-vtools

gha_language: TypeScript

repo_name: Venryx/vscode-vtools


text:
# Smug - tmux session manager

Inspired by [tmuxinator](https://github.com/tmuxinator/tmuxinator) and [tmuxp](https://github.com/tmux-python/tmuxp).

Smug automates your [tmux](https://github.com/tmux/tmux) workflow. You can create a single configuration file, and smug will create all required windows and panes from it.

![gif](https://raw.githubusercontent.com/ivaaaan/gifs/master/smug.gif)

Configuration used in this GIF can be found [here](#example-2).

## Usage

`smug <command> <project>[:window name] [-w window name]`.

### Examples

To start/stop a project and all windows, run:

```console
xyz@localhost:~$ smug start project

xyz@localhost:~$ smug stop project
```

When you already have a running session, and you want to create only some windows from the configuration file, you can do something like this:

```console
xyz@localhost:~$ smug start project:window1

xyz@localhost:~$ smug start project:window1,window2

xyz@localhost:~$ smug start project -w window1

xyz@localhost:~$ smug start project -w window1 -w window2

xyz@localhost:~$ smug stop project:window1

xyz@localhost:~$ smug stop project -w window1 -w window2
```

## Installation

#### Prerequisite Tools

* [Git](https://git-scm.com/)
* [Go (we test it with the last 2 major versions)](https://golang.org/dl/)

#### Fetch from GitHub

The easiest is to clone Smug from GitHub and install it using `go-cli`:

```bash
cd /tmp
git clone https://github.com/ivaaaan/smug.git
cd smug
go install
```

## Configuration

Configuration files stored in the `~/.config/smug` directory in the `YAML` format, e.g `~/.config/smug/your_project.yml`.

### Examples

#### Example 1

```yaml
session: blog

root: ~/Developer/blog

before_start:
  - docker-compose -f my-microservices/docker-compose.yml up -d # my-microservices/docker-compose.yml is a relative to `root`

stop:
  - docker stop $(docker ps -q)

windows:
  - name: code
    root: blog # a relative path to root
    manual: true # you can start this window only manually, using the -w arg
    layout: main-vertical
    commands:
      - docker-compose start
    panes:
      - type: horizontal
        root: .
        commands:
          - docker-compose exec php /bin/sh
          - clear

  - name: infrastructure
    root: ~/Developer/blog/my-microservices
    layout: tiled
    panes:
      - type: horizontal
        root: .
        commands:
          - docker-compose up -d
          - docker-compose exec php /bin/sh
          - clear
```
#### Example 2

```yaml
session: blog

root: ~/Code/blog

before_start:
  - docker-compose up -d

stop:
  - docker-compose stop

windows:
  - name: code
    layout: main-horizontal
    commands:
      - vim app/dependencies.php
    panes:
      - type: horizontal
        commands:
          - make run-tests
  - name: ssh
    commands:
      - ssh -i ~/keys/blog.pem<EMAIL_ADDRESS>```

repository: kforsthoevel/smug

repo_name: kforsthoevel/smug


text:
# Mini_c_interpreter
This repository contains all the documents developed for an interpreter which can interpret a subset of C language.

Objective:- We are trying to develop an interpreter which can interpret a subset of C language. It will help us to get an understanding of
any language development and its conversion from text file to executable machine language(0 or 1).


text:
![Data Exchange logo](logo.png)

# AWS Data Exchange Samples

[AWS Data Exchange](https://aws.amazon.com/data-exchange/) is a service that makes it easy for millions of AWS customers to securely find, subscribe to, and use third-party data in the cloud. This repository contains a collection of samples that interact with the AWS Data Exchange API.

![Data Exchange diagram](DE-diagram.png)

## Subscriber Samples

Examples of interacting with the AWS Data Exchange API from the data subscriber side can be found in [/subscribers](subscribers).

### Java

* [all-entitled-datasets](subscribers/java/all-entitled-datasets): Lists all data sets one is subscribed to.

### Ruby

* [all-entitled-datasets](subscribers/ruby/all-entitled-datasets): Lists all data sets one is subscribed to.
* [most-expensive-neighborhoods-in-nyc](subscribers/ruby/most-expensive-neighborhoods-in-nyc): Most expensive neighborhoods in NYC by median price.

### JavaScript

* [all-entitled-datasets](subscribers/javascript/all-entitled-datasets): Lists all data sets one is subscribed to.
* [auto-export-to-s3](subscribers/javascript/auto-export-to-s3): Automatically exports newly published revisions to S3 using a CloudWatch Rule and Lambda Function.

### Go

* [all-entitled-datasets](subscribers/go/all-entitled-datasets): Lists all data sets one is subscribed to.

### Python

* [download-entitled-assets](subscribers/python/download-entitled-assets): Download all assets to which you've subscribed.
* [pandas-describe-csv](subscribers/python/pandas-describe-csv): Download a CSV asset by Arn, import it into a Pandas data frame, and `describe()` the result.
* [auto-export-to-s3](subscribers/python/tf-auto-export-to-s3): Terraform based deployment to automatically export newly published revisions to S3 using a CloudWatch Rule and Lambda.

### DotNet

* [all-entitled-datasets](subscribers/dotnet/all-entitled-datasets): Lists all data sets one is subscribed to.

### C++

* [all-entitled-datasets](subscribers/cpp/all-entitled-datasets): Lists all data sets one is subscribed to.

### PHP

* [all-entitled-datasets](subscribers/php/all-entitled-datasets): Lists all data sets one is subscribed to.

## Provider Samples

Examples of interacting with the AWS Data Exchange API from the data provider side can be found in [/providers](providers).

### Ruby

* [create-data-set-with-finalized-revision](providers/ruby/create-data-set-with-finalized-revision): Create a data set with a finalized revision.
* [enumerate-data-products](providers/ruby/enumerate-data-products): Enumerate data products, examine each product's data sets, and fetch a data set.
* [add-data-set](providers/ruby/add-data-set): Create and publish a data set into an existing product.
* [add-revision-to-a-data-set](providers/ruby/add-revision-to-a-data-set): Add a new revision to a data set using data in S3.

## Other Samples

* [awslabs/aws-data-exchange-publisher-coordinator](https://github.com/awslabs/aws-data-exchange-publisher-coordinator): Coordinate the publishing steps for a dataset revision based on an S3 manifest file being uploaded to the specified S3 bucket.
* [awslabs/aws-data-exchange-subscriber-coordinator](https://github.com/awslabs/aws-data-exchange-subscriber-coordinator): Coordinate subscription steps to receive a dataset revision into S3 from AWS Data Exchange when the publisher publishes a new revision.

## API References

* [AWS Data Exchange API](https://docs.aws.amazon.com/data-exchange/latest/apireference/welcome.html)
* [AWS Marketplace Catalog API](https://docs.aws.amazon.com/marketplace-catalog/latest/api-reference/welcome.html)

## License

This library is licensed under the MIT-0 License. See the [LICENSE](LICENSE) file.

repository: melchii/aws-dataexchange-api-samples

repo_name: melchii/aws-dataexchange-api-samples


text:
# **RFNT** / RumbleFighter Nanmu Tool

Very simplistic tool for RumbleFighter to for infinite Nanmu.

## Use

Simply build the project and inject the library into the RumbleFighter client. When the client window is created, the library will initialize itself.

* Use the F1 key to reset your Nanmu counter. If you don't have Nanmu yet, this tool will enable it for you. A bypass is **not** required as we're flipping bytes back and forth.
* The F2 key will suspend you in air if you get knocked off a map or accidently fall off. Pressing the key again will resume the client's regular physics.
* To crash a room, use the F3 key. You must be in-game, press the key right before another player hits you and everyone but yourself will have their client crash.

## How it works

The RumbleFighter client has a realtime thread with a loop that checks your character's state. Nanmu locks are client sided as opposed to server sided, so simply modifying the register responsible will set your counter back to 0.

## Disclaimer

This project was created for eductional purposes only. I have not, and will not monetize this code for any personal gains.

---

Copyright (c) 2019 John Nolette Licensed under the MIT license.

repository: ShaunKB/rf

repo_name: ShaunKB/rf


text:
# hometrack-test-api

This is my solution to the Hometrack Interview problem.

[Problem definition](https://github.com/Hometrack/codetest)

## Getting Started

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

### Prerequisites

* NodeJS 6.11.4+
* Heroku CLI - (Deployment only)

### Installing

Install dependcies

```bash
npm install
```

Run express server locally

```bash
npm start
```

## Running the tests

This project uses mocha to for testing. Install mocha globally to access it directly from the terminal

```bash
npm -g install mocha
```

Then run the test suite using.

```bash
npm test
```

## Deployment

This project is configured to be deployed to heroku for futher instructions see - [Getting Started Heroku](https://devcenter.heroku.com/articles/getting-started-with-nodejs#deploy-the-app)

To deploy first login to your heroku account by running the command below and following the prompts

```bash
heroku login
```

Then create a Heroku app for the project

```bash
heroku create
```

This will add the heroku remote configuration to your local git repository, you can deploy by pushing to this remote

```bash
git push heroku master
```

## Built With

* [Express](https://expressjs.com/) - The web framework used

## License

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

repository: Astr-o/hometrack-test-api

repo_name: Astr-o/hometrack-test-api