text:
---
layout: page
title: About Me
permalink: /about/
---

My name is Phil Heijkoop. I like to style myself as a full-stack machine learning engineer. I've spent a year and a half at the German Aerospace Center (DLR) in Oberpfaffenhofen, working under Martin Schuster to develop tools for research in multi-robot SLAM techniques. Afterwards I returned to the Netherlands and picked up at Veneficus (my employer before I left for Germany), where I worked closely with the data science and software development teams to help create reproducible data-science tools for our clients. I now live in Boston and am looking for my next challenge.

### Background Information

I've had the privilege of growing up in numerous countries around the world (the United States, South Korea, Belgium, and Cuba just to name a few), this has served as a catalyst for my interests in international relations, history and learning. Besides my experience at DLR and Veneficus, I've also spent time doing research in bipedal robotic locomotion, teaching at a middle/high school, coaching lacrosse, and playing on the Dutch national team.

I'm passionate about learning and passing that on to others. Hopefully the items under the projects tab here give you a glimpse of my diverse background and interests. My hobbies include:

* Electronics (Arduino, Raspberry pi projects) and domotics
* Reading and writing
* Hiking and traveling

### Contact Me

Please feel free to reach out to me using any of the platforms in the footer or send me an [email](mailto:philip.heijkoop@gmail.com).


text:
# System-Monitor

This Project is a part of Udacity's C++ Nanodegree Program

## Instructions
1.Clone the project repository
2.Build the project: `make build`
3.Run the executable: `./build/monitor`

license: MIT

branch_name: refs/heads/main

extension: md

license_type: permissive


text:
Free-play Sandbox - QtQuick GUI
===============================

