text:
An extension of the builtin [RadioButton](/docs/controls/builtin/RadioButton) control which allows to specify various Bootstrap classes.

<http://getbootstrap.com/css/#forms-controls>

repository: Mitroz/dotvvm-docs

branch_name: refs/heads/latest

gha_language: C#

repo_name: Mitroz/dotvvm-docs


text:
---
permalink: "/Try-our-download-improvements-with-Samsung-Internet-Beta-v6-4/"
title: Try our download improvements with Samsung Internet Beta v6.4
category: "Browser Features"
cover: img.jpg
author: Peter O'Shaughnessy
authorImg: https://miro.medium.com/fit/c/240/240/1*ky-noIIf_ZZIoGDsvfW3AA.jpeg
---

### Try our download improvements with Samsung Internet Beta v6.4

Our latest [Samsung Internet Beta](https://play.google.com/store/apps/details?id=com.sec.android.app.sbrowser.beta) v6.4 is now rolling out to the Play Store and Galaxy Apps Store. Along with some bug fixes, it contains a number of improvements related to file downloads.

Firstly, now when you download a file from a website, you’ll get a prompt to allow you to rename the file:

![](https://cdn-images-1.medium.com/max/800/1*APDha9oKP87af8d2QFu3Hw.png)

The new file download prompt

Once it’s downloaded, there’s a new prompt that lets you open it:

![](https://cdn-images-1.medium.com/max/800/1*7Ac8Ql51HPUW3ATfDShLbw.png)

For large downloads, as well as seeing the progress in the notification (as before), you can also pause and resume the download directly in the notification UI. If you need to reveal these controls (it depends on the OS), you can swipe down on the notification with two fingers, or tap on the down arrow.

![](https://cdn-images-1.medium.com/max/800/1*EZ8ODvQED_UAeoRHHOTNmg.png)

Pause and resume downloads directly in the notification UI

There’s a new Download History UI too. Tapping on the notification will reveal a new page that displays your previous and current downloads. You can also access this page from `Bookmarks > History > Download history.` You can pause and resume downloads here too.

![](https://cdn-images-1.medium.com/max/800/1*SS2RTlC3e69U8_NXykUKOg.png)

You can also delete your download history from here if you wish:

![](https://cdn-images-1.medium.com/max/800/1*E0PZCCX3fukxPhDEvaqskA.png)

Hopefully by the time you [take a look](https://play.google.com/store/apps/details?id=com.sec.android.app.sbrowser.beta), you’ll see this latest version 6.4 available to download. (If not, please check again in a couple of days). Then please [let us know what you think](https://twitter.com/samsunginternet) of the updates and [tell us if you spot any bugs](https://github.com/SamsungInternet/support). Thanks and happy downloading!

Tagged in [Android](https://medium.com/tag/android), [Web](https://medium.com/tag/web), [Browsers](https://medium.com/tag/browsers), [Samsung](https://medium.com/tag/samsung), [Samsung Internet](https://medium.com/tag/samsung-internet)

By [Peter O'Shaughnessy](https://medium.com/@poshaughnessy) on [January 9, 2018](https://medium.com/p/7aa6730b066a).

[Read this article on Medium](https://medium.com/@poshaughnessy/try-our-download-improvements-with-samsung-internet-beta-v6-4-7aa6730b066a)

license: MIT

branch_name: refs/heads/master

extension: md

gha_language: HTML

gha_license_id: MIT

license_type: permissive


text:
#Chapter 3 The role of the project manager

The **project manager** is the person assigned by the performing
organization to lead the team that is responsible for the project
objectives.

The **talent triangle** focuses on three key skill sets:
- **Technical project management**
- **Leadership**
- **Strategic and business management**

repository: enroute/blog

repo_name: enroute/blog


text:
## Contributing to RouteComposer

We welcome contributions to the RouteComposer's repository.

Contributing can take many forms, but to make administering the process easier, we handle all contributions in one of two ways:

### Making Suggestions & Pointing Out Problems

Such contributions include:

- Reporting bugs
- Sending feature requests
- Pointing out typos

For these types of contributions, **please create a [GitHub Issue](https://guides.github.com/features/issues/) in the appropriate repo** containing the message that you'd like to convey.

### Improving the Codebase

This would include:

- Fixing bugs
- Tweaking project file settings
- Writing unit tests
- Submitting performance and other code improvements
- Adding new features
- Correct typos

To contribute in this way, **please [submit a pull request](https://help.github.com/articles/using-pull-requests/)** by:

1. [Forking the repo](https://help.github.com/articles/fork-a-repo/) to which you'd like to submit a contribution
2. Committing changes to your fork
3. Pushing your changes to GitHub
4. Submitting a pull request from your changes

If your pull request is related to something already tracked in a GitHub Issue, please be sure to note the issue number (and include a link to the issue page) in your pull request.

repository: ekazaev/route-composer

gha_language: Swift

repo_name: ekazaev/route-composer


text:
fu-scripts 🛠📦

CLI toolbox for common scripts for my projects

[![Build Status][build-badge]][build] [![Code Coverage][coverage-badge]][coverage]
[![version][version-badge]][package] [![downloads][downloads-badge]][npmcharts]
[![MIT License][license-badge]][license]

[![PRs Welcome][prs-badge]][prs] [![Code of Conduct][coc-badge]][coc]

[![Watch on GitHub][github-watch-badge]][github-watch]
[![Star on GitHub][github-star-badge]][github-star] [![Tweet][twitter-badge]][twitter]

## The problem

I do a bunch of open source and want to make it easier to maintain so many projects.

## This solution

This is a CLI that abstracts away all configuration for my open source projects for linting,
testing, building, and more.

## Table of Contents

- [Installation](#installation)
- [Usage](#usage)
  - [Overriding Config](#overriding-config)
  - [Flow support](#flow-support)
- [Inspiration](#inspiration)
- [LICENSE](#license)

## Installation

This module is distributed via [npm][npm] which is bundled with [node][node] and should be installed
as one of your project's `devDependencies`:

```
npm install --save-dev fu-scripts
```

## Usage

This is a CLI and exposes a bin called `fu-scripts`. I don't really plan on documenting or testing
it super duper well because it's really specific to my needs. You'll find all available scripts in
`src/scripts`.

This project actually dogfoods itself. If you look in the `package.json`, you'll find scripts with
`node src {scriptName}`. This serves as an example of some of the things you can do with
`fu-scripts`.

### Overriding Config

Unlike `react-scripts`, `fu-scripts` allows you to specify your own configuration for things and
have that plug directly into the way things work with `fu-scripts`. There are various ways that it
works, but basically if you want to have your own config for something, just add the configuration
and `fu-scripts` will use that instead of it's own internal config. In addition, `fu-scripts`
exposes its configuration so you can use it and override only the parts of the config you need to.

This can be a very helpful way to make editor integration work for tools like ESLint which require
project-based ESLint configuration to be present to work.

So, if we were to do this for ESLint, you could create an `.eslintrc` with the contents of:

```
{"extends": "./node_modules/fu-scripts/eslint.js"}
```

> Note: for now, you'll have to include an `.eslintignore` in your project until
> [this eslint issue is resolved](https://github.com/eslint/eslint/issues/9227).

Or, for `babel`, a `.babelrc` with:

```
{ "presets": ["fu-scripts/babel"] }
```

Or, for `jest`:

```js
const { jest: jestConfig } = require('fu-scripts/config');

module.exports = Object.assign(jestConfig, {
  // your overrides here

  // for test written in Typescript, add:
  transform: {
    '\\.(ts|tsx)$': '<rootDir>/node_modules/ts-jest/preprocessor.js',
  },
});
```

Or, for `commitlint`, a `commitlint.config.js` file or `commitlint` prop in package.json:

```js
// commitlint.config.js or .commitlintrc.js
const { commitlint: commitlintConfig } = require('fu-scripts/commitlint');

module.exports = {
  ...commitlintConfig,
  rules: {
    // overrides here
  },
};
```

```json
// package.json
{
  "commitlint": {
    "extends": ["./node_modules/fu-scripts/commitlint"],
    "rules": {
      // your overrides here
      // https://commitlint.js.org/#/reference-rules
    }
  }
}
```

> Note: `fu-scripts` intentionally does not merge things for you when you start configuring things
> to make it less magical and more straightforward. Extending can take place on your terms. I think
> this is actually a great way to do this.

### Flow support

If the `flow-bin` is a dependency on the project the `@babel/preset-flow` will automatically get
loaded when you use the default babel config that comes with `fu-scripts`. If you customised your
`.babelrc`-file you might need to manually add `@babel/preset-flow` to the `presets`-section.

## Inspiration

This is inspired by `react-scripts`.

## LICENSE

MIT

[npm]: https://www.npmjs.com/
[node]: https://nodejs.org
[build-badge]: https://img.shields.io/travis/fashionunited/fu-scripts.svg?style=flat-square
[build]: https://travis-ci.org/fashionunited/fu-scripts
[coverage-badge]:
  https://img.shields.io/codecov/c/github/fashionunited/fu-scripts.svg?style=flat-square
[coverage]: https://codecov.io/github/fashionunited/fu-scripts
[version-badge]: https://img.shields.io/npm/v/fu-scripts.svg?style=flat-square
[package]: https://www.npmjs.com/package/fu-scripts
[downloads-badge]: https://img.shields.io/npm/dm/fu-scripts.svg?style=flat-square
[npmcharts]: http://npmcharts.com/compare/fu-scripts
[license-badge]: https://img.shields.io/npm/l/fu-scripts.svg?style=flat-square
[license]: https://github.com/fashionunited/fu-scripts/blob/master/LICENSE
[prs-badge]: https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square
[prs]: http://makeapullrequest.com
[donate-badge]: https://img.shields.io/badge/$-support-green.svg?style=flat-square
[coc-badge]: https://img.shields.io/badge/code%20of-conduct-ff69b4.svg?style=flat-square
[coc]: https://github.com/fashionunited/fu-scripts/blob/master/other/CODE_OF_CONDUCT.md
[github-watch-badge]:
  https://img.shields.io/github/watchers/fashionunited/fu-scripts.svg?style=social
[github-watch]: https://github.com/fashionunited/fu-scripts/watchers
[github-star-badge]: https://img.shields.io/github/stars/fashionunited/fu-scripts.svg?style=social
[github-star]: https://github.com/fashionunited/fu-scripts/stargazers
[twitter]:
  https://twitter.com/intent/tweet?text=Check%20out%20fu-scripts!%20https://github.com/fashionunited/fu-scripts%20%F0%9F%91%8D
[twitter-badge]:
  https://img.shields.io/twitter/url/https/github.com/fashionunited/fu-scripts.svg?style=social

repository: fashionunited/fu-scripts

repo_name: fashionunited/fu-scripts


text:
---
layout: post
title: A gentle introduction to OmicsPLS
subtitle: How to do cross-validation with OmicsPLS
gh-repo: selbouhaddani/OmicsPLS
gh-badge: [star, fork, follow]
tags: [OmicsPLS, cross-validation, Joint Principal Components, data integration, O2PLS]
comments: true
---

Implementing software for omics data integration can be challenging. The statistical theory is often complex, and the code needs to run fast. (To make things worse, there are many definitions and solutions for omics data integration!) Our data integration approach in OmicsPLS has statistical theory 'under the hood' (see [the article](https://doi.org/10.1186/s12859-015-0854-z)) and can be efficiently programmed. To actually use OmicsPLS in your analysis, there is some help available via the vignettes [with an actual data example](https://github.com/selbouhaddani/OmicsPLS/blob/master/OmicsPLS_vignette_realdata.pdf) and [without](https://github.com/selbouhaddani/OmicsPLS/blob/master/vignettes/OmicsPLS_vignette.pdf), and of course [the manual](https://rdrr.io/cran/OmicsPLS/man/). Still I believe that a basic introduction to the main functions in OmicsPLS will help you with getting everything out of this package.

In this blog, I'll go through one of the functions that you will need at the start of the analysis: the cross-validation (CV) function `crossval_o2m_adjR2`.

# The cross-validation function

From the [manual](https://rdrr.io/cran/OmicsPLS/man/crossval_o2m_adjR2.html), we can see the full CV function and its arguments:

    crossval_o2m_adjR2(X, Y, a, ax, ay, nr_folds, nr_cores = 1,
    stripped = TRUE, p_thresh = 3000, q_thresh = p_thresh,
    tol = 1e-10, max_iterations = 100)

First of all, make sure your omics datasets are stored in `X` and `Y`, with subjects across the rows (sometimes called subjects, or replicates) and variables across the columns (relations are sought between the variables, e.g. genes).

Now the question is, how many components do you need?

_Brief recap: What is a component?_ Each component represents a combination of variables, say genes. A joint component in `X` is a weighted combination of genes that has optimal covariance with another joint component in `Y`. Sometimes it helps to see a combination of genes as being a data-derived genetic pathway. The weights indicate how important each gene is in that component. For more information, [read the vignette](https://github.com/selbouhaddani/OmicsPLS/blob/master/OmicsPLS_vignette_realdata.pdf).

With CV, you can try out several combinations of component numbers and see which one yields the best fit. Keeping this idea in mind, you specify some integers for `a`, `ax`, and `ay`. For example, take `a=1:3`, `ax=0:2` and `ay=0:2`. A good range depends of course on the data application.

The next parameter is `nr_folds`, specifying in how many slices the rows will be cut. If you cut a pizza in 2 slices, you have 1 for fitting and 1 for independent tasting. Note that you need 2 rounds, first you fit the first slice and taste the second. Then you fit the second slice, and taste the first. Now replace the word "pizza" with "rows/subjects" and "tasting" with "testing" and you have a description of how CV works. Say we cut the pizza in 10 slices, then we can use 9 for fitting and 1 for tasting. And you can use each slice for tasting, making the total number of fitting and tasting to be 10. Of course, you need more rows to cut all slices, and choosing 1 slice leaves you without tasting slice. So for `nr_folds`, choose something between 2 and `nrow(X)`. Typically one chooses 5 or 10, but know that more slices takes more time.

The last argument of interest is `nr_cores`. If you have a computer with multiple cores (which you have, unless you've been hiding in a bunker the past decades), you can use let each core cut its own pizza and do the tasting. Be careful when `X` and `Y` are very large, and you are on a Windows machine! These matrices will be copied, quickly filling up your RAM.

# Summary

The other arguments are not so exciting, and you usually don't need to adjust them. So to summarize:
1. Input your data `X` and `Y`
2. Choose a couple of integers that you want to try out
3. Choose the number of slices
4. Choose the number of parallel workers (defaults to 1)

If you run the [example for the CV function](https://rdrr.io/cran/OmicsPLS/man/crossval_o2m_adjR2.html), you'll get something like this:

    minimum is at n = 1
    Elapsed time: 0.51 sec
           MSE n nx ny
    1 1.969997 1  1  1
    2 2.087187 2  2  1
    3 2.093943 3  2  2
    4 2.057414 4  1  1

The advice based on CV is here: take 1 joint component, and also 1 specific component for `X` and `Y`. Now you can proceed to the `o2m` function, and use these numbers of components.

****

Questions, comments, tips? Let me know!


text:
---
layout: page
title: About VocabHunter
short_title: About
permalink: /about/
description: About VocabHunter, acknowledgements and thanks
image: /assets/VocabHunter-About.png
ref: about
---

VocabHunter is a system to help learners of foreign languages.  See the [download] page for details on how to download and run the program.  You can follow VocabHunter on Twitter at [@{{site.twitter.username}}]({{site.twitter.link}}).

The system is Open Source Software, published under the [Apache Licence, Version 2.0].  You can find the source code on GitHub [here][GitHub].

[Adam Carroll] is the principal author of VocabHunter.

# Technical Articles

* [Installable Java Apps with jpackage] - There is a separate installer for Mac, Linux and Windows, each one tailored to the operating system in question.  These installable bundles are self-contained so that the user doesn't need to have to worry about first installing Java or any other special setup.  This article explains how this was achieved using _jpackage_.
* [Read (Almost) Any Document in Java] - VocabHunter uses Apache Tika to read documents in a wide variety of formats ranging from Microsoft Word through to PDF.  This article explains how it is done.
* [How JavaFX was used to build a desktop application] (King Tech Blog) - A detailed look at several important features of JavaFX using VocabHunter as an example.
* [Migrating to JUnit 5] - How the VocabHunter project was updated to use JUnit 5 for testing.  This article explains the changes that were made, the problems that were encountered and how they were solved.
* [Dependency Injection in JavaFX] - How to Gluon Ignite and Google Guice are used for the  Dependency Injection in VocabHunter.
* [User Interface Testing with TestFX] - A guide to automating user interface tests using TestFX.  VocabHunter includes a complete automated GUI test suite and here you can learn how it works.
* [Building a JavaFX Search Bar] - How the user interface for the VocabHunter search bar works with details of the use of ControlsFX in giving the bar a distinctive style.
* [VocabHunter – A tool for learners of foreign languages] (King Tech Blog) - An introduction to some of the technologies being used in VocabHunter.

# Acknowledgements and Thanks

Like all good Open Source projects, VocabHunter builds on the software and work of others.  This includes but is not limited to:

* The user interface of VocabHunter is built with the [JavaFX], now developed under the Open Source OpenJFX project.
* [TestFX][TestFXProject] is used for the automated GUI test.  The detailed guide [User Interface Testing with TestFX] explains how this works.
* [ControlsFX] is used for some of the GUI components including the status bar.
* The [Apache Tika] project provides the components that make it possible to read a wide variety of document formats.  You can learn more about this in the article [Read (Almost) Any Document in Java].
* VocabHunter uses various icons from the [Font Awesome] set.
* Dependency Injection is handled with [Gluon Ignite] and [Guice].  You can find out all about this in the article [Dependency Injection in JavaFX].
* [JUnit] is used as the principle testing framework.  [Migrating to JUnit 5] explains how the VocabHunter project was migrated to the latest verson of JUnit.

Finally, some acknowledgements for this website:

* Output from the [Simple Sharing Buttons Generator] was adapted for the social network sharing buttons on this site.
* The icons for the sharing buttons come from the [Social Flat Rounded Rects] set by [Aha-Soft].

[Adam Carroll]:https://github.com/AdamCarroll/
[download]:/download
[Apache Licence, Version 2.0]:http://www.apache.org/licenses/LICENSE-2.0
[GitHub]:https://github.com/VocabHunter/VocabHunter

[Dependency Injection in JavaFX]:/2016/11/13/JavaFX-Dependency-Injection.html
[User Interface Testing with TestFX]:/2016/07/27/TestFX.html
[Building a JavaFX Search Bar]:/2017/01/15/Search-Bar.html
[Read (Almost) Any Document in Java]:/2017/04/30/Read-Any-Document-Format.html
[Migrating to JUnit 5]:/2017/10/17/migrating-to-junit-5.html

[VocabHunter – A tool for learners of foreign languages]:https://medium.com/techking/vocabhunter-a-tool-for-learners-of-foreign-languages-55c467a6250c
[How JavaFX was used to build a desktop application]:https://medium.com/techking/how-javafx-was-used-to-build-a-desktop-application-7d4c680d8dc
[Installable Java Apps with jpackage]:/2021/07/10/installable-java-apps-with-jpackage.html

[JavaFX]:https://openjfx.io/
[Apache Tika]:https://tika.apache.org/
[TestFXProject]:https://github.com/TestFX/TestFX
[ControlsFX]:https://github.com/controlsfx/controlsfx
[Font Awesome]:https://fortawesome.github.io/Font-Awesome/
[Gluon Ignite]:http://gluonhq.com/labs/ignite/
[Guice]:https://github.com/google/guice
[JUnit]:http://junit.org/

[Simple Sharing Buttons Generator]:https://simplesharingbuttons.com/
[Social Flat Rounded Rects]:https://www.iconfinder.com/iconsets/social-flat-rounded-rects
[Aha-Soft]:http://www.aha-soft.com/

gha_language: CSS


text:
# Pipeless.GetActivityOnObjectResultEvents

## Properties

Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**_object** | [**ObjectReadable**](ObjectReadable.md) |  |
**relationship** | [**RelationshipWriteable**](RelationshipWriteable.md) |  |
**direction** | [**RelationshipDirection**](RelationshipDirection.md) |  |
**cursor** | **String** |  | [optional]

repository: pipeless/pipeless-node

branch_name: refs/heads/main

gha_language: JavaScript

repo_name: pipeless/pipeless-node


text:
# Population dynamics

Library to conduct experiements on population dynamics.

![Lotka-Volterra predator-prey system](./graphics/predator_prey.png)

## Installation

1. Create conda environment
```
conda env create -f environment.yml
```
2. Activate the environment
```
source activate population-dynamics
```
3. Install `causal` as a package within the environment
```
python install_causal.py develop
```
4. To setup all the log and results folders, run
```
bash setup.sh
```

repository: SumMuk/population-dynamics

repo_name: SumMuk/population-dynamics


text:
# Typescript Metaprogramming

This project is a result of research to understand Typescript metaprogramming capabilities. Resulting in showcase that Typescript Types are Turing Complete.

We showcase this by first simulating Addition and Substraction in [`math.ts`](./src/math.ts) and moving further into a more complext algorithm. Inside [`brackets.ts`](./src/brackets.ts) we run an algorith to detect whether a given bracket statement is valid or not.

For example `()(()())` is valid while `()())(` is not.

# Run the example

The best way to explore the examples is to use Visual Studio Code which can show you the result of each Type by hovering above it, as well as highlighting wrong results.

Otherwise you can use `tsc` to verify that it compiles:

```bash
yarn install
yarn build
```


text:
OLTP on MonkeyDB
================

# Description

We execute the following four benchmarks from [OLTPBench](https://github.com/oltpbenchmark/oltpbench) (source code included) on MonekyDB.
- TPCC
- smallbank
- voter
- Wikipedia

Then we check for the following assertions (subsection 8.1, 8.2) on these benchmarks and present the number of violations.
- A1-A12 (8.1) for TPCC
- A13 (8.2) for smallbank
- A14 (8.2) for voter
- A15-A17 (8.2) for wikipedia

# Implementation

## OLTPBench modifications

We use four benchmarks from OLTPBench. As our implementation does not support all the modern SQL syntax, we had to modify some parts of the original OLTPBench code to transform complicated SQL queries into a group of simplified queries. The modified codes are available in the following directories,
- `oltpbench/src/com/benchmarks/tpcc`
- `oltpbench/src/com/benchmarks/smallbank`
- `oltpbench/src/com/benchmarks/voter`
- `oltpbench/src/com/benchmarks/wikipedia`

## MonkeyDB

MonkeyDB is implemented in the Rust language. The source code is present inside the `src` directory. It consists of the following components:

- The SQL client-server connection is present in `src/server.rs`.
- The compliation of SQL to Key-Value (KV) api (Section 5) is in `src/sql.rs`.
- The KV store (Section 6) is implemented in `src/dis_kv.rs`.

# Results from paper

We present the results of our experiments as 2D plots, as in Figure 14 and 15 in the paper. This artifact reproduces the same plots. (Note that there is randomness involved, so the results will not reproduce exactly, but only approximately the same. The longer you run the artifact, the closer the results would be.)

# Option 1: Use Docker

This is the recommended option for running this artifact. We also provide a second option without docker later but this option is preferable because it ensures that the correct dependencies are installed.

We provide a [`Dockerfile`](Dockerfile) based on Archlinux docker image. _Docker containers are supported in any OS as long as [Docker is installed](https://docs.docker.com/get-started)._ Here are the necessary steps for building (takes 3 to 15 min):

```
# build the docker image. this includes `bash build.sh`
docker build . -t oopsla21_aec48
```

Next, start the container as follows.

```
# start the docker container
docker run -it oopsla21_aec48
```

We provide a script called `run.sh` for running the experiments. It requires the following parameters:

`bash run.sh <iterations> <benchmark> <consistency> <number of nodes> <timelimit>`

For example, in order to run `tpcc` under `causal` consistency, configured with `3` replicas for a total of `20` iterations, and a runtime limit of `10` secs per iteration, you may run the following command:

`bash run.sh 20 tpcc causal 3 10`

Possible values of parameters:
- benchmark: `tpcc`, `smallbank`, `voter`, `wikipedia`
- consistency: `causal`, `readcommitted`

You can pass comma-separated multiple values to run for multiple configurations together. For example:

`bash run.sh 20 tpcc,smallbank causal,readcommitted 3,5 10`

will run both `tpcc` and `smallbank` under `causal` and `readcommitted` consistency on `3` and `5` replica setup.

For kick-the-tires, run the following:

```
bash run.sh 15 wikipedia causal 3 10
```

It should finish in less than 5 minutes. (See below for expected output.)

_Logs will be generated in `log` directory._

For the full experiments:

```
bash run.sh 100 tpcc,smallbank,voter,wikipedia causal,readcommitted 2,3 10
```

It will take around 20 hours to finish and will most closely resemble the results presented in the paper (Fig. 14 and 15).

The output of this command with `20` iterations that we obtained on our machine is available at [`output_example.txt`](output_example.txt).

# Option 2: Self (non-docker) install

We require the following set of dependencies to be installed.
- A stable `rust` toolchain. (Install via [Rustup](https://www.rust-lang.org/tools/install))
- Apache Ant (for OLTPBench)
- MySQL console client (for OLTPBench)
- libssl, clang
- Bash and its utilities

We have verified that the following simple commands are enough to install these dependencies.
- If you are using apt, `apt install cargo ant mariadb-client libssl-dev clang bsdmainutils`
- If you are using pacman, `pacman -S rustup ant mariadb openssl clang base-devel --needed; rustup install stable`

From the current directory, execute `bash build.sh`. This will take around 3 to 15 min, depending on how many packages need to be installed.
For quick sanity checking, run:

```
bash run.sh 15 wikipedia causal 3 10
```

It should finish in less than 5 minutes. Use this to verify your setup. (See below for expected output.)

# Output

A sample output would look as follows,

```
$ bash run.sh 15 wikipedia causal 3 10
==========
Benchmark: wikipedia
----------
15 runs with time limit of 10 secs
On 3 nodes with "causal" consistency
Average duration per run: 9 secs
-----------------------------------------------
Assertion  #Violation among 15 runs  Violation%
A15        9                         60.00
A16        9                         60.00
-----------------------------------------------
```

It briefs about the parameters. Then it prints a table with the number of violations and the percentage of violations.
It also prints the average duration per run. If an assertion is not present in the table, its count (and also its percentage) is zero.
The output above shows that `A15` and `A16` were violated 60% times and `A17` was never violated.

# Runtime

This particular artifact was run on an Intel-i7 (gen 7) laptop with 16GB RAM.

The table below lists the average duration per run in seconds.

| benchmarks | tpcc | smallbank | voter | wikipedia |
|-|:-:|:-:|:-:|:-:|
| 2 nodes ; causal | 60 | 15 | 15 | 15 |
| 3 nodes ; causal | 60 | 15 | 15 | 15 |
| 2 nodes ; readcommitted | 170 | 15 | 15 | 15 |
| 3 nodes ; readcommitted | 170 | 15 | 15 | 15 |

# Futher usage

Our main contribution is MonkeyDB. It is just a `cargo` binary project. To run MonekeyDB, execute `cargo run --release` and MonkeyDB will serve SQL queries at default 3306 port. The binary will also be available in the `target/release` directory.

You can make MonkeyDB listen to some other port as `cargo run --release -- -a 8800` (check `cargo run --release -- --help`).

Once MonkeyDB is up, it is ready to connect to any MySQL client such as MySQL console client or even Rust MySQL client. You can connect to it concurrently from multiple terminals as well. MonkeyDB currently does not support everything that a modern MySQL server does. So complex SQL queries may not work with MonkeyDB currently.

## Special commands for MonkeyDB

There are few special commands for MonkeyDB.

| Query | Description |
|-|-|
|`reset`|Erase the whole database|
|`loading reset`|Reset the database back to loading phase and start weak consistency|
|`set consistency (readcommitted\|causal)`|Set consistency level|

1. By default, MonkeyDB starts with a Serializable level. At this point, we can load unambiguous initial data to MonkeyDB. We execute OLTPBench's loading phase at this point.
2. Then we send `loading reset` command to stop the loading phase and move to a weak consistent database. We execute OLTPBench's execution phase at this point. By default, the level is Causal Consistency.

### `commit` at the end of transactions

MonkeyDB processes each transaction in a sequence. The transaction requests possibly come in parallel. So a transaction on session A stays blocked, until a previously started transaction commits on session B. This is why the transactions must be committed before progressing on transactions in a different session.

For example, if we have two MySQL client consoles - `mysql1` and `mysql2`

If we query something on `mysql1` first.

```
mysql1> SELECT * FROM Table;
...
```

and, before _committing_ on `mysql1`, we query on `mysql2`.

```
mysql2> SELECT * FROM Table;
# stuck here
```

Then `mysql2` will stay blocked until `commit` is called on `mysql1`.

```
mysql1> commit;
```


text:
# INSTALL

- Clone project from GitHub: `https://github.com/iErdem1/mbta_departure_board.git`
- Create a virtual environment: `virtualenv venv -p python3.8`
- Switch to virtual environment: `source venv/bin/activate`
- Install project requirements: `pip install -r requirements.txt`
- Switch to `board` directory: `cd board`
- Create `.env` file via `.env_template`: `cp .env_template .env`
- Add your environment variables to `.env` file.
- Run the application: `python app.py`
- Go to `http://<IP_ADDRESS>:5000/departure_board` on your browser.

# PROJECT DESCRIPTION
- Project basically gets Boston North Station Commuter Rail departure data from MBTA API and then process related data and displays on a simple web app as `Departure Board` format.
- Data relied on MBTA API's `/predictions` endpoint results but mainly this data is incomplete. So, as a fallback, when the system couldn't get some relevant data from predictions, gets from `/schedules` endpoint.

# MISCELLANEOUS COMMENTS
- API's predictions are not reliable. They use live data from trains, so data like `departure_time` or `stops` is not reliable all the time.
- Train's `track` data supposed to be predicted by `/predictions` endpoint. But I was unable to reach that data. That's why track info declared as `TBD`.
- Normally you do not have to have an API key to make limited amount of requests but that is also unrilable. I got `HTTPError: 429` pretty often (program does not request a lot) so I decided to pass key to url. You can get key from https://api-v3.mbta.com/
- Board page refreshes itself in every 2 minutes. Normally I would pass the data with `AJAX` but I could not find time. Also, data stream is not huge so simple HTML refresh works fine on this project.
- Unit tests needs to be add.
- Frontend of the code needs a lot of improvements. For instance, I used `inline styling` for frontend because of the size of the project but makes code looks ugly. Frontend code could be more sophisticated.
- I could not find time to add `docstring`. If you have any further questions about the code itself, please do not hesitate to reach out.

# REFERENCES
- Digital-7 Font: http://www.styleseven.com/
- API: https://api-v3.mbta.com/
- Flask Documentation: https://flask.palletsprojects.com/en/2.0.x/
- Jinja Docs: https://jinja.palletsprojects.com/en/3.0.x/
- Bootstrap: https://getbootstrap.com/docs/5.1/


text:
rcon is a command line application that can be used as a Source RCON client.
It will send commands to the given server, and print the reply to stdout.

# Installation

[![Packaging status](https://repology.org/badge/vertical-allrepos/rcon.svg)](https://repology.org/project/rcon/versions)

## Homebrew

[@Holek](https://github.com/Holek) has made a
[homebrew tap](https://github.com/Holek/homebrew-rcon) for rcon, which you can
use like this:

```
$ brew install Holek/rcon/rcon
```

## Manual Installation

You require ```libbsd```, ```check```, ```cmake``` and ```glib-2.0```
to successfully build rcon. You have to install those from your distribution's
repository. For example:

- In Debian you'd do something like this:
```shell
$ apt-get install build-essential cmake check libbsd-dev libglib2.0-dev
```

- In Fedora you'd do something like this:
```shell
$ dnf install @c-development cmake check-devel libbsd-devel glib2-devel
```

Then build the project:

```shell
$ mkdir build
$ cd build
$ cmake .. -DCMAKE_INSTALL_PREFIX=/usr
$ make
$ sudo make install
```

A ```bash-completion``` script is available, but not installed by default.
If you use bash completion simply specify ```INSTALL_BASH_COMPLETION=ON``` on
the cmake command line:

```shell
$ cmake .. -DCMAKE_INSTALL_PREFIX=/usr -DINSTALL_BASH_COMPLETION=ON
```

## Debian package

If you prefer to build a Ubuntu/Debian package out of the source code: You can!
Just run the following command in the source code:

```
$ dpkg-buildpackage -b -uc -us
```

You will need the `dpkg-dev` and `debhelper` packages of course, which contain
`dpkg-buildpackage`, and all the dependencies as they are listed in the manual
installation section above.

# Documentation

The utility comes with a man page: ```rcon(1)```. View it with:
```man 1 rcon```.

# Usage

## Command Line

The command can be called from the command line directly, like so:

```
$ rcon -H somehost -p someport -P somepass status
```

rcon automatically concats all your arguments together into one command:

```
$ rcon -H somehost -p someport -P somepass sm plugins list
```

This sends the command "sm plugins list" to the server.

## Standard Input

If you wish to send more than one command to the server, don't specify one on
the command line. Instead give rcon a list of commands through standard input:

```shell
$ rcon -H somehost -p someport -P somepass <<EOS
status
sm plugins list
# This might be long!
cvarlist
EOS
```

In this mode lines starting with ```#``` are ignored. This allows rcon to be
used as a script interpreter. Just pass it the script file through stdin:

```shell
$ cat somescript.txt
# This is a comment
status

# and this too!
sm plugins list

cvarlist
```

And execute your script like this:

```shell
$ rcon -H somehost -p someport -P somepass < somescript.txt
# Or:
$ cat somescript.txt | rcon -H somehost -p someport -P somepass
```

## Security Concerns

Please note that the RCON protocol is not encrypted, meaning that your
passwords are transmitted in plain text to the server.

## Exit Code

The command exit with 0 on success, and some arbitrary non-zero exit code on
failure.

# Config file

You can also store your server credentials in a configuration file. The default
location for this file is ```$HOME/.rconrc```. You can specify an alternate
configuration file through the ```-c``` option. Entries from this configuration
file are referenced through the ```-s``` option.

Here is an example configuration file:

```
[somehost]
hostname = <IP_ADDRESS>
port = 27045
password = somepass
# remove the following line if the server
# is not minecraft, or set it to 'false'
minecraft = true
```

Now you can do:

```
$ rcon -s somehost status
```

# Notable Forks

[dad's variant](https://github.com/dad98253/rcon) is a fork of rcon that offers
an ncurses interface. Perfect for running it in a local or remote shell.

# See Also

* [RCON Protocol Specification](https://developer.valvesoftware.com/wiki/Source_RCON_Protocol)

gha_language: C


text:
redux-reducer-dispatcher
=========

This is a small module to help dispatch an action in a reducer asynchronously.

## Installation

  `npm install redux-reducer-dispatcher`

## Usage

```javascript
import { applyMiddleware, createStore } from 'redux';

import reducerDispatcherMiddleware from "redux-reducer-dispatcher";

const store = createStore(
  reducer,
  applyMiddleware(reducerDispatcherMiddleware)
)

// Note passing middleware as the third argument requires<EMAIL_ADDRESS>```

```javascript
//Reducer Function

export default function(state: any = initialState, action: Function) {
  switch (action.type) {
    case "XYZ":
      action.reducerDispatch({ type: "newActionType" });
      return {
        ...state
        //XYZ: ZYX,
      };
  }
}
```

repository: arjupba/redux-reducer-dispatcher

repo_name: arjupba/redux-reducer-dispatcher


text:
# go-libp2p-gorpc

[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](https://protocol.ai)
[![](https://img.shields.io/badge/project-libp2p-yellow.svg?style=flat-square)](https://libp2p.io)
[![](https://img.shields.io/badge/freenode-%23libp2p-yellow.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23libp2p)
[![GoDoc](https://pkg.go.dev/badge/github.com/libp2p/go-libp2p-gorpc)](https://pkg.go.dev/github.com/libp2p/go-libp2p-gorpc)
[![Codecov](https://codecov.io/gh/libp2p/go-libp2p-gorpc/badge.svg)](https://codecov.io/gh/libp2p/go-libp2p-gorpc)
[![Discourse posts](https://img.shields.io/discourse/https/discuss.libp2p.io/posts.svg)](https://discuss.libp2p.io)

> Simple Go RPC for libp2p.

`go-libp2p-gorpc` provides RPC support on top of libp2p in the same way that [net/rpc](https://golang.org/pkg/net/rpc) does on HTTP with a few additional features like:

- Streaming RPC calls using channels.
- Contexts and async calls.

## Table of Contents

- [Install](#install)
- [Usage](#usage)
- [Contribute](#contribute)
- [License](#license)

## Install

This module can be installed with `go get`:

```
> go get github.com/libp2p/go-libp2p-gorpc
```

This repo is [gomod](https://github.com/golang/go/wiki/Modules)-compatible, and users of
go 1.11 and later with modules enabled will automatically pull the latest tagged release
by referencing this package. Upgrades to future releases can be managed using `go get`,
or by editing your `go.mod` file as [described by the gomod documentation](https://github.com/golang/go/wiki/Modules#how-to-upgrade-and-downgrade-dependencies).

## Usage

Documentation for this module is maintained in [pkg.go.dev](https://pkg.go.dev/github.com/libp2p/go-libp2p-gorpc).

There are also examples inside the [examples directory](./examples)

## Contribute

PRs accepted.

Small note: If editing the README, please conform to the [standard-readme](https://github.com/RichardLitt/standard-readme) specification.

## License

MIT

---

The last gx published version of this module was: 1.1.4: QmcJCApoEsCJJap2iS1os9GFX5EuRrfuPeZdjCopz2SyPm

gha_language: Go

gha_license_id: NOASSERTION


text:
![STAR Module Architecture Diagram](https://i.ibb.co/TqqhDgh/star-arch.jpg)

Our solution consists the deployment of a single Techman 12 cobot mounted on a large table with two defined
spaces (vision system selection area and stitching/ taping area). The function of the is to pick (using a vacuum
gripper) the acoustic parts from selection area, present the part to a stitching machine or taping machine. The
robot then guides the part through either machine while a coordinated operation edge tapes or stitches the part.
Finally, the cobot will place the part down for manual removal and QC checks.

repository: ramp-eu/STAR

repo_name: ramp-eu/STAR


text:
### 2014-10-17

#### objective-c
* [
      facebook
      /
      AsyncDisplayKit
](https://github.com/facebook/AsyncDisplayKit):
      Smooth asynchronous user interfaces for iOS apps.

* [
      dogo
      /
      SCLAlertView
](https://github.com/dogo/SCLAlertView):
      Beautiful animated Alert View. Written in Swift but ported to Objective-C

* [
      ArthurGuibert
      /
      FSLineChart
](https://github.com/ArthurGuibert/FSLineChart):
      A line chart library for iOS

* [
      davbeck
      /
      CacheKit
](https://github.com/davbeck/CacheKit):
      Simple and flexible caching mechanism for in memory and persistent caches.

* [
      facebook
      /
      Shimmer
](https://github.com/facebook/Shimmer):
      An easy way to add a simple shimmering effect to any view in an iOS app, which is particularly useful as an unobtrusive loading indicator.

* [
      artemstepanenko
      /
      CrossNavigation
](https://github.com/artemstepanenko/CrossNavigation):
      Any side navigation.

* [
      smileyborg
      /
      PureLayout
](https://github.com/smileyborg/PureLayout):
      The ultimate API for iOS & OS X Auto Layout — impressively simple, immensely powerful. Objective-C and Swift compatible.

* [
      zats
      /
      Voltron
](https://github.com/zats/Voltron):
      When UICollectionViewCell needs to be a UIViewController!

* [
      tdginternet
      /
      TGCameraViewController
](https://github.com/tdginternet/TGCameraViewController):
      Custom camera with AVFoundation. Beautiful, light and easy to integrate with iOS projects.

* [
      lucholaf
      /
      Auto-Importer-for-Xcode
](https://github.com/lucholaf/Auto-Importer-for-Xcode):
      Plugin for Xcode to quickly import your headers on the fly.

* [
      carsonperrotti
      /
      CNPPopupController
](https://github.com/carsonperrotti/CNPPopupController):
      CNPPopupController is a simple and versatile class for presenting a custom popup in a variety of fashions. It includes a many options for controlling how your popup appears and behaves.

* [
      dfmuir
      /
      KINWebBrowser
](https://github.com/dfmuir/KINWebBrowser):
      A web browser module for your iOS apps.

* [
      shinydevelopment
      /
      SimulatorStatusMagic
](https://github.com/shinydevelopment/SimulatorStatusMagic):
      Clean up your status bar for taking screenshots on the iOS simulator.

* [
      mamaral
      /
      Wethr
](https://github.com/mamaral/Wethr):
      Wethr provides developers the ability to add location-based current weather conditions to their views as simply as adding any UIView.

* [
      AFNetworking
      /
      AFNetworking
](https://github.com/AFNetworking/AFNetworking):
      A delightful iOS and OS X networking framework

* [
      rs
      /
      SDWebImage
](https://github.com/rs/SDWebImage):
      Asynchronous image downloader with cache support with an UIImageView category

* [
      jamztang
      /
      CSStickyHeaderFlowLayout
](https://github.com/jamztang/CSStickyHeaderFlowLayout):
      UICollectionView replacement of UITableView. Do even more like Parallax Header, Sticky Section Header. Made for iOS 7.

* [
      slackhq
      /
      SlackTextViewController
](https://github.com/slackhq/SlackTextViewController):
      A drop-in UIViewController subclass with a growing text input view and other useful messaging features

* [
      realm
      /
      realm-cocoa
](https://github.com/realm/realm-cocoa):
      Realm is a mobile database: a replacement for Core Data & SQLite

* [
      xissburg
      /
      XBImageFilters
](https://github.com/xissburg/XBImageFilters):
      OpenGL ES 2-based image and real-time camera filters for iOS

* [
      ReactiveCocoa
      /
      ReactiveCocoa
](https://github.com/ReactiveCocoa/ReactiveCocoa):
      A framework for composing and transforming streams of values

* [
      BradLarson
      /
      GPUImage
](https://github.com/BradLarson/GPUImage):
      An open source iOS framework for GPU-based image and video processing

* [
      ccgus
      /
      fmdb
](https://github.com/ccgus/fmdb):
      A Cocoa / Objective-C wrapper around SQLite

* [
      facebook
      /
      facebook-ios-sdk
](https://github.com/facebook/facebook-ios-sdk):
      Use the Facebook SDK for iOS to integrate with Facebook, help build engaging social apps, and get more installs.

* [
      Cocoanetics
      /
      DTCoreText
](https://github.com/Cocoanetics/DTCoreText):
      Methods to allow using HTML code with CoreText

#### go
* [
      gopherjs
      /
      gopherjs
](https://github.com/gopherjs/gopherjs):
      A compiler from Go (golang.org) to JavaScript for running Go code in a browser

* [
      docker
      /
      docker
](https://github.com/docker/docker):
      Docker - the open-source application container engine

* [
      syncthing
      /
      syncthing
](https://github.com/syncthing/syncthing):
      Open Source Continuous File Synchronization

* [
      hokaccha
      /
      sprinkler
](https://github.com/hokaccha/sprinkler):
* [
      google
      /
      cadvisor
](https://github.com/google/cadvisor):
      Analyzes resource usage and performance characteristics of running containers.

* [
      GoogleCloudPlatform
      /
      kubernetes
](https://github.com/GoogleCloudPlatform/kubernetes):
      Container Cluster Manager

* [
      coreos
      /
      etcd
](https://github.com/coreos/etcd):
      A highly-available key value store for shared configuration and service discovery

* [
      influxdb
      /
      influxdb
](https://github.com/influxdb/influxdb):
      Scalable datastore for metrics, events, and real-time analytics

* [
      deis
      /
      deis
](https://github.com/deis/deis):
      Your PaaS. Your Rules.

* [
      flynn
      /
      flynn
](https://github.com/flynn/flynn):
      A next generation open source platform as a service (PaaS)

* [
      sosedoff
      /
      pgweb
](https://github.com/sosedoff/pgweb):
      Web-based PostgreSQL database browser

* [
      jwilder
      /
      dockerize
](https://github.com/jwilder/dockerize):
      Utility to simplify running applications in docker containers

* [
      tsenart
      /
      vegeta
](https://github.com/tsenart/vegeta):
      HTTP load testing tool and library. It's over 9000!

* [
      Masterminds
      /
      glide
](https://github.com/Masterminds/glide):
      Simplified Go project management, dependency management, and vendoring.

* [
      spf13
      /
      hugo
](https://github.com/spf13/hugo):
      A Fast and Flexible Static Site Generator built with love by spf13 in GoLang

* [
      drone
      /
      drone
](https://github.com/drone/drone):
      Drone is a Continuous Integration platform built on Docker, written in Go

* [
      hashicorp
      /
      consul
](https://github.com/hashicorp/consul):
      Consul is a tool for service discovery, monitoring and configuration.

* [
      astaxie
      /
      build-web-application-with-golang
](https://github.com/astaxie/build-web-application-with-golang):
      A golang ebook intro how to build a web with golang

* [
      shipyard
      /
      shipyard
](https://github.com/shipyard/shipyard):
      Composable Docker Management

* [
      coreos
      /
      fleet
](https://github.com/coreos/fleet):
      A Distributed init System

* [
      hashicorp
      /
      terraform
](https://github.com/hashicorp/terraform):
      Terraform is a tool for building, changing, and combining infrastructure safely and efficiently.

* [
      limetext
      /
      lime
](https://github.com/limetext/lime):
      Experimental Sublime Text clone

* [
      aeden
      /
      eventbus
](https://github.com/aeden/eventbus):
      Unified interface for event distribution and consumption in web apps

* [
      zettio
      /
      weave
](https://github.com/zettio/weave):
      The Docker Network

* [
      mitchellh
      /
      packer
](https://github.com/mitchellh/packer):
      Packer is a tool for creating identical machine images for multiple platforms from a single source configuration.

#### javascript
* [
      aFarkas
      /
      lazysizes
](https://github.com/aFarkas/lazysizes):
      High performance lazy loader for images (responsive and normal), iframes and scripts, that detects any visibility changes triggered through user interaction, CSS or JavaScript without configuration.

* [
      kimmobrunfeldt
      /
      progressbar.js
](https://github.com/kimmobrunfeldt/progressbar.js):
      Beautiful and responsive progress bars

* [
      github
      /
      fetch
](https://github.com/github/fetch):
      A window.fetch JavaScript polyfill.

* [
      sindresorhus
      /
      pageres
](https://github.com/sindresorhus/pageres):
      Responsive website screenshots

* [
      enaqx
      /
      awesome-react
](https://github.com/enaqx/awesome-react):
      A collection of awesome React libraries, resources and shiny things.

* [
      zeman
      /
      perfmap
](https://github.com/zeman/perfmap):
      Front-end performance heatmap bookmarklet.

* [
      angular
      /
      angular.js
](https://github.com/angular/angular.js):
      HTML enhanced for web apps

* [
      florianheinemann
      /
      passwordless
](https://github.com/florianheinemann/passwordless):
      node.js/express module to authenticate users without password

* [
      gtramontina
      /
      ghooks
](https://github.com/gtramontina/ghooks):
      Simple git hooks

* [
      mbostock
      /
      d3
](https://github.com/mbostock/d3):
      A JavaScript visualization library for HTML and SVG.

* [
      julianlloyd
      /
      scrollReveal.js
](https://github.com/julianlloyd/scrollReveal.js):
      Declarative on-scroll reveal animations.

* [
      facebook
      /
      react
](https://github.com/facebook/react):
      React is a JavaScript library for building user interfaces. It's declarative, efficient, and extremely flexible. What's more, it works with the libraries and frameworks that you already know.

* [
      a8m
      /
      angular-filter
](https://github.com/a8m/angular-filter):
       Bunch of useful filters for AngularJS (with no external dependencies!)

* [
      driftyco
      /
      ionic
](https://github.com/driftyco/ionic):
      Advanced HTML5 Mobile App Framework. A beautiful front-end framework for developing hybrid mobile apps in HTML5. Best friends with AngularJS.

* [
      segmentio
      /
      nightmare
](https://github.com/segmentio/nightmare):
      A high level wrapper for Phantomjs.

* [
      omniscientjs
      /
      omniscient
](https://github.com/omniscientjs/omniscient):
      A library providing an abstraction for React components that allows for fast top-down rendering embracing immutable data for js

* [
      jquery
      /
      jquery
](https://github.com/jquery/jquery):
      jQuery JavaScript Library

* [
      joyent
      /
      node
](https://github.com/joyent/node):
      evented I/O for v8 javascript

* [
      LogIN-
      /
      ospnc
](https://github.com/LogIN-/ospnc):
      OpenSource Project Name Checker - OSPNC is a simple web-service that checks if your new project name is already taken on some of most popular open-source communities

* [
      angular
      /
      material
](https://github.com/angular/material):
      Material design for Angular

* [
      kethinov
      /
      BubblePainter
](https://github.com/kethinov/BubblePainter):
      Customize the chat bubbles in Messages.app in OS X 10.10 Yosemite.

* [
      meteor
      /
      meteor
](https://github.com/meteor/meteor):
      Meteor, an ultra-simple, database-everywhere, data-on-the-wire, pure-Javascript web framework.

* [
      adobe
      /
      brackets
](https://github.com/adobe/brackets):
      An open source code editor for the web, written in JavaScript, HTML and CSS.

* [
      gritzko
      /
      swarm
](https://github.com/gritzko/swarm):
      JavaScript replicated model (M of MVC) library

* [
      facebook
      /
      flux
](https://github.com/facebook/flux):
      Application Architecture for Building User Interfaces

#### ruby
* [
      bborn
      /
      lewsnetter
](https://github.com/bborn/lewsnetter):
      E-mail marketing application (create and send e-mail newsletter via SES). Includes subscription management, delivery, bounce and complaint notification, templates, and some stats.

* [
      Intrepidd
      /
      working_hours
](https://github.com/Intrepidd/working_hours):
      A modern ruby gem allowing to do time calculation with business / working hours.

* [
      Homebrew
      /
      homebrew
](https://github.com/Homebrew/homebrew):
      The missing package manager for OS X.

* [
      JuanitoFatas
      /
      fast-ruby
](https://github.com/JuanitoFatas/fast-ruby):
      Writing Fast Ruby —— Collect Common Ruby idioms.

* [
      rails
      /
      rails
](https://github.com/rails/rails):
      Ruby on Rails

* [
      eval
      /
      envied
](https://github.com/eval/envied):
      Ensures presence and type of your app's ENV-variables

* [
      ruboto
      /
      ruboto
](https://github.com/ruboto/ruboto):
      A platform for developing apps using JRuby on Android.

* [
      thoughtbot
      /
      laptop
](https://github.com/thoughtbot/laptop):
      A shell script which turns your OS X laptop into an awesome development machine.

* [
      jekyll
      /
      jekyll
](https://github.com/jekyll/jekyll):
      Jekyll is a blog-aware, static site generator in Ruby

* [
      caskroom
      /
      homebrew-cask
](https://github.com/caskroom/homebrew-cask):
      A CLI workflow for the administration of Mac applications distributed as binaries

* [
      adambutler
      /
      kevlar
](https://github.com/adambutler/kevlar):
      Secrets created by kevlar.io are kept until they are accessed, they are then deleted permanently from the server.

* [
      jasonfb
      /
      nondestructive_migrations
](https://github.com/jasonfb/nondestructive_migrations):
      Separate schema-only migrations from nondestrucitve (data) migrations in your Rails app

* [
      jedcn
      /
      reveal-ck
](https://github.com/jedcn/reveal-ck):
      Create reveal.js presentations with a ruby toolset. Author slides in Markdown, Haml, and more!

* [
      discourse
      /
      discourse
](https://github.com/discourse/discourse):
      A platform for community discussion. Free, open, simple.

* [
      junegunn
      /
      fzf
](https://github.com/junegunn/fzf):
      Fuzzy finder for your shell

* [
      mitchellh
      /
      vagrant
](https://github.com/mitchellh/vagrant):
      Vagrant is a tool for building and distributing development environments.

* [
      capistrano
      /
      capistrano
](https://github.com/capistrano/capistrano):
      Remote multi-server automation tool

* [
      bbatsov
      /
      rubocop
](https://github.com/bbatsov/rubocop):
      A Ruby static code analyzer, based on the community Ruby style guide.

* [
      stympy
      /
      faker
](https://github.com/stympy/faker):
      A library for generating fake data such as names, addresses, and phone numbers.

* [
      rapid7
      /
      metasploit-framework
](https://github.com/rapid7/metasploit-framework):
      Metasploit Framework

* [
      gitlabhq
      /
      gitlabhq
](https://github.com/gitlabhq/gitlabhq):
      Open source software to collaborate on code. Follow us on twitter @gitlabhq

* [
      maccman
      /
      nestful
](https://github.com/maccman/nestful):
      Simple Ruby HTTP/REST client with a sane API

* [
      spree
      /
      spree
](https://github.com/spree/spree):
      Spree is a complete open source e-commerce solution for Ruby on Rails.

* [
      LunarLogic
      /
      pg_morph
](https://github.com/LunarLogic/pg_morph):
      PgMorph gives you a way to handle DB consistency for polymorphic relations and is based on postgreSQL inheritance and partitioning features.

* [
      sass
      /
      sass
](https://github.com/sass/sass):
      Sass makes CSS fun again.

repository: josephyzhou/github-trending

repo_name: josephyzhou/github-trending


text:
---
title = "Sprinkler Project Parts List"
tags = ["elixir", "nerves", "sprinkler", "meetup"]
---

The [nerves remote meetup](/2018/07/03/nerves-sprinkler-meetup.html) is getting started soon and it seemed like a good idea to get a parts list put together.
This should work for anyone following along with the meetup or for people watching the recording later.

* [8 Channel Relays](http://a.co/033ga9I) these will send power to the sprinkler valves
* [Raspberry Pi 3 B+](http://a.co/1xSC2kR) this will be running our nerves code
* [3 Pack of Micro SD Cards](http://a.co/5miyrEc) holds our nerves code
* [Wires and Breadboard](http://a.co/bCkOvnf) useful for quickly wiring things together in a testable way
* [Wall Plug to USB](http://a.co/3l4Mpkx)
* [USB to MicroUSB cords](http://a.co/3Dz5VYo)
* [USB <-> TTL Serial Cable](http://a.co/0oimg8b) (optional) useful to debug what's happening on the raspberry pi

> Note: if you have micro SD cards, micro USB charge cords etc laying around, you can probably just use what you have.

For this project we are planning to re-use most of the existing wiring that your sprinkler control board has avaiable.
Here is a picture of my sprinkler control board.

![sprinkler control board](/images/2018-07-27/sprinkler_control_board.jpg)

The main 24VAC power line comes into the top-left and I plan to just tap into those in order to power the relays.
The small boxes in the middle are the power inputs for each of the valves so I plan to wire my relays to those same inputs.

repository: mmmries/blog

extension: markdown

gha_language: Elixir

repo_name: mmmries/blog


text:
#Learn How to Program

## Ruby on Rails - Basics

A clone

By Maldon Meehan & Cory Olson

## Description
learnhowtoprogram.com is powered by a fairly simple Rails app. Rebuild it today with your partner. Include integration testing with Capybara for all interactions in your browser, especially clicking on links and making new chapters/sections/lessons.

* First, work on CRUD/L functionality for lessons. A lesson has a name and some text content. Don't worry about videos and cheat sheets.

Also, take care of the Previous lesson link.

* Then, add sections: a section has many lessons. List out sections in the table of contents, along with the lessons inside them. Make the table of contents completely expanded - don't worry about the JavaScript that lets you expand and collapse sections. When you create a lesson, provide a drop-down list of all the sections, so that the user can choose which section it's in. (If you didn't get to drop-downs before, do a web search for html drop-down mdn to learn how to make them in HTML.)
* Next, add chapters: a chapter has many sections.
* Make sure that the table of contents displays the lessons in the order of their number attribute. Try a default scope and the Active Record #order method.

## Setup/Installation Requirements

```
$ git clone https://github.com/maldonmeehan/lh2p.git
```

Install required gems:
```
$ bundle
```

Run Postgres:
```
$ postgres
```

Open a new window and run:
```
$ rake db:create && rake db:migrate && rake db:test:prepare
```
```
$ rails s
```

Navigate to `http://localhost:3000` in your browser of choice.

## Known Bugs

No known bugs at this point

## Support and contact details

If you have any questions please feel free to contact Maldon on github

## Technologies Used

* Ruby on Rails
* Postgres

### License

MIT License

Copyright (c) 2016, **Maldon Meehan, Epicodus**


text:
---
title: Autoloading
menu: Autoloading
template: jaxon
---

When the Jaxon library processes a request to a given class, it has to create an instance of this class in order to call the target method.
Jaxon must therefore be able to find all the classes that have been registered.

For the developer who wants it, the Jaxon library can handle autoloading for all the classes it calls.

#### Autoloading a class

When registering a class, the `include` option allows to specify the path to the file where the class is defined.

```php
$jaxon->register(Jaxon::CALLABLE_CLASS, HelloWorld::class, ['include' => '/path/to/dir/HelloWorld.php']);
```

This file will be included in the application only if a method of the class is called.

#### Autoloading a directory

When registering a directory without a namespace, the `autoload` option can be use to setup autoloading.

```php
$jaxon->register(Jaxon::CALLABLE_DIR, '/the/class/dir', ['autoload' => true]);
```

In this case, Jaxon will browse the directory and register each class found with the corresponding file, using the `include` option.

#### Autoloading a namespace

When registering a directory with a namespace, the `autoload` option can also be use to setup autoloading.

```php
$jaxon->register(Jaxon::CALLABLE_DIR, '/the/class/dir', ['namespace' => 'App\Jaxon', 'autoload' => true]);
```

In this case, Jaxon will add the directory to the Composer autoloading mechanism.

repository: jaxon-php/jaxon-website

repo_name: jaxon-php/jaxon-website


text:
### zSub1x is a fork of [PIVX](https://github.com/PIVX-Project/PIVX) that forked [Dash](https://github.com/dashpay/dash) that forked [Bitcoin](https://github.com/bitcoin/bitcoinp)

# zSub1x Core integration/staging repository

zSub1x is a cutting edge cryptocurrency, with many features not available in most other cryptocurrencies.
- Anonymized transactions using zerocoin technology.
- Fast transactions featuring guaranteed zero confirmation transactions, PIVX named it _SwiftX_.
- Decentralized blockchain voting providing for consensus based advancement of the current Masternode
  technology used to secure the network and provide the above features, each Masternode is secured
  with a collateral of 20 SUB1X.

More information at [Sub1x.org](https://sub1x.org/) Visit our ANN thread at [BitcoinTalk](http://www.bitcointalk.org/index.php)

### Coin Specs

Algo	Xevan

Block Time	60 Seconds

Difficulty Retargeting	Every Block

Max Coin Supply (PoW Phase)	11200 SUB1X

Max Coin Supply (PoS Phase)	Infinite

Premine	11200 SUB1X

### Reward Distribution

PoW Phase

Block Height	Reward Amount	Notes	Duration (Days)

1	11200 SUB1X	Initial Premine	0 Days

200	0.05 SUB1X	Closed Mining	 Approx 3 hours

PoS Phase

Block Height	Reward Amount

259201-Infinite	Masternodes: 80%	Stakers: 20%

### PoS Rewards Breakdown

Phase	Block Height	Reward	Masternodes	Stakers

Phase 1	3030-518400	0.05 SUB1X	80% (0.04 SUB1X)	20% (0.01 SUB1X)

Phase 2	518401-777600	0.05 SUB1X	80% (0.04 SUB1X)	20% (0.01 SUB1X)

Phase 3	777601-1036801	0.05 SUB1X	80% (0.04 SUB1X)	20% 0.01 SUB1X)

Phase 4	1036802-Infinite	0.05 SUB1X	80% (0.04 SUB1X)	20% (0.01 SUB1X)


text:
# android-ins-unins-tool

A commond wrapper on ```adb``` command to support install or uninstall multi-Apks. [githug mirror](https://github.com/XinyueZ/android-ins-unins-tool) .

# Why

- The ```adb``` doesn't support multi-Apks at moment.
- The ```.gradlew uninstall/install``` is slow, too slow. When you run it, the gradle must download something.
- Other tools ? Not found yet.

# Run

> Uninstall Apks

- On all devices

```ruby uninstallapp.rb --all com.name.apk```

- On selected devices with id, i.e 234524

```ruby uninstallapp.rb<PHONE_NUMBER>524 35345 com.name.apk```

> Install Apks(from file)

- On all devices

```ruby installapp.rb --all ../../Desktop/name.apk```

- On Selected devices with id, i.e 234524

```ruby installapp.rb<PHONE_NUMBER>524 35345 ../../Desktop/name.apk```

# Known issues

- For hight level versions of Android, you'll see errors like this when you run the command. It is *OK* because the ```adb``` can't find Apks and dump these out. This happens just on some devices like *Pixel XL* etc.

```
Exception occurred while dumping:
java.lang.IllegalArgumentException: Unknown package: adfasdf.asdffasdf.com
        at com.android.server.pm.Settings.isOrphaned(Settings.java:4134)
        at com.android.server.pm.PackageManagerService.isOrphaned(PackageManagerService.java:18150)
        at com.android.server.pm.PackageManagerService.deletePackage(PackageManagerService.java:15567)
        at com.android.server.pm.PackageInstallerService.uninstall(PackageInstallerService.java:888)
        at com.android.server.pm.PackageManagerShellCommand.runUninstall(PackageManagerShellCommand.java:792)
        at com.android.server.pm.PackageManagerShellCommand.onCommand(PackageManagerShellCommand.java:118)
        at android.os.ShellCommand.exec(ShellCommand.java:94)
        at com.android.server.pm.PackageManagerService.onShellCommand(PackageManagerService.java:18408)
        at android.os.Binder.shellCommand(Binder.java:468)
        at android.os.Binder.onTransact(Binder.java:367)
        at android.content.pm.IPackageManager$Stub.onTransact(IPackageManager.java:2387)
        at com.android.server.pm.PackageManagerService.onTransact(PackageManagerService.java:3048)
        at android.os.Binder.execTransact(Binder.java:565)
```

- Normal output when Apks can't be found after  running command you'll see output like this

```
@Tool@: It is a real package: asdfasdf.asdfasdf.com
@Tool@: Find devices:["ce051715d931181103"]
@Tool@: Removed asdfsdf.asdfadsf.com on ce051715d931181103
@Tool@: Failure [DELETE_FAILED_INTERNAL_ERROR]
```

- When all successful, you'll see

```
@Tool@: It is a real package: afasdf.asdfasdf.com
@Tool@: Find devices:["ce051715d931181103"]
@Tool@: Removed asdfasdf.asdfasdf.com on ce051715d931181103
@Tool@: Success
````

# License

The MIT License (MIT)

Copyright (c) 2018 Chris Xinyue Zhao

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

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

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

repository: XinyueZ/android-ins-unins-tool

repo_name: XinyueZ/android-ins-unins-tool


text:
## Tabs

- `gt` go to the next *tab*
- `gT` go to the previous *tab*

## Windows

### If `ctrl+w` isn't quite right

Every shortcut that will affect the windows starts with `ctrl+w` (w like
window). If it doesn't fit your need (on some terminal, ctrl+w closes the
current tab), you can always remap it to an other one, and will affect *every*
shortcut starting by it:

    nnoremap <C-e> <C-w>

Now, `ctrl+e` will to the exact same as `ctrl+w` (so, you can now do `ctrl+e`,
`p` to go to the previous window)

### The shortcuts

#### Move the cursor across windows

- `ctrl+w`, `ctrl+w`: move the focus across the windows, in a clickwise
direction
- `ctrl+w`, `w` same as `ctrl+w`, `ctrl+w`
- `ctrl+w`, `p` goes to the Previous window
- `ctrl+w`, `T` move current window to a new *Tab*
- `ctrl+w`, `c` Close current window (if it was the last one, it'll close the
whole tab)

- `ctrl+w`, `j` gives the focus to the window below
- `ctrl+w`, `k` gives the focus to the window above
- `ctrl+w`, `h` gives the focus to the window on the left
- `ctrl+w`, `l` gives the focus to the window on the right

More info: `:help window-move-cursor`

#### Move the actual windows

And, what's just great about it is that if you use uppercased letters, instead
of moving the cursor, you'll move the *window*

- `ctrl+w`, `J` move the window bottom
- `ctrl+w`, `K` move the window top
- `ctrl+w`, `H` move the window to the very left
- `ctrl+w`, `l` move the window to the very right

More info: `:help window-moving`

#### Resize the windows

- `ctrl+w`, `>` increases the width
- `ctrl+w`, `>` decreases the width
- `ctrl+w`, `+` increases the height
- `ctrl+w`, `+` decreases the height
- `ctrl+w`, `=` set the windows' size to equal

More info: `:help window-resize`


text:
# MSSQL Helper

PDO_SQLSRV wrapper for legacy MSSQL PHP database functions

## Usage

Include this file and legacy code that relies on ``sqlsrv_*`` database calls will work in a modern environment utilizing PDO\_SQLSRV drivers.

## See Also

* [PHP MSSQL Documentation](https://php-legacy-docs.zend.com/manual/php5/en/book.mssql)
* [PDO_SQLSRV Drivers](http://www.microsoft.com/en-us/download/details.aspx?id=20098)


text:
# set2regex
Generating regular expressions from both natural language and examples

- Copyright [IBM]
- This product includes software (seq2seq base model) developed at https://github.com/IBM/pytorch-seq2seq
- This product use fado module from https://github.com/0xnurl/fado-python3

## Dataset download
> [set2regex dataset](https://github.com/woaksths/set2regex_dataset "set2regex dataset link")
## Install
    $python3 -m venv venv
    $source venv/bin/activate
    $pip install -r requirements.txt
    $python setup.py install
    $python fado-python3/setup.py install

## Usage
    # Before running this command, check the training option via $python examples/sample.py --help
    $python examples/sample.py --train_path $TRAIN_PATH --dev_path $DEV_PATH --expt_dir $EXPT_DIR
    $python examples/evaluation.py --train_path $TRAIN_PATH --test_path $TEST_PATH --checkpoint $CHECKPOINT


text:
# Kubernetes Security

## Kubernetes Networking

1. **Kubernetes Networking 101** (60 mins), you will use different ways to control traffic on a Kubernetes cluster with Service types, Ingress, Network Policy and Calico. Start [here](https://ibm.github.io/kubernetes-networking/services/).
2. **Kubernetes Network Security using a Virtual Private Cloud (VPC)** (90 mins), you will deploy a guestbook application to a Kubernetes cluster in a Virtual Private Cloud (VPC) Gen2, you will create the VPC, add a subnet, attach a public gateway, and update a security group with rules to allow inbound traffic to the guestbook application. Start [here](https://ibm.github.io/kubernetes-networking/vpcgen2/).
3. **[Istio](https://ibm.github.io/istio101/)**, use Istio to manage network traffic, load balance across microservices, enforce access policies, verify service identity, and more.

## Configuration Management

1. Application Configuration for Kubernetes:
    1. [Lab0. Setup](kubeconfig/0_setup.md)
    1. [Lab1. Container Configuration](kubeconfig/1_container_config.md)
    1. [Lab2. Using Environment Variables in Pod Config](kubeconfig/2_config_using_env.md)
    1. [Lab3. Store Key-Value Pairs using ConfigMap](kubeconfig/3_config_using_configmap.md)
    1. [Lab4. Store Sensitive Data using Secrets](kubeconfig/4_config_using_secrets.md)
    1. [Lab5. Pull an Image from a Private Registry](kubeconfig/5_config_private_registry.md)
1. Key Management Services (KMS)
    1. [Lab1. Encrypt Secrets using a Cloud-Managed Vault Service (IBM Secrets Manager)](vault/1_ibm_secrets_manager.md)
    1. Lab 2. Using Vault on OpenShift
        1. [Lab2. Setup Internal Vault with Vault Agent Injector on OpenShift](vault/2_setup_internal_vault.md)
        1. [Lab3. Access Internal Vault using Vault Agent Injector](vault/3_access_internal_vault_using_injector_annotations.md)

repository: porben/kubernetes-security

repo_name: porben/kubernetes-security


text:
# Combustion Engine

*Requires BuildCraft Energy*

Class path: `mods.buildcraft.CombustionEngine`

## Use

To use, import the class with `import mods.buildcraft.CombustionEngine;` at the beginning of your script.

## Adding a Clean Fuel

`CombustionEngine.addCleanFuel(liquid, powerPerTick, timePerBucket);`

- `liquid` <[ILiquidStack](/Vanilla/Liquids/ILiquidStack)> The liquid to be used as fuel
- `powerPerTick` <double> Power output in MJ per tick
- `timePerBucket` <int> Amount of ticks that 1,000 mB (1 bucket) should run for

```zenscript
import mods.buildcraft.CombustionEngine;

CombustionEngine.addCleanFuel(<liquid:iron>, 32.0, 1200);
```

## Adding a Dirty Fuel

`CombustionEngine.addDirtyFuel(lFuel, powerPerTick, timePerBucket, lResidue);`

- `lFuel` <[ILiquidStack](/Vanilla/Liquids/ILiquidStack)> The liquid to be used as fuel
- `powerPerTick` <double> Power output in MJ per tick
- `timePerBucket` <int> Amount of ticks that 1,000 mB (1 bucket) should run for
- `lResidue` <[ILiquidStack](/Vanilla/Liquids/ILiquidStack)> The residue fluid, per bucket of the original fuel

```zenscript
import mods.buildcraft.CombustionEngine;

CombustionEngine.addDirtyFuel(<liquid:iron>, 32.0, 1200, <liquid:water>);
```

repository: kindlich/CraftTweaker-Documentation

repo_name: kindlich/CraftTweaker-Documentation


text:
# ChangeLog #

## Build <IP_ADDRESS> (10-06-2020)

- Added support for the SWM (split Windows image) file type.
- If the source image is a SWM file, only the first SWM file needs passed to Optimize-Offline. It will recursively copy all additional SWM files. Likewise, the SWM files do not need to be named 'install.swm,' etc. Do note that in order to use a SWM file as the source image, all of the SWM files must be in their own directory. For example, if there are three SWM files named 'test.swm,' 'test2.swm,' 'test3.swm,' then all three of these SWM files must be in their own directory in order for Optimize-Offline to recognize them as split images from the same WIM file.
- Corrected some registry vales that contained an invalid hive mount point.
- Updated the Microsoft Edge Chromium package for Windows 10 builds 19041+.
- Updated the Windows Store bundle packages.
- The MAML XML external help file and manifest data have been updated.
- Multiple code improvements across the framework.

## Build <IP_ADDRESS> (09-17-2020) ##

- Fixed an error where the metadata for the image would not be returned if both the -DaRT and -Additional parameters were omitted.
- Updated the Win32Calc integration image package to correct a bug where selecting 'Unit Conversion' from its drop-down list would cause the Win32Calc.exe to close immediately.
- Updated the Resource Function that returns the metadata for any images being optimized.
- Additional Optimize-Offline code improvements.

## Build <IP_ADDRESS> (08-23-2020) ##

- Added support for Windows 10 build 19042 (20H2).
- Added the new 20H2 Start Menu Experience to the applied registry settings.
- Corrected an issue for Windows 10 builds 19041+ where it occasionally would be returned as an unsupported image build.
- Updated the Windows Store bundle packages.
- Updated the optional Set-Additional runtime script.
- Multiple code improvements across the framework.

## Build <IP_ADDRESS> (08-07-2020) ##

- Added the clean-up of any directories for Windows Apps that were deprovisioned.
- Added additional disabling of Microsoft Edge telemetry and tracking.
- Updated the custom App Associations .xml that gets imported.
- Updated the 'Additional Tweaks.reg' file in the 'Content\Additional\RegistryTemplates' directory.
- Updated the Windows Store bundle packages.
- Added two scripts in the 'Content\Additional\Setup' directory named 'Remove-OneDrive.ps1' and 'Set-Additional.ps1' that can be run during system runtime (when the image is in an online state). These two scripts are copied to the image's 'Windows\Setup\Scripts' directory.
- Remove-OneDrive.ps1 will completely and thoroughly remove Microsoft OneDrive.
- Set-Additional.ps1 uses the included ScheduledTasks.json and Services.json files to disable any scheduled tasks or system services that have 'SetState' value to 'Disable.' Additionally runtime-specific privacy and system settings are also applied.

**NOTE: Make sure you evaluate the contents of the Set-Additional.ps1 script, and its associated ScheduledTasks and Services .json files, before running the script. Though there are no ill effects of running it as-is, and before disabling any scheduled tasks or services it makes backup files of their default states, make sure no scheduled tasks or system services are set to be disabled that will be required by the system. Lastly, if you do not intend to use either of these scripts, you can remove them from the 'Content\Additional\Setup' directory.**

## Build <IP_ADDRESS> (07-02-2020) ##

- The Microsoft Edge Chromium browser can now be integrated into Windows 10 builds 18362+
- Following the integration of the Microsoft Edge Chromium package, Optimize-Offline will also apply all administrative policy templates to the image and a custom 'master_preferences' file for Microsoft Edge Chromium updates.
- Additional registry settings specific to Microsoft Edge Chromium have been added.
- The -DaRT parameter value 'All' has been removed. The -DaRT parameter now accepts one or both of the 'Setup' and 'Recovery' values.
- The Configuration.json file has been updated to incorporate the change to the -DaRT parameter.
- The Start-Optimize call script and Resource Functions have been updated.
- The MAML XML external help file and manifest data have been updated.
- There have been additional offline process code changes to reflect the aforementioned updates.

repository: goofwear/Optimize-Offline

repo_name: goofwear/Optimize-Offline


text:
---
layout: default
---

# 1994-07-02 - Mac PGP 2.6 sig file

## Header Data

From<EMAIL_ADDRESS>(Lance Cottrell)

To<EMAIL_ADDRESS>Message Hash: 78083f5e6a68e9cfc6327f7424d36717161b2bde80b8192d4e8b786c2bbedda2

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1994-07-02 03:37:00 UTC

Raw Date: Fri, 1 Jul 94 20:37:00 PDT

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Lance Cottrell)
Date: Fri, 1 Jul 94 20:37:00 PDT
To<EMAIL_ADDRESS>Subject: Mac PGP 2.6 sig file
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

I have just unstuffed the Mac PGP archive I grabbed from MIT. Inside is a
detached signature file. What file is a signature for? Is it for the binhex
file, for the first archive, for the archive in the archive? Has anyone
made this work?

--------------------------------------------------
Lance Cottrell  who does not speak for CASS/UCSD
<EMAIL_ADDRESS>PGP 2.3 key available by finger or server.

"Love is a snowmobile racing across the tundra.  Suddenly
it flips over, pinning you underneath.  At night the ice
weasels come."
                        --Nietzsche

{% endraw %}
```

## Thread

+ Return to [July 1994](/archive/1994/07)

+ Return to<EMAIL_ADDRESS>(Lance Cottrell)](/authors/lcottrell_at_popmail_ucsd_edu_lance_cottrell_)"

+ 1994-07-02 (Fri, 1 Jul 94 20:37:00 PDT) - Mac PGP 2.6 sig file -<EMAIL_ADDRESS>(Lance Cottrell)_


text:
# ExchangeLINQ

This library is a LINQ query provider for the Stack Exchange API v2. The beauty
of this thing is that it doesn't use expression trees and IQueryable, but instead
relies on the mapping from the query syntax to methods as Where and Select.
It is currently in alpha stage with some parts working and some parts not.
I developed the library as part of a stack exchange app for Windows Phone
I'm currently building with two other students.

## How to use it

Create a context with StackExchangeContext.Create.

Choose and endpoint: context.Questions.

Start querying: from q in context.Questions select q.

license: MS-PL

repository: jlaanstra/ExchangeLINQ

repo_name: jlaanstra/ExchangeLINQ


text:
# LD_PRELOAD-run-at-load-time
Code samples to go along with the blog post on how to run code at load/unload time when using LD_PRELOAD to inject libraries.

## Links to Tutorials
Blog: TODO - FILL IN WHEN READY

## Overview
This repo is used to provide some code samples to go along side a tutorial in Secure Ideas blogs. This code repo will provide you with the code for:

 * A simple hello world binary target
 * The LD_PRELOAD injection code
 * A make file to build it easily in a Kali VM.

The goal of this tutorial is to show how to use constructor and destructor attributes for running code at load/unload time with an LD_PRELOAD shared object to run code without hijacking a function call. In this case, It will demo this on a simple hello world binary but

## Building The Code Using Make.
Once you clone the repo, simply change into the directory and run ```make``` or ```make all``` to build both the game and the LD_PRELOAD hijack shared object. The make file also includes a help option to show all of the build targets:

```
kali@kali:~$ make help
Default Target:
         all => Build the default hello world & inject shared object.

Hello World Targets:
         hello_world => Build the default hello world ELF binary.

Inject Targets:
         inject.so => Build standard LD_PRELOAD inject.so shared object.
         inject.so_nocolor => Build non-colorized LD_PRELOAD inject.so shared object.

Maintance Targets:
         clean => delete the binaries.
kali@kali:~$
```

## Basic Hello World Usage
Standard Hello World build and usage:
```
kali@kali:~$ make hello_world
gcc -Wall -O3 -s src/hello_world.c -o hello_world
kali@kali:~$ ./hello_world
Hello World!
kali@kali:~$
```

## Building and injecting inject.so
```
kali@kali:~$ make inject.so
gcc -Wall -O3 -FPIC -shared src/inject.c -o inject.so
kali@kali:~$ ./hello_world
Hello World!
kali@kali:~$ LD_PRELOAD=./inject.so ./hello_world
 [+] Inject.so Loaded!
 [*] PID: 1445
 [*] Process: /home/kali/src/ld_preload_load_time/hello_world

Hello World!

 [-] Inject.so is being unloaded!
kali@kali:~$
```


text:
FT-Hackday-2012
===============

My Entry into FT Hackday 2012.

The Financial Times inaugural hack day was about using their content API.

My entry used the API to grab articles with images and present a screen
saver like falling display of articles. Don't expect the code to run any
more as the content api access keys have long changed.

Screen shot of idea:
http://www.screencast.com/t/81gvaAnwN6zd

Video of it in action:
http://www.screencast.com/t/HUaJZb595lN6

This is just a code sample showing what can be done in a 24ish hour period.

Yes, I even wrote unit tests for the code.

Made use of the HTML5 boilerplate / modernizr / jquery mobile / qunit.

license: Unlicense


text:
# 01 Dist

In this sample we are going to create a distribution folder where we are going
to place the result of the grunt build folder, then we are going to configure our
dev server to point to that distribution folder.

Summary steps:

- Create a _dist_ folder.
- Install and configure a clean plugin for grunt: [_grunt-contrib-clean_](https://github.com/gruntjs/grunt-contrib-clean).
- Install and configure a copy plugin for grunt: [_grunt-contrib-copy_](https://github.com/gruntjs/grunt-contrib-copy).
- Create task called _build-dev_ that will make use of the two plugins to copy the html to dist, this task:
    - Will first clean the _dist_ folder content using the cleaning plugin.
    - Then will copy all the needed files to that folder.
- Change where connect is pointing and configure root as _dist_.
- Create a simple js file called _calculator.js_ add a simple sum function.
- Create a simple js file called _main.js_ this file will make use of sum function.
- Reference both files in the HTML via _script_ tags.
- Extend the copy task to copy as well the js files.
- Test that everything is working as expected.

# Steps to build it

##Prerequisites

This sample takes as starting point _00 Connect_.

##Steps

- The first step is to create a _dist_ folder under the project root:

```
.
├─ dist
├─ src
│  └─ main.html
├─ gruntfile.js
└─ package.json
```

- Then let's install and configure _grunt-contrib-clean_ to clean folders and _grunt_contrib_copy_ to copy files.

  ```
  npm install grunt-contrib-clean grunt-contrib-copy --save-dev
  ```
  - (I) Let's add the config for the plugin:

```diff
  grunt.initConfig({
    connect: {
      server: {
        options: {
          hostname: 'localhost',
          port: 8080,
          keepalive: true,
          base: 'src',
          directory: 'src',
          open: {
            target: 'http://localhost:8080/index.html'
          }
        }
      }
-    },
+    },
+    clean: ['dist']
  });
```

- (II) We also need to load the grunt plugin:

```diff
module.exports = function (grunt) {
  grunt.loadNpmTasks('grunt-contrib-connect');
+ grunt.loadNpmTasks('grunt-contrib-clean');
```

- The next step is to install and configure _grunt-contrib-copy_ to copy our built files from _src_ to  _dist_ folder.

```bash
npm install grunt-contrib-copy --save-dev
```
- (I) Let's add the config for the copy plugin:

```diff
    },
    clean: ['dist'],
+    copy: {
+      main: {
+        files: [
+          {
+            expand: true,
+            cwd: './src/',
+            src: ['*.js'],
+            dest: './dist'
+          },
+          {
+            src: './src/index.html',
+            dest: './dist/index.html'
+          }
+        ]
+      }
+    }
  });
```

- (II) We also need to tell grunt to load this plugin:

```diff
grunt.loadNpmTasks('grunt-contrib-connect');
grunt.loadNpmTasks('grunt-contrib-clean');
+  grunt.loadNpmTasks('grunt-contrib-copy');
```

- Once we have the two plugins in our _gruntfile.js_ let's define a _build-dev_ task that will sequentially execute clean and then copy:

```diff
grunt.registerTask('web', ['connect']);
+ grunt.registerTask('build-dev', ['clean', 'copy']);
```

- It's time to update where our dev server is pointing. Let's change it to _dist_.

```diff
  grunt.initConfig({
    connect: {
      server: {
        options: {
          hostname: 'localhost',
          port: 8080,
          keepalive: true,
+          base: 'dist',
+          directory: 'dist',
-          base: 'src',
-          directory: 'src',
          open: {
            target: 'http://localhost:8080/index.html'
          }
        }
      }
    },
```

- Let's add a new command to our _package.json_

```diff
"scripts": {
  "start": "grunt web",
+ "build": "grunt build-dev"
  "test": "echo \"Error: no test specified\" && exit 1"
},
```

- Let's try both commands:

```bash
npm run build
```

```bash
npm start
```

- It's time to play with some javascript, let's add a simple _calculator.js_ file under _src_:

```javascript
function mySum(a, b) {
  return a + b;
}
```

 - Now let's add an _main.js_ file that will make use of the previously created filed (_calculator_):

 ```javascript
 var result = mySum(2, 4);
 document.write(" sum result:" + result);
 ```

 - Let's reference both files in the main HTML:

```html
...
    <h1>Hello Grunt !</h1>
    <script src="./calculator.js"></script>
    <script src="./main.js"></script>
  </body>
</html>
```

- Finally it's time to test that everything is working as expected.
  - (I) Execute the `build-dev` task we've created.

  ```
  npm run build
  ```

  - (II) Launch the `web` task to see the result.

  ```
  npm start
  ```

  You should end up seeing something like the figure below:

  ![html result](../99 Resources/01 Dist/01 Result.png "01 Result.png")

repository: Lemoncode/grunt-by-sample

path: /01 Dist/README.md

repo_name: Lemoncode/grunt-by-sample