text:
---
layout: default
---

# 1996-05-21 - MixMaster fair use

## Header Data

From: Jim Choate<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 5ec71f3393f0e54ba3c09a714304e190b9e8a8c0bac08fd42c3f804a9fdca7e7

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-05-21 19:38:28 UTC

Raw Date: Wed, 22 May 1996 03:38:28 +0800

## Raw message

```
{% raw  %}From: Jim Choate<EMAIL_ADDRESS>Date: Wed, 22 May 1996 03:38:28 +0800
To<EMAIL_ADDRESS>Subject: MixMaster fair use
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text

Hi all,

Perhaps I am confused about what MixMaster's license allows. I have joined
the confusing part (for me anyway)...

README.no-export :

All the files in this archive contain crpytographic code which is
restricted by the ITAR regulations on munitions.
These files may only be retrieved by US citizens, and only on condition of
agreement not to export any of this software or dats, and to extract
a similar agreement from any person they may transfer it to.

To access the export-controled materials on
this site, you must agree to "THE AGREEMENT"
below. If your email address ends in one of the following:

.edu .com .edu. .gov .mil .org .net .us .ca

Do this by sending "THE AGREEMENT",
exactly as it appears, to

<EMAIL_ADDRESS>

If it does not, but you qualify to retrieve
Mixmaster under "THE AGREEMENT", then send mail
to<EMAIL_ADDRESS>explaining your
situation.

In either case you will be sent a message containing
the name of a hidden directory in which you will
find the controlled software. The name of the directory
changes frequently, so you must get the name
each time you want to access the hidden directory.

	-John A. Perry 5/6/95

--------------------------------------------------
	THE AGREEMENT:
I am a citizen or national of the United States,
or of Canada, or have been lawfully admitted for permanent
residence in the United States under the
Immigration and Naturalization Act.

I agree not to export Mixmaster, or RSAREF
or any other software in this archive,
in violation of the export
control laws of the United States of America as implemented
by the United States Department of State Office of
Defense Trade Controls.

Before I download Mixmaster, I will read
and agree to the terms and conditions of the RSAREF
license (in ftp://ftp.jpunix.com/pub/rsalicen.txt).

I will use Mixmaster solely for non-commercial purposes.
----------------------------------------------------------

Directory name last changed at: Wed May 1 09:00:01 CDT 1996

End README.no-export

What confuses me is the part above that states that I agree to use Mixmaster
for solely non-commercial use. This is NOT GNU or copyleft.

                                                  Jim Choate

{% endraw %}
```

## Thread

+ Return to [May 1996](/archive/1996/05)

+ Return to "[Jim Choate <ravage@ssz.com>](/authors/jim_choate_ravage_at_ssz_com_)"

+ 1996-05-21 (Wed, 22 May 1996 03:38:28 +0800) - MixMaster fair use - _Jim Choate<EMAIL_ADDRESS>


text:
# Tapster PBR
Controller software library for the Tapster PBR robot

## Install:

_Run in a terminal window:_

    git clone https://github.com/tapsterbot/pbr.git
    cd pbr/software
    npm install

## Run:

_Run in a terminal window:_

    node bot.js

If everything is working, this is what the terminal window will look like:

    $ node bot.js
<PHONE_NUMBER>894 Available /dev/tty.usbmodem14401
<PHONE_NUMBER>905 Connected /dev/tty.usbmodem14401
<PHONE_NUMBER>779 Repl Initialized
    >>

## Try Demo Code:

After bot.js is running and you see the `>>` prompt, try pasting in some sample code from pbr.js, then hit Enter or Return:

    >> power = {
    ...   tap: function() { s1.to(70); setTimeout( () => s1.to(90), 200) },
    ...   longPress: function() { s1.to(70) },
    ...   release: function() { s1.to(90) }
    ... }
    { tap: [Function: tap],
      longPress: [Function: longPress],
      release: [Function: release] }
    >>

Now try running a command:

    >> power.tap()

_At this point, one of the servos on your PBR should quickly toggle back and forth._

license: MIT

repository: tapsterbot/pbr

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: tapsterbot/pbr


text:
# dashr_sample_layouts

This repository is intended to give people new to DashR a hand in making layouts for their dashboards. We've found that the examples in most Dash tutorials to be too simple to be useful and the examples in the [Dash gallery](https://dash-gallery.plotly.host/Portal/) to be too complex for beginners. So, the teaching staff of STAT 547 at UBC has put together this small assortment of simple (but not too simple) layouts, with well commented code so you'll be able to see where customization is possible.

The different layouts can be found in the descriptively titled folders.

### The Layouts:

#### Two plots and a sidebar

![](img/two-plots-and-sidebar.png)

> This layout simply has a header, and a sidebar with a description of the data as well as dropdown boxes that change the x- and y-axes of the plots in the main area of the page.

#### Four plots and a sidebar

![](img/four-plots.png)

> This layout has two dropdown boxes controlling the x- and y-axes of all four plots. In practice, this is not a useful thing to do, but it gives a good head start if you want to have a lot of graphs on your dashboard.

#### Basic tabs

![](img/basic-tabs.png)

> Tabs in DashR are a little more complicated than they look and more complicated than Dash for Python. They're good to use if you have a lot of plots or if you want to put documentation on a separate page.

### Contribution

If you would like to contribute to this repo, simply fork the repo and open a pull request. If you see any errors, please open an issue.

gha_language: R


text:
# brave-resteasy-example #