*This project is part of the 'Free-play Sandbox' experimental framework for Cognitive Human-Robot
Interaction research. [Check the PInSoRo website](https://freeplay-sandbox.github.io/) for details and [documentation](https://freeplay-sandbox.github.io/freeplay-software)*.

![Screenshot of the playground](docs/freeplay-sandbox.png)

Pre-requisites
--------------

First, you need a working installation of Qt5. On Ubuntu, `sudo apt install
qtdeclarative5-dev qtdeclarative5-qtquick2-plugin`.

You also need [Box2D for QtQuick](https://github.com/qml-box2d/qml-box2d) >=v2.0
for 2D physics. Download it and install it manually.

Second, you need a working installation of
[ROS](http://wiki.ros.org/ROS/Installation) (at time of writing, ROS Kinetic or
ROS Lunar are both ok).

Finally, the sandbox GUI requires my own [ROS plugin for
QtQuick](https://github.com/severin-lemaignan/ros-qml-plugin)

Install it before attempting to compile the sandbox.

Installation
------------

Simply open the Qt project from QtCreator and compile it from there.

**Important: because the freeplay sandbox GUI needs ROS to compile, the ROS
environment needs to be properly configured when starting QtCreator, so that
QtCreator can find the ROS headers & libraries. Assuming your ROS installation
is working, the easiest way to ensure that is simply to manually start QtCreator
from a terminal.**

Usage
-----

Before starting the GUI, you need to launch `roscore` in a different terminal.

When you then launch the application, **the screen is blank**. **This is
normal** as when we run an experiment, we typically do not want anything on the
screen while we welcome the participants.

The [supervisor](https://github.com/freeplay-sandbox/web-supervisor) can be used
to remotely set the current stage of the experiment (and accordingly control the
display).

You can manually trigger the display by opening a terminal and typing:

```
$ rostopic pub /sandtray/signals/start_freeplay std_msgs/Empty
```

repository: freeplay-sandbox/qt-gui

branch_name: refs/heads/master

repo_name: freeplay-sandbox/qt-gui


text:
## sampleterrain - Update coordinates of a GeoJSON file from node.js with sampled elevation data from [Cesium Terrain Provider](https://cesiumjs.org/data-and-assets/terrain/stk-world-terrain.html)

When you work with [Cesium](https://cesiumjs.org/), often times you need to incorporate elevation data in your geo features so that they are properly positioned relative to the ground when using terrain visualization. You can do it in the browser by invoking the [Cesium.sampleTerrain](https://cesiumjs.org/Cesium/Build/Documentation/sampleTerrain.html) function, but if your features have tons of coordinates, it will be very slow. Most of the time it will be much better to preprocess the data off-line to include elevation information. This small library allows you to do that from a node.js application.

Caveat: Cesium.js does not currently support invoking Cesium.sampleTerrain from a node.js application. I have created a [branch](https://github.com/jimmyangel/cesium/tree/loadWithXhr-for-node) (and a [pull request](https://github.com/AnalyticalGraphicsInc/cesium/pull/5138)) to include such support. While this functionality makes it into the official Cesium release, npm install will get [this](https://github.com/jimmyangel/cesium/tree/lhxr-build) branch from my repo.

### Install
```
npm install sampleterrain
```

### Use as library

```
var sampleterrain = require('sampleterrain');

sampleterrain.sample(data, function(err, result) {
  if (err) {
    console.log(err)
  } else {
    console.log(result);
  }
});

Where:
	data - GeoJSON object
	result - Update GeoJSON object

```

### Use from the command line
```
Sampling terrain...
Usage:
  sampleterrain.js [OPTIONS] [ARGS]

Options:
  -f, --file FILE        GeoJSON File
  -h, --help             Display help and usage details
```

### Example
```
node sampleterrain.js -f ./sampledata/test1.json  > sampled.json
```

repository: baloola/sampleterrain

repo_name: baloola/sampleterrain


text:
# Setup instructions

The LTI-ready virtual classroom experience uses AWS Amplify to roll out a serverless web application to your AWS account as illustrated in the yellow box below. For this experience to work, you must also set up the Amazon Chime SDK meeting experience (frontend and backend) and an LTI platform such as a learning management system (LMS) like Moodle, Blackboard or Canvas.

![Architectural overview](../doc/chime-lti-architectural-overview.png)

There are four key components:

- **LMS system with the LTI plugin configured**: This is supported with the LTI Client API which provides endpoints to integrate as an LTI tool in an LMS like Moodle, Canvas, or Blackboard. This API also issues web tokens and uses AWS Secrets Manager to store a secret key.

- **Events Management Center**: a React web application that educators will use to create and maintain _events_ and by students to review these _events_. An event represents a scheduled Amazon Chime SDK meeting, e.g. a virtual classroom experience, with information like event title, date, time, and description. The web application is hosted in Amazon S3, distributed via Amazon CloudFront, and also uses Amazon DynamoDB tables to store data. Additionally, the Events Management Center subscribes to user events in Amazon Chime meetings (via Amazon EventBridge) and pulls in event data, e.g. meeting started, meeting ended, attendee joined, attendee left, started and stopped sharing screen, etc. The tool takes these events and augments them with relevant data like LTI user information and event details before aggregating metrics to present meaningful insight into Amazon Chime SDK meeting activities.

- **Events API**: a backend API for the web application which encapsulates persistence logic for _events_. Also, this API owns communication to the Amazon Chime web meetings API when initiating and joining actual Amazon Chime SDK meetings.

- **Amazon Chime SDK meeting experience**: where attendees can collaborate over audio/video and screen share.

## Prerequisites

**What you need to start this setup:**

- Installed on your local machine: Git, Node (12.x or 14.x), NPM, AWS Amplify CLI

**What you need to complete this setup and make it functional** (but is optional for installation):

- an LTI platform such as an LMS, e.g. Moodle, Canvas, or Blackboard which supports [LTI v1.3](https://www.imsglobal.org/spec/lti/v1p3/#overview) or later.
  - specifically you'll need to set up an LTI plugin and get the public keyset, auth request, and token URIs. Step 7 provides further instructions on how to set up an LTI plugin and get the listed information in the most popular LMS products.
- the Amazon Chime SDK meeting experience rolled out in your AWS account
  - specifically you'll need the Amazon CloudFront web and API url which are provided as outputs of the setup process

## Setup

### 1. Clone Git repository using the git repo url

```bash
git clone https://github.com/aws-samples/lti-ready-virtual-classroom-with-amazon-chime-sdk
```

### 2. Install and configure AWS Amplify

Please follow [these instruction steps](https://docs.amplify.aws/cli/start/install) to install and set up AWS Amplify CLI on your local machine.

### 3. Initialize AWS Amplify project

Navigate to the **/web** folder of this project run _amplify init_ from your commandline.

```bash
cd lti-components/web
amplify init
```

a) Name your environment e.g. "dev" or "prod"

b) Choose your preferred IDE to work on this project such as _Visual Studio Code_. If you're not sure select _None_

c) Select authentication method e.g. _AWS profile_ and select the AWS profile or AWS IAM credentials with administrative permissions. Most likely you'll use AWS credentials that you already created as part of configuring your local AWS Amplify CLI in step 2 of this guide.

### 4. Publish AWS Amplify project to AWS

From the **/web** folder of this project please run the following from your commandline:

```bash
npm run amplify:publish
```

When asked to continue, confirm with **Y (Yes)**. The initial setup can take some time. Please help yourself with a coffee.

Congratulations! You successfully deployed the LTI tool. Now it is time to configure it properly to work in conjunction with an LTI platform and the Amazon Chime Meetings App like it is illustrated at the top. Both of these components need to be set up seperately (covered in step 6 and 7 below).

### 5. Prepare for setting up LTI platform and Amazon Chime SDK meeting experience

To set up your LTI plugin in an LMS you'll need endpoint information from the LTI tool that you rolled out in the previous step.

a) Log in to your AWS account and go to _Systems Manager_.

b) From the _Systems Manager_ menu, select _Parameter Store_.

c) You should see the following parameters:

- **/chime/lti/{env}/ltiToolAuthUri**: is the Url to provide to an LTI platform when it asks for the tool url and redirect url.
- **/chime/lti/{env}/ltiToolLoginUri**: is the Url used by an LTI platform to initiate an external login.
- **/chime/lti/{env}/ltiToolJwkUri**: is the Url to provide to an LTI platform when it asks for a public keyset or token verification url.

_{env}_ represents the name of your AWS Amplify environment that you set in step 3 e.g. "dev" or "prod".
To receive the url value from these parameters click on them on copy the assigned _Value_.

If you don't see these parameter names please make sure your AWS Management Console is set to the AWS region which was targeted for deployment in step 4.

### 6. Deploy the Amazon Chime SDK meeting experience

Please go ahead and deploy the Amazon Chime SDK meeting experience from [Github](https://github.com/aws-samples/lti-ready-virtual-classroom-with-amazon-chime-sdk/tree/main/chime-sdk-components) by following the instructions.

When you are asked to provide the _Public JWK uri_ please use the value of **/chime/lti/{env}/ltiToolJwkUri** from the previous step.

### 7. Set up LTI plugin in your LMS

d) Now use this information to complete setting up an LTI plugin in your LMS.

- Read [detailed instructions for MOODLE LMS](README-Moodle.md)
- Read [detailed instructions for CANVAS LMS](README-Canvas.md)

If you're using a different LTI-enabled product please refer to its technical guidance on setting up LTI plugins.

### 8. Update platform configuration

The final step is to configure the LTI tool to work with the LMS and the Amazon Chime SDK meeting experience.

Please navigate to back to _Systems Manager_ in your AWS Management Console and go to _Property Store_. You'll find three more parameters that need their values updated to the following:

- **/chime/lti/{env}/ltiPlatformTokenUri**: update value and set to the auth token url as provided by the LMS in step 7
- **/chime/lti/{env}/ltiPlatformJwkUri**: update value to the public keyset url which is provided by the LMS in step 7
- **/chime/lti/{env}/ltiPlatformAuthRequestUri**: update value to the auth request url as provided by the LMS in step 7

Please double check if there are two more properties in _Property Store_ called:

- **/chime/web/backendUrl**: which should contain an API gateway url. It points to the API backend of the Amazon Chime meetings app as it was installed in step 6.
- **/chime/web/frontendUrl**: which should contain a Amazon CloudFront url. It points to the API frontend of the Amazon Chime meetings app as it was installed in step 6.

If any of these parameters are missing please ensure you've successfully completed step 6 of this guide.

### You're all set

Step 7 already provided you with instructions on how to create resource links from an LTI plugin in your LMS. You should now be able to click on these links and see this demo application in action.

**IMPORTANT NOTE**

The parameter values that you updated in step 8 act as default configuration values for any new LTI platform which sends a request to the LTI client API. This action creates a configuration item in an Amazon DynamoDB table named **chimePlatforms-{env}**. That said, in order to update configuration for an existing LTI platform setup you'll need to update values in the Amazon DynamoDB table instead of updating values in _Systems Manager's_ _Parameter Store_.


text:
---
layout: post
title: "Deep feature compression for collaborative object detection"
date: 2018-02-12 08:26:07
categories: arXiv_CV
tags: arXiv_CV Object_Detection Detection
author: Hyomin Choi, Ivan V. Bajic
mathjax: true
---

* content
{:toc}

##### Abstract
Recent studies have shown that the efficiency of deep neural networks in mobile applications can be significantly improved by distributing the computational workload between the mobile device and the cloud. This paradigm, termed collaborative intelligence, involves communicating feature data between the mobile and the cloud. The efficiency of such approach can be further improved by lossy compression of feature data, which has not been examined to date. In this work we focus on collaborative object detection and study the impact of both near-lossless and lossy compression of feature data on its accuracy. We also propose a strategy for improving the accuracy under lossy feature compression. Experiments indicate that using this strategy, the communication overhead can be reduced by up to 70% without sacrificing accuracy.

##### Abstract (translated by Google)

##### URL
[https://arxiv.org/abs/1802.03931](https://arxiv.org/abs/1802.03931)

##### PDF
[https://arxiv.org/pdf/1802.03931](https://arxiv.org/pdf/1802.03931)


text:
## **Update OPC Toolbox V4.1x Projects to OPC Toolkit V4.40**

### Summary

This article gives a brief description of the differences between the Softing OPC Toolbox V4.10 and Softing OPC Toolkit V4.40. Moreover it gives some hints to the code changes you should make to migrate your developed OPC application to the Softing OPC Toolkit V4.40.

Because the API of the OPC Toolkit (V4.40) has been changed due to compatibility issues with OPC Unified Architecture and due to user handling issues you will have to change the source code of your OPC Toolbox projects. The OPC Toolkit V4.40 (.NET) part has also been changed. In the new version we provide a .NET API to access the Toolkit Core API directly. Because of that matter you will have to rework your .NET OPC application as well if it was developed with the OPC Toolbox V4.10 (.NET).

###  OPC Servers

You can find an overview of the most important server interface classes which have to be used for server implementation at the [server concept](0c396293-a224-46ba-94dd-e821af146d72.htm) description.

When developing OPC Servers with the OPC Toolkit V4.40, basically you will have to change the main tasks which are:

-   Configuration of the OPC Server

-   Interfacing the Data Access I/O

-   Selection of the Application Type

###  Configuration of the OPC Server
Update OPC Toolbox V4.1x Projects to OPC Toolkit V4.40

The first difference between OPC Toolkit V4.40 and V4.10 is, that DA Namespace, AE area space and AE event space of an OPC server has been combined into a common Address Space.

The Address Space can include one **DaAddressSpaceRoot** or one **AeAddressSpaceRoot**, many **DaAddressSpaceElements** or **AeAddressSpaceElements**

In this connection nodes and leafs from V4.10 changed to **AddressSpaceElements** with and without children.

This means that you have to take this into account at address space definition/creation/parsing (e.g. at buildObjectSpaces()) for different address space types (e.g. [object based or string based address space](03cf9124-11f8-49e6-bcf9-3428c258b01e.htm))

If you would like to implement a hierarchy, you will have to add the address space elements accordingly to their hierarchical order.
### C
```
node = new MyDaAddressSpaceElement();
node.Name = "maths";
node.Type = MyDaAddressSpaceElement.TYPE_NODEMATH;
node.IoMode = EnumIoMode.NONE;
node.HasChildren = true;
Application.Instance.DaAddressSpaceRoot.AddChild(node);

g_sin = new MyDaAddressSpaceElement();
g_sin.Name = "sin";
g_sin.Type = MyDaAddressSpaceElement.TYPE_SINE;
g_sin.AccessRights = EnumAccessRights.READABLE;
g_sin.Datatype =  typeof(double);
g_sin.IoMode = EnumIoMode.REPORT;
node.AddChild(g_sin);
```
### VB .NET
```
node = New MyDaAddressSpaceElement
node.Name = "maths"
node.Type = MyDaAddressSpaceElement.TYPE_NODEMATH
node.IoMode = EnumIoMode.NONE
node.HasChildren = True
Application.Instance.DaAddressSpaceRoot.AddChild(node)

g_sin = New MyDaAddressSpaceElement
g_sin.Name = "sin"
g_sin.Type = MyDaAddressSpaceElement.TYPE_SINE
g_sin.AccessRights = EnumAccessRights.READABLE
g_sin.Datatype = GetType(Double)
g_sin.IoMode = EnumIoMode.REPORT
node.AddChild(g_sin)
```
### C++
```
node = (MyDaAddressSpaceElement*)creator->createMyDaAddressSpaceElement();
aName = tstring(_T("maths"));
node->setName(aName);
node->setType(MyDaAddressSpaceElement::TYPE_NODEMATH);
node->setIoMode(EnumIoMode_NONE);
node->setHasChildren(TRUE);
daRoot->addChild(node);

m_sin = (MyDaAddressSpaceElement*)creator->createMyDaAddressSpaceElement();
aName = tstring(_T("sin"));
m_sin->setName(aName);
m_sin->setType(MyDaAddressSpaceElement::TYPE_SINE);
m_sin->setAccessRights(EnumAccessRights_READABLE);
m_sin->setDatatype(VT_R8);
m_sin->setIoMode(EnumIoMode_REPORT);
node->addChild(m_sin);
```

### Interfacing the Data Access I/O (OPC DA)

In the OPC Toolbox V4.20 you will have to choose the update mechanism for active items by selecting the **EnumIoMode**. There are two mechanisms supported:

-   Polling

-   Reporting

A more detailed description can be found [here](2e1facc5-6688-4183-ac2b-7cdfba1c7b4a.htm).

These settings were done in OPC Toolbox V4.10 by selecting the itemTagUpdateMode of an item. After choosing the **EnumIoMode** you will have to change the implementation of the corresponding Methods used by the mechanism you have selected. e.g. **HandleReadRequests()**, **HandleWriteRequests()** of a transaction or **QueryCacheValue** of address space element.

In the OPC Toolbox V4.10 you could also set a itemTagDeviceIOMode to specify the IO mode for the device access. The OPC Toolkit V4.40 is using direct device access. If you want to have a queued device access you will have to separate the OPC communication from the device IO access.

Basically there are two different possibilities how the handling of the OPC communication (handling the incoming Requests) and the device IO access can be implemented. If you have a fast IO or you are working on memory areas in the context of the running process, the OPC communication and the device IO access can be combined within the according methods. (e.g. **HandleReadRequests**, of the Transaction class like in the sample [\V43x\Windows\C++\samples\server\Console](75ae2e25-6977-4820-8ead-ded22ee6f3c3.htm#Console))

If you have a slow IO or a somehow timeconsuming device IO access it is more likely to separate the OPC communication from the device IO access by filling a queue and having a separate thread which is then making the device IO access, and completing the requests from the queue. (like in the sample [\V43x\Windows\C++\samples\server\Serial_IO](75ae2e25-6977-4820-8ead-ded22ee6f3c3.htm#Serial_IO))

###  Handling Alarms and Events (OPC AE)

The OPC Alarms & Events specification describes different types of events. You can have simple events, tracking related events and condition related events. After the Eventsources have been configured in [buildNamespace](dca520c4-fd52-40a1-a4d5-76e36a096a48.htm) and [buildEventCategories](dca520c4-fd52-40a1-a4d5-76e36a096a48.htm) methods, the events can be triggered by calling the according methods (e.g. **Application::fireEvents**, **Application::changeConditions** or **AEEvent::fire**) which depend on the event type. The [server console sample](75ae2e25-6977-4820-8ead-ded22ee6f3c3.htm#Console) shows the implementation of an OPC DA and AE server and the handling of Events.

###  Selection of the Application Type

In the Toolkit V4.40 you will have to select what kind of OPC server application you are going to implement. To do this you will have to set the **Application type property**.

The OPC Toolkit V4.40 supports two application types:

-   **EnumApplicationType_EXECUTABLE** for Out-Of-Process OPC servers

-   **EnumApplicationType_LIBRARY** for In-Process OPC servers

### C#
```
Application.Instance.AppType = EnumApplicationType.EXECUTABLE;
```
### VB .NET
```
Application.Instance.AppType = EnumApplicationType.EXECUTABLE;
```
### C++
```
getApp()->setAppType(EnumApplicationType_EXECUTABLE);
```

Furthermore you will have to implement the corresponding methods depending on the application type you have selected. (e.g. Service methods like OnStart and OnStop if you would like to implement an OPC server running as windows service or DLL methods like DLLMain if you want to implement an In-Process OPC server)

###  OPC Clients

You can find an overview of the most important client interface classes which have to be used for client implementation at the [client concept](07026f9b-26d1-4ff7-90ff-8745ad4b7499.htm) description.

The main tasks which you will be faced with will be handling the possible object state changes of the OPC objects you are using. This will be DA/AE Sessions, DA/AE Subscriptions and DA/AE items. Furthermore you will have to implement the correct callback methods, for the received callbacks.(e.g. **handleReadCompleted**, **handleWriteCompleted**, **handleDataChanged** for asynchronous DataChange callbacks or **handleAeEventsReceived** for incoming alarms and events.)

The next thing you will have to decide is, which kind of operations you are going to use. You can perform different tasks like [reading items](e0b47f54-7b1a-4cf9-b5db-a4475d6e6229.htm) in a [synchronous or asynchronous](bc435923-131a-4d36-afa5-aa5ff28e3fab.htm) way. Synchronous operations can lower the performance of the communication, because they first return after the operation has been completed. You can also use asynchronous operations which return after their call immediatelly and then you receive e.g. the value changes or the object state changes in the according callback methods. (e.g. **handleDataChanged**)

Which kind or execution type is used is defined in the **executionType** property of the **executionOptions**. You can specify an **ExecutionType** which can be e.g. SYNCHRONOUS or ASYNCHRONOUS.

### C#
```
ExecutionOptions executionOptions = new ExecutionOptions();
executionOptions.ExecutionType = EnumExecutionType.ASYNCHRONOUS;
executionOptions.ExecutionContext = 0;
```
### VB .NET
```
Dim executionOptions As New ExecutionOptions()
executionOptions.ExecutionType = EnumExecutionType.ASYNCHRONOUS
executionOptions.ExecutionContext = Convert.ToUInt32(0)
```
### C++
```
ExecutionOptions executionOptions;
executionOptions.setExecutionType(ASYNCHRONOUS);
executionOptions.setExecutionContext(0);
```

Moreover for asynchronous operations you will have to increment the **ExecutionContext** to make sure that the received callbacks can be identified correctly.
### C#
```
if (ResultCode.FAILED(subscription.Read(100, itemList, out values, out results, executionOptions)))
{
    Console.WriteLine(" Subscription read failed!");
}
else
{
    executionOptions.ExecutionContext++;
}
```
### VB .NET
```
if ResultCode.FAILED (subscription.Read(Convert.ToUInt32(100), itemList, values, results, executionOptions)) then
    System.Console.WriteLine(" Subscription read failed")
Else
    Decimal.op_Increment(Convert.ToDecimal(executionOptions.ExecutionContext))
End If
```
### C++
```
if (FAILED (result = subscription->read(
                                    0,
                                    itemsToRead,
                                    valuesToRead,
                                    readResults,
                                    &executionOptions)))
{
    _tprintf(_T(" Subscription read failed "));
} //end if
else
{
    executionOptions.setExecutionContext(++executionContext);
} //end if ... else
```

The OPC Softing Toolkit implements a multithreaded architecture for OPC communication. This means that the communication to every single OPC server is handled in a separate thread. This ensures that possible application blocking scenarios are avoided. Your application is still working also if one of the currently running threads performs a timeconsumig synchronous operation or is in a blocking state.

repository: SoftingIndustrial/OPC-Classic-SDK

gha_license_id: MIT

repo_name: SoftingIndustrial/OPC-Classic-SDK


text:
# matrix.py

matrix.py is a small and compact library that provides an interface to mathematical [Matrix](https://en.wikipedia.org/wiki/Matrix_(mathematics)) constructs, along with functionality to execute common operations on matrices or pairs of matrices.


text:
splaylist.js
=============

Splay-tree container with order statistics for Javascript.

version 0.0.0

Author: David Bau

Date: 2014 Dec 31

A SplayList is an array-like container that provides **both** fast
array-index and fast list-insertion access.  It is useful for
situations such as tracking an array of thousands of lines of
text when insertions and deletions must be instant, yet where
indexing by line number or character must also be fast,

This array-or-list replacement provides:

* A linked-list interface with O(1) (nanosecond) next() and prev(), and
  O(log n) (microsecond) insert(), remove(), splice() operations. These
  operations are all fast regardless of the number of elements.
* An array-style interface for skipping to the nth(i) item, or getting
  or setting the value at the ith position.
* An order-statistic interface, for determining the integer position
  of a node in O(log n) (microsecond) time.  Additional order statistics,
  tracking running sums of any nonnegative weights of each value, can
  be added by subclassing SplayList.

Internally a SplayList is an automatically balanced splay tree.  In practice,
splay trees perform better than O(log n) because they take advantage
of the typical locality of access in real applications.

This library is packaged to be used as a plain script or a node.js module.

Script tag usage
----------------

<script src="splaylist.js"></script>

var list = new SplayList();
// See below....

Node.js usage
-------------

var SplayList = require('splaylist').SplayList,
    assert = require('assert');

var list = new SplayList();

// Use as a push/pop stack is O(nanoseconds).
assert.equal(list.push("first", "second"), 2);
assert.equal(list.pop(), "second");
var loc1 = list.last();

// Use with shift/unshift is also fast.
assert.equal(list.unshift("also", "unshifted"), 3);
assert.equal(list.shift(), "also");
var loc4 = list.first();
assert.equal(list.length, 2);

// Insertion is O(microseconds) when at a new spot.
var loc3 = list.insertAfter(loc1, "after");
var loc2 = list.insertBefore(loc1, "before");

// Values at locations are dereferenced using val(), instant.
assert.equal(loc1.val(), 'first');
assert.equal(loc2.val(), 'before');
assert.equal(loc3.val(), 'after');
assert.equal(loc4.val(), 'unshifted');

// Visualize the splay tree structure with toString().
// (Most recent location is usually at the root.)
assert.equal(list.toString(),
  "   ┌╴after {n:1}\n" +
  " ┌╴first {n:2}\n" +
  "━before {n:4}\n" +
  " └╴unshifted {n:1}\n"
);

// Traversal is O(nanoseconds) using first and next, or last and prev.
var expect = [loc4, loc2, loc1, loc3];
for (var it = list.first(); it !== null; it = it.next()) {
  assert.equal(expect.shift().val(), it.val());
}
assert.equal(list.last(), loc3);
assert.equal(list.last().prev(), loc1);

// Quickly find a location by index, O(microseconds).
assert.equal(list.nth(0), loc4);
assert.equal(list.nth(1), loc2);
assert.equal(list.nth(2), loc1);
assert.equal(list.nth(3), loc3);

// Simple array-like access, O(microseconds).
assert.equal(list.get(0), 'unshifted');
assert.equal(list.get(1), 'before');
assert.equal(list.get(2), 'first');
assert.equal(list.get(3), 'after');

// Copy to an array with slice.
assert.deepEqual(list.slice(), ['unshifted', 'before', 'first', 'after']);
assert.deepEqual(list.slice(1,3), ['before', 'first']);

// Quickly discover index of any location, O(microseconds).
assert.equal(list.index(loc1), 2);
assert.equal(list.index(loc2), 1);
assert.equal(list.index(loc3), 3);
assert.equal(list.index(loc4), 0);

// Removal is O(microseconds).
assert.equal(list.length, 4);
list.removeAt(loc1);
assert.equal(list.length, 3);
assert.equal(list.nth(2), loc3);
assert.equal(list.pop(), 'after');
assert.equal(list.shift(), 'unshifted');
assert.equal(list.length, 1);
assert.equal(list.get(0), 'before');

// Use splice just like Array.splice.
assert.deepEqual(list.splice(0, 1, "Banana", "Orange", "Apple", "Mango"),
  ["before"]);
assert.deepEqual(list.splice(2, 0, "Lemon", "Kiwi"),
  []);
assert.deepEqual(list.slice(),
  ["Banana", "Orange", "Lemon", "Kiwi", "Apple", "Mango"]);
assert.deepEqual(list.splice(list.nth(3), 2),
  ["Kiwi", "Apple"]);
assert.deepEqual(list.slice(1, 3),
  ["Orange", "Lemon"]);
assert.deepEqual(list.slice(),
  ["Banana", "Orange", "Lemon", "Mango"]);
assert.deepEqual(list.splice(2),
  ["Lemon", "Mango"]);
assert.deepEqual(list.slice(),
  ["Banana", "Orange"]);
assert.deepEqual(list.splice(null, 0, "Pear", "Peach", "Plum"),
  []);
assert.deepEqual(list.slice(),
  ["Banana", "Orange", "Pear", "Peach", "Plum"]);

// Use removeRange to remove without copying, or spliceList to cheaply get a
// list back containing the removed list.
assert.deepEqual(list.spliceList(1, 2).slice(),
  ["Orange", "Pear"]);
assert.deepEqual(list.slice(),
  ["Banana", "Peach", "Plum"]);
assert.deepEqual(list.spliceList(1, 0).slice(),
  []);
assert.deepEqual(list.slice(),
  ["Banana", "Peach", "Plum"]);
list.removeRange(list.last(), 1);
assert.deepEqual(list.slice(),
  ["Banana", "Peach"]);
list.spliceList(list.first());
assert.deepEqual(list.slice(),
  []);
var list2 = new SplayList();
list2.push("Coconut", "Guava", "Papaya");
list.spliceList(0, 0, list2);
assert.equal(list2.length, 0);
assert.deepEqual(list.slice(), ["Coconut", "Guava", "Papaya"]);
list2.push("Pineapple", "Cherry");
var list3 = list.spliceList(list.first(), list.last(), list2);
assert.deepEqual(list3.slice(), ["Coconut", "Guava"]);
assert.deepEqual(list.slice(), ["Pineapple", "Cherry", "Papaya"]);
assert.equal(list.spliceList(null, null, list3).length, 0);
assert.deepEqual(list.slice(),
  ["Pineapple", "Cherry", "Papaya", "Coconut", "Guava"]);

// insertBefore can accept multiple arguments.
// it returns the location of the first one inserted, if any.
var locb = list.insertBefore(list.first().next(), "Blueberry", "Raspberry");
assert.equal(locb.val(), "Blueberry");
assert.equal(locb.next().val(), "Raspberry");
assert.equal(list.first().next(), locb);

// insertBefore null is the same as push.
var locp = list.insertBefore(null, "Watermelon");
assert.equal(locp.val(), "Watermelon");
assert.equal(locp, list.last());

// insertAfter can accept multiple arguments.
// It returns the location of the first one inserted, if any.
var loca = list.insertAfter(list.last().prev(), "Pumpkin", "Squash");
assert.equal(loca.val(), "Pumpkin");
assert.equal(loca.next().val(), "Squash");
assert.equal(list.last().prev(), loca.next());

// insertAfter null is the same as unshift.
var locp = list.insertAfter(null, "Almond");
assert.equal(locp, list.first());

Order Statistics
----------------

By default, the list tracks an "n" statistic: the number of locations
before any given location.

// Stat returns the total of a statistic to the left of a location.
assert.equal(list.stat('n', loc), list.index(loc));
// Find returns the leftmost location where the sum of the stat up
// to that location is at least a given value.
assert.equal(list.find('n', i), list.nth(i));

It is possible to extend SplayList to track other order statistics
beyond n; just override the orderstats method.  The SplayList class
has an extend method for conveniently creating subclasses that
override SplayList methods.  The orderstats method is passed
four arguments.  It must fill in sum statistics in X to reflect the
sum of the contribution of value V as well as subtrees L and R.
Either or both of L and R may be null.

var OrderList = SplayList.extend({
  orderstats: function(V, X, L, R) {
    // Calculate contriutions of V.
    var n = 1,
        k = V.k,
        m = V.s.length;
    // Add contributions of L and R.
    if (L !== null) { n += L.n; k += L.k; m += L.m; }
    if (R !== null) { n += R.n; k += R.k; m += R.m; }
    // Store the result in X.
    X.n = n;
    X.k = k;
    X.m = m;
  }
});

The example above defines stats "n", "k", and "m".  If orderstats is
overridden, the statistic "n" should count elements, as above.

See test/test.js for an example of overriding orderstats to generalize
to more than one order statistic.

LICENSE (MIT)
-------------

Copyright 2015 David Bau.

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

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

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

repository: davidbau/splaylist

gha_language: JavaScript

repo_name: davidbau/splaylist


text:
# SINGLE-VENDOR SINGLE-STORE CHEAT SHEET

_A Single-Vendor (Single-Store) E-Commerce Platform.
More simply, **an online store**._

My other repos showing different platforms,

* [multi-vendor marketplace](https://github.com/JeffDeCola/my-cheat-sheets/tree/master/software/service-architectures/software-as-a-service/content-management/multi-vendor-marketplace-cheat-sheet)
* [multi-vendor multi-store](https://github.com/JeffDeCola/my-cheat-sheets/tree/master/software/service-architectures/software-as-a-service/content-management/multi-vendor-multi-store-cheat-sheet)
* [single-vendor single-store](https://github.com/JeffDeCola/my-cheat-sheets/tree/master/software/service-architectures/software-as-a-service/content-management/single-vendor-single-store-cheat-sheet)
  **(You are Here)**

Table of Contents,

* [OVERVIEW](https://github.com/JeffDeCola/my-cheat-sheets/tree/master/software/service-architectures/software-as-a-service/content-management/single-vendor-single-store-cheat-sheet#overview)
* [USERS (ADMIN, VENDORS & CUSTOMERS)](https://github.com/JeffDeCola/my-cheat-sheets/tree/master/software/service-architectures/software-as-a-service/content-management/single-vendor-single-store-cheat-sheet#users-admin-vendors--customers)
* [STEPS TO CREATE AN ONLINE STORE USING WORDPRESS](https://github.com/JeffDeCola/my-cheat-sheets/tree/master/software/service-architectures/software-as-a-service/content-management/single-vendor-single-store-cheat-sheet#steps-to-create-an-online-store-using-wordpress)
  * [SOFTWARE STACK](https://github.com/JeffDeCola/my-cheat-sheets/tree/master/software/service-architectures/software-as-a-service/content-management/single-vendor-single-store-cheat-sheet#software-stack)
  * [INSTALL & BASIC OCNFIGURATION](https://github.com/JeffDeCola/my-cheat-sheets/tree/master/software/service-architectures/software-as-a-service/content-management/single-vendor-single-store-cheat-sheet#install--basic-ocnfiguration)
  * [USERS & PAGES](https://github.com/JeffDeCola/my-cheat-sheets/tree/master/software/service-architectures/software-as-a-service/content-management/single-vendor-single-store-cheat-sheet#users--pages)
  * [BASIC WOOCOMMERCE CONFIGURATION](https://github.com/JeffDeCola/my-cheat-sheets/tree/master/software/service-architectures/software-as-a-service/content-management/single-vendor-single-store-cheat-sheet#basic-woocommerce-configuration)
  * [PRETTY IT UP](https://github.com/JeffDeCola/my-cheat-sheets/tree/master/software/service-architectures/software-as-a-service/content-management/single-vendor-single-store-cheat-sheet#pretty-it-up)

Documentation and reference,

* See my offsite
  [demo of an online store](https://single-vendor-single-store.jeffdecola.com)
* [WordPress](https://github.com/JeffDeCola/my-cheat-sheets/tree/master/software/service-architectures/software-as-a-service/content-management/wordpress-cheat-sheet)
  content management system
* [WooCommerce](https://woocommerce.com/)
  e-commerce plugin
* View a list of all my-cheat-sheets on my
  [github webpage](https://jeffdecola.github.io/my-cheat-sheets/)

## OVERVIEW

The following illustration is a high-level view of an
Single-Vendor (Single-Store) E-Commerce platform (SaaS)
on a private server using,

* WordPress (Content Management System)
* WooCommerce PlugIn (E-Commerce Platform)

Or more simply, this illustration shows an **online store** hosted on your private server,

![IMAGE - single-vendor-single-store.jpg - IMAGE](../../../../docs/pics/single-vendor-single-store.jpg)

## USERS (ADMIN, VENDORS & CUSTOMERS)

There are 3 main users of an E-Commerce site that have
the following capabilities,

* **ADMIN**
  * Manages Stores
  * Manages Vendors and Customers
  * Integrate CRM (user.com)
  * Payment systems (Stripe/Paypal)
  * Shipping systems (USPS/FedEx)
* **VENDORS**
  * Manage E-Commerce Website
  * Editing inventory and Pricing
  * CMS Page Editor
  * Payments
  * Managing Orders
  * Sales Analytics
* **CUSTOMERS**
  * Browsing Products/Categories
  * Live Search
  * Coupons/Discount Codes
  * SEO Optimised
  * Purchasing
  * Shipping/Tracking

## CREATE AN ONLINE STORE USING WORDPRESS

These are the high-level steps I did to create my
[online store demo](https://single-vendor-single-store.jeffdecola.com).

### SOFTWARE STACK

* WORDPRESS
  * WooCommerce Plugin
    * WooCommerce Shiping & Tax Plugin
    * Creative Mail by Constant Contact Plugin
    * Facebook for WooCommerce Plugin
    * Google Ads & Marketing by Kliken Plugin
    * Mailchimp for WooCommerce Plugin
    * WC Vendors Marketplace Plugin
  * Loginizer Plugin

### INSTALL & BASIC CONFIGURATION

* GET WORDPRESS SETUP ON YOUR SERVER
  * Get a WebServer like Bluehost
  * Buy a domain name
  * Setup SSL (i.e. https)
  * Install WordPress
* INSTALL WOOCOMMERCE PLUGIN
  * Install the WooCommerce Plugin
  * The setup wizard will help you with basic plugin setup
  * Chose the Storefront theme
  * This will add four new Pages: **Cart, Checkout, My account & Shop**
  * This will add 2 new Users: **Shop manager & Customer**
* INSTALL OTHER PLUGINS
  * Install the Loginizer Plugin
  * Install Jetpack by wordpress.com

### USERS & PAGES

What you should have for users,

* WORDPRESS USERS
  * Subscriber
  * Contributor
  * Author
  * Editor
  * Administrator
* WOOCOMMERCE USERS
  * Shop manager
  * Customer

What you should have for pages,

* WORDPRESS PAGES
  * Privacy Policy (Privacy Policy Page)
  * Sample Page
* WOOCOMMERCE PAGES
  * Cart (Cart Page)
  * Checkout (Checkout Page)
  * My account (My Accounts Page)
  * Shop (Shop Page)

### BASIC WOOCOMMERCE CONFIGURATION

* Go throught the steps to get the store up means having a product.
  * Add a product
  * Setup payments
  * Setup tax
  * Setup shipping

### PRETTY IT UP

How to make it look better using the WooCommerce Storefront Theme,

* Add a logo
*

repository: JeffDeCola/my-cheat-sheets

gha_language: Shell

repo_name: JeffDeCola/my-cheat-sheets


text:
# Hierarchical / Multilevel / Mixed Effects Models

Repo contains foundational materials and examples  implementing a Bayesian and Frequentist Hierarchical models on simulated bounce rate data.

These materials are related to the following Towards Data Science articles:

- **foundations**: [When Mixed Effects (Hierarchical) Models Fail: Pooling and Uncertainty]( https://towardsdatascience.com/when-mixed-effects-hierarchical-models-fail-pooling-and-uncertainty-77e667823ae8)

- **bayes_lmm**:
    1. [A Bayesian Approach to Linear Mixed Models (LMM) in R/Python](https://towardsdatascience.com/a-bayesian-approach-to-linear-mixed-models-lmm-in-r-python-b2f1378c3ac8)
    2. [Evaluating Bayesian Mixed Models in R/Python](https://towardsdatascience.com/evaluating-bayesian-mixed-models-in-r-python-27d344a03016)

## Main Content

- **foundations**: Materials covering hierarchical model foundations with toy examples, basic implementation and evaluation of frequentist models and a primer on Bayesian models

- **lmm**: Materials covering Bayesian hierarchical (mixed effects) models in R and Python. Topics cover implementation, diagnostics, and evaluation.

- **data**: contains data sets used throughout all the implementations


text:
# A Java Program / Project

**This is a Java project from my early days as a Computer Science student**

_This programm was created for the fourth semester class Programming on the Internet and the World Wide Web
and is the final project for the class_

> #### Description of project
>
>>A Java dynamic web project which simulates an eclass application where users can sign up and sign in as admin, students or professors and can handle their grades and classes, running in apache Tomact and using pgAdmin as the database server.

> #### Functionality and Impementation of project
>
> 1. Uses the application server Tomcat
> 2. Uses the database server pgAdmin
> 3. It is a dynamic web project
> 4. Includes the sql code for the Entity-Relationship Model, which describes the Database
> 5. A class package with all servlets
> 5. Uses dynamic jsp pages
> 6. The JDBC connection method is pool

> #### About this project
>
> - This project used as base the repo https://github.com/PetePrattis/eclass-web-application-practise
> - The comments to make the code understandable, are within the archives
> - This project was written in Eclipse Java IDE
> - This repository was created to show the variety of the work I did and experience I gained as a student
>

repository: PetePrattis/eclass-web-application

repo_name: PetePrattis/eclass-web-application


text:
# Building

This library is designed to build under Windows and Linux by using
[Cake](https://cakebuild.net/), however, there are bootstrap scripts to download
and invoke the tool, so there isn't anything else to install apart from the
normal C# and C++ build tools.

## Windows

Make sure that the .NET Core SDK 3.1 is installed and the Visual C++ 2019
compiler (although it's probably easier to install Visual Studio for this,
you can just install the Build Tools for Visual Studio 2019). Then run the
`build.cmd` (or `build.ps1` from PowerShell) inside the `build` directory and
it will perform a full build and generate the NuGet packages.

## Linux

To build under Linux, the following will need installing:

+ [.NET Core SDK 3.1](https://docs.microsoft.com/en-gb/dotnet/core/install/linux)
+ g++ (version 9 is currently used, but versions supporting C++17 should work)
+ python (version 3+, should be installed by default)

You will also need to install `python3-venv` if running under Ubuntu, as by
default the python that ships with it doesn't include it. In addition to these,
for a full build (including code analysis), the following additional packages
will need to be available:

+ clang-format
+ clang-tidy

With all the above, you should then be able to run the `builds.sh` script from
inside the `build` directory and it will perform a full build, run the tests,
perform code analysis and then generate the NuGet packages.

repository: samcragg/Autocrat

repo_name: samcragg/Autocrat


text:
TRAFFIC RUSH:

Traffic Rush is an Android app for making traveling much easier by giving information about traffic details.

Copyright (c) 2017 Hemanth Lam, Nikhitha Durvasula

This project is licensed under the "MIT License". Please see the file LICENSE in this distribution for license terms https://github.com/NikhithaDurvasula/Traffic-Rush/blob/master/LICENSE

#PROJECT DESCRIPTION: An open source android application which helps people to know the traffic details from the current location to the desired destination address. This is all about knowing the occurrence of traffic incidents like accidents, traffic issues, cop traps, in your way to your destination.

This app allows users to register using email id and login. It provides users with mainly four options
1. Login or Register
2. Enter Destination Address
3. Get Directions to the destination
4. Get traffic information

You can find the source code at https://github.com/NikhithaDurvasula/Traffic-Rush

#INSTALLATION:
Firstly, clone the git repository.
git clone https://github.com/NikhithaDurvasula/Traffic-Rush

And then get all the packages required for the application by using the command.
You have to follow the instructions in the links provided below for all the APIs to generate your own keys.

The app starts with login or registering with a google account. Registering is done by connecting the button with the Google sign-in web page.

Then it requests for destination address, it takes source address as your current location. The destination address can be filled using the auto complete suggestions. This is done by using Places AutoComplete API: https://developers.google.com/places/web-service/autocomplete

The longitude and latitude values of both the source(your current location) and the destination are known using the geocoding API: https://developers.google.com/maps/documentation/geocoding/intro

The Marker is used to check the point where the destination points to.

The directions to the destination is given with the help of the Directions API: https://developers.google.com/maps/documentation/directions/start

Then other details like traffic, presence of a police etc are known by connecting Traffic Rush to another app named waze using Waze Deep Links: https://developers.google.com/waze/api/

#TECHNICAL DETAILS:
Android Studio 2.3.3
JRE 1.8.0_112-release-b06 x86_64
JVM: OpenJDK 64-Bt Server VM by JetBrains s.r.o
compile sdk version 21

#SOURCE CODE: https://github.com/NikhithaDurvasula/Traffic-Rush

#.apk File You can get the apk file from : https://github.com/NikhithaDurvasula/Traffic-Rush/blob/master/app-debug.apk

#Bug or Issue Tracker You can report the bugs in the following link: https://github.com/NikhithaDurvasula/Traffic-Rush/issues

#FUTURE ENHANCEMENTS:
1. Add maps functionality for taking source address from the user
2. Adding backend to store registration data and user history
3. To use Bing Maps Traffic Incidents API instead of wage API
4. To integrate this app with there vehicle related apps like uber, left etc, or other vehicles for communication.

#REFERENCES:
1. Android Studio - http://www.tutorialspoint.com/android/
2. https://developer.android.com/training/index.html
3. GoogleMaps: https://developers.google.com/maps/documentation/directions/intro ,
4. https://developers.google.com/maps/documentation/android/start#getting_the_google_maps_android_api_v2
5. Kinvey User guide : http://devcenter.kinvey.com/android/guides/users

#Final Presentation and screenshots of the app can be found at https://github.com/NikhithaDurvasula/Traffic-Rush/blob/master/quick-talk.pdf

#Demo video https://drive.google.com/drive/folders/0ByTz45D8AFAua016N3FIU3FMYlE?usp=sharing

#Author Hemanth Lam & Nikhitha Durvasula

#Contact Information You can email to<EMAIL_ADDRESS>/<EMAIL_ADDRESS>if you have any queries on this project

repository: NikhithaDurvasula/Traffic-Rush

repo_name: NikhithaDurvasula/Traffic-Rush


text:
Javascript Pseudo 3D Racer
==========================

An Outrun-style pseudo-3d racing game in HTML5 and Javascript

 * [play the game](http://codeincomplete.com/projects/racer/v4.final.html)
 * view the [source](https://github.com/jakesgordon/javascript-racer)
 * read about [how it works](http://codeincomplete.com/posts/2012/6/22/javascript_racer/)

Incrementally built up in 4 parts:

 * play the [straight road demo](http://codeincomplete.com/projects/racer/v1.straight.html)
 * play the [curves demo](http://codeincomplete.com/projects/racer/v2.curves.html)
 * play the [hills demo](http://codeincomplete.com/projects/racer/v3.hills.html)
 * play the [final version](http://codeincomplete.com/projects/racer/v4.final.html)

With detailed descriptions of how each part works:

 * read more about [v1 - straight roads](http://codeincomplete.com/posts/2012/6/23/javascript_racer_v1_straight)
 * read more about [v2 - curves](http://codeincomplete.com/posts/2012/6/24/javascript_racer_v2_curves/)
 * read more about [v3 - hills](http://codeincomplete.com/posts/2012/6/26/javascript_racer_v3_hills/)
 * read more about v4 - final (coming soon)

A note on performance
=====================

The performance of this game is **very** machine/browser dependent. It works quite well in modern
browsers, especially those with GPU canvas acceleration, but a bad graphics driver can kill it stone
dead. So your mileage may vary. There are controls provided to change the rendering resolution
and the draw distance to scale to fit your machine.

Currently supported browsers include:

 * Firefox (v12+) works great, 60fps at high res - Nice!
 * Chrome (v19+) works great, 60fps at high res... provided you dont have a bad GPU driver
 * IE9 - ok, 30fps at medium res... not great, but at least it works

The current state of mobile browser performance is pretty dismal. Dont expect this to be playable on
any mobile device.

>> _NOTE: I havent actually spent anytime optimizing for performance yet. So it might be possible to
   make it play well on older browsers, but that's not really what this project is about._

A note on code structure
========================

This project happens to be implemented in javascript (because its easy for prototyping) but
is not intended to demonstrate javascript techniques or best practices. In fact, in order to
keep it simple to understand it embeds the javascript for each example directly in the HTML
page (horror!) and, even worse, uses global variables and functions (OMG!).

If I was building a real game I would have much more structure and organization to the
code, but since its just a racing game tech demo, I have elected to [KISS](http://en.wikipedia.org/wiki/KISS_principle).

FUTURE
======

It's quite astounding what it takes to actually [finish](http://codeincomplete.com/posts/2011/9/21/defining_finished/)
a game, even a simple one. And this is not a project that I plan on polishing into a finished state. It should
really be considered just how to get started with a pseudo-3d racing game.

If we were to try to turn it into a real game we would have to consider:

 * car sound fx
 * better synchronized music
 * full screen mode
 * HUD fx (flash on fastest lap, confetti, color coded speedometer, etc)
 * more accurate sprite collision
 * better car AI (steering, braking etc)
 * an actual crash when colliding at high speed
 * more bounce when car is off road
 * screen shake when off-road or collision
 * throw up dirt particles when off road
 * more dynamic camera (lower at faster speed, swoop over hills etc)
 * automatic resolution & drawDistance detection
 * projection based curves ? x,y rotation
 * sub-pixel aliasing artifacts on curves
 * smarter fog to cover sprites (blue against sky, cover sprites)
 * multiple stages, different maps
 * a lap map, with current position indicator
 * road splits and joins
 * day/night cycle
 * weather effects
 * tunnels, bridges, clouds, walls, buildings
 * city, desert, ocean
 * add city of seattle and space needle to background
 * 'bad guys' - add some competetor drivers to race against as well as the 'traffic'
 * different game modes - fastest lap, 1-on-1 racing, collect coins ? shoot bad guys ?
 * a whole lot of gameplay tuning
 * ...
 * ...

Related Links
=============

 * [Lou's Pseudo-3d Page](http://www.extentofthejam.com/pseudo/) - high level how-to guide
 * [Racer 10k](https://github.com/onaluf/RacerJS) - another javascript racing game

License
=======

[MIT](http://en.wikipedia.org/wiki/MIT_License) license.

>> NOTE: the music tracks included in this project are royalty free resources paid for and licensed
from [Lucky Lion Studios](http://luckylionstudios.com/). They are licensed ONLY for use in this
project and should not be reproduced.

>> NOTE: the sprite graphics are placeholder graphics [borrowed](http://pixel.garoux.net/game/44) from the old
genesis version of outrun and used here as teaching examples. If there are any pixel artists out there who want to
provide original art to turn this into a real game please get in touch!

gha_language: HTML


text:
## [Bringup](#bringup)

### [Run roscore](#run-roscore)

Run roscore from PC.

```bash
$ roscore
```

### [Bringup TurtleBot3](#bringup-turtlebot3)

**TIP**: Before executing this command, you have to specify the model name of TurtleBot3. The `${TB3_MODEL}` is the name of the model you are using in `burger`, `waffle`, `waffle_pi`.
{: .notice--success}

1. Open a new terminal from PC with `Ctrl` + `Alt` + `T` and connect to Raspberry Pi with its IP address.
  The default password is **turtlebot**.
  ```bash
$ ssh ubuntu@{IP_ADDRESS_OF_RASPBERRY_PI}
  ```

2. Bring up basic packages to start TurtleBot3 applications.
  ```bash
$ export TURTLEBOT3_MODEL=${TB3_MODEL}
$ roslaunch turtlebot3_bringup turtlebot3_robot.launch
  ```

3. If the TurtleBot3 model is `burger`, the terminal will print below messages.
  ```bash
    SUMMARY
    ========

    PARAMETERS
    * /rosdistro: noetic
    * /rosversion: 1.15.8
    * /turtlebot3_core/baud: 115200
    * /turtlebot3_core/port: /dev/ttyACM0
    * /turtlebot3_core/tf_prefix:
    * /turtlebot3_lds/frame_id: base_scan
    * /turtlebot3_lds/port: /dev/ttyUSB0

    NODES
    /
        turtlebot3_core (rosserial_python/serial_node.py)
        turtlebot3_diagnostics (turtlebot3_bringup/turtlebot3_diagnostics)
        turtlebot3_lds (hls_lfcd_lds_driver/hlds_laser_publisher)

    ROS_MASTER_URI=http://<IP_ADDRESS>:11311

    process[turtlebot3_core-1]: started with pid [14198]
    process[turtlebot3_lds-2]: started with pid [14199]
    process[turtlebot3_diagnostics-3]: started with pid [14200]
    [INFO] [1531306690.947198]: ROS Serial Python Node
    [INFO] [1531306691.000143]: Connecting to /dev/ttyACM0 at 115200 baud
    [INFO] [1531306693.522019]: Note: publish buffer size is 1024 bytes
    [INFO] [1531306693.525615]: Setup publisher on sensor_state [turtlebot3_msgs/SensorState]
    [INFO] [1531306693.544159]: Setup publisher on version_info [turtlebot3_msgs/VersionInfo]
    [INFO] [1531306693.620722]: Setup publisher on imu [sensor_msgs/Imu]
    [INFO] [1531306693.642319]: Setup publisher on cmd_vel_rc100 [geometry_msgs/Twist]
    [INFO] [1531306693.687786]: Setup publisher on odom [nav_msgs/Odometry]
    [INFO] [1531306693.706260]: Setup publisher on joint_states [sensor_msgs/JointState]
    [INFO] [1531306693.722754]: Setup publisher on battery_state [sensor_msgs/BatteryState]
    [INFO] [1531306693.759059]: Setup publisher on magnetic_field [sensor_msgs/MagneticField]
    [INFO] [1531306695.979057]: Setup publisher on /tf [tf/tfMessage]
    [INFO] [1531306696.007135]: Note: subscribe buffer size is 1024 bytes
    [INFO] [1531306696.009083]: Setup subscriber on cmd_vel [geometry_msgs/Twist]
    [INFO] [1531306696.040047]: Setup subscriber on sound [turtlebot3_msgs/Sound]
    [INFO] [1531306696.069571]: Setup subscriber on motor_power [std_msgs/Bool]
    [INFO] [1531306696.096364]: Setup subscriber on reset [std_msgs/Empty]
    [INFO] [1531306696.390979]: Setup TF on Odometry [odom]
    [INFO] [1531306696.394314]: Setup TF on IMU [imu_link]
    [INFO] [1531306696.397498]: Setup TF on MagneticField [mag_link]
    [INFO] [1531306696.400537]: Setup TF on JointState [base_link]
    [INFO] [1531306696.407813]: --------------------------
    [INFO] [1531306696.411412]: Connected to OpenCR board!
    [INFO] [1531306696.415140]: This core(v1.2.1) is compatible with TB3 Burger
    [INFO] [1531306696.418398]: --------------------------
    [INFO] [1531306696.421749]: Start Calibration of Gyro
    [INFO] [1531306698.953226]: Calibration End
  ```

<details>
<summary>
![](/assets/images/icon_unfold.png) **Read more about launching RViz**
</summary>
### [Load TurtleBot3 on Rviz](#load-turtlebot3-on-rviz)

1. Open a new terminal and launch the robot state publisher.
  ```bash
$ roslaunch turtlebot3_bringup turtlebot3_remote.launch
  ```

2. Open a new terminal and enter the below command to run RViz. To run rviz, you need to specify the model name of TurtleBot3.
  ```bash
$ rosrun rviz rviz -d `rospack find turtlebot3_description`/rviz/{burger, waffle_pi}.rviz
  ```
  ![](/assets/images/platform/turtlebot3/bringup/2022_run_rviz.png)

</details>

repository: ROBOTIS-GIT/emanual

repo_name: ROBOTIS-GIT/emanual


text:
Libcalib
---
This repository contains some sources to calibrate stereo cameras.

#### Dependencies
- OpenCV
- Eigen3
- [Ceres](https://github.com/ceres-solver/ceres-solver), version 1.14.0
- [Rapidjson](https://github.com/Tencent/rapidjson)
- [Libcbdetect](https://github.com/ftdlyc/libcbdetect)

#### Compilation
1. build libcbdetect
2. copy libcbdetect header files into libcalib/include/libcbdetect
3. copy rapidjson header files into libcalib/include/rapidjson
3. copy libcbdetect.so into libcalib/lib
4. build libcalib

repository: Narthill/libcalib

repo_name: Narthill/libcalib


text:
# Malum-Game-Engine
[![Build Status](https://travis-ci.org/Dallas-Makerspace/Malum-Game-Engine.svg?branch=master)](https://travis-ci.org/Dallas-Makerspace/Malum-Game-Engine) [![Docker Build Status](https://img.shields.io/docker/build/dallasmakerspace/Malum-Game-Engine.svg)](https://hub.docker.com/r/dallasmakerspace/Malum-Game-Engine) [![License](https://img.shields.io/github/license/Dallas-Makerspace/Malum-Game-Engine.svg?style=flat-square)](https://github.com/Dallas-Makerspace/Malum-Game-Engine/blob/master/LICENCE) [![Coverage Status](https://coveralls.io/repos/github/Dallas-Makerspace/Malum-Game-Engine/badge.svg?branch=master)](https://coveralls.io/github/Dallas-Makerspace/Malum-Game-Engine?branch=master)
[![Release](https://img.shields.io/github/tag/Dallas-Makerspace/Malum-Game-Engine.svg?style=flat-square)](https://github.com/Dallas-Makerspace/Malum-Game-Engine/tags)

Find a copy of the latest build at [Docker Hub](https://hub.docker.com/r/dallasmakerspace/Malum-Game-Engine/). Join us .

## Prerequisites

Editor of your choice

Godot Engine

## Setup

```
git clone https://github.com/Dallas-Makerspace/Malum-Game-Engine.git
import the game folder in the godot editor
```

## Branching strategy

http://blog.plasticscm.com/2010/11/linus-on-branching.html
https://stackoverflow.com/questions/30268332/why-does-the-linux-kernel-repository-have-only-one-branch/30268416

TLDR; Commit pull request to master, check out from tagged semantic version. Tagged odd versions should be considered unstable, even considered stable.

## Contributing content or assets

Upload your contribution to the asset branch at https://github.com/Dallas-Makerspace/Malum-Game-Engine/tree/assets

repository: Dallas-Makerspace/Malum-Game-Engine

gha_language: GDScript

repo_name: Dallas-Makerspace/Malum-Game-Engine


text:
# ADR 2022-10-27: Lifetime of RunnerScaleSet on Service

**Date**: 2022-10-27

**Status**: Done

## Context

We have created the RunnerScaleSet object and APIs around it on the GitHub Actions service for better support of any self-hosted runner auto-scale solution, like [actions-runner-controller](https://github.com/actions-runner-controller/actions-runner-controller).

The `RunnerScaleSet` object will represent a set of homogeneous self-hosted runners to the Actions service job routing system.

A `RunnerScaleSet` client (ARC) needs to communicate with the Actions service via HTTP long-poll in a certain protocol to get a workflow job successfully landed on one of its homogeneous self-hosted runners.

In this ADR, we discuss the following within the context of actions-runner-controller's new scaling mode:

- Who and how to create a RunnerScaleSet on the service?
- Who and how to delete a RunnerScaleSet on the service?
- What will happen to all the runners and jobs when the deletion happens?

## RunnerScaleSet creation

- `AutoScalingRunnerSet` custom resource controller will create the `RunnerScaleSet` object in the Actions service on any `AutoScalingRunnerSet` resource deployment.
- The creation is via REST API on Actions service `POST _apis/runtime/runnerscalesets`
- The creation needs to use the runner registration token (admin).
- `RunnerScaleSet.Name` == `AutoScalingRunnerSet.metadata.Name`
- The created `RunnerScaleSet` will only have 1 label and it's the `RunnerScaleSet`'s name
- `AutoScalingRunnerSet` controller will store the `RunnerScaleSet.Id` as an annotation on the k8s resource for future lookup.

## RunnerScaleSet modification

- When the user patch existing `AutoScalingRunnerSet`'s RunnerScaleSet related properly, ex: `runnerGroupName`, `runnerWorkDir`, the controller needs to make an HTTP PATCH call to the `_apis/runtime/runnerscalesets/2` endpoint in order to update the object on the service.
- We will put the deployed `AutoScalingRunnerSet` resource in an error state when the user tries to patch the resource with a different `githubConfigUrl`
  > Basically, you can't move a deployed `AutoScalingRunnerSet` across GitHub entity, repoA->repoB, repoA->OrgC, etc.
  > We evaluated blocking the change before instead of erroring at runtime and that we decided not to go down this route because it forces us to re-introduce admission webhooks (require cert-manager).

## RunnerScaleSet deletion

- `AutoScalingRunnerSet` custom resource controller will delete the `RunnerScaleSet` object in the Actions service on any `AutoScalingRunnerSet` resource deletion.
  > `AutoScalingRunnerSet` deletion will contain several steps:
  >
  > - Stop the listener app so no more new jobs coming and no more scaling up/down.
  > - Request scale down to 0
  > - Force stop all runners
  > - Wait for the scale down to 0
  > - Delete the `RunnerScaleSet` object from service via REST API
- The deletion is via REST API on Actions service `DELETE _apis/runtime/runnerscalesets/1`
- The deletion needs to use the runner registration token (admin).

The user's `RunnerScaleSet` will be deleted from the service by `DormantRunnerScaleSetCleanupJob` if the particular `AutoScalingRunnerSet` has not connected to the service for the past 7 days. We have a similar rule for self-hosted runners.

## Jobs and Runners on deletion

- `RunnerScaleSet` deletion will be blocked if there is any job assigned to a runner within the `RunnerScaleSet`, which has to scale down to 0 before deletion.
- Any job that has been assigned to the `RunnerScaleSet` but hasn't been assigned to a runner within the `RunnerScaleSet` will get thrown back to the queue and wait for assignment again.
- Any offline runners within the `RunnerScaleSet` will be deleted from the service side.

repository: actions/actions-runner-controller

gha_language: Go

repo_name: actions/actions-runner-controller


text:
# update-auth-methods
update-auth-methods.py is an interactive tool for [updating Tenable.IO user authentication methods](https://developer.tenable.com/reference#users-update-auths).

This can be especially useful if:
- You have enabled SAML authentication and want to disable local Tenable.IO authentication.
- You have created an API user and want to disable GUI login.

WARNING: It is possible to lockout accounts with this tool. Do not use this tool if you do not understand how it works.
## Requirements
* Python3
## Installation
update-auth-methods.py is a dependency free, standalone Python program. Just download it and run it.
### git
```
git clone https://github.com/andrewspearson/update-auth-methods.git
```
### curl
```
curl https://raw.githubusercontent.com/andrewspearson/update-auth-methods/main/update-auth-methods.py -O
```

**NOTE:** macOS users running Python 3.6+ will need to [install certificates](https://bugs.python.org/issue28150).
TLDR, run this command:
```
/Applications/Python {version}/Install Certificates.command
```
This seems to only be an issue on macOS.
## Usage
update-auth-methods.py will update the authentication methods for all users in a user group.

It will accept arguments to set a web proxy and disable SSL verification, like this:
```
update-auth-methods.py --proxy '<IP_ADDRESS>:8080' --insecure
```
These arguments are not required. Disabling SSL verification is HIGHLY discouraged.

Example:
![](https://raw.githubusercontent.com/andrewspearson/file-server/main/repositories/update-auth-methods/update-auth-methods.gif)

repository: andrewspearson/update-auth-methods

repo_name: andrewspearson/update-auth-methods


text:
# sn-edit

Download the extension [SN-EDIT - Servicenow Editor Engine](https://marketplace.visualstudio.com/items?itemName=SNEDIT.sn-edit)

The extension provides a bridge between sn-edit and the Visual Studio Code UI. We've created a few simple commands that are useful for daily development and could be used while development.

**For the extension to work correctly:**
- Install **NodeJS** from the [Official Page](https://nodejs.org/en/download/) (At least the LTS version or anything newer)
- Download the [sn-edit](https://docs.sn-edit.com/#/getting-started/README) application, for the instructions, please refer to our [docs site](https://docs.sn-edit.com/#/getting-started/README).

After installing sn-edit, please use the [configuration generator](https://conf.sn-edit.com/) to download your config file.

The capabilities include:
- Downloading of entries
- Uploading entries onsave
- Update set management, like displaying the currently selected update set and setting a new default one that would be used in subsequent calls in your session
- To choose a different update set, just click on the right bottom on the update set name and you should be presented with a list of other update sets
- We support basic authentication only but if there will be popular demand on other types, we are able to do it
- We support scopes, that means your entries will be saved in the specific scope they belong to
- No support for creating new entries for now
- We support searching for tables and their entries inside of vscode. After picking your entry, the entry gets downloaded locally
- Support to run background scripts from local js files (Not supported by the extension yet, but supported by sn-edit)

**Note**: If anyone feels capable enough to take up the challenge of maintaining this project let me know! Feel free to send feedback
and improvement suggestions! Every help is welcome!

We invite every one of you to contribute to this project to make it better for you and for everyone else.


text:
# Data Export

Here some export functionality is documented. Also note that [ExtendableGrids.jl](https://github.com/j-fu/ExtendableGrids.jl) offers an interface
to [WriteVTK.jl](https://github.com/jipolanco/WriteVTK.jl) which can be used in combination with nodevalues interpolations.

```@autodocs
Modules = [GradientRobustMultiPhysics]
Pages = ["dataexport.jl"]
Order   = [:type, :function]
```

gha_language: Julia

gha_license_id: NOASSERTION


text:
---
title: Responsible use
weight: 10
menu:
  docs:
    parent: "Browser checks"
---

Checkly reserves the right to block, remove or otherwise disable any browser checks that are not created for the intented
purpose of monitoring web applications and sites. This means we actively keep an eye out for behavior such as:

- mining crypto currencies
- vandalism (blocking / waiting scripts with no purpose)
- overuse / spamming the interactive script runner

Checkly uses multiple mitigating techniques to make sure this type of behaviour and traffic is flagged and dealed with as
soon as possible. If you have any questions about this, please contact us at<EMAIL_ADDRESS>


text:
# IE8-EventListener
A polyfill for IE8

How can I get it?
-----------------

IE8-EventListener is available through npm and can be installed with the following command:

```
npm install ie8-eventlistener
```

What is it?
-----------

IE8-EventListener strives to add full addEventListener compliance to IE8. Specifically:

* Listeners are executed in the order in which they were added
* Modifying the event object in one listener does not affect the event object in other listeners
* Events not present on window in IE8, but that are supported on document are put on the document but triggered with the window context
* localStorage Storage Events will appear propery in IE8 with the `key`, `newValue`, and `oldValue` properties correctly set as long as `window['ie8-eventlistener/storage'].setItem` is used instead of `window.localStorage.setItem`. Currently does not support the `storageArea` and `url` properties of Storage Events, but those are rarely used.

Why does it exist?
------------------

I wanted to try to support Storage Events for use in https://github.com/tejacques/crosstab, and after scouring the web for polyfills was unable to find one which worked correctly. Using the excellent Financial Times polyfill project as a basis, I added support for Storage Events, and brought the behavior of event listeners closer to the spec.

Inspiration
-----------

* https://github.com/tejacques/crosstab
* https://github.com/Financial-Times/polyfill-service
* https://github.com/jonathantneal/EventListener

Licence
-------

Because this is based on Johnathan Neal's https://github.com/jonathantneal/EventListener and the Financial Times https://github.com/Financial-Times/polyfill-service, this version is released under the CC0 1.0 Universal License


text:
# Frequently Asked Questions
- [Are you thinking what I'm thinking?](#are-you-thinking-what-i'm-thinking)
- [How Frequently are Frequently Asked Questions Asked?](#how-frequently-are-frequently-asked-questions-asked)
- [How much more black could this be?](#how-much-more-black-could-this-be)
- [What are the chances of anything coming from Mars?](#what-are-the-chances-of-anything-coming-from-mars)
- [What does FAQ stand for?](#what-does-faq-stand-for)
- [What happens if you keep using signed 32-bit integers to keep track of time in 2038?](#what-happens-if-you-keep-using-signed-32-bit-integers-to-keep-track-of-time-in-2038)
- [What is the answer to the Ultimate Question of Life, The Universe, and Everything?](#what-is-the-answer-to-the-ultimate-question-of-life,-the-universe,-and-everything)
- [What Python version does FAQtory require?](#what-python-version-does-faqtory-require)
- [What's the difference between a duck?](#what's-the-difference-between-a-duck)
- [When you are in front of a a Minbari fleet, where should you really be if you value your life?](#when-you-are-in-front-of-a-a-minbari-fleet,-where-should-you-really-be-if-you-value-your-life)
- [Where am I?](#where-am-i)
- [Who built FAQtory?](#who-built-faqtory)
- [Who was Joan of Arc?](#who-was-joan-of-arc)
- [Who's the lady with the log?](#who's-the-lady-with-the-log)

## Are you thinking what I'm thinking?

I think so, Brain. But would the villains really have gotten away with it, if it weren't for those pesky kids and their dog

Pinky

## How Frequently are Frequently Asked Questions Asked?

In fact, most *frequently asked questions* have never, and perhaps will
never be asked.

> "89% of statistics are made up on the spot"

  — [*Vic Reeves*](https://www.linkedin.com/pulse/89-statistics-made-up-spot-vic-reeves-friend-llp/)

> "73% of FAQ questions have never, in fact, been asked, and 71% never will be"

  — [*Nick Radcliffe*](https://github.com/njr0/faqtory/blob/main/questions/frequency.question.md)

## How much more black could this be?

None. None more. Black.

Tufnel, Nigel

## What are the chances of anything coming from Mars?

Around a million to one.

Ogilvy

## What does FAQ stand for?

FAQ stands for *Frequently Asked Questions*.

## What happens if you keep using signed 32-bit integers to keep track of time in 2038?

You'll experience an epoch fail.

## What is the answer to the Ultimate Question of Life, The Universe, and Everything?

42

## What Python version does FAQtory require?

FAQtory requires Python3.7 or above.

## What's the difference between a duck?

Somewhere else.

Delenn

## Where am I?

In the village.

Number 2

## Who built FAQtory?

FAQtory was built by [Will McGugan](https://www.willmcgugan.com).

Will is the author of [Rich](https://github.com/Textualize/rich) and [Textual](https://textual.textualize.io).

## Who was Joan of Arc?

Noah's wife.

Theodore Logan

## Who's the lady with the log?

The Log Lady.

Harry S. Truman

Generated by [FAQtory](https://github.com/willmcgugan/faqtory)

repository: willmcgugan/faqtory

gha_language: Python

repo_name: willmcgugan/faqtory


text:
---
title: Presentation - How Not to Freak Out ...
excerpt: How Not to Freak Out When You Start Writing Puppet Modules for Windows
read_time:
category:
  - presentation
header:
  overlay_image: /images/header-puppetconf-2016.png
  overlay_filter: 0.5
  teaser: /images/teaser-puppetconf-2016.png
tags:
  - puppetconf
  - presentation
  - puppet
read_time: false
---

### [PuppetConf 2016 Presentation](http://sched.co/6fjw)

---

Writing your first Puppet module is pretty daunting. There are so many things to set up: tools, repositories, tests! In this presentation we’ll walk through setting up a local Windows development environment, and then write a Puppet module. We’ll also look at debugging, testing and publishing the module to the Puppet Forge.

[Presentation](https://speakerdeck.com/glennsarti/how-not-to-freak-out-when-you-start-writing-puppet-modules-for-windows)

[Recording](https://www.youtube.com/watch?v=9A2-_nPrqfs)

Github Repo with demo code - Coming Soon!


text:
---
layout: page
title: About
permalink: /about/
---

Hi! I'm Wesley Soo-Hoo. I'm a robotics engineering undergraduate student at the Olin College of Engineering. I'm passionate about the power of robotics. I love experimenting with new and innovative ideas that have the power to change the world.

### Olin College

I am currently a student at [Franklin W. Olin College of Engineering](https://olin.edu). Olin is a tiny, engineering-only private college about half an hour outside Boston. Olin is well-known in the academic circles for it's innovative way to teach engineering through project based learning and it's focus on student feedback.

### In Progress

This site is still in progress! Check back later for more details! If you would like to hear more about me, please fel free to contact me with the information below!

### Contact me

[wsoohoo<EMAIL_ADDRESS>[github.com/wsh32](https://github.com/wsh32)


text:
DVR-Scan Changelog

### 1.0.1 (2017-01-12)

 * [bugfix] unhandled exception affecting users running source distributions under Python 2.7 environments

### 1.0 (2017-01-11)

 * [feature] detects motion events with configurable sensitivity and noise removal thresholds
 * [feature] output events to individual video files, or as a single-file compilation
 * [feature] allows input seeking, frame skipping, and output suppression mode
 * [feature] configurable detection windows and pre/post-event inclusion length

repository: nagyistge/DVR-Scan

repo_name: nagyistge/DVR-Scan


text:
# Qlip
Qlip is a simple but effective clipboard manager for Windows. It saves the contents of your clipboard as it changes and gives you quick access to a history of your clips in the order that they appeared on your clipboard.

You don't need to do anything extra to get your clipboard contents into Qlip. As long as Qlip is running, each time you copy a new piece of text, it will be added to your Qlip History. You can bring up the Qlip History Viewer with the global keyboard shortcut CTRL+SHIFT+V. Once open, you can cycle through your history with V, TAB, or the arrow keys. Paste the current clip by either lifting all keys, or by pressing ENTER.

The Qlip preferences menu can be accessed via the Qlip icon in your system tray. Click on the Qlip icon and select "Open Preferences" to edit settings. Editable settings include:

| Setting              | Description
|:---------------------|:-------------
| Save Count           | How many clips to hold on to in history
| Reset on Paste       | Reset history viewer back to start each time you paste
| Reset On Cancel      | Reset history viewer back to start when you cancel a paste
| Paste Timeout        | Amount of time (in seconds) with no user action to wait before auto-pasting
| Move Pasted to Front | Move pasted clip to front of history viewer after paste

### Full list of Qlip functionality (When Qlip History Viewer is open):
| Key         | Action
|:------------|:-------------
| V           | Next Clip
| TAB         | Next Clip
| UP-Arrow    | Next Clip
| RIGHT-Arrow | Next Clip
| DOWN-Arrow  | Previous Clip
| LEFT-Arrow  | Previous Clip
| ENTER       | Paste
| ESC         | Cancel Paste
| HOME        | Go To First Clip In History
| END         | Go To Last Clip In History
| DELETE      | Remove Current Clip From History
| BACKSPACE   | Remove Current Clip From History
| X           | Remove Current Clip From History

### Possible Future Improvements:
- [ ] Exploded view of all clips
- [ ] Allow for saving of binary clips (e.g. images, files, etc.)
- [ ] Make a better logo...

gha_language: C#


text:
# LogCLI - Helm Chart

[![Artifact HUB](https://img.shields.io/endpoint?url=https://artifacthub.io/badge/repository/logcli)](https://artifacthub.io/packages/search?repo=logcli)

This chart deploys a single [LogCLI](https://grafana.com/docs/loki/latest/getting-started/logcli/) container tool to interact with [Loki](https://grafana.com/oss/loki/).

## Installing the Chart

To install the chart with the release name `logcli` run:

```bash
helm repo add logcli https://raw.githubusercontent.com/hansehe/logcli-helm/master/helm/charts
helm repo update
helm install logcli --set loki.addressOverride=<loki_url> logcli/logcli
```

Execute LogCLI statement with:
```bash
kubectl get pods | grep logcli
kubectl exec -it <logcli_pod> -- logcli help
kubectl exec -it <logcli_pod> -- logcli query '{cluster=\"CLUSTER_NAME\"} |= \"error\"'
```

repository: hansehe/logcli-helm

repo_name: hansehe/logcli-helm


text:
# Install Player

## Dependencies

For Player installation the following dependencies are required:

* autotools
* libboost-thread
* libboost-signals
* libcv 2.4
* libhighgui 2.4
* libgdk-pixbuf 2.0
* libgnomecanvas 2
* libgsl0
* libtool
* libxmu
* swig
* libgtk2.0
* libltdl
* libplayerc++ 3.0

```
sudo apt-get install autotools-dev build-essential cmake git subversion libboost-thread-dev libboost-signals-dev libcv2.4 libcv-dev libhighgui2.4 libhighgui-dev libgdk-pixbuf2.0-0 libgdk-pixbuf2.0-dev libgnomecanvas2-0 libgnomecanvas2-dev libgsl0ldbl libgsl0-dev libtool libxmu-dev swig libgtk2.0-dev libplayerc++3.0 libplayerc++3.0-dev libdb5.1-stl libdb5.1-stl-dev
```

## Compile

Now compile and install __Player__ (used revision __9140__):

```
svn co svn://svn.code.sf.net/p/playerstage/svn/code/player/trunk player-svn
cd player-svn
svn up -r9140
mkdir build
cd build
cmake ..
make
sudo make install
```

If you are using a 64bit linux, the Player libraries will be installed to ```/usr/local/lib64```
instead of ```/usr/local/lib``` and Player will fail to load the libraries. Add the following lines
to your ```~/.bashrc```:

```
# Player
export PLAYERPATH="/usr/local/lib":"/usr/local/lib64"
```

## CMake

To compile your player client with cmake add the following lines to your
CMakeLists.txt file:

```
# set search path of cmake
set(CMAKE_MODULE_PATH "/usr/local/share/cmake/Modules")

# These files include macros that make building against Player easier. They provide
# the PLAYER_ADD* macros
include(UsePlayerC++)
include(UsePlayerPlugin)

# add a client which should be be compiled
PLAYER_ADD_PLAYERCPP_CLIENT(${CLIENT_NAME}
    SOURCES ${CLIENT_SRC})
```

Player throws many deprecation warnings because of __Boost.Signals__. To disable
these warnings add the following line to your CMakeLists.txt:

```
add_definitions( -DBOOST_SIGNALS_NO_DEPRECATION_WARNING )
```

## Code Lite

For code completion add the following directory to your tag search path.

```
/usr/local/include/player-3.1
```

repository: Rookfighter/MultiAgentExploration

repo_name: Rookfighter/MultiAgentExploration


text:
dssg-jupyter: Jupyter Resources for Data Science for Social Good
================================================================

This repository contains some of the materials for a summer code camp
for middle school students that focuses on data science for social good.
The repository focuses on the Jupyter materials.  (Why Jupyter?  Because
students find it incredibly empowering to know that they are using the
same tools that professionals use.)

The `Data` directory contains sample data.

The `Notebooks` directory contains the sample notebooks.

repository: stellasylee/dssg-jupyter

repo_name: stellasylee/dssg-jupyter


text:
# Configuration options for the Envoy‑based WAF node

[link-lom]:                     ../../../glossary-en.md#lom
[link-dashboard]:               ../../../user-guides/dashboard/waf.md

[anchor-process-time-limit]:    #processtimelimit
[anchor-ts]:                    #ts
[anchor-tsets]:                 #filtering-mode-settings

Envoy uses pluggable filters defined in the Envoy configuration file to process incoming requests. These filters describe the actions to be performed on the request. For example, an `envoy.http_connection_manager` filter is used to proxy HTTP requests. This filter has its own set of HTTP filters that can be applied to the request.

The Wallarm WAF module is designed as an Envoy HTTP filter. The module's general settings are placed in a section dedicated to the `wallarm` HTTP filter:

```
listeners:
   - address:
     filter_chains:
     - filters:
       - name: envoy.http_connection_manager
         typed_config:
           http_filters:
           - name: wallarm
             typed_config:
              "@type": type.googleapis.com/wallarm.Wallarm
              <the Wallarm WAF module configuration>
              ...
```

!!! warning "Enable request body processing"
    In order to enable the Wallarm WAF module to process an HTTP request body, the buffer filter must be placed before the WAF node in the Envoy HTTP filter chain. For example:

    ```
    http_filters:
    - name: envoy.buffer
      typed_config:
        "@type": type.googleapis.com/envoy.config.filter.http.buffer.v2.Buffer
        max_request_bytes: <maximum request size (in bytes)>
    - name: wallarm
      typed_config:
        "@type": type.googleapis.com/wallarm.Wallarm
        <the Wallarm module configuration>
        ...
    ```

    If the incoming request size exceeds the value of the `max_request_bytes` parameter, then this request will be dropped and Envoy will return the `413` response code (“Payload Too Large”).

## Request filtering settings

The `tsets` section of the file contains the parameters related to request filtering settings:

```
tsets:
- name: ts0
  pdb: /etc/wallarm/proton.db
  lom: /etc/wallarm/lom
  key: /etc/wallarm/license.key
  ts_request_memory_limit: 0
  ...
- name: tsN:
  ...
```

The `ts0` ... `tsN` entries are one or more parameter groups. The groups can have any name (so that they can be referred to later via the [`ts`][anchor-ts] parameter in the `conf` section). At least one group should be present in the WAF node configuration (e.g., with the name `ts0`).

This section has no default values. You need to explicitly specify values in the config file.

!!! info "Definition level"
    This section can be defined on the WAF node level only.

Parameter | Description | Default value
--- | ---- | -----
pdb | Path to the `proton.db` file. This file contains the global settings for request filtering, which do not depend on the application structure. | `/etc/wallarm/proton.db`
lom | Path to the [LOM][link-lom] file that contains information about the protected application and the WAF node settings. | `/etc/wallarm/lom`
key | Path to the file with the Wallarm license key. | `/etc/wallarm/license.key`
ts_request_memory_limit | Limit for the maximum amount of memory that can be used by one instance of proton.db and LOM. If the memory limit is exceeded while processing some request, the user will get the 500 error. The following suffixes can be used in this parameter:

`k` or `K` for kilobytes

`m` or `M` for megabytes

`g` or `G` for gigabyte

Value of `0` turns the limit off. | `0`

##  Postanalytics module settings

The `tarantool` section of the WAF node contains the parameters related to the postanalytics module:

```
tarantool:
  server:
  - uri: localhost:3313
    max_packets: 512
    max_packets_mem: 0
    reconnect_interval: 1
```

The `server` entry is a parameter group that describes the settings for the Tarantool server.

!!! info "Definition level"
    This section can be defined on the WAF node level only.

Parameter | Description | Default value
--- | ---- | -----
uri | String with the credentials used to connect to the Tarantool server. The string format is `IP address` or `domain name:port`. | `localhost:3313`
max_packets | Limit of the number of serialized requests to be sent to Tarantool. To remove the limit, set `0` as the parameter value. | `512`
max_packets_mem | Limit of the total volume (in bytes) of serialized requests to be sent to Tarantool. | `0` (the volume is not limited)
reconnect_interval | Interval (in seconds) between attempts to reconnect to the Tarantool. A value of `0` means that the WAF node will try to reconnect to the server as quickly as possible if the server renders unavailable (not recommended). | `1`

## IP blacklisting settings

The `acls` section of the file contains the parameters related to the IP blacklisting settings:

```
acls:
  - name: acl0
    path: acl0
    mapsize: 1000000
    ...
  - name: aclN
...
```

The `acl0` ... `aclN` entries are one or more parameter groups. The groups can have any name (so that they can be referred to later via the `acl` parameter in the `conf` section).

Parameter | Description | Default value
--- | ---- | -----
path | Directory that will be used to save the state of the ACL.  | -
mapsize | Initial memory size to be allocated for the corresponding ACL. When the limit is reached, the memory will automatically be reallocated, but the API request that attempted to change the ACL and caused the overflow will produce an error, and should be repeated. | -

##  Basic settings

The `conf` section of the Wallarm WAF contains the parameters that influence WAF node's basic operations:

```
conf:
  ts: ts0
  mode: "monitoring"
  mode_allow_override: "off"
  instance: 42
  process_time_limit: 1000
  process_time_limit_block: "attack"
  request_memory_limit: 104857600
  wallarm_status: "off"
  wallarm_status_format: "json"
  acl: acl0
```

!!! info "Definition level"
    For more flexible protection level, this section can be overridden on the route or virtual host level:

    * on the route level:

        ```
        routes:
        - match:
          typed_per_filter_config:
            wallarm:
              "@type": type.googleapis.com/wallarm.WallarmConf
              <the section parameters>
        ```

    * on the virtual host level:

        ```
        virtual_hosts:
        - name: <the name of the virtual host>
          typed_per_filter_config:
            wallarm:
              "@type": type.googleapis.com/wallarm.WallarmConf
              <the section parameters>
        ```
    The parameters in the `conf` section overridden on the route level have priority over the parameters in the section defined on the virtual host level which in turn have higher priority than the parameters listed in the section on the WAF node level.

Parameter | Description | Default value
--- | ---- | -----
ts | One of the parameter groups that is defined in the `tsets` section. This parameter group sets the request filtering rules to be used.
If this parameter is omitted from the `conf` section of the WAF node, then it should be present in the `conf` section overridden on the route or virtual host level.  | -
mode | WAF node mode:

`block` to block malicious requests

`monitoring` to analyze but not block requests

`off` to disable traffic analyzing and processing

 | `block`
mode_allow_override | Allows overriding the WAF node mode that is set via the `mode` parameter with the [LOM][link-lom] rules:

`off`: the LOM rule set is ignored

`strict`: LOM can only strengthen the operation mode.

`on`: it is possible to both strengthen and soften the operation mode

For example, if the `mode` parameter is set to the `monitoring` value and the `mode_allow_override` parameter is set to the `strict` value, then it will be possible to block some requests (`block`) but not to fully disable the WAF node (`off`). | `off`
instance | Application identifier. It is used to visually separate the data of different applications on the [dashboard][link-dashboard]. Only numeric values are allowed.
The application identifiers are used solely for the convenience of data presentation. To correctly separate the data of different applications, the same application identifiers must be set in the Wallarm Console.
Any WAF node will filter traffic for any number of applications without additional configuration.| -
process_time_limit | Limit on the processing time of a single request (in milliseconds). If the request cannot be processed in the defined amount of time, then an error message is recorded to the log file and the request is marked as an `overlimit_res` attack. | `1000`
process_time_limit_block | Action to take when the request processing time exceeds the limit set via the `process_time_limit` parameter:

`off`: the requests are always ignored

`on`: the requests are always blocked

`attack`: depends on the attack blocking mode set via the `mode` parameter:

`off`: the requests are not processed

`monitoring`: the requests are ignored

`block`: the requests are blocked

 | `attack`
wallarm_status | Whether to enable the [WAF node statistics service](../../configure-statistics-service.md). | `false`
wallarm_status_format | Format of the [WAF node statistics](../../configure-statistics-service.md): `json` or `prometheus`. | `json`
acl | One of the parameter groups that is defined in the `acls` section. This parameter group sets the IP blocking configuration.
If this parameter is omitted from the `conf` section of the WAF node, then it should be present in the `conf` section overridden on the route or virtual host level. | -

repository: AnastasiaTWW/product-docs-en

repo_name: AnastasiaTWW/product-docs-en


text:
# AppSignal for vue changelog

## 1.1.3

### Fixed

- [d5c8751](https://github.com/appsignal/appsignal-javascript/commit/d5c8751a183ce6ce24b2f30f56bd582fe0e841ba) patch - Fixed a bug that was preventing Vue3 apps written in TypeScript from starting up.

## 1.1.2

### Changed

- [449d4d4](https://github.com/appsignal/appsignal-javascript/commit/449d4d40381e7e6c13076732a8b4e7f65f94d5db) patch - Update package metadata to be more up-to-date and to specify the package location in the mono repository.
- patch - Update @appsignal/types dependency to 3.0.0.

## 1.1.1

### Changed

- patch - Update @appsignal/types dependency to 2.1.7.

### Fixed

- [038d1b8](https://github.com/appsignal/appsignal-javascript/commit/038d1b8beb4042b2610ee3db1c6b3bdb3c9e881f) patch - Fix distributed sourcemaps to include the referenced source properly.

## 1.1.0

- [66f074c](https://github.com/appsignal/appsignal-javascript/commit/66f074c3e94a209870246771a9d17c13db705d37) minor - Add support for Vue 3

  Vue 3.0+ is now supported. Previously we were relying only on the 2.0 Vue object to install the error handling function. Now we support the two latest major versions of the framework.

  To install AppSignal error tracking:

  ```js
  import { createApp } from 'vue'
  import App from './App.vue'
  import Appsignal from "@appsignal/javascript"
  import { errorHandler } from "@appsignal/vue"
  const appsignal = new Appsignal({
    key: "YOUR FRONTEND API KEY"
  })
  const app = createApp(App)
  app.config.errorHandler = errorHandler(appsignal, app)
  app.mount('#app')
  ```

  More info on [README.md](https://github.com/appsignal/appsignal-javascript/tree/main/packages/vue)

## 1.0.15

- patch - Update @appsignal/types dependency to 2.1.6.

## 1.0.14

- patch - Update @appsignal/types dependency to 2.1.5.

## 1.0.13

- patch - Update @appsignal/types dependency to 2.1.4.

## 1.0.12

- patch - Update @appsignal/types dependency to 2.1.3.

## 1.0.11

- patch - Update @appsignal/types dependency to 2.1.2.

## 1.0.10

- patch - Update @appsignal/types dependency to 2.1.1.

## 1.0.9

- patch - Update @appsignal/types dependency to 2.1.0.

repository: appsignal/appsignal-javascript

gha_language: TypeScript

repo_name: appsignal/appsignal-javascript


text:
An theme base on `Any Dark` and `One Dark Pro` theme.

- https://github.com/teabyii/vscode-ayu
- https://github.com/Binaryify/OneDark-Pro

## Install

```shell
ext install ayu-one-dark
```

Then go to `Preferences > Color Theme > Ayu One Dark`.

## Screenshots

![One Dark](assets/one-dark.png)

repository: faceair/vscode-ayu-onedark

repo_name: faceair/vscode-ayu-onedark


text:
YoctoTools
==========

several helper scripts (installer, toolchain builder, etc) for Yocto Linux

***yocto_dependency_installer.sh*** - (STABLE) requires ROOT. Will detect distro and install dependencies. Run with --help for more info.

***yocto_15_installer.sh*** - (STABLE) Yocto 1.5.1 installer. Will download, unpack and build Yocto 1.5.1 .

***yocto_toolchain_installer.sh*** - Installer to build and deploy toolchain.

***yocto_project_manager.sh*** - Project management (to add source, to recompile, to sort projects)

repository: daemonna/YoctoTools

repo_name: daemonna/YoctoTools


text:
ElasticsearchMonitor
=====

Use elasticsearch sql plugin & mysql, query some meaningful results

Reference
===========

Thanks for great code by NLPchina [elasticsearch-sql](https://github.com/NLPchina/elasticsearch-sql) implementation.

License
=======

This is released under the [MIT License](http://www.opensource.org/licenses/MIT).

repository: lizekui/ElasticsearchMonitor

repo_name: lizekui/ElasticsearchMonitor


text:
# Keylogger for Windows and Mac
## Windows
Simply compile into an .exe, and then run.

There are two files; klog_visible and klog_invisible. It is pretty simple, but I will expand:

`klog_visible` is visible, and the window does not close when typing. Great for testing it out. `klog_invisible` makes the window of the logger disappear, and it also starts up hidden from view. Note that it is still visible in the task manager.

Both of these save the keystrokes to a .txt file when closed.

## Mac
This is a little more complicated, as its Apple after all! Please note, it does not work for secure areas such as password inputs. I have not found a work around yet.

### Installation
Download the repo. It will install in `/usr/local/bin/keylogger`.

Install it:

`$ git clone https://github.com/GiacomoLaw/Keylogger && cd keylogger
$ make && make install`

It will log to `/var/log/keystroke.log`. This may require root access, but you can change that if you want. Set where you want it to log:

`$ keylogger ~/logfile.txt
Logging to: /var/log/keystroke.log`

Want to make it start on system startup?

`$ sudo make uninstall`

That will run it on startup.

### Uninstall
`$ sudo make uninstall`
Will uninstall the program, but not the logs.

---

Please feel free to contribute to fix any problems, or to submit an issue!

Please note, this repo is for educational purposes only. No contributors are to fault for any actions done by this program.