text:
---
layout: default
---

# 1993-10-20 - Re: pseudospoofed out

## Header Data

From<EMAIL_ADDRESS>(Mike McNally)

To<EMAIL_ADDRESS>Message Hash: 1ba7b387a32e2021a9334744cee7a6b9819f2e6086fafa59ac79bd850e34b8b9

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1993-10-20 13:32:30 UTC

Raw Date: Wed, 20 Oct 93 06:32:30 PDT

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Mike McNally)
Date: Wed, 20 Oct 93 06:32:30 PDT
To<EMAIL_ADDRESS>Subject: Re: pseudospoofed out
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

"L. Detweiler"  writes:
 > [ the funniest thing I've read on the net in years. ]

Thank you, thank you, thank you *all* for making this possible.  The
hours of cleaning crud from my INBOX are *easily* worth this kind of
entertainment.  I am literally in tears, irritating my officemate with
incessant laughter.

Mr. Detweiler (if that really *is* your name), thank you especially.
You write well, kinda, even if I utterly disagree with you.  I think
I'll print this out and paste it into my big unabridged next to
"hyperbole".

--
Mike McNally

{% endraw %}
```

## Thread

+ Return to [October 1993](/archive/1993/10)

+ Return to "["L. Detweiler" <ld231782@longs.lance.colostate.edu>](/authors/l_detweiler_ld231782_at_longs_lance_colostate_edu_)"
+ Return to<EMAIL_ADDRESS>(Mike McNally)](/authors/m5_at_vail_tivoli_com_mike_mcnally_)"

+ 1993-10-20 (Wed, 20 Oct 93 00:17:42 PDT) - [pseudospoofed out](/archive/1993/10/46b8f7bda8441adb214a1682d6a67d1f5d20ce75208ba29707434ed57e32dd2f) - _"L. Detweiler"<EMAIL_ADDRESS>  + 1993-10-20 (Wed, 20 Oct 93 06:22:42 PDT) - [pseudospoofed out](/archive/1993/10/f6f78633f4ba2d5d6aad992c0938ae36f6c201a7b8a3d69b3305d37d27c3e0cc) -<EMAIL_ADDRESS>(Mike McNally)_
  + 1993-10-20 (Wed, 20 Oct 93 06:32:30 PDT) - Re: pseudospoofed out -<EMAIL_ADDRESS>(Mike McNally)_


text:
---
layout: post
title: April 19th - Extreme Love...works at overcoming anger.
categories: [Verse of the Day]
alias: [/VerseOfTheDay/2010/04/19/]
---

_Proverbs 16:32
He that is slow to anger is better than the mighty; and he that
ruleth his spirit than he that taketh a city._

One of the tactics of the evil one, is to make sure you focus on
all the wrong things in your life, rather than the good. Every time
there is a door shut in your life through adversity or problems, God
will also open a door for your deliverance. If you respond with
anger, you will never see what "love" could have accomplished. When
you embrace God's goodness, anger leaves the room.

 --

Jesus Every Day is a ministry of Rodgers Baptist Church in Garland, Texas.

license: MIT

branch_name: refs/heads/master

extension: markdown

gha_language: JavaScript

license_type: permissive


text:
# Algolia4You

# Goal
Allow some e-commerce owner who wants to try [Algolia](https://algolia.com) without anything to code to actually do that.

# How it works
  *1 - Simply go to [pamart.in/Algolia4you/](http://pamart.in/Algolia4you/)
  *2 - Put your e-commerce CMS in the input
  *3 - Let the magic happen

# Limitation
For now it only works with Woocomerce (YEAST SEO installed) and Shopify. Prestashop should arrive
Limit for each site is 500 objects as the app on my site is plugged to a Community plan

# Installation
If you want plug your own accound to use this tools, you'll simple have to change the API key :
 * One back/secret_key.php defining : $GLOBALS['MASTER_KEY'] = [your-write-key];
 * AppID in app.js const appId = '[your-app-id]';
 * apiKey in app.js const apiKey = '[your-api-READ-ONLY]';

** !!!Never put your Admin API Key in a front Javascript file!!! **

# Left to do :

* Listen and adapt to your feedback
* Fine tunes the indices
* Add a debug mode
* Add a more visual progress bar
* Update Algolia libraries
* Add a function to compare with native search
* Add Color, Size etc. in Object
* Add more CMS
* Remove first level of categories when generic (shops, collections etc...)
* Lite version of the repo

* Sky is the limit...

I'll create github issues to details those.

# Disclaimer

I code for fun and this was made to show Algolia my <3 !

extension: md


text:
## What is new in 1.8.7

 - **Plugins subsystem changes**

It has been upgraded to include context plugins and multi-instance support.

 - **ImageScope section object viewer**

New WinObjEx64 context plugin. Display information about section object that is backed by an image file. Show version info fields, printable strings.

 - **Other**
   + Compatibility improvements for Windows 10 20H1/20H2/21H1 versions.
   + Added recongnizing of shimmed drivers in drivers list, this feature is only supported starting from Windows 10
   + Process trust label (if present) now also displayed for objects of section type
   + Added plugins viewer
   + Multiple other minor changes in program logic and UI
   + Fixed several bugs

gha_language: C


text:
# Parmelia ambigua var. exasperata (Müll. Arg.) Gyeln. VARIETY

#### Status
SYNONYM

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

#### Published in
Annls hist. -nat. Mus. natn. hung. 30: 125 (1936)

#### Original name
Parmelia conspersa f. exasperata Müll. Arg.

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Ascomycota/Lecanoromycetes/Lecanorales/Parmeliaceae/Xanthoparmelia/Xanthoparmelia amplexula/ Syn. Parmelia ambigua exasperata/README.md

repo_name: mdoering/backbone


text:
---
layout: post
title: "Migrations with Spring Boot and Flyway"
author: "Lasse Schultebraucks"
categories:  [Spring Boot, Java, Hibernate, Flyway, Database]
comments: true
---

In the last month I worked a lot with migrations in a Spring Boot application. I used [Flyway](https://flywaydb.org/) as a version control tool to manage migration scripts. Flyway is a great and easy to use tool to deal with migrations in a Java project with a SQL database.

In the following I will show you in a demo application how to set up flyway in a spring boot application with PostgreSQL. You can check out the whole code on my [GitHub](https://github.com/LSchultebraucks/FlywayMigrationDemoSpringBoot).

First we need to create a fresh spring boot application. You can also add Flyway to your spring boot application if you are already in development or in production and want to begin with database migrations.

You can create a fresh spring boot application with the [spring initializer](https://start.spring.io/). As dependencies choose Web, JPA, Flyway and PostgreSQL. That is all you need in the beginning. I started with adding a Book entity.

```java
package com.lasseschultebraucks.flyway.demo.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Book {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private long id;

    private String name;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

```

As you can see it already has JPA annotations on the class and on one attribute to mark the whole class as a database entity and the determine the primary key.

Next we can use PostgreSQL to set up a local database and to connect it to our application. Therefore we first need to [download and install PostgreSQL](https://www.postgresql.org/download/). After the installation you can start pgAdmin, add a user (with username/password `admin`) and create a new database named `flyway-core` and owner `admin`.

Next we can create the configure the connection to the database in the `application.yaml`.

```yaml
spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/flyway-demo
    username: ${db.appUser:admin}
    password: ${db.password:admin}
  jpa:
    hibernate:
      ddl-auto: none
    database-platform: org.hibernate.dialect.PostgreSQLDialect
    properties:
      hibernate:
        temp:
          use_jdbc_metadata_defaults: false
  flyway:
    baseline-on-migrate: true
```

In the first lines we have configured our PostgreSQL database connection. Then we told hibernate to disable the automatic schema generation, because we will deal with it yourself now. Last but not least we enabled the flyway migration on the application start.

Next we can create our first migration script. We can either create migration scripts in Java or SQL with flyway. In this tutorial I will just create migration scripts in SQL. To do this, we need to create a new file in the `resources/db/migration` package. Flyway executes the migration script in folder based on their version numbers. So we will start with a file named `V0__InitialBook.sql`

```sql
CREATE TABLE public.book
(
    id   BIGINT NOT NULL,
    name CHARACTER varying(255),
    CONSTRAINT book_pkey PRIMARY KEY (id)
);
ALTER TABLE public.book
    OWNER TO admin;
```

As you can see the script will create a new table in our database for the book entity which we created previously.

Now we can start our Spring Boot Application for the first time. You can open pgAdmin and see that the there will be now a table named `book`. There is also a table named flyway_schema_history, which holds and manage the current version and state of the database. If there is a new migration script which is not marked in the table, then flyway will execute the script and bring the database to the newest state.

Next I added a new entity named `Author`.

```java
package com.lasseschultebraucks.flyway.demo.model;

import javax.persistence.*;
import java.util.ArrayList;
import java.util.Collection;

@Entity
public class Author {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    @Column(name = "author_name")
    private String name;

    @OneToMany(mappedBy = "author", cascade = CascadeType.DETACH)
    private Collection<Book> bookCollection = new ArrayList<>();

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Collection<Book> getBookCollection() {
        return bookCollection;
    }

    public void setBookCollection(Collection<Book> bookCollection) {
        this.bookCollection = bookCollection;
    }
}

```

Also the book entity gets an extra line:

````java
   // ...
    @ManyToOne
    private Author author;
    //...
````
As you can see, there is now a Many to One relationship between Author and book.

Because we have a new entity and also a new relationship between our entities we have to update our database schema with a second migration script:

```sql
CREATE TABLE public.author(
    id BIGINT NOT NULL,
    author_name CHARACTER varying(255),
    CONSTRAINT author_pkey PRIMARY KEY (id)
);
ALTER TABLE public.author
    OWNER TO admin;

ALTER TABLE public.book
    ADD author_id bigint,
    ADD CONSTRAINT author_id FOREIGN KEY (author_id)
        REFERENCES public.author (id) MATCH SIMPLE;

CREATE SEQUENCE public.hibernate_sequence
    INCREMENT 1
    MINVALUE 1
    MAXVALUE<PHONE_NUMBER>854775807
    START 1
    CACHE 1;
ALTER TABLE public.hibernate_sequence
    OWNER TO admin;
```

The first two queries will create an author table and create a foreign key constraint in book for the author id.

The last query will create a hibernate sequence. A hibernate sequence manage the id numbers in our database, so that no entity has equals ids. We need this because in our next step we will insert data in our database:

````java
package com.lasseschultebraucks.flyway.demo;

import com.lasseschultebraucks.flyway.demo.model.Author;
import com.lasseschultebraucks.flyway.demo.model.Book;
import com.lasseschultebraucks.flyway.demo.repository.AuthorRepository;
import com.lasseschultebraucks.flyway.demo.repository.BookRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import java.util.Arrays;

@SpringBootApplication
public class DemoApplication implements CommandLineRunner {

    private final AuthorRepository authorRepository;
    private final BookRepository bookRepository;

    @Autowired
    public DemoApplication(AuthorRepository authorRepository, BookRepository bookRepository) {
        this.authorRepository = authorRepository;
        this.bookRepository = bookRepository;
    }

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        clearTables();

        Author author = new Author();
        author.setName("J.K. Rowling");
        Book book = new Book();
        book.setName("Harry Potter and the Philosopher’s Stone");
        book.setAuthor(author);
        Book book1 = new Book();
        book1.setName("Harry Potter and the Chamber of Secrets");
        book1.setAuthor(author);
        author.setBookCollection(Arrays.asList(
                book, book1
        ));
        authorRepository.save(author);
        bookRepository.save(book);
        bookRepository.save(book1);
    }

    private void clearTables() {
        authorRepository.deleteAll();
        bookRepository.deleteAll();
    }
}

````

After executing once again our Spring Boot application we will now have a new state of our database and also initial data in our database. You can check you state of your database once again in pgAdmin.

As mentioned earlier, you can find the whole code on my [GitHub](https://github.com/LSchultebraucks/FlywayMigrationDemoSpringBoot).


text:
# SAT: 2D Semantics Assisted Training for 3D Visual Grounding
[SAT: 2D Semantics Assisted Training for 3D Visual Grounding](https://arxiv.org/pdf/2105.11450.pdf)

by [Zhengyuan Yang](https://zhengyuan.info), [Songyang Zhang](https://sy-zhang.github.io/), [Liwei Wang](https://lwwangcse.github.io/), and [Jiebo Luo](http://cs.rochester.edu/u/jluo)

IEEE International Conference on Computer Vision (ICCV), 2021, Oral

## Introduction
We propose 2D Semantics Assisted Training (SAT) that assists 3D visual grounding with 2D semantics.
SAT helps 3D tasks with 2D semantics in training but does not require 2D inputs during inference.
For more details, please refer to our
[paper](https://arxiv.org/pdf/2105.11450.pdf).

## Citation

    @inproceedings{yang2021sat,
      title={SAT: 2D Semantics Assisted Training for 3D Visual Grounding},
      author={Yang, Zhengyuan and Zhang, Songyang and Wang, Liwei and Luo, Jiebo},
      booktitle={ICCV},
      year={2021}
    }

## Prerequisites
* Python 3.6.9 (e.g., conda create -n sat_env python=3.6.9 cudatoolkit=10.0)
* Pytorch 1.2.0 (e.g., conda install pytorch==1.2.0 cudatoolkit=10.0 -c pytorch)
* Install other common packages (numpy, [pytorch_transformers](https://pypi.org/project/pytorch-transformers/), etc.)
* Please refer to ``setup.py`` (From [ReferIt3D](https://github.com/referit3d/referit3d)).

## Installation

- Clone the repository

    ```
    git clone https://github.com/zyang-ur/SAT.git
    cd SAT
    pip install -e .
    ```

- To use a PointNet++ visual-encoder you need to compile its CUDA layers for [PointNet++](http://arxiv.org/abs/1706.02413):
```Note: To do this compilation also need: gcc5.4 or later.```
    ```
    cd external_tools/pointnet2
    python setup.py install
    ```

## Data
### ScanNet
First you should download the train/val scans of ScanNet if you do not have them locally. Please refer to the [instructions from referit3d](referit3d/data/scannet/README.md) for more details. The output is the ``scanfile`` ``keep_all_points_00_view_with_global_scan_alignment.pkl/keep_all_points_with_global_scan_alignment.pkl``.

### Ref3D Linguistic Data
You can dowload the Nr3D and Sr3D/Sr3D+ from [Referit3D](https://github.com/referit3d/referit3d#our-linguistic-data), and send the file path to ``referit3D-file``.

### SAT Processed 2D Features
You can download the processed 2D object image features from [here](https://drive.google.com/file/d/1X_a9jWWNNkBGs49A3j4OKW4iz-gytnJA/view?usp=sharing). The cached feature should be placed under the ``referit3d/data`` folder, or match the cache path in the [dataloader](https://github.com/zyang-ur/SAT/blob/main/referit3d/in_out/pt_datasets/listening_dataset.py#L142). The feature extraction code will be cleaned and released in the future. Meanwhile, feel free to contact<EMAIL_ADDRESS>if you need that before the official release.

## Training
Please reference the following example command on Nr3D. Feel free to change the parameters. Please reference [arguments](referit3d/in_out/arguments.py) for valid options.
  ```
  cd referit3d/scripts
  scanfile=keep_all_points_00_view_with_global_scan_alignment.pkl ## keep_all_points_with_global_scan_alignment if include Sr3D
  python train_referit3d.py --patience 100 --max-train-epochs 100 --init-lr 1e-4 --batch-size 16 --transformer --model mmt_referIt3DNet -scannet-file $scanfile -referit3D-file $nr3dfile_csv --log-dir log/$exp_id --n-workers 2 --gpu 0 --unit-sphere-norm True --feat2d clsvecROI --context_2d unaligned --mmt_mask train2d --warmup
  ```

## Evaluation
Please find the pretrained models [here](https://drive.google.com/drive/folders/14VZQHu38mZ0aoLbBAXM-_LHCMgBktH_Q?usp=sharing) (clsvecROI on Nr3D).
A known issue [here](https://github.com/zyang-ur/SAT/blob/main/referit3d/scripts/train_referit3d.py#L12).
  ```
  cd referit3d/scripts
  python train_referit3d.py --transformer --model mmt_referIt3DNet -scannet-file $scanfile -referit3D-file $nr3dfile --log-dir log/$exp_id --n-workers 2 --gpu $gpu --unit-sphere-norm True --feat2d clsvecROI --mode evaluate --pretrain-path $pretrain_path/best_model.pth
  ```

## Credits
The project is built based on the following repository:
* [ReferIt3D](https://github.com/referit3d/referit3d).

Part of the code or models are from [ScanRef](https://github.com/daveredrum/ScanRefer), [MMF](https://github.com/facebookresearch/mmf), [TAP](https://github.com/microsoft/TAP), and [ViLBERT](https://github.com/jiasenlu/vilbert_beta).

repository: sega-hsj/SAT

branch_name: refs/heads/main

repo_name: sega-hsj/SAT


text:
# part 1:
- These are different in many ways, including their dimensions such as the number of commits, users, breanches etc. The visualization could show: commits, timeline, number of commits, user info, amount of commit, collaboration etc.
- commits, timeline, number of commits, user info, collaboration
- We choose the collboration as the most important point and using the hive plot we will visualize that.

# Part 2:
- commits, timeline, number of commits, user info, collaboration. Here we use collaboration as the strongest.
- It is necessary if we want to actually have an idea of the amount of commit an user did. However, if the number of added lines is not large we could choose not to show that commit.

- Having a row for each contributor makes the graph simpler. However, we could try to achieve the effect with colors and make the visualization more compact.
- Node-link diagram seems to be most appropriate here because here are talking about relations and collaborations,

# part 3:
- We had two ideas, one was using line graph to show the contricution of individual user another was to show the collaboration using a hive plot. We choose the hive plot because it not only shows the commit timescale, it shows the collaoboration very clearly, which could be a valuable information. (Please check the sketch.jpg for the sketch).


text:
# Min-Node

## Idea

NPM already provides a possibility for package authors to specify which Node versions their package can be used with, namely the [engines](https://docs.npmjs.com/files/package.json#engines) field in the package.json file.

## Motivation

But there is currently no way to find out quickly which the minimum required Node version is that you need for your project depending on your dependencies.

So it would be super nice to run some script like

`npx min-node`

and get an answer to this question. Well... now you can do exactly that!

## Disclaimer

**This package WILL NOT PROVIDE and CAN NOT GUARANTEE you a 100% accurate answer to this question.**

Why not? Well, we do not live in a perfect world and thus there are certain factors and assumptions that influence the quality of the result.

### Assumption: Node range specified on a dependency fulfills the Node ranges of all its own dependencies

Example: Your project has package "foo" as a dependency. "foo" itself has a dependency on its own called "bar".

To simplify the logic here we assume that the minimum node version that "foo" requires also matches the Node range specified on "bar" and any other dependency "foo" might have besides "bar".

With this assumption it is "enough" to check the direct dependencies of your project instead of checking the whole dependency tree.

### Factor package.json Quality: What about packages that do not provide the `engines` field in their package.json?

Short answer: We ignore those packages for now, but still they all might have hidden Node dependencies which are not taken into account at all.

You will just find them while trying it out.

## Tl;dr

Don't take the results too seriously. The package is meant to be used for getting a broad idea which Node version might be required to fit all dependencies.

The result you get back is baked under all those assumptions and factors explained above.

But one thing is for sure: The exact specified minimum node version you need is not less than what we gave you as an orientation. It can just be higher as that one.

gha_language: TypeScript

gha_license_id: MIT


text:
# Configuring WS-Federation

WS-Federation (Web Services Federation) describes the management and
brokering of trust relationships and security token exchange across Web
services and organizational boundaries. WS-Federation is a part of the
larger WS-Security framework. For example, WS-Federation builds on the
Security Token Service (STS) by providing mechanisms that facilitate
interactions. In the WS-Federation Model, an Identity Provider is a
Security Token Service (STS). Service Providers depend on an Identity
Provider or Security Token Service to do the user authentication. OAuth
is an important protocol for IdP services as most major Web services are
also identity providers, mainly through the use of OAuth. These Web
services include Google, Facebook, Yahoo, AOL, Microsoft, PayPal,
MySpace, and Flickr among much more. Furthermore, all major email
providers offer OAuth IdP services.

In most instances it is necessary to secure the Security Token Service.
According to the Trust Brokering model defined in the WS-Trust
specification, the subject (user) should authenticate themself to the STS
before obtaining a token. STS may use this authentication information
when constructing the security token. For example, STS may populate the
required claims based on the user name provided by the subject.

To navigate to the federated authenticators configuration section, do
the following.

1.  Sign in. Enter your username and password to log on to the
    [Management
    Console](../../setup/getting-started-with-the-management-console).

2.  Navigate to the **Main** menu to access the **Identity** menu. Click
    **Add** under **Identity Providers**.
    For more information, see [Adding and Configuring an Identity
    Provider](../../learn/adding-and-configuring-an-identity-provider).

3.  Fill in the details in the **Basic Information** section.

1.  Expand the **WS-Federation(Passive) Configuration** form.
    ![ws-federation-passive-configuration](../assets/img/tutorials/ws-federation-passive-configuration.png)

2.  Fill in the following fields where relevant.

    <colgroup>
    <col style="width: 33%" />
    <col style="width: 44%" />
    <col style="width: 22%" />
    </colgroup>

    Field
    Description
    Sample value

    Enable Passive STS
    Selecting this option enables Passive STS to be used as an authenticator for users provisioned to the Identity Server.
    Selected

    Default
    Selecting the Default checkbox signifies that Passive STS is the main/default form of authentication. This removes the selection made for any other Default checkboxes for other authenticators.
    Selected

    Passive STS Realm
    This is used as an identifier for the realm and can be any value.
    WSFederationHealthCare

    Passive STS URL

When sending the authentication request, there is a request for a security token generated by WS-Trust.

Note

	As long as the federated IdP is the WSO2 Identity Server, this URL must follow this format:                                    https://(host-name):(port)/acs

    https://localhost:9443/passivests/

    Passive STS User ID Location
    Select whether the User ID is found in 'Name Identifier' as part of the authentication request or if it is found among the claims. This specifies how the user is identified.
    User ID found in 'Name Identifier'

    Additional Query Parameters
    This is necessary if you are connecting to another Identity Server or application. Sometimes extra parameters are required by this IS or application so these can be specified here.
    paramName1=value1

!!! info "Configuring hostname verification"

	In previous releases, Passive STS Single-Logout (SLO) requests for
	service providers were initiated without hostname verification which can
	impose a security risk. From IS 5.2.0 release onwards, certificate
	validation has been enforced and hostname verification is enabled by
	default. If you want to disable the hostname verification, open the `	<IS_HOME>/repository/conf/deployment.toml	` file and add the following configuration.

	``` xml
	[saml.slo]
	host_name_verification: false
	```

	!!! info

		- If the certificate is self-signed, import the service
		provider's public key to the IS client trust store to ensure that the
		SSL handshake in the SLO request is successful. For more information on
		how to do this, see [Managing Keystores with the UI](../../administer/managing-keystores-with-the-ui) in
		the WSO2 Product Administration Guide.

		- Identity Federation is part of the process of configuring an
		identity provider. For more information on how to configure an
		identity provider, see [Configuring an Identity
		Provider.](../../learn/adding-and-configuring-an-identity-provider)

repository: NipuniBhagya/docs-is

repo_name: NipuniBhagya/docs-is


text:
---
layout: layouts/component.njk
title: Sortable table
---

{% lastUpdated "sortable-table" %}

{% example "/examples/sortable-table", 450 %}

## When to use

Use the sortable table component to let users sort columns in ascending or descending order.

Use this component when sorting is needed to help find data within a large table of data. This might be useful in combination with the [filter](../../patterns/filter-a-list) pattern.

## How to use

If you are using [Nunjucks](https://mozilla.github.io/nunjucks/) or the [GOV.UK Prototype Kit](https://govuk-prototype-kit.herokuapp.com/), you can use the Nunjucks [table macro](https://design-system.service.gov.uk/components/table/).

repository: ministryofjustice/moj-frontend

repo_name: ministryofjustice/moj-frontend


text:
# Fab

A build system for C++ projects.  Make based, non-recursive and incremental.

## Features

- Robust incremental builds.  Rebuilds exactly what needs to be rebuilt, no more and no less.
- Build artifacts (object files, libraries, binaries, etc) are placed in a build tree outside the source tree.
- Support for executing unit tests as part of the build process.  A test failure is treated as a build failure.
- Zero Make boilerplate required to build a project.
- Tested with GNU Make, g++ and clang++ on Linux and macOS.

## Getting Started

Clone Fab, it may be placed inside or outside your project, e.g.

    FAB=~/fab
    git clone https://github.com/dpicken/fab $FAB
    cd my-project
    ln -s $FAB/Makefile .; # Use Fab's Makefile.
    ln -s $FAB/config .; # Use Fab's example configuration (optional, see below).
    make

Fab looks for source code within sub-directories of `my-project/src` and places all build artifacts in `my-project/build`.
These locations are configurable (see below).

N.B. Fab's example configuration supports release and debug builds.
A release build places its (optimized) artifacts in `my-project/build_release`.
A debug build places its artifacts in `my-project/build_debug`.

## Libraries

A static library is built for each directory that contains files with a `.cc` extension.
The extension is configurable (see below).

A library is named after its corresponding source path, e.g.

    src/example/foo.cc
    src/example/bar.cc
    src/example/subexample/qux.cc

...will yield:

    build/example/example.a (containing the object files built from src/example/foo.cc and src/example/bar.cc).
    build/example/subexample/subexample.a (containing the object file built from src/example/subexample/qux.cc).

## Binaries

An executable binary is built for each source directory that contains a `main.cc` and/or a `bin.make` file.

A binary is named after its corresponding source path, e.g.

    src/hello_world/main.cc

...will yield:

    build/hello_world/hello_world.a (containing the object file built from src/hello_world/main.cc).
    build/hello_world/hello_world (binary, implicitly linked with build/hello_world/hello_world.a).

Any additional libraries a binary depends on must be explicitly specified in its `bin.make` file.

### bin.make files

A `bin.make` file specifies a binary's additional dependencies via two lists:

- `LIB_DIRS` - list of paths within `my-project/src`.
- `SYSTEM_LIBS` - list of system libraries.

e.g. if `src/hello_world/bin.make` contained:

    LIB_DIRS += example
    LIB_DIRS += example/subexample
    SYSTEM_LIBS += rt

...then `build/hello_world/hello_world` would additionally be linked with the project libraries built from:

- `src/example`
- `src/example/subexample`

And the system library:

- `librt`

Alternatively and/or additionally, specific flags needed to build the binary can be specified via:

- `LDFLAGS` - list of link-time flags.

## Tests

Any binaries beneath a directory named "test" are executed by the build process.

The standard out/error streams of a test binary are redirected to a log file named after the binary.

A test is expected to return zero on success and non-zero on failure.

A test failure is treated as a build failure (its log file will be printed to standard out).

e.g. the binary produced from:

    src/example/test/main.cc

...would be:

    build/example/test/test

...and its log file would be:

    build/example/test/test.log

## Build targets

Fab provides the following standard targets:

- `all` - builds everything (that needs to be rebuilt) and runs all tests (that need to be re-run).  This is the default target.
- `clean` - removes all build artifacts.

## Configuration

The following Make variables may be overriden via `my-project/config/*.make` files:

- `SRC_DIR` - the name of the directory that contains the project's source code.  The default is `src`.
- `SRC_EXT` - the file name extension used by the project's C++ files.  The default is `cc`.
- `BUILD_DIR` - the directory into which build artifacts are placed.  The default is `build`.
- `CXX` - the compiler.  The default is `g++`.
- `CXXFLAGS` - flags passed to the compiler.  The default flags are `""`.
- `AR` - the archive tool used to create static libraries from objects files.  The default is `ar`.

The following Make variables have no effect on the build artifacts and may be overriden via `my-project/config/*.make` files or via the environment:

- `ECHO_BUILD_MESSAGES` - whether to print out-of-date targets (build artifacts) and their prerequisites that have changed.  The default is `x` (yes).
- `ECHO_RECIPES` - whether to print build recipes.  The default is `""` (no).

## Example configuration and project

Fab includes an example configuration, with the following features:

- Release and debug builds:
  - A release build is built by default (or explicitly with `BUILD=release make`), its artifacts are placed in `build_release`.
  - A debug build is built with `BUILD=debug make`, its artifacts are placed in `build_debug`.
- Compiles using the C++14 standard.
- Almost all warnings enabled.
- Warnings treated as errors.

Fab also includes an example project containing:

- the traditional "hello world" program
- a multilingual "hello world" program, supporting libraries and a test.

## License

Fab is available under the MIT license.  See the LICENSE file for details.

repository: dpicken/fab

repo_name: dpicken/fab


text:
# Concepts of Parallel Letter Frequency

## Concurrency

The goal of this exercise is to learn to write concurrent code to count the letters inside different texts.

## Goroutines

In order to count concurrent the apppearance of different letters in separate texts it is important to be able to create goroutines with the `go` keyword, one for each text where the letters are counted.

## Channel

In this exercise the student can learn to use a channel to make the main goroutine communicate with the goroutines that count letters.

## Functions

The function that has to be called concurrently to count needs to be created in order to get the total count at the end.

### Anonymous functions

However, since it is a simple function it is not necessary to define an external function but it can be coded inside the `go` statement.

## For range

To iterate on the texts and on the frequency map a plain `for` clause is no more needed than a for range statement as there is no specific manipulation to do on the index of the `for` loop.

## Map

The type `FreqMap` is itself a map so students have to familarize with it and with operations such as accessing via `[]` ,looping and its zero-value when the key requested does not exists


text:
#  <img src="skill_icon" alt="Dinosaur Alphabet icon" width="36"> [Dinosaur Alphabet](http://alexa.amazon.com/#skills/amzn1.echo-sdk-ams.app.7463426e-d72e-409d-a6e8-19df81922f93)
![0 stars](../../images/ic_star_border_black_18dp_1x.png)![0 stars](../../images/ic_star_border_black_18dp_1x.png)![0 stars](../../images/ic_star_border_black_18dp_1x.png)![0 stars](../../images/ic_star_border_black_18dp_1x.png)![0 stars](../../images/ic_star_border_black_18dp_1x.png) 0

To use the Dinosaur Alphabet skill, try saying...

* *Alexa, ask Dinosaur Alphabet for a dinosaur that starts with Bravo*

* *a dinosaur that begins with the NATO phonetic letter Bravo*

* *the letter Bravo*

Practice your NATO phonetic alphabet and learn fun facts about dinosaurs at the same time. Simply ask Alexa to give you a dinosaur that starts with any letter of the NATO phoenetic alphabet and she will tell you some facts about a dinosaur that starts with that letter.  If you give alexa a word that is not part of the NATO phonetic alphabet, she will let you know.

***

### Skill Details

* **Invocation Name:** dinosaur alphabet
* **Category:** null
* **ID:** amzn1.echo-sdk-ams.app.7463426e-d72e-409d-a6e8-19df81922f93
* **ASIN:** B01HC599MU
* **Author:** Tim North
* **Release Date:** July 4, 2016 @ 04:57:47
* **In-App Purchasing:** No


text:
# codingame-multiplayer-bot_programming-coders_strike_back
22,929 CodinGamers in the Coders Strike Back arena

https://www.codingame.com/multiplayer/bot-programming/coders-strike-back

![alt text](screenshots/ScreenShot001.png)

## The Goal

Win the race.

## Rules

The circuit of the race is made up of checkpoints. To complete one lap, your vehicle (pod) must pass through each checkpoints in order and back through the start. The first player to reach the starting checkpoint on the final lap wins.

The pods work as follows:
- To pass a checkpoint, the center of a pod must be inside the radius of the checkpoint.
- To move a pod, you must print a target destination point followed by a thrust value. Details of the protocol can be found further down.
- The thrust value of a pod is it's acceleration and must be between 0 and 100.

### Victory Conditions
- Be the first to complete all the laps of the circuit with your pod.

### Lose Conditions
- Your program provides incorrect output.
- Your program times out.
- Your pod does not reach the next checkpoint in time.
- Somebody else wins.

## Expert Rules

The game is played on a map 16000 units wide and 9000 units high. The coordinate X=0, Y=0 is the top left pixel.

The checkpoints work as follows:
- The checkpoints are circular, with a radius of 600 units.
- The disposition of the checkpoints is selected randomly for each race.

The pods work as follows:
- If none of your pods make it to their next checkpoint in under 100 turns, you are eliminated and lose the game.
- The pods may move normally outside the game area.

Note: You may activate debug mode in the settings panel () to view additional game data.

## Note

The program must, within an infinite loop, read the contextual data from the standard input and provide to the standard output the desired instructions.

## Game Input

### Input for one game turn

First line: 6 integers x & y for your pod's position. nextCheckpointX & nextCheckpointY for the coordinates of the next checkpoint the pod must go through. nextCheckpointDist for the computed distance between your pod and the next checkpoint, nextCheckpointAngle for the angle in degrees between your pod orientation and the direction of the next checkpoint (from -180 to 180).

Second line: 2 integers opponentX & opponentY for the opponent pod's position.

### Output for one game turn

One line: 2 integers for the target coordinates of your pod followed by thrust, the thrust to give to your pod.

### Constraints

- 0 ≤ thrust ≤ 100
- Response time first turn ≤ 1000ms
- Response time per turn ≤ 150ms

repository: DamienFremont/codingame

repo_name: DamienFremont/codingame


text:
![Newron](https://raw.githubusercontent.com/hugues31/newron/master/newron.png)
===========
[![crates.io](https://img.shields.io/crates/v/newron.svg)](https://crates.io/crates/newron)
[![Downloads from crates.io](https://img.shields.io/crates/d/newron.svg)](https://crates.io/crates/newron)
![Rust](https://github.com/hugues31/newron/workflows/Rust/badge.svg?branch=master)
[![doc.rs](https://docs.rs/newron/badge.svg)](https://docs.rs/newron/)
[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)

Newron is a Rust library to train deep learning models.

*Projet is currently under heavy development. No stable API yet !*

Please see the [docs](https://docs.rs/newron/) or review [examples](https://github.com/hugues31/newron/tree/master/examples) to learn more about Newron features.

## Features

Layers:
- Dense (Linear fully connected layer)
- ReLU
- TanH
- Sigmoid
- Softmax

Loss:
- Mean Square Error (MSE)
- Categorical Entropy

Optimizers:
- SGD

## Roadmap

| Feature                                                                             | Progress | Comment |
|-------------------------------------------------------------------------------------|----------|---------|
| Improve metrics (confusion matrix struct and method to compute accuracy, recall..)  |⬤◯◯◯◯    |         |
| Implement Convolutional Layer                                                       |◯◯◯◯◯     |         |
| Implement RNN Layer                                                                 |◯◯◯◯◯     |         |
| Webapp to monitor training phase                                                    |◯◯◯◯◯     |         |
| Save and load trained models/weights                                                |◯◯◯◯◯     |         |

## Contribution

Your contribution is highly appreciated. Do not hesitate to open an issue or a
pull request. Note that any contribution submitted for inclusion in the project
will be licensed according to the terms given in [LICENSE](LICENSE).

## Disclaimer
This SOFTWARE PRODUCT is provided by THE PROVIDER "as is" and "with all faults."
THE PROVIDER makes no representations or warranties of any kind concerning the
safety, suitability, lack of viruses, inaccuracies, typographical errors, or
other harmful components of this SOFTWARE PRODUCT. There are inherent dangers
in the use of any software, and you are solely responsible for determining
whether this SOFTWARE PRODUCT is compatible with your equipment and other
software installed on your equipment. You are also solely responsible for the
protection of your equipment and backup of your data, and THE PROVIDER will not
be liable for any damages you may suffer in connection with using, modifying,
or distributing this SOFTWARE PRODUCT.

gha_language: Rust


text:
# Simplist

Simplist (short for _simple list_) is a sample synchronisable to-do list app developed to showcase React Native with Expo, Redux, Firebase Authentication and Realtime Database.

>Simplist was developed as training material for NUS Orbital 2021 Mission Control 1: React Native (Part 2) conducted by Phillmont Muktar on May 22, 2021.

### Development environment pre-requisites
- A package manager (e.g., npm, Yarn, or pnpm)
- A working Firebase account
- [Expo Go](https://expo.io/tools#client) on your mobile device or simulators
- [`expo-cli`](https://expo.io/tools#cli), install with `npm install expo-cli --global` or `yarn global add expo-cli`

### Setting up
1. Clone this repository
`git clone https://github.com/purfectliterature/simplist.git`

2. Change-directory into the project root
`cd simplist`

3. Install all dependencies with your package manager
`npm install` or `yarn install`

4. Create a [Firebase](https://firebase.google.com) application
Since this app only uses Firebase Authentication and Realtime Database, [Spark plan](https://firebase.google.com/pricing) (without credit card) is sufficient.

5. Add a _web application_ on your Firebase project
You can set this application's nickname to whatever you feel like. The author used `web-ui`, for example.

6. Grab the configuration info from _Add Firebase SDK_
If you missed this page, go to _Project Overview_, scroll down to _Your apps_, and locate the web app with your set nickname. Under _SDK setup and configuration_, choose _Config_ and the configuration info is given to you in the form of `config firebaseConfig = { ... };`.

7. Create a `.env` file (yes, starting with a dot) in the root project directory

8. Populate the `.env` file with the Firebase configuration info as follows:
```sh
API_KEY=<your firebaseConfig.apiKey>
AUTH_DOMAIN=<your firebaseConfig.authDomain>
PROJECT_ID=<your firebaseConfig.projectId>
STORAGE_BUCKET=<your firebaseConfig.storageBucket>
MESSAGING_SENDER_ID=<your firebaseConfig.messagingSenderId>
APP_ID=<your firebaseConfig.appId>
MEASUREMENT_ID=<your firebaseConfig.measurementId>
```

9. In Firebase, enable **Authentication** by navigating to _Build_ > _Authentication_ > _Get started_ on your Firebase console

10. In Firebase, enable **Realtime Database** by navigating to _Build_ > _Realtime Database_ > _Get started_ on your Firebase console
You may choose to initialise the database in test mode for debugging purposes.

11. Run the app
`npm start` or `yarn start`

12. (Optional) To set up the Firebase Admin SDK in the `admin` directory, follow [these instructions to set up your Service Account](https://firebase.google.com/docs/admin/setup#initialize-sdk) and place the downloaded JSON file as `service-account.json` in `admin`

13. Create a `.env` file in `admin` and populate it as follows:
```sh
AUTH_DOMAIN=<your firebaseConfig.authDomain>
```

14. With your Terminal working directory in `admin` (invoke `cd admin` from project root if have not already), run the Firebase Admin SDK "server"
`npm start` or `yarn start`

15. The Admin SDK "server" has been set up using [nodemon](https://www.npmjs.com/package/nodemon), so simply type any Admin SDK syntax in `index.js` (example commented to create an account) and save to apply changes to your Firebase application

repository: purfectliterature/simplist

repo_name: purfectliterature/simplist


text:
Particle Effect For UGUI (UI Particle)
===

This plugin provide a component to render particle effect for uGUI in Unity 2018.2 or later.
The particle rendering is maskable and sortable, without Camera, RenderTexture or Canvas.

![](https://img.shields.io/badge/Editor-2018.2+-4796F2?logo=unity)
[![](https://img.shields.io/npm/v/com.coffee.ui-particle?label=openupm&registry_uri=https://package.openupm.com)](https://openupm.com/packages/com.coffee.ui-particle/)
[![](https://img.shields.io/github/v/release/mob-sakai/ParticleEffectForUGUI?include_prereleases&sort=semver)](https://github.com/mob-sakai/ParticleEffectForUGUI/releases)
[![](https://img.shields.io/github/v/release/mob-sakai/ParticleEffectForUGUI?include_prereleases&sort=semver&filter=3.%2A&label=release(3.x))](https://github.com/mob-sakai/ParticleEffectForUGUI/releases)
[![](https://img.shields.io/github/release-date/mob-sakai/ParticleEffectForUGUI.svg)](https://github.com/mob-sakai/ParticleEffectForUGUI/releases)  [![](https://img.shields.io/github/license/mob-sakai/ParticleEffectForUGUI.svg)](https://github.com/mob-sakai/ParticleEffectForUGUI/blob/master/LICENSE.txt)
[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-orange.svg)](http://makeapullrequest.com)

<< [Description](#Description) | [Demo](#demo) | [Installation](#installation) | [Usage](#usage) | [Development Note](#development-note) | [Change log](https://github.com/mob-sakai/ParticleEffectForUGUI/blob/upm/CHANGELOG.md) >>

## Description

![](https://user-images.githubusercontent.com/12690315/41771577-8da4b968-7650-11e8-9524-cd162c422d9d.gif)

This plugin uses new APIs `MeshBake/MashTrailBake` (added with Unity 2018.2) to render particles by CanvasRenderer.
You can mask and sort particles for uGUI without Camera, RenderTexture, Canvas.

Compares this "Baking mesh" approach with the conventional approach:
[Performance test results](https://github.com/mob-sakai/ParticleEffectForUGUI/issues/193#issuecomment-1160028374)

|Approach|Good|Bad|Screenshot|
|-|-|-|-|
|Baking mesh
**\(UIParticle\)**|Rendered as is.
Maskable.
Sortable.
Less objects.|[Not support `TEXCOORD*.zw` components for custom vertex stream](https://github.com/mob-sakai/ParticleEffectForUGUI/issues/191#issuecomment-1043409186)||
|Do nothing|Rendered as is.|**Looks like a glitch.**
Not maskable.
Not sortable.||
|Convert particle to UIVertex
[\(UIParticleSystem\)](https://forum.unity.com/threads/free-script-particle-systems-in-ui-screen-space-overlay.406862/)|Maskable.
Sortable.
Less objects.|**Adjustment is difficult.**
Requires UI shaders.
Difficult to adjust scale.
Force hierarchy scalling.
Simulation results are incorrect.
Trail, rotation of transform, time scaling are not supported.
Generate heavy GC every frame.||
|Use Canvas to sort|Rendered as is.
Sortable.|**You must to manage sorting orders.**
Not maskable.
More batches.||
|Use RenderTexture|Maskable.
Sortable.|**Requires Camera and RenderTexture.**
Difficult to adjust position and size.
Quality depends on the RenderTexture's setting.||

|Approach|FPS on Editor|FPS on iPhone6|FPS on Xperia XZ|
|--|--|--|--|
|Particle System|43|57|22|
|UIParticleSystem|4|3|0 (unmeasurable)|
|Sorting By Canvas|43|44|18|
|UIParticle|17|12|4|
|UIParticle with MeshSharing|44|45|30|

#### Features

* Easy to use: the package is out-of-the-box
* Sort particle effects and UI by sibling index
* No Camera, RenderTexture or Canvas are required
* Masking by Mask or RectMask2D
* Support Trail module
* Support CanvasGroup alpha
* No allocations
* Support overlay, camera space and world space
* Support Universal Render Pipeline (URP) and High Definition Render Pipeline (HDRP)
* Support disabling `Enter Play Mode Options > Reload Domain`
* Support changing material property with AnimationClip (AnimatableProperty)
![](https://user-images.githubusercontent.com/12690315/53286323-2d94a980-37b0-11e9-8afb-c4a207805ff2.gif)
* [4.0.0+] Support 8+ materials
* [4.0.0+] Correct world space particle position when changing window size for standalone platforms (Windows, MacOSX and Linux)
* [4.0.0+] Adaptive scaling for UI
* [4.0.0+] Mesh sharing group to improve performance
![](https://user-images.githubusercontent.com/12690315/174311048-c882df81-6c34-4eba-b0aa-5645457692f1.gif)
* [4.0.0+] Particle attractor component
![](https://user-images.githubusercontent.com/12690315/174311027-462929a4-13f0-4ec4-86ea-9c832f2eecf1.gif)
* [4.1.0+] Relative/Absolute particle position mode
![](https://user-images.githubusercontent.com/12690315/175751579-5a2357e8-2ecf-4afd-83c8-66e9771bde39.gif)

## Demo

* [WebGL Demo](https://mob-sakai.github.io/demos/UIParticle_Demo/index.html)
> ![](https://user-images.githubusercontent.com/12690315/174311768-1843a5f2-f776-491b-aaa8-2a131a8b6a16.gif)
* [WebGL Demo (Cartoon FX & War FX)](https://mob-sakai.github.io/Demos/ParticleEffectForUGUI_CFX)
  * [Cartoon FX Free][CFX] & [War FX][WFX] (by [Jean Moreno (JMO)][JMO]) with UIParticle
> ![](https://user-images.githubusercontent.com/12690315/91664766-3e07ac00-eb2c-11ea-978b-ef723be80619.gif)

[CFX]: https://assetstore.unity.com/packages/vfx/particles/cartoon-fx-free-109565
[WFX]: https://assetstore.unity.com/packages/vfx/particles/war-fx-5669
[JMO]: https://assetstore.unity.com/publishers/1669

## Installation

### Requirement

Unity 2018.2 or later

### Install via OpenUPM

This package is available on [OpenUPM](https://openupm.com).
It's recommended to install it via [openupm-cli](https://github.com/openupm/openupm-cli).
```
openupm add com.coffee.ui-particle
```

### Install via Package Manager Window (using Git URL)

1. Select `Window/Package Manager` menu to open `Package Manager` window.
2. Click `+` and `Install package from git URL...`
![](https://github.com/mob-sakai/ParticleEffectForUGUI/assets/12690315/57317aa4-e55c-4568-b2aa-2ee2a78ddc02)
3. Input `https://github.com/mob-sakai/ParticleEffectForUGUI.git` and click `Install`
![](https://github.com/mob-sakai/ParticleEffectForUGUI/assets/12690315/72cc38b5-cb32-4c85-8209-c85f7bb931ea)

Or, use [UpmGitExtension](https://github.com/mob-sakai/UpmGitExtension) to install and update the package.

### Install via manifest.json (using Git URL)

1. Open `Packages/manifest.json` in your project.
2. Add this line below `"dependencies": {`
  * `"com.coffee.ui-particle": "https://github.com/mob-sakai/ParticleEffectForUGUI.git",`
  ![](https://github.com/mob-sakai/ParticleEffectForUGUI/assets/12690315/fe1cad9c-8d09-4e17-b6f5-9eac0d267921)
3. To update the package, change suffix `#{version}`.
  * `"com.coffee.ui-particle": "https://github.com/mob-sakai/ParticleEffectForUGUI.git#4.2.0",`

### Install as an embed package

1. Download a source code zip file from [Releases](https://github.com/mob-sakai/ParticleEffectForUGUI/releases) page
2. Extract it and place it under `Packages` directory in your project.
![](https://github.com/mob-sakai/ParticleEffectForUGUI/assets/12690315/4c3d3439-5bb0-4e87-a917-ebe328ef89a8)

## How to play demo

### For Unity 2019.1 or later

1. Open `Package Manager` window
2. Select `UI Particle` package in package list
3. Click `Import Sample` button
![demo](https://user-images.githubusercontent.com/12690315/95017806-83bd1480-0696-11eb-8c24-c56f45ab1ac2.png)
4. The demo project is imported into `Assets/Samples/UI Particle/{version}/Demo`
5. Open `UIParticle_Demo` scene and play it

### For Unity 2018.4 or earlier

1. Select `Assets/Samples/UI Particle Demo` from menu
2. The demo project is imported into `Assets/Samples/UI Particle/{version}/Demo`
3. Open `UIParticle_Demo` scene and play it

### About `Cartoon FX & War Fx Demo`

* It requires free assets ([Cartoon FX Free][CFX] & [War FX][WFX])
  * by [Jean Moreno (JMO)][JMO]

## Usage

### UIParticle component

`UIParticle` controls the ParticleSystems that is attached to its own game objects and child game objects.

![](https://github.com/mob-sakai/ParticleEffectForUGUI/assets/12690315/3559df45-63e7-4c4c-9233-f455779efa29)

| Properties | Description |
| -- | -- |
| Maskable | Does this graphic allow masking. |
| Scale | Scale the rendering.
When the `3D` toggle is enabled, 3D scale (x,y,z) is supported. |
| Animatable Properties | If you want update material properties (e.g. `_MainTex_ST`, `_Color`) in AnimationClip, use this to mark the changes. |
| Mesh Sharing | Particle simulation results are shared within the same group.
A large number of the same effects can be displayed with a small load.
When the `Random` toggle is enabled, it will be grouped randomaly. |
| Position Mode | **Absolute:** Emit from the world position of the `ParticleSystem`.
**Relative:** Emit from the scaled position of the `ParticleSystem`. |
| Auto Scaling | Transform.lossyScale (=world scale) will be set to `(1, 1, 1)` on update.
It prevents the root-Canvas scale from affecting the hierarchy-scaled `ParticleSystem`. |
| Rendering Order | The ParticleSystem list to be rendered.
You can change the order and the materials. |

NOTE: Press `Refresh` button to reconstruct rendering order based on children ParticleSystem's sorting order and z position.

### Basically usage

1. Select `Game Object/UI/ParticleSystem` to create UIParticle with a ParticleSystem.
![particle](https://user-images.githubusercontent.com/12690315/95007361-cad0e880-0649-11eb-8835-f145d62c5977.png)
2. Adjust the ParticleSystem as you like.
![particle1](https://user-images.githubusercontent.com/12690315/95007359-ca385200-0649-11eb-8383-627c9750bda8.png)

### With your existing ParticleSystem prefab

1. Select `Game Object/UI/ParticleSystem (Empty)` to create UIParticle.
![empty](https://user-images.githubusercontent.com/12690315/95007362-cb697f00-0649-11eb-8a09-29b0a13791e4.png)
2. Drag & drop your ParticleSystem prefab on UIParticle.
![particle3](https://user-images.githubusercontent.com/12690315/95007356-c6a4cb00-0649-11eb-9316-562f4bce3f31.png)

### With `Mask` or `RectMask2D` component

If you want to mask particles, set a stencil supported shader (such as `UI/UIAdditive`) to material for ParticleSystem.
If you use some custom shaders, see [How to make a custom shader to support Mask/RectMask2D component](#how-to-make-a-custom-shader-to-support-maskrectmask2d-component) section.

![](https://user-images.githubusercontent.com/12690315/95017591-3b512700-0695-11eb-864e-04166ea1809a.png)

### Script usage

```cs
// Instant ParticleSystem prefab with UIParticle on runtime.
var go = GameObject.Instantiate(prefab);
var uiParticle = go.AddComponent<UIParticle>();

// Control by ParticleSystem.
particleSystem.Play();
particleSystem.Emit(10);

// Control by UIParticle.
uiParticle.Play();
uiParticle.Stop();
```

### UIParticleAttractor component

`UIParticleAttractor` attracts particles generated by the specified ParticleSystem.

![](https://github.com/mob-sakai/ParticleEffectForUGUI/assets/12690315/ea6ae0ed-f9a8-437c-8baa-47526303391e)
![](https://user-images.githubusercontent.com/12690315/174311027-462929a4-13f0-4ec4-86ea-9c832f2eecf1.gif)

| Properties | Description |
| -- | -- |
| Particle System | Attracts particles generated by the specified particle system. |
| Distination Radius | Once the particle is within the radius, the particle lifetime will become 0 and `OnAttracted` will be called. |
| Delay Rate | Delay to start attracting.
It is a percentage of the particle's start lifetime. |
| Max Speed | Maximum speed of attracting.
 If this value is too small, attracting may not be completed by the end of the lifetime and `OnAttracted` may not be called. |
| Movement | Attracting movement type. (Linear, Smooth, Sphere) |
| Update Mode | **Normal:** Update with scaled delta time.
**Unscaled Time:** Update with unscaled delta time. |
| OnAttracted | An event called when attracting is complete (per particle). |

## Development Note

### FAQ: Why are my particle effects not displayed correctly?

If `ParticleSystem` alone displays particles correctly but `UIParticle` does not, please check the following points:

* [Shader Limitation](https://github.com/mob-sakai/ParticleEffectForUGUI#shader-limitation)
  * Most cases can be solved by using `UI/Additive` or `UI/Default`.
* Particles are masked
  * `UIParticle` is maskable.
  * Set `Mask` or `RectMask2D` component properly.

  * Increase the `Scale` value.
  * If you don't want to change the apparent size depending on the resolution, try `Auto Scaling` option.
* Particles are too many
  * No more than 65535 vertices can be displayed (for mesh combination limitations).
  * Please set `Emission` module and `Max Particles` of ParticleSystem properly.
* Particles are emitted off-screen.
  * When `Position Mode = Relative`, particles are emitted from scaled position of the ParticleSystem, not from the screen point of the ParticleSystem.
  * Place the ParticleSystem in the proper position or try `Position Mode = Absolute`.
* Attaching `UIParticle` to the same object as `ParticleSystem`
  * `Transform.localScale` will be overridden by `Auto Scaling` option.
  * It is recommended to place `ParticleSystem` under `UIParticle`.

### Shader Limitation

The use of UI shaders is recommended.

- If you need a simple Additive shader, use the `UI/Additive` shader instead.
- If you need a simple alpha-blend shader, use the `UI/Default` shader instead.
- If your custom shader does not work properly with UIParticle, consider creating a custom UI shader.

#### Built-in shaders are not supported

UIParticle does not support all built-in shaders except for `UI/Default`.
If their use is detected, an error is displayed in the inspector.
Use UI shaders instead.

#### UV.zw components will be discarded

UIParticleRenderer renders the particles based on UIVertex.
Therefore, only xy components is available for each UV in the shader. (zw components will be discarded).
So unfortunately UIParticles will not work well with some shaders.

#### Custom vertex streams

When using custom vertex streams, you can fill zw components with "unnecessary" data.
https://github.com/mob-sakai/ParticleEffectForUGUI/issues/191

### Overheads

UIParticle has some overheads and the batching depends on uGUI.
When improving performance, keep the following in mind:
- If you are displaying a large number of the same effect, consider `Mesh Sharing` feature in [UIParticle Component](#uiparticle-component).
  - If you don't like the uniform output, consider `Random Group` feature.
![](https://user-images.githubusercontent.com/12690315/174311048-c882df81-6c34-4eba-b0aa-5645457692f1.gif)
- If you are using multiple materials, you will have more draw calls.
  - Consider single material, atlasing the sprites, and using `Sprite` mode in the `Texture Sheet Animation` module in ParticleSystem.

### How to make a custom shader to support Mask/RectMask2D component

Shader tips

```ShaderLab
Shader "Your/Custom/Shader"
{
    Properties
    {
        // ...
        // #### required for Mask ####
        _StencilComp ("Stencil Comparison", Float) = 8
        _Stencil ("Stencil ID", Float) = 0
        _StencilOp ("Stencil Operation", Float) = 0
        _StencilWriteMask ("Stencil Write Mask", Float) = 255
        _StencilReadMask ("Stencil Read Mask", Float) = 255
        _ColorMask ("Color Mask", Float) = 15
        [Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip ("Use Alpha Clip", Float) = 0
    }

    SubShader
    {
        Tags
        {
            // ...
        }

        // #### required for Mask ####
        Stencil
        {
            Ref [_Stencil]
            Comp [_StencilComp]
            Pass [_StencilOp]
            ReadMask [_StencilReadMask]
            WriteMask [_StencilWriteMask]
        }
        ColorMask [_ColorMask]
        // ...

        Pass
        {
            // ...
            // #### required for RectMask2D ####
            #include "UnityUI.cginc"
            #pragma multi_compile __ UNITY_UI_CLIP_RECT
            float4 _ClipRect;

            // #### required for Mask ####
            #pragma multi_compile __ UNITY_UI_ALPHACLIP

            struct appdata_t
            {
                // ...
            };

            struct v2f
            {
                // ...
                // #### required for RectMask2D ####
                float4 worldPosition    : TEXCOORD1;
            };

            v2f vert(appdata_t v)
            {
                v2f OUT;
                // ...
                // #### required for RectMask2D ####
                OUT.worldPosition = v.vertex;
                return OUT;
            }

            fixed4 frag(v2f IN) : SV_Target
            {
                // ...
                // #### required for RectMask2D ####
                #ifdef UNITY_UI_CLIP_RECT
                    color.a *= UnityGet2DClipping(IN.worldPosition.xy, _ClipRect);
                #endif

                // #### required for Mask ####
                #ifdef UNITY_UI_ALPHACLIP
                    clip (color.a - 0.001);
                #endif

                return color;
            }
            ENDCG
        }
    }
}
```

## Contributing

### Issues

Issues are very valuable to this project.

- Ideas are a valuable source of contributions others can make
- Problems show where this project is lacking
- With a question you show where contributors can improve the user experience

### Pull Requests

Pull requests are, a great way to get your ideas into this repository.
See [CONTRIBUTING.md](/../../blob/develop/CONTRIBUTING.md).

### Support

This is an open source project that I am developing in my spare time.
If you like it, please support me.
With your support, I can spend more time on development. :)

[![](https://user-images.githubusercontent.com/12690315/50731629-3b18b480-11ad-11e9-8fad-4b13f27969c1.png)](https://www.patreon.com/join/mob_sakai?)
[![](https://user-images.githubusercontent.com/12690315/66942881-03686280-f085-11e9-9586-fc0b6011029f.png)](https://github.com/users/mob-sakai/sponsorship)

## License

* MIT

## Author

* ![](https://user-images.githubusercontent.com/12690315/96986908-434a0b80-155d-11eb-8275-85138ab90afa.png) [mob-sakai](https://github.com/mob-sakai) [![](https://img.shields.io/twitter/follow/mob_sakai.svg?label=Follow&style=social)](https://twitter.com/intent/follow?screen_name=mob_sakai) ![GitHub followers](https://img.shields.io/github/followers/mob-sakai?style=social)

## See Also

* GitHub page : https://github.com/mob-sakai/ParticleEffectForUGUI
* Releases : https://github.com/mob-sakai/ParticleEffectForUGUI/releases
* Issue tracker : https://github.com/mob-sakai/ParticleEffectForUGUI/issues
* Change log : https://github.com/mob-sakai/ParticleEffectForUGUI/blob/upm/CHANGELOG.md

repository: mob-sakai/ParticleEffectForUGUI

gha_language: C#

repo_name: mob-sakai/ParticleEffectForUGUI


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

### Description

The Skyoftech So Listing Tabs module 2.2.0 for OpenCart allows a remote attacker to inject a serialized PHP object via the setting parameter, potentially resulting in the ability to write to files on the server, cause DoS, and achieve remote code execution because of deserialization of untrusted data.

### POC

#### Reference
- http://packetstormsecurity.com/files/167197/OpenCart-So-Listing-Tabs-2.2.0-Unsafe-Deserialization.html

#### Github
No PoCs found on GitHub currently.

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
# Tourist guide on demand for travel tips

Videocalls to answer about travel questions, made by locals. If I want to go and visit Italy I can pay a time token (i.e. 19$ for 1 hour) and chat with an italian asking questions about Milan, Rome, daily habits, etc...

### PROs

* MVP can start on Google Hangout with low tech involved
* You can connect with locals before your trip
* Makes people earn money thanks to their knowledge
* Can be used for more than travel tips: language lessons, etc...
* Can work live, but also "offline": I ask for a question and I receive a video answer later

### CONs

* Verification of locals identity and knowledge
* Good insurance is needed. What if a tourist is tricked by a local to make something dangerous or at worse into a robbery?
* Hard to scale
* Once not an MVP anymore you need some tech for video conferencing
* A money back guarantee should be offered

### Notice

Check https://github.com/napolux/1000ideas for license and FAQ


text:
---
date: "2019-04-28"
title: "Fashion week"
slug: fashion-week2
permalink: "https://www.jakpost.travel/wimages/large/208-2089295_fashion-wallpapers-girl-with-big-hat.jpg"
---

Fashion week

## Always the best!
Nynne Kunde, the talented winner of I’M ALUMNI COLLECTIONS ® EVOLUTION, made her debut on the catwalks of Milan fashion week showcasing her collection ‘Ducens Domina’.

After receiving her degree in Fashion Design from Istituto Marangoni London in 2018, Nynne was named ‘Womenswear Designer of the Year’ and, with the launch of her own label NYNNE, a contemporary luxury brand focused on craftsmanship and exaggerated silhouettes, is beginning her journey of professional growth.

The fashion show, held at Palazzo Serbelloni, gave the young Danish designer the chance to present to the public her refined technical skills and stylistic signature, expressed through the idea of a woman who has a strong personality, is pragmatic and the star of the show. “Ducens Domina” is in fact a collection that is striking for the originality of the silhouettes and the pairing of the fabrics, characterized by a glamorous 1940s style accentuated by voluminous shapes crafted in silk, wool, cotton and leather, and by a palette of pastel colours that go from lavender to yellow all the way to warm cognac.

Designer: Nynne Kunde

Designer: Donna Karan

What to dress on fashion week?

 An important debut that saw the young designer hosted on the catwalk of Ermanno Scervino, one of Istituto Marangoni Brand Ambassadors who has always supported new generations of designers both as a mentor and a promoter of visibility for promising fashion talents.

“For me, it is a real pleasure to be able to give concrete assistance to young creative people. Organizing a fashion show is a fundamental component of the promotion and visibility of collections: hosting Nynne at Palazzo Serbelloni, I am proud to contribute to supporting her and most of all to share my knowledge and experience with her. I will watch her fashion show with great interest, because engaging with the aesthetics of new talents is always stimulating,” said Ermanno Scervino.


text:
[![DOI](https://zenodo.org/badge/352306496.svg)](https://zenodo.org/badge/latestdoi/352306496)

## About

This repo contains functions for computing Bayes factors.

Currently, the following distributions are supported for likelihoods:

- *d* scaled non-central *t*
- *t* scaled non-central *t*
- normal distribution
- binomial distribution
- scaled and shifted t distribution

The following distributions are supported for priors:

- Cauchy distribution (with arbitrary location parameter)
- normal distribution
- beta distribution
- uniform
- scaled and shifted t-distribution
- point

repository: ljcolling/go-bayesfactor

repo_name: ljcolling/go-bayesfactor


text:
# Contributing

## Dev Statuses
[![CircleCI](https://circleci.com/gh/sergiitk/pagerbeauty/tree/master.svg?style=shield)](https://circleci.com/gh/sergiitk/pagerbeauty/tree/master) [![dependencies Status](https://david-dm.org/sergiitk/pagerbeauty/status.svg)](https://david-dm.org/sergiitk/pagerbeauty) [![devDependencies Status](https://david-dm.org/sergiitk/pagerbeauty/dev-status.svg)](https://david-dm.org/sergiitk/pagerbeauty?type=dev)

### Docker images
[![](https://images.microbadger.com/badges/version/sergiitk/pagerbeauty:dev.svg)](https://microbadger.com/images/sergiitk/pagerbeauty:dev) [![](https://images.microbadger.com/badges/image/sergiitk/pagerbeauty:dev.svg)](https://microbadger.com/images/sergiitk/pagerbeauty:dev)
[![](https://images.microbadger.com/badges/version/sergiitk/pagerbeauty.svg)](https://microbadger.com/images/sergiitk/pagerbeauty) [![](https://images.microbadger.com/badges/image/sergiitk/pagerbeauty.svg)](https://microbadger.com/images/sergiitk/pagerbeauty)

## Rules

The source code of [Pager Beauty](https://github.com/sergiitk/pagerbeauty) is maintained by [@sergiitk](https://github.com/sergiitk).
It's an Open Source project under MIT License. Contributions are welcomed. Follow the usual GitHub Pull Request process.

[Be nice.](CODE_OF_CONDUCT.md)

## Running local services

### Requisites
- Install [Docker](https://docs.docker.com/install/)

### Running local services

1. Clone the repository
2. Build an run local Docker container

```sh
docker-compose up
```

3. Open [localhost:8080](http://localhost:8080)

PagerBeauty for local development is preconfigured, no `.env` file is necessary.
It's using [Mockserver](https://github.com/namshi/mockserver) in place of real PagerDuty API v2: [localhost:8090](http://localhost:8090).

Application HTTP server and webpack are running in `watch` mode.
All changes you make should be picked up automatically on the next page refresh: [localhost:8080](http://localhost:8080).

Additional version of PagerBeauty with HTTP authentication enabled is available at [localhost:8081](http://localhost:8081). Default credentials:

```sh
PAGERBEAUTY_HTTP_USER=basic_username
PAGERBEAUTY_HTTP_PASSWORD=basic_password
PAGERBEAUTY_HTTP_ACCESS_TOKEN=803651A9-E3B7-4153-9566-6E54F5F0CEAB
```

#### Grafana
There's a test Grafana with pre-provisioned PagerBeauty board available
at <http://localhost:3000/d/RUn-WZumz/pagerbeauty>. Feel free to use for testing.
Login and pasword are `admin`.

### Additional configuration

Use `.env` to override the [default settings](https://github.com/sergiitk/pagerbeauty#configuration),
for example:

**Verbose logging**

```sh
PAGERBEAUTY_LOG_LEVEL=verbose
```

**Custom HTTP ports**

In case you have another service running on port 8080, the following option
will start PagerBeauty on custom port and bind it to the same port on the host.

```sh
# Start PagerBeauty on port 8181 in Docker and bind it to port 8181 on the host:
# http://localhost:8181/
PAGERBEAUTY_HTTP_PORT=8181
```

In the same manner, you can choose custom port for `pagerbeauty-dev-with-auth` service:

```sh
# Start PagerBeauty with enabled HTTP authentication on port 8182
# in Docker and bind it to port 8181 on the host:
# http://localhost:8182/
PAGERBEAUTY_WITH_AUTH_HTTP_PORT=8182
```

To change PagerDuty Mock API port, you need to update the following
```sh
# Use custom port for PagerDuty Mock API:
PAGERBEAUTY_PD_API_MOCK_PORT=9090
# Instruct PagerBeauty use different PagerDuty API:
PAGERBEAUTY_PD_API_URL=http://mock-pagerduty-api:9090
```

You can configure grafana local port with:
```sh
PAGERBEAUTY_GRAFANA_PORT=3001
```

**Using real PagerDuty API**

```sh
# Use real API
PAGERBEAUTY_PD_API_URL=https://api.pagerduty.com
PAGERBEAUTY_PD_API_KEY=real_key
```

Note, using real PagerDuty API will break local acceptance tests. It shouldn't be a problem for a routine development.

### Other

#### Installing new packages

```sh
docker-compose run --rm yarn add --dev your_package
```

#### Running linter
We mostly adhere to [Airbnb JavaScript Style](https://github.com/airbnb/javascript), with [minor exceptions](https://github.com/sergiitk/pagerbeauty/blob/master/.eslintrc.js).

```sh
docker-compose run --rm yarn lint
```

#### Running tests
```sh
docker-compose run --rm yarn test:full
```

#### Running acceptance tests
```sh
docker-compose run --rm yarn test:acceptance
```

### Questions?
Ask me on Twitter: [@sergiitk](https://twitter.com/sergiitk)

repository: sergiitk/pagerbeauty

repo_name: sergiitk/pagerbeauty


text:
Pattern: Use of native global constant

Issue: -

## Description

Detects use of new PHP native global constants.

PHP version All.

## Further Reading

* [PHP_CodeSniffer - PHPCompatibility.Constants.NewConstants](https://github.com/PHPCompatibility/PHPCompatibility/tree/develop/PHPCompatibility/Sniffs/Constants/NewConstantsSniff.php)

repository: Adroiti/docs-for-code-review-tools

repo_name: Adroiti/docs-for-code-review-tools


text:
---
date: 2009-08-07 09:38:50
title: product minimalism
layout: post
comments: true
categories: software
---
Garry Tan, a developer for [Posterous](http://posterous.com/) (a simple
but powerful blog platform), wrote a brilliant
[post](http://garry.posterous.com/practicing-product-minimalism) about
product design.

> Are there any questions? I said yes -- one last one: "When do we
> decide to remove features?"

In a similar vein, Amit Agarwal asks 'What's Common Between an iPod and
Google ?' Answer:
[Simplicity](http://www.labnol.org/internet/marvel-of-simplicity/9357/).

repository: andycowl/octopress

repo_name: andycowl/octopress


text:
#[Kuali-UI](https://kualico.github.io/kuali-ui/)
[npm package](https://www.npmjs.com/package/kuali-ui)

Kuali-UI is a customized version of Material-UI, which is a set of [React](http://facebook.github.io/react/) components that implement
[Google's Material Design](https://www.google.com/design/spec/material-design/introduction.html)
specification.

Check out our [documentation site](https://kualico.github.io/kuali-ui/) for live examples.
It's still a work in progress, but hopefully you can see where we're headed.

## Installation

Kuali-UI is available as an [npm package](https://www.npmjs.com/package/kuali-ui).

**Stable channel**
```sh
npm install kuali-ui
```

### React-Tap-Event-Plugin

Some components use
[react-tap-event-plugin](https://github.com/zilverline/react-tap-event-plugin) to
listen for touch events because onClick is not fast enough
_This dependency is temporary and will eventually go away._ Until then,
be sure to inject this plugin at the start of your app.

```js
import injectTapEventPlugin from 'react-tap-event-plugin';

// Needed for onTouchTap
// http://stackoverflow.com/a/34015469/988941
injectTapEventPlugin();
```

## Usage

Kuali-UI components require a theme to be provided. The quickest way to get up and running is by using the `MuiThemeProvider` to inject the theme into your application context. Following that, you can to use any of the components as demonstrated in the documentation.

Here is a quick example to get you started:

**./App.js**
```jsx
import React from 'react';
import ReactDOM from 'react-dom';
import MuiThemeProvider from 'kuali-ui/styles/MuiThemeProvider';
import MyAwesomeReactComponent from './MyAwesomeReactComponent';

const App = () => (
  <MuiThemeProvider>
    <MyAwesomeReactComponent />
  </MuiThemeProvider>
);

ReactDOM.render(
  <App />,
  document.getElementById('app')
);
```

**./MyAwesomeReactComponent.js**
```jsx
import React from 'react';
import RaisedButton from 'kuali-ui/RaisedButton';

const MyAwesomeReactComponent = () => (
  <RaisedButton label="Default" />
);

export default MyAwesomeReactComponent;
```

Please refer to each component's documentation page to see how they should be imported.

## License
This project is licensed under the terms of the
[MIT license](https://github.com/KualiCo/kuali-ui/blob/master/LICENSE)

repository: KualiCo/kuali-ui-mui

repo_name: KualiCo/kuali-ui-mui


text:
# TREE-WALKING

The **expert system** represents the knowledge it learns from a user as a simple **binary tree**. It furthermore persists this growing knowledge on the Dragonchain, where it MAY be further verified (trainer's reputation, resolving one or more users who have trained the same question, _et al_) as a **map** of key-value pairs (_k_, _v_).

## Why a map?

A **map** (associative array, dictionary) was chosen as the best way to represent what will most likely be a sparse **binary tree**, particularly at greater depths. Some branches may represent detailed knowledge while other branches remain more general, or terminate in a satisfactory answer to the user's problem after fewer rounds of questioning.

![Binary tree 4-levels deep showing the index k uniquely identifying each node in a map representation](https://github.com/derekharmon/flutter_expert_system/raw/master/docs/figures/BinaryTree.png)

### Keys

The keys are represented by an integer, _k_, and the leading 1-bit of this integer always indicates our depth in the **binary tree** (_i.e._, what round of questioning the app is on). Any user run through in the **expert system** can be seen as progressing through a sequence of keys, _k_: _k_ 1, _k_ 2, ... _k_ i, _k_ i+1, ... _k_ n.

### Values

The values are represented by text strings. If the value comes from a non-leaf node in the **binary tree**, then it is a Question. A value coming from a leaf node terminates the user's tree-walk with the Answer (or at least a Guess).

## Traversing to the Next Node

### Next Node Function

The next node function, _f_, takes two arguments _k_ i and a Boolean value, _b_, equivalent to the integers: 1 or 0. This _b_ comes from the user's response of _Yes_ or _No_ to the Question _v_ i at _k_ i.

Simply stated, _k_ i+1 = _f_(_k_ i, _b_) = 2 _k_ i + _b_.

If this seems surprising, then you can try it out using the figure of key indices shown above.

### IDK

If the Answer resulting from a tree-walk doesn't satisfy the user's problem, then a Question MUST exist which differentiates the incorrect Guess from the correct Answer. In training, the user provides the **expert system** with these distinguishing Questions, and that is the process by which it learns.

In the "I Don't Know" state, the learning happens by obtaining a new Question which replaces _v_ i at _k_ i. The user indicates whether a _Yes_ or _No_ answer leads to the correct Answer, so there are two cases for what happens to the incorrect Guess and correct Answer:

1. If user indicates _No_ is correct for the new Answer: _v_ i+1 becomes the new Answer, and _v_i+1 + 1 becomes the old Guess.
2. If user indicates _Yes_ is correct for the new Answer: _v_ i+1 becomes the old Guess, and _v_i+1 + 1 becomes the new Answer.


text:
Track URL shares
================

This is source code for simple webapp that tracks how many times given URL was shared on social media. It returns
information from: Facebook, Twitter, Google+, LinkedIn, Pinterest and StumbleUpon.

**Try it on: [shares.webit.pl](http://shares.webit.pl)**

## Requirements
As it uses PHP as backend (api endpoint) you need to be running **PHP 5.4+**. Backend build on top of [Silex](http://silex.sensiolabs.org/).
Additionally it stores data in **MySQL** database, so you will need one.

### Installation

* PHP dependencies are managed by [Composer](https://getcomposer.org/). To install everything required run following command in main application directory: ```composer install```. If you didn't use Composer before - check how to [install](https://getcomposer.org/download/) it.

 **IMPORTANT** you must run composer in Linux/Unix shell as it created some directories using `mkdir` command.

 It will install Silex micro framework, Doctrine DBAL, Monolog and Symphony Yaml and [shares-counter-php](https://github.com/dominikbulaj/shares-counter-php) library that's responsible for checking social media APIs.

* Frontend dependencies are manages by [Bower](http://bower.io/). Installing dependencies is as easy as running ```bower install``` assuming you already have installed Bower. If not - check how to [install Bower](http://bower.io/#install-bower).

  It will install: AngularJS with additional modules, Bootstrap and jQuery. Because on inconsistency Bower package vs GitHub repository - [Material Design for Bootstrap](http://fezvrasta.github.io/bootstrap-material-design/) is bundled with application assets.

* Finally you need to create MySQL tables. Assuming you have running MySQL server and already created new database, easiest way to create tabels is to run: ```mysql -h{host} -u{username} -p {database name} < database.sql```. Check MySQL [command line tool](http://dev.mysql.com/doc/refman/5.6/en/mysql.html) for additional parameters and how-to.

### Configuration
There's one configuration file. It stores database access information (for now) and is located in ```/app/config.yml```
Just fill in informations about: host, database name, username and password.

By default after Composer during installation will create two directories in `api/`:

1. `api/cache/` for storing Silex cache
2. `api/log/` log directory where are logged request & response information as well application issues

**SECURITY NOTE** both directories have default access permissions set to 777 (full access). Please change it allowing write from web-server user only (apache, www-data, etc.)

### Todo
Unit testing

### License
Copyright (c) 2014 [Dominik Bułaj](http://www.webit.pl). See the LICENSE file for license rights and limitations (MIT)

repository: dominikbulaj/shares-webapp

repo_name: dominikbulaj/shares-webapp


text:
# GitList Vagrant Setup

#### Provisions a vagrant VM to build and test GitList.

## Software

- [Precise32](http://files.vagrantup.com/precise32.box)
- ant
    - java
    - ark
- apt
- apache2
    - apache2::mod_php5
    - apache2::mod_deflate
    - apache2::mod_rewrite
- php
- git
- composer
- PHP_Depend
- PHPUnit
- PHPLOC
- PHP Copy/Paste Detector
- PHP_Mess Detector

## Setup
Requires vagrant to be installed and uses the box name precise32. If you have another base box to use you can change that in the Vagrantfile.

Clone this repository and run Vagrant to build GitList
    `git clone git://github.com/khornberg/vagrant-gitlist.git`
    `vagrant up`

## Build
The recipe will clone the latest master from klaussilveria, build it, and set up gitlist.
You can access the built Gitlist at `http://localhost:8080`.
You will be looking at the latest clone of GitList from which you build GitList.

## Local Build
You can build from your clone of Gitlist by un/commenting out a section in the [cookbooks/vagrant_main/recipes/default.rb](/blob/master/cookbooks/vagrant_main/recipes/default.rb)

repository: khornberg/vagrant-gitlist

gha_language: Ruby

repo_name: khornberg/vagrant-gitlist


text:
# Fable.DateFunctions [![Build Status](https://travis-ci.org/Zaid-Ajaj/Fable.DateFunctions.svg?branch=master)](https://travis-ci.org/Zaid-Ajaj/Fable.DateFunctions) [![Build status](https://ci.appveyor.com/api/projects/status/od92jraqhec4vbj5?svg=true)](https://ci.appveyor.com/project/Zaid-Ajaj/fable-datefunctions) [![Nuget](https://img.shields.io/nuget/v/Fable.DateFunctions.svg?maxAge=0&colorB=brightgreen)](https://www.nuget.org/packages/Fable.DateFunctions)

Fable binding for the popular [date-fns](https://date-fns.org/), a library for date manipulation. This binding implements the imports as 120+ extension methods for `DateTime` and `DateTimeOffset` instances. 32 Languages are supported for formatting dates, see [live docs](https://zaid-ajaj.github.io/Fable.DateFunctions/).

## Installation Using Femto
Using [Femto](https://github.com/Zaid-Ajaj/Femto) you can install the library and its npm dependency in one go:
```
femto install Fable.DateFunctions
```

## Installation
Install the binding from Nuget
```
paket add Fable.DateFunctions --project path/to/Proj.fsproj
```
Install the actual Javascript library `date-fns` from npm
```
npm install<EMAIL_ADDRESS>```
Now from your F# code
```fs
open Fable.DateFunctions

let now = DateTime.Now
now.SubtractDays(1).IsInThePast() // true
```

## Todo (PRs are welcome)
 - ISO Week-Numbering Year Helpers
 - More docs
 - Better tree-shaking (lazy imports, i.e. only import what you use)

## Build and running the app

1. Start Fable server and Webpack dev server: `./build.sh Watch`
2. In your browser, open: http://localhost:8080/

Any modification you do to the F# code will be reflected in the web page after
saving.

gha_language: F#


text:
## Restaurant Analyzer and Recommender
### By Anshul Sharma, Archit Goyal & Avaiyang Garg

Project Proposal Link: https://github.com/NYU-VIS-FALL2018/storytelling-group-5-offline/blob/master/Project%20Proposal/IV%20Project%20Proposal.pdf

Demo Link: https://nyu-vis-fall2018.github.io/storytelling-group-5-offline/

Demo Video Link: https://drive.google.com/file/d/182rBHppIN1On16LHG9tIRIuzMUf_Jw46/view

## Project goal
Our project goal is to analyze Yelp data and visualize the data using map views and other graphs to answer various questions to determine the best restaurant in the proximity with a type of cuisine which the user wants to eat. Users can locate their location and choose the type of cuisine they want and filter them based on their ratings. This will help them eat their favorite cuisine in the proximity at a place which has good ratings and reviews in the comments. We have tried to make this an interactive webpage for the user so that they can add filters and choose a place to eat with best of their needs.

## Main objectives:

Build interactive application to answer questions about restaurants in NYC
Show which cuisines are most common on different boroughs.
Show how cuisine preferences change according to borough in NYC.
Show where restaurants cluster more in NYC.
Show most high rated restaurants in five boroughs and within boroughs too.

## Data Set

URL for the DataSet: https://www.yelp.com/dataset/challenge

Dataset files used:

Business.json

Review.json

Checkin.json

User.json

Attributes used from the data set are :

Business.json - business_id, name, city, address, postal code, longitude, latitude, stars, review_count, category, outDoorSitting

Review.json - review_id, business_id, stars

Checkin.json - business_id, time.

User.json - user_id, user_count, reviews.

## Analytical Questions and Proxy Tasks

1. Where are the restaurants clustered in New York City Area?
Proxy Tasks:
How is area divided in New York City? Area in New york city can be divided among the boroughs or the zip codes.
Proxy Values:
Lattitude, Longitude and city: From these three we can find the borough they belong to and where on map we can plot and identify them.

2. Which Borough in New York City has top average rated restaurants?
Proxy Tasks:
What is the significance of “top”? Listing the restaurant with the most number of 5 stars because there may be restaurants with a single user review but a 5-star rating.
Proxy Values:
We will be using the Review.json file, in this, we will be using stars, and in the business.json file, we will use stars and review_count.

3. Which cuisine is most common in different boroughs of New York City?
Proxy Tasks:
Based on the current location, there may be many different types of cuisines which the person can have as options to eat. They can select the nearest one and eat there.
Proxy Values:
business.json file provide us with the categories which will help us to determine the different cuisines and then the latitude, longitude, and postal code will provide the location of the restaurant.

4. Which are the top rated restaurants in different boroughs of New York City?
Proxy Tasks:
What is the significance of “top”? Listing the restaurant with the most number of 5 stars because there may be restaurants with a single user review but a 5-star rating.
Proxy Values:
We will be using the Review.json file, in this, we will be using stars, and in the business.json file, we will use stars and review_count.

5. How cuisine preference change from overall New York to different boroughs?
Proxy Task:
What does change mean here? Change means how the count of restaurants of different cuisines change from whole new york city to individual boroughs.
Proxy Value: Count of Restaurants for different cuisines
What is preference?
Proxy Value: Preference is determined by the highest count of restaurants for the cuisine.

## Story Design
## Data Analysis
Data Analysis
The answer to the above-mentioned questions are the following:

1. Restaurants in New York City.

![](https://github.com/NYU-VIS-FALL2018/storytelling-group-5-offline/blob/master/img/1.png)

This is the overall map of New York City showing all the restaurants based on the latitude and longitude plotted on the map. The color range is from yellow to red for restaurants on the basis of their ratings. Red being 5 rating and yellow being lowest rated. For the image we analysed that among the five boroughs, manhattan has the most number of restaurants.
![](https://github.com/NYU-VIS-FALL2018/storytelling-group-5-offline/blob/master/img/5.png)

This map shows the number of restaurants when the map is focussed on a particular region and also showing details of the selected restaurant.

2. Which Borough have the top average rated restaurant in New York City?

The above map shows that Brooklyn has the highest average of restaurants in New York City.

The Average rating Goes by Brooklyn -> Queens -> Manhattan -> Staten Island -> Bronx.
![](https://github.com/NYU-VIS-FALL2018/storytelling-group-5-offline/blob/master/img/2.png)

3. Most common cuisine in different boroughs of New York City.

![](https://github.com/NYU-VIS-FALL2018/storytelling-group-5-offline/blob/master/img/3.png)

This shows the restaurants in Manhattan area of New York City and below is the tree map, which shows which cuisine has the highest number of restaurants in the area.
![](https://github.com/NYU-VIS-FALL2018/storytelling-group-5-offline/blob/master/img/6.png)

4. Top rated restaurants in different Boroughs of New York City.

![](https://github.com/NYU-VIS-FALL2018/storytelling-group-5-offline/blob/master/img/9.png)
For each borough, we can see the color of restaurants in the brough, which signifies their ratings and also we can change the ratings of the restaurants to filter the values.

5. Change in cuisine preference from whole New York City to different boroughs.

![](https://github.com/NYU-VIS-FALL2018/storytelling-group-5-offline/blob/master/img/4.png)

The above two graphs show that which cuisine was most common in the New York City area and which cuisine is most common in the  given borough.

## Storyboard
There have been many mobile applications which help users in finding the restaurants of their choice, but there aren’t in web applications. Web applications which we are creating will provide a much clear approach with all necessary question and answers and will allow the user to filter appropriately and show the results on the map, thus the user will have a better user experience. The user along with filtering is able to simultaneously look the result on the map and if the user is not able to get some good results, he can just drag the slider to change the filter value and then get the desired results. Based on our experience, we decided that few key factors are very important while designing our story, like the average rating of the business, the location, number of ratings of the user, stars, review counts. These key factor will help us in better designing our story and also help in a better user experience.

With this web application, we will be taking step by step approach towards helping the user in finding the overview of restaurants in New York City and its different Boroughs. The first step taken would be to provide the user with the number of restaurants within the proximity of the user. Now the user can also have the restaurants with the filter of the borough or even the zip code. This can be visualized on the basis of latitude and longitude in the dataset. The next step which comes is to filter the restaurants on the basis of the desired cuisine. From the dataset, we can get which all cuisines are served by the restaurant and then filter accordingly. Once these are filters, now the user can filter the restaurants on the basis of their star rating, since each restaurant has the star count in the dataset and the user review counts.

## Steps:

1. We have made the graph where we use the longitude and latitude to plot the restaurants on the map. We are using the color from yellow to red of the circles to show the rating of the restaurant where if the restaurant has a red color circle then it has a higher rating and the restaurant with a yellow color circle has a lower rating.We are plotting the restaurants on the map using the longitude and latitude.
![](https://github.com/NYU-VIS-FALL2018/storytelling-group-5-offline/blob/master/img/1.png)
2. Then show which borough has the top average rated restaurants
![](https://github.com/NYU-VIS-FALL2018/storytelling-group-5-offline/blob/master/img/2.png)

3. After the graph is made, we will add the treemap, which will show the various cuisines present in our dataset. Size of each cuisines depend on the star rating present corresponding to the restaurants. After this, when we hover over the each restaurant marker, we will be able to see number of reviews vs stars bar chart.
![](https://github.com/NYU-VIS-FALL2018/storytelling-group-5-offline/blob/master/img/3.png)
4. Then we compare the cuisine preference among different boroughs and whole new york
![](https://github.com/NYU-VIS-FALL2018/storytelling-group-5-offline/blob/master/img/4.png)
5. Our final solution will look something like this and will be interactive for users to show the results.
![](https://github.com/NYU-VIS-FALL2018/storytelling-group-5-offline/blob/master/img/2.png)


text:
# Addons - Custom Ops

## Contents
| Layer  | Description                             |
|:----------------------- |:-----------------------------|
| Image | Ops for image manipulation   |
| Text |  Ops for text processing  |

## Contribution Guidelines
#### Standard API
In order to conform with the current API standard, all custom ops
must:
 * Must be impossible to implement in one of the other API
 standards (Layers, Losses, etc.).
 * Add the addon to the `py_library` in this sub-package's BUILD file.

#### Testing Requirements
 * Simple unittests that demonstrate the custom op is behaving as
    expected.
 * When applicable, run all unittests with TensorFlow's
   `@run_in_graph_and_eager_modes` (for test method)
   or `run_all_in_graph_and_eager_modes` (for TestCase subclass)
   decorator.
 * Add a `py_test` to the custom-op's BUILD file.

#### Documentation Requirements
 * Update the table of contents in the project's central README.
 * Update the table of contents in this sub-packages's README.


text:
# DeepEye: UserInterface

## Table of Contents
1. [Introduction](#introduction)
2. [Methods](#methods)
3. [Customization](#customization)

User Interface          |  Warning Interface
:-------------------------:|:-------------------------:
![User Interface](user_interface.png)  |  ![Warning Interface](warning_interface.png)

## Introduction
This is a Graphical User Interface that pops up as soon as main is run.  This allows the user to change certain useful parameters for running the program, detailed below.  Once the user clicks "Run", the program launches with the given parameters.
The code makes use of the Tkinter library.  The boilerplate code (for widget creation and placement) was generated using [Page](http://page.sourceforge.net/), a drag-and-drop Python GUI creation tool.

## Methods
Name | Description
--- | ---
**Window** | This is the main class that contains all the widgets and their associated variables, positioning and default values.
**show_label** | This is used to raise the positioning of one widget above another.
**hide_label** | Similarly, this is used to lower the positioning of one widget below another.
**updateState** | This updates the warning icons and FPS counter on the interface while the main program is running.  It accesses the threats dictionary, and will either call show_label or hide_label for each warning icon widget.
**playBeep** | Plays a beep sound effect.  Is called in the updateState method when a collision threat is detected.
**FlipState** | This method controls whether the custom window width and height widgets are enabled or disabled based on the state of the checkbox above them.
**set_adas_prams** | This sets up all of the different parameters for the Driving Assistant.  The paramters are obtained from the setup widgets.  Some are converted to appropriate data types (strings to ints, for example).
**mainLoop** | This in how the main program functions.  It calls the [DrivingAssistant](../README.md) class to start the program, then enters a loop which runs untils the escape key is pressed.  In the loop, the run method in driving_assistant is called, and then the updateState method is called.  The frame rate is also updated.  When the loop exits, it goes back to the setup frame.
**runProgram** | Simply calls the mainLoop method, but in a new thread.
**exitProgam** | Destroys all the windows.  Is called when the Exit button is pressed.
**TextRedirector** | This class is used to redirect system output to the textbox in the setup interface.
**AutoScroll** | Autogenerated code from [Page](http://page.sourceforge.net/) which creates an autoscrolling textbox.  This is used for the command line output in the setup frame.

## Customization
Name | Description
--- | ---
**Monitor ID** | This selects which monitor to feed frames.  The default values are 0, 1 , and 2.  For the typical dual-monitor setup, 0 is both, whereas 1 and 2 are the other individual monitors.  Eventually this will hopefully be populated only by options available to the user.
**Custom Window Size** | If the Set Custom Window Size button is not checked, then the frame size will default to the size of the entire monitor that's feeding the visual stream.  If it's checked, this allows the user to enter a custom size (a smaller window size results in better performance).
**Top/Left Offset** | By default, the visual stream will be feeding from the very top left corner on the monitor, even with a custom smaller window size.  Adding an offset allows the user to change what part of the screen is being fed to the visual feed.
**Enable Object Detection** | Toggles whether to run object detection.
**Enable Lane Detection** | Toggles whether lane detection runs.  Will significantly decrease FPS.
**Enable Object  Visualization** | Toggles whether to visualize objects.  Will decrease FPS.
**Enable Lane Visualization** | Toggles whether to visualize lanes. Will decrease FPS.
**Diagnostic Mode** | Toggles whether to run in diagnostic mode.  Every time the run method is called, a frame is exported before and after the object/lane detection.  The values of the threats dictionary is added to a CSV which lists the threat dictionary results from each frame for testing purposes.
**CNN** | There are three options for changing the feature identifier model. The default is Resnet101, which gives us the best hardware performance.  NAS is a more accurate model, however its performance is slower.  Inception-Resnet is a compromise between the two, however we found that it didn't perform any better for us.
**Dataset** | There are two options: Coco and Kitti.  Coco is an American trained dataset, with more classes, so this is the default option.  Kitti has less classes, and was trained in Europe.
**Threshold** | This controls the confidence threshold cutoff for detected objects.  Any object detected with a confidence below the set threshold will not be displayed onscreen.  The default value is 85%.

*Note:* press the (ESC) key to return to the setup menu.