Example RESTEasy service implementation that shows the use of the client and server side interceptors from the
`brave-resteasy-spring` module and the usage of [brave](https://github.com/kristofa/brave) in general.

## What is it about? ##

On one hand there is the service resource which can be found in following class:
`com.github.kristofa.brave.resteasyexample.RestEasyExampleResourceImpl`

Next to that there is an integration test: `com.github.kristofa.brave.resteasyexample.ITRestEasyExample` that sets up
an embedded Jetty server at port `8080` which deploys our service resource at context path http://localhost:8080/RestEasyTest.

The resource (RestEasyExampleResource) makes available 2 URI's

*   GET http://localhost:8080/RestEasyTest/brave-resteasy-example/a
*   GET http://localhost:8080/RestEasyTest/brave-resteasy-example/b

The test code (ITRestEasyExample) sets up our EndPoint, does a http GET request to http://localhost:8080/RestEasyTest/brave-resteasy-example/a
The code that is triggered through
this URI will make a new call to the other URI: http://localhost:8080/RestEasyTest/brave-resteasy-example/b.

For both requests our client and server side interceptors that use the Brave api are executed.  This results in 2 spans being logged.
The test uses `LoggingSpanCollectorImpl` which simply logs the spans through slf4j:

    14:57:42,730 INFO  [qtp948887574-13] brave.LoggingSpanCollectorImpl (LoggingSpanCollectorImpl.java:24) - Span(trace_id:-5137944522864564053, name:/brave-resteasy-example/b, id:-6201587421931759351, parent_id:-5137944522864564053, annotations:[Annotation(timestamp:1372856262381000, value:sr, host:Endpoint(ipv4:2130706433, port:8080, service_name:RestEasyTest)), Annotation(timestamp:1372856262730000, value:ss, host:Endpoint(ipv4:2130706433, port:8080, service_name:RestEasyTest))], binary_annotations:null)
    14:57:42,744 INFO  [qtp948887574-18] brave.LoggingSpanCollectorImpl (LoggingSpanCollectorImpl.java:24) - Span(trace_id:-5137944522864564053, name:brave-resteasy-example/b, id:-6201587421931759351, parent_id:-5137944522864564053, annotations:[Annotation(timestamp:1372856262366000, value:cs, host:Endpoint(ipv4:2130706433, port:8080, service_name:RestEasyTest)), Annotation(timestamp:1372856262743000, value:cr, host:Endpoint(ipv4:2130706433, port:8080, service_name:RestEasyTest))], binary_annotations:[BinaryAnnotation(key:http.responsecode, value:32 30 30, annotation_type:STRING, host:Endpoint(ipv4:2130706433, port:8080, service_name:RestEasyTest))])
    14:57:42,745 INFO  [qtp948887574-18] brave.LoggingSpanCollectorImpl (LoggingSpanCollectorImpl.java:24) - Span(trace_id:-5137944522864564053, name:/brave-resteasy-example/a, id:-5137944522864564053, annotations:[Annotation(timestamp:1372856261792000, value:sr, host:Endpoint(ipv4:2130706433, port:8080, service_name:RestEasyTest)), Annotation(timestamp:1372856262745000, value:ss, host:Endpoint(ipv4:2130706433, port:8080, service_name:RestEasyTest))], binary_annotations:null)
    14:57:42,746 INFO  [main] brave.LoggingSpanCollectorImpl (LoggingSpanCollectorImpl.java:24) - Span(trace_id:-5137944522864564053, name:brave-resteasy-example/a, id:-5137944522864564053, annotations:[Annotation(timestamp:1372856261537000, value:cs, host:Endpoint(ipv4:2130706433, port:8080, service_name:RestEasyTest)), Annotation(timestamp:1372856262746000, value:cr, host:Endpoint(ipv4:2130706433, port:8080, service_name:RestEasyTest))], binary_annotations:[BinaryAnnotation(key:http.responsecode, value:32 30 30, annotation_type:STRING, host:Endpoint(ipv4:2130706433, port:8080, service_name:RestEasyTest))])

The spans are logged in reverse order:

1.  The last log line logs the client part of the first span the is initiated in the test code.
    You notice that is has no parent spanid and it logs cs (client send), cr (client received) annotations as well as the http code return code as binary annotation.
2.  The 3rd log line logs the server part of the first span. So it has the same trace id, span id and null parent span id.
    It logs sr (server received) and ss (server send) annotations.
3.  The 2nd log line logs the client request from URI brave-resteasy-example/a to brave-resteasy-example/b.
    It has the same trace id but different span id and refers to the our first span as parent span id.
    As it is a client request it again logs cs, cr and http return code annotations.
4.  The 1st log line logs the server side part of brave-resteasy-example/b.
    So it has sr and ss annotations and same trace information as previous span log.

So the 2 server side logs are generated by having `BravePreProcessInterceptor` and `BravePostProcessInterceptor` available.
The client side logs are generated by the `BraveClientExecutionInterceptor`.

## How is it all hooked together? ##

### src/main/webapp/WEB-INF/web.xml ###

We use Spring to wire everything together and use the `brave-impl-spring` module. Spring is set up in the web.xml

We use the Spring DispatcherServlet and choose to use annotation based configuration (AnnotationConfigWebApplicationContext) instead of
XML configuration.

We set up our context by scanning only 1 package (com.github.kristofa.brave). Spring will scan this package AND sub packages (!)
for bean definitions, Configuration classes. As a result following classes will be detected and picked up by Spring:

*   com.github.kristofa.brave : Because we have `brave-impl-spring` as dependency the Configuration classes for EndPointSubmitter, ClientTracer, ServerTracer will be picked up.
*   com.github.kristofa.brave.resteasy : This package contains our Brave client interceptor and server pre/post process interceptors.
    As they are annotated with the Spring @Component annotation they will be picked up by Spring.
*   com.github.kristofa.brave.resteasyexample : This package contains our application resource but also dependency injection configuration
    classes for:

    Resteasy : Loads springmvc-resteasy.xml which integrates resteasy with Spring.

    TraceFilters : Sets up TraceFilter that will trace all requests. The TraceFilters dependency is required for the ClientTracer Configuration part of brave-impl-spring.

    SpanCollector : Used and shared by both ClientTracer and ServerTracer that are set up by Configuration classes in brave-impl-spring.

### Jetty ###

Jetty is embedded and started in the setup method of our test (ITRestEasyExample) and stopped in the tearDown method.

It is configured to use src/main/webapp/WEB-INF/web.xml so that is how Spring / Resteasy are being set up.

## Running it yourself ##

The project depends on Brave 2.1.0 which is available through Maven Central so you
should do:

    # Check out and build brave-resteasy-example which relies on brave 2.1.0 dependencies.
    git clone https://github.com/kristofa/brave-resteasy-example.git
    # In brave-resteasy-example directory execute:
    mvn verify # This executes unit and integration tests and will execute ITRestEasyExample.

## Adapt test to submit spans to zipkin collector ##

By default we use a SpanCollector implementation that simply logs the received spans through log4j.
We don't want to use the ZipkinSpanCollector by default because we can't assume that everybody who
checks out the code and runs the test has the Zipkin Collector service running at a fixed port.

However with few adaptations you can change this test to make it submit spans to Zipkin Collector.

### Add brave-zipkin-spancollector dependency to pom.xml ###

    <dependency>
        <groupId>com.github.kristofa</groupId>
        <artifactId>brave-zipkin-spancollector</artifactId>
        <version>${brave.version}</version>
    </dependency>

First you have to add the brave-zipkin-spancollector dependency to your pom.xml

### Update SpanCollectorConfiguration ###

Update com.github.kristofa.brave.resteasyexample.SpanCollectorConfiguration class to instantiate ZipkinSpanCollector instead
of the LoggingSpanCollector configured by default.

    @Configuration
    public class SpanCollectorConfiguration {

        @Bean
        @Scope(value = "singleton")
        public SpanCollector spanCollector() {

            return new ZipkinSpanCollector("localhost", 9410);
        }
    }

Before you run the test you should make sure the Zipkin collector is running at port
9410, and in the example case on localhost. If you execute the test now you should
see the spans in zipkin-web if services are running and properly configured.

## Integration with BraveTracer
BraveTracer can be seamlessly integrated with RestEasy. Basically brave-resteasy-spring takes care of starting and stop server tracing, as well as propogating and reconstructing server tracing information, and the actual application is response to use client trace to actual trace its own progress. Here is the sample code,

	@Override
	@Path("/a")
	@GET
	public Response a() throws InterruptedException, ClientProtocolException,
			IOException {
		braveTracer.startClientTracer("Sleep for random time");
		final Random random = new Random();
		Thread.sleep(random.nextInt(1000));
		braveTracer.stopClientTracer();

		braveTracer.startClientTracer("Calling remote REST service");

		final RestEasyExampleResource client = ProxyFactory.create(
				RestEasyExampleResource.class,
				"http://localhost:8080/RestEasyTest");
		@SuppressWarnings("unchecked")
		final ClientResponse<Void> response = (ClientResponse<Void>) client.b();
		try {
			braveTracer.stopClientTracer();
			return Response.status(response.getStatus()).build();
		} finally {
			response.releaseConnection();
		}
	}

	@Override
	@Path("/b")
	@GET
	public Response b() throws InterruptedException {

		//final Random random = new Random();
		//Thread.sleep(random.nextInt(1000));
		clientCall();
		return Response.ok().build();
	}

	private void clientCall() {
		try {
			braveTracer.startClientTracer("FirstLevelClient");
			braveTracer.submitAnnotation("Marker 1", "begin sleep marker");
			braveTracer.submitBinaryAnnotation(
					"Some Interesting Contaxt Value", "session id is 123");
			Thread.sleep(250);
			braveTracer.submitAnnotation("Marker 2", "end sleep marker");
			Thread.sleep(250);
			secondLevelClientCall();
			braveTracer.stopClientTracer();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private void secondLevelClientCall() throws Exception {
		braveTracer.startClientTracer("SecondLevelClient");
		Thread.sleep(250);
		thirdLevelClient();
		braveTracer.stopClientTracer();
	}

	private void thirdLevelClient() throws Exception {
		braveTracer.startClientTracer("ThirdLevelClient()");
		Thread.sleep(250);
		braveTracer.stopClientTracer();
	}

And a sample snapshot from zipkin,
![Snapshot from Zipkin](./brave-tracer-rest.png?raw=true)

On the left side, the red highlighted block shows calls within the first REST call, while the orange block shows calls within the second REST call. The right side of orange block highlights the client tracing within the second REST call. In combining brave REST support with brave tracer, one can trace any level within the service itself, as well as tracing any level across service calls, provided that the services themselves as well as frameworking calls those services support brave.

repository: leigu/brave-resteasy-example

repo_name: leigu/brave-resteasy-example


text:
---
title: Negative.ts
nav_order: 3
parent: Modules
---

## Negative overview

Added in v1.0.0

---

Table of contents

- [utils](#utils)
  - [NegativeArbitrary](#negativearbitrary)

---

# utils

## NegativeArbitrary

**Signature**

```ts
export declare const NegativeArbitrary: fc.Arbitrary<Branded<number, NegativeBrand>>
```

Added in v1.0.0

license: ISC

repository: EricCrosson/fast-check-numbers

repo_name: EricCrosson/fast-check-numbers


text:
---
layout: post
title: Browser Rendering Optimisation
---
* TOC
{:toc}

## The Critical Rendering Path

### Juddering

When a frame takes too long to be calculated it will be left out. When frames are left out, this causes a juddering effect.

### The Render Tree

only visible elements go into the render tree

### Layout

Layout is the process of turning the render tree and the css into the DOM.
This is also known as reflow.

### Vector to Raster

This is the process of turning an image into pixels.

## Render Pipleline

javascript -> style -> layout -> paint -> composite

if we change an elements geomentry, i.e. width
    javascript -> style -> layout -> paint -> composite

if we change image background
    javascript -> style -> paint -> composite

if we change applicable layers
    javascript -> style -> composite

(i) different ccs properties affect the performance of a web page in different ways

css triggers web site lists information on how different properties affects a page's render pipeline.
[css trigger](https://csstriggers.com/transform)

## App Lifecycles

### LIAR

| Item | Time |
| --- | --- |
| Reponse | 100 ms |
| Animate | 16 ms |
| Idle | 50 ms |
| Load | 1 second |

### Load

Initial load should take no longer than 1 second.
This is where critial functionality should be loaded.
Load anything for above-the-fold

### Idle

Once the application has finished loading it goes into idle time. This is where the application is waiting for user input.
This is a good time to do any work that was defered to meet the 1 second load time.
Things to load during post-load idle state would be the following:

* image assets
* videos
* comments section

Load anything for below-the-fold

### Animations

**FLIP** - First Last Invert Play

Anything that involve moment or finger on the screen requires 60fps.

### Setup Mobile Debugging

chrome://inspect

### Battling Janking

_tips for testing_

* quit other apps
* go incognito - extension / plugins can interfere
* focus on cause of bottlenecks, not symptoms
* measure first, then optimise

###JIT Compilers

[IR Hydra](http://mrale.ph/irhydra/2/)
forget micro optimisations. This should be a last resort.
Spend energy on other things instead.

###Optimizing JS Animations

javascript should be executed as soon as possible in a frame. this could trigger style calculation, layout, paint and composite

To perform animations, use requestAnimationFrame.
Old libraries used 'setTimeout' and 'setInterval'.
(!) The javascript engine takes no notice of the rendering pipeline when scheduling these.
Not a good fit for animations.
jQuery still uses them.

So, anything that changes the layout of a page should happen inside a 'requestAnimationForm' routine.

###Long Running Javascript

[Sort Compare](http://output.jsbin.com/feloni/quiet)

###Web Workers

Web workers are a really nice way to offload processing of long running javascript onto a separate thread.

[Image manipulation Repo](https://github.com/udacity/web-workers-demo)
[Using Web Workers](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Using_web_workers)

###JavaScript Memory Management

[Writing Fast, Memory-Efficient JavaScript](http://www.smashingmagazine.com/2012/11/writing-fast-memory-efficient-javascript/)
[Memory Management](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Memory_Management)
[High-Performance, Garbage-Collector-Friendly Code](http://buildnewgames.com/garbage-collector-friendly-code/)

###Styleing and Layout

The performance cost of recalculating styles scales 'linearly' with the number of elements affected by the change.

A method of managing style changes by organising css is Block, Element, Modifier or BEM.
*Complex css selectors add to the browser's workload*
The take away is to keep selectors simple.

Here is some javascript that dynamically addes some boxes and then uses css selectors and records the time for each.

```javascript
var container = document.querySelector('.box-container');
var button = document.querySelector('button');
var count = 10000;

for (var i = 0; i < count; i++) {
  var div = document.createElement('div');
  div.classList.add('box');

  div.innerHTML = '<div class="title-container">' +
      '<div class="title">Box ' + (i + 1) + '</div>' +
      '</div>';

  if (i === count - 1)
    div.classList.add('box--last');

  container.appendChild(div);
}

button.addEventListener('click', function() {

  var selectors = [
    "div.box:not(:empty):last-of-type .title",
    ".box--last > .title-container > .title",
    ".box:nth-last-child(-n+1) .title"
  ];

  selectors.forEach(function(s) {
    console.time(s);
    var d = document.querySelector(s);
    console.timeEnd(s);
    console.log(d);
  });

});
```

Ways to reduce 'recalculate styles':

* reduce affected elements
    - fewer changes to the render tree
* reduce selector complexity
    - use fewer tags and class names to select elements

It can often beneficial to reduce the complexity of css selectors by using javascript.
A combination of reducing css and adding some javascript could uncover significant performance boots.

##Layout Thrashing

When running javascript that contains request to get geometric information of elements, such as <element>.offsetWidth, it forces layout calculation. This layout calculation is moved to the javascript point of the 'render pipleline'. This is ok, unless a style change is requested, such as setting the width of an element. This will cause the layout calculation to run for a second time.
If this is done in a loop, it could become very expensive operation.

This is know as **FSL** or **Forced Synchronous Layout**.

To combat FSL it is beneficial to read layout properties and then batch style updates.

Batching in this way, prevents the browser from having to redo layout calculations which can be very expensive.

this is a handy function for selecting dom elements into a collection to allow use of useful Array methods.

```javascript
function getDomNodeArray(selector) {
  // get the elements as a DOM collection
  var elemCollection = document.querySelectorAll(selector);

  // coerce the DOM collection into an array
  var elemArray = Array.prototype.slice.apply(elemCollection);

  return elemArray;
};

var divs = getDomNodeArray('div');
```

**Element**

* clientHeight,
* clientLeft,
* clientTop,
* clientWidth,
* focus(),
* getBoundingClientRect(),
* getClientRects(),
* innerText,
* offsetHeight,
* offsetLeft,
* offsetParent,
* offsetTop,
* offsetWidth,
* outerText,
* scrollByLines(),
* scrollByPages(),
* scrollHeight,
* scrollIntoView(),
* scrollIntoViewIfNeeded(),
* scrollLeft,
* scrollTop,
* scrollWidth

**Frame, Image**

* height,
* width

**Range**

* getBoundingClientRect(),
* getClientRects()

**SVGLocatable**

* computeCTM(),
* getBBox()

**SVGTextContent**

* getCharNumAtPosition(),
* getComputedTextLength(),
* getEndPositionOfChar(),
* getExtentOfChar(),
* getNumberOfChars(),
* getRotationOfChar(),
* getStartPositionOfChar(),
* getSubStringLength(),
* selectSubString()

**SVGUse**

* instanceRoot

**window**

* getComputedStyle(),
* scrollBy(),
* scrollTo(),
* scrollX,
* scrollY,
* webkitConvertPointFromNodeToPage(),
* webkitConvertPointFromPageToNode()

[How (not) to trigger a layout in WebKit](http://gent.ilcore.com/2011/03/how-not-to-trigger-layout-in-webkit.html)

###Managing Layers
The browser engine will place elements on layers. This is called 'update layer tree'.
Sometimes it can be beneficial to force an element into its own layer. The performance boost comes from informing the browser that the element will change.

```css
.box {
  will-change: transform
}
```
*layer promotion*

Note: only use this when appropriate. using this on elements such as text or shadows will not lead to any performance gains as paint is still required.

Update Layer Tree and Composite are not free. Aim for:

* 2 ms update layer tree
* 2 ms composite

for 60 fps critical work like animations.

**Counting Layers**
To count layers, use the TimeLine panel of the devTools.
Record some activity, ensuring you have 'Paint' capture checked. Navigate to the bottom section to view the layers.
Selecting each layer will show the reason for it being on its layer.

![alt text]({{ "/assets/images/chrome-devtool-paint-layers.png" | prepend: site.baseurl }})

###Example Website Optimisation Walkthrough
[Test Website](http://udacity.github.io/news-aggregator/)
[Solution](https://www.youtube.com/watch?v=f_1vM3o6uJA)

## Reference

[Browser Rendering Optimization - course](https://www.udacity.com/course/browser-rendering-optimization--ud860)


text:
# Syringa ×persica var. laciniata (Mill.) Weston VARIETY

#### Status
SYNONYM

#### According to
GRIN Taxonomy for Plants

#### Published in
Bot. Univ. 1:289. 1770

#### Original name
null

### Remarks
null

repository: mdoering/backbone

path: /life/Plantae/Magnoliophyta/Magnoliopsida/Lamiales/Oleaceae/Syringa/Syringa laciniata/ Syn. Syringa persica laciniata/README.md

repo_name: mdoering/backbone


text:
---
layout: post
title: "Motion Prediction with Recurrent Neural Network Dynamical Models and Trajectory Optimization"
date: 2019-06-28 16:01:39
categories: arXiv_RO
tags: arXiv_RO Optimization Prediction
author: Philipp Kratzer, Marc Toussaint, Jim Mainprice
mathjax: true
---

* content
{:toc}

##### Abstract
Predicting human motion in unstructured and dynamic environments is difficult as humans naturally exhibit complex behaviors that can change drastically from one environment to the next. In order to alleviate this issue, we propose to encode the lower level aspects of human motion separately from the higher level geometrical aspects, which we believe will generalize better over environments. In contrast to our prior work~\cite{kratzer2018}, we encode the short-term behavior by using a state-of-the-art recurrent neural network structure instead of a Gaussian process. In order to perform longer-term behavior predictions that account for variation in tasks and environments, we propose to make use of gradient-based trajectory optimization. Preliminary experiments on real motion data demonstrate the efficacy of the approach.

##### Abstract (translated by Google)

##### URL
[http://arxiv.org/abs/1906.12279](http://arxiv.org/abs/1906.12279)

##### PDF
[http://arxiv.org/pdf/1906.12279](http://arxiv.org/pdf/1906.12279)


text:
# Tumblr to XML

This takes a Tumblr archive generated with [tumblr-rb](https://github.com/mwunsch/tumblr) and turns it into a single XML file using Jekyll.

## Requirements

- Rubygems
- [tumblr-rb](https://github.com/mwunsch/tumblr)
- [Jekyll](http://jekyllrb.com)

## Instructions
1. If you have not done so, install `tumblr-rb` with the command `gem install tumblr-rb`

1. Clone this repo:

		git clone https://github.com/thebestsophist/tumblrtoxml.git

1. Enter the directory and download your tumblr archive to `_posts`

		$ TUMBLRHOST=yourbloghere.tumblr.com tumblr backup _posts/

1. Update the yaml front matter in `index.xsl` with your blog details.

1. Enter the `_posts` directory and rename the archived posts to something jekyll will like:

		$ find *.txt -exec bash -c 'mv "$0" "2013-10-05-${0%\.txt}.markdown"' {} \;

You can replace the date `2013-10-05` with any date you prefer, jekyll requires it, but it is not used in the generated XML file. I prefer to use the date of import.

1. Mass replace `id: ` with `tumblrid: `

[Need a good command for this that only matches the `id:` in the yaml front matter, I currently just use a mass-repace app.]

1. Edit the YAML front matter in `archive.xml` to match your site.

1. Return to your jekyll root and build the xml file:

		$ jekyll build

Jekyll will still build individual pages for your posts, you can ignore those, the important file is `_site/archive.xml` which will be a single XML.

## Notes
- Since Tumblr is terrible at generating clean XHTML, post contents are shoved into a `<![CDATA[]>`. You may need to clean up the data a little more if you plan on using it to generate your sites.
- Since XML is more strict with special characters, you may have to go through and clean your ampersands, smart quotes and such.

repository: thebestsophist/tumblrtoxml

repo_name: thebestsophist/tumblrtoxml


text:
# Json Schema

Adds support for [JSON Schema](http://json-schema.org/) in [Atom](http://atom.io).

![](https://raw.githubusercontent.com/OmniSharp/atom-json-schema/master/schema.gif)

![](https://raw.githubusercontent.com/OmniSharp/atom-json-schema/master/schema2.gif)

## Whats it do
Using is-my-json-valid for schema validation, Json Schema warns the user if their json file doesn't match the commonly defined schema.  Also using the defined Json Schema we can offer auto completion results for enum values.

## Extentions
Json Schema was built for use with [OmniSharp](http://www.omnisharp.net/).  There is an extension point that lets you plug in custom intellisense providers.  This is to help with tools like Npm or NuGet, where package.json and project.json
both have their package references.  This this extension point you can plug in calls off to the associated webservice / localcache / whatever you want.

## Npm support
As stated above, NPM support is added out of the box.  Search is limited to `starts with` (if anyone knows how to fuzzy search against skimdb log an issue!).  We can add the package for you, as well as the latest version as values.

## Bower support
Bower support is planned, I still have to figure out the best way to find version numbers (or if its even possible since bower uses git...).

# Make your own schema provider
The schema interface is declared in typescript as follows:

```
interface IAutocompleteProvider {
    fileMatchs: string[];
    pathMatch: (path: string) => boolean;
    getSuggestions: (options: IAutocompleteProviderOptions) => Promise<Suggestion[]>;
    dispose(): void;
}

interface IAutocompleteProviderOptions {
    editor: Atom.TextEditor;
    bufferPosition: TextBuffer.Point; // the position of the cursor
    prefix: string;
    scopeDescriptor: { scopes: string[] };
    activatedManually: boolean;
    path: string;
}
```

* fileMatchs
  are the files that the provider applies to
* pathMatch
  is a callback method that lets you determine.  The path that is give is based on where the user has their cursor in the file.
* getSuggestions
  identical to autocomplete+ with a few extra options.
  * path
    is the path part of the file such as `dependencies` or `dependencies.lodash`

Then in your `package.json` add...

```
"jsonschema.provider": {
  "versions": {
    "0.1.0": "consumeProvider"
  }
}
```

# TODO
* Bower support?
* JSPM support?
* Allow for custom $schema's

gha_language: JavaScript


text:
# Highlight Bad Chars

Atom package to highlight bad characters such as No-break space ( ) and the Greek question mark (;) in your source files.

With this package you'll easily notice invisible and easy-to-confuse characters,
which can be the cause for incredibly annoying syntax errors in source code.

Save yourself the burden of debugging invisible bugs for hours!

## Before

![](https://github.com/ohanhi/atom-highlight-bad-chars/raw/master/images/before.png)

## After

![](https://github.com/ohanhi/atom-highlight-bad-chars/raw/master/images/after.png)

## Version 2.0+ note

Versions from 2.0.0 onwards use a (user-extendable) whitelist of commonly used source code characters instead of trying to find specific bad characters using a blacklist. If this is an issue for you, check out the blacklist-based fork: [highlight-bad-chars-bl](https://atom.io/packages/highlight-bad-chars-bl)

repository: ohanhi/atom-highlight-bad-chars

gha_license_id: MIT

repo_name: ohanhi/atom-highlight-bad-chars


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

### Description

Observable response discrepancy in some Intel(R) Processors may allow an authorized user to potentially enable information disclosure via local access.

### POC

#### Reference
No PoCs from references.

#### Github
- https://github.com/ARPSyndicate/cvemon
- https://github.com/JUSDJTIN/Speculative-Code-Store-Bypass-POC
- https://github.com/coolcatlee/Speculative-Code-Store-Bypass-POC
- https://github.com/vusec/fpvi-scsb

repository: trickest/cve

branch_name: refs/heads/main

gha_language: HTML

repo_name: trickest/cve


text:
myList module

append : For appending 2 lists
last:For finding the last element of the list
is_member:To check if the member exist in the list
sort: To sort the list
sum: To find the sum of elements in the list
addlast:Adds a element to the end of the list
addfirst:Adds a element to the begining of the list

complexCalc

add: For adding two complex number
subtract:For subtracting two complex number
multiply:For multiplying two complex number
divide:For dividing two complex number
arg:For finding the arguement of a complex number
absolute:For finding absolute value of a complex number
argInv:To find the complex number from its argument
print:To print the details of the complex number


text:
# Verba Scipta Que Volent

## What is that?
**Verba Scripta Que Volent** is a wink to latin locution "Verba Volent Scripta Manent" meaning _words fly away, writings remain_.

This PHP tool allow you to write text that can fly away too, it as simple as filling some fields in a form and click ok.

## How to use it
* Create a database schema
* Execute SQL script
* Copy/paste the files
* Copy `inc/conf.template.php` to `inc/conf.php`
* Configure your app in `inc/conf.php`
* Go to the tool: http://yourhost/

### How to create the database
Execute the sql script `install/install.sql` in your dataabse schema.

### Configure the tool
There is few fields to configure in `inc/conf.php`.

## Contributors
[Color palette - http://paletton.com/#uid=20B0r0khCij9Qooeblwn8gsuBc5](http://paletton.com/#uid=20B0r0khCij9Qooeblwn8gsuBc5)

repository: olivierperez/VerbaScriptaQueVolent

gha_language: PHP

repo_name: olivierperez/VerbaScriptaQueVolent


text:
# Workspaces-app

## Description
The `workspaces-app` is a vanilla web application which wraps `@glue42/golden-layout` and implements the `workspaces-api` protocol while providing the user with a PWA Workspaces experience.

## Usage
Please go to [Glue42 Core's website](https://docs.glue42.com/core/what-is-glue42-core/index.html) for more information.

repository: ggeorgievx/core

gha_language: CSS

repo_name: ggeorgievx/core


text:
---
layout: post
title: "Angular scope issue with nested HTML elements"
comments: true
---

I have this very simple example where I am trying show a processing icon, clicking on the save button sets a `saving` flag in `$scope` in the controller.

My issue is that the button is disabled via the directive `ng-disabled` but the other directives under the button don't hold the value for `saving`

```
button.btn.btn-default(ng-show='editMode', ng-disabled='saving', ng-click='save()')
  ui-icon(ng-hide='saving', icon='fa-save')
  ui-icon-processing(ng-show='saving')
  span Save

```

What could cause this issue to happen?

branch_name: refs/heads/gh-pages


text:
## workshopctl gen

Generate a set of manifests based on the configuration

```
workshopctl gen [flags]
```

### Options

```
  -h, --help                help for gen
      --skip-local-charts   Don't consider the local directory's charts/ directory
```

### Options inherited from parent commands

```
      --config-path string   Where to find the config file (default "workshopctl.yaml")
      --dry-run              Whether to apply the selected operation, or just print what would happen (to dry-run) (default true)
      --log-level loglevel   Specify the loglevel for the program (default info)
      --root-dir string      Where the workshopctl directory is. Must be a Git repo. (default ".")
```

### SEE ALSO

* [workshopctl](workshopctl.md)	 - workshopctl: easily run Kubernetes workshops

repository: cloud-native-nordics/workshopctl

gha_language: Go

repo_name: cloud-native-nordics/workshopctl


text:
# Contributing

Hello! Thank you for taking the time to learn how to make a contribution to Octo!

These guidelines ensure the maintainers and contributors are working together respectfully on all projects related to Octo. The maintainers have a limited amount of time to devote to this project, so we ask contributors to be considerate. In return, the maintainers will reciprocate that respect and will consider, discuss, and support all acceptable contributions as appropriately identified in this document.

## Contributions

Octo is an Open Source project, and we love support from our community!

To help you out, we will list some examples of acceptable and unacceptable contributions so that you do not waste the valuable time or effort of yourself or our maintainers.

#### Is this your first time contributing to Open Source?

Here are a few resources to learn more about the process!

- https://makeapullrequest.com
- https://www.firsttimersonly.com
- https://app.egghead.io/playlists/how-to-contribute-to-an-open-source-project-on-github

### Acceptable Contributions

- [Open an Issue](https://github.com/writewithocto/octo/issues) for a newly discovered bug that is not yet reported.
- Comment on [Issues](https://github.com/writewithocto/octo/issues), [Discussions](https://github.com/writewithocto/octo/discussions), or [Pull Requests](https://github.com/writewithocto/octo/pulls) to provide constructive feedback or (functional) examples.
- [Start a Discussion](https://github.com/writewithocto/octo/discussions) about a feature idea that does not already exist as an [Issue](https://github.com/writewithocto/octo/issues) or a [Discussion](https://github.com/writewithocto/octo/discussions).
- Write or record an unofficial tutorial for how to use or contribute to Octo.
- [Submit a Pull Request](https://github.com/writewithocto/octo/pulls) that resolves a documented Issue.
- [Submit a Pull Request](https://github.com/writewithocto/octo/pulls) that improves the existing documentation.

### Unacceptable Contributions

- **Do not** open an Issue for support questions.
- **Do not** submit a Pull Request for an undocumented feature idea. All feature ideas should start as a [Discussion](https://github.com/writewithocto/octo/discussions) to ensure we have the chance to properly vet the idea.
- **Do not** submit a Pull Request purely for code quality (linting, refactoring, reorganizing, etc).
- **Do not** comment on an Issue, Discussion, or Pull Request to engage in arguments or promote harassment. See our [Code of Conduct](https://github.com/writewithocto/octo/blob/main/CODE_OF_CONDUCT.md).
- **Do not** disclose security vulnerabilities in public. Please email [david<EMAIL_ADDRESS>instead.

## Setting up the local dev environment

Install the dependencies.

```bash
yarn install
```

Copy `.env.example` to `.env`.

```bash
cp .env.example .env
```

### Launching the app

Run the app in `development` mode.

```bash
# binds to localhost:8888
yarn dev
```

Run the app in `production` mode (to test the PWA).

_Note: Offline functionality is only available in `production` mode._

```bash
# binds to localhost:8889
yarn preview
```

### Launching the Firebase Emulator

For more information about retrieving a Firebase access token, see the [docker-firebase-cli](https://github.com/voraciousdev/docker-firebase-cli) project.

```bash
docker-compose up -d
```

The Firebase Emulator dashboard is available at [localhost:32777](http://localhost:32777).

### Compiling the production build

```bash
# compiles to ./dist
yarn build
```

The production build (static assets) will be available in the `dist` directory.

repository: austenmadden/octo

repo_name: austenmadden/octo


text:
# Session&User&Registration
## Session
To use session, firstly you should require the module `local Session = require 'bamboo.session'`.
To store the data, use `Session:setKey(key, value)`.
To get the data, use `value = Session:getKey(key)`.
Each session has a expiration time, you can add `expiration = 1800` in `settings.lua` to set the expiration time to 30 minutes.
## User & Registration
User is a special model, bamboo provides a User model, and you can use it by `local User = require 'bamboo.models.user'`. Also, you can define your own model by extending User model.
To register the User model, you'd better user `bamboo.registerMainUser(User)` instead `bamboo.registerModel(User)`. Only in this way can you use the [bamboo admin interface][admin].
`User.encrypt` is a function to describe how the password is encrypted, by default md5. This function is used when generating the user instance and authenticating.
### Login & Logout
To login, use `User:login{username='username', password='password'}`. Always, `username` and `password` will be submitted, so we can use `User:login(Form:parse(req))` to handle this.
To logout, just use `User:logout()`.
Note: In fact, the information of logined or not is stored to session.
### Registration
To register, use `User:register{username='username', password='password'}`. Always, `username` and `password` will be submitted, so we can use `User:register(Form:parse(req))` to handle this.

[admin]:https://github.com/littlehaker/bamboo_admin

repository: SatWiz/bamboo

repo_name: SatWiz/bamboo


text:
# The Ani Class
This class provides an intuitive way to use the native [Web Animations API (WAAPI)](https://developer.mozilla.org/en-US/docs/Web/API/Web_Animations_API).

## Import

```js
import Ani from<EMAIL_ADDRESS>```

## Syntax

```js
let animation = new Ani(el, effect[, timing = {}]);
```

### Parameters
+ `el` - `HTMLElement`: The subject DOM element.
+ `effect` - `Array|Object|String`: The effect to play. This could be a standard keyframes array, a CSS object or a stylesheet-based animation name.
+ `timing` - `Object`: Options for the animation.
    + `duration` - `Number`: The animation's duration in milliseconds.
    + `fill` - `String`: The element's final state on finish; one of `none` (default), `forwards`, `both`.
    + `delay` - `Number`: The animation's delay in milliseconds before playing.
    + `endDelay` - `Number`: The animation's delay in milliseconds after playing.
    + `direction` - `String`: The animation's direction; one of `normal` (default), `reverse`, `alternate`, `alternate-reverse`.
    + `easing` - `String`: The rate of the animation's change over time; one of `linear` (default), `ease`, `ease-in`, `ease-out`, `ease-in-out`, or a custom `cubic-bezier` value like `cubic-bezier(0.42, 0, 0.58, 1)`.
    + `iterations` - `Number`: The number of times the animation should repeat.
    + `iterationStart` - `Number`: At what point in the iteration the animation should start.
    + `cancelForCss` - `Boolean`: (Specific to Ani) Whether to cancel the animation on finish for subsequent CSS rules on the element to take effect. By default, properties animated with WAAPI cannot be modified with CSS.

## Usage

```js
let el = document.querySelector('#el');
let ani = new Ani(el, [{opacity:1}, {opacity:0}], {duration:600});
ani.play().then(el => {
    console.log('The end!');
});
```

## Features
Ani provides the following rich set of features over WAAPI:
+ **Support for single-frame keyframes.** *Ani* will automatically derive the animation's first frame from the element's current state.
    ```js
    // Fade out from current opacity level
    let ani = new Ani(el, {opacity: 0}, timing);
    ```

+ **Support for CSS keyframes.** *Ani* can play animations defined in the document's stylesheets. Just mention an animation name.
    ```html
    <style>

    @keyframes fadeout {
    0% { opacity: 1;}
    100% { opacity: 0;}
    }

    </style>
    ```
    ```js
    // Play the animation from stylesheet
    let ani = new Ani(el, 'fadeout', timing);
    ```

+ **Support for *auto* height and width.** *Ani* accepts and automacally computes the keyword *auto* for the width and height properties.
    ```html
    <div style="width:0px"></div>
    ```
    ```js
    // Expand to the element's real size at "auto"
    let ani = new Ani(el, {width: 'auto'}, timing);
    ```

+ **Automatic units for unit-based CSS properties.** *Ani* will automacally suffix numeric values with `px` for properties like `top` that don't go without units.
    ```js
    // Help add "px" to the value for width
    let ani = new Ani(el, {width: 50}, timing);
    ```

+ **Support for shortform rules.** *Ani* will accept an object or array for the following shortforms: inset, margin, padding.
    ```js
    // Destructure the following object into their individual properties
    let ani = new Ani(el, {inset: {top: 50, left: 100}}, timing);
    // Here we actually mean
    let ani = new Ani(el, {top: 50, left: 100}, timing);
    // ---------------
    // Destructure the following array into their individual properties
    let ani = new Ani(el, {inset: [50, 100, 75, 125,]}, timing);
    // Here we actually mean
    let ani = new Ani(el, {top: 50, right: 100, bottom: 75, left: 125}, timing);
    // All shortforms go in this order: top, right, bottom, left
    ```

+ **Sensible default timing parameters.** *Ani* will automatically create sensible values for the animation timing where not defined.
    ```js
    // The timing object has the following defaults
    {
        duration: 400,
        fill: 'both',
    }
    ```

+ **Other usefull methods.** See below.

## Methods
+ [`ready()`](/play-ui/v002/api/ani/Ani/ready.md) - Accepts a callback that runs when the animation is created and ready.
+ [`onfinish()`](/play-ui/v002/api/ani/Ani/onfinish.md) - Accepts a callback that runs when the animation is completed.
+ [`oncancel()`](/play-ui/v002/api/ani/Ani/oncancel.md) - Accepts a callback that runs when the animation is cancelled.
+ [`progress()`](/play-ui/v002/api/ani/Ani/progress.md) - Returns the animation's percentage progress at any point during the animation.
+ [`seek()`](/play-ui/v002/api/ani/Ani/seek.md) - Seeks to a specific percentage of playback.
+ [`reverse()`](/play-ui/v002/api/ani/Ani/reverse.md) - Reverses the animation playback.
+ [`play()`](/play-ui/v002/api/ani/Ani/play.md) - Plays the animation and returns a promise that resolves when the animation completes.
+ [`pause()`](/play-ui/v002/api/ani/Ani/pause.md) - Pauses the animation.
+ [`finish()`](/play-ui/v002/api/ani/Ani/finish.md) - Forces the animation to the finished state.
+ [`cancel()`](/play-ui/v002/api/ani/Ani/cancel.md) - Cancels the animation.

repository: web-native/docs

repo_name: web-native/docs


text:
# Add NFS to Rook

## Overview

This document explores a design to add NFS to Rook. This is a part of the rook feature request [#1551](https://github.com/rook/rook/issues/1551).

## Rook Architecture

Rook turns distributed storage software into a self-managing, self-scaling, and self-healing storage services. It does this by automating deployment, bootstrapping, configuration, provisioning, scaling, upgrading, migration, disaster recovery, monitoring, and resource management. Rook uses the facilities provided by the underlying cloud-native container management, scheduling and orchestration platform to perform its duties.
![Rook Architecture on Kubernetes](../Documentation/media/rook-architecture.png)

## Network File System (NFS)

NFS allows remote hosts to mount file systems over a network and interact with those file systems as though they are mounted locally. This enables system administrators to consolidate resources onto centralized servers on the network.

## Why NFS?

NFS is widely used for persistent storage in kubernetes cluster. Using NFS storage is a convenient and easy way to provision storage for applications.
An NFS volume allows an existing NFS (Network File System) share to be mounted into the pod.
The contents of an NFS volume are preserved and the volume is merely unmounted if the pod is stopped/destroyed. This means that an NFS volume can be pre-populated with data, and that data can be “handed off” between pods.
NFS supports multiple read/write simultaneously so a single share can be attached to multiple pods.

## Design
With this design Rook is exploring to providing another widely adopted storage option for admins and users of cloud-native environments. This design tends to automate NFS starting from its configuration (such as allowed hosts, read/write permissions etc.) to deployment and provisioning. The operations on NFS which cannot be done natively by Kubernetes will be automated.
NFS doesn’t provide an internal provisioner for kubernetes, so Rook is needed as an external provisioner.
This design uses NFS-Ganesha server and NFS v4.

### Initial Setup

The flow of creating NFS backed storage in Rook is
1. The settings are determined and saved in an NFS server CRD (rook-nfs.yaml)
2. `kubectl create -f rook-nfs.yaml`
3. When the NFS CRD instance is created, Rook responds to this request by starting the NFS daemon with the required configuration and exports stated in the CRD and creates a service to expose NFS.
4. NFS volume is ready to be consumed by other pods through a PVC.

### NFS CRD

The NFS CRD spec will specify the following:
1. NFS server storage backend configuration. E.g., configuration for various storage backends(ceph, ebs, azure disk etc) that will be shared using NFS.
2. NFS server configuration
   The following points are required for configuring NFS server:
    - export (The volume being exported)
    - client (The host or network to which the export is being shared)
    - client options (The options to be used for the client) e.g., read and write permission, root squash etc.

The parameters to configure NFS CRD are demonstrated in the example bellow which is followed by a table that explains the parameters:

A simple example for sharing a volume(could be hostPath, cephFS, cephRBD, googlePD, EBS etc.) using NFS, without client specification and per export based configuration, whose NFS-Ganesha export entry looks like:
```
EXPORT {
    Export_Id = 1;
    Path = /export;
    Pseudo = /nfs-share;
    Protocols = 4;
    Sectype = sys;
    Access_Type = RW;
    Squash = none;
    FSAL {
        Name = VFS;
    }
}
```
the CRD instance will look like the following:
```yaml
apiVersion: rook.io/v1alpha1
kind: NetworkFileSystem
metadata:
  name: nfs-vol
  namespace: rook
spec:
  replicas: 1
  exports:
  - name: nfs-share
    server:
      accessMode: ReadWrite
      squash: root
    persistentVolumeClaim:
      claimName: googlePD-claim
```
The table explains each parameter

| Parameter                                 | Description                              | Default                       |
|-------------------------------------------|------------------------------------------|-------------------------------|
| `replicas`                                | The no. of NFS daemon to start           | `1`                           |
| `exports`                                 | Parameters for creating an export        | <none>                        |
| `exports.name`                            | Name of the volume being shared          | <none>                        |
| `exports.server`                          | NFS server configuration                 | <none>                        |
| `exports.server.accessMode`               | Volume access modes(Reading and Writing) for the share          | `ReadOnly` |
| `exports.server.squash`                   | This prevents root users connected remotely from having root privileges  | `root` |
| `exports.server.allowedClients`           | Access configuration for clients that can consume the NFS volume         | <none> |
| `exports.server.allowedClients.name`      | Name of the host/hosts                                                   | <none> |
| `exports.server.allowedClients.clients`   | The host or network to which export is being shared.(could be hostname, ip address, netgroup, CIDR network address, or all) | <none> |
| `exports.server.allowedClients.accessMode` | Reading and Writing permissions for the client*                         | `ReadOnly` |
| `exports.server.allowedClients.squash`    | Squash option for the client*                                          | `root`     |
| `exports.persistentVolumeClaim`      | Claim to get volume(Volume could come from hostPath, cephFS, cephRBD, googlePD, EBS etc. and these volumes will be exposed by NFS server ). | <none> |
| `exports.persistentVolumeClaim.claimName` | Name of the PVC                                         | <none>    |

*note: if `exports.server.accessMode` and `exports.server.squash` options are mentioned, `exports.server.allowedClients.accessMode` and `exports.server.allowedClients.squash` are overridden respectively.

Available options for `volumes.allowedClients.accessMode` are:
1. ReadOnly
2. ReadWrite
3. none

Available options for `volumes.allowedClients.squash` are:
1. none     (No user id squashing is performed)
2. rootId   (uid 0 and gid 0 are squashed to the anonymous uid and anonymous gid)
3. root     (uid 0 and gid of any value are squashed to the anonymous uid and anonymous gid)
4. all      (All users are squashed)

The volume that needs to be exported by NFS must be attached to NFS server pod via PVC. Examples of volume that can be attached are Host Path, AWS Elastic Block Store, GCE Persistent Disk, CephFS, RBD etc. The limitations of these volumes also apply while they are shared by NFS. The limitation and other details about these volumes can be found [here](https://kubernetes.io/docs/concepts/storage/persistent-volumes/).

### Examples

Here are some examples for advanced configuration:

1. For sharing a volume(could be hostPath, cephFS, cephRBD, googlePD, EBS etc.) using NFS, which will be shared as /nfs-share by the NFS server with different options for different clients whose NFS-Ganesha export entry looks like:
```
EXPORT {
    Export_Id = 1;
    Path = /export;
    Pseudo = /nfs-share;
    Protocols = 4;
    Sectype = sys;
    FSAL {
        Name = VFS;
    }
    CLIENT {
        Clients = <IP_ADDRESS>;
        Access_Type = RO;
        Squash = root;
    }
    CLIENT {
        Clients = <IP_ADDRESS>/16, serverX;
        Access_Type = RW;
        Squash = none;
    }
}
```
the CRD instance will look like the following:
```yaml
apiVersion: rook.io/v1alpha1
kind: NetworkFileSystem
metadata:
  name: nfs-vol
  namespace: rook
spec:
  replicas: 1
  exports:
  - name: nfs-share
    server:
      allowedClients:
      - name: host1
        clients: <IP_ADDRESS>
        accessMode: ReadOnly
        squash: root
      - name: host2
        clients:
        - <IP_ADDRESS>/16
        - serverX
        accessMode: ReadWrite
        squash: none
    persistentVolumeClaim:
      claimName: ebs-claim
```

2. For sharing multiple volumes using NFS, which will be shared as /share1 and /share2 by the NFS server whose NFS-Ganesha export entry looks like:
```
EXPORT {
    Export_Id = 1;
    Path = /export;
    Pseudo = /share1;
    Protocols = 4;
    Sectype = sys;
    FSAL {
        Name = VFS;
    }
    CLIENT {
        Clients = all;
        Access_Type = RO;
        Squash = none;
    }
}
EXPORT {
    Export_Id = 2;
    Path = /export2;
    Pseudo = /share2;
    Protocols = 4;
    Sectype = sys;
    FSAL {
        Name = VFS;
    }
    CLIENT {
        Clients = all;
        Access_Type = RW;
        Squash = none;
    }
}
```
the CRD instance will look like the following:
```yaml
apiVersion: rook.io/v1alpha1
kind: NetworkFileSystem
metadata:
  name: nfs-multi-vol
  namespace: rook
spec:
  replicas: 1
  exports:
  - name: share1
    server:
      allowedClients:
      - name: ebs-host
        clients: all
        accessMode: ReadOnly
        squash: none
    persistentVolumeClaim:
      claimName: ebs-claim
  - name: share2
    server:
      allowedClients:
      - name: ceph-host
        clients: all
        accessMode: ReadWrite
        squash: none
    persistentVolumeClaim:
      claimName: cephfs-claim
```

## Adding and Removing exports from an existing NFS server
Exports can be added and removed by updating the CRD using kubectl edit/replace -f rook-nfs.yaml

## Client Access
The administrator creates a storage class.
Here is an example of NFS storage class for Example 1:
```yaml
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: rook-nfs
provisioner: nfs.rook.io/nfs
parameters:
  server: nfs-vol
  export: nfs-share
```

The user can use the NFS volume by creating a PVC.
Here is an example of NFS PVC
```yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: httpd-pv-claim
  labels:
    app: web
spec:
  storageClassName: rook-nfs
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi
---
apiVersion: apps/v1beta1
kind: Deployment
metadata:
  name: web-server
  labels:
    app: web
spec:
  template:
    metadata:
      labels:
        app: web
        tier: httpd
    spec:
      containers:
      - image: httpd
        name: httpd
        ports:
        - containerPort: 80
          name: httpd
        volumeMounts:
        - name: httpd-persistent-storage
          mountPath: /var/www/html
      volumes:
      - name: httpd-persistent-storage
        persistentVolumeClaim:
          claimName: httpd-pv-claim
---

repository: upbound/rook

repo_name: upbound/rook


text:
---
layout: default
title: Java
parent: Hacking
nav_order: 1
has_children: true
---

# Java

Java is a general-purpose programming language intended to let application developers write once, run anywhere (WORA), meaning that compiled Java code can run on all platforms that support Java without the need for recompilation.
{: .fs-6 .fw-300 }


text:
# cpptalksindex
An index for C++ talks

## Aim
The aim of this is to provide a community-managed tags for C++ conferences.
Both experienced developers seeking to improve on a particular area or beginners looking for new areas to explore may use it to find material to watch.

## Adding a talk
Talks are gathered from `db.json`. Copy-pasting should get you the structure:
```json
  {
    "speakers": ["sample_speaker", "sample_speaker2"],
    "title": "",
    "conference": "CppCon",
    "year": 2020,
    "link": "https://www.youtube.com/watch?v=",
    "tags": [
      "no-tags-yet"
    ]
  },
```

## Building the server
Requirements:

  - `cmake` (tested with cmake 3.18.4)
  - A recent C++ compiler, supporting the C++17 standard (tested with gcc 10.2.0)

Steps:

```sh
mkdir build && cd build
cmake .. # -GNinja
cmake --build . # Or make / ninja
ln -s ../www . # The server will run fine but 404 if you forget this step
```

There should be a `bin/cpptalksindex` binary in `build`.
You can start the server with `./bin/cpptalksindex ../db.json`, which will run the server.
The server listens on port 8485 (hardcoded in `main.cpp`, should you need to change it).

repository: Ethiraric/cpptalksindex

repo_name: Ethiraric/cpptalksindex


text:
### [CVE-2019-3901](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-3901)
![](https://img.shields.io/static/v1?label=Product&message=kernel&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=%3D%20older%20then%204.8%20&color=brighgreen)
![](https://img.shields.io/static/v1?label=Vulnerability&message=CWE-667&color=brighgreen)

### Description

A race condition in perf_event_open() allows local attackers to leak sensitive data from setuid programs. As no relevant locks (in particular the cred_guard_mutex) are held during the ptrace_may_access() call, it is possible for the specified target task to perform an execve() syscall with setuid execution before perf_event_alloc() actually attaches to it, allowing an attacker to bypass the ptrace_may_access() check and the perf_event_exit_task(current) call that is performed in install_exec_creds() during privileged execve() calls. This issue affects kernel versions before 4.8.

### POC

#### Reference
No PoCs from references.

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


text:
# Nova Perspectives

With this package it is possible to create different perspectives in Nova. The following _optional_ features are available for each perspective:

* Different main menu
* Different user menu
* Different fields, cards, filters etc. (`$request->viaPerspective` is global available in Nova)
* Different styling via CSS child classes

[![Live Preview](https://raw.githubusercontent.com/Muetze42/Muetze42/main/files/btn-live-preview.jpg)](https://nova-demo.huth.it)

## Installation

You can install the package via composer:

```nothing
composer require norman-huth/nova-perspectives
```

## Middleware

Add the `NormanHuth\NovaPerspectives\Http\Middleware\HandleNovaPerspektive` to `/config/nova.php`.

```php

use NormanHuth\NovaPerspectives\Http\Middleware\HandleNovaPerspektive; // [tl! focus]

return [
    //...
    'middleware' => [
        'web',
        HandleInertiaRequests::class,
        HandleNovaPerspektive::class, // [tl! focus]
        DispatchServingNovaEvent::class,
        BootTools::class,
    ],
    //...
];
```


text:
# Understanding and Visualizing Convolutional Neural Networks

```{warning}
Source Material is yet to be fully updated. Waiting for completion.
```

```{admonition} Original Source:
:class: tip
[CS231n of Stanford](https://cs231n.github.io/understanding-cnn/)
```

url: https://raw.githubusercontent.com/dipranjan/opensourcemlbook/ee94443341a528db6a71eed34b737ae9f7d81cd5/_build/html/_sources/contents/Deep Learning/Convolutional Neural Networks for Visual Recognition/Understanding and Visualizing Convolutional Neural Networks.md

repository: dipranjan/opensourcemlbook

repo_name: dipranjan/opensourcemlbook


text:
---
title: Using Vue in Markdown
layout: docs
---

## Interpolation

Markdown code is compiled to HTML first and then compiled to Vue render function, for example:

```markdown
Hello **Saber**!
```

compiles to:

```js
function render() {
  var _vm = this
  var _h = _vm.$createElement
  var _c = _vm._self._c || _h
  return _c('p', [
    _vm._v('Hello '),
    _c('strong', [_vm._v('Saber')]),
    _vm._v('!')
  ])
}
```

This means you can use Vue-style interpolation in Markdown like this:

```markdown
This result of 1 + 1 is: {{ 1 + 1 }}
```

It renders:

This result of 1 + 1 is: {{ 1 + 1 }}

If you want to disable Vue-style interpolation for a part of your Markdown page, you can wrap it inside code fence, inline code or using the `v-pre` attribute as follows:

````markdown
```js
const foo = `{{ safe, this won't be interpolated! }}`
```

And `{{ bar }}` is safe too! <span v-pre>{{ yeah }}</span>
````

It renders:

```js
const foo = `{{ safe, this won't be interpolated! }}`
```

And `{{ bar }}` is safe too! {{ yeah }}

## `<script>` block

`<script>` tag in Markdown page is not normal HTML `<script>` element, it's treated as [Vue SFC `<script>` block](https://vue-loader.vuejs.org/spec.html#script) instead.

```markdown
**This is an example:**

<button @click="count++">{{ count }}</button>

<script>
export default {
  data() {
    return {
      count: 0
    }
  }
}
</script>
```

It renders:

**This is an example:**

<button @click="count++">{{ count }}</button>

Like a regular Vue single-file component, your Markdown page can have at most one script block.

## `<style>` block

`<style>` tags in Markdown page are not HTML `<style>` elements either, they are [Vue SFC `<style>` blocks](https://vue-loader.vuejs.org/spec.html#style).

repository: soyaine/saber

repo_name: soyaine/saber


text:
## v2.2.2 (2020-04-09)

* Merge pull request #760 from ember-fastboot/yarn-sync (ca9b2ea)
* Re-roll yarn.lock (0d7ce72)
* Merge pull request #757 from ember-fastboot/revert-755-greenkeeper/release-it-13.0.0 (94c2a6c)
* Revert "Update release-it to the latest version 🚀" (1340196)
* Merge pull request #752 from zonkyio/fastboot-config (2458159)
* Add FastBoot configuration section into README (40b6634)
* Update based on review (1f6c8c2)
* Merge pull request #755 from ember-fastboot/greenkeeper/release-it-13.0.0 (715c5b1)
* Merge pull request #720 from ember-fastboot/greenkeeper/eslint-plugin-ember-7.0.0 (8e10913)
* chore(package): update lockfile yarn.lock (5fa71f5)
* chore(package): update release-it to version 13.0.0 (c48a612)
* Add support for custom configuration (12e121c)
* Re-roll yarn.lock. (#738) (6a5d6c6)
* Re-roll yarn.lock. (60b5eaa)
* Merge pull request #737 from dnalagatla/dnalagatla/fix-custom-app-build (808479b)
* Fix custom app build issue #730 (9ad8446)
* fix typo in property name isFastboot -> isFastBoot (#728) (dea2f93)
* fix typo in property name isFastboot -> isFastBoot (afadb85)
* chore(package): update eslint-plugin-ember to version 7.0.0 (66f56c1)

## v2.2.1 (2019-09-11)

* move cheerio from devDependency to dependency
* move broccoli-file-creator from devDependency to dependency

## v2.2.0 (2019-09-10)

* use volta to pin node to ease development
* Added support to update manifest app files from index.html
 Embroider Support: Moved app factory module out of fastboot-app-module (#714)
* Point to ember-data-storefront instead of ember-cached-shoe (#718)
* Dev server forwards out of scope requests

## v2.1.1 (2019-06-03)

#### :bug: Bug Fix
* [#699](https://github.com/ember-fastboot/ember-cli-fastboot/pull/699) Ensure FastBoot rendered content is cleared even if the server rendered application contains malformed HTML. ([@noslouch](https://github.com/noslouch))

#### Committers: 1
- Brian Whitton ([@noslouch](https://github.com/noslouch))

## v2.1.0 (2019-05-28)

#### :rocket: Enhancement
* [#666](https://github.com/ember-fastboot/ember-cli-fastboot/pull/666) memoize existsSync calls on the fastboot instance itself ([@stefanpenner](https://github.com/stefanpenner))

#### :bug: Bug Fix
* [#692](https://github.com/ember-fastboot/ember-cli-fastboot/pull/692) Fix deprecation warning for Ember.Logger usage ([@rileyhilliard](https://github.com/rileyhilliard))
* [#690](https://github.com/ember-fastboot/ember-cli-fastboot/pull/690) Moved building fastboot config tree from postProcessTree to treeForPublic ([@dnalagatla](https://github.com/dnalagatla))

#### :memo: Documentation
* [#694](https://github.com/ember-fastboot/ember-cli-fastboot/pull/694) Add automated release setup. ([@rwjblue](https://github.com/rwjblue))

#### :house: Internal
* [#694](https://github.com/ember-fastboot/ember-cli-fastboot/pull/694) Add automated release setup. ([@rwjblue](https://github.com/rwjblue))
* [#679](https://github.com/ember-fastboot/ember-cli-fastboot/pull/679) Get tests passing again by testing against<EMAIL_ADDRESS>instead of master ([@kiwiupover](https://github.com/kiwiupover))

#### Committers: 5
- David Laird ([@kiwiupover](https://github.com/kiwiupover))
- Dinesh Nalagatla ([@dnalagatla](https://github.com/dnalagatla))
- Riley Hilliard ([@rileyhilliard](https://github.com/rileyhilliard))
- Robert Jackson ([@rwjblue](https://github.com/rwjblue))
- Stefan Penner ([@stefanpenner](https://github.com/stefanpenner))

## 2.0.4

* Fix issue in IE11 when using `Array.from`

## 2.0.1
* Fixes issue where shoebox data was being cleared when clearing the server side content.

## 2.0.0

* Drop Node 4 support.
* Disentangle from broccoli-asset-rev (requires broccoli-asset-rev@3.0.0).

## 1.1.3

Support without rootElement

## 1.1.2

* Make FastBoot addon compatible with Ember CLI 3.0.0

## 1.1.1

* Make manifest in package.json respect outputPaths configuration in EmberApp (PR # 539) (@SergeAstapov)
* Register fastboot transform for apps to wrap non compatible asserts (PR#470) (@kratiahuja)
* Move fastboot-transform and fs-extra to depedencies in package.json (@SergeAstapov)

## 1.1.0

* Bumping `fastboot-express-middleware` to 1.1.0

repository: ZucchabarInc/ember-cli-fastboot

repo_name: ZucchabarInc/ember-cli-fastboot


text:
**Week 7 Deliverables**

**Overview:** This week, you studied additional Flask functionality for creating a secure login form and
associated files for a web site. The Lab for this week demonstrates your knowledge of this additional
Python functionality. Be sure to use the examples in the textbook reading along with the associate
libraries, functions and processes when completing the assignments for this week.

**Submission requirements for this project includes multiple files. (Zipping them into one file is
acceptable and encouraged):**
* Python Web Page Code (Python code, Templates, CSS and other associated files)
* Word or PDF file containing your test and pylint results

**Python Applications for this lab: (total 100 points):**
1. **(80 points)** This exercise uses your programming environment to enhance the Web site you
   created last week with additional functionality to include images, tables and a Form using
   Python flask. Specifically, you will add two (2) additional routes allowing a user to register and
   login to a website. Additional security considerations include other routes (beyond the register
   route) will not be accessible until a successful login has occurred.
   In addition to the requirements list above the following functionality should be found within your web
   site on one or more web pages.

   * Add at least 4 different images. The images should be local in your environment. For example,
   they should be saved in your environment and referenced similar to this syntax: <img
   src="image.gif">
   * A Table with at least 4 rows and 3 columns.
   * A user registration form
   * A user login form
   * A password complexity should be enforced to include at least 12 characters in length, and
   include at least 1 uppercase character, 1 lowercase character, 1 number and 1 special character.

The content and topic of the new images, and tables are up to you. How much is required for the user
registration is up to you as well. However, the registration and associated login should contain at least a
login name and password.

Hints:

1. Start early. This will take you longer than you think.
2. Test all aspects of the forms from input to output on your environment.
3. Use comments to document your code
4. Test with many combinations.
5. Use pylint to verify the code style – the goal is a 10!

2. **(20 points)** Document your testing results using your programming environment. You should also
   include and discuss your pylint results for the application. The test document should include a test table
   2
   that includes the input values, the expected results and the actual results. A screen capture should be
   included that shows the actual test results of running each test case found in the test table. Be sure to
   include multiple test cases to provide full coverage for all code and for each function you develop and
   test.

**Any submissions that do not represent work originating from the student will be submitted to the
Dean’s office and evaluated for possible academic integrity violations and sanctions.**


text:
atk14_init.sh
-------------

Script atk14_init.sh installs skelet of a new ATK14 application. It works fine on Ubuntu 10.10 or higher.

You can find more info in the ATK14 Book: http://book.atk14.net/czech/installation%3Ainstalling-skelet/

You may not omit Requirements chapter: http://book.atk14.net/czech/installation%3Arequirements/


text:
# A Hands-On Introduction to modern web based A&A

<!-- TOC -->

- [A Hands-On Introduction to modern web based A&A](#a-hands-on-introduction-to-modern-web-based-aa)
  - [Workshop objectives](#workshop-objectives)
  - [Workshop outline](#workshop-outline)
  - [Pre-requisites](#pre-requisites)
    - [Roles](#roles)
    - [Skills](#skills)
    - [Software](#software)
    - [Consideration when using Windows](#consideration-when-using-windows)
      - [Shell](#shell)
      - [Known isues](#known-isues)
  - [Verifying working environment](#verifying-working-environment)

<!-- /TOC -->

Workshop is slides is published at [https://larskaare.github.io/WebAuthAuthorAndOtherCreatures/](https://larskaare.github.io/WebAuthAuthorAndOtherCreatures/). Slides are developed using [reveal.js]([reveal.js](https://revealjs.com))

## Workshop objectives

De-mystify, build confidence and prepare for further exploration of Authentication and Authorization.

- Give an introduction to basics modern web A&A
- Explore Spec and Azure Implementation
- Hands-on coding with a few A&A scenarios
- Insight into threats and current best practices (BCP) for security

## Workshop outline

- What problem are we trying to solve?
- Practicalities
- The basics of A&A
- Exercises (8+1)
  - Raw flows, add authentication to web app, using frameworks & libraries, accessing 3rd party api, refresh tokens, single page web app (SPA), protecting web api's
- Deploy application to the Cloud (using Radix)

## Pre-requisites

These are the pre-requisites that will make the workshop a whole lot more usefull.

### Roles

- Valid Equinor Software Developer On-Boarding
- Valid role "Application Developer (Azure Active Directory)
- Optional for deploy to cloud exercise: Access to Radix Playground - role "Radix Playground Users"

### Skills

Helpful knowledge and skills:

- HTTP
- JavaScript/Node.js
- Linux command line
- (Docker)

### Software

Installed and verified to work software.

- Node.js
  - Use Node LTS version v12.16.3
  - Using node version manager [nvm](https://github.com/nvm-sh/nvm) is recommended on Linux/Mac. For Windows users [nvm-windows](https://github.com/coreybutler/nvm-windows) could be an option.
  - Python may be needed for some node modules to install
- Development IDE (like [Visual Studio Code](https://code.visualstudio.com/))
- Git, account on github.com
- [Postman](https://www.postman.com/downloads/)
- Optional for deploy to cloud
  - Local Docker installation

### Consideration when using Windows

#### Shell

Most things should work ok with the cmd or powershell - with a few limitations. I've tested with using git-bash which is part of [Git for Windows](https://gitforwindows.org/)

#### Known isues

- Be aware of how to export environment variables, `set` for Windows, `export` for Bash/Linux
- Define proxy variables if needed:

```shell
  HTTP_PROXY=http://url:port
  HTTPS_PROXY=http://url:port
```

- `npm` is a bit quicky when it comes to running scripts. Doing `npm start` may fail, but copying the command from `package.json` and running from the terminal works for most scenarios. Configuring NPM to use a different shell could be an option `npm config set shell-script` could be an option to explore.
- Using [Docker Desktop for Windows](https://www.docker.com/get-started) should work fine. Remeber to define proxy settings if your beind one of these. Update the `~/.docker/config.json` with something like this (update `url`and `port` to reflect your context):

```json
{"proxies":
  {
    "default":
      {
        "httpProxy": "http://url:port",
        "httpsProxy": "http://url:port",
        "noProxy": ""
      }
  }
}
```

## Verifying working environment

```shell
$ git --version
git version 2.24.3
```

Should produce proof of an up to date version of git [Git](https://git-scm.com/downloads)

```shell
$ node --version
v12.16.3
```

Should produce proof of an up to date LTS version of [NodeJS](https://nodejs.org/en/download/)

```shell
$ npm --version
6.14.4
```

Npm is installed with NodeJS

```shell
$ python --version
Python 2.7.16
```

Should produce proof of a relevant 2.7 version of [Python2](https://www.python.org/downloads)

```shell
$ docker --version
Docker version 19.03.8
```

Should produce evidence of an update to date version of docker [Docker](https://www.docker.com/products/docker-desktop)

> Please verify that the tools work properly within your network environment. Typical problems would be related to PROXY settings.

repository: vnys/WebAuthAuthorAndOtherCreatures

repo_name: vnys/WebAuthAuthorAndOtherCreatures


text:
# VUE-TERMINAL
Vue-terminal is a dependency-free, lightweight terminal emulator in Vue.js. Vue-terminal provide flexible api for developer to define task or command that can be executed by users.
## [Try the demo](https://islasher.com/vue-terminal)

### How to use?
```bash
npm install vue-terminal
```
### Example

```vue
// you can also load vue-terminal.min.js in script tag:
// <script src="/path/to/file/vue-terminal.min.js"></script>
<template>
	<vue-terminal :task-list="taskList" :command-list="commandList" style="width:50%;margin:0 auto"></vue-terminal>
</template>

<script>
  import VueTerminal from 'vue-terminal';
  export default {
    components: { VueTerminal },
    data () {
      return {
        taskList: {
            // your tasks
        },
        commandList: {
            // your commands
        }
      }
    }
  }
</script>
```
The content of taskList or commandList is:
```vue
    {
      commandOrTask:{
        description:'',
        messagesOrTask:[]//(function)
        }
    }
```
You can check /docs/plugins/commandList.js and  /docs/plugins/taskList.js to view the detail of task and command.

### Configuration options

The following options can be passed as props to the `VueTerminal` component to customize its behavior:

**title** _(string)_: Sets the title that appears at the top of the terminal window, in the greeting, and in front of the prompt. Defaults to `vTerminal`.

**showHeader** _(boolean)_: Indicates whether or not to render the window chrome on top of the terminal. Defaults to `true`.

**greeting** _(string)_: Sets the greeting that will be shown to the user in the first line of the terminal. Pass `false` to not render a greeting. Defaults to `Welcome to vTerminal.`.

**showInitialCd** _(boolean)_: Initializes the terminal by showing an initial `cd vTerminal` command. Defaults to `true`.

**prompt** _(string)_: The text to show before the prompt. Defaults to `\vTerminal`.

**showHelpMessage** _(boolean)_: Indicates whether a help message should be shown.  Defaults to `true`.

**unknownCommandMessage** _(object)_: Allows the message that is printed when an unknown command is run to be customized. This object should have a `message` property and can optionally include some additional properties that change how this message is displayed:

```js
{ time: '10:53', type: 'error', label: 'Error', message: 'That command is not recognized!' },
```

If not provided, the default message will be displayed:

```
Unknown Command.

type "help" to get a supporting command list.
```

repository: wheelersh/vue-terminal

repo_name: wheelersh/vue-terminal


text:
---
title: Bench - bench uninstall-app
metatags:
 description: >
  The Bench CLI has an uninstall-app command to remove apps from your Frappe sites.
---

# bench uninstall-app

## Usage

```bash
bench uninstall-app [OPTIONS] APP
```

## Description

Remove Application and linked doctypes, modules from the site. Executing the
vanilla command will check if the app exists on site before attempting to delete
its modules and doctypes. The application may not be necessarily installed on
the bench to run the `uninstall-app` command.

## Flags

 - `-y`, `--yes` To bypass confirmation prompt for uninstalling the app
 - `--dry-run` List all doctypes that will be deleted
 - `--no-backup` Do not backup the site
 - `--force` Force remove the app from site

## Examples

1. Perform a dry run to see what would happen on running it on a particular
   site.

   ```bash
   bench --site {site} uninstall-app {app} --dry-run
   ```

1. Don't take a backup before the application uninstall operation.

   ```bash
   bench --site {site} uninstall-app {app} --no-backup
   ```

1. Use force to uninstall application from site.

   ```bash
   bench --site {site} uninstall-app {app} --force
   ```

2. Skip the interactive prompt for confirmation of uninstall.

   ```bash
   bench --site {site} uninstall-app {app} --yes
   ```

gha_license_id: NOASSERTION


text:
# IBM FHIR Server - Schema Tool

The IBM FHIR Server Schema Tool is designed to create and update the IBM FHIR Server's schema idempotently.

The tool supports the following flows in one image:

* Onboarding - create SQL schemas, populate the SQL objects, grant permissions to the database user. For db2, the tool sets up a single tenant and tenant key.
* Offboarding - removes the schema, on Db2, if no other tenants, it deallocates the tenants
* Custom - executes a single fhir-persistence-schema cli action
* Debug - outputs debug information

# **Use**

The solution should set the variables as Environment Variables or mounted into the workarea folder as a volume which contains the persistence.json file.

## **Environment Variables**
The following environment variables:

| Name           | Purpose  |
|----------------|----------|
| ENV_SKIP       | Stop the container from making any changes, and passes through with a successful state change: `[empty\|true\|false]`|
| ENV_TOOL_INPUT | Encoded String, in most circumstances base64 encoded or well escaped text, of the json|
| ENV_TOOL_DEBUG | Flags the debug |

## Configuration Commandline
The following is read from the properties file:

| Name       | Purpose  |
|------------|----------|
| tool.behavior | Switches from the Onboarding BEHAVIOR to Offboarding BEHAVIOR flow: `[onboard\|offboard\|debug\|custom]`. |
| db.type | The database type - `[postgresql\|db2]` |
| db.host | The database server hostname|
| db.port | The database server port|
| db.database | The name of the database|
| user | A username with connect and admin permissions on the target database|
| password | The user password for connecting to the database|
| sslConnection | true or anything else, true triggers JDBC to use ssl, an example --prop sslConnection=true (db2) |
| ssl | true or anything else, true triggers JDBC to use ssl, an example --prop ssl=true (postgres) |
| tenant.key | the tenant key is a generated key, or used to set a specific value |
| tenant.name | the tenant name is typically default |
| schema.name.oauth | uses the default or custom |
| schema.name.fhir | defaults to fhirdata |
| schema.name.batch | uses the default or custom |
| grant.to | grants access to a specific user (which is going to run the application) |
| sslmode | For Postgres, you can set verify-full |
| sslrootcert | For Postgres, you must set as /opt/schematool/workarea/db.cert |
| db.cert | For Postgres, you must set as a base64 encoding of the certificate |

Further, any property supported by the [fhir-persistence-schema](https://github.com/IBM/FHIR/blob/master/fhir-persistence-schema/README.md) module is put into the file and mounted to the system.

## Configuration file - persistence.json
The configuration file is as follows in the examples configuration.

```
{
    "persistence": [
        {
            "db":  {
                "host": "<IP_ADDRESS>",
                "port": "50000",
                "database": "fhirdb",
                "user": "db2inst1",
                "password": "change-password",
                "type": "db2",
                "ssl": "false",
                "certificate_base64": "empty"
            },
            "tenant": {
                "name": "default3",
                "key": "custom-key-here"
            },
            "schema": {
                "fhir": "fhirdata",
                "batch": "",
                "oauth": ""
            },
            "grant":  "fhirserver",
            "behavior": "onboard"
        }
    ]
}
```

Note, tenant only applies to db2 implementations. The tenantKey is limited in size, and if not provided is generated. You will have to pick it out of the logs. To generate a tenantKey, you can execute: `openssl rand -base64 20`.

It's converted to base64 using `cat persistence.json | base64`. You can run locally using:

*Mac*

```
docker run  --env ENV_TOOL_INPUT=$(cat persistence.json | base64) ibmcom/ibm-fhir-schematool:latest
```

*Linux*

```
docker run  --env ENV_TOOL_INPUT=$(cat persistence.json | base64 -w 0) ibmcom/ibm-fhir-schematool:latest
```

An example volume mount:

```
    volumeMounts:
        - name: binding
          mountPath: "/opt/schematool/workarea"
          readOnly: true
    volumes:
      - name: binding
        secret:
          secretName: binding-persistence
          items:
          - key: binding
            path: persistence.json
```

# Running the Tool

## Running: Debug Behavior

The debug behavior outputs the details of the running image:

Using an encoded persistence.json

``` shell
docker run ibmcom/ibm-fhir-schematool:latest --tool.behavior=debug
```

Output
```
run.sh - [INFO]: 2020-11-09_21:39:27 - The files included with the tool are:
total 37M
drwxr-xr-x 1 root root 4.0K Nov  9 21:39 .
drwxr-xr-x 1 root root 4.0K Nov  9 20:00 ..
-rw-r--r-- 1 root root  37M Nov  6 20:33 fhir-persistence-schema-4.5.0-SNAPSHOT-cli.jar
-rwxr-xr-x 1 root root  632 Nov  9 21:39 jq
-rwxr-xr-x 1 root root  15K Nov  9 21:38 run.sh
drwxr-xr-x 2 root root 4.0K Nov  9 19:23 workarea
The OpenSSL version is:
OpenSSL 1.1.1g FIPS  21 Apr 2020
```

## Running: Offboard Behavior

Using an encoded persistence.json

*Mac*

```
docker run  --env ENV_TOOL_INPUT=`cat examples/db2/persistence-offboard-example.json |base64` \
    ibmcom/ibm-fhir-schematool:latest | tee out.log
```

*Linux*

```
docker run  --env ENV_TOOL_INPUT=`cat examples/db2/persistence-offboard-example.json |base64 -w 0` \
    ibmcom/ibm-fhir-schematool:latest | tee out.log
```

Using arguments on the commandline

``` shell
docker run ibmcom/ibm-fhir-schematool:latest --tool.behavior=offboard --db.host=<IP_ADDRESS> \
    --db.port=50000 --user=db2inst1 --password=change-password --db.database=fhirdb \
    --sslConnection=false --db.type=db2 --schema.name.fhir=fhirdata --grant.to=fhirserver \
    --tenant.name=default2 2>&1 | tee out.log
```

## Running: Onboard Behavior

Using an encoded persistence.json

*Mac*

```
docker run  --env ENV_TOOL_INPUT=`cat examples/db2/persistence-onboard-example.json |base64` \
    ibmcom/ibm-fhir-schematool:latest | tee out.log
```

*Linux*

```
docker run  --env ENV_TOOL_INPUT=`cat examples/db2/persistence-onboard-example.json |base64 -w 0` \
    ibmcom/ibm-fhir-schematool:latest | tee out.log
```

Using arguments on the commandline

``` shell
docker run ibmcom/ibm-fhir-schematool:latest --tool.behavior=onboard --db.host=<IP_ADDRESS> \
    --db.port=50000 --user=db2inst1 --password=change-password --db.database=fhirdb \
    --sslConnection=false --db.type=db2 --schema.name.fhir=fhirdata --grant.to=fhirserver \
    --tenant.name=default2 2>&1 | tee out.log
```

## Running: Custom Behavior

The custom behavior only supports commandline arguments:

``` shell
docker run ibmcom/ibm-fhir-schematool:latest --tool.behavior=onboard --list-tenants \
    --db.host=1000.com --db.password=change-password --db.user=db2inst1
```

************
# **License**

The IBM FHIR Server - Schema Tool is licensed under the Apache 2.0 license. Full license text is available at [LICENSE](https://github.com/IBM/FHIR/blob/master/LICENSE).

FHIR® is the registered trademark of HL7 and is used with the permission of HL7. Use of the FHIR trademark does not constitute endorsement of this product by HL7.
IBM and the IBM logo are trademarks of International Business Machines Corporation, registered in many jurisdictions worldwide. Other product and service names might be trademarks of IBM or other companies. A current list of IBM trademarks is available on [https://ibm.com/trademark](https://ibm.com/trademark).


text:
# Face_Detection_And_Recognition
A Python Project to detect and recognize faces using OpenCV and K-Nearest-Neighbors algorithm written from scratch in Python 3.4.4.

Dependencies - Numpy, OpenCV-Python

![alt text](https://github.com/srijannnd/Face_Detection/blob/master/my_face.png)


text:
---
title: Getting Started
page_title: Getting Started - WinForms Callout Control
description: Get started with the WinForms Callout and construct a custom notification hint with a UserControl.
slug: callout-getting-started
tags: callout
published: True
position: 3
CTAControlName: Callout
---

# Getting Started with WinForms Callout

This article shows how you can start using **RadCallout**. The following result will be achieved at the end of this tutorial:

![WinForms RadCallout Getting Started](images/callout-getting-started001.png)

>note The design may vary according to the applied theme to the application.

Follow the steps:

1\. Go ahead and add a **RadCallout** and a **RadButton** from the toolbox.

2\. Add a **UserControl** to the form. Its design depends on the exact requirement a developer may have.

The following UserControl contains:

* Header **RadPanel** which is docked to Top. It hosts a **RadPictureBox** showing the information image, a **RadLabel** displaying the "Language" caption and a **RadButton** for closing purposes.

>important Please ensure that the close **RadButton**'s **Name** property is set to **closeButton** and the RadPanel.**Name** property is set to **headerPanel**.

* Footer **RadPanel** which is docked to Bottom. It hosts three **RadButton** controls for the "Previous", "Next" and "Tour again" actions.

* **RadLabel** for displaying the main information message "Select a Language and continue to a Version".

![WinForms RadCallout RadLabel](images/callout-getting-started002.png)

3\. Build the project and then add the UserControl from the toolbox to the form.

4\. Select **RadCallout** and click the small arrow on the top right position in order to open the Smart Tag. Then set the **AssociatedControl** to the UserControl we just added onto the form:

![WinForms RadCallout AssociatedControl](images/callout-getting-started003.png)

5\. At design time double-click the **RadButton** that we added in step 1. Thus, its **Click** event handler will be generated. Now, when the button is clicked, the **RadCallout** will be shown:

#### Showing the RadCallout

{{source=..\SamplesCS\Callout\CalloutSettings.cs region=ShowCallout}}
{{source=..\SamplesVB\Callout\CalloutSettings.vb region=ShowCallout}}

````C#
private void radButton1_Click(object sender, EventArgs e)
{
    this.radCallout1.Show(this.radButton1);
}

````
````VB.NET
Private Sub RadButton1_Click(sender As Object, e As EventArgs) Handles RadButton1.Click
    Me.RadCallout1.Show(Me.RadButton1)
End Sub

````

{{endregion}}

6\. Run the project and click the button. Once the callout is shown, it will be automatically hidden if you click outside the callout's bounds.

7\. It is possible to force closing the callout when the user hits the close button in the header. For this purpose it is necessary to access the close button from the UserControl and handle its **Click** event:

#### Closing the RadCallout

{{source=..\SamplesCS\Callout\CalloutSettings.cs region=CloseCallout}}
{{source=..\SamplesVB\Callout\CalloutSettings.vb region=CloseCallout}}

````C#
public CalloutSettings()
{
    InitializeComponent();

    RadButton closeButton = calloutUserControl1.Controls["headerPanel"].Controls["closeButton"] as RadButton;
    closeButton.Click += CloseButton_Click;
}

private void CloseButton_Click(object sender, EventArgs e)
{
    if (this.radCallout1.CalloutForm.Visible)
    {
        this.radCallout1.Close();
    }
}

````
````VB.NET
Public Sub New()
    InitializeComponent()
    Dim closeButton As RadButton = TryCast(CalloutUserControl1.Controls("headerPanel").Controls("closeButton"), RadButton)
    AddHandler closeButton.Click, AddressOf CloseButton_Click
End Sub

Private Sub CloseButton_Click(ByVal sender As Object, ByVal e As EventArgs)
    If Me.RadCallout1.CalloutForm.Visible Then
        Me.RadCallout1.Close()
    End If
End Sub

````

{{endregion}}

# See Also

* [Getting Started]({%slug callout-getting-started%})
* [Design Time]({%slug callout-structure%})

repository: telerik/winforms-docs

repo_name: telerik/winforms-docs


text:
(serve-handling-dependencies)=
# Handle Dependencies

(serve-runtime-env)=
## Add a runtime environment

The import path (e.g., `fruit:deployment_graph`) must be importable by Serve at runtime.
When running locally, this path might be in your current working directory.
However, when running on a cluster you also need to make sure the path is importable.
Build the code into the cluster's container image (see [Cluster Configuration](kuberay-config) for more details) or use a `runtime_env` with a [remote URI](remote-uris) that hosts the code in remote storage.

As an example, we have [pushed a copy of the FruitStand deployment graph to GitHub](https://github.com/ray-project/test_dag/blob/40d61c141b9c37853a7014b8659fc7f23c1d04f6/fruit.py). You can use this config file to deploy the `FruitStand` deployment graph to your own Ray cluster even if you don't have the code locally:

```yaml
import_path: fruit:deployment_graph

runtime_env:
    working_dir: "https://github.com/ray-project/serve_config_examples/archive/HEAD.zip"
```

:::{note}
You can also package a deployment graph into a standalone Python package that you can import using a [PYTHONPATH](https://docs.python.org/3.10/using/cmdline.html#envvar-PYTHONPATH) to provide location independence on your local machine. However, the best practice is to use a `runtime_env`, to ensure consistency across all machines in your cluster.
:::

## Dependencies per deployment

Ray Serve also supports serving deployments with different (and possibly conflicting)
Python dependencies.  For example, you can simultaneously serve one deployment
that uses legacy Tensorflow 1 and another that uses Tensorflow 2.

This is supported on Mac OS and Linux using Ray's {ref}`runtime-environments` feature.
As with all other Ray actor options, pass the runtime environment in via `ray_actor_options` in
your deployment.  Be sure to first run `pip install "ray[default]"` to ensure the
Runtime Environments feature is installed.

Example:

```{literalinclude} ../../../../python/ray/serve/examples/doc/conda_env.py
```

:::{tip}
Avoid dynamically installing packages that install from source: these can be slow and
use up all resources while installing, leading to problems with the Ray cluster.  Consider
precompiling such packages in a private repository or Docker image.
:::

The dependencies required in the deployment may be different than
the dependencies installed in the driver program (the one running Serve API
calls). In this case, you should use a delayed import within the class to avoid
importing unavailable packages in the driver.  This applies even when not
using runtime environments.

Example:

```{literalinclude} ../../../../python/ray/serve/examples/doc/delayed_import.py
```

repository: ray-project/ray

gha_language: Python

repo_name: ray-project/ray


text:
How do you share your honest opinions with your in-laws? These are some of the family issues tackled by the good people at M³@Nee Soon.
Huda Ali meets Madam Zarina and Mr Djohan Abdul Rahman to learn more about M3 at Nee Soon’s efforts to strengthen family ties and unite the community ❤

To find out more on:
- M³@Nee Soon, follow them on [Facebook](https://bit.ly/m3atneesoon)
- Becoming an M³@Town volunteer, visit [here](https://www.m3.gov.sg/be-a-volunteer)

branch_name: refs/heads/staging

gha_language: SCSS


text:
WordPress Core Autoloader for Composer
=====================================

This is a custom autoloader generator and class map loader Composer plugin for WordPress Core.

It diverges from the default Composer autoloader setup in the following ways:

* The generated autoloader is compatible with PHP 5.2. Classes containing PHP 5.3+ code will be skipped and throw warnings.
* The paths to the classes are relative to a set constant. The default constant being used is `ABSPATH`.
* The class maps can optionally be configured to be case-insensitive.

Usage
-----

In your project's `composer.json`, add the following lines:

```json
{
    "require": {
        "schlessera/composer-wp-autoload": "^1"
    },
    "scripts": {
        "post-install-cmd": [
            "WordPress\\ComposerAutoload\\Generator::dump"
        ],
        "post-update-cmd": [
            "WordPress\\ComposerAutoload\\Generator::dump"
        ],
        "post-autoload-dump": [
            "WordPress\\ComposerAutoload\\Generator::dump"
        ]
    },
    "extra": {
        "wordpress-autoloader": {
            "class-root": "ABSPATH",
            "case-sensitive": true
        },
    }
}
```

After the next update/install, you will have a `vendor/autoload_wordpress.php` file, that you can simply include and use to autoload classes within WordPress Core.

Valid "extra" Keys
------------------

You can configure the autoloader by providing `"extra"` keys under the `"wordpress-autoloader"` root key.

* __`"class-root"`__ :

    String value that is used to replace the `dirname($vendorDir)` string.
    The default is `"ABSPATH"`, to make the autoloader use the `ABSPATH` constant.

* __`"case-sensitive"`__:

    Boolean value to configure whether the classmap loader should be case-sensitive or not. The default value is `true`.

Contributing
------------

All feedback / bug reports / pull requests are welcome.

License
-------

This code is released under the MIT license.

For the full copyright and license information, please view the [`LICENSE`](LICENSE) file distributed with this source code.

repository: schlessera/composer-wp-autoload

repo_name: schlessera/composer-wp-autoload