text:
# netbeans-jpf #

This is a plugin to launch JPF on selected application properties (*.jpf) files from within NetBeans. No worries, this is a minimal plugin that mainly starts an external process (JPF), so it doesn't muck with your NetBeans views.

The main functions are

 - start the JPF shell in an external process
 - wait for editor positioning requests from the JPF shell, and show the corresponding source lines

Why is this named differently than all the other projects? Because it is a different kind of project: this is *not* a normal JPF project, i.e. it is not a freeform NetBeans project with the usual JPF directory structure and artifacts. It is a NetBeans module, and it's main artifact is a *.nbm file in the build directory.

repository: MLB-SE/Experiment

repo_name: MLB-SE/Experiment


text:
# Plugin Development Guide
This document describe how to understand, develop and contribute plugin.

There are 2 kinds of plugin
1. [Tracing plugin](#tracing-plugin). Follow the distributed tracing concept to collect spans with tags and logs.
1. [Meter plugin](#meter-plugin). Collect numeric metrics in Counter, Guage, and Histogram formats.

We also provide the [plugin test tool](#plugin-test-tool) to verify the data collected and reported by the plugin. If you plan to contribute any plugin to our main repo, the data would be verified by this tool too.

# Tracing plugin
## Concepts
### Span
Span is an important and common concept in distributed tracing system. Learn **Span** from
[Google Dapper Paper](https://research.google.com/pubs/pub36356.html)  and
[OpenTracing](http://opentracing.io)

SkyWalking supports OpenTracing and OpenTracing-Java API from 2017. Our Span concepts are similar with the paper and OpenTracing.
Also we extend the Span.

There are three types of Span

1.1 EntrySpan
EntrySpan represents a service provider, also the endpoint of server side. As an APM system, we are targeting the
application servers. So almost all the services and MQ-consumer are EntrySpan(s).

1.2 LocalSpan
LocalSpan represents a normal Java method, which does not relate to remote service, neither a MQ producer/consumer
nor a service(e.g. HTTP service) provider/consumer.

1.3 ExitSpan
ExitSpan represents a client of service or MQ-producer, as named as `LeafSpan` at early age of SkyWalking.
e.g. accessing DB by JDBC, reading Redis/Memcached are cataloged an ExitSpan.

### ContextCarrier
In order to implement distributed tracing, the trace across process need to be bind, and the context should propagate
across the process. That is ContextCarrier's duty.

Here are the steps about how to use **ContextCarrier** in a `A->B` distributed call.
1. Create a new and empty `ContextCarrier` at client side.
1. Create an ExitSpan by `ContextManager#createExitSpan` or use `ContextManager#inject` to init the `ContextCarrier`.
1. Put all items of `ContextCarrier` into heads(e.g. HTTP HEAD), attachments(e.g. Dubbo RPC framework) or messages(e.g. Kafka)
1. The `ContextCarrier` propagates to server side by the service call.
1. At server side, get all items from heads, attachments or messages.
1. Create an EntrySpan by `ContextManager#createEntrySpan` or use `ContextManager#extract` to bind the client and server.

Let's demonstrate the steps by Apache HTTPComponent client plugin and Tomcat 7 server plugin
1. Client side steps by Apache HTTPComponent client plugin
```java
            span = ContextManager.createExitSpan("/span/operation/name", contextCarrier, "ip:port");
            CarrierItem next = contextCarrier.items();
            while (next.hasNext()) {
                next = next.next();
                httpRequest.setHeader(next.getHeadKey(), next.getHeadValue());
            }
```

2. Server side steps by Tomcat 7 server plugin
```java
            ContextCarrier contextCarrier = new ContextCarrier();
            CarrierItem next = contextCarrier.items();
            while (next.hasNext()) {
                next = next.next();
                next.setHeadValue(request.getHeader(next.getHeadKey()));
            }

            span = ContextManager.createEntrySpan(“/span/operation/name”, contextCarrier);
```

### ContextSnapshot
Besides across process, across thread but in a process need to be supported, because async process(In-memory MQ)
and batch process are common in Java. Across process and across thread are similar, because they are both about propagating
context. The only difference is that, don't need to serialize for across thread.

Here are the three steps about across thread propagation:
1. Use `ContextManager#capture` to get the ContextSnapshot object.
1. Let the sub-thread access the ContextSnapshot by any way, through method arguments or carried by an existed arguments
1. Use `ContextManager#continued` in sub-thread.

## Core APIs
### ContextManager
ContextManager provides all major and primary APIs.

1. Create EntrySpan
```java
public static AbstractSpan createEntrySpan(String endpointName, ContextCarrier carrier)
```
Create EntrySpan by operation name(e.g. service name, uri) and **ContextCarrier**.

2. Create LocalSpan
```java
public static AbstractSpan createLocalSpan(String endpointName)
```
Create LocalSpan by operation name(e.g. full method signature)

3. Create ExitSpan
```java
public static AbstractSpan createExitSpan(String endpointName, ContextCarrier carrier, String remotePeer)
```
Create ExitSpan by operation name(e.g. service name, uri) and new **ContextCarrier** and peer address
(e.g. ip+port, hostname+port)

### AbstractSpan
```java
    /**
     * Set the component id, which defines in {@link ComponentsDefine}
     *
     * @param component
     * @return the span for chaining.
     */
    AbstractSpan setComponent(Component component);

    AbstractSpan setLayer(SpanLayer layer);

    /**
     * Set a key:value tag on the Span.
     *
     * @return this Span instance, for chaining
     */
    AbstractSpan tag(String key, String value);

    /**
     * Record an exception event of the current walltime timestamp.
     *
     * @param t any subclass of {@link Throwable}, which occurs in this span.
     * @return the Span, for chaining
     */
    AbstractSpan log(Throwable t);

    AbstractSpan errorOccurred();

    /**
     * Record an event at a specific timestamp.
     *
     * @param timestamp The explicit timestamp for the log record.
     * @param event the events
     * @return the Span, for chaining
     */
    AbstractSpan log(long timestamp, Map<String, ?> event);

    /**
     * Sets the string name for the logical operation this span represents.
     *
     * @return this Span instance, for chaining
     */
    AbstractSpan setOperationName(String endpointName);
```
Besides setting operation name, tags and logs, two attributes should be set, which are component and layer,
especially for EntrySpan and ExitSpan

SpanLayer is the catalog of span. Here are 5 values:
1. UNKNOWN (default)
1. DB
1. RPC_FRAMEWORK, for a RPC framework, not an ordinary HTTP
1. HTTP
1. MQ

Component IDs are defined and reserved by SkyWalking project.
For component name/ID extension, please follow [Component library definition and extension](Component-library-settings.md) document.

### Special Span Tags
All tags are available in the trace view, meanwhile,
in the OAP backend analysis, some special tag or tag combination could provide other advanced features.

#### Tag key `status_code`
The value should be an integer. The response code of OAL entities is according to this.

#### Tag key `db.statement` and `db.type`.
The value of `db.statement` should be a String, representing the Database statement, such as SQL, or `[No statement]/`+span#operationName if value is empty.
When exit span has this tag, OAP samples the slow statements based on `agent-analyzer/default/maxSlowSQLLength`.
The threshold of slow statement is defined by following [`agent-analyzer/default/slowDBAccessThreshold`](../setup/backend/slow-db-statement.md)

#### Extension logic endpoint. Tag key `x-le`
Logic endpoint is a concept, which doesn't represent a real RPC call, but requires the statistic.
The value of `x-le` should be JSON format, with two options.
1. Define a separated logic endpoint. Provide its own endpoint name, latency and status. Suitable for entry and local span.
```json
{
  "name": "GraphQL-service",
  "latency": 100,
  "status": true
}
```
2. Declare the current local span representing a logic endpoint.
```json
{
  "logic-span": true
}
```

### Advanced APIs
#### Async Span APIs
There is a set of advanced APIs in Span, which work specific for async scenario. When tags, logs, attributes(including end time) of the span
needs to set in another thread, you should use these APIs.

```java
    /**
     * The span finish at current tracing context, but the current span is still alive, until {@link #asyncFinish}
     * called.
     *
     * This method must be called<br/>
     * 1. In original thread(tracing context).
     * 2. Current span is active span.
     *
     * During alive, tags, logs and attributes of the span could be changed, in any thread.
     *
     * The execution times of {@link #prepareForAsync} and {@link #asyncFinish()} must match.
     *
     * @return the current span
     */
    AbstractSpan prepareForAsync();

    /**
     * Notify the span, it could be finished.
     *
     * The execution times of {@link #prepareForAsync} and {@link #asyncFinish()} must match.
     *
     * @return the current span
     */
    AbstractSpan asyncFinish();
```
1. Call `#prepareForAsync` in original context.
1. Do `ContextManager#stopSpan` in original context when your job in current thread is done.
1. Propagate the span to any other thread.
1. After all set, call `#asyncFinish` in any thread.
1. Tracing context will be finished and report to backend when all spans's `#prepareForAsync` finished(Judged by count of API execution).

## Develop a plugin
### Abstract
The basic method to trace is intercepting a Java method, by using byte code manipulation tech and AOP concept.
SkyWalking boxed the byte code manipulation tech and tracing context propagation,
so you just need to define the intercept point(a.k.a. aspect pointcut in Spring)

### Intercept
SkyWalking provide two common defines to intercept Contructor, instance method and class method.
* Extend `ClassInstanceMethodsEnhancePluginDefine` defines `Contructor` intercept points and `instance method` intercept points.
* Extend `ClassStaticMethodsEnhancePluginDefine` defines `class method` intercept points.

Of course, you can extend `ClassEnhancePluginDefine` to set all intercept points. But it is unusual.

### Implement plugin
I will demonstrate about how to implement a plugin by extending `ClassInstanceMethodsEnhancePluginDefine`

1. Define the target class name
```java
protected abstract ClassMatch enhanceClass();
```

ClassMatch represents how to match the target classes, there are 4 ways:
* byName, through the full class name(package name + `.` + class name)
* byClassAnnotationMatch, through the class existed certain annotations.
* byMethodAnnotationMatch, through the class's method existed certain annotations.
* byHierarchyMatch, through the class's parent classes or interfaces

**Attentions**:
* Never use `ThirdPartyClass.class` in the instrumentation definitions, such as `takesArguments(ThirdPartyClass.class)`, or `byName(ThirdPartyClass.class.getName())`, because of the fact that `ThirdPartyClass` dose not necessarily exist in the target application and this will break the agent; we have `import` checks to help on checking this in CI, but it doesn't cover all scenarios of this limitation, so never try to work around this limitation by something like using full-qualified-class-name (FQCN), i.e. `takesArguments(full.qualified.ThirdPartyClass.class)` and `byName(full.qualified.ThirdPartyClass.class.getName())` will pass the CI check, but are still invalid in the agent codes, **Use Full Qualified Class Name String Literature Instead**.
* Even you are perfectly sure that the class to be intercepted exists in the target application (such as JDK classes), still, don't use `*.class.getName()` to get the class String name. Recommend you to use literal String. This is for
avoiding ClassLoader issues.
* `by*AnnotationMatch` doesn't support the inherited annotations.
* Don't recommend to use `byHierarchyMatch`, unless it is really necessary. Because using it may trigger intercepting
many unexcepted methods, which causes performance issues and concerns.

Example：
```java
@Override
protected ClassMatch enhanceClassName() {
    return byName("org.apache.catalina.core.StandardEngineValve");
}

```

2. Define an instance method intercept point
```java
public InstanceMethodsInterceptPoint[] getInstanceMethodsInterceptPoints();

public interface InstanceMethodsInterceptPoint {
    /**
     * class instance methods matcher.
     *
     * @return methods matcher
     */
    ElementMatcher<MethodDescription> getMethodsMatcher();

    /**
     * @return represents a class name, the class instance must instanceof InstanceMethodsAroundInterceptor.
     */
    String getMethodsInterceptor();

    boolean isOverrideArgs();
}
```
Also use `Matcher` to set the target methods. Return **true** in `isOverrideArgs`, if you want to change the argument
ref in interceptor.

The following sections will tell you how to implement the interceptor.

3. Add plugin define into skywalking-plugin.def file
```properties
tomcat-7.x/8.x=TomcatInstrumentation
```

### Implement an interceptor
As an interceptor for an instance method, the interceptor implements
`org.apache.skywalking.apm.agent.core.plugin.interceptor.enhance.InstanceMethodsAroundInterceptor`
```java
/**
 * A interceptor, which intercept method's invocation. The target methods will be defined in {@link
 * ClassEnhancePluginDefine}'s subclass, most likely in {@link ClassInstanceMethodsEnhancePluginDefine}
*/
public interface InstanceMethodsAroundInterceptor {
    /**
     * called before target method invocation.
     *
     * @param result change this result, if you want to truncate the method.
     * @throws Throwable
     */
    void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class<?>[] argumentsTypes,
        MethodInterceptResult result) throws Throwable;

    /**
     * called after target method invocation. Even method's invocation triggers an exception.
     *
     * @param ret the method's original return value.
     * @return the method's actual return value.
     * @throws Throwable
     */
    Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class<?>[] argumentsTypes,
        Object ret) throws Throwable;

    /**
     * called when occur exception.
     *
     * @param t the exception occur.
     */
    void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments, Class<?>[] argumentsTypes,
        Throwable t);
}
```
Use the core APIs in before, after and exception handle stages.

### Do bootstrap class instrumentation.
SkyWalking has packaged the bootstrap instrumentation in the agent core. It is easy to open by declaring it in the Instrumentation definition.

Override the `public boolean isBootstrapInstrumentation()` and return **true**. Such as
```java
public class URLInstrumentation extends ClassEnhancePluginDefine {
    private static String CLASS_NAME = "java.net.URL";

    @Override protected ClassMatch enhanceClass() {
        return byName(CLASS_NAME);
    }

    @Override public ConstructorInterceptPoint[] getConstructorsInterceptPoints() {
        return new ConstructorInterceptPoint[] {
            new ConstructorInterceptPoint() {
                @Override public ElementMatcher<MethodDescription> getConstructorMatcher() {
                    return any();
                }

                @Override public String getConstructorInterceptor() {
                    return "org.apache.skywalking.apm.plugin.jre.httpurlconnection.Interceptor2";
                }
            }
        };
    }

    @Override public InstanceMethodsInterceptPoint[] getInstanceMethodsInterceptPoints() {
        return new InstanceMethodsInterceptPoint[0];
    }

    @Override public StaticMethodsInterceptPoint[] getStaticMethodsInterceptPoints() {
        return new StaticMethodsInterceptPoint[0];
    }

    @Override public boolean isBootstrapInstrumentation() {
        return true;
    }
}
```

**NOTICE**, doing bootstrap instrumentation should only happen in necessary, but mostly it effect the JRE core(rt.jar),
and could make very unexpected result or side effect.

### Provide Customization Config for the Plugin
The config could provide different behaviours based on the configurations. SkyWalking plugin mechanism provides the configuration
injection and initialization system in the agent core.

Every plugin could declare one or more classes to represent the config by using `@PluginConfig` annotation. The agent core
could initialize this class' static field though System environments, System properties, and `agent.config` static file.

The `#root()` method in the `@PluginConfig` annotation requires to declare the root class for the initialization process.
Typically, SkyWalking prefers to use nested inner static classes for the hierarchy of the configuration.
Recommend using `Plugin`/`plugin-name`/`config-key` as the nested classes structure of the Config class.

NOTE, because of the Java ClassLoader mechanism, the `@PluginConfig` annotation should be added on the real class used in the interceptor codes.

Such as, in the following example, `@PluginConfig(root = SpringMVCPluginConfig.class)` represents the initialization should
start with using `SpringMVCPluginConfig` as the root. Then the config key of the attribute `USE_QUALIFIED_NAME_AS_ENDPOINT_NAME`,
should be `plugin.springmvc.use_qualified_name_as_endpoint_name`.
```java
public class SpringMVCPluginConfig {
    public static class Plugin {
        // NOTE, if move this annotation on the `Plugin` or `SpringMVCPluginConfig` class, it no longer has any effect.
        @PluginConfig(root = SpringMVCPluginConfig.class)
        public static class SpringMVC {
            /**
             * If true, the fully qualified method name will be used as the endpoint name instead of the request URL,
             * default is false.
             */
            public static boolean USE_QUALIFIED_NAME_AS_ENDPOINT_NAME = false;

            /**
             * This config item controls that whether the SpringMVC plugin should collect the parameters of the
             * request.
             */
            public static boolean COLLECT_HTTP_PARAMS = false;
        }

        @PluginConfig(root = SpringMVCPluginConfig.class)
        public static class Http {
            /**
             * When either {@link Plugin.SpringMVC#COLLECT_HTTP_PARAMS} is enabled, how many characters to keep and send
             * to the OAP backend, use negative values to keep and send the complete parameters, NB. this config item is
             * added for the sake of performance
             */
            public static int HTTP_PARAMS_LENGTH_THRESHOLD = 1024;
        }
    }
}
```

# Meter Plugin
Java agent plugin could use meter APIs to collect the metrics for backend analysis.

* `Counter` API represents a single monotonically increasing counter, automatic collect data and report to backend.
```java
import org.apache.skywalking.apm.agent.core.meter.MeterFactory;

Counter counter = MeterFactory.counter(meterName).tag("tagKey", "tagValue").mode(Counter.Mode.INCREMENT).build();
counter.increment(1d);
```
1. `MeterFactory.counter` Create a new counter builder with the meter name.
1. `Counter.Builder.tag(String key, String value)` Mark a tag key/value pair.
1. `Counter.Builder.mode(Counter.Mode mode)` Change the counter mode, `RATE` mode means reporting rate to the backend.
1. `Counter.Builder.build()` Build a new `Counter` which is collected and reported to the backend.
1. `Counter.increment(double count)` Increment count to the `Counter`, It could be a positive value.

* `Gauge` API represents a single numerical value.
```java
import org.apache.skywalking.apm.agent.core.meter.MeterFactory;

ThreadPoolExecutor threadPool = ...;
Gauge gauge = MeterFactory.gauge(meterName, () -> threadPool.getActiveCount()).tag("tagKey", "tagValue").build();
```
1. `MeterFactory.gauge(String name, Supplier<Double> getter)` Create a new gauge builder with the meter name and supplier function, this function need to return a `double` value.
1. `Gauge.Builder.tag(String key, String value)` Mark a tag key/value pair.
1. `Gauge.Builder.build()` Build a new `Gauge` which is collected and reported to the backend.

* `Histogram` API represents a summary sample observations with customize buckets.
```java
import org.apache.skywalking.apm.agent.core.meter.MeterFactory;

Histogram histogram = MeterFactory.histogram("test").tag("tagKey", "tagValue").steps(Arrays.asList(1, 5, 10)).minValue(0).build();
histogram.addValue(3);
```
1. `MeterFactory.histogram(String name)` Create a new histogram builder with the meter name.
1. `Histogram.Builder.tag(String key, String value)` Mark a tag key/value pair.
1. `Histogram.Builder.steps(List<Double> steps)` Set up the max values of every histogram buckets.
1. `Histogram.Builder.minValue(double value)` Set up the minimal value of this histogram, default is `0`.
1. `Histogram.Builder.build()` Build a new `Histogram` which is collected and reported to the backend.
1. `Histogram.addValue(double value)` Add value into the histogram, automatically analyze what bucket count needs to be increment. rule: count into [step1, step2).

# Plugin Test Tool
[Apache SkyWalking Agent Test Tool Suite](https://github.com/apache/skywalking-agent-test-tool)
a tremendously useful test tools suite in a wide variety of languages of Agent. Includes mock collector and validator.
The mock collector is a SkyWalking receiver, like OAP server.

You could learn how to use this tool to test the plugin in [this doc](Plugin-test.md). If you want to contribute plugins
to SkyWalking official repo, this is required.

# Contribute plugins into Apache SkyWalking repository
We are welcome everyone to contribute plugins.

Please follow there steps:
1. Submit an issue about which plugins you are going to contribute, including supported version.
1. Create sub modules under `apm-sniffer/apm-sdk-plugin` or `apm-sniffer/optional-plugins`, and the name should include supported library name and versions
1. Follow this guide to develop. Make sure comments and test cases are provided.
1. Develop and test.
1. Provide the automatic test cases. Learn `how to write the plugin test case` from this [doc](Plugin-test.md)
1. Send the pull request and ask for review.
1. The plugin committers approve your plugins, plugin CI-with-IT, e2e and plugin tests passed.
1. The plugin accepted by SkyWalking.

repository: zhentaoJin/skywalking

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: zhentaoJin/skywalking


text:
# Installation

## Short way

Build a container locally:

```
# docker build -t gtoonstra/databook:0.1.0 .
```

Then just run it from the docker compose. There's a couple of shortcuts in that approach,
but it's the fastest way:

```
# ./run_databook.sh
```

This will download docker containers for:
- postgres
- airflow (puckel)
- elasticsearch
- neo4j

Start the containers for you and then you can log into the following apps:

localhost:8080 (airflow)
localhost:5000 (databook)
localhost:7474 (neo4j)
localhost:9200 (elasticsearch)

See the respective apps for more information.

To get started:

- From airflow, run the DAG "init_airflow", wait to finish.
- From airflow, run DAG "load_neo4j_data", wait to finish.

This will populate neo4j with some test data, transfer this to elasticsearch for
the search functionality and you can take it from there (access databook!)

### Change / contribute stuff?

See the "dag" directory where everything goes (for the moment). Change/add hooks and
operators from there.

You can add additional packages in the "requirements.txt" script in docker/airflow,
which will add some other deps you may need for additional operators.

# Long way around

Only follow this if you hate docker and you can face the pain
of neo4j version hell, elasticsearch integration and python version
incompatibility...

## Install neo4j and elasticsearch

Assuming the elasticsearch API is stable, you can use the latest version of ElasticSearch.

Neo4j has restrictions on the version utilized there because it uses plugins for APOC and
a project that integrates neo4j with elasticsearch. At the time of writing I use neo4j 3.2.3.

I used a manual install process for Debian that is described here:

https://neo4j.com/docs/operations-manual/current/installation/linux/debian/

Then use:

sudo apt-get install neo4j=3.3.0

This should complete the installation for neo4j. Check that it's working, otherwise
start its service:

> sudo service neo4j restart

Then, download 4 plugins:

- APOC for 3.3.0:

https://github.com/neo4j-contrib/neo4j-apoc-procedures/releases

- Elastic search plugins as listed on this page for version 3.3.1 (fixes bug in 3.3.0):

https://github.com/graphaware/neo4j-to-elasticsearch

(points to)

https://graphaware.com/products/#download_products

where you'll want:
- GraphAware Framework
- GraphAware Neo4j2Elastic
- GraphAware UUID (optional)

Modify the config of neo4j according to the instructions on the github plugin page:

https://github.com/graphaware/neo4j-to-elasticsearch

Make sure ElasticSearch is running:

> sudo service elasticsearch restart

Check:

http://localhost:9200/

Then restart neo4j:

> sudo service neo4j restart

Check:

http://localhost:7474/browser/

You can query elasticsearch through the following:

http://localhost:9200/_cat/indices

http://localhost:9200/neo4j-index-node/_search?q=Jimmy

### Install a virtual environment

Execute setup_venv.sh:

```
# ./setup_venv.sh
```

Source the environment:

```
# source venv/bin/activate
```

Install the pip requirements:

```
# pip install -r requirements.txt
```

Start the www frontend:

```
# cd www
# python3 app.py
```

Visit http://localhost:5000/  to see the index page

repository: rizplate/databook

repo_name: rizplate/databook


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

### Description

Use-after-free vulnerability in the mozilla::DataChannelConnection::Close function in Mozilla Firefox before 45.0 and Firefox ESR 38.x before 38.7 allows remote attackers to execute arbitrary code by leveraging mishandling of WebRTC data-channel connections.

### POC

#### Reference
- http://www.oracle.com/technetwork/topics/security/linuxbulletinjan2016-2867209.html

#### Github
- https://github.com/ARPSyndicate/cvemon

license: MIT

repository: trickest/cve

branch_name: refs/heads/main

gha_language: HTML

gha_license_id: MIT

repo_name: trickest/cve


text:
# Article Evaluator with Natural Language Processing

> This project showcases a web tool that allows users to run Natural Language Processing (NLP) on articles or blogs found on other websites using pure HTML, CSS, Javascript, Express and Webpack.

![](html-js-css-logo.png)![](node-webpack-logo.png)

![GitHub](https://img.shields.io/github/license/mashape/apistatus.svg)

## Article Evaluator App

![](article-evaluator-app-screenshot.jpg)

Visit the website [here](https://article-evaluator.herokuapp.com/)

## Installation

### Setup

Clone the source locally:

```sh
$ git clone https://github.com/thepembeweb/article-evaluator.git
$ cd article-evaluator
```
If you're on Debian or Ubuntu, you'll also need to install
`nodejs-legacy`:

Use your package manager to install `npm`.

```sh
$ sudo apt-get install npm nodejs-legacy
```

Install project dependencies:

```sh
$ npm install
```

Create a new .env file and add the following environment variables for the [Aylien API](https://docs.aylien.com/textapi/endpoints/#api-endpoints):

```sh
API_ID=**************************
API_KEY=**************************
```

Start the server app:

```sh
$ npm start
```

Open another terminal and start the client app:

```sh
$ npm run dev
```

Alternatively you can view the live website [here](https://article-evaluator.herokuapp.com/).

## Built With

* [HTML](https://en.wikipedia.org/wiki/HTML) - The markup language used
* [CSS](https://en.wikipedia.org/wiki/Cascading_Style_Sheets) - The style sheet language used
* [Javascript](https://en.wikipedia.org/wiki/JavaScript) - The programming language used
* [Node.js®](https://nodejs.org/) - The JavaScript runtime used
* [Express.js®](https://nodejs.org/) - The web application framework used
* [Webpack](https://webpack.js.org/) - The build tool used
* [Aylien API](https://docs.aylien.com/textapi/endpoints/#api-endpoints) - The Natural Language Processing API used

## Authors

* **[Pemberai Sweto](https://github.com/thepembeweb)** - *Initial work* - [Article Evaluator Project](https://github.com/thepembeweb/article-evaluator)

## License

[![License](http://img.shields.io/:license-mit-green.svg?style=flat-square)](http://badges.mit-license.org)

- This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details
- Copyright 2020 © [Pemberai Sweto](https://github.com/thepembeweb).

repository: thepembeweb/article-evaluator

gha_language: JavaScript

repo_name: thepembeweb/article-evaluator


text:
# PyRCN
A Python 3 framework for Reservoir Computing with a [scikit-learn](https://scikit-learn.org/stable/)-compatible API.

PyRCN ("Python Reservoir Computing Networks") is a light-weight and transparent Python 3 framework for Reservoir Computing (currently only implementing Echo State Networks) and is based on widely used scientific Python packages, such as numpy or scipy. The API is fully scikit-learn-compatible, so that users of scikit-learn do not need to refactor their code in order to use the estimators implemented by this framework. Scikit-learn's built-in parameter optimization methods and example datasets can also be used in the usual way.

PyRCN is used by the [Chair of Speech Technology and Cognitive Systems, Institute for Acoustics and Speech Communications, Technische Universität Dresden, Dresden, Germany](https://tu-dresden.de/ing/elektrotechnik/ias/stks?set_language=en) and [IDLab (Internet and Data Lab), Ghent University, Ghent, Belgium](https://www.ugent.be/ea/idlab/en).

Currently, it implements Echo State Networks (ESNs) by Herbert Jaeger in different flavors, e.g. Classifier and Regressor. It is actively developed to be extended into several directions:

- Incorporate Feedback
- Better sequence handling with [sktime](http://sktime.org/)
- A unified API to stack ESNs
- More towards future work: Related architectures, such as Liquid State Machines (LSMs) and Perturbative Neural Networks (PNNs)

PyRCN has successfully been used for several tasks:

- Music Information Retrieval (MIR)
    - Multipitch tracking
    - Onset detection
- Time Series Prediction
    - Mackey-Glass benchmark test
    - Stock price prediction
- Ongoing research tasks:
    - Beat tracking in music signals
    - Pattern recognition in sensor data
    - Phoneme recognition

Please see the [References section](#references) for more information. For code examples, see [Getting started](#getting-started).

# Installation

## Prerequisites

PyRCn is developed using Python 3.6 or newer. It depends on the following packages:

- [numpy>=1.18.1](https://numpy.org/)
- [scipy>=1.2.0](https://scipy.org/)
- [scikit-learn>=0.23.1](https://scikit-learn.org/stable/)
- [joblib>=0.13.2](https://joblib.readthedocs.io)
- [pandas>=1.0.0](https://pandas.pydata.org/)
- [matplotlib](https://matplotlib.org/)
## Installation from PyPI

The easiest and recommended way to install ``PyRCN`` is to use ``pip`` from [PyPI](https://pypi.org) :

```python
pip install pyrcn
```

## Installation from source

If you plan to contribute to ``PyRCN``, you can also install the package from source.

Clone the Git repository:

```
git clone https://github.com/TUD-STKS/PyRCN.git
```

Install the package using ``setup.py``:
```
python setup.py install --user
```

# Package structure
The package is structured in the following way:

- `doc`
    - This folder includes the package documentation.
- `examples`
    - This folder includes example code as Jupyter Notebooks and python scripts.
- `images`
    - This folder includes the logos used in ´README.md´.
- `pyrcn`
    - This folder includes the actual Python package.

# Getting Started

PyRCN includes currently variants of Echo State Networks (ESNs) and Extreme Learning Machines (ELMs): Regressors and Classifiers.

Basic example for the ESNClassifier:

```python
from pyrcn.echo_state_network import ESNClassifier

clf = ESNClassifier()
clf.fit(X=X_train, y=y_train)

y_pred_classes = clf.predict(X=X_test)  # output is the class for each input example
y_pred_proba = clf.predict_proba(X=X_test)  #  output are the class probabilities for each input example
```

Basic example for the ESNRegressor:

```python
from pyrcn.echo_state_network import ESNRegressor

reg = ESNRegressor()
ref.fit(X=X_train, y=y_train)

y_pred = reg.predict(X=X_test)  # output is the prediction for each input example
```

An extensive introduction to getting started with PyRCN is included in the [examples](https://github.com/TUD-STKS/PyRCN/blob/master/examples) directory. The notebook [digits](https://github.com/TUD-STKS/PyRCN/blob/master/examples/digits.ipynb) or its corresponding [Python script](https://github.com/TUD-STKS/PyRCN/blob/master/examples/digits.py) show how to set up an ESN for a small hand-written digit recognition experiment.

Launch the digits notebook on Binder:

[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/TUD-STKS/PyRCN/master?filepath=examples%2Fdigits.ipynb)

Fore more advanced examples, please have a look at our [Automatic Music Transcription Repository](https://github.com/TUD-STKS/Automatic-Music-Transcription), in which we provide an entire feature extraction, training and test pipeline for multipitch tracking and for note onset detection using PyRCN.

# Citation

If you use PyRCN, please cite the following publication:

```latex
@misc{steiner2021pyrcn,
      title={PyRCN: Exploration and Application of ESNs},
      author={Peter Steiner and Azarakhsh Jalalvand and Simon Stone and Peter Birkholz},
      year={2021},
      eprint={2103.04807},
      archivePrefix={arXiv},
      primaryClass={cs.LG}
}
```

# References
Glottal Closure Instant Detection using Echo State Networks

```latex
@InProceedings{src:Steiner-21a,
	title = {Glottal Closure Instant Detection using Echo State Networks},
	author = {Peter Steiner and Ian S. Howard and Peter Birkholz},
	year = {2021},
	pages = {161--168},
	keywords = {Oral},
	booktitle = {Studientexte zur Sprachkommunikation: Elektronische Sprachsignalverarbeitung 2021},
	editor = {Stefan Hillmann and Benjamin Weiss and Thilo Michael and Sebastian Möller},
	publisher = {TUDpress, Dresden},
	isbn = {978-3-95908-227-3}
}
```

Cluster-based Input Weight Initialization for Echo State Networks

```latex
@misc{src:Steiner-21b,
    title={Cluster-based Input Weight Initialization for Echo State Networks},
    author={Peter Steiner and Azarakhsh Jalalvand and Peter Birkholz},
    year={2021},
    eprint={2103.04710},
    archivePrefix={arXiv},
    primaryClass={cs.LG}
}
```

PyRCN: Exploration and Application of ESNs

```latex
@misc{steiner2021pyrcn,
      title={PyRCN: Exploration and Application of ESNs},
      author={Peter Steiner and Azarakhsh Jalalvand and Simon Stone and Peter Birkholz},
      year={2021},
      eprint={2103.04807},
      archivePrefix={arXiv},
      primaryClass={cs.LG}
}
```

Note Onset Detection using Echo State Networks

```latex
@InProceedings{src:Steiner-20a,
	title = {Note Onset Detection using Echo State Networks},
	author = {Peter Steiner and Simon Stone and Peter Birkholz},
	year = {2020},
	pages = {157--164},
	keywords = {Poster},
	booktitle = {Studientexte zur Sprachkommunikation: Elektronische Sprachsignalverarbeitung 2020},
	editor = {Ronald Böck and Ingo Siegert and Andreas Wendemuth},
	publisher = {TUDpress, Dresden},
	isbn = {978-3-959081-93-1}
}
```

Feature Engineering and Stacked ESNs for Musical Onset Detection

```latex
@INPROCEEDINGS{src:Steiner-20d,
    author={Peter Steiner and Simon Stone and Azarakhsh Jalalvand and Peter Birkholz},
    booktitle={2020 25th International Conference on Pattern Recognition (ICPR)},
    title={Feature Engineering and Stacked ESNs for Musical Onset Detection},
    year={2020},
    volume={},
    number={},
    note={submitted},
}
```

Multipitch tracking in music signals using Echo State Networks
```latex
@INPROCEEDINGS{src:Steiner-20b,
    author={Peter Steiner and Simon Stone and Peter Birkholz and Azarakhsh Jalalvand},
    booktitle={28th European Signal Processing Conference (EUSIPCO), 2020},
    title={Multipitch tracking in music signals using Echo State Networks},
    year={2020},
    note={accepted},
}
```

Multiple-F0 Estimation using Echo State Networks

```latex
@inproceedings{src:Steiner-19,
  title={Multiple-F0 Estimation using Echo State Networks},
  booktitle={{MIREX}},
  author={Peter Steiner and Azarakhsh Jalalvand and Peter Birkholz},
  year={2019},
  url = {https://www.music-ir.org/mirex/abstracts/2019/SBJ1.pdf}
}
```

# Acknowledgements
This research is funded by the European Social Fund (Application number: 100327771) and co-financed by tax funds based on the budget approved by the members of the Saxon State Parliament, and by Ghent University.

repository: ManuNeuro/PyRCN

repo_name: ManuNeuro/PyRCN


text:
"League" PHP API Library
======

A simple PHP library for the official League of Legends API

Still heavily in development. Currently supports getting Summoner data and Champion data. Can also request specific summoner stats for champions or game types.

Requirements
---------
* PHP >=5.3
* PHP Curl Extension

Installation
---------
You can install this library using composer. Learn about composer @ [getcomposer.org](http://getcomposer.org/)

1) Require the package in your composer.json

    "sct/league": "dev-master"

2) Run Composer to install the new requirement

    php composer.phar install
or

    php composer.phar update

Now make sure you are using the composer autoload in your project:

    require 'vendor/autoload.php';

    use sct\League\Summoner;

    $summoner = new Summoner("summoner", "region", "APIKEY");

And thats it you are good to go.

Usage
---------

Getting Summoner Data

    $dyrus = new Summoner("Dyrus", "na", "api key");

    $dyrus->getSummonerLevel();
    $dyrus->getStats();
    $dyrus->getRankedStats();
    $dyrus->getStatsForGameType(GameType::Unranked);
    $dyrus->getStatsForChampionByName("Darius");
    $dyrus->getMatchHistory();
    $dyrus->getMasteries();
    $dyrus->getRunes();

Getting Champion Data

    Champions::loadChampions("na", "api key");

    $anivia = Champions::getChampion("Anivia");

    $anivia->getActive();
    $anivia->getRanks();
    $anivia->getRankedPlayEnabled();

License
---------
This project is licensed under the MIT License. Feel free to do whatever you want with it.

Todo
---------
* Implement proper exceptions for all API requests
* Implement API calls for league (ranked) information. (Silver tier lists, and such)
* Implement API calls for team information

*This product is not endorsed, certified or otherwise approved in any way by Riot Games, Inc. or any of its affiliates.*

repository: tristanbes/League

repo_name: tristanbes/League


text:
# Swap keys for laptop

Laptop keyboards are definitively not emacs user friendly. This is my
configuration file for swapping keys like fn, ctrl\_l, right key with ctrl\_l.

This link shows all the desired tricks as well:

https://help.ubuntu.com/community/AppleKeyboard#Change%20Function%20Key%20behavior

# MX Keys Mac

Some keys are interverted and the file allows to swap the ALT and Command keys.

license: Unlicense


text:
# 1.5.0
* Updated `jss` to 8.1.
* Updated Flow definitions.
* Wrapped errors in `__DEV__` environment checks.

# 1.4.2
* Fixed an issue with the lerna package.

# 1.4.1
* Updated `react` to 15.6.
* Updated `prop-types` to 15.5.10.

# 1.4.0
* Updated IE requirement to 11+.
* Updated to include src/ files in the published package.

# 1.3.0
* Updated to support React 15.5 and the new `prop-types` package.
* Updated JSS to 7.1.

repository: cuevash/aesthetic

repo_name: cuevash/aesthetic


text:
---
layout: post
status: publish
published: false
title: Clippy Public Beta 0.1.6 is in progress
author:
  display_name: Dylan Taylor
  login: dylanmtaylor
  email<EMAIL_ADDRESS>date: '2010-08-21 21:17:16 +0000'
date_gmt: '2010-08-21 21:17:16 +0000'
---

I've been working on the next iteration of the Clippy project, Clippy Public Beta 0.1.6. In this release, I have made several major changes already, including:

All reading/writing to the database is now handled by the Clippy Service

Adding a notification bar icon, as well as a notification that allows you to easily get back into Clippy from the notification bar

Created a custom notification layout for usage in the notification bar

Fixing a major bug where rotating the screen would restart the Clippy Service (only noticeable in verbose mode)

Moving most hard-coded strings into a string resource file to allow for easier localization

Adding several additional log messages

Implementing an AIDL interface to allow other classes to interact with the service

Added several more preferences in the settings menu

Added debugging tools, including the ability to replace all of your clippings with sample content copied from Wikipedia

Completely recreated the "About" tab layout from scratch, using much better written code

Enabled the "testing mode" for AdMob ads when the application is running in the emulator

The find functionality now works perfectly, and the background of the interface for find is now transparent instead of being solid black

The "Search" button now opens/closes the find bar for easy access to the find functionality

Added a preference to the Settings screen that allows you to choose whether or not the find function is case sensitive (by default, the find function does not pay attention to case)

And several other, less noteworthy improvements. I am planning on releasing this new version to the Android Market soon.

extension: markdown


text:
This sample Android app demonstrates
creating an app widget for both the home screen and for Android 4.x device lockscreens.

This app is covered in
[the chapter on app widgets](https://commonsware.com/Android/previews/home-screen-app-widgets)
in [*The Busy Coder's Guide to Android Development*](https://commonsware.com/Android/).

gha_language: Java


text:
---
layout: post
title: "Here I Come to Save the Day"
excerpt: "Global"
categories: global
comments: false
share: true
---

![](https://pbs.twimg.com/media/CaBBoyCUUAAtS4F.jpg)

Last week, Trump introduced us to the stupidest idea ever; arming teachers to prevent school shootings.

This week, he said the stupidest thing ever;

“You know, I really believe you don't know until you test it, but I think I'd run in there even if I didn't have a weapon.”

God, amazing huh.

But not amazing that Trump said this. I mean hell, we all knew something like this was coming. In fact, this is an absolutely typical thing he would say.

Let's analyze his three-pronged method:

1. Make it about himself

2. Exalt himself

3. Demean others

He does this all the time. No matter how tragic or how innocent the event is, he will:

1. Make it about himself: 'I.........'. The most commonly used word in his vocabulary

2. Exalt himself: '...run in there even if I didn't have a weapon'. Such bravery, so bold, so powerful.

3. Demean others: this was in response to the fact that there were multiple police deputies who did not enter the school.

I am not sure what Trump would actually have in mind if he ran in. Maybe he would bounce bullets off his magic cuff links like Wonder Woman, or maybe he would dodge the bullets like the Matrix, limboing around the shots in slo-mo like Neo.   But here is the president, doing his three-pronged method on a national tragedy.

No, that is not the amazing part. The amazing part is that the President of your country actually said this. Yes, this is seriously the stupidest thing ever said by a president. And your country elected him. Simply amazing huh.

He really should be impeached for that comment.  Even if he has done everything else right (Lord knows that is NOT the case, but go with me on this), he should be fired for this comment. I mean this demonstrates a stupidity beyond a normal ill-placed comment.

Seriously. Think about this. The President of the United States said he would run into a mass school shooting without a gun, implying he would save everyone from certain death.  That is something that a 1st grader would say to try to impress his friends, only for his fellow classmates to tease him for being so stupidly pathetic.

I don't have anything else to say about this. It is amazing and not amazing at the same time.

And yet 30% of America thinks he is doing great.

ARGHHH!!!!!


text:
---
title: "Overview of Borrowing By-Law"
author<EMAIL_ADDRESS>tags: ["Rajah","Contract Overviews","Borrowing By-Law"]
date: 2017-03-30 13:58:05
description: "Overview of Borrowing By-Law

What is this document?

This corporate by-law, often referred to as “By-Law No. 2”, is a by-law that is approved by the directors and shareholders of the corporation o..."
---

Overview of Borrowing By-Law

What is this document?

This corporate by-law, often referred to as “By-Law No. 2”, is a by-law that is approved by the directors and shareholders of the corporation once the entity has been incorporated. It authorizes the directors of the corporation to incur and issue debt on behalf of the corporation.

When would I use this document?This document is one of the two standard by-laws that are usually approved shortly after a corporation has been incorporated. It is approved in conjunction with the General By-Law, also known as “By-Law No. 1”. It is one element of the corporation’s minute book.

Who signs this Agreement?This by-law is signed by the Secretary of the corporation and then approved in a resolution signed by the directors,  and in a resolution signed by the shareholders of the corporation. If any shareholder is not an individual, but rather a corporation or other entity, it will be signed by an authorized signing officer on behalf of the corporate shareholder.

More details about this document:It is important that this document be approved in resolutions signed by both the applicable directors and the shareholders. The directors enact the by-law while the shareholders confirm the by-law. In practice, this can often be the joint resolutions of one sole director and shareholder in the case of a small business.

Once approved, this document should be kept safely as a record in the corporation’s minute book. This will be an important document for when the corporation seeks to borrow money, issue debt, loan money, or create any security interests on corporate property and assets. As such, the drafter should take care to read, understand, and customize the by-law as needed.

What are the core elements of this document?The core elements include: the Power to Borrow and the creation of Directors’ Committees. Additional clauses could include limitations on borrowing power.

Related DocumentsMinute Book - this is where the corporate records are kept.Directors’ Resolution - Director’s have to enact the by-law with this resolution.Shareholders’ Resolution - Shareholders are required to confirm the by-law. General By-Law - a by-law setting out the requirements for officers, meetings, quorum etc. all dealing with the internal governance of the corporation

repository: JaninaFe/clausehound-blog

repo_name: JaninaFe/clausehound-blog


text:
# Flask / Python3 / JWT / Argon2 / MySQL 8 / Nginx / uWSGI

This project is a simple template to perform signup and login with flask on python3

## Getting Started

git clone git@github.com:cmontedonico/flask-JWT-Argon.git

### Prerequisites

What things you need to install the software and how to install them

```
You need to preinstall Python3 on your computer.
Probably is better to use some Docker Image

Also this project uses MySQL 8.0, so use this

$ docker pull mysql:8.0
```

## DOCKERFILE quick testing
Create the image called flask-sample
```
$ docker build -t flask-sample:latest .
```

Then run the image
```
$ docker run -d -p 8080:8080 flask-sample
```

Open this URL to get the API response
http://<IP_ADDRESS>:8080

### Installing

Create the VirtualEnv and install dependencies
```
$ python3 -m venv venv
$ . venv/bin/activate
$ pip3 install -r requirements.txt
```

Change settings.py to your MySQL connection DATA

```
mysql+mysqlconnector://root:root@<IP_ADDRESS>:3306/database
```

And finally run the project
```
$ python3 server.py
```

this should start the server on
http://<IP_ADDRESS>:8080

## Deployment for production

In production i suggest to use NGINX wiht uWSGI as a service.

```
sudo rm /etc/nginx/sites-enabled/default
sudo ln -s /var/www/flask-JWT-Argon/app_nginx.conf /etc/nginx/conf.d
sudo mkdir -p /var/log/uwsgi
sudo chown ubuntu:www-data /var/log/uwsgi
sudo chmod g+w /var/log/uwsgi
```

Restart nginx, and start uWSGI with our config file (delete the log file after to avoid a permissions issue in the next step).
```
sudo /etc/init.d/nginx restart
rm /var/log/uwsgi/demoapp_uwsgi.log
uwsgi --ini /var/www/flask-JWT-Argon/app_uwsgi.ini
```

Now, visiting the IP address should show our Flask app. However, we want uWSGI to run as a background service, using uWSGI Emperor and systemd. We set up new directories and config files to do so.
```
sudo mkdir -p /etc/uwsgi/vassals
sudo ln -s /var/www/flask-JWT-Argon/app_uwsgi.ini /etc/uwsgi/vassals
sudo cp uwsgi.service /etc/systemd/system
sudo systemctl enable uwsgi
sudo systemctl start uwsgi
```

## Built With

* [Flask](http://flask.pocoo.org/)
* [MySQL 8.0](http://www.mysql.com)

## Authors

* **Cesare Montedonico** - *Initial work* - [Twitter](https://www.twitter.com/cmontedonico)

## License

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

repository: cmontedonico/flask-JWT-Argon

repo_name: cmontedonico/flask-JWT-Argon


text:
# Amazon Inc.

## What are the parameters in training a decision tree ?
- **max_depth** : This indicates how deep the tree can be. The deeper the tree, the more splits it has and it captures more information about the data.
- **min_samples_split** : min_samples_split represents the minimum number of samples required to split an internal node.
- **min_samples_leaf**: min_samples_leaf is The minimum number of samples required to be at a leaf node.
- **max_features** : max_features represents the number of features to consider when looking for the best split.

## What are the criteria for splitting at a node in decision trees ?
- **CART (Classification and Regression Trees)** → uses Gini Index(Classification) as metric.
- **ID3 (Iterative Dichotomiser 3)** → uses Entropy function and Information gain as metrics.

## What is the formula of Gini index criteria?
## What is the formula for Entropy criteria?
## How is it decided that on which features it has to split ?
## How do you calculate information gain mathematically ?

Read this post for all the answers</br>
[Decision Trees Algorithms](https://medium.com/deep-math-machine-learning-ai/chapter-4-decision-trees-algorithms-b93975f7a1f1)

repository: ashoklathwal/MLInterview

path: /MLInterview Questions.md

filename: MLInterview Questions.md

repo_name: ashoklathwal/MLInterview


text:
##  Inventory Usage Update (USAGE.P1)

<PageHeader />

**Form Details**
[ Form Details ](USAGE-P1-1/README.md)

**Purpose**
The USAGE.P1 procedure updates the Usage History file (USAGE) with the
accumulated usage for the period specified. The operator must specify the
first and last day of the month for which the accumulation is to be performed.
This procedure can only be run for one month at a time.

There is a "run for previous month" check box that, when checked, allows the
procedure to run for the month immediately prior to the dates entered. This is
meant to be used when running the USAGE.P1 procedure as part of the nightly
update process. Normally, you do not want to run this procedure during the
current month, as it may skew the statistics. Therefore, placing this into the
nightly process and checking the box will cause the procedure to run every
night. The intent is to alleviate having to remember to run it after each
month.

The procedure selects all of the inventory transactions (IT) which occured
during the month specified and determines which of them constitute a usage of
material. The procedures considers usage to be any transaction which moved
materials from a physical to a non-physical location. This includes movements
to work orders and shipments, it does not include transactions created by
debits against purchase order receipts since those transactions constitute a
return rather than a consumption of the materials. Also not included are
records generated as a result of a cycle or physical inventory.

All months currently maintained which are in excess of the number of months defined in the [ INV.CONTROL ](../../../../../../../../rover/AP-OVERVIEW/AP-ENTRY/AP-E/AP-E-2/INV-CONTROL) record will be dropped.

**Frequency of Use**
This procedure should be run at the end of each month after all inventory
transactions have been entered It is usually included in the month end batch
processing queue.

**Prerequisites**
All of the inventory transactions for the period should be entered prior to
running this procedure.

<badge text= "Version 8.10.57" vertical="middle" />

<PageFooter />

repository: zumasys/docs

repo_name: zumasys/docs


text:
# Isthmotricladia britannica Descals, 1982 SPECIES

#### Status
ACCEPTED

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
in Descals & Webster, Trans. Br. mycol. Soc. 78(3): 417 (1982)

#### Original name
Isthmotricladia britannica Descals, 1982

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
#to see your face again

Here "face" stands for the whole person. AT: "to see you again" (See: [[:en:ta:vol2:translate:figs_synecdoche]])

#between Israel's knees

When Joseph placed his sons on Israel's lap or knees it was a sign that Israel was adopting them. This gave the children special inheritance rights from Jacob. (See: [[:en:ta:vol2:translate:translate_symaction]])

#then he bowed with his face to the earth

Joseph bowed down to show honor to his father. (See: [[:en:ta:vol2:translate:translate_symaction]])

#Manasseh in his left hand toward Israel's right hand

Joseph places the boys so that Israel will put his right hand on Manasseh. Manasseh was the oldest brother and the right hand was the sign he would receive the greater blessing. (See: [[:en:ta:vol2:translate:translate_symaction]])


text:
# api-spec-helper

`api-spec-helper` is a CLI tool meant to help you generate API documentation based on the [OAS3](https://swagger.io/resources/open-api/).
It generates simple stubs for user-specified paths, allowing you to add methods and responses to your requests automatically. You will still need to customize requestBody properties, request parameters and response schemas.  You will also need to fix the indentation in some parts, unfortunately.
It is currently in the early stages of development, and only supports JSON formatting.

## Installation

Install globally on your computer:

``` bash
  npm install -g api-spec-helper
```

## Usage

Run `api-spec-helper --help` to get a list of commands and arguments.

``` txt
api-spec-helper command references:
  -h      --help                        Display this help message.

  -a      --add-path                    Adds routes to specific paths. Expects arguments:
  -p        --paths=users,estates         Specify which paths will be documented.
  -t        --tag='Admin Panel'           Specify a single tag to the generated paths.
  -m        --methods=GET,PUT,DELETE      Specify which methods will be generated. Defaults to all 4.
  -r        --responses=200,203           Specify HTTP status codes for responses. Defaults to 200, 204, 401 & 404.

  -g       --generate-stub               Generate barebones OAS3 file. Accepts the following arguments:
  -t         --tag='Admin,Customer'      Specify your project's tags, which will be referenced in your paths. Comma-separated.
  -n         --name='Application'        Specify your application's title.
```

## Examples

### generate-stub

``` bash
  api-spec-helper -g -t 'Admin Panel'
```

will be equivalent to

``` bash
  api-spec-helper --generate-stub --tag 'Admin Panel'
```

and will generate the following json in stdout:

```json
{
    "openapi": "3.0.0",
    "info": {
      "version": "0.1.0",
      "title": "Application Title",
      "description": "Application Description"
    },
    "servers": [
      {
        "url": "http://localhost",
        "description": "Your local application server"
      }
    ],
    "tags": [
       {"name": "Admin Panel", "description": "Tag description"}
    ],
    "paths": {

```

### add-path

``` bash
  api-spec-helper -a -p users,estates -t 'Admin Panel' -m GET,POST -r 200
```

will be equivalent to

``` bash
  api-spec-helper --add-path --paths=users,estates --tag='Admin Panel' --methods=GET,POST --responses=200
```

and will generate the following json in stdout:

```json
"/users": {
 "get": {
      "tags": ["Admin Panel"],
      "summary": "",
      "responses": {
        "200": {"description": "OK"}
      }
    },
  "post": {
      "tags": ["Admin Panel"],
      "summary": "",
      "requestBody": {
        "description": "",
        "content": {

        }
      },
      "responses": {
        "200": {"description": "OK"}
      }
    }
},
"/estates": {
 "get": {
      "tags": ["Admin Panel"],
      "summary": "",
      "responses": {
        "200": {"description": "OK"}
      }
    },
  "post": {
      "tags": ["Admin Panel"],
      "summary": "",
      "requestBody": {
        "description": "",
        "content": {

        }
      },
      "responses": {
        "200": {"description": "OK"}
      }
    }
},
```

You can choose to send your output for a specific text file or simply copy-paste the stubs on your swagger.json file. Then, adapt and add content as necessary.

## Contributing

Please visit the [Contributing Guide](https://github.com/sandobits/api-spec-helper/blob/master/Contributing.md).

## License

MIT

repository: sandbardev/api-spec-helper

repo_name: sandbardev/api-spec-helper


text:
# Grounded Theory
<standard name="Grounded Theory">

*A study of a specific area of interest or phenomenon that involves
iterative and interleaved rounds of qualitative data collection and
analysis, leading to key patterns (e.g. concepts, categories)*

## Application

This standard applies to empirical inquiries that meet all of the
following conditions:

-   Explores a broad area of investigation without specific, up-front
    research questions.
-   Applies theoretical sampling with iterative and interleaved rounds
    of data collection and analysis.
-   Reports rich and nuanced findings, typically including verbatim
    quotes and samples of raw data.

For predominately qualitative inquiries that do not iterate between data
collection and analysis or do not use theoretical sampling, consider the
**Case Study Standard** or the **Qualitative Survey Standard**.

## Specific Attributes

### Essential Attributes
<checklist name="Essential">

<intro>

<method>

- [ ]	identifies the version of Grounded Theory used/adapted (Glaser, Strauss-Corbin, Charmaz, etc.)
- [ ]	explains how data source(s) were selected and accessed (e.g. participant sampling strategy)
- [ ]	describes data sources (e.g. participants' demographics, work roles)
- [ ]	explains how the research iterated between data collection and analysis using constant comparison and theoretical sampling
- [ ]	provides evidence of saturation; explains how saturation was achieved[1](#myfootnote1)
- [ ]	explains how key patterns (e.g. categories) emerged from GT steps (e.g. selective coding)

<results>

- [ ]	provides clear chain of evidence from raw data (e.g. interviewee quotations) to derived codes, concepts, and categories

<discussion>

<other>

</checklist>

### Desirable Attributes
<checklist name="Desirable">

- [ ]	provides supplemental materials such as interview guide(s), coding schemes, coding examples, decision rules, or extended chain-of-evidence tables
- [ ]	explains how and why study adapts or deviates from claimed GT version
- [ ]	presents a mature, fully-developed theory or taxonomy
- [ ]	includes diverse participants and/or data sources (e.g. software repositories, forums)
- [ ]	uses direct quotations extensively to support key points
- [ ]	explains how memo writing was used to drive the work
- [ ]   validates results using member checking, dialogical interviewing, feedback from non-participant practitioners or research audits of coding by advisors or other researchers
- [ ]	discusses transferability; characterizes the setting such that readers can assess transferability
- [ ]	compares results with (or integrates them into) prior theory or related research
- [ ]	explains theoretical sampling vis-à-vis the interplay between the sampling process, the emerging findings, and theoretical gaps perceived therein
- [ ]	reflects on how researcher’s biases may have affected their analysis
- [ ]	explains the role of literature, especially where an extensive review preceded the GT study
</checklist>

### Extraordinary Attributes
<checklist name="Extraordinary">

- [ ]	triangulates with extensive quantitative data (e.g. questionnaires, sentiment analysis)
- [ ]	employs a team of researchers and explains their roles
</checklist>

## Quality Criteria

Glaser, Strauss, Corbin and Charmaz advance inconsistent quality
criteria. Using definitions in our **Glossary**, reviewers should
consider common qualitative criteria such as **credibility**,
**resonance**, **usefulness** and the degree to which results *extend*
our cumulative knowledge. Quantitative quality criteria such as internal
validity, construct validity, replicability, generalizability and
reliability typically do not apply.

## Examples of Acceptable Deviations

-   In a study of sexual harassment at a named organization, detailed
    description of interviewees and direct quotations are omitted to
    protect participants.

## Antipatterns

-   Conducting data collection and data analysis sequentially; applying
    only analysis techniques of GT.
-   Data analysis focusing on counting words, codes, concepts, or
    categories instead of interpreting.
-   Presenting a tutorial on grounded theory instead of explaining how
    the current study was conducted.
-   Small, heterogenous samples creating the illusion of convergence and
    theoretical saturation. For example, it is highly unlikely that a
    full theory can be derived only from interviews with 20 people.
-   Focusing only on interviews without corroborating statements with
    other evidence (e.g. documents, observation).

## Invalid Criticisms

-   Lack of quantitative data; causal analysis; objectivity, internal
    validity, reliability, or generalizability.
-   Lack of replicability or reproducibility; not releasing transcripts
-   Lack of representativeness (e.g. of a study of Turkish programmers,
    'how does this generalize to America?')
-   Research questions should have been different
-   Findings should have been presented as a different set of
    relationships, hypotheses, or a different theory.

## Suggested Readings

Steve Adolph, Wendy Hall, and Philippe Kruchten. 2011. Using grounded
theory to study the experience of software development. *Empirical
Software Engineering*. 16, 4 (2011), 487–513.

Khaldoun M. Aldiabat and Carole-Lynne Le Navenec. "Data Saturation: The Mysterious Step in Grounded Theory Methodology." _The Qualitative Report_, vol. 23, no. 1, 2018, pp. 245-261.

Kathy Charmaz. 2014. *Constructing grounded theory*. Sage.

Juliet Corbin and Anselm Strauss. 2014. *Basics of qualitative research:
Techniques and procedures for developing grounded theory*. Sage
publications.

Dennis A. Gioia, Kevin G. Corley, and Aimee L. Hamilton. "Seeking qualitative rigor in inductive research: Notes on the Gioia methodology." _Organizational Research Methods_ 16, no. 1 (2013): 15-31.

Janet Morse Morse, Barbara J. Bowers, Kathy Charmaz, Adele E. Clarke, Juliet Corbin, Caroline Jane Porr, and Phyllis Noerager Stern (eds). (2021) _Developing Grounded Theory: The Second Generation Revisited_. Routledge, New York, USA.

Klaas-Jan Stol, Paul Ralph, and Brian Fitzgerald. 2016. Grounded theory
in software engineering research: a critical review and guidelines. In
*Proceedings of the 38th International Conference on Software
Engineering (ICSE '16)*. Association for Computing Machinery, New York,
NY, USA, 120–131. DOI: 10.1145/2884781.2884833

## Exemplars

Barthélémy Dagenais and Martin P. Robillard. 2010. Creating and evolving
developer documentation: understanding the decisions of open source
contributors. In Proceedings of the eighteenth ACM SIGSOFT international
symposium on Foundations of software engineering (FSE '10). Association
for Computing Machinery, New York, NY, USA, 127–136. DOI:
10.1145/1882291.1882312

Rashina Hoda, James Noble, and Stuart Marshall. 2012. Self-organizing
roles on agile software development teams. *IEEE Transactions on
Software Engineering*. IEEE 39, 3 (May 2012), 422–444. DOI:
10.1109/TSE.2012.30

Todd Sedano, Paul Ralph, and Cécile Péraire. 2017. Software development
waste. In 2017 IEEE/ACM 39th International Conference on Software
Engineering (ICSE). (May. 2017), 130–140. DOI: 10.1109/icse (2017).

Christoph Treude and Margaret-Anne Storey. 2011. Effective communication
of software development knowledge through community portals. In
*Proceedings of the 19th ACM SIGSOFT symposium and the 13th European
conference on Foundations of software engineering (ESEC/FSE '11)*.
Association for Computing Machinery, New York, NY, USA, 91–101.
DOI:10.1145/2025113.2025129

Michael Waterman, James Noble, and George Allan. 2015. How much
up-front? A grounded theory of agile architecture. In *2015 IEEE/ACM
37th IEEE International Conference on Software Engineering*. 1, (May
2015), 347–357.

---
<footnote>[1](#myfootnote1) cf. Khaldoun M. Aldiabat and Carole-Lynne Le Navenec. "Data Saturation: The Mysterious Step in Grounded Theory Methodology." _The Qualitative Report_, vol. 23, no. 1, 2018, pp. 245-261.</footnote>

</standard>

repository: whasselbring/EmpiricalStandards

repo_name: whasselbring/EmpiricalStandards


text:
# Mobile Focus-demo app
Mobile Focus demo app In REACT Native

## Install tools

Follow online React-native instruction on https://facebook.github.io/react-native/docs/getting-started.html

## Launch the application

Open your favorite terminal

```shell
react-native run-ios
```


text:
seq-apps
========

Apps for the [Seq](http://getseq.net) event server. You can find installable versions of these by searching for the [seq-app tag on NuGet](http://www.nuget.org/packages?q=seq-app).

repository: TravJd/seq-apps

repo_name: TravJd/seq-apps


text:
bash-2.02 - bash-2.01.1

1. New Features in Bash

a.  A new version of malloc, based on the older GNU malloc, that has many
    changes, is more page-based, is more conservative with memory usage,
    and does not 'orphan' large blocks when they are freed.

b.  A new version of gmalloc, based on the old GLIBC malloc, with many
    changes and range checking included by default.

c.  A new implementation of fnmatch(3) that includes full POSIX.2 Basic
    Regular Expression matching, including character classes, collating
    symbols, equivalence classes, and support for case-insensitive pattern
    matching.

d.  ksh-88 egrep-style extended pattern matching ([@+*?!](patlist)) has been
    implemented, controlled by a new 'shopt' option, 'extglob'.

e.  There is a new ksh-like '[[' compound command, which implements
    extended 'test' functionality.

f.  There is a new 'printf' builtin, implemented according to the POSIX.2
    specification.

g.  There is a new feature for command substitution: $(< filename) now expands
    to the contents of 'filename', with any trailing newlines removed
    (equivalent to $(cat filename)).

h.  There are new tilde prefixes which expand to directories from the
    directory stack.

i.  There is a new '**' arithmetic operator to do exponentiation.

j.  There are new configuration options to control how bash is linked:
    '--enable-profiling', to allow bash to be profiled with gprof, and
    '--enable-static-link', to allow bash to be linked statically.

k.  There is a new configuration option, '--enable-cond-command', which
    controls whether or not the '[[' command is included.  It is on by
    default.

l.  There is a new configuration option, '--enable-extended-glob', which
    controls whether or not the ksh extended globbing feature is included.
    It is enabled by default.

m.  There is a new configuration #define in config.h.top that, when enabled,
    will cause all login shells to source /etc/profile and one of the user-
    specific login shell startup files, whether or not the shell is
    interactive.

n.  There is a new invocation option, '--dump-po-strings', to dump
    a shell script's translatable strings ($"...") in GNU 'po' format.

o.  There is a new 'shopt' option, 'nocaseglob', to enable case-insensitive
    pattern matching when globbing filenames and using the 'case' construct.

p.  There is a new 'shopt' option, 'huponexit', which, when enabled, causes
    the shell to send SIGHUP to all jobs when an interactive login shell
    exits.

q.  'bind' has a new '-u' option, which takes a readline function name as an
    argument and unbinds all key sequences bound to that function in a
    specified keymap.

r.  'disown' now has '-a' and '-r' options, to limit operation to all jobs
    and running jobs, respectively.

s.  The 'shopt' '-p' option now causes output to be displayed in a reusable
    format.

t.  'test' has a new '-N' option, which returns true if the filename argument
    has been modified since it was last accessed.

u.  'umask' now has a '-p' option to print output in a reusable format.

v.  A new escape sequence, '\xNNN', has been added to the 'echo -e' and $'...'
    translation code.  It expands to the character whose ascii code is NNN
    in hexadecimal.

w.  The prompt string expansion code has a new '\r' escape sequence.

x.  The shell may now be cross-compiled for the CYGWIN32 environment on
    a Unix machine.

2. New Features in Readline

a.  There is now an option for 'iterative' yank-last-arg handline, so a user
    can keep entering 'M-.', yanking the last argument of successive history
    lines.

b.  New variable, 'print-completions-horizontally', which causes completion
    matches to be displayed across the screen (like 'ls -x') rather than up
    and down the screen (like 'ls').

c.  New variable, 'completion-ignore-case', which causes filename completion
    and matching to be performed case-insensitively.

d.  There is a new bindable command, 'magic-space', which causes history
    expansion to be performed on the current readline buffer and a space to
    be inserted into the result.

e.  There is a new bindable command, 'menu-complete', which enables tcsh-like
    menu completion (successive executions of menu-complete insert a single
    completion match, cycling through the list of possible completions).

f.  There is a new bindable command, 'paste-from-clipboard', for use on Win32
    systems, to insert the text from the Win32 clipboard into the editing
    buffer.

g.  The key sequence translation code now understands printf-style backslash
    escape sequences, including \NNN octal escapes.  These escape sequences
    may be used in key sequence definitions or macro values.

h.  An '$include' inputrc file parser directive has been added.


text:
# basic-syntax-tests
Comparison of the syntactic capabilities of SentiLecto, MeaningCloud, Google and IBM's Watson.

Here, you'll find the battery of tests that we use and the outputs of each API. If you want to know more about the methodology, the linguistics and the results, please visit out blog post at https://medium.com/@NaturalTech/how-does-sentilecto-nlu-api-perfoms-respect-to-others-part-1-6ea7aa7899ea

If you have any question/comment or simply want to learn more about how to leverage SentiLecto for your business, contact us at<EMAIL_ADDRESS>

repository: NaturalTech/basic-syntax-tests

repo_name: NaturalTech/basic-syntax-tests


text:
# Higher/Lower Game

#### _C#, .NET: Higher/Lower Game, 9/24/2019_

## Description
Create a Higher/Lower Game, console application that 'guesses' what number a user is thinking of.

## Application should have:
- Separate frontend and backend logic

- The app should ask the user to pick a number between 1-100.

- The app should then 'guess' a number and ask whether the user's number is higher or lower than the 'guessed' number.

- If the user says the number is lower, the program should guess a lower number. If the user says the number is higher, the program should guess a higher number.

- The game should go on until the program guesses the correct number.

- Alter the app so the computer 'picks' a random number and asks the user to guess it using the same higher/lower rules. The user should be able to pick which version of the game they would like to play.

## Example
- Program: Would you like to play the higher/lower game? (Yes/No)
- User: Yes.
- Program: Okay.
- Program: Is your number higher or lower than 50? (Higher/Lower/Correct)
- User: Lower
- Program: Is your number higher or lower than 25? (Higher/Lower/Correct)
- User: Higher
- Program: Is your number higher or lower than 33? (Higher/Lower/Correct)
- User: Higher
- Program: Is your number higher or lower than 42? (Higher/Lower/Correct)
- User: Higher
- Program: Is your number higher or lower than 46? (Higher/Lower/Correct)
- User: Lower
- Program: Is your number higher or lower than 44? (Higher/Lower/Correct)
- User: Correct
- Program: Great! I guessed your number. Would you like to play again? (Yes/No)
- User: No
- -Program Quits-

## Setup/Installation Requirements

1. Clone this repo:
```
$ git clone https://github.com/misakimichy/higher-lower-game.git
```

2. Go into the repo and run this application:
```
$ dotnet run
```

## Known Bugs
* No known bugs at this time.

## Support and contact details
<EMAIL_ADDRESS>
## Technologies Used
_Git, GitHub, C# and .NET Core

## License
Copyright © 2019 under the MIT License

repository: misakimichy/higher-lower-game

repo_name: misakimichy/higher-lower-game


text:
# Data Heaving - Pulumi Azure
[![Code Coverage](https://codecov.io/gh/DataHeaving/pulumi/branch/main/graph/badge.svg?flag=automation)](https://codecov.io/gh/DataHeaving/pulumi)

This folder contains source code for `@data-heaving/pulumi-azure` NPM package.
The exported entities include:
- Commonly used helper functions (e.g. `getOrCreateStackWithAzureBackend`) to easily acquire Pulumi Stack which has all env variables and other settings correctly configured.

# Usage
Include `@data-heaving/pulumi-automation` dependency in your `package.json` file.

# More information
To learn more what Data Heaving project is all about, [see here](https://github.com/DataHeaving/orchestration).

repository: DataHeaving/pulumi

gha_language: TypeScript

repo_name: DataHeaving/pulumi


text:
---
layout: entry
title: rect
codetitle: 'rect(x, y, w, h, [tl], [tr], [br], [bl])'
description: "Draws a rectangle on the page.\nBy default, the first two parameters set the location of the upper-left corner, the third sets the width, and the fourth sets the height. The way these parameters are interpreted, however, may be changed with the `rectMode()` function.\nThe fifth, sixth, seventh and eighth parameters, if specified, determine corner radius for the top-right, top-left, lower-right and lower-left corners, respectively. If only a fifth parameter is provided, all corners will be set to this radius."
category: Shape
subcategory: Primitives
returns:
    name: null
    description: 'The rectangle that was created.'
    type: [Rectangle]
parameters:
    - {name: x, description: 'X-coordinate of the rectangle.', optional: false, type: [Number]}
    - {name: y, description: 'Y-coordinate of the rectangle.', optional: false, type: [Number]}
    - {name: w, description: 'Width of the rectangle.', optional: false, type: [Number]}
    - {name: h, description: 'Height of the rectangle.', optional: false, type: [Number]}
    - {name: tl, description: 'Radius of top left corner or radius of all 4 corners (optional).', optional: true, type: [Number]}
    - {name: tr, description: 'Radius of top right corner (optional).', optional: true, type: [Number]}
    - {name: br, description: 'Radius of bottom right corner (optional).', optional: true, type: [Number]}
    - {name: bl, description: 'Radius of bottom left corner (optional).', optional: true, type: [Number]}
kind: function
todo: null
examples: []

---

gha_language: SCSS

gha_license_id: NOASSERTION


text:
# Online Food Delivery(5TH SEM DBMS MINI PROJECT)  [![](https://img.shields.io/badge/Rutuja-Rajesh-brightgreen.svg?colorB=ff0000)](https://www.linkedin.com/in/rutuja-rajesh-20909610b/)

It is a DBMS Mini project under 2015 VTU CBCS scheme.

# Instructions

# BACK END

Download ORACLE 11G and above version.After installing it.

* ADD [CREATE STMT](https://github.com/rutujar/Online-food-delivery/blob/master/Backend/create%20table.txt)

* ADD [INSERT STMT](https://github.com/rutujar/Online-food-delivery/blob/master/Backend/insert.txt)

# QUERY

Sample queries can be executed.

# JDBC

Download ojdbc 7 from oracle website

# FRONT END

Install NetBeans IDE 8 and JDK 1.8 and above.

Download ojdbc6 for connectivity both front end and back end.

* DOWNLOAD [OFD](https://github.com/rutujar/Online-food-delivery/blob/master/ofd)

                                      OR

* IMPORT [FRONT END](https://github.com/rutujar/Online-food-delivery/tree/master/Front%20end)

* USE IMAGES FOR FRONT END.

# OUTPUT

### STEP 1: Front page
![Front page](https://github.com/rutujar/Online-food-delivery/blob/master/output/Front%20page.png)

### STEP 2: Sign in page

![GitHub Logo](https://github.com/rutujar/Online-food-delivery/blob/master/output/Sign%20in%20page.png)

### STEP 3: OFD

![GitHub Logo](https://github.com/rutujar/Online-food-delivery/blob/master/output/Online%20Food%20Delivery.png)

### STEP 4: Employee Access

![GitHub Logo](https://github.com/rutujar/Online-food-delivery/blob/master/output/Employee%20Access.png)

### STEP 5: Employee Information

![GitHub Logo](https://github.com/rutujar/Online-food-delivery/blob/master/output/Employee%20Information.png)

### STEP 6: Customer Data

![GitHub Logo](https://github.com/rutujar/Online-food-delivery/blob/master/output/Customer%20Data.png)

### STEP 7: Customer Details

![GitHub Logo](https://github.com/rutujar/Online-food-delivery/blob/master/output/Customer%20Details.png)

# NOTE:

* In customer details i have used only 4 attributes include all that for the project.

* Lacks in dynamic payment.

# LICENSE

[![](https://img.shields.io/github/license/sourcerer-io/hall-of-fame.svg?colorB=ff0000)](https://github.com/rutujar/Online-food-delivery/blob/master/LICENSE)

For more details contact me.

repository: prasad-kumkar/Online-Food-Delivery

repo_name: prasad-kumkar/Online-Food-Delivery


text:
[![Arduino CI](https://github.com/RobTillaart/TOPMIN/workflows/Arduino%20CI/badge.svg)](https://github.com/marketplace/actions/arduino_ci)
[![Arduino-lint](https://github.com/RobTillaart/TOPMIN/actions/workflows/arduino-lint.yml/badge.svg)](https://github.com/RobTillaart/TOPMIN/actions/workflows/arduino-lint.yml)
[![JSON check](https://github.com/RobTillaart/TOPMIN/actions/workflows/jsoncheck.yml/badge.svg)](https://github.com/RobTillaart/TOPMIN/actions/workflows/jsoncheck.yml)
[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/RobTillaart/TOPMIN/blob/master/LICENSE)
[![GitHub release](https://img.shields.io/github/release/RobTillaart/TOPMIN.svg?maxAge=3600)](https://github.com/RobTillaart/TOPMIN/releases)

# TOPMIN

Arduino library to track the top N minima.

## Description

This experimental library tracks the top N minima of a series of values.

The library implements two classes:
- **TOPMIN** just tracks the values. (smaller footprint).
- **TOPMINext** also tracks a user defined 32-bit tag (e.g. timestamp).

The latter is more useful as it allows to link the top N values to a certain time
or day, an index in a database, or another indirect reference.
It can even be used to store a second parameter e.g. what was the humidity for
the top N temperatures.

The library can be used for different applications:
- track top N minima temperature / humidity over a given period of time.
- track top N UV minima intensity during the day.
- track top N trading volumes or $$.
- track top N smallest fish caught in a contest.
- track top N minimum number of visitors during a day.

The 32 bit tag, can be filled with a 32 bit number like a timestamp, bit can also
be used more creatively e.g. 2x 16 bit numbers or even 32 booleans.
Any mapping is possible (but not part of the library).

#### 0.2.0 breaking change

Since version 0.2.0 the minima is found with **getValue(index == 0)**.
In earlier versions the minima was found with **index == count()**.

The advantage of this change is that independent of the size of the TOPMIN
object the true minima will always at index == 0. So if you change your code
and the size of the TOPMIN object, far less code needs to be changed.
It also allows to have two or more TOPMIN objects of different size and use one
index to access both.

#### Links

- https://github.com/RobTillaart/TOPMAX
- https://github.com/RobTillaart/TOPMIN
- https://github.com/RobTillaart/runningAverage
- https://github.com/RobTillaart/MINMAX

## Interface

```cpp
#include "TOPMIN.h"
```

#### TOPMIN

- **TOPMIN(uint8_t size = 5)** Constructor, defines the number of elements it can hold.
Default number of elements is 5. If **size** < 3 it will be set to 3.
The maximum size is currently 255, or less if there is not enough memory.
- **uint8_t count()** returns the number of elements in the internal array. 0.. size.
- **uint8_t size()** returns the maximum number of elements in the internal array.
- **void reset()** reset the internal counter to 0, logical clearing of the system.
- **bool add(float value)** add a value to the TOPMIN object if it is in the top N of minima.
If so the largest element is removed.
Returns false if not added or if there was an allocation error.
- **float getValue(uint8_t index)** get an element of the internal array.
The index must be <= **count()**, if not the function currently returns **NaN**.
This may or may not be a valid value, so the user should guard the **index** parameter carefully.
- **bool fill(float value)** convenience function to fill the internal array
with a single value e.g. 0. Returns true on success.

#### TOPMINext

Derived from TOPMIN, extended with a tag field.

- **TOPMINext(uint8_t size = 5)** Constructor, defines the number of elements it can hold.
Default number of elements is 5. If **size** < 3 it will be set to 3.
The maximum size is currently 255, or less if there is not enough memory.
- **bool add(float value, uint32_t tag)** add a value to the TOPMINext object to check if
it needs to be in the top N of minima. If so add the 32-bit **tag** too (at same index).
The 32-bit **tag** is typical an index, counter or timestamp, but any semantic is possible.
- **uint32_t getTag(uint8_t index)** get the tag from an element of the internal array.
The index must be <= **count()**, if not the function currently returns **0xFFFFFFFF**.
This may or may not be a valid value, so the user should guard the **index** parameter carefully.
- **bool fill(float value, uint32_t tag)** convenience function to fill the internal array
with a single value e.g. 0. (tag idem).

# Future

#### Must

- keep TOPMIN and TOPMAX functional in sync.
- improve documentation.

#### Should

- add unit tests.
  - for extended version if possible.

#### Could

- add more examples.
  - example creative use of tag field.
- add error handling
  - TOP_ERR_ALLOCATION
  - TOP_ERR_INDEX
  - TOP_NOT_ADDED
  - TOP_OK
  - int error; **int lastError()**
- create template class.
- **bool check(float value)** and **bool check(float value, uint32_t tag)**
  - if (value < getValue(0)) or so.
  - **inRange(value)**
  - checks if this value would be added to the TOP-N
- **TOP** class, in which the condition can be set as parameter.
  - a function() returning true or false when comparing 2 values.
- **bool hasValue(float value)** and **bool hasTag(uint32_t tag)**
  - or **int getIndex(...)** duplicates?

#### Wont

- how to handle double/triple etc. entries with same value
  - they are handled as unique elements, that is what I had in mind.
- optimize loops in **fill()** (maybe upon request)
  - pointer math

repository: RobTillaart/Arduino

repo_name: RobTillaart/Arduino


text:
---
title: Deploy
uid: deploy_webtools
description: Web Tools deployment in a restricted environment
author: {github-id}
keywords:
so.topic: howto
so.envir: onsite
so.client:
---

# Web Tools deployment in a restricted environment

Currently, the best way of distributing Web Tools is by deploying the pre-requisites and allowing users to [install Web Tools themselves][4]. This method will utilize the built-in update functionality.

However, there are companies where users are not allowed to install software on their devices at all. Those companies need to deploy the pre-requisites and the MSI files using their preferred deployment strategy. Updates must be manually handled by the company and deployed through their solution.

If Web Tools are already installed, or if you for other reasons wish to configure it, it is possible to use **SoConfig** files for the initial setup:

![Example of a SoConfig file -screenshot][img1]

When deploying through GPO or other alternatives, executing the *SoConfig* file during the log-on process will set up Web Tools for the user. The site will not be added again if it has already been added.

> [!NOTE]
> If you are not the administrator, you get Web Tools installed in *c:\users\\\<yourname>\appdata\local\SuperOffice*. To install on *C:/Program files*, you need to be the local administrator.

## Overview

1. Extract required files from the Web Tools installer.
2. Distribute the MSI files (using GPO or SCCM tools) to all machines that are going to use WebTools.
3. Auto-configure the URL and Settings using a script.

The following MSI files must be deployed to every SuperOffice user (AD group all SuperOffice users):

* SoCrossTableInstaller.msi (component for viewing cross-table reports)
* SuperOffice.MailLink.Setup.msi (add-in for Microsoft Outlook)
* SuperOffice.Web.Extensions.msi (document-handling plugin for SuperOffice)

## Pre-requisites

* Username in SuperOffice must be the same as in ActiveDirectory (sAMAccountName).
* SuperOffice needs to be configured to use Active Directory as the authentication method for all users.
* SuperOffice WEB needs to be configured to use Windows Authentication on the website.
* We also recommend to [disable the Web Tools upgrade dialog][2].
* Blocking applications must be closed.
* Libraries must be installed **before any SuperOffice plugins are installed**.

**Required libraries:**

* Microsoft .NET framework 4.5.1 (Full) or higher
* VSTO 2010 runtime (32bit or 64bit) for Ribbons on Office 2007 and higher
* Visual C++ 2017 runtime for x86 (version 14.14.26429.4)

> [!NOTE]
> You need administrative privileges to install the required libraries.

## Blocking applications

There are several applications that need to be closed when MailLink and Web Extensions are being installed. Make sure all of these are switched off when you deploy Web Tools.

> [!WARNING]
> Do not run Outlook.exe as administrator (then you do not run it as "your own local user") and that will not work for MailLink.

**For MailLink, close:**

* Outlook
* SuperOffice CRM Win client
* SoEventServer

**For Web Extensions, close:**

* SuperOffice TrayApp Client

## Step 1: Extract required files from the Web Tools installer

You need to extract *SoCrossTableInstaller.msi*, *SuperOffice.MailLink.Setup.msi*, and *SuperOffice.Web.Extensions.msi*.

1. Download the Web Tools installer from the [Download Service][3] or from inside the SuperOffice Web **Download** menu.

2. Extract Mail Link and Web Extensions installers out of Web Tools installer:

    `SuperOffice.Web.Tools.exe /k /d C:\Temp`

3. Run `SuperOffice.MailLink.Setup.exe` but don't finish the installation. While keeping the installer on-screen:

    1. Go to the *%temp%* folder.
    2. Locate a folder where the installer unpacked the MailLink files.
    3. Copy the *SuperOffice.MailLink.Setup.msi* file out of it.

4. Run `SuperOffice.Web.Extensions.exe` as above to obtain *SuperOffice.Web.Extensions.msi*.

5. To get *SoCrossTableInstaller.msi*, download CrossTable viewer from inside the SuperOffice Web **Download** menu and follow the same procedure as with MailLink to get the MSI from the *%temp%* folder during CrossTable viewer installation.

> [!TIP]
> Because MailLink is a separate downloadable installer (the latest version) available on the Download Service, customers wishing to upgrade or extract MSI only MailLink can do so.

## Steps 2-3: Deploy and configure MSI files

1. Install all MSI packages with a help of the **InstallWebTools.cmd** script (see below). It also copies the **SuperOfficeWebToolConfiguration.cmd** script to the **Start** menu for all users and removes the default Web Extensions link.

2. Edit *SuperOfficeWebToolConfiguration.cmd* with correct settings:

    ```bat
    set SuperOfficeWebUrl=https://socrm.myorganization.com/sales
    set SuperOfficeServiceURL=https://socrm.myorganization.com/service
    set SuperOfficeOwnerContactName=Licence owner name
    ```

3. Restart the target computer.

### InstallWebTools.cmd

Copy the below code-lines to Notepad or another text editor and save as *InstallWebTools.cmd*.

[!code-batchfile[cmd](includes/InstallWebTools.cmd)]

### SuperOfficeWebToolConfiguration.cmd

Copy the below code-lines to Notepad or another text editor and save as *SuperOfficeWebToolConfiguration.cmd*.

[!code-batchfile[cmd](includes/SuperOfficeWebToolConfiguration.cmd)]

<!-- Referenced links -->
[1]: index.md
[2]: upgrade.md
[3]: https://www3.superoffice.com/DownloadService/
[4]: install.md

<!-- Referenced images -->
[img1]: media/11033-21660.jpg

repository: ArildEik/superoffice-docs

repo_name: ArildEik/superoffice-docs


text:
Introduction to Web API with Python and Flask
===
SUTD Independent Activity Period
## Table of Contents

* [Introduction to Web API with Python and Flask](#introduction-to-web-api-with-python-and-flask)
    * [Table of Contents](#table-of-contents)
    * [Making a request to an API](#making-a-request-to-an-api)
        * [Method 1](#method-1)
        * [Method 2](#method-2)
    * [Flask RESTful](#flask-restful)
    * [SQLite](#sqlite)
    * [Author](#author)

## Making a request to an API

We will be using the Astronomy Picture of the Day API by NASA

### Method 1

1. Open up your preferred modern browser
2. Paste `https://api.nasa.gov/planetary/apod?api_key=pNYC2hpSuDjKQ9IhbKszZ5IctGbGjuTe91oTohlS`

### Method 2

1. Open up your terminal
2. Paste
```gherkin
$ curl --request GET \
       --url 'https://api.nasa.gov/planetary/apod?api_key=pNYC2hpSuDjKQ9IhbKszZ5IctGbGjuTe91oTohlS' \
       --header 'Accept: application/json'
```

## Flask RESTful

Install dependencies
```python
pip install flask flask_restful flask_sqlalchemy
pip install requests
```

Your First API
```python
from flask import Flask
from flask_restful import Resource, Api

app = Flask(__name__)
api = Api(app)

class HelloWorld(Resource):
    def get(self):
        return {'hello': 'world'}

api.add_resource(HelloWorld, '/')

if __name__ == '__main__':
    app.run(debug=True)
```

## SQLite
To check your sqlite database, you can use the following commands in your terminal.

1. To launch the database service: `sqlite3 weather.db`
2. To list the available tables: `.table`

A list of fundamental SQL query

1. To list the entries inside the table: `SELECT * FROM weather_model;`
2. To insert an entry into the table:
`INSERT INTO (column1, column2, ..) VALUES (value1, value2, ..);`
3. To update an entry:
`UPDATE table
SET column_1 = new_value_1,
    column_2 = new_value_2
WHERE search_condition;`
4. To delete an entry: `DELETE FROM table
WHERE search_condition;`

## Author
Jun Wei
Song Gee


text:
ElasticParser
=============

ElasticParser is a library used by the ElasticJasper Data Adapter to execute queries and page through the results of the query.

It has been extracted from the Data Adapter to allow usage in other software and plugins.

repository: adagios/ElasticParser

repo_name: adagios/ElasticParser


text:
# Celebrity Picture Rater

[![CircleCI](https://circleci.com/gh/Mingosio/celebrity-picture-rater/tree/master.svg?style=svg)](https://circleci.com/gh/Mingosio/celebrity-picture-rater/tree/master) [![Heroku](https://heroku-badge.herokuapp.com/?app=celebrity-picture-rater)](https://celebrity-picture-rater.herokuapp.com/)

At Mingos.io, we share a high volume of celebrity photos. We really wanted to find the best photo for each celebrity, so we made a celebrity picture rater in search for that answer.

## Getting Started

### Prerequisites

```plaintext
ruby 2.5.0
nodejs 8.9.3
  - yarn
postgres 9.6
```

### Installing

Ensure all prerequisites are installed then run:

```bash
bin/setup
```

After that, you can run:

```bash
bundle exec rails s
```

To enable live reloading, you can run the `webpack-dev-server` with:

```bash
bin/webpack-dev-server
```

## Running the Tests

### RSpec

Ensure you have `google-chrome` installed, then you can run the tests with `bundle exec rake`.

### Style Tests

`rubocop` can run the style suite. All PRs require the style suite to pass 100% and the style suite is included in CI.

repository: grepsedawk/celebrity-picture-rater

gha_language: Ruby

repo_name: grepsedawk/celebrity-picture-rater


text:
---
title: sf.org.numDatapointsDroppedExceededQuota
brief: Number of new datapoints not processed by SignalFx; exceeded subscription limit
metric_type: counter
---
### sf.org.numDatapointsDroppedExceededQuota

Total number of new datapoints you sent to SignalFx but that SignalFx didn't accept, because your organization exceeded its subscription limit.

For more information on how SignalFx processes incoming data when subscription limits are exceeded, see [this FAQ](https://docs.signalfx.com/en/latest/_sidebars-and-includes/dpm-faq.html).

Dimension(s): `orgId`

Data Resolution: 1 second

gha_language: Python


text:
# dotfiles
collection of the setting that I like as well as some scripts to automate the post-install setup process

You can download and run it at the same time by copying the command in `pull-from-github.sh`

TODO Add symlinks everywhere!

# Components
Here is what the repo structure looks like, along with short explanations:

```
dotfiles
├── auto-setup.sh # starts everything
├── configs
│   └── These files will tell the *auto-setup.sh* script what to set up
├── Dockerfile
├── dotfiles
│   └── The dotfiles to use (e.g. for bash, vim, i3 etc.)
├── private
│   └── similar to "dotfiles", but these config files should not be shared! (e.g. private/public ssh keys)
├── fonts
│   ├── Some useful fonts
│   └── update-fonts.sh # Look online for new versions of these fonts
├── LICENSE
├── pull-from-github.sh
├── README.md
├── scripts
│   └── these scripts are the ones that do the actual work
├── src
│   └── a compilation of some nice-to-have functions
├── tests
│   └── for debugging
└── update.sh # Looks for updates (e.g. runs the update-fonts.sh script)
```
# Config file lookup
program  |  config
---      |  ---
termite  |  ~/.config/gtk-3.0/gtk.css

# Dotfiles
file           |  purpose
---            |  ---
~/.Xresources  |  screen scaling for i3+High DPI screens
~/.xprofile    |  default screen layout from xrandr

# Testing
Build the base docker image with:
```
docker build . --tag dotfile-test
```

Afterwards, you can test the output of the `auto-setup.sh` script by running the following command (substituting "development.sh" with any one of the configs in *configs/*:
```
docker run --rm -it --env CONFIG_TO_TEST=development.sh dotfile-test
```

For development, it's easiert to copy over the local files instead of pulling them from github every time. You can do that by mounting the repo like so:
```
docker run --rm -it --env CONFIG_TO_TEST=development.sh --mount type=bind,source=$(pwd),destination=/dotfiles/,readonly dotfile-test
```

You can also just start an interactive bash shell directly:
```
docker run --rm -it --mount type=bind,source=$(pwd),destination=/dotfiles/,readonly dotfile-test /bin/bash
```

repository: imochoa/dotfiles

repo_name: imochoa/dotfiles