text:
---
title: Exploring Scala with MongoDB
categories:
  - mongodb
  - scala
  - casbah
comments: true
layout: post
---

2010 proved to be a great year for growth and adoption of many fledgling technologies---not least among them, [MongoDB](http://mongodb.org/ "MongoDB") and [Scala](http://scala-lang.org).  Scala is designed as an alternative language for the Java platform, with a focus on scalability. It merges many of the Object Oriented concepts of languages like Java and C++ with the functional tools of Erlang, Haskell and Lisp with a bit of the dynamic natures of modern languages like Ruby and Python.  This flexible nature has sped Scala's adoption in the technology stacks of platforms like [LinkedIn](http://www.scala-lang.org/node/7806), [Twitter](http://www.artima.com/scalazine/articles/twitter_on_scala.html), [FourSquare](http://www.10gen.com/video/misc/foursquare) and many more.  By running on the JVM Scala has a strong affinity for working alongside existing Java applications, which allows users to build on their existing technology investments.

For 2011, MongoDB has added official support for Scala with the release of [Casbah](http://api.mongodb.org/scala/casbah/latest/), a Scala driver for MongoDB.  Casbah is built around the existing MongoDB Java Driver to give it a strong foundation, but designed to take advantage of many of the idioms of Scala such as a strong collections library, fluid syntax for building DSLs and functional concepts like closures and currying.

Because it is designed to be easy to work with for Scala users, Casbah introduces a more 'friendly' syntax for creating MongoDB Objects, using Scala's Map syntax:

{% highlight scala %}
import com.mongodb.casbah.Imports._

/** Create an object directly */
val newObj = MongoDBObject("foo" -> "bar",
                           "x" -> "y",
                           "pie" -> 3.14,
                           "spam" -> "eggs")

/** Or, use a builder interface */
val builder = MongoDBObject.newBuilder
builder += "foo" -> "bar"
builder += "x" -> "y"
builder += ("pie" -> 3.14)
builder += ("spam" -> "eggs", "mmm" -> "bacon")
val newObj = builder.result
{% endhighlight %}

The goal of this syntax is to be more readable, similar to what one might expect from a dynamic language like Ruby or Python.

<!--more-->

In contrast, the same statements in Java tend to be more verbose:

{% highlight scala %}
import com.mongodb.*;

DBObject newObj = new BasicDBObject();
newObj.put("foo", "bar");
newObj.put("x", "y");
newObj.put("pie", 3.14);
newObj.put("spam", "eggs");

/** or, builder style */

BasicDBObjectBuilder builder = BasicDBObjectBuilder.start();
builder.add("foo", "bar");
builder.add("x", "y");
builder.add("pie", 3.14);
builder.add("spam", "eggs");
builder.add("mmm", "bacon");
DBObject newObj = builder.get();

{% endhighlight %}

The semantics of working with Collections and Cursors in Casbah are similar to the Java driver they wrap, with a bit of Scala-friendly syntactic sugar added for things like [for comprehensions](http://www.scala-lang.org/node/111).  Where Casbah really shines is in its use of a DSL syntax for creating MongoDB Queries.

{% highlight scala %}

/** This Query Object ... */
val query = new MongoDBObject(
                "foo" -> MongoDObject("$gte" -> 5, "$lte" -> 10),
                "baz" -> 5,
                "x" -> "y",
                "n" -> "r"
            )
/** Can be constructed instead with the Query DSL: */
val queryDSL = ("foo" $gte 5 $lte 10) ++ ("baz" -> 5) ++ ("x" -> "y") ++ ("n" -> "r")

/** Easily create negated statements.
    Instead of a nested DBObject constructor like this: */

val ltGt = MongoDBObject(
            "foo" -> MongoDBObject(
                "$not" -> MongoDBObject(
                    "$gte" -> 15,
                    "$lt" -> 35.2,
                    "$ne" -> 16)
                )
            )

/** Use Casbah's Query DSL to say it much simpler */
val ltGtDSL = "foo" $not { _ $gte 15 $lt 35.2 $ne 16 }

{% endhighlight %}

All of MongoDB's *$ Operators* including Geospatial Queries are supported by Casbah's DSL.

This is just a small taste of what Casbah and Scala offer to the MongoDB user, but we encourage you to explore more.  [Version 2.01](http://api.mongodb.org/scala/casbah/latest/setting_up.html) is now available for download.


text:
# Domain.Api.V1.Model.MeV1ProviderSummary
Create provider response
## Properties

Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**Id** | **string** | Provider identifier - this will map to the username | [optional]
**CompanyName** | **string** | Company name | [optional]
**ContactNameTechnical** | **string** | Contact person's name for technical related enquiries | [optional]
**EmailTechnical** | **string** | Email address to receive technical related emails | [optional]
**PhoneTechnical** | **string** | Phone to be contact for technical related enquiries | [optional]
**ContactNameBusiness** | **string** | Contact person's name for business related enquiries | [optional]
**EmailBusiness** | **string** | Email address to receive business related emails | [optional]
**PhoneBusiness** | **string** | Phone to be contact for business related enquiries | [optional]

[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

license: MIT

repository: nad-au/Propella

branch_name: refs/heads/main

extension: md

license_type: permissive

repo_name: nad-au/Propella


text:
Buy at Leanpub

* 45 day money back guarantee
* 200+ pages (pdf/epub/mobi)
* 2000+ readers
* Future updates for free
* Digital version - min. $19.99 + VAT

## About Author

Juho Vepsäläinen has been dealing with the web since the 90s. He is behind [jswiki](https://github.com/bebraw/jswiki) and [jster.net](http://jster.net/).

He has developed [colorjoe](https://github.com/bebraw/colorjoe) and [reactabular](http://reactabular.js.org/) in addition to many other libraries.

He started the SurviveJS effort early 2015 and has been pushing it forward ever since!

* [@bebraw](https://twitter.com/bebraw)
* [Personal blog](http://nixtu.info)
* [GitHub](https://github.com/bebraw)

repository: faceyspacey/site

branch_name: refs/heads/master

repo_name: faceyspacey/site


text:
# Phaeophyscia leana (Tuck.) Essl. SPECIES

#### Status
ACCEPTED

#### According to
Index Fungorum

#### Published in
Mycotaxon 7(2): 311 (1978)

#### Original name
Physcia leana Tuck.

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
## Version 1.0.0 (2021/05/18)

### Issues Closed

* [Issue 3](https://github.com/python-lsp/python-lsp-black/issues/3) - Update README and add RELEASE instructions
* [Issue 2](https://github.com/python-lsp/python-lsp-black/issues/2) - Release v1.0.0

In this release 2 issues were closed.

### Pull Requests Merged

* [PR 1](https://github.com/python-lsp/python-lsp-black/pull/1) - PR: Python LSP server migration, by [@andfoy](https://github.com/andfoy)

In this release 1 pull request was closed.

repository: lieryan/python-lsp-black

repo_name: lieryan/python-lsp-black


text:
### usage:

This requires that easy68k is installed on the system to work.

```
python3 ./cli.py
(easier68k) assemble ./test.68k
[ stuff gets printed ]

(easier68k) assemble ./test.68k ./output.json
[ file saved ]
[ errors/warnings printed ]

(easier68k) run ./output.json
[ will load sub-repl eventually ]

(easier68k) exit
```

note: on Linux (and other operating systems?) auto complete works when pressing tab

gha_language: Python

gha_license_id: MIT


text:
# Atom Solarized Dark UI theme

My personal take on a full solarized feel for Atom, recommended for use with the
[Solarized Dark Syntax](https://github.com/atom/solarized-dark-syntax) theme. This package is not under active development (I recommmend the built in "One Dark" and "One Light" themes), but I'm happy to review pull requests.

![screen shot](https://f.cloud.github.com/assets/136521/2304949/df273aea-a23d-11e3-91fd-182b5f2212cf.png)

repository: tclem/atom-solarized-dark-ui

gha_language: CSS

repo_name: tclem/atom-solarized-dark-ui


text:
---
title: "Google Assistant via Open Peer Power Cloud"
description: "Enable the Google Assistant via Open Peer Power Cloud integration."
sidebar: false
---

Open Peer Power Cloud is a subscription service provided by our partner Nabu Casa, Inc. Check out [the Nabu Casa website](https://www.nabucasa.com/config/google_assistant/) for help with the Google Assistant integration via Open Peer Power Cloud.

branch_name: refs/heads/develop

extension: markdown

gha_language: HTML


text:
---
title: ASP.NET JSON Date
version: 1.3.0
signature: |
  moment(String);
---

Microsoft Web API returns JSON dates in proper ISO-8601 format by default, but older ASP.NET technologies may return dates in JSON as `/Date(1198908717056)/` or `/Date(1198908717056-0700)/`

If a string that matches this format is passed in, it will be parsed correctly.

```javascript
moment("/Date(1198908717056-0700)/"); // 2007-12-28T23:11:57.056-07:00
```

gha_language: JavaScript


text:
# The Game of Life in Elm

## Game of Life
https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life

### Rules
The universe of the Game of Life is an infinite, two-dimensional orthogonal grid of square cells, each of which is in one of two possible states, live or dead, (or populated and unpopulated, respectively). Every cell interacts with its eight neighbours, which are the cells that are horizontally, vertically, or diagonally adjacent. At each step in time, the following transitions occur.

1. Any live cell with two or three live neighbours survives.
2.
3.  Example](https://github.com/tlentz/cobble/blob/master/images/gol.gif)

repository: tlentz/cobble

gha_language: Elm

repo_name: tlentz/cobble


text:
---
title: About
layout: page
---
![Profile Image]({{ site.url }}/{{ site.picture }})

If we tried to think of a good idea, we wouldn’t have been able to think of a good idea. You just have to find the solution for a problem in your own life. I am fascinated by the process of architecting software applications. I believe in every software you make, there needs to be a better architecture. You’re most likely to be productive when you’re trying to make the code as separate and clean as possible. Problem-Solving is what I am passionate about. It gives me immense pleasure to work in teams and seize the opportunity to mentor and be mentored. In the past, I have worked on projects in various capacities like Data Mining, Information Retrieval and Web Services. Throughout this journey, I got exposed to technologies like Apache Spark, Scala, Kafka, Python, and Java.

I aspire to become an Entrepreneur and build something that can change the world. This is my way of giving it back to the society. I will soon be joining VMware as a Software Engineer. With all the experience I acquire, I look forward to creating an impact.


text:
Example application for [react-native-google-nearby-connection](https://github.com/butchmarshall/react-native-google-nearby-connection)

Download the React Native Nearby Connection demo app from the [Google Play Store (Android)](https://play.google.com/store/apps/details?id=com.butchmarshall.reactnative.nearby.connection)

## Build Instructions

```bash

npm install

react-native start

npm run android
```


text:
+++
title = "Add the Required IAM Role"
chapter = false
weight = 17

+++

Creating and using EKS clusters in AWS requires specific IAM roles for the user creating and accessing EKS clusters.

- Switch to the **AWS Console** (You can open the console from the "Team Dashboard")
- Under **Services**, select **EC2**
- Click **Running Instances**
- Select the instance named "aws-cloud9-..." by clicking the check box to the left of the name
- On **Actions** pull down, select **Instance Settings -> Attach/Replace IAM Role**
- In the **IAM role** pull down, select **modernization-admin**
- To the right, click **Apply**

gha_license_id: NOASSERTION


text:
# django-imager

**Authors**: Steven Starwalt, Shannon Tully

**Version**: 2.0.2

## Overview
A site that hosts images

## Getting Started
*  Project-specific env variables
* `export SECRET_KEY='secret key'`
* `export DEBUG=True`
* `export DB_NAME='imager'`
* `export DB_USER=''` set these two if need for linux
* `export DB_PASSWORD=''`
* `export DB_HOST='localhost'`

### initalize and run server
* `dropdb $DB_NAME`
* `createdb $DB_NAME`
* `./manage.py makemigrations`
* `./manage.py migrate`
* `./manage.py check`
* `./manage.py test`
* `./manage.py runserver`

### Routes
* Home
* Admin
* Login
* Register
* logout
* Activate

### Requirements
- Python

## Architecture
This app is written using Python 3.6.4 and Django framework, for full environmental requirements check requirements.txt

## Change Log
- 23 April 2018 - Start, Added git ignore, added ENV, django and req.txt, added factory.Faker. new requirements.txt, added tests for proper responses. version 1.0.0

- 24 April 2018 - added code for registration and django registration, new requirements.txt, added static css SMACSS file system and started styling, added image for the home page, new tests for registration. version 1.0.1

- 25 April 2018 - added imager_images app, added Album and Photo models, MEDIA folder with an images folder, added sorl.thumbnail & pillow, new requirements.txt, added tests for the imager_images app. version 1.0.2

- 26 April 2018 - added the profile and library page views. Still need to test and add a package to render thumbnails for the library page.  Will update version after tests are written and passed for these additions.

repository: ShannonTully/django-imager

repo_name: ShannonTully/django-imager


text:
# Some notes while learning rust

- define function, entry point is `main()`
    ```rust
    fn main() {

    }
    ```

- stdout with `println!()`

- Compile with `rustrc *.rs`

- Some `cargo` usages
    ```bash
    cargo new *name* # initiate new project
    cargo build # build project
    cargo run # run binary
    cargo check # check compilation without produce binary
    ```
- Input/output library from standard library `use std::io;`

- Use `let` to create variables; use `mut` to specify mutatble variables

- `String::new()` returns a new instance of a `String`

- `//` to start a comment

repository: tonyyzy/rust-learn

repo_name: tonyyzy/rust-learn


text:
# About OMTS

This is a demo app for Online Movie Ticket Service (OMTS), which is an application for the advance purchase of movie tickets from any local theatre. Customers use the service to find out information about movies currently playing in their city and to order advance tickets for specific showings of the movies.

# User’s guide

### For developers:

- Download and run XAMPP
- Download/Clone the app from github
- Depending on your Operating System change XAMPP’s starting location ([guide](https://stackoverflow.com/questions/8847392/how-to-change-xampp-localhost-to-another-folder-outside-xampp-folder))
- Go to http://localhost/phpmyadmin/
- Go to SQL tab and copy - paste and run the content of the omts.ddl
- Open http://localhost/ and you should be able to see the app
- The code is commented properly and the variable names are logical so readability and understanding the logic should be easy.

### For Admins:
- With admin access you have all the privileges of a normal user and also access to admin dashboard.
- On admin dashboard you will be able to see some statistics for most popular movie and theatre.
- Managing members by deleting or checking their purchase history.
- Adding or updating theatre complexes.
- Adding movies.
- And managing shows.

### For Users:
- Users can sign up.
- Log in to the app.
- Under profile tab, they can update their info, also check or cancel their purchases.
- On the homepage they can browse movies, buy tickets and read or leave a review.

# List of assumptions:

1.  For screening table the weak entity relationship is defined as three unique key and screening_id as a primary key. This decision was made to easily access screening data.

2.  There are two roles: admin and user and it is defined in app-user table as role.

3.  Users can review a movie only once.

4.  Passwords are not hashed for demo purposes.

# Technologies and tools used in developing the application.

**Languages:** PHP, SQL, HTML, CSS, JavaScript

**Frameworks:** Bootstrap, Bootstrap-select

**Others:** XAMPP, Git

repository: soheil-hamidi/omts

repo_name: soheil-hamidi/omts


text:
# Configuration

Configuring the BreadcrumbHeader can be done in `components.json` where the `style` key is set to one of the following:
- simple (default)
- arrows

## Example Configuration

```
{
    "BreadCrumbHeader": {
        "style": "simple"
    }
}
```

repository: dfst/webgme-breadcrumbheader

repo_name: dfst/webgme-breadcrumbheader


text:
# Mafia Chat Game

Online multiplayer [Mafia](https://en.wikipedia.org/wiki/Mafia_(party_game)) game implementation. Can be played through the [web app](https://mafiachatgame.herokuapp.com) or through [Facebook Messenger](https://facebook.com/mafiachatgame).

## Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a live system.

git clone https://github.com/adelavegaf/mafiachatgame.git
npm start

### Prerequisites

You need to have installed [npm](https://www.npmjs.com/) in your system.
In order for the Facebook Chat Bot to work, you must have an active facebook page.

### Installing

npm install

## Running the tests

At the root of the project type:

npm test

### Break down into end to end tests

Tests the server implementation and the game logic. Note that the tests do not cover server communication with Facebook Messenger API and thus errors might be generated when communicating to them.

## Deployment

In order for the app to work with Facebook Messenger, you must change the information in the file ./security/sensible.js.

```javascript
token: "<token_here>",
verify_token: "<verify_token_here>"
```

Additionally, you must modify the value of the attribute messenger_app_id in the file ./views/play.html.

```html
<div class="fb-messengermessageus" messenger_app_id="496004080598108" page_id="1691882611078540" color="white" size="xlarge">
```

## Built With

* NodeJS - Used for server and game logic implementation.
* Express - RESTful API.
* AngularJS - Used for web app Front End with Angular Material.
* SocketIO - Used for web app - server communication.

## Authors

* **Antonio de la Vega**

## License

This project is licensed under the MIT License.

repository: adelavegaf/mafiachatgame

repo_name: adelavegaf/mafiachatgame


text:
# E13-Final-Project

* Our project is called Revelation.

* Assets
  - Textures: https://textures.pixel-furnace.com/
  - CC0 Textures
  - Particles: Kenney.nl
  - Music from opengameart.org

* Story
  - the player is a survivor in what is left of a hellish world. monsters roam and lava, fire, and dust surround you.

* Levels
  - there are two main levels, a labyrinth-like level that leads to a portal that takes you to the second level.
  - the second level is the dungeon with the boss that you fight using bullets


text:
---
layout: default
---

# 1994-01-26 - Re: REMAIL: Cover traffic

## Header Data

From<EMAIL_ADDRESS>(Jim Miller)

To<EMAIL_ADDRESS>Message Hash: 90bb0806f2dc3beeaed83b367e9a2b63af884aa9230345145e75ffb870fc8611

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1994-01-26 01:06:53 UTC

Raw Date: Tue, 25 Jan 94 17:06:53 PST

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Jim Miller)
Date: Tue, 25 Jan 94 17:06:53 PST
To<EMAIL_ADDRESS>Subject: Re: REMAIL: Cover traffic
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Arsen Ray Arachelian writes:

> ...Even better, have each remailer send a specific
> number of messages to each of the other remailers on the
> network.  These messages would be bogus messages,
> however, there would be a fixed number of them.
>

> If a real nym message arrives, it is sent to the next mailer
> up the chain, as part of the n (n-1 now) that are bogus.  That
> way a spook couldn't tell where a message was going since
> he couldn't count the number of messages going out of the
> mailer.

>

> Also if a target remailer has n real messages to be sent to,
> any messages over that assigned packet size of messages
> get spooled for the next round of bogus mail.  This way each
> remailer will send exactly n messages to every other
> remailer on the net every specified period of time.

>

I like this idea.  It seems to use fewer CPU resources than having a
remailer route a bogus message through a random set of other remailers and
back to itself.

If I understand the encrypted remailer scheme correctly, the "route
through random set" mechanism requires a remailer to enclose a bogus
message in a set of nested digital envelopes (one for each remailer in the
random remailer set).  The "round-robin send to peers" mechanism only
requires the remailer to create one envelope per bogus message.

I also like the idea because it seems easier to analyse, and therefore
easier to describe/formalize the properties of the system as a whole.

<EMAIL_ADDRESS>

{% endraw %}
```

## Thread

+ Return to [January 1994](/archive/1994/01)

+ Return to<EMAIL_ADDRESS>(Jim Miller)](/authors/jim_at_bilbo_suite_com_jim_miller_)"

+ 1994-01-26 (Tue, 25 Jan 94 17:06:53 PST) - Re: REMAIL: Cover traffic -<EMAIL_ADDRESS>(Jim Miller)_


text:
# Pretrained weights

Download the pretrained weights from the [official repository](https://github.com/deepmind/deepmind-research/tree/master/nfnets#pre-trained-weights) and place them inside this folder.
Then start training with
```
python3 train.py --pretrained pretrained/F0_haiku.npz
```

The large model F6+SAM is currently not supported.


text:
NBEllipsisView
==============

Dots to indicate multiple items to scroll through horizontally

Demo
====

The demo/ folder contains a demo project showing NBEllipsisView in use.
Open and run it.

Usage
=====

Set all the following properties to configure the ellipsis:

    _ellipsis.currentDot = 0;
    _ellipsis.numDots = 4;
    _ellipsis.dotSpacing = 17.0;
    _ellipsis.dotImage = [UIImage imageNamed:@"ellipsis_outline"];
    _ellipsis.currentDotImage = [UIImage imageNamed:@"ellipsis_blue"];

The ellipsis isn't bound to any particular UI element, although you will
most likely use it with a UIScrollView with paging enabled. When you
need to update which ellipsis dot is selected, call:

	[_ellipsis setCurrentDot:i];

Compatibility
=============

This class has been tested back to iOS 6.1.

Implementation
==============

This class is implemented as a UIView that lays out multiple
UIImageView subviews.

License
=======

This code is released under the MIT License. See the LICENSE file for
details.

repository: needbee/nbellipsisview

repo_name: needbee/nbellipsisview


text:
# Alysaar
## A Rainmeter Feed Reader Skin

<img src="https://recordit.co/itdd1Q7uIO.gif" width="900" />

---

## Installation

### Using .rmskin (Recommended)

- Download the latest .rmskin file from the [releases](https://github.com/AlphaCortex/Rainmeter-Skins/releases)

### Manual

- [Download](https://github.com/AlphaCortex/Rainmeter-Skins/archive/master.zip) the whole repository and extract the folder to your Rainmeter skins folder `%USER%\Documents\Rainmeter\Skins\`
---

## Optional

- You can change the language/localisation of google news reader by changing the Variables Localesmall and Localebig
```
;===== CONFIGURATION =====
    [Variables]
        ; - Google News Reader Variables -
        ;e.g.: de-DE ; en-GB ; en-US ; ja-JP ; https://developers.google.com/assistant/console/languages-locales
        Localesmall     =de
        Localebig       =DE
```

---
## License
[![License](http://img.shields.io/:license-mit-blue.svg?style=flat-square)](http://badges.mit-license.org)
- Copyright 2019 © AlphaCortex


text:
# Example tasks

[This](tasks/cpu-file.json) example task will publish metrics to file
from the **cpu** plugin.

## Running the example

### Requirements
 * `docker` and `docker-compose` are **installed** and **configured**

Running the sample is as *easy* as running the script `./run-cpu-file.sh`.

## Files

- [run-cpu-file.sh](run-cpu-file.sh)
    - The example is launched with this script
- [tasks/cpu-file.json](tasks/cpu-file.json)
    - Snap task definition
- [docker-compose.yml](docker-compose.yml)
    - A docker compose file which defines two linked containers
        - "runner" is the container where snapteld is run from.  You will be dumped
        into a shell in this container after running
        [run-cpu-file.sh](run-cpu-file.sh).  Exiting the shell will
        trigger cleaning up the containers used in the example.
- [cpu-file.sh](cpu-file.sh)
    - Downloads `snapteld`, `snaptel`, `snap-plugin-publisher-file`,
    `snap-plugin-collector-cpu` and starts the task
    [tasks/cpu-file.json](tasks/cpu-file.json).
- [.setup.sh](.setup.sh)
    - Verifies dependencies and starts the containers.  It's called
    by [run-cpu-file.sh](run-cpu-file.sh).

repository: intelsdi-x/snap-plugin-collector-cpu

gha_language: Go

repo_name: intelsdi-x/snap-plugin-collector-cpu


text:
---
title: "Testing NgRx effects"
date: "2017-08-30T23:46:37.121Z"
template: "post"
draft: false
slug: "/posts/testing-ngrx/"
category: "NgRx"
tags:
  - "TypeScript"
  - "Angular"
  - "NgRx"
description: "My approach in testing NgRx effects. Some of the things that worked and some that did not."
---

**Update:** Since I’ve wrote this, both NgRx and RxJs released some new versions that require some small changes in how we can write the tests. You can see all those in [this follow up](https://medium.com/@adrianfaciu/update-on-testing-ngrx-effects-cf32a80d3601).

If you decide to use a _state management_ library in your [Angular](https://angular.io/) application (and for most of them you should :) ) a good choice is one of the [Redux](http://redux.js.org/) inspired libraries. You’ll most likely have actions, reducers and pretty soon something to handle all the side effects. In case of [ngrx](https://github.com/ngrx/platform), these side effects are handled with the help of the ngrx/effects module.

This post will show an approach on how to test [ngrx effects](https://github.com/ngrx/platform) and show some samples. It will not go into state management and why to use this library for managing side effects.

**An Effect** is a stream that filters the actions object (all the actions going through the application) and filters them based on the action type we want to react to. **An action** is handled by a reducer function which updates the application state. In cases where we want to have some side effects (eg. xhr call) as a result of that action, we do it in an _Effect_.

Testing reducers is pretty straight forward since they are pure functions and should not be that complex. The interesting part comes when we want to test the effects that we’ve built.

There is some [documentation ](https://github.com/ReactiveX/rxjs/blob/master/doc/writing-marble-tests.md)and [some samples](https://github.com/ngrx/platform/tree/master/example-app/app/books/effects) on how to test them, but the samples don’t have that much information provided and they are using the [TestBed](https://angular.io/api/core/testing/TestBed) provided by Angular. I liked better the approach that [Victor Savkin](undefined) took in his [repo on how to test effects](https://github.com/vsavkin/testing_ngrx_effects). We instantiate everything ourselves, there is no TestBed, no subscribe calls and generally the tests look and feel more clean.

As a bonus this approach works with both old (2.x) and new (4.x) version of ngrx so you can easily have the tests up and running and then migrate with confidence, and without having to rewrite the tests afterwards.

I’ve added some samples, including a bit more complex scenarios that I’ve encountered while writing tests for effects, and tried to explain each of them.

We use [jasmine-marbles](https://github.com/synapse-wireless-labs/jasmine-marbles) for easier testing and a better visualisation of Observables. While it’s not wildly popular, it’s being used trough several open source projects (including ngrx itself) and quite a few presentations. The code base is quite small so you could look at it and implement it yourself if needed.

Assuming we have the most simple effect possible that just listens for an action, might do some processing, and triggers another action as a result. The most basic approach would look something like:

We listen to the increment action, perform any processing we might want to and generate a new action.

Inside a test we would want to trigger the increment action and make sure we always get back the update text resulting action:

Using jasmine-marbles library we can create observables using marble diagrams which generally helps a lot when reading the tests. So if we have an observable that emits two values we can describe it as: ‘ -a-b-|’.

When using marble diagrams we represent them as a string using:

- - to represent passing of time (10 frames)

- | to mark the completion event

- # to emit an error

- most other characters to represent an emitted value

The library has two useful methods hot/cold that allow us to create an observable from a string representation. If you want to read about the difference between a cold and a hot observable, [Ben Lesh](undefined) has a [great article about this](https://medium.com/@benlesh/hot-vs-cold-observables-f8094ed53339).

When we create an observable using hot/cold method, the second parameter that we can pass to the method is an object that maps values for each emitted item. In our case we only pass the action object that we want to handle:

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

Another nice thing that jasmine-marbles adds is the **toBeObservable** matcher so we can directly compare our input with the expected result:

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

This is the basic setup for testing a simple effect that we might use.

We can move on to our second testing scenario where we use a service in the effect and we want to mock it:

Similar to our first example just that in this case we’re using a service to fetch some data. We get this service through dependency injection so we’ll need to mock it in our test to make sure we don’t hit an API or some other costly operation.

An important thing we should notice is that we don’t want to throw an exception directly on an effect stream, remember this is the main actions stream and an Observable is done after an error occured, so if we do that, no more actions will flow through the application. This is why we use the switchMap/catch combination and we make sure we create a test that checks this case.

We create a mock for our service using *createSpyObject *method from jasmine and we handle both cases where we want to return a value or an error:

If we pass in a value, we return an observable that will emit that value and if we pass in an error object, we return an observable that will throw that error.

Having this in place we can create our first test to check that we can retrieve data:

This looks pretty much as our first simple test, we instantiate a new service instance with our mock method and pass it in the effect constructor. Checking the expected value is pretty much as before. For simplicity we’re checking just the action type, but in a more real world application we would also check that the payload from the action contains the data that we want.

As mentioned above, we need to make sure we handle an exception on the stream, so we also test that our catch method works as it should:

In this case we create our service and pass an error so when we call *getDummyData *it will emit the error and it should be caught and transformed in a data fetch failed action.

Another type of effect that we can have is where we might need some other data from our application state in order to process the action or to generate a new one. This would be simple if the data would be in the same part, handled by the same reducer, but imagine that we have a more complex state object and we need to fetch something from different places. An option is to inject the store in the effect class and select what we need:

Notice that we’re creating two streams *numberStream *and *textStream *that read some data from the state and then use these values in the effect, in the *withLatestFrom *operator.

In order to test this effect we need to mock the store and make sure we select whatever data we want from it. If we would have only one stream we could have easily mocked the store and return whatever we want:

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

But if we have multiple streams for which we use different selector it will be more tricky. One nice way to handle this is to actually initialize the state with the default value by calling the root reducer with an unknown ‘INIT’ action. Then we can call the selector on the state object and return the result in a stream:

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

The whole test looks like this:

The last type of test that I’ve encountered is that where we need to control time :) If we use different kind of operators like _timer_, *interval *or _debounceTime_ on our effects we need some special handling in our tests.

Suppose we have an effect that looks like this:

We can see that we use _debounceTime_ operator to emit only the last value from a period of time and ignore the rest. Since we do this our normal way to test this will not work, since when we check the expected value the initial one will not have emitted anything.

One dirty way to hack around this is to spy on the operator and make it do nothing:

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

Basically we just return the stream itself without anything applied to it, and then we can write the test as we would normally do, just make sure to spy on the observable operator before we create the effect:

A second approach is to use the Scheduler that is provided by the jasmine marbles library. If you look in the ngrx repository at [the sample app](https://github.com/ngrx/platform/blob/master/example-app/app/books/effects/book.ts) you can see that an optional injected scheduler is used inside the effects class. If it’s provided it’s used, if not, the default one from rxjs is used.

While this approach works just fine, it makes you add some code in all the effect classes that is not used for anything else beside testing. Another thing is that you’ll have to instantiate the effect using the TestBed provided by Angular to make sure that everything is in place.

A different approach, using the same scheduler that you can fetch using *getTestScheduler *method, is to override all the required Observable operators to use it:

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

A similar approach to what we used in the first try, here we just save the original operator and call it with our scheduler.

This will make sure our test passes again, as long as we spy on the operator before we instantiate the effect class:

So far these have been the most common scenarios that I’ve encountered while writing tests for ngrx effects.

You can find the complete [working code on GitHub](https://github.com/adrianfaciu/testingNgRx). Have fun writing tests ;)


text:
---
layout: post
title:  "2/1: The Great Kindness Challenge"
date:   2021-2-1 05:30:59
author: Lucy Zises
categories: Advocacy
---
Payton's students with disabilities are learning about the power of kindness. Every act of kindness matters, which is why we are asking students and faculty to participate in The Great Kindness Challenge! Please send in your daily acts of kindness either via [Google Form](https://forms.gle/sWU3Gj6dP1q8xqi2A) or by mailing/dropping off bright strips of paper with the acts written on them to a box outside of Payton. The students will turn these colorful strips into a chained work of art that grows with every submission and represents the kindness and love in our Payton community! Reach out to Ms. Spencer at<EMAIL_ADDRESS>with any questions!

- [Kindness Form](https://forms.gle/sWU3Gj6dP1q8xqi2A)
- [Kindness Video](https://youtu.be/EghSSOzgwX4)

repository: awissink/wpcpbb

repo_name: awissink/wpcpbb


text:
---
title: "Check your Extension version and Firewall settings"
category: "Magento 1 Q&A"
template: "faqs"
tags: "Magento, Magento 1, fail-orders, fail-order, fail-order-m1"
---

Older versions of the M1 Extension are no longer supported and are likely to cause "`fail-order`" errors within the new app. Please check that your extension version matches the latest version available (https://github.com/zendesk/magento_extension). If not please update by following the instructions in [Magento: Installing the Zendesk extension for Magento.](https://support.zendesk.com/hc/en-us/articles/203660046-Magento-Integration-Installing-the-Zendesk-extension-for-Magento)

Errors caused by outdated M1 Extension versions can be seen within your Magento PHP logs, and include the following error messages:

ArgumentCountError

Uncaught exception ‘ArgumentCountError’ with message ‘Too few arguments to function Zendesk_Zendesk_ApiController::ordersAction()

or

```
PHP Fatal error: Call to a member function find() on a non-object in /var/www/html/apache.git/magento/store2/app/code/community/Zendesk/Zendesk/Model/Observer.php`
```

## Check your firewall configuration for Zendesk

If are experiencing a "`fail-orders`" error, you may have a firewall in front of your Magento instance (and/or CDN) that needs to be configured to ensure it allows access from Zendesk's built-in Secure Prooxy. Wnsure you have allowed unrestricted access to your Magento 1 Extension's API routes **_<< YOUR STORE URL >>/index.php/zendesk/api/*_** from your Zendesk Subdomain and/or Zendesk’s IPs. For more details, see [Configuring your firewall for Zendesk.](https://support.zendesk.com/hc/en-us/articles/203660846).

repository: aagatsapkota/alexa-skill

repo_name: aagatsapkota/alexa-skill


text:
---
published: true
layout: post
title: "Chapter 184 - Mere Worldly Possessions Are Nothing To Worry About"
category: zhan-xian
previous_chapter: 183
next_chapter: 185
chapter:
  number: 184
date: 2017-02-26 17:10:00 +0200
has_note: false
note: ""
is_sponsored: false
sponsors: []
has_credits: false
translator:
editor:
proofreader:
is_preview:
---
For Gao Yue and Gongsun Ling, this was the first time someone was targeting them. Gao Yue was still fine compared to Gongsun Ling. She had experienced someone attacking her at the Great NanHuang Mountains, but Gongsun Ling never had such experience.

The experienced Gao Yue hated such actions even more, especially right now, when these people were targeting Yang Chen. Unconsciously, both Gao Yue’s and Yang Chen’s minds were set on each other more seriously, thinking that they could allow themselves to be hurt, but not the other person.

Moreover it was Gongsun Ling’s first time facing a life and death battle within the cultivation world. Although she had already experienced the sect’s martial art competition and had also tempered herself at the Immortal Falling Well, this was her first time fighting a true life and death battle. What astonished Yang Chen was that, even under these circumstances, Gongsun Ling didn’t seem to be the slightest bit nervous, instead she seemed to be looking forward to it.
<!--more-->

The thirst for battle was perhaps fostered in the Immortal Falling Well, but at that time Gongsun Ling had only faced underground spirit beasts and hadn’t thought of targeting cultivators. Right now, that thirst for killing evolved from the bottom of her heart had been rekindled after her discussion with Yang Chen. Perhaps Yang Chen had confidence that Gongsun Ling would walk even further in this life.

After discovering the enemy’s presence, under probe of Gui Shanyou’s spiritual awareness, everyone knew what kind of tricks the enemy had planned. Spell flags were placed properly, but they couldn’t hide them from this formidable Da Cheng stage expert.

Naturally, Yang Chen was the one who told the others everything, as Gui Shanyou’s existence had to be kept hidden from them. Yang Chen absolutely didn’t want Gao Yue and Gongsun Ling to think that they had a support, otherwise if they walked into battle knowing that they would never be defeated, the opportunity to temper themselves would be meaningless.

“That is the coiling spell.”

In the field of spell formations, if Yang Chen didn’t have the knowledge of a Great Principal Golden Immortal from his previous life, then the most formidable among them was Gongsun Ling, who identified the spell formation of the spell flag with one glance:

“It is used to capture people, not kill them. I can’t arrange such a formation, at the moment.”

Having enough insights but not enough strength was a normal thing. Neither Yang Chen nor Gao Yue found it strange, but Yang Chen intended to temper Gao Yue and Gongsun Ling, so he didn’t say anything, moreover this entire battle was just for the benefit of his master and his senior apprentice sister.

From another point of view, it would seem that Yang Chen was instructing his master and senior apprentice sister. Just from the aspect of seniority, this was in reverse order. It was an extremely strange affair. Even more than instructing, he seemed to be testing them.

In their personal opinion however, it was not strange. Yang Chen had long ago proven that his battle experience and ability to battle was much higher than theirs, not to mention others, just the number of qiankun pouches which Yang Chen had obtained after killing enemies was sufficient proof of everything. Let alone the life and death challenges which he had won against people stronger than him.

“What should we do?”

Gao Yue and Gongsun Ling was frantically thinking about their approach. Yang Chen had already told them about the enemy’s strength, three JieDan stage experts, three Foundation stage experts and a few qi layer cultivators which shouldn’t be much of a problem, but the first six people were formidable, so regardless of anything, they had to be defeated first.

Taking another way was also an option, but that would certainly make them look cowardly. Moreover, both women understood Yang Chen’s intentions, and didn’t want to step aside. They also realized that if they conceded there, if a similar situation happened in the future, it would be very troublesome and having such matter gnawing at their mind would certainly be detrimental to their cultivation.

“I can tell you my appearance hiding spell formation, but we still won’t be able to break away from the entanglement of the coiling spell formation.”

Gongsun Ling spoke about the things she could handle:

“I have another spell formation which can restrain the coiling spell, but my cultivation is not sufficient. Even if I stake all of my spirit power in it, I would still be unable to resist it. But if aunt master Gao helps me, then maybe we can do something, but she will be unable to protect herself from enemies.”

After thinking of everything, they understood that breaking a high grade spell flag could only be done by relying on another spell formation to break it. Just relying on Gao Yue who only had the strength of the initial JieDan stage, they simply would not be able to handle three JieDan stage experts, but if they used spell formations, they may be able to trap the enemy and then kill them or cut off their limbs, and everything would be easy.

There was only one problem: their spirit power was insufficient. Even if the spirit power of Yang Chen, Gao Yue and Gongsun Ling was combined, it still wouldn’t be enough to match up with the three JieDan experts. Clearly, they were in a disadvantageous position.

“If you just require spirit power for the spell formation, I may have a way.”

Yang Chen was not worried much about Gongsun Ling failing. As long as they had a method, he would do everything he could to help with it. Since Gao Yue and Gongsun Ling had both agreed that this was the best method, Yang Chen would naturally support it:

“If the spirit power for the spell formation is not enough, use spirit stones.”

“They are spell flags refined by three JieDan stage experts, they also have spirit stones. We will not be able to compete with them.”

Gongsun Ling shook her head. She wasn’t very optimistic regarding Yang Chen’s suggestion to use spirit stones to solve the problem of their spirit power being insufficient:

“The spirit stones used by the two spell formations will be finite, we would have to use at least two whole pieces, possibly it would also be completely exhausted. This is no good!”

“There are no certain things in this world. Maybe it will work!”

“Just spirit stones won’t work, we require……….”

Gongsun Ling could only speak half the sentence and then couldn’t say another word. On the other side, Gao Yue was also looking at Yang Chen in astonishment, not daring to believe what she was seeing.

Two pieces of top quality spirit stones, each seemed to be around one jin, twinkling brightly within Yang Chen’s hands like two bright pearls, attracting the attention of both women.

“These spirit stones should be enough, shouldn’t they?”

Yang Chen asked with a smile.

“Enough!”

Gongsun Ling replied a little sluggishly, taking the two jin of top grade spirit stones, that were actually equivalent to two hundred jin of high grade spirit stones, twenty thousand jin of middle grade spirit stones and two million jin of low grade spirit stones. With this much, forget about dealing with some JieDan stage expert’s trifling coiling spell, even if a peak YuanYung stage cultivator had been there, in terms of spirit power, they still wouldn’t be at a disadvantage.

“So, what’s next?”

“Do you really intend to use these two top grade spirit stones?”

Even with spirit stones in her hand, Gongsun Ling still couldn’t dare to believe it. While holding them, she clenched her hands as tightly as she could to feel that sensation of the spirit stones, ready to overflow, and sense the extremely smooth and soft surface, only then could she believe it. But when she was allowed to use both of the spirit stones immediately, she still hesitated a little.

“These are mere worldly possessions, as long as we can obtain victory, this is not too high of a price to pay.”

Yang Chen nodded his head, as if instructing both of them and continued to speak:

“At the crucial time, even if it is your destined flying sword, you should be ready to abandon it. Always remember, your life is far more precious than these mere worldly possessions.”

The argument was quite easy to understand but when the time came, it may not be so easy to follow it. Even Gao Yue, who was a JieDan stage expert, had never seen a top grade spirit stone before.

Just these two spirit stones easily surpassed both Gao Yue and Gongsun Ling’s entire wealth combined, at least by a hundred times. So when they were suddenly asked to use such a large amount of wealth, they could not help but feel astonished.

Gao Yue quickly understood something and subtly raised her head, glancing at Yang Chen, just when Yang Chen was looking straight at her with a smile dancing in his eyes. A trace of a smile also blossomed on Gao Yue’s face. Looking into Yang Chen’s eyes, she felt very grateful.

After another moment, Gongsun Ling also finally looked up from her internal struggle and took a deep breath, but her expression clearly conveyed that she had been relieved of some burden.

“I understand, younger apprentice brother Yang!”

Gongsun Ling faintly nodded her head towards Yang Chen:

“I used to believe that I was already unaffected by worldly possessions, but after seeing right now, it seems that was not the case before.”

Tossing the spirit stones around in her hand, Gongsun Ling smiled without any worries:

“Then let’s see how formidable the spell formation will be after being propelled by top quality spirit stones.”

Gao Yue was also thinking of the same thing. Cultivators should never have to worry about worldly possessions, only then could they completely free their minds. But, in the end, cultivators were also people and knew the importance of wealth and companionship. While everyone was vying for these, they could also subconsciously get caught up in the worries for mortal treasures.

Yang Chen’s lesson allowed both of them to undergo a small baptism for the first time. Their mental state blossomed even more, which naturally would be very beneficial towards their cultivation.

Although Gongsun Ling’s research of that senior’s illusion spell was not complete, she could already make a lesser imitation. As for another spell formation which would resist the coiling spell, it was simply the five phases sword attack spell formation. As long as the attacks were sufficiently incisive, regardless of what kind of entanglement it was, everything could be cut.

The JieDan expert monitoring the three people didn’t dare to get too close and kept looking at the three of them talking from afar for a good moment, then he sat down on the ground to rest. Afterwards he disappeared from where he had appeared in a flash.

The JieDan expert suddenly felt something amiss and could not help but rub his eyes. When he looked again, he became certain that the three people had certainly disappeared from their original place.

Yang Chen and both women had entered the illusion spell arranged by Gongsun Ling. Although this illusion spell didn’t have any killing power, it had a strong invisibility effect. The people using it couldn’t even be discovered by using spiritual awareness. They could only be discovered if someone walked into the region.

The three inside the spell could clearly see the figure of that JieDan stage expert rushing over. Seeing the silhouette, Gongsun Ling faintly laughed and with a tremble, the spirit stone embedded in the spell flag fell to the ground.

She was very fortunate. Under a large amount of stress, that JieDan expert directly entered the killing spell and basically didn’t have any time to respond.

But still, the reaction of that JieDan expert was quite fast. He immediately summoned a magic weapon. The magic weapon was called out hurriedly however. In front of the attack power of the spell formation, driven by top quality spirit stones, the defensive magic weapon was simply like paper.

Bang!

Just as the armor took shape on his body, it was directly crushed into pieces by the powerful attack of the spell formation. As for the expert himself, his body trembled violently and he began to puff out blood madly. With great injuries, he wasn’t able to maintain the armor anymore and many formless flying swords pierced his body as if it was a sieve.

“So simple? How is it possible?”

Gongsun Ling simply didn’t dare to believe what she was seeing. A JieDan stage expert hadn’t even been able to stand up in front of her. The difference between their strengths and the actual result was very shocking, which put Gongsun Ling at a loss for a good moment.

“The five phases sword spell formation which only has offensive strength is the most simple spell formation and perhaps because it is the simplest spell formation, it can use all of its strength on attacking and can also make the most efficient use of spirit power in the spirit stone.”

Yang Chen lauded:

“The choice of spell formation is quite good!”

Gongsun Ling was both frightened and delighted. Admittedly, killing this JieDan expert had a hint of a sneak attack, the enemy basically didn’t have the time to respond, but it also clearly showed that it was not necessary that only a highly complex spell formation would shine in battles. Sometimes the simplest spell formation used correctly could reveal astonishing strength.

This kind of real combat was a completely different experience for Gongsun Ling. Compared to killing those underground spirit beasts who didn’t have any intelligence, by attracting them to the simplest traps, it was more complex and completely novel.

Their enemies were a few JieDan stage experts, moreover they still didn’t know anything, so this was the perfect time. The illusion spell made by Gongsun Ling allowed the three people to noiselessly approach those people who were waiting to ambush them.

“Isn’t such a method despicable?”

Gongsun Ling still hadn’t completely accepted this method and could not help but ask Yang Chen, who was hidden within the illusionary spell some distance away from her.

“So is it righteous, that those people have sent so many JieDan stage and Foundation stage cultivators to attack us three people?”

Yang Chen didn’t reply directly, but rather asked a rhetorical question.

“So, even if we won by using such a method and this method worked again in the future, would it also be usable at the time of a tribulation?”

Before reaching the Foundation stage, Gongsun Ling had been deeply influenced by the academics of the sect and hence still resisted launching a sneak attack.

“I am not asking senior apprentice sister to use this kind of method every time.”

Yang Chen gazed into Gongsun Ling’s eyes and sternly said:

“I only wanted to let senior apprentice sister become aware that such methods can also be used. Moreover, this method was thought of by you yourself, senior apprentice sister, isn’t that so? What kind is to be used at what time is entirely up to you.”

After saying this, Yang Chen seemed to be wanting to continue and added:

“Senior apprentice sister, actually the heavenly tribulations are not passed by using the same method. All of those seniors who passed the heavenly tribulation didn’t use only one method.”

“I understand!”

Gongsun Ling was worthy of being considered a genius and quickly understood Yang Chen’s intention and was no longer confused.

Gao Yue standing near them didn’t say anything, quietly listening to their dialog. Although the conversation between Yang Chen and Gongsun Ling was quite simple, the content was not profound, it still created much for her to reflect upon.


text:
# nRF_Detekt

The best documention for this project will be the code, I like to comment and I feel like my code has been extra readable for this project.  This is meant as an add-on of sorts to existing security systems.  It's nice having the code and being able to flash MCU.

Using nRF24L01+ radio modules nRF_Detekt send remote logs of activating a sensor from a transmitter connected to sensor; to an ideally hidden receiver.  If device uses wire as transmission line, it would be easy for a physical attacker to "follow the line" to logging device.

I won't move development to Atmel Studio 7 for this project.  But I would like more debugging capabilities (and just a better IDE) in the future.

Add in these libraries to the Arduino IDE to build:

==> RF24: https://github.com/tmrh20/RF24/

==> Entropy: https://sites.google.com/site/astudyofentropy/project-definition/timer-jitter-entropy-sources/entropy-library

==> XTEA: https://github.com/franksmicro/Arduino/tree/master/libraries/Xtea

==> AESLib: https://github.com/DavyLandman/AESLib

==> LiquidCrystal_I2C: https://arduino-info.wikispaces.com/LCD-Blue-I2C?responseToken=1e511cd9cf16df3bfb9d039fb46f4752

Currently using AES-128-ECB, then XTEA, then AES-128-ECB encryption of a 32 byte struct: a microsecond timer, 4 entropy samples, a millisecond timer, and 2 authentication variables as the packet being sent back to the receiver, whenever a sensor changes state.  This should mean that the same encrypted data would be sent very rarely, if at all.  Also, the 2 authentication variables means not just anything can be sent to the receiver.  I kept going back and forth between more authentication but more similar messages, and less authentication but less similar messages (since I'm using AES-128-ECB) but settled on less authentication.  I'm not sure how to do IV's for AES-CBC between radios just yet (I can say what I want, just not sure how to do it).

It will use a AMS1117 5V-3.3V regulator module, to supply the radio with enough power.  As is, just using the 3.3V output pin on the Arduino does not supply enough current for the radio (supplies max of 50mA, we need about 130mA or so).  You could also use a transistor as an amplifier for the power, or use a completely separate power supply like a LM317T (probably the best, safest, most secure option but I'm choosing not to do that for "looks" and keeping everything compact).

My WishList is the following:

1) Want to support more better and stronger ciphers/modes.

2) Want to make a "shield" for holding the nRF24 module and a separate power supply.

3) Want some kind of "spread spectrum" implementation integrated in, to change channels on every send.

4) Want to incorporate some kind of authentication chip, like the ATSHA204A.

5) Want a battery backup power system that switches on if AC power is lost.

/* Development will happen sporatically, but mostly thru the summer and winter break times.  I want to move to some other projects too.  But I will keep revisiting this project because I know it can eventually be really good. */

![nrfd_p1](http://1.bp.blogspot.com/-XRwyKl3rFLQ/VrG48nReEUI/AAAAAAAAANI/AyTfjKfyB_s/s1600/0101161626.jpg)

![nrfd_p2](http://4.bp.blogspot.com/-xkpkRvPDMsE/VrG4_sUPCWI/AAAAAAAAANM/GqbcLJq_DQE/s1600/0101161633.jpg)

![nrfd_p3](http://1.bp.blogspot.com/-APzVJiaRSlg/VrG5CoMjAJI/AAAAAAAAANQ/rdJeIdwVzW8/s1600/0119160345.jpg)

![nrfd_p4](https://1.bp.blogspot.com/-V6RRoeGqZPg/V2uCpYnySYI/AAAAAAAAAN8/IaAWHKK6qqYHWNv0ph-Pu7p8cYir21IUQCLcB/s1600/nrf_detekt_pinout_recv.png)

![nrfd_p5](https://3.bp.blogspot.com/-Q-tvfZppnik/V2uCptDcHRI/AAAAAAAAAOE/gbL02jddSIcf1gVidwmsiHgbPR11BbApwCLcB/s1600/nrf_detekt_pinout_trans.png)

![nrfd_p6](https://1.bp.blogspot.com/-eC6pKo5zhXY/V3gafeqXVII/AAAAAAAAAOY/qT0lQnu-qJ406bZvJfdvNyXJu8U531yaQCLcB/s1600/0702161534%255B1%255D.jpg)

gha_language: Arduino


text:
# Attention!

On Windows 8.1, the origin of unexpected errors can occur with unknown use (random clicking on buttons, abrupt navigation between menus, etc.); such as: application crash, endless error generation and so on. At the moment the application works stably on: macOS, Windows 10 (7 not tested), Linux.

In the event of errors: write to<EMAIL_ADDRESS>with a description of the error and the order of the forgoing actions. Delete DataBase/RSSDataBase/RSSLinks.txt, or the entire DataBase directory and restart the application.

# iReadNews

Hey. Maybe you wonder how I'm doing? Even if yes, I do not have RSS feeds ...
But many of your favorite news sites have! This application will help cache the news
for today so that you can read them in the metro. Connect any RRS-tape and read what you like!

How to use the application:
1. Open it
2. Connect any RSS-feed
3. After that you can add and cache any tape and save them!

So it's open source, so you can screw anything here!

repository: poluh/iReadNews

gha_language: Java

repo_name: poluh/iReadNews


text:
requirejs-handlebars
====================

This is an AMD loader for [Handlebars semantic templates](http://handlebarsjs.com/) which can be used as a drop-in replacement to [SlexAxton/require-handlebars-plugin](http://github.com/SlexAxton/require-handlebars-plugin/blob/master/hbs.js)

## Overview

- Uses an external HandlebarsJS engine (distributed by the Handlebars team).
- Uses the official ``text`` loader plugin maintained by the RequireJS team.
- You don't have to specify the template file extension (``.html is assumed``, but this is configurable).

Notes:

- The ``text`` and ``hbar`` plugins can be removed at build-time using ``r.js`` (with the ``stubModules`` setting).
- The extension ``.html`` is assumed, and this makes loading templates similar to loading JavaScript files with RequireJS (all extensions are assumed).

## Changelog

0.0.1 Initial version

0.0.2 Various updates:
- Add template path option to hbar.js (thanks drewrichards)
- Updated require.js to 2.1.8 , and r.js to 2.1.8
- Updated handlebar.js to 1.0.0

## Installation

Download HandlebarsJS and RequireJS-text:

- [HandlebarsJS](http://handlebarsjs.com/)
- [RequireJS-text](http://requirejs.org/docs/download.html#text)

Typically, you would place them in a ``scripts/libs`` folder then create a ``scripts/main.js`` file to alias them and to shim Handlebars:

```
require.config({
  paths: {
    Handlebars: 'libs/handlebars',
    text: 'libs/text'
    hbars: 'libs/hbars'
  },
  shim: {
    Handlebars: {
        exports: 'Handlebars'
    }
  }
});
```

## Usage

Specify the plugin using ``hbars!`` followed by the template file:

```
require(['backbone', 'hbars!template'], function (Backbone, template) {
  return Backbone.View.extend({
    initialize: function(){
      this.render();
    },
    render: function(){
      this.$el.html(template({message: 'hello'}));
  });
});
```

## Customization

You can specify the template file extension in your main.js:

```
require.config({

  // some paths and shims

  hbars: {
    extension: '.hbs', // default = '.html'
    compileOptions: {}  // options object which is passed to Handlebars compiler
  }
});
```

## Optimization

This plugin is compatible with [r.js](http://requirejs.org/docs/optimization.html).

Optimization brings three benefits to a project:

- The templates are bundled within your code and not dynamically loaded which reduces the number of HTTP requests.

- The templates are pre-compiled before being bundled which reduces the work the client has to do.

- Since templates are pre-compiled during build you can use the handlebars.runtime which is ~1KB after minification+gzip.

If you don't use any extra tool to manage your libraries, need to manually replace the handlebars.runtime during compilation by adding this routine to your main.js. See the example for how it works:

```
    onBuildWrite : function(moduleName, path, content){

        // replace handlebars with the runtime version
        if (moduleName === 'Handlebars') {
            path = path.replace('handlebars.js','handlebars.runtime.js');
            content = fs.readFileSync(path).toString();
            content = content.replace(/(define\()(function)/, '$1"handlebars", $2');
        }
        return content;
    }
```

The most important build options are:

```stubModules: ['text', 'hbars']```

The list of modules to stub out in the optimized file, i.e. the code is replaced with ``define('module',{});`` by ``r.js``

```removeCombined: true```

Removes from the output folder the files combined into a build.

## Example

Sample build options are in the root ``build.js``. Compile the example using:

```
  $ ./build.sh
```

Copy the ``example`` and ``example-build`` folders to your web server (``text`` is not compatible with the ``file://`` protocol and opening ``index.hml`` directly from your browser will not work).

### Using a test server

Alternatively, you can use Connect and NodeJS to spin a web server:

- Install ``connect`` using ``npm`` and launch the server with NodeJS:

```
  $ npm install -g connect
  $ npm link connect
  $ node server.js
```

Go to [http://localhost:9000/example](http://localhost:9000/example). Your browser should load:

- index.html
- require.js
- main.js
- hbars.js
- handlebars.js
- text.js
- message.html

Go to [http://localhost:9000/example-build](http://localhost:9000/example-build). Your browser should load:

- index.html
- require.js
- main.js

repository: aerisweather/aerisjs

repo_name: aerisweather/aerisjs


text:
Angular Redux
=========================

[![Build Status](https://img.shields.io/travis/bcarroll22/ng-component-redux/master.svg?style=flat-square)](https://travis-ci.org/bcarroll22/ng-component-redux) [![npm version](https://img.shields.io/npm/v/ng-component-redux.svg?style=flat-square)](https://www.npmjs.com/package/ng-component-redux)

Angular component bindings for [Redux](https://github.com/reactjs/redux).
Inspired by [ng-redux](https://github.com/angular-redux/ng-redux) and [react-redux](https://github.com/reactjs/react-redux). A great way to manage application state in component-based applications.

## Advantages
[@wbuchwalter](https://github.com/wbuchwalter) did a great job with [ng-redux](https://github.com/angular-redux/ng-redux), and if you need to use Redux with an earlier version of Angular, be sure to check out his package. The main motivation for building this package was having the ability to build Angular 1.5 applications with Redux bindings that were component based, just like the React bindings.

Possibly the single greatest advantage of this package is that nearly all code that is written for react-redux can be directly ported to an Angular application using this package. This is because the `connect` function to create connected components works the same way, and stores are configured and used in the application almost entirely the way you would in a react-redux application.
The only exception is that this package provides a helper function that will allow you to get Angular dependencies to use in middleware. This helper can be accessed via `import injector from 'ng-component-redux'`

## Installation

This package requires Angular 1.5.3 or higher. This is because this package relies on Angular 1.5's `.component()` method, and also takes advantage of the lifecycle hooks introduced in v1.5.3.

To install this package, run:
```
npm i -S ng-component-redux
```
The preferred method of using this package is with a build system such as Browserify or Webpack and npm. If, however, you don't yet use a modern build system or npm, you can include the pre-built UMD module which can be found in the dist directory, and access it via the global `AngularRedux` object. This is not a recommended approach since many complementary redux packages are only available via npm.

## Documentation
- [Using this Package](docs/usage.md#usage)
- [API](docs/api.md#api)
  - [`<provider store>`](docs/api.md#provider-store)
  - [`connect([mapStateToProps], [mapDispatchToProps])`](docs/api.md#connectmapstatetoprops-mapdispatchtoprops-mergeprops-options)
  - [`injector([ngDependency])`](docs/api.md#connectmapstatetoprops-mapdispatchtoprops-mergeprops-options)

## License
MIT

## Credits
Huge thank you to [@gaearon](https://github.com/gaearon/) for creating [redux](https://github.com/reactjs/redux) and [the official React bindings](https://github.com/reactjs/react-redux). This package was heavily based off of and inspired by the React bindings.

Also, many thanks to [@wbuchwalter](https://github.com/wbuchwalter) for building ng-redux, which allowed me to gain my first exposure to Redux in an Angular 1.x application.

repository: npmcdn-to-unpkg-bot/ng-component-redux

repo_name: npmcdn-to-unpkg-bot/ng-component-redux


text:
# Password Importer plugin for Passbolt

This is a CakePHP plugin for PassBolt to enable importing secrets/passwords to the community edition.

After importing the secrets/passwords a detailed downloadable report will appear with imported-, existed- secrets/passwords and errors.

The plugin is tested on the dockerized version _2.1.0-debian_ and _2.3.0-debian__. Check [Docker](./Dockerfile) for an example.

### Screenshots

![screenshots](https://raw.githubusercontent.com/aahmadts/general-styleguide/master/images/passbolt-password-importer-screenshot-1.0.2.png)

![report-screenshots](https://raw.githubusercontent.com/aahmadts/general-styleguide/master/images/passbolt-password-importer-screenshot-report.png)

## Installation

You can install this plugin into your CakePHP application using [composer](http://getcomposer.org).

### Composer
The recommended way to install composer packages is:

```
composer require aahmadts/passbolt-password-manager
```

### Manually Installing a Plugin

Download PasswordImporter into the `passbolt/plugins` folder, then let composer know about it by adding the following into _composer.json_

    {
        "autoload": {
            "psr-4": {
                "PassboltPasswordImporter\\": "plugins/passbolt-password-manager/src/"
            }
        }
    }

After that run this composer command

    php composer.phar dumpautoload

### Load Plugin

After installing the plugin you will need to tell PassBolt to load the Plugin by extending the `config/bootstrap.php` with the following:

	Plugin::load('PassboltPasswordImporter', ['routes' => true]);

or if you have cake's console installed use:

    ./bin/cake plugin load aahmadts/PassboltPasswordImporter

For more info about CakePHP Plugins check here: https://book.cakephp.org/3.0/en/plugins.html

## Usage

To use the Password Importer run `https://your-domain/password-importer` and enjoy.

repository: aahmadts/passbolt-password-importer

gha_language: PHP

repo_name: aahmadts/passbolt-password-importer


text:
# LIVER-PATIENT-ANALYSIS

[![author](https://img.shields.io/badge/author-Abhishek-ff69b4.svg?style=flat-square)](https://www.linkedin.com/in/abhishekmali/)
[![GitHub followers](https://img.shields.io/github/followers/AbhishekMali21?style=social)](https://github.com/AbhishekMali21?tab=followers)
[![GitHub watchers](https://img.shields.io/github/watchers/AbhishekMali21/LIVER-PATIENT-ANALYSIS?style=social)](https://github.com/AbhishekMali21/LIVER-PATIENT-ANALYSIS/watchers)
[![GitHub stars](https://img.shields.io/github/stars/AbhishekMali21/LIVER-PATIENT-ANALYSIS?style=social)](https://github.com/AbhishekMali21/LIVER-PATIENT-ANALYSIS/stargazers)
[![GitHub forks](https://img.shields.io/github/forks/AbhishekMali21/LIVER-PATIENT-ANALYSIS?style=social)](https://github.com/AbhishekMali21/LIVER-PATIENT-ANALYSIS/network/members)

![GitHub language count](https://img.shields.io/github/languages/count/AbhishekMali21/LIVER-PATIENT-ANALYSIS?style=flat-square)
![GitHub top language](https://img.shields.io/github/languages/top/AbhishekMali21/LIVER-PATIENT-ANALYSIS?logoColor=9cf&style=flat-square)
![GitHub repo size](https://img.shields.io/github/repo-size/AbhishekMali21/LIVER-PATIENT-ANALYSIS?logoColor=important&style=flat-square)

[![GitHub issues](https://img.shields.io/github/issues/AbhishekMali21/LIVER-PATIENT-ANALYSIS?style=flat-square)](https://github.com/AbhishekMali21/LIVER-PATIENT-ANALYSIS/issues?q=is%3Aopen+is%3Aissue)
[![GitHub closed issues](https://img.shields.io/github/issues-closed/AbhishekMali21/LIVER-PATIENT-ANALYSIS?style=flat-square)](https://github.com/AbhishekMali21/LIVER-PATIENT-ANALYSIS/issues?q=is%3Aissue+is%3Aclosed)
[![GitHub pull requests](https://img.shields.io/github/issues-pr/AbhishekMali21/LIVER-PATIENT-ANALYSIS?logoColor=yellow&style=flat-square)](https://github.com/AbhishekMali21/LIVER-PATIENT-ANALYSIS/pulls?q=is%3Aopen+is%3Apr)
[![GitHub closed pull requests](https://img.shields.io/github/issues-pr-closed/AbhishekMali21/LIVER-PATIENT-ANALYSIS?logoColor=yellow&style=flat-square)](https://github.com/AbhishekMali21/LIVER-PATIENT-ANALYSIS/pulls?q=is%3Apr+is%3Aclosed)
[![LICENSE](https://img.shields.io/dub/l/vibe-d.svg?style=flat-square)](https://github.com/AbhishekMali21/LIVER-PATIENT-ANALYSIS/blob/master/LICENSE)
[![HitCount](http://hits.dwyl.com/AbhishekMali21/LIVER-PATIENT-ANALYSIS.svg)](http://hits.dwyl.com/AbhishekMali21/LIVER-PATIENT-ANALYSIS)

### Objectives of Research
In India, delayed diagnosis of diseases is a fundamental problem due to a shortage of medical
professionals. A typical scenario, prevalent mostly in rural and somewhat in urban areas is:
1. A patient going to a doctor with certain symptoms.
2. The doctor recommending certain tests like blood test, urine test etc depending on the
symptoms.
3. The patient taking the aforementioned tests in an analysis lab.
4. The patient taking the reports back to the reports back to the hospital, where they are
examined and the disease is identified.

This project aims to reduce the time delay caused due to the unnecessary back and forth shuttling between the hospital and the pathology lab. Here a machine learning algorithm will be trained to predict a liver disease in patients using a data-set collected from North East of Andhra Pradesh, India.

### Problem Statement
The problem statement is formally defined as:
‘Given a dataset containing various attributes of 584 Indian patients, use the features
available in the dataset and define a supervised classification algorithm which can identify
whether a person is suffering from liver disease or not. This data set contains 416 liver patient
records and 167 non- liver patient records.The data set was collected from north east of Andhra
Pradesh, India. This data set contains 441 male patient records and 142 female patient records.
Any patient whose age exceeded 89 is listed as being of age "90"

### Team Members

- [@AbhishekMali21](https://github.com/abhishekmali21) - **Abhishek Mali** (Project Head)
- [@AdityaSindol](https://github.com/AdityaSindol) - **Aditya Sindol**
- [@KeshavPola](https://github.com/keshavpola) - **Keshav Pola**
- [@KaranDange](https://github.com/KaranDange) - **Karan Dange**
- [@Veereshsg](https://github.com/Veereshsg) - **Veeresh Gobbur**

### Context
Patients with Liver disease have been continuously increasing because of excessive
consumption of alcohol, inhale of harmful gases, intake of contaminated food, pickles and
drugs. This dataset was used to evaluate prediction algorithms in an effort to reduce burden on
doctors.

### Content
This data set contains 416 liver patient records and 167 non liver patient records
collected from North East of Andhra Pradesh, India. The "Dataset" column is a class label used
to divide groups into liver patient (liver disease) or not (no disease). This data set contains 441
male patient records and 142 female patient records. Any patient whose age exceeded 89 is
listed as being of age "90".

### Columns:
* Age of the patient
* Gender of the patient
* Total Bilirubin
* Direct Bilirubin
* Alkaline Phosphotase
* Alamine Aminotransferase
* Aspartate Aminotransferase
* Total Protiens
* Albumin
* Albumin and Globulin Ratio
* Dataset: field used to split the data into two sets (patient with liver disease, or no disease)

### Screenshots

👉 **Node Red Flow**

![Noderedflow](https://github.com/AbhishekMali21/LIVER-PATIENT-ANALYSIS/blob/master/Screenshots/Node%20Red%20Flow.png)

👉 **ML Model UI**

![MLModelUI](https://github.com/AbhishekMali21/LIVER-PATIENT-ANALYSIS/blob/master/Screenshots/ML%20Modek%20UI.png)

### Conclusion

Initially, the dataset was explored and made ready to be fed into the classifiers. This
was achieved by removing some rows containing null values, transforming some columns
which were showing skewness and using appropriate methods (Label Encoding) to convert
the labels so that they can be useful for classification purposes. Performance metrics on which
the models would be evaluated were decided. The dataset was then split into a training and
testing set.

Firstly, a naive predictor and a benchmark model ('Logistic Regression') were run on
the dataset to determine the benchmark value of accuracy. The greatest difficulty in the
execution of this project was faced in two areas- determining the algorithms for training and
choosing proper parameters for fine-tuning. Initially, I found it very vexing to decide upon 3
or 4 techniques out of the numerous options available in sklearn.

This exercise made me realize that parameter tuning is not only a very interesting but
also a very important part of machine learning. I think this area can warrant further
improvement, if we are willing to invest a greater amount of time as well as computing power.


text:
# Record Audio
## Notes
Records audio with the given parameters.
## Syntax
```
recordAudio(quality: <#Type (WFRecordingCompression)#>, start: <#Type (WFRecordingStart)#>, end: <#Type (WFRecordingEnd)#>, duration: <#Time Interval#>)
```
## Example
```
recordAudio(quality: Normal, start: On Tap, end: After Time, duration: 10 min 15 sec)
```

license: Unlicense

repository: extratone/jellycuts

repo_name: extratone/jellycuts


text:
# Dungeon Generator

A dungeon generator for rogue-like games written in C.

## Usage

```
# To compile the main executable
Make

# To generate a dungeon
./generator

# To generate a dungeon with a specific width/height (default are 10)
./generator -h 20 -w 15

# To generate a dungeon and display it (the default behaviour will list the
# rooms values)
./generator -v

# To compile and run the test executable
Make test
./test
```

## Explanations

A dungeon is defined by a grid (with a width and a height). Each cell of the
grid is a room.

A room can have up to 4 doors, one per cardinal direction.
A dungeon has one room considered as the entrance.

Each room of the dungeon is an integer (can be listed when generated without
-v option). The integer is a combination of bits of settings. Each bit is
described in section "Room bits details".

Example of generated dungeon with -v option (E is the entrance room):
```
            ###
            # #
    ##### ### #
    #   # #   #
### # # ##### #######
# # #E#     # #     #
# ### # ##### ### # #
#                   #
# ##### ####### ### #
# # # #   # #   #   #
### # # ### ### # ###
    #   #     # #   #
    #####     # #####
              # #
              ###
```

The rooms can be shown this way:
```
   |   |   |   |   |   |###|   |   |
   |   |   |   |   |   |# #|   |   |
   |   |   |   |   |   |# #|   |   |
---------------------------------------
   |   |###|###|   |###|# #|   |   |
   |   |#  |  #|   |#  |  #|   |   |
   |   |# #|# #|   |###|# #|   |   |
---------------------------------------
###|   |# #|# #|###|###|# #|###|###|###
# #|   |#E#|#  |   |  #|# #|#  |   |  #
# #|   |# #|# #|###|###|# #|###|# #|# #
---------------------------------------
# #|###|# #|# #|###|###|# #|###|# #|# #
#  |   |   |   |   |   |   |   |   |  #
# #|###|###|# #|###|###|###|# #|###|# #
---------------------------------------
# #|   |###|# #|###|   |###|# #|###|# #
# #|   |# #|#  |  #|   |#  |  #|#  |  #
###|   |# #|# #|###|   |###|# #|# #|###
---------------------------------------
   |   |# #|# #|   |   |   |# #|# #|###
   |   |#  |  #|   |   |   |# #|#  |  #
   |   |###|###|   |   |   |# #|###|###
---------------------------------------
   |   |   |   |   |   |   |# #|   |
   |   |   |   |   |   |   |# #|   |
   |   |   |   |   |   |   |###|   |
```

A room is a 3x3 square, a space represents a empty space and a # represents a
wall. The central point is always empty (the room itself), the points on the
edge are the walls. The corner points are always walls.
For example, the following room is a room with a door leading to the south and
another to the west:
```
###
  #
# #
```

## Generation

The dungeon to generate has a maximum width and a maximum height (once
generated, it will probably not use all the cells).

To generate the dungeon, 2 lists of width*height elements are needed. One will
be the dungeon grid itself and the other one will be temporary (used only for
the generation).

The generation process is the following:
- a loop is executed on the temporary list while the current index is lower than
the list size and the current element is different than 0 if the index is higher
than 0,
- 	if the current index is 0, the dungeon entrance is defined (index of the
entrance room randomly generated between 0 and the max number of rooms). The
entrance room is set in the rooms list and its index is added in the temporary
list.
- 	then, the current room's doors are defined (to define the neighbour rooms)
and those neighbour rooms are added to the temporary list to be processed later
in the loop.

## Room bits details

A room is a combination of bits stored in an integer. Here is the value of each
bits:
- 0x01: Set to 1 if the cell is an used room,
- 0x02: Set to 1 if the room is the dungeon entrance,
- 0x04: Set to 1 if the room has a door leading to the north
- 0x08: Set to 1 if the room has a door leading to the east
- 0x10: Set to 1 if the room has a door leading to the south
- 0x20: Set to 1 if the room has a door leading to the west
- 0x40: Not used yet, will probably be used to set a stair to the floor below
- 0x80: Not used yet, will probably be used to set a stair to the floor above

repository: redispade/dungeon-generator

repo_name: redispade/dungeon-generator


text:
# Menu Rain for Telltale Definitive Series

### [Download the Mod here](https://github.com/changemymindpls/TTDS-MenuRain/releases)

### Install this mod using the [Telltale Mod Launcher](https://github.com/Telltale-Modding-Group/TelltaleModLauncher).

## DISCLAIMER

**This only works for 'The Walking Dead Telltale Definitive Edition'.**
**Not Compatible with [Relighting Mod](https://github.com/changemymindpls/TTDS-Relighting)**

## About

This simple mod adds rain to the menu scene for The Walking Dead Telltale Definitive Edition, complete with full rain effects and sound! This mod also is compatible with [Ambience](https://github.com/droyti/Ambience) and [Load Any Level](https://github.com/droyti/LoadAnyLevel)

**[Original Reddit Post](https://www.reddit.com/r/TheWalkingDeadGame/comments/kfs8uh/mod_menu_rain_ambience_for_the_definitive_series/)**

**Built using the [Telltale Script Editor!](https://github.com/Telltale-Modding-Group/Telltale-Script-Editor)**

![Screenshot 1](screenshots/main-preview.png)

## Download

**[Download the mod](https://github.com/changemymindpls/TTDS-MenuRain/releases)**

**This mod is compatible with the [Telltale Mod Launcher](https://github.com/Telltale-Modding-Group/TelltaleModLauncher) and can be installed using the tool.**

![Screenshot 2](screenshots/launcher-preview.png)

## Editing/Modifying

***For Modders/Developers Only***

**You are free to download the source code and edit/use it as you wish using the [Telltale Script Editor](https://github.com/Telltale-Modding-Group/Telltale-Script-Editor)!** You can even fork this repository to create your own version of this mod. *Just note to be mindful and edit the .tsproj file to change the author to your name and not mine in notepad or another text editor.*

To Edit/Modify this project, be sure to either download this repository or go to the releases tab and download the "Source code.zip" file. Then extract and open the project using the [Telltale Script Editor](https://github.com/Telltale-Modding-Group/Telltale-Script-Editor) and edit the code as you wish!

NOTE: This project was built using the [Telltale Script Editor Alpha 1.1.0](https://github.com/Telltale-Modding-Group/Telltale-Script-Editor)

repository: Telltale-Modding-Group/TTDS-MenuRain

repo_name: Telltale-Modding-Group/TTDS-MenuRain


text:
---
author: gene
title: 'Configuration Management Part 3: Vagrant & Packer'
tags:
- apache
- configuration-management
- devops
- puppet-me
- vagrant
---

To facilitate developing my Puppet code, the [Pro Puppet](http://amzn.to/QPzitQ) book suggests using [Vagrant](http://bit.ly/QPzpFI). Seeing as I’ve been meaning to get around to learning it for a while I decided now was the time to finally do so. The only problem is that, being a responsibly paranoid SysAdmin, I was never a fan of using a base for my work that I didn’t know the contents of. I also never liked the idea of basing my work off of something I didn’t understand (a Vagrant box) or that could go away at anytime.

**Box building time**
 The solution to my dilemma was to learn how to use Vagrant and to make my own base boxes for it. Their site does a good job of listing the minimum specs and Puppet Labs publishes the [recipes](http://bit.ly/QPAf5g) for their base boxes that are built using [Veewee](http://bit.ly/QPAoFN) on GitHub. Between these two resources I was able to figure most stuff out and built a CentOS 6 vm that was to be my base. I was then able to use another tool called [Packer](http://bit.ly/QPBnWy) to [reference the VMX file](http://www.packer.io/docs/builders/vmware-vmx.html) and build a box from it.

**I have a box, now what?**
 Once I built this first iteration of my box I setup an account on Vagrant Cloud, setup space on [my personal server](http://bit.ly/QPBJMV) to host the boxes, and published my VMware Fusion box. The problem was that I couldn’t publish my Packer template because it was dependent on a custom vm.

**Packer to the Rescue, Again **
 I then dove into Packer a bit more and, thanks to [another resource](http://bit.ly/QPFy4B) found on GitHub, was able to take what I learned from my first box and produce base boxes for both VirtualBox & VMware Fusion using a fairly simple template file, some shell scripts, an ISO, and a kickstart file. These new boxes are exactly what I was aiming for. I’ve [published the template](http://bit.ly/QPFNg4) on GitHub and, after a bit more testing, will be publishing the boxes on [my Vagrant Cloud account](http://bit.ly/QPFX7g).

**Next up:**
 Once those boxes are vetted I’ll be making versions with Puppet pre-installed so that I can get back to the book.

repository: genebean/jekyll-beanbag

repo_name: genebean/jekyll-beanbag


text:
# tcpproxy
Proxy TCP on a specific port. This is used to proxy data between two distinct ports on the same machine or two different machines entirely.

```
usage: tcpproxy.py [-h] [--listenAddr LISTENADDR] [--chunkSize CHUNKSIZE]
                   proxyAddr

End-to-end TCP Proxy

positional arguments:
  proxyAddr             Destination server address to proxy

optional arguments:
  -h, --help            show this help message and exit
  --listenAddr LISTENADDR
                        Listen on this address. Default: "<IP_ADDRESS>"
  --chunkSize CHUNKSIZE
                        Data reception is done in chunks. Default: 1024
```

repository: gili-yankovitch/tcpproxy

repo_name: gili-yankovitch/tcpproxy


text:
# sinatra-project-movie-review

## Objectives

 Build a Sinatra application that uses:

 - MVC
 - RESTful routes
 - ActiveRecord(Models, Associations)
 - A sqlite database
 - Login/Logout

 ## Overview

 This project is building a simple Content Management System (CMS) using the tools we've learned so far.

 It can track the reviews of movies from users and user needs to sign up to see or wirte reviews. Once the user is logged in, they are able to create, edit and delete their own reviews but they will still able to see other user's posts.

 ## Instructions

 Go to the GitHub page and click the "Fork" button. Once you've done that, you can clone your repo with the command line:

 ```
  # Clone your fork to your local machine
  git clone git@github.com:USERNAME/FORKED-PROJECT.git

```
 After clone the repo, install all the required gems with `bundler install`. If you want to see how your application looks like, you can run it locally with `shotgun`.

## Contributing

 This project is open source under the MIT license, which means you have full access to the source code and can modify it to fit your own needs.

repository: junymc/sinatra-project-movie-review

gha_language: Ruby

repo_name: junymc/sinatra-project-movie-review


text:
--------------------------------------------------------------------------------
Thank you for downloading "Beetle Golem" by killyone
Released under
Creative Commons Zero (Public Domain)
Downloaded from http://www.blendswap.com/blends/view/53818

The following is important licensing information, please keep this file for
archival and future reference when working with the file. It's important that
you know, understand and follow any requirements stated in this file regarding
the usage of the materials included.

Some parts of this file are marked with [#], the corresponding numbered note is
at the end of the file.

--------------------------------------------------------------------------------
################################################################################

VERY IMPORTANT LICENSE INFORMATION:

This blend has been released under
Creative Commons Zero (Public Domain)

This means that you can use it for any purpose you see fit, even commercially,
as long as you respect these requirements:

	--There are no requirements for CC-0 licensed blends.
################################################################################
--------------------------------------------------------------------------------

ABOUT THE BLEND:

Ready for Blender 2.63
Published on: 2012-09-12 15:33:44

--------------------------------------------------------------------------------

HELP US MODERATE THIS BLEND:
If you find anomalies in this blend or any of the contained files such as:

	- Missing, unneeded or corrupted files.
	- Inaccurate/mismatching preview image on the site.
	- Illegal distribution of third party files.
	- Ripping from a game or other 3D repository.
	- Uncredited or incorrect use of other CC licensed works.
	- Some other troubling issues[1].

Please submit a report from  http://www.blendswap.com/blends/view/53818
by pressing the red button with the flag, including links and details that serve
as evidence and can help us to solve any conflicts or issues derived from the
contents of this file.

--------------------------------------------------------------------------------

Thank you for using Blend Swap!

Register to get tons of more blends! http://www.blendswap.com/register
Share your own blends with the world from http://www.blendswap.com/blends/add

Get answers to your questions and doubts: http://www.blendswap.com/page/faq
If the site doesn't work for you try here: http://www.blendswap.com/page/issues
For questions please contact us: http://www.blendswap.com/contact
Check out our Terms Of Use: http://www.blendswap.com/tou
Report website bugs: http://www.blendswap.com/bugs

Consider getting an associate Membership to get some neat features and
enhancements.

--------------------------------------------------------------------------------

NOTES:

[1] Please make sure your problem is not derived from a setting in Blender (like
hidden layers or objects) before submitting a report under the "Other" category.
Issues arising from this type of problem will be ignored.

--------------------------------------------------------------------------------
######################    END OF BLEND SWAP LICENSE.txt    #####################

Pattern provided by Nobiax.

Absolutely free to use or to modify in any kind of work (personal, commercial or else).

Give me a link of the result at nobiax.deviantart.com or my other account on OpenGameArt.com or ShareCG.com
( watch my journal on deviantart ) ;)

Patterns provided by :

BirdseyeStock
http://birdseyestock.deviantart.com/

Stock by BirdseyeStock - Terms of Use
=====================================

All stock textures offered as free for use to members of Deviantart.com, subject to the rest of the terms below:

What IS allowed
---------------
No need to ask first, you HAVE my permission to:
 o  use these textures as part of your own artwork
 o  offer your own artwork as a Print
 o  use these textures in commercial artwork
 o  use these textures for private purposes such as school projects, desktop wallpaper, card making etc.
 o  submit your own artwork to another website or gallery

What is NOT allowed
-------------------
You must NOT:
 o  use this stock for images portraying pornography, racism, violence or hatred of any kind
 o  sell, redistribute, upload or offer any of these stock textures on other sites, galleries, blogs etc.
 o  copy or alter these textures, in an effort to disguise their origin and claim it as your own work. That's low and dishonest, don't do it!
 o  use these textures to make other stock material

Credit where credit is due
--------------------------
If you use a stock texture please acknowledge my creative efforts and do the following:
 o  you MUST acknowledge your source material in the artist comments below your deviation, together with a link to the texture pack deviation and/or to me: ~BirdseyeStock
 o  leave a comment or note me with a link to your deviation, I like to see what people have done
 o  add the stock deviation to your DA faves so others can find and enjoy them too
 o  for artwork outside DeviantArt please credit your sources and note me with a link
 o  if you think something is cool then by all means tell your friends and share it online but do so by *linking* to the original deviation rather than copying the images elsewhere. Thanks!

Questions?
----------
For any other questions regarding usage, please ask first! I will probably be happy to oblige.

I hope you agree that these terms of use are fair and reasonable.
Thank you for respecting and honoring my wishes.
Now go and be creative (and show me your work afterwards)! :D

BirdseyeStock

http://birdseyestock.deviantart.com/

===================================

"bad explosion" from nthompson
https://www.freesound.org/people/nthompson/sounds/47252/

Laser gun from soundslikewillem
https://www.freesound.org/people/soundslikewillem/sounds/190707/

FX_26_Laser from AlienXXX
https://www.freesound.org/people/AlienXXX/sounds/211588/


text:
Pattern: Missing use of `while` loop

Issue: -

## Description

Prefer `while` loops instead of `for` loops without an initializer and incrementor.

Rationale: Simplifies the readability of the loop statement, while maintaining the same functionality.

## Further Reading

* [TSLint - prefer-while](https://palantir.github.io/tslint/rules/prefer-while)

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

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


text:
  Challenge: Building Foodfy

  About the challenge   |
  License

## :rocket: About the challenge

In this challenge, we had to build a complete website for a recipe company called Foodfy.

### Materials
Challenge introduction (in Portuguese): https://vimeo.com/372742889/63b926d7e0

## :memo: License

This project is under the MIT License.

---

Made with :purple_heart: by hilstc.

repository: hilstc/launchbase-foodfy

repo_name: hilstc/launchbase-foodfy


text:
---
title: Shell script
---

This script is a simple Perl shell that allows you to retrieve a single relevance
evaluation. This example requires the **SOAP::Lite** module, version 0.71 or later. It
uses the **GetRelevanceResult** SOAP method.

```perl
use SOAP::Lite;
#arguments: [hostname] [username] [password] [relevance expression]
#hostname only, e.g. 'example.com' rather than 'http://example.com/webreports'
my $host = $ARGV[0];
my $username = SOAP::Data->name('username' => $ARGV[1] );
my $password = SOAP::Data->name('password' => $ARGV[2] );
my $expr = SOAP::Data->name('relevanceExpr' => $ARGV[3] );
my $service = SOAP::Lite -> uri( 'http://' . $host . '/webreports?wsdl' ) -> proxy( $host );
my $result = $service -> GetRelevanceResult( $expr, $username, $password );
if( $result->fault ) {
   print "faultcode: " . $result->faultcode . "\n";
   print "faultstring: " . $result->faultstring . "\n";
}
else {
   foreach my $answer ( $result->valueof( "//GetRelevanceResultResponse/a" ) ) {
     print $answer . "\n";
}
}
```

You pass four arguments to this script: host, username, password, and the
relevance expression that you want to evaluate. The host name is something like
```example.com```, denoting the location of your Web Reports server. After passing the
parameters to the SOAP module, a call is made to **GetRelevanceResult**. If there is
an error, it can be parsed here. Otherwise, the results of the relevance evaluation
(typically plural) are printed in a loop.

Add the following line at the top of the file to help with debugging:

```perl
use SOAP::Lite +trace => 'debug';
```

The following line might be required to avoid a bug in **SOAP:Lite**:

```perl
$SOAP::Constants::DO_NOT_CHECK_CONTENT_TYPE = 1;
```


text:
# Iterative Linear Quadratic Regulator
This program is about iLQR (Iteratice Linear Quadratic Regulator)

# Problem Formulation

# Usage

# Expected Results

# Requirement

- python3.5 or more
- numpy
- matplotlib
- cvxopt
- scipy1.2.0 or more
- python-control

# Reference

- study wolf
https://github.com/studywolf/control

- Sergey Levine's lecture
http://rail.eecs.berkeley.edu/deeprlcourse/

- Tassa, Y., Erez, T., & Todorov, E. (2012). Synthesis and stabilization of complex behaviors through online trajectory optimization. IEEE International Conference on Intelligent Robots and Systems, 4906–4913. https://doi.org/10.1109/IROS.2012.6386025

- Li, W., & Todorov, E. (n.d.). Iterative Linear Quadratic Regulator Design for Nonlinear Biological Movement Systems. Retrieved from https://homes.cs.washington.edu/~todorov/papers/LiICINCO04.pdf


text:
# xray_microbeam_database
Annotations and scripts for use with the [University of Wisconsin X-Ray Microbeam Speech Production Database (1994) dataset](https://berkeley.box.com/v/xray-microbeam-database-data).

## Citation for the Wisconsin X-Ray Microbeam Speech Production Database

Westbury, John with Greg Turner and Jim Dembowski (1994) X-Ray Microbeam Speech Production Database User’s Handbook, v. 1.0, Waisman Center on Mental Retardation & Human Development, Univ. of Wisconsin, Madison, WI.


text:
Run all gradle commands from this directory. On Windows use `gradlew` instead of `./gradlew` (doesn't apply to git bash).
For instructions on how to run the application, see the readmes of the respective sub-directories:
* [Server](https://github.com/xinra-it/review-community/blob/master/server/README.md)
* [Android Client](https://github.com/xinra-it/review-community/blob/master/android/README.md)

To build the project in an IDE, you need to install the lombok plugin:
* [Eclipse](https://projectlombok.org/setup/eclipse)
* [IntelliJ / Android Studio](https://projectlombok.org/setup/intellij)

repository: xinra-oss/review-community

repo_name: xinra-oss/review-community


text:
# file-content-replacer

A simple Github Action that wraps the NPM package [replace-in-file](https://www.npmjs.com/package/replace-in-file).

## Usage

The sample workflow sets the assembly version based on a new Build Number

```yaml
name: Build

on: [push]

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
    - name: Checkout code
      uses: actions/checkout@v1

    - name: Get Build Number
      uses: einaregilsson/build-number@v2
      with:
        token: ${{secrets.github_token}}

    - name: Update project file
      uses: rshillington/file-content-replacer@master
      with:
        files: "**/*.csproj"
        from: "<AssemblyVersion>[0-9\\.]+<\/AssemblyVersion>"
        to: "<AssemblyVersion>1.0.0.${{ env.BUILD_NUMBER}}</AssemblyVersion>"

```

repository: RainwayApp/file-content-replacer

repo_name: RainwayApp/file-content-replacer