text:
# Angular 2 QuickStart with working example tests

This project was made on top of the Angular 2 QuickStart project on [github](https://github.com/angular/quickstart)

It contains a basic Angular 2 TypeScript application with working unit tests (karma-jasmine). It demonstrates
some usages of components and services. The tested scenarios include:
* Syncrhonous component-service communication
* Asynchronous component-service communication using RxJS Observables
* Router navigation
* Services sending HTTP requests
* Use of @Input and @Output for inter-component communication
* Forms
* Injection of stubbed/mocked dependencies in test environments
* Use of [sinon](https://www.npmjs.com/package/karma-sinon) test doubles (stubs, mocks, spies)

Some other things this app uses:
* [browserify] (https://www.npmjs.com/package/browserify)
* [lite-server] (https://www.npmjs.com/package/lite-server)
* [jQuery] (https://www.npmjs.com/package/jquery)

### Prerequisites

**Verify that you are running at least node `v4.x.x` and npm `3.x.x`**
by running `node -v` and `npm -v` in a terminal/console window.
Older versions produce errors.

## Clone
Clone this repo into new project folder (e.g., `my-proj`).
```bash
git clone  https://github.com/dav793/angular2-seed.git  my-proj
cd my-proj
```

## Install npm package dependencies

> See npm version notes above

Install the npm packages described in the `package.json` and verify that it works:

```bash
npm install
npm start
```

The `npm start` command first compiles the application, then runs the `lite-server`.
Afterwards, it simultaneously re-compiles and re-runs whenever file change is detected.
Both the compiler and the server watch for file changes.

Shut it down manually with `Ctrl-C`.

### npm scripts

Some useful commands defined in `package.json`:

* `npm start` - runs the compiler and a server at the same time, both in "watch mode".
* `npm run start-s` - same as `start`, but it also runs a simple server which sandbox 11 uses.
* `npm run start-s-silent` - same as `start-s`, but shuts up lite-server so you can see the output produced by the other server.
* `npm run tsc` - runs the TypeScript compiler once.
* `npm run tsc:w` - runs the TypeScript compiler in watch mode; the process keeps running, awaiting changes to TypeScript files and re-compiling when it sees them.
* `npm run lite` - runs the [lite-server](https://www.npmjs.com/package/lite-server), a light-weight, static file server, which serves the angular app to the browser.

Here are the test related scripts:
* `npm test` - compiles, runs and watches the karma unit tests
* `npm run test-coverage` - compiles and runs the karma unit tests, and generates a code coverage report under `/coverage`
(currently broken)
* `npm run e2e` - run protractor e2e tests, written in JavaScript (*e2e-spec.js)

## The Sandboxes

The sandboxes are located in `/app/components/sandbox`. They demonstrate some common interactions between
components and services. Each sandbox tries to demonstrate only one or few interactions in isolation,
in order to keep their code simple, quick to understand and easy to modify.

The subjects demonstrated by each sandbox are:
* Sandbox1: Test a component in an environment which simulates the application (TestBed).
* Sandbox2: Compile component under test which uses templateUrl (async).
* Sandbox3: Component calls a synchronous function on a service.
* Sandbox4: Component fetches data asynchronously (through observables) from a service.
* Sandbox5: Component gets data from HTTP request (through a service).
* Sandbox6: Component allows navigation between child components using the Router.
* Sandbox7: Child component uses @Input and @Output to communicate with parent controller (using a form).
* Sandbox8: Parent component interacts with child component via local variable.
* Sandbox9: Component generates a form programatically using reactive forms.
* Sandbox10: **Not yet implemented.**
* Sandbox11: Service communicates with express server using WebSockets. (remember to use `npm run start-s-silent` for this one)
* Sandbox12: Custom form element that plays nicely with angular forms
* Sandbox13: Custom form element with validation
* Sandbox14: Custom combobox with validation
* Sandbox15: Custom combobox with search filter
* Sandbox16: Custom combobox with multiple selection

You can use these sandboxes as a quick code reference when working with your projects. You can
also build on them and experiment with Angular 2. You are welcome to use them as templates for your own projects as well.

~~Most~~ Some of the sandboxes had unit tests written for them. Run the tests and look at their output to get a better
understanding of what each sandbox does. The next section describes how to run the unit tests.

The tests for each sandbox can be found in the files ending with '.spec.ts'. They are placed in the same
directory as the rest of files related to that component (.html, .css, .ts), as per the
[Angular 2 Style Guide](https://angular.io/docs/ts/latest/guide/style-guide.html).

## Testing

This repo adds both karma/jasmine unit test and protractor end-to-end testing support.

### Unit Tests
TypeScript unit-tests are usually in the `app` folder. Their filenames must end in `.spec`.

Add more `.spec.ts` files as you wish; karma was configured to find them.

Run it with `npm test`

That command first compiles the application, then simultaneously re-compiles and runs the karma test-runner.
Both the compiler and karma watch for file changes.

Test-runner output appears in both the terminal and the browser window.
Karma is occasionally confused and it is often necessary to shut down its browser or even shut the command down (`Ctrl-C`) and
restart it.

To debug tests with Chrome's inspector, hit the DEBUG button. This will open a new tab. Open the inspector in the new tab with
`Ctrl-Shift-I`.

### Code coverage (currently broken!)
Run `npm run test-coverage` to run the unit tests and generate a code coverage report using istanbul.
The report is stored in the directory `./coverage`


text:
# The film app

This is a web app with minimalistic design, that lets you search for a movie or series and shows you some info about them.

I used the [OMDb API](http://www.omdbapi.com/) to obtain the movie information.

![](usage.gif)

### But why?
The reason for this project was to familiarize myself with the animation platform [GSAP](https://greensock.com/gsap/) and practice on my ReactJS skills

#### So What I learned
- The basics of GSAP
- How to create modals with the use of react router
- Better understanding on React Hooks

### The packages

- [react-hook-form](https://www.npmjs.com/package/react-hook-form)
- [react-infinite-scroller](https://www.npmjs.com/package/react-infinite-scroller)
- [gsap](https://www.npmjs.com/package/gsap)
- [react-router-dom](https://www.npmjs.com/package/react-router-dom)

license: MIT

repository: JRoussos/the-film-app

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: JRoussos/the-film-app


text:
# Instructions for teachers

## Taking Code Vault into use

When Code Vault is launched for the first time for a new course in the course
management system, a new Code Vault instance is automatically generated. There
is no need to request a new instance from your system admins if they have
configured the required LTI settings in the course management system so that you
can add Code Vault as a part of your course in the CMS.

## Settings

As a teacher you can configure settings for your course by selecting the
Settings tab. Remember to save the settings by clicking Save in the bottom of
the page.

The following options are available:

**Course name**: The name of the course shown in the top of the page. The
default value for the name is taken from the initial launch of Code Vault from
the course management system.

**Combine with**: If there are multiple course codes in use although they
basically share the same course instance, it is possible to combine Code Vaults
so that only a single Code Vault is used for the all courses. Check the correct
Course id field above of that course which shall remain in use and paste the
value in this field.

After this setting is stored, all the other users except the course teacher are
redirected to the defined Course Vault instance.

**Default UI language**: This option is valid only if the course management
system does not provide the preferred language. In this case the user interface
will use the language specified here.

**Programming language**: This setting is optional and affects the syntax
highlighting. The used code library can automatically detect the correct
language but if it does not work properly, it is possible to define the used
language here.

See the list [here](https://highlightjs.org/download/). Code Vault uses the
common bundle containing the most typical languages. Also Scala programming
language is added to the bundle.

**Expiration**: This setting defines how many days the content is stored in Code
Vault which after the items are automatically removed.

**Quota size**: It is possible to adjust how much content each student can store
to Code Vault in this course. The limit is defined as kilobytes.

All the content is stored to Code Vault's database shared with all courses so
the value should not be too high to avoid using all disk space.

repository: ttsirkia/koodisailo

repo_name: ttsirkia/koodisailo


text:
This Action makes it easy to download any folder from a Persistent Volume (PV) on Kubernetes.

This action schedules a job to mount a PVC, then uses kubectl copy to transfer the files from the running pod to the local filesystem and finally cleans up the job.

| Parameters  | Description |
| ------------- | ------------- |
| kubeConfig  | Base64 encoded kubeConfig  |
| volume  | Persistent Volume Claim (PVC) name to download from  |
| sourcePath | Path to a folder on the Persistent Volume to download from |
| outputPath | Name of the folder to download into (the default is k8s-volume-download) |
| timeout | Timeout in seconds to wait for the job to successfully bind to the PVC |

Note: Currently very large files will fail to transfer using kubectl copy. I will be adding better support for breaking up files above a certain size into smaller chunks and reassembling them soon.


text:
# CleanFolders
Opens an MS Windows mini-application for providing a quick and easy-to-use mechanism for
deleting extraneous files and/or folders from within a given Visual Studio
`solution` folder.

This application is not limited to just Visual Studio `solution` specific files
and folders, i.e., it can also be used to methodically delete other files and folders of a particular
name or extension.

The following shows the **Clean Folder...** context menu item being displayed when right-clicking
a folder in Window's Explorer:

![Image2](Images/image2.png)

Launching this application directly or by selecting **Clean Folder...** context menu opens a
window such as:

![Image1](Images/image1.png)

Notice that certain items in the tree view are automatically checkmarked and highlighted in red.

These items correspond to the 'Folder Names' and 'File Extensions' containing checkmarks
inside the 'Auto-Select' group box.

Not so obvious, but there is available a 'context menu' when right-clicking anywhere on the main
listbox as shown here :

![Image3](Images/image3.png)

From this context menu you can:

    1) Physically delete the currently selected item or items from disk.
	(Note: A confirmation dialog is displayed prior to the delete actually being performed.)

    2) Expand or collapse all the items displayed in the list at one time.

    3) Uncheck all the items in the list.

    4) Open an 'Options' dialog:

![Image4](Images/image4.png)

A Window's context menu item is available for quickly launching this application by right-clicking a
selected folder inside 'MS Windows Explorer'.

The 'Clean Folder Options' dialog is displayed when selecting 'Options...' from the context menu
defined above:

Place a checkmark beside the "Show 'Clean Folder' context menu..." control; then click the 'OK' button
to have the Clean Folder... context menu item automatically added to Window's Explorer.

(NOTE: This same context menu item can also be manually added to Window's Explorere by launching the
"CleanFolders.reg" file included in this solution folder).

    5) Show the 'Properties' window associated with a selected item:

![Image7](Images/image7.png)

    6) Show the About box dialog:

![Image5](Images/image5.png)

### Other Notes

A folder can be dragged directly onto this application or opened from within the
application itself by clicking the 'folder' icon button located adjacent to the folder path.

This application is also aware of any changes being made (outside of the application itself), to all the
files and folders located in the parent folder and child folders:

![Image6](Images/image6.png)

repository: sokooltools/CleanFolders

repo_name: sokooltools/CleanFolders


text:
# Compiling

This document is about compiling software within **SCAMP/os**. For more general
thoughts on the compiler, see COMPILER.md instead.

## Basic usage

    $ kilo foo.sl
    $ slc < foo.sl > foo
    $ ./foo

## Linking

To keep the library blob small, the bigint and fixed-point code is not included
by default. Ideally we'd be able to link against arbitrary combinations of
libraries, but for now the compiler only supports a single library blob, which
means if we want to support different options then we need to have a
pre-compiled blob for each possible combination.

If you need to use either the `fixed` or `bigint` libraries, then you need to
tell `slc` to select the appropriate library blob by passing it a blob name in
`-l`. Example:

    $ slc -lfixed < foo.sl > foo

Available blobs are:

             - normal library
    fixed    - normal library, plus `fixed.sl`
    bigint   - normal library, plus `bigint.sl`
    bigfix   - normal library, plus both of `fixed.sl` and `bigint.sl`

For more explanation of how linking works, see LINKING.md.

## Workings

`slc` is the compiler driver. It delegates to `slangc` to turn source code into
assembly language, and `asm` to turn assembly language into machine code. It also
brings in pre-packaged assembly language source for the "head" and "foot" of
the program, from `/lib/head.s` and `/lib/foot.s`, and library definitions
from `/lib/lib.s` (or `/lib/libfoo.s` in the case of `-lfoo`).

`head.s` is responsible for setting the start address of the program code
to 0x100, initialising the stack pointer, allocating space to store the `TOP`
variable, and defining constants for system call vectors.

`foot.s` is responsible for calling `exit(0)` after the program finishes,
and defining a constant for the initial value of `TOP`.

`lib.s` is responsible for including the library blob from `/lib/lib.o`, and
defining the addresses of the symbols exposed by the library.

license: Unlicense

repository: jes/scamp-cpu

repo_name: jes/scamp-cpu


text:
Menu Dialogs

Android Demo

Customize your Android apps dialogs easily!

  Author: Giorgio Cantoni

  Dialogs Resources: Bryan Owens

## Download Sample
 [](https://play.google.com/store/apps/details?id=dialogmenu.folgore95.it.dialogmenu)[](https://github.com/gcantoni/menudialogs/releases)

## Custom dialogs available
- Simple Dialog Menu
- Rounded Dialog Menu
- Rounded Colored Dialog Menu (Borders)
- Rounded Colored Dialog Menu (Borders and background)

## Simple Dialog Menu

- First, create your dialog menu items and icons like it has been done here.

```
final String[] items = { string, string, string, string, ...};
final Integer[] icons = new Integer[] {icon, icon, icon, icon, ...};

// You can add how much texts and icons you want but you need to consider your users phones dpi
```
- Create a new **ListAdapter**
```
ListAdapter adapter = new DialogArrayAdapter(getApplicationContext(), items, icons);
```
- Create a new class `DialogArrayAdapter` like this one.
 Notice that this class **extends ArrayAdapter** class and in his constructor there is passed an **Android framework layout**. If you are planning to play with your dialog colors like the background, we need to redefine this layout or the text of the various options will be broken. For preventing that, we have overwritten the ArrayAdapter constructor layout with a new one available under our app resources.
```
public DialogArrayAdapter(Context context, String[] items, Integer[] images) {
        super(context, R.layout.dialog, items); // dialog is the layout interested
        this.images = Arrays.asList(images);
    }
```
- In your principal class build a Dialog using **AlertDialog**
```
AlertDialog.Builder builder = new AlertDialog.Builder(this);
```

- If you want add options ( methods from AlertDialog)
```
builder.setTitle(string); // title
builder.setIcon(icon); // icon
builder.setCancelable(true);

// options
```

- Now create the dialog interface
```
builder.setAdapter(adapter, new DialogInterface.OnClickListener() {
            public void onClick(DialogInterface dialog, int which) {
                                                                   }
                                                                   }

// Creating the dialog interface
```

- Inside onClick method create a switch with all of your options like it has been done here.
```
switch (which) {
                    case 0:
                        // Action
                        break;

                    case 1:
                        // Action
                        break;

                    case 2:
                        // Action
                        break;

                    case 3:
                        // Action
                        break;
                }

// Menu options: they must follow the numbers of your icons and strings declared at the start as constants
// Action can be everything such as sending an email, open an installed app, show a toast and whatever you like
```
## Rounded Dialog Menu

## Rounded Colored Dialog Menu

## Rounded Black Colored Menu

## License
```
Copyright 2018 Giorgio Cantoni

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
```

gha_license_id: NOASSERTION


text:
# [get_model_matrix](get_model_matrix.hpp)

```cpp
glm::mat4 get_model_matrix(const core::transform & transform, const core::transform * model) noexcept;
```

Generates a model matrix for an entity, applying any transformations it may have inherited from its `model`.

repository: phisko/kengine

branch_name: refs/heads/main

gha_license_id: MIT

repo_name: phisko/kengine


text:
# beam.ruby

Ruby support.

Install latest Ruby package.

**Example of usage:**

```yamlex
roles:
  - { role: beam.ruby}
```

repository: dotintent/BEAM-Framework

repo_name: dotintent/BEAM-Framework


text:
---
layout: creature
name: "Giant Crab"
tags: [medium, beast, cr1/8, monster-manual]
cha: 3 (-4)
wis: 9 (-1)
int: 1 (-5)
con: 11 (0)
dex: 15 (+2)
str: 13 (+1)
size: Medium beast
alignment: unaligned
challenge: "1/8 (25 XP)"
senses: "blindsight 30 ft."
skills: "Stealth +4"
speed: "30 ft., swim 30 ft."
hit_points: "13 (3d8)"
armor_class: "15 (natural armor)"
---

***Amphibious.*** The crab can breathe air and water.

### Actions

***Claw.*** Melee Weapon Attack: +3 to hit, reach 5 ft., one target. Hit: 4 (1d6 + 1) bludgeoning damage, and the target is grappled (escape DC 11). The crab has two claws, each of which can grapple only one target.

gha_language: CSS


text:
---
type: TutorialStep
date: 2021-06-02
title: Introduction
technologies: []
topics: []
author: da
subtitle: Getting started with Spring Data JPA.
thumbnail: ./thumbnail.png

---

[Spring Data JPA](https://spring.io/projects/spring-data-jpa) is a powerful framework that allows users to easily interact with their database while minimizing boilerplate code. In this tutorial, we're going to look at how to use Spring Data JPA to insert into and query data from a database. We'll create a simple Spring Boot application using [IntelliJ IDEA Ultimate](https://www.jetbrains.com/lp/intellij-frameworks/) to take advantage of its Spring feature support.


text:
---
templateKey: blog-post
title: The Crypto Guide for Beginners – Why are tokens burned?
path: the-crypto-guide-for-beginners-why-are-token-burned
date: '2018-01-02T15:59:07+01:00'
author: Karin
tags:
  - Crypto Guide
description: Why are tokens burned?
image: /img/fire-2777580_960_720-670x447.jpg
---
![](/img/fire-2777580_960_720.jpg)

First of all, it has nothing to do with actual fire! “Burning tokens” is simply a clever way to reduce the number of tokens available on the open market, thereby increasing the value of investors‘ existing tokens. No flames, just a basic economic principle.

If you are interested in the details and how tokens can be burned, check out this [article on Forbes.com](https://www.forbes.com/sites/eidoo/2017/11/29/token-burning-and-other-crypto-jargon-simplified/#f7013e954c4b).

gha_language: JavaScript


text:
## dependencies_list
Manage dependencies to run resources.

#### Synopsis
 Provides an interface to manage dependencies to run resources.

#### Requirements (on the host that executes the module)
  * hpeOneView >= 5.4.0

## Example Playbook

```yaml
- hosts: all
  collections:
    - hpe.oneview
  roles:
    - hpe.oneview.dependencies_list
```

## License

Apache

gha_language: Python


text:
Title: Using MSBuild Binary Log Files
Lead: Going beyond Structured Log Viewer.
Published: 10/4/2018
Image: /images/blocks.jpg
Tags:
  - msbuild
---
[In a previous post](/posts/msbuild-loggers-and-logging-events) I looked at MSBuild logging and logging events. In this post I want to talk about [MSBuild binary log files](http://msbuildlog.com/) and what you can do with them beyond viewing in the excellent [Structured Log Viewer](https://github.com/KirillOsenkov/MSBuildStructuredLog).

# Binary Log Files

As discussed in the [previous post](/posts/msbuild-loggers-and-logging-events), MSBuild emits a series of [different events](https://docs.microsoft.com/en-us/dotnet/api/microsoft.build.framework.ieventsource?view=netframework-4.7.2#events) while it's executing. The MSBuild binary logger captures all of these events and serializes them to disk in a binary format. The result is a complete picture of every logging event which can be analyzed or replayed later to understand exactly what happened during a build.

To create a binary log you can either [use the `/bl` switch from the CLI](http://msbuildlog.com/#commandline) or use the [Project System Tools Visual Studio extension](https://marketplace.visualstudio.com/items?itemName=VisualStudioProductTeam.ProjectSystemTools). In both cases you'll end up with a `.binlog` file that contains all the serialized logging events from that build.

# Structured Log Viewer

By far the easiest way to view your binary log is with the [Structured Log Viewer](https://github.com/KirillOsenkov/MSBuildStructuredLog). This tool has been a lifesaver for me more than once and I use it _all the time_. Now that I've got that out of the way though, it's not really what this post is about. I want to look at other ways in which we can use the MSBuild binary log files.

# MSBuild API

MSBuild has an API for reading binary log files that ships with the [Microsoft.Build](https://www.nuget.org/packages/Microsoft.Build/) package. Unfortunately, [until recently](https://github.com/Microsoft/msbuild/pull/3814) it was `internal` and you have to use a little proxy (or otherwise use reflection) to get access to it:

```
public class BuildEventArgsReaderProxy
{
    private readonly Func<BuildEventArgs> _read;

    public BuildEventArgsReaderProxy(BinaryReader reader)
    {
        object argsReader;
        Type buildEventArgsReader =
            typeof(BinaryLogger).GetTypeInfo().Assembly
                .GetType("Microsoft.Build.Logging.BuildEventArgsReader");
        ConstructorInfo readerCtor = buildEventArgsReader
            .GetConstructor(new[] { typeof(BinaryReader) });
        if (readerCtor != null)
        {
            argsReader = readerCtor.Invoke(new[] { reader });
        }
        else
        {
            readerCtor = buildEventArgsReader
                .GetConstructor(new[] { typeof(BinaryReader), typeof(int) });
            argsReader = readerCtor.Invoke(new object[] { reader, 7 });
        }
        MethodInfo readMethod = buildEventArgsReader.GetMethod("Read");
        _read = (Func<BuildEventArgs>)readMethod
            .CreateDelegate(typeof(Func<BuildEventArgs>), argsReader);
    }

    public BuildEventArgs Read() => _read();
}
```

Once you've got access to the `BuildEventArgsReader.Read()` method, either directly, through a proxy like above, or via some other reflection hackery, you can use it to get one `BuildEventArgs` event at a time from the binary log file until none are left:

```
string logFile = @"C:\MyLogFile.binlog";
using (Stream stream = new FileStream(logFile, FileMode.Open, FileAccess.Read, FileShare.Read))
{
    GZipStream gzipStream = new GZipStream(stream, CompressionMode.Decompress, leaveOpen: true);
    BinaryReader binaryReader = new BinaryReader(gzipStream);
    BuildEventArgsReaderProxy buildEventArgsReader =
        new BuildEventArgsReaderProxy(binaryReader);

    // We don't actually need this, but have to advance the BinaryReader past it
    int fileFormatVersion = binaryReader.ReadInt32();

    while(true)
    {
        BuildEventArgs buildEvent = buildEventArgsReader.Read();
        if(buildEvent == null)
        {
            break;
        }
        // Do something with the buildEvent
    }
}
```

There are two little gotchas to point out in the code above. The first is that we use a `GZipStream` instead of just reading directly from the `FileStream`. That's because binary log files are gzipped to save space when they're originally written. The second gotcha is that we have to read a version flag from the file before reading it. We could probably be smarter about matching the version from the file to the read operations, but this code has worked for me in most situations.

# Structured Log Viewer API

BinLogReader

# Replaying Logging Events

Can send them to any MSBuild logger

# Structured Log Viewer Composition

Getting back to the [Structured Log Viewer](https://github.com/KirillOsenkov/MSBuildStructuredLog), it actually has it's own API for reading and constructing a tree representation of all the logging events that closely matches what you see in the Structured Log Viewer interface. It just happens that this tree structure is also a pretty good representation that you can use from your own code as well.

# Buildalyzer

repository: Drex-Dbm/daveaglick

gha_language: HTML

repo_name: Drex-Dbm/daveaglick


text:
## Welcome to Ourzobia PHP

Ourzobia PHP - Social Ponzi Investment Script is the most advanced Ponzi investment php script currently available in the market, it designed to accommodate millions of users with the sole aim of creating a platform for social investment, somewhat like the usual weekly Esusu contributions done locally.
Built upon the latest version of the Codeigniter PHP framework this script will enable you to run and manage your own Social Ponzi investment scheme without flaws and limits.
Ourzobia PHP has a built in Social Network called playground, purposely designed to alienate the use of conventional social media accounts alongside your website and to eliminate the fear of criminal actors that have become a plague on the social networking handles of so many similar concepts.
Installation and management has been so simplified that you might not have any other work to do after installation other than monitoring, as almost all major processes and actions have been automated.

### Who can use Ourzobia PHP?

Ourzobia PHP is right for you if:

-  You want a to run a Social Ponzi Investment Scheme.
-  You want a to run a Social Ponzi Investment Scheme with honesty and a difference.
-  You want to limit your Job to just monitoring and debugging.
-  You want to create a sustainable Ponzi Investment platform.
-  You want to keep scam actors, impersonators and hackers away from your platform.
-  You are a student who wants to learn how certain features can implemented.
-  You are a teacher who wants to show students how certain features can implemented.
-  You are doing a research project in a related topic.

### Demo

A working demo is available for your to try out Ourzobia PHP before purchasing, visit [https://demo.ourzobiaphp.cf](https://demo.ourzobiaphp.cf/). The demo has no restrictions.

- Demo Admin Username<EMAIL_ADDRESS>- Demo Admin Password: `demo`


text:
# Change Log

All notable changes to this project will be documented in this file.
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.

# [3.1.0](https://github.com/mjzhang1993/lerna-test/compare/...v3.1.0) (2021-02-06)

### 👽 Other Effect

**Note:** Version bump only for package @mjz-test/conventional-changelog-mjz

# 3.0.0 (2021-02-05)

### 👽 Other Scope

#### ✨ Features

* nothing to change ([d8d01ce](https://github.com/mjzhang1993/lerna-test/commit/d8d01ceb2fee671e7e722baf1ba9f13b38631c4f))

### conventional-changelog-mjz

#### ✨ Features

* ***[Project]***  create new project ([718d957](https://github.com/mjzhang1993/lerna-test/commit/718d9572d8b77a38752e7691070f06f55c2533a7))

#### 🐛 Bug Fixes

* [@mjzhang1993](https://github.com/mjzhang1993) fixed ([17ad912](https://github.com/mjzhang1993/lerna-test/commit/17ad91299023d5582395fa383974c34156c4f3ab))
* [Custom Scope] update build ([05f5f87](https://github.com/mjzhang1993/lerna-test/commit/05f5f871008e1e67220c41cbdc8e2a0d00162296))

#### 📖 Documentation

* add a document ([1a64519](https://github.com/mjzhang1993/lerna-test/commit/1a64519819c6608791a720e5228fabaead007e33))

repository: asialiugf/lerna-test

repo_name: asialiugf/lerna-test


text:
---
layout: default
---

# 1996-10-02 - Re: Can we kill single DES?

## Header Data

From: Lucky Green<EMAIL_ADDRESS>To: Peter Trei<EMAIL_ADDRESS>Message Hash: adb9b47f662861a4903f0dea19b8e44d89032e919c28481f55dce0e71af43ac9

Message ID: \<Pine.3.89.9610011638.A7805-0100000@netcom14\>

Reply To<EMAIL_ADDRESS>UTC Datetime: 1996-10-02 03:15:22 UTC

Raw Date: Wed, 2 Oct 1996 11:15:22 +0800

## Raw message

```
{% raw  %}From: Lucky Green<EMAIL_ADDRESS>Date: Wed, 2 Oct 1996 11:15:22 +0800
To: Peter Trei<EMAIL_ADDRESS>Subject: Re: Can we kill single DES?
In-Reply-To<EMAIL_ADDRESS>Message-ID: <Pine.3.89.9610011638.A7805-0100000@netcom14>
MIME-Version: 1.0
Content-Type: text/plain

On Tue, 1 Oct 1996, Peter Trei wrote:

> Since it looks like the US government will be allowing the export of
> 56 bit espionage-enabled software, it's time to kill single DES.
>
> As some of you will recall, a while back I wondered aloud about the
> feasibility of brute-forcing DES on general purpose machines, ala the
> RC4-40 crack last year.
[...]

> Yes, I KNOW that a hardware based cracker is a LOT more efficient,
> but between the up-front cost and the difficulty of design and production,
> it's less likely to get done.  (Still if someone wants to buy me a nice
> FPGA board, I'll see what I can do).

I understand that *two* independent efforts cracking single DES using FPGAs
are currently being set up. If the parties whish to come forward, my offer
to donate to this cause still stands.


text:
OroAddressBundle
================

OroAddressBundle implements base entity and interfaces for address and address related entities like country, region,
phone and email. It also provides a dictionary with country region codes and names.

### Table of contents

* [Usage](./Resources/doc/reference/usage.md)
* [Entities](./Resources/doc/reference/entities.md)
* [Form Types](./Resources/doc/reference/form_types.md)
* [Address Type](./Resources/doc/reference/address_type.md)
* [Validators](./Resources/doc/reference/validators.md)


text:
# Warning: this project as been deprecated

This tool has been deprecated internally but remains for posterity.  We actively encourage you to use another tool and will not provide support or accept liability if you use this.

# GeekHive Gulp Sass Build

A simplified, standardized, gulp-compatible build script to bundle a source file using Sass, Autoprefixer, and CSSMin.

## Installation

Using NPM

```
npm install geekhive/gulp-sass-build --save-dev
```

Using yarn

```
yarn add geekhive/gulp-sass-build --dev
```

## Configuration

Optional configuration for processing steps can be defined in module's `package.json` from the key `SASSBuild`.  For example:

```js
{
    // ...
    "SASSBuild": {
        "sass": { ... }, // SASS options
        "autoprefixer": { ... }, // Autoprefixer options
        "cssmin": { ... } // CSSMin options
    },
    // ...
}
```

## Usage

Require `@geekhive/gulp-sass-build` to access the build class.

```
const SassBuild = require('@geekhive/gulp-sass-build');
```

## `new SassBuild(src, dest, gulp)`

Create a new `SassBuild` object by passing it source and destination paths for the file to compile as well as a reference to `gulp`.

```
const css = new SassBuild(
    `${__dirname}/assets/sass/site.scss`,
    `${__dirname}/assets/css/site.min.css`,
    gulp);
```

The `dest` argument may also be an array of destinations.

```
const css = new SassBuild(
    `${__dirname}/assets/sass/site.scss`,
    [
        `${__dirname}/assets/css/site.min.css`,
        `${__dirname}/assets/example/alternative.css`
    ],
    gulp);
```

## `SassBuild#build()`

The `SassBuild#build` method can be passed directly to gulp as a build task:

```
gulp.task('build:css', css.build);
```

Calling `css.build` will compile the source file using Sass, Autoprefixer, and CSSMin. It will then output the result to the destination location.

## `SassBuild#watch()`

The `SassBuild#watch` method can be passed directly to gulp as a watch task:

```
gulp.task('watch:css', css.watch);
```

Calling `css.watch` will start watching the source directory and subdirectories for changes and will recompile the CSS file when changes are made.

repository: GeekHive/gulp-sass-build

repo_name: GeekHive/gulp-sass-build


text:
# Module 10: Introduction to DPLYR

The **`dplyr`** ("dee-ply-er") package is the preeminent tool for data wrangling in R (and perhaps, in data science more generally). It provides users with an intuitive vocabulary for executing data management and analysis tasks. Learning and utilizing this package will make your data preparation and management process faster and easier to understand.

<!-- START doctoc generated TOC please keep comment here to allow auto update -->
<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
**Contents**

- [Resources](#resources)
- [A Grammar of Data Manipulation](#a-grammar-of-data-manipulation)
- [Using `dplyr` Functions](#using-dplyr-functions)
  - [Select](#select)
  - [Filter](#filter)
  - [Mutate](#mutate)
  - [Arrange](#arrange)
  - [Summarize](#summarize)
- [Multiple Operations](#multiple-operations)
  - [The Pipe Operator](#the-pipe-operator)
- [Grouped Operations](#grouped-operations)
- [Joins](#joins)
- [Non-Standard Evaluation vs. Standard Evaluation](#non-standard-evaluation-vs-standard-evaluation)

<!-- END doctoc generated TOC please keep comment here to allow auto update -->

## Resources
- [Introduction to dplyr](https://cran.r-project.org/web/packages/dplyr/vignettes/introduction.html)
- [dplyr and pipes: the basics (blog)](http://seananderson.ca/2014/09/13/dplyr-intro.html)
- [Two-table verbs](https://cran.r-project.org/web/packages/dplyr/vignettes/two-table.html)
- [DPLYR Join Cheatsheet (Jenny Bryan)](http://stat545.com/bit001_dplyr-cheatsheet.html)
- [Non-standard evaluation](https://cran.r-project.org/web/packages/dplyr/vignettes/nse.html)
- [Data Manipulation with DPLYR (R-bloggers)](https://www.r-bloggers.com/data-manipulation-with-dplyr/)
- [Data Manipulation in R (DataCamp)](https://www.datacamp.com/courses/dplyr-data-manipulation-r-tutorial)

## A Grammar of Data Manipulation
[Hadley Wickham](http://hadley.nz/), the creator of the [`dplyr`](https://github.com/hadley/dplyr) package, fittingly refers to it as a ___Grammar of Data Manipulation___.

This is because the package provides a set of **verbs** (functions) to that describe and perform common data preparation tasks. One of the core challenge in programming is _mapping_ from questions about a dataset to specific programming operations. The presence of a data manipulation grammar makes this process smoother, as it enables us to use the same vocabulary to both _ask_ questions and _write_ our program. Specifically, the `dplyr` grammar lets us to easily talk about and perform task such as:

- **select** specific features (columns) of interest from the data set
- **filter** out irrelevant data and only keep observations (rows) of interest
- **mutate** a data set by adding more features (columns)
- **arrange** the observations (rows) in a particular order
- **summarize** the data in terms of aspects such as the mean, median, or maximum
- find **distinct** observations (rows) in the data set
- **join** multiple data sets together into a single data frame

You can use these words when describing the _algorithm_ or process for interrogating data, and then use `dplyr` to write code that will closely follow your "plain language" description because it uses functions and procedures that share the same language. Indeed, many real-world questions about a dataset come down to isolating specific rows/columns of the data set as the "elements of interest", and then performing a simple comparison or computation (mean, count, max, etc.). While it is possible to perform this computation with base R code—the `dplyr` library makes it much easier to write and read such code.

<!-- Refactor this into Module 9 probably -->
To practice asking questions about datasets using these questions but ___without___ `dplyr`, see [exercise-1](exercise-1).

## Using `dplyr` Functions
The `dplyr` package provides functions that mirror the above verbs. Using this package's functions will allow you to quickly and effectively write code to ask questions of your data set.

Since `dplyr` is an external package, you will need to install it (once per machine) and load it to make the functions available:

```r
install.packages("dplyr")  # once per machine
library("dplyr")
```

After loading the library, you can call any of the functions just as if they were the built-in functions you've come to know and love.

For each `dplyr` function discussed here, the **first argument** to the function is a data frame to manipulate, with the rest of the arguments providing more details about the manipulation.

- ___IMPORTANT NOTE:___ inside the function argument list (inside the parentheses), we refer to data frame columns **without quotation marks**—that is, we just give the column names as _variable names_, rather than as _character strings_. This is refered to as [non-standard evaluation](#Non-standard Evaluation), and is described in more detail below; while it makes code easier to write and read, it can occassionally create challenges.

<small>The images in this section come from the [RStudio's STRATA NYC R-Day workshop](http://bit.ly/rday-nyc-strata15), which was presented by [Nathan Stephens](http://conferences.oreilly.com/strata/big-data-conference-ny-2015/public/schedule/speaker/217840).</small>

### Select
The **`select()`** operation allows you to choose and extract **columns** of interest from your data frame.

![Diagram of select function](img/select.png)

```r
# Select `storm` and `pressure` columns from `storms` data frame
storm.info <- select(storms, storm, pressure)
```

The `select()` function takes in the data frame to select from, followed by the names of the columns you wish to select (without quotation marks!)

This function is equivalent to simply extracting the columns:

```r
# extract columns by name
storm.info <- storms[, c("storm", "pressure")]  # Note the comma!
```

But easier to read and write!

### Filter
The **`filter()`** operation allows you to choose and extract **rows** of interest from your data frame (contrasted with `select()` which extracts _columns_).

![Diagram of filter function](img/filter.png)

```r
# Select rows whose `wind` column is greater than or equal to 50
some.storms <- filter(storms, wind >= 50)
```

The `filter()` function takes in the data frame to filter, followed by a comma-separated list of conditions that each _row_ returned row must fill. Note again that columns are provided without quotation marks!
-  R will extract the rows that match **all** conditions. Thus you are specifying that you want to filter down a data frame to contain only the rows that meet Condition 1 **and** Condition 2.

This function is equivalent to simply extracting the rows:

```r
# extract rows by condition
some.storms <- storms[storms$wind >= 50, ]  # Note the comma!
```

### Mutate
The **`mutate()`** operation allows you to create additional **columns** for your data frame.

![Diagram of mutate function](img/mutate.png)

```r
# Add `ratio` column that is ratio between pressure and wind
storms <- mutate(storms, ratio = pressure/wind)  # Replace existing frame with mutated one!
```

The `mutate()` function takes in the data frame to mutate, followed by a comma-separated list of columns to create using the same **`name = vector`** syntax we used when creating **lists** or **data frames** from scratch. As always, the names of the columns in the data frame are used without quotation marks.
- Despite the `mutate()` function doesn't actually change the data frame; instead it returns a _new_ data frame that has the extra columns added. You will often want to replace the old data frame variable with this new value.

In cases where you are creating multiple columns (and therefore writing really long lines of code), you should break the single statement into multiple lines for readability. Because you haven't closed the parentheses on the function parameters, R will not treat each line as a separate statement.

```r
# Generic mutate command
more.columns <- mutate(my.data.frame,
                       new.column.1 = old.column * 2,
                       new.column.2 = old.column * 3,
                       new.column.3 = old.column * 4
                      )
```

### Arrange
The **`arrange()`** operation allows you to **sort the rows** of your data frame by some feature (column value).

![Diagram of arrange function](img/arrange.png)

```r
# Arrange storms by INCREASING order of the `wind` column
sorted.storms <- arrange(storms, wind)
```

By default, the `arrange()` function will sort rows in **increasing** order. To sort in **reverse** (decreasing) order, place a minus sign (**`-`**) in front of the column name (e.g., `-wind`). You can also use the `desc()` helper function (e.g, `desc(wind)`).
- You can pass multiple arguments into the `arrange()` function in order to sort first by `argument.1`, then by `argument.2`, and so on.
- Again, this doesn't actually modify the argument data frame—instead returning a new data frame you'll need to store.

<!-- ### Distinct
The **`distinct()`** operation allows you to extract distinct values (rows) from a particular **column** in your data frame—that is, you'll get one row for each different value in the column. If multiple columns are specified, you will get a row for each different combination.

For example (no diagram available):

```r
# Create a quick data frame
x <- c(1, 1, 2, 2, 3, 3, 4, 4)  # duplicate x values
y <- 1:8                        # unique y values
my.df <- data.frame(x, y)

# Select distinct rows, judging by the `x` column
distinct.rows <- distinct(my.df, x)
                                    #   x
                                    # 1 1
                                    # 2 2
                                    # 3 3
                                    # 4 4

# Select distinct rows, judging by the `x` and `y`columns
distinct.rows <- distinct(my.df, x, y)  # returns whole table, since no duplicate rows
```

While this is a simple way to get a unique set of rows, **be careful** not to unintentionally remove rows of your data which may be important. -->

### Summarize
The **`summarize()`** function (equivalently `summarise` for those using the British spelling) will generate a new data frame that contains a "summary" of a **column**, computing a single value from the multiple elements in that column.

![Diagram of summarize function](img/summarize.png)

```r
# Compute the median value of the `amount` column
summary <- summarize(pollution, median = median(amount))
```

The `summarize()` function takes in the data frame to mutate, followed by the values that will be included in the resulting summary table. You can use multiple arguments to include multiple summaries in the same statement:

```r
# Compute statistics for the `amount` column
summaries <- summarize(pollution,
                       median = median(amount),  # median value
                       mean = mean(amount),      # "average" value
                       sum = sum(amount),        # total value
                       count = n()               # number of values (neat trick!)
                       )
```

Note that the `summarize()` function is particularly useful for grouped operations (see below), as you can produce summaries of different groups of data.

To practice asking questions about datasets _with_ `dplyr`, see [exercise-2](exercise-2). For a more involved example, see [exercise-4](exercise-4).

## Multiple Operations
<!-- This discussion may be better for lecture than module, but leave in for now -->
You've likely encountered a number of instances in which you want to take the results from one function and pass them into another function. Our approach thus far has often been to create _temporary variables_ for use in our analysis. For example, if you're using the `mtcars` dataset, you may want to ask a simple question like,

> Which 4-cylinder car gets the best milage per gallon?

This simple question actually requires a few steps:

1. _Filter_ down the dataset to only 4 cylinder cars
2. Of the 4 cylinder cars, _filter_ down to the one with the highest mpg
3. _Select_ the car name of the car

You could then implement each step as follows:

```r
# Preparation: add a column that is the car name
mtcars.named <- mutate(mtcars, car.name = row.names(mtcars))

# 1. Filter down to only four cylinder cars
four.cyl <- filter(mtcars.named, cyl == 4)

# 2. Filter down to the one with the highest mpg
best.four.cyl <- filter(four.cyl, mpg == max(mpg))

# 3. Select the car name of the car
best.car.name <- select(best.four.cyl, car.name)
```

While this works fine, it clutters our work environment with variables we won't need to use again, and which can potentially step on one anothers toes. It can help with readability (the results of each step is complete), but those extra variables make it harder to modify and change the algorithm later.

An alternative to saving each step as a distinct variable would be to write the desired statements **nested** within other statements. For example, we could write the statement above as follows:

```r
# Preparation: add a column that is the car name
mtcars.named <- mutate(mtcars, car.name = row.names(mtcars))

# Write a nested operation to return the best car name
best.car.name <- select(  # 3. Select car name of the car
                  filter(  # 2. Filter down to the one with the highest mpg
                    filter( # 1. Filter down to only four cylinder cars
                      mtcars.named,  # parameters for the Step 1 filter
                      cyl == 4
                    ),
                    mpg == max(mpg)  # other parameters for the Step 2 filter
                  ),
                  car.name  # other parameters for the Step 3 select
                )
```

This version uses **anonymous variables**—result values which we don't give names to (so are anonymous), but instead immediately use as the arguments to another function. We've used these frequently with the `print()` function and with filters (those vectors of `TRUE` and `FALSE` values), and even the `max(mpg)` in Step 2 above is an anonymous variable!

This _nested_ version performs the same results as the _temporary variable_ version without creating the extra variables, but even with only 3 steps it can get quite complicated to read—in a large part because you have to think about it "inside out", with the stuff in the middle evaluating first.

This will obviously become undecipherable for more involved operations. Luckily, the pipe operator will provide us with a more clean (and cleaver) way of achieving the above task.

### The Pipe Operator
Luckily, `dplyr` provides a cleaner and effective way of achieving the same task (that is, using the result of one function as a parameter to the next). The **Pipe Operator** (**`>%>`**) indicates that the result from the first function operand should be passed in as **the first argument** to the next function operand!

As a simple example:
```r
# nested version: evaluate c(), then max(), then print()
print( max( c(2, 0, 1) ) )

# pipe version
c(1,2,3) %>%   # do first function
  max() %>%   # which becomes the _first_ argument to the next function
  print()  # which becomes the _first_ argument to the next function
```

Or as another version of the above data wrangling:

```r
# Preparation: add a column that is the car name
mtcars.named <- mutate(mtcars, car.name = row.names(mtcars))

best.car.name <- filter(mtcars.named, cyl == 4) %>%  # Step 1
  filter(four.cyl, mpg == max(mpg)) %>%  # Step 2
  select(best.four.cyl, car.name)
```

- Yes, the `%>%` operator is awkward to type and takes some getting use to (especially compared to the command-line's use of `|` to pipe). However, you can ease typing either by noticing that you hold down the `shift` key for all 3 characters, or by using the [RStudio keyboard shortcut](https://support.rstudio.com/hc/en-us/articles/200711853-Keyboard-Shortcuts) `cmd + shift + m`.

The pipe operator is part of the `dplyr` package (it is only available if you load that package), but it will work with _any_ function, not just `dplyr` ones! This syntax, while slightly odd, can complete change and simply the way you write code to ask questions about your data!

For an introduction to and practice working with the pipe operator, see [exercise-3](exercise-3).

## Grouped Operations
`dplyr` functions are powerful, but they are truly awesome when you can apply them to **groups of rows** within a data set. For example, the above use of `summarize()` isn't particularly useful since it just gives a single summary for a given column (which we could have done anyway). However, a **grouped** operation would allow us to compute the same summary measure (`mean`, `median`, `sum`, etc.) automatically for multiple groups of rows, enabling us to ask more nuanced questions about our data set.

The **`group_by()`** operation allows you to break a data frame down into _groups_ of rows, which can then have the other verbs (e.g., `summarize`, `filter`, etc). applied to each one.

![Diagram of the group_by function](img/group_by.png)

```r
# Get summary statistics by city
city.summary <- group_by(pollution, city) %>%
  summarize( # first parameter (the data frame) is recieved from the pipe
    mean = mean(amount),
    sum = sum(amount),
    n = n()
  )
```

As another example, if you were using the `mtcars` dataset, you may want to answer this question:

> What are the differences in mean miles per gallon for cars with different numbers of gears (3, 4, or 5)?

This simple question requires computing the mean for different subsets of the data. Rather than explicitly breaking your data into different groups (a.k.a bins or chunks) and running the same operations on each, you can use the `group_by()` function to accomplish this in a single command:

```r
# Group cars by gear number, then compute the mean and median mpg
gear.summary <- group_by(mtcars, gear) %>%  # group by gear
                 summarise(mean = mean(mpg))  # calculate mean
# computing the difference between scores is done elsewhere (or by hand!)
```

Thus grouping can allow you to quickly and easily compare different subsets of your data!

For an introduction to and practice working with grouped operations, see [exercise-5](exercise-5).

## Joins
When working with real-world data, you'll often find that that data is stored across _multiple_ files or data frames. This can be done for a number of reasons. For one, it can help to reduce memory usage (in the same manner as **factors**): for example, if we had a data frame containing information on students enrolled in university courses, we might store information about each course (the professor, meeting time, and classroom) in a separate data frame rather than duplicating that information for every student that takes the same course. We also may simply want to keep our information organized: have student information in one file, and course information in another.

- This separation and organization of data is a core concern in the design of [relational databases](https://en.wikipedia.org/wiki/Relational_database); check out the iSchool's Database courses for more information!

But at some point, we'll want to access information from both data sets (e.g., we need to figure out a student's schedule), and thus need a way to combine the data frames. This process is called a **join** (because we are "joining" the data frames together). When we perform a join, we identify **columns** which are present in both tables. Those column values are then used as **identifiers** to determine which rows in each table correspond to one another, and thus will be combined into a row in the resulting joined table.

The **`left_join()`** operation is one example of a join. This operation looks for matching columns between the two data frames, and then returns a new data frame that is the first ("left") operand with extra columns from the second operand added on.

![Diagram of the left_join function](img/left_join.png)

```r
# Combine (join) songs and artists data frames
left_join(songs, artists)
```

To understand how this works, consider a specific example where we have a table of student ids and their contact information. We also have a separate table of student ids and their majors (your institution very well may store this information in separate tables for privacy or organizational reasons).

```r
# Table of contact information
student.contact <- data.frame(
    student.id = c(1, 2, 3, 4),  # id numbers
    email =<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>)

# Table of information about majors
student.majors <- data.frame(
  student.id = c(1, 2, 3),  # id numbers
  major = c('sociology', 'math', 'biology')
)
```

Notice that both tables have a `student.id` column, allowing us to "match" the rows from the `student.contact` table to the `student.majors` table and merge them together:

```r
# Join tables by the student.id column
merged.student.info <- left_join(student.contact, student.majors)
                        #    student.id          email     major
                        # 1          1<EMAIL_ADDRESS>sociology
                        # 2          2<EMAIL_ADDRESS>    math
                        # 3          3<EMAIL_ADDRESS> biology
                        # 4          4<EMAIL_ADDRESS>    <NA>
```

When we perform this **left join**, R goes through each row in thetable on the "left" (the first parameter), looking at the shared column (`student.id`). For each row, it looks for a corresponding value in `student.majors$student.id`, and if it fines one then it adds any data from columns that are in `student.majors` but _not_ in `student.contact` (e.g., `major`) to new columns in the resulting table, with values from whatever the matching row was. Thus student \#1 was given a `major` of "sociology", student \#2 was given a `major` of "math", and student \#4 was given a `major` of `NA` (because that student had no corresponding row in `student.majors`!)

- In short, a **left join** returns all of the rows from the first table, along with all of the columns from both tables.

R will join tables by any and all shared columns. However, if the names of your columns don't match specifically, you can also specify a `by` argument indicating which columns should be used for the matching:

```r
# Use the named `by` parameter to specify (a vector of) columns to match on
left_join(student.contact, student.majors, by="student.id")  # column name IS a string here!
```

Notice that because of how we've described a left join, **the order matters!!**. The resulting table only has rows for elements in the _left_ (first) table; any unmatched elements in the second table are lost. If you switch the order of the operands, we would only have information for students with majors:

```r
# Join tables by the student.id column
merged.student.info <- left_join(student.majors, student.contact)  # switched order!
                        #   student.id     major          email
                        # 1          1 sociology<EMAIL_ADDRESS>                        # 2          2      math<EMAIL_ADDRESS>                        # 3          3   biology<EMAIL_ADDRESS>```

We don't have any information for student \#4, because they didn't have a record in the left-hand table!

Because of this behavior, `dplyr` (and relational database systems in general) provide a number of different kinds of joins, each of which influences _which_ rows are included in the final table. Note that in any case, _all_ columns from _both_ tables will be included, with rows taking on any values from their matches in the second table.

- **`left_join`** All rows from the first (left) data frame are returned. That is, we get all the data from the left-hand table, with extra column values added from the right-hand table. Left-hand rows without a match will have `NA` in the right-hand columns.

- **`right_join`** All rows from the second (right) data frame are returned. That is, we get all the data from the right-hand table, with extra column values added from the left-hand table. Right-hand rows without a match will have `NA` in the left-hand columns. This is the "opposite" of a `left_join`, and the equivalent of switching the operands.

- **`inner_join`** Only rows in **both** data frames are returned. That is, we get any rows that had matching observations in both tables, with the column values from both tables. There will be no additional `NA` values created by the join. Observations from the left that had no match in the right, or observations in the right that had no match in the left, will not be returned at all.

- **`full_join`** All rows from **both** data frames are returned. That is, we'll get a row for any observation, whether or not it matched. If it happened to match we'll have values from both tables in that row. Observations without a match will have `NA` in the columns from the other table.

The key to deciding between these is to think about what set of data you want as your set of observations, and which columns you'd be okay with being `NA` if a record is missing.

Note that these are all _mutating joins_, which add columns from one table to another. `dplyr` also provides _filtering joins_ which exclude rows based on whether they have a matching observation in another table, and _set operations_ which combine observations as if they were set elements. See [the documentation](https://cran.r-project.org/web/packages/dplyr/vignettes/two-table.html) for more detail on these options, but in this class we'll be primarily focusing on the mutating joins described above.

For an introduction to and practice working with joins, see [exercise-6](exercise-6).

## Non-Standard Evaluation vs. Standard Evaluation
One of the features that makes `dplyr` such a clean and attractive way to write code is that inside of each function, we've been able to write column variable names **without quotes**. This is called [**non-standard evaluation**](https://cran.r-project.org/web/packages/dplyr/vignettes/nse.html) (it is _not_ the _standard_ way that code is _evaluated_, or interpreted), and is useful primarily because of how it reduces typing (along with some other benefits when working with databases).

However, there are times when you want to use `dplyr` with **standard evaluation**: that is, you want to be able to specify column names as normal _values_ (in quotes). Luckily, `dplyr` supplies a set of functions that support standard evaluation. These have the exact same names as the normal verb functions, except are followed by an underscore (**`_`**):

```r
# Normal, non-standard evaluation version
mpg <- select(mtcars, mpg)

# Standard-evaluation version (same result)
mpg <- select_(mtcars, 'mpg')  # with quotes! 'mpg' is a normal value!

# Normal, non-standard evaluation version of equations
mean.mpg <- summarize(mtcars, mean(mpg))

# Standard-evaluation version of equations (same result)
mean.mpg <- summarize_(mtcars, 'mean(mpg)')
```

- Yes, it does feel a bit off that the "normal" way of using `dplyr` is the "non-standard" way.

The most common use-case for this system is when you're storing the _name of a column of interest_ in a variable:

```r
# Which column you're interested in
which.column <- 'mpg'

# Use standard evaluation to execute function:
my.column <- select_(mtcars, which.column)
```

Because we're using standard evaluation, `which.column` isn't treated as the _name_ of the column (it's _not_ refering to `mtcars$which.column`, a.k.a. `mtcars[['which.column']]`), but is instead a normal variable which contains the name of the column in it (it _is_ referring to `mtcars[[which.column]]`)


text:
# COL226 Assignment 3 #
## Sayam Sethi (2019CS10399) ##

* To build the language compiler, run `make build`
* To run the compiler for a single file, run `./a3 <file>`
* To run the compiler for all testcases, execute `./run.sh`


text:
# Bipolaris zizaniae (Y. Nisik.) Shoemaker, 1959 SPECIES

#### Status
SYNONYM

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

#### Published in
Can. J. Bot. 37: 885 (1959)

#### Original name
Helminthosporium zizaniae Y. Nisik., 1929

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Ascomycota/Dothideomycetes/Pleosporales/Pleosporaceae/Drechslera/Drechslera zizaniae/ Syn. Bipolaris zizaniae/README.md

repo_name: mdoering/backbone


text:
---
title: Zoom
page_title: Zoom
description: Zoom
slug: radimageeditor-features-zoom
tags: zoom
published: True
position: 11
---

# Zoom

The Zoom tool allows you to set zoom to the image. You can use the track bar or select specific value from the drop-down list.

![WinForms RadImageEditor Zoom Option](images/image-editor-zoom001.gif)

# See Also

* [Getting Started]({%slug radimageeditor-getting-started%})
* [Structure]({%slug radimageeditor-structure%})
* [Properties and Events]({%slug radimageeditor-properties-and-events%})

repository: telerik/winforms-docs

repo_name: telerik/winforms-docs