text:
# utl-python-base64-encode-and-decode-a-binary-execl-workbook-or-binary-file
Python base64 encode and decode a binary execl workbook or binaryfile
    Python base64 encode and decode a binary execl workbook

        Steps in Python code

            1. Read entire binary file into Python string object (can be as large as memory?)
            2. base 64 encode binary file into clear ascii (A-Z a-z + /)
            3. Decode the binary file created into Python string object (can be as large as memory?)
            4. Decode and open decoded excel workbook to check process

         'pybase64' package may be faster?
          There are options for safe encode/decode for "utf#" and "url", passwords?

    Maybe this is best done by Python?

    github
    https://tinyurl.com/y5d2j6z2
    https://github.com/rogerjdeangelis/utl-python-base64-encode-and-decode-a-binary-execl-workbook-or-binary-fil

    *_                   _
    (_)_ __  _ __  _   _| |_
    | | '_ \| '_ \| | | | __|
    | | | | | |_) | |_| | |_
    |_|_| |_| .__/ \__,_|\__|
            |_|
    ;

    * Make binary excel workbook;

    libname xel "d:/xls/class.xlsx";
    data xel.class;
      set sashelp.class;
    run;quit;
    libname xel clear;

    Here is what a excel workbook looks like in binary

    d:/xls/class.xlsx
    =================

    *                                        _    _                 _
     _ __ __ ___      __ __      _____  _ __| | _| |__   ___   ___ | | __
    | '__/ _` \ \ /\ / / \ \ /\ / / _ \| '__| |/ / '_ \ / _ \ / _ \| |/ /
    | | | (_| |\ V  V /   \ V  V / (_) | |  |   <| |_) | (_) | (_) |   <
    |_|  \__,_| \_/\_/     \_/\_/ \___/|_|  |_|\_\_.__/ \___/ \___/|_|\_\

    ;

    * unprintable bytes may not align with ruler, because of tabs/CR...

    --- RECORD NUMBER ---  1   ---  RECORD LENGTH ----   100

    1...5....10...15...20...25...30...35...40...45...50...55...60...65...70...75...80...85...90...95...
    PK.....!.œ×ü¨^..<...Ï[Content_Types].xml ¢Ë( ............................................
<PHONE_NUMBER>00209DFA5000300010C054667667557767527662AC02A000000000000000000000000000000000000000000000
    0B344060800010C7C8E100C40030F1B3FE45E4F49053DE8DC02B180020000000000000000000000000000000000000000000

     --- RECORD NUMBER ---  2   ---  RECORD LENGTH ----   100

    1...5....10...15...20...25...30...35...40...45...50...55...60...65...70...75...80...85...90...95...
    ....................................................................................................
<PHONE_NUMBER>000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
<PHONE_NUMBER>000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
    ....
    ....
     --- RECORD NUMBER ---  6   ---  RECORD LENGTH ----   100

    1...5....10...15...20...25...30...35...40...45...50...55...60...65...70...75...80...85...90...95...
    .......¬“ËNÃ0E÷HüCä-JÜ²@5í‚Çº(`ìIcÕ/yÜ6ý{Æ      *UÙÄŠ¬¹wæÌõdÖYSl ¢ö®fãjÄ
pÒ+í–5{_¼”÷¬À$œÆ;¨Ù
<PHONE_NUMBER>00A9C4C314F4F4E24DB403E8C1B216E46D27D3F7C0A0215DC8AB7ECF6D5562AFA6E6C07D2E9375B9FAC291C3AD
<PHONE_NUMBER>00C3BE300578C34DAC2085D272A8F0C935F9C6DB69D4A5594AC976C54693C026E63A4A02BD65BFC47C04C26B89

     --- RECORD NUMBER ---  7   ---  RECORD LENGTH ----   100

    1...5....10...15...20...25...30...35...40...45...50...55...60...65...70...75...80...85...90...95...
    Í¦×W“Å..Tí°fmJás”-X•àè¦ñÑŠD¿qÉƒ+±~;Ýqé]—Ê”5ØtòF  ˜‹˜^…%
    UEsDBBQABgAIAAAAIQCc1/yoXgEAADwEAAATAM8BW0NvbnRlbnRfVHlwZXNdLnhtbCCiywEooAACAAAAAAAAAAAAAAAAAAAAAAAA
<PHONE_NUMBER>444444454632765644447444454434534766566656546755464667644677466444444444444444444444444444
<PHONE_NUMBER>19111191331F9F8751147511141D8270E62E2C2E2668C7A8E4CE842339975FF113111111111111111111111111

     --- RECORD NUMBER ---  2   ---  RECORD LENGTH ----   100

    1...5....10...15...20...25...30...35...40...45...50...55...60...65...70...75...80...85...90...95...
    AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
<PHONE_NUMBER>444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444
<PHONE_NUMBER>111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
    ....
    ....
    ....

     --- RECORD NUMBER ---  6   ---  RECORD LENGTH ----   100

    1...5....10...15...20...25...30...35...40...45...50...55...60...65...70...75...80...85...90...95...
    AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
<PHONE_NUMBER>444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444
<PHONE_NUMBER>111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111

     --- RECORD NUMBER ---  7   ---  RECORD LENGTH ----   100

    1...5....10...15...20...25...30...35...40...45...50...55...60...65...70...75...80...85...90...95...
    AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACsk8tOwzAQRfdI/EPk
<PHONE_NUMBER>444444444444444444444444444444444444444444444444444444444444444444444444476374774556642456
<PHONE_NUMBER>11111111111111111111111111111111111111111111111111111111111111111111111133B84F7A112649F50B

     --- RECORD NUMBER ---  8   ---  RECORD LENGTH ----   100

    1...5....10...15...20...25...30...35...40...45...50...55...60...65...70...75...80...85...90...95...
    LUrcskAINe2CxxK6KB9g7Elj1S953Db9e8YJrQQqFVXZxIqsuXfmzPVk1llTbCCi9q5m42rECnDSK+2WNXtfvJT3rMAknBLGO6jZ
<PHONE_NUMBER>347743443634663533346363547557455574777566755636656446373633744645423545767453744664444365
    C5233B19E52388B6B29775CA13953429589A2111668A8913586DA06B1CC42339915D42253E43BB27E8466A432D1BE2C7F6AA

     --- RECORD NUMBER ---  9   ---  RECORD LENGTH ----   100

    1...5....10...15...20...25...30...35...40...45...50...55...60...65...70...75...80...85...90...95...


text:
# PetljaDoc - Petlja's tool for interactive books

The tool is based on https://github.com/RunestoneInteractive/RunestoneComponents and https://github.com/sphinx-doc/sphinx and includes:

- additional Sphinx extensions
- partial Pygame implementation for Sculpt (https://github.com/Petlja/pygame4skulpt)
- additional ActiveCode features
- customized Sphinx theme
- customized project template
- ``petljadoc`` command line interface (CLI)

PetljaDoc currenty depends on forked RunestoneComonents, but we are gradually closing the gap with the upstream repository through pull requests.

## Installation

Use `pip` to `install` DetljaDoc:

`pip3 install https://github.com/Petlja/PetljaDoc/archive/master.zip`

If you use Windows and previous command does not work, try:

`py -3 -m pip install https://github.com/Petlja/PetljaDoc/archive/master.zip`

## CLI usage

`petljadoc [OPTIONS] COMMAND [ARGS]...`

Options:
  - `--help`    Show help message

Commands:
  - `init-runestone`    Create a new Runestone project in your current directory
  - `preview`    Build a Runstone projec (like `runestone build --all`), open it in browser, watch for changes, rebuild changed files and refresh browser after rebuild (using [sphinx-autobuild](https://github.com/GaretJax/sphinx-autobuild))
  - `publish`    Build a Runestone project (like `runestone build --all`) and copy produced content in `docs` subfolder (ready to be published using GitHub Pages)

By using `petljadoc preview`, an author may keep opened a browser window for preview. Any saved changes will be updated in browser in about 5-10 seconds.

`petljadoc publish` command helps an author to share a public preview of his work via GitHub Pages.

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# redux-practice

## Use Redux to add new users to the list
[] - GET & POST endpoint 'https://jdo-user-post-api.herokuapp.com/api/users'
[] - Use https://cors-anywhere.herokuapp.com/YOURURL if you are dealing with CORS issues

[] - Use actions to handle Redux functions
[] - Use reducers to handle Redux store/state


text:
---
title: " "
permalink: /youthroundtable/
---

![]({{ site.url }}/assets/images/communities/youthroundtable_logo3.png)

## 2021年俄勒冈华裔青少年圆桌会
# 5th Annual Oregon Chinese Youth Roundtable

## Date
12/26/2021 Sunday 2:00 pm - 4:00 pm

## Place
Virtual Zoom Event

## Participants

Middle and high school students, college students, and college graduates

## Registration

Please [register at Zoom](https://us02web.zoom.us/meeting/register/tZwtdumsrz0sHdNyTO9vP1FF-4S5Bt6ot72p), you will receive the login information for the event. (We understand parents can register the event for their children especially when they are under eighteen years old.)

## Agenda 2:00 pm - 4:00 pm

### Presentation of (1)Local Chinese American Community, (2)OCC as Community Organization, and (3)Youth Engagement

by Hongcheng Zhao (西北兆)

All we do is to make our children proud of being part of this community. Our youth have become an important part of rebuilding our community.

### Reflections of High School Years under Pandemic

by high school seniors who just committed to the schools from their early action/decision applications

Successfully responding to the pandemic so often falls outside the classrooms.

### From Actions to Motivation: Volunteerism

by President's Volunteer Service Award recipients

Regardless of what you want to get motivated about, the answer always begins with action. Action is the impetus for motivation. Action is the precursor to motivation.

### Breakout Sessions

You can choose the group when being prompted

1. Q&A on Community, OCC and Parenting
2. Positively Handling Impact from Pandemic at Schools
3. Volunteering
4. Meeting Up with Post Graduates for Career and their Reflections

### Logo designed by [Olando Lin](https://www.linkedin.com/in/olando-lin-3696ab37/)

## Archive

2020 Youth Roundtable [Agenda](/assets/pdf/youth-roundtable-2020.pdf) | [Recap](http://pdxchinese.org/youth-roundtable-2020/)
2019 Youth Roundtable [Agenda](/assets/pdf/youth-roundtable-2019.pdf) | [Recap](http://pdxchinese.org/youth-roundtable-2019-recap/)
2018 Youth Roundtable [Agenmda](/assets/pdf/youth-roundtable-2018.pdf) | [Recap](http://pdxchinese.org/youth-roundtable-2018-recap/)
2017 Youth Roundtable [Agenda](/assets/pdf/youth-roundtable-2017.pdf) | [Recap](http://pdxchinese.org/youth-roundtable-2017-recap/)
[Materials distributed at Roundtables](http://pdxchinese.org/resources/benefits_resources/roundtable/)


text:
# aws-workbox

* Uses Packer to build a base Ubuntu 16.04 box with lots of nice AWS and DevOps-y tools.

# Usage

* Install Virtualbox
* Install Vagrant

Run the following:
```bash
vagrant init kmcquade/aws-workbox \
  --box-version 0.0.1
vagrant up
```

### Building from scratch

* Install Packer

Run the following:

```bash
packer build -on-error=ask ubuntu1604.json
```

Once that completes, run the following:

```bash
vagrant up
```

# Tools list

### AWS
* [awscli](https://github.com/aws/aws-cli)
* [saw](https://github.com/TylerBrock/saw)
* [chamber](https://github.com/segmentio/chamber)

### Infrastructure as Code
* [Packer](https://www.packer.io/)
* [Docker](https://docs.docker.com/get-started/)
* [Terraform](https://www.terraform.io/)
* [tfenv](https://github.com/tfutils/tfenv)

### Config Management
* [Ansible](https://docs.ansible.com/ansible/latest/index.html)

### Continuous Testing
* [inspec](https://www.inspec.io/)
* [serverspec](https://stelligent.com/2016/08/17/introduction-to-serverspec-what-is-serverspec-and-how-do-we-use-it-at-stelligent-part1/)

### Tweaks
* A few of Kinnaird's scripts
  * [Copying all SSM Parameters](https://gist.github.com/kmcquade/028fc845b30a4c2fd56603b103b0c142)
  * [Commands to export all AWS Profile keys](https://gist.github.com/kmcquade/d7d05513dbcc27bb1d9bb74d038a07d0)
  * [Get and Put KMS-encrypted secrets in S3 buckets](https://gist.github.com/kmcquade/91b6cc3cb143977bf4eea6ab234a1cdf)

### Other
* [rbenv](https://github.com/rbenv/rbenv)
* [jdk8](https://launchpad.net/~webupd8team/+archive/ubuntu/java)
* [gitcrypt](https://github.com/AGWA/git-crypt)
* VirtualBox Guest Additions

### Might add this later
* [prowler](https://github.com/toniblyx/prowler)
* [Scout Suite](https://github.com/nccgroup/ScoutSuite)
* [awslogs](https://github.com/jorgebastida/awslogs)

### Notes

##### Local .iso usage
I removed this from the original `iso_urls` line in the Packer JSON file. I can add it later.

        "iso/ubuntu-16.04.5-server-amd64.iso"

##### VagrantCloud in future

When I want to eventually push this to VagrantCloud, I should add this to Packer:

```
,
      {
        "type": "vagrant-cloud",
        "box_tag": "geerlingguy/ubuntu1604",
        "version": "{{user `version`}}"
      }
```

### References

Based on https://github.com/geerlingguy/packer-ubuntu-1604
Inspired by https://github.com/kief/infra-workbox

repository: kmcquade/aws-workbox

repo_name: kmcquade/aws-workbox


text:
# social-network-demo
Full demonstration of a basic social network with DB, API, web client, and mobile app

This is the source for the "Building a Social Network" series on Medium
* [Part I - Defining concepts, models, and security in PostgreSQL](https://itnext.io/building-a-social-network-part-i-25856fc693e1)
* [Part II - Creating a Dart package with common data models](https://itnext.io/building-a-social-network-part-ii-1e6883ba27f6)
* [Part III - Creating a REST API Framework with Dart and PostgreSQL](https://itnext.io/building-a-social-network-part-iii-9f9d215a624)

repository: mezga-alex/Laboratory-work-SFedU

gha_language: Jupyter Notebook

repo_name: mezga-alex/Laboratory-work-SFedU


text:
# dependiff

Compare diffs of dependencies between meta files.

```
 {
   dependencies: {
-    ao-mesher: "~0.2.4"
+    ao-mesher: "~0.2.5"
+    ao-shader: "~0.2.3"
-    gl-now: "~0.0.4"
+    gl-now: "~0.0.3"
-    ndarray: "~1.0.1"
+    ndarray: "~1.0.3"
+    teapot: "~0.0.1"
-    brfs: "~0.0.5"
+    brfs: "~0.0.6"
   }
 }
```

## install

Install globally to access the `dependiff` command:

`npm install -g dependiff`

Or install locally to use programmatically:

`npm install dependiff`

## `dependiff` cli usage

``` shell
$ dependiff path/to/package.json compare/package.json

$ dependiff githubuser/repo anotheruser/repo

$ dependiff githubuser/repo anotheruser/repo --metafile component.json

$ dependiff http://example.com/package.json http://example2.com/component.json
```

## api usage

`var dependiff = require('dependiff')`

#### `dependiff(fileA, fileB, [options,] callback)`

- `fileA` and `fileB` are either filepaths or urls to meta files to compare.
- `options`
  - `cwd` Default: `process.cwd()` - Current working directory to search from
  -  `metafile` Default: `'package.json'` - Name of metafile to search for.
  - `keys` Default: `['dependencies', 'devDependencies', 'peerDependencies']` - Keys in metafile to compare.
  - `type` Default: `'diff'` - Type of comparison to run. Options are:
    - `diff` - Returns an object indicated added/deleted lines.
    - `diffString` - Returns a colorized string of the diff.

## Release History

* 0.1.0 initial release

## License

Copyright (c) 2013 Kyle Robinson Young
Licensed under the MIT license.

repository: shama/dependiff

repo_name: shama/dependiff


text:
# libp2p-kad-dht-trail

Hello world local libp2p network with kad-dht rendezvous discovery

# How to test

First clone the repo, then goto `bootstrap` and run that. You will get a multiaddress.

```
$ cd bootstrap
$ go run main.go

This node is  QmRDzQAZ9bdDWwfK4i33qtPW3Eziditovvg3D7Sn3dWN7f
Available multiaddrs :
/ip4/<IP_ADDRESS>/tcp/4000/p2p/QmRDzQAZ9bdDWwfK4i33qtPW3Eziditovvg3D7Sn3dWN7f

```
Now in root run the `main.go` file

```
$ go run main.go --bootstrap /ip4/<IP_ADDRESS>/tcp/4000/p2p/QmRDzQAZ9bdDWwfK4i33qtPW3Eziditovvg3D7Sn3dWN7f --port 3000
```

you will be connected to the bootstrap. In another terminal run the same command with different port
```
$ go run main.go --bootstrap /ip4/<IP_ADDRESS>/tcp/4000/p2p/QmRDzQAZ9bdDWwfK4i33qtPW3Eziditovvg3D7Sn3dWN7f --port 3001
```

You should see bot nodes getting connected

# Project52

It is one of my [project 52](https://github.com/Sab94/project52).


text:
# gke_coreos

## Background

Container-Optimized OS from Google is an operating system image for your Compute Engine VMs that is optimized for running Docker containers. Container-Optimized OS is maintained by Google and based on the open source Chromium OS project. With Container-Optimized OS, you can bring up your Docker containers on Google Cloud Platform quickly, efficiently, and securely.

GKE Clusters' Nodes with OS image other than COS are forbidden.

## Fix

Replace nodPools images.

[Creating and configuring instances using COS](https://cloud.google.com/container-optimized-os/docs/how-to/create-configure-instance)

## References

- [Container-Optimized OS features, benefits, limitations](https://cloud.google.com/container-optimized-os/docs/concepts/features-and-benefits)
- [Security features of COS](https://cloud.google.com/container-optimized-os/docs/concepts/security)

repository: Liadeo/ram-config-template

repo_name: Liadeo/ram-config-template


text:
# Simple Linked List

Write a simple linked list implementation that uses Elements and a List.

The linked list is a fundamental data structure in computer science,
often used in the implementation of other data structures. They're
pervasive in functional programming languages, such as Clojure, Erlang,
or Haskell, but far less common in imperative languages such as Ruby or
Python.

The simplest kind of linked list is a singly linked list. Each element in the
list contains data and a "next" field pointing to the next element in the list
of elements.

This variant of linked lists is often used to represent sequences or
push-down stacks (also called a LIFO stack; Last In, First Out).

As a first take, lets create a singly linked list to contain the range (1..10),
and provide functions to reverse a linked list and convert to and from arrays.

When implementing this in a language with built-in linked lists,
implement your own abstract data type.

## Hints

To complete this exercise, you need to create the data type `LinkedList`,
and implement the following functions:

- `datum`
- `fromList`
- `isNil`
- `new`
- `next`
- `nil`
- `reverseLinkedList`
- `toList`

You will find a dummy data declaration and type signatures already in place,
but it is up to you to define the functions and create a meaningful data type,
newtype or type synonym.

## Getting Started

Please refer to the [installation](https://exercism.io/tracks/haskell/installation)
and [learning](https://exercism.io/tracks/haskell/learning) help pages.

## Running the tests

To run the test suite, execute the following command:

```bash
stack test
```

#### If you get an error message like this...

```
No .cabal file found in directory
```

You are probably running an old stack version and need
to upgrade it.

#### Otherwise, if you get an error message like this...

```
No compiler found, expected minor version match with...
Try running "stack setup" to install the correct GHC...
```

Just do as it says and it will download and install
the correct compiler version:

```bash
stack setup
```

## Running *GHCi*

If you want to play with your solution in GHCi, just run the command:

```bash
stack ghci
```

## Feedback, Issues, Pull Requests

The [exercism/haskell](https://github.com/exercism/haskell) repository on
GitHub is the home for all of the Haskell exercises.

If you have feedback about an exercise, or want to help implementing a new
one, head over there and create an issue.  We'll do our best to help you!

## Source

Inspired by 'Data Structures and Algorithms with Object-Oriented Design Patterns in Ruby', singly linked-lists. [https://web.archive.org/web/20160731005714/http://brpreiss.com/books/opus8/html/page96.html](https://web.archive.org/web/20160731005714/http://brpreiss.com/books/opus8/html/page96.html)

## Submitting Incomplete Solutions
It's possible to submit an incomplete solution so you can see how others have completed the exercise.

repository: fruit-in/exercism-solution

repo_name: fruit-in/exercism-solution


text:
# PCL Examples

These examples are designed to illustrate and exercise build and execution
of a project that depends on both Drake and PCL.

This has only been tested on Ubuntu Xenail (16.04) which is no longer
supported by Drake. This has not yet been tested on Ubuntu Bionic (18.04).

## Drake-PCL Caveats

### Eigen

Drake's version of Eigen is compatible with PCL's (system) but not vice
versa. Make sure you discover them in the correct order.

```
find_package(drake CONFIG REQUIRED)
find_package(pcl CONFIG REQUIRED)
```

so that a version of Eigen that is compatible to both projects is discovered
and used. Note that `CONFIG` and `REQUIRED` are merely good practice if you
are looking for the installed cmake modules). If you do not do this, then you
will receive a static assertion failure from Drake:

```
Drake requires Eigen >= v3.3.3.
static_assert(EIGEN_VERSION_AT_LEAST(3, 3, 3),
```

### VTK

The system built version of PCL with VTK6 has a dependency issue (this is strictly a
PCL/VTK6 problem). Either exclude vtkproj4 or use the version of VTK6 shipped by ROS
which includes a bugfix.

```
list(REMOVE_ITEM PCL_LIBRARIES "vtkproj4")
```

## Simple PCL Example

### How do I build it?

Follow the instructions in the [README](../../README.md) for this project.

### How do I run it?

```
# Switch to the build directory
cd build/src/pcl
# Run the example
./simple_pcl_example
```

### Gory Details

In particular, the problems that are exercised by this example include:

* Use of different versions of Eigen by both Drake and PCL
* Use of different versions of VTK

The Eigen issue is resolved simply by ensuring that Drake's bundled Eigen is
discovered first as noted earlier.

VTK itself has been extremely well engineered so that different versions of
VTK can co-exist within the same project. On Ubuntu Xenial, Drake uses a very
recent version of VTK (8) whilst PCL uses the system version (6.2). The only
software engineering employed by Drake is to hide the VTK header trail so
header conflicts are not transferred to downstream projects.

repository: josephsnyder/drake-external-examples

repo_name: josephsnyder/drake-external-examples


text:
# .NET Yoti Sign Example

## Setup

1) Register for Yoti Sign at <https://www.yotisign.com/app/contact-us/>
1) Request an API key (Bearer Authentication Token)

## Running the example

1) Clone this repo
1) Run `cd dotnet/YotiSignDemo`
1) Rename `.env.example` to `.env`
1) Add your Bearer Authentication Token to the `YOTI_AUTHENTICATION_TOKEN` variable in the `.env` file
1) Customise the `options.json` file as you wish
1) Run `dotnet run`
1) visit <https://localhost:5001/sign>

repository: Bayurzx/yoti-sign-examples

repo_name: Bayurzx/yoti-sign-examples


text:
![skycoin web](https://user-images.githubusercontent.com/8619106/56056491-f4bd8d80-5d79-11e9-8e55-8ebf2668edac.png)

# Skycoin web client

[![Build Status](https://travis-ci.org/skycoin/skycoin-web.svg?branch=master)](https://travis-ci.org/skycoin/skycoin-web)
[![Known Vulnerabilities](https://snyk.io/test/github/skycoin/skycoin-web/badge.svg)](https://snyk.io/test/github/skycoin/skycoin-web)

The Skycoin web client provides a lite multi-coin wallet which can be ran from the browser, using a remote full node exposing selected back-end functions.

## Prerequisites

The Skycoin web interface requires Node 6.9.0 or higher, together with NPM 3 or higher.

## Installation

This project is generated using Angular CLI, therefore it is adviced to first run `npm install -g @angular/cli`.

To install all Angular, Angular CLI and all other libraries, you will then have to run `npm install`.

You will only have to run this again, if any dependencies have been changed in the `package.json` file.

## Compiling new target files

To compile new target files, you will have to run: `npm run build`. To create a dev build, use `npm run build-dev`
instead. To compile a build capable of being run from the local file system, use `npm run build-for-local-fs`.

## Docker

To build a production ready Docker image, you have to run:

```sh
docker build -t image_name:tag -f docker/images/Dockerfile .
```

or you can pull the image from the official repository:

```sh
docker pull skycoin/skycoin-web:<tag>
```

To create a container you must run:

```sh
docker run -d --name <name> -p 8001:80 skycoin/skycoin-web:latest
```

Then, you can access to the web wallet by visiting `http://your_IP:8001`

## Development server

Run `npm start` for a dev server. Navigate to `http://localhost:4200/`.

## Back-end

As this is a lite client, it requires a back-end to retrieve the blockchain state and inject new transactions. While using
a dev build, the wallet tries to connect to a Skycoin node running locally, which must be started with the `-disable-csrf`
option. The production builds connects to a public node set up at `https://node.skycoin.net`. The user can connect the wallet
to another backend by entering its URL.

### Minimum back-end version

The wallet is currently compatible with nodes running v0.24.0 and above. As it is not possible to recover the number of active
decimals in version 0.24.0, the wallet assumes that it is 6. The same happens with burn rate, so it is assumed to be 50%.
Because of this, it is advisable to connect to a node running v0.25.0 or higher.

## Multi-coin compatibility

This wallet have options for switching between different coins and is compatible with most coins based on the Skycoin
technology (as long as they meet some version requirements and do not have modifications in areas necessary for
compatibility). You can find information about how to add a new coins in [MULTICOIN-INFO.md](MULTICOIN-INFO.md).

## Cryptography

For security reasons, this wallet does not store the the seeds, neither in the backend nor in the client, so the user must
maintain a backup of them. The seeds are also not transmitted anywhere outside the application code.

To maintain maximum compatibility with Skycoin's original code, the cryptographic functions used by this wallet are in the
[skycoin-lite](https://github.com/skycoin/skycoin-lite) repository, coded in Go (Golang), and are compiled to wasm.
The compiled wasm file is [src/assets/scripts/skycoin-lite.wasm](/src/assets/scripts/skycoin-lite.wasm).

The mnemonic phrases are created using the [bip39 library](https://www.npmjs.com/package/bip39). To create mnemonic phrases
with enough entropy, that library uses the [randombytes library](https://www.npmjs.com/package/randombytes), which uses
[Crypto.getRandomValues()](https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues) for obtaining
cryptographically strong random values. The use of the [bip39 library](https://www.npmjs.com/package/bip39) is limited to
the creation of mnemonic phrases, the code that creates the binary seeds is in
[skycoin-lite](https://github.com/skycoin/skycoin-lite).

## Pre-release testing

Perform these actions before releasing:

- Test if all options are working correctly when opening the wallet on the test server (using `npm start`). Load a wallet with balance and try to send coins, to verify if the functions for loading wallets and creating transactions work correctly.

- Test if all options are working correctly when opening the wallet from the local file system (the compilation is done by executing `make build-for-local-fs`). In the local version it is important to check all the pages and make sure that all the images load correctly. For this it is useful to go through all pages while the development console is open.

repository: skycoin/skycoin-web

branch_name: refs/heads/develop

gha_language: TypeScript

gha_license_id: MIT

repo_name: skycoin/skycoin-web


text:
### Post-truth

It's the word of 2016 year chosen by Oxford Dictionaries due to numerous disinformations about Brexit referendum and US presidential elections. The truth is secondary thing in post-truth concept apart from the traditional definition of truth; the blief of popularity is the primary one.

I tried to visualize how a disinformation becomes a post-truth by the people who subscribed in a network. We can think this network as a social media such as Facebook or Twitter. The nodes (points) in the map represent individuals and the edges (lines) shows the relationships between them in the community. The disinformation will be forwarded to their audience by the unconscious internet (community) members.

Demo: <http://fatiherikli.github.io/post-truth>

![Screenshot](http://fatiherikli.github.io/post-truth/static/simulation.gif)

repository: cagataycali/post-truth

repo_name: cagataycali/post-truth


text:
# genericNodeReactApp

[![Join the chat at https://gitter.im/RobertWarrenGilmore/pgSandbox](https://badges.gitter.im/RobertWarrenGilmore/pgSandbox.svg)](https://gitter.im/RobertWarrenGilmore/pgSandbox?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

a simple web app with auth, info pages, a blog, and admins

# instructions

Change the values in appInfo.json. `host` should reflect the host where the app will be served and `name` should reflect the display name of the application. Also add the following lines to a file named .env:

- `sparkPostApiKey=thisIsYourKey`, substituting your SparkPost API key
- `NODE_ENV=production`, or `NODE_ENV=development` if you're not in production
-<EMAIL_ADDRESS>substituting an email address suitable for error reports
- `dbPassword=yourPasswordHere`, substituting the password for your database. This line will be added automatically if you run `npm run dbSetup`, as described later in this readme.

## to install Node and NPM
I recommend that you manage Node/NPM versions using NVM. Install it like so:
```
curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.29.0/install.sh | bash
```
After you've installed NVM, you'll need to start a new shell in order to use it. you can either close and reopen your shell or start a new one, like so:
```
bash
```
Next, use NVM to install the version of Node and NPM specified for the project.
```
nvm install
```
Use NVM to load Node and NPM into your PATH so that you can run Node and NPM commands. You'll need to do this in each new shell.
```
nvm use
```

## to lint the code
```
npm run lint
```

## to set up the database
The app needs a local Postgres database named sandbox with user sandboxUser. To run the script that sets this up (including installing Postgres on Ubuntu):
```
npm run dbSetup
```

## to route the ports
The app serves on ports 8000 and 44300. Those ports need to be exposed as 80 and 443. To do that:
```
npm run openPorts
```

## to create an SSL key and a self-signed certificate
```
npm run cert
```

## to install dependencies
```
npm install
```

## to run the tests
```
npm test
```

## to run the application
This will run the application synchronously.
```
node index.js
```
Alternatively, this will run the application and free the current shell.
```
npm start
```
This will stop the app if it's running in the background.
```
npm stop
```

## for quick deployment
To deploy the app quickly,
```
npm run deploy
```
You must first have access to Node and NPM in the shell, have an SSL certificate, and have routed the ports. This script will take care of pulling down the latest version from the repository, updating the dependencies, running the tests, and starting the app in the background. If any of those steps fails, the script will revert the app to the commit it was on before, update the dependencies again, and then start the app again.

repository: RobertWarrenGilmore/pgSandbox

gha_language: JavaScript

repo_name: RobertWarrenGilmore/pgSandbox


text:
# MYO Bluetooth communication library

A bluetooth communication library for the myo armband, using Node and Noble and written in Javascript. **It doesn't require the Myo Connect software or the Myo SDK**, but communicates directly over bluetooth by using the released bluetooth spec.

For a demo build with this library, see https://www.youtube.com/watch?v=R19rKXpttjY The demo application will be published later.

## Install
This library uses [Noble](https://github.com/sandeepmistry/noble) v0.3.8, which currently only supports Mac OS X and Linux. Checkout Noble to find out it's prerequisites and installation guidance.

I have not yet published this repository on npm, but will do eventually. Install via npm:

``` npm install git://github.com/manueloverdijk/myonodebluetooth.git ```

As the project is written with some of the new javascript features of ES6, compile the project with traceur or use [io.js](https://github.com/iojs/io.js) with the following flags:

``` --use_strict --es_staging --harmony_classes  --harmony_arrow_functions```

## Usage

The following is an example which starts discovering myo armbands and connects to the first available armband. Wait for the ```ready event``` after calling ```initStart()``` before reading and writing to characteristics of the Myo.

``` javascript
var MyoBluetooth  = require('MyoNodeBluetooth');
var MyoAgent = new MyoBluetooth();

MyoAgent.on('discovered', function(armband){
    armband.on('connect', function(connected){

    	// armband connected succesfully
        if(connected){
            // discover all services/characteristics and enable emg/imu/classifier chars
        	this.initStart();
    	} else {
    	  // armband disconnected
   		}

	});

    // Armband receives the ready event when all services/characteristics are discovered and emg/imu/classifier mode is enabled
    armband.on('ready', function(){

    	// register for events
        armband.on('batteryInfo',function(data){
        	console.log('BatteryInfo: ', data.batteryLevel);
        });

        // read or write data from/to the Myo
        armband.readBatteryInfo();
    });

   armband.connect();
});
```

## Supported features
### Agent

Get notified of newly discovered Myo armbands.

``` javascript
Agent.on('discovered', function(armband){
 ...
});
```

Get notified of bluetooth adapter state changes, see Noble for more information.

``` javascript
Agent.on('stateChange', function(state){
 ...
});
```

### Armband

Discover all services/characteristics and enable the EMG, IMU and Classifier Characteristics to notify/indicate the communicator of new events. The Myo will also be set in no sleep mode and unlocked until disconnection.

``` javascript
Armband.initStart();
```

Wait for the ready event after calling initStart(), after which the Myo is ready to read/write and notify characteristics.

```javascript
Armband.on('ready', function(){
...
})
```
#### Reading characteristics
##### EMG data
Get notified of EMG data (which the Myo sends after calling ```initStart()```)

```javascript
/*
data = {
	sample1: Array[8],
	sample2: Array[8]
}
*/
Armband.on('emg', function(data){

 	...
});
```

##### Orientation data

Get notified of orientation data (which the Myo sends after calling ```initStart()```)

```javascript
/*
data = {
	w, x, y, z
}
*/
Armband.on('orientation', function(data){
 	...
});
```

##### Accelerometer data

Get notified of accelerometer data (which the Myo sends after calling ```initStart()```)

```javascript
//data = Array[3]
Armband.on('accelerometer', function(data){
 	...
});
```

##### Gyroscope data

Get notified of gyroscope data (which the Myo sends after calling ```initStart()```)

```javascript
//data = Array[3]
Armband.on('gyroscope', function(data){
 	...
});
```

##### Pose events

Get notified of pose events (which the Myo sends after calling ```initStart()```)

```javascript
/* data = {
	type: rest | fist | waveIn | waveOut | spread | tap | unkown
} */
Armband.on('pose', function(data){
 	...
});
```

##### Sync events

Get notified of sync events (which the Myo sends after calling ```initStart()```)

```javascript
// Synced true | false | failed
Armband.on('sync', function(Boolean){
 	...
});
```

##### Unlock events

Get notified of unlock events (which the Myo sends after calling ```initStart()```)

```javascript
// Unlocked true | false
Armband.on('unlocked', function(Boolean){
 	...
});
```

##### Read info

Read the Myo info characteristic

```javascript
Armband.on('info', function(data){
 	...
});
Armband.readInfo();
```

##### Read version

Read the Myo version characteristic

```javascript
Armband.on('version', function(data){
 	...
});
Armband.readVersion();
```

##### Read batteryInfo

Read the Myo batteryinfo characteristic

```javascript
// data: { batteryLevel }
Armband.on('batteryInfo', function(data){
 	...
});
Armband.readBatteryInfo();
```

#### Writing characteristics

Listen for the command event after executing a write command to the Myo to be notified on results/success

```javascript
// data = {type, data}
Armband.on('command', function(data){
 ...
});
```

Set the sleep mode

```javascript
Armband.setSleepMode(Boolean); // Never sleep: true | false
```

Set the unlock mode

```javascript

// mode:   0 -> unlock now and relock after lock command is recieved
//         1 -> re-lock immediatly
//         2 ->  unlock now and relock after a fixed timeout

Armband.setUnlockMode(mode);
```

Set the user action mode, to notify the user that an action has been recognized / confirmed.
```javascript
Armband.setUserAction();
```

Set the IMU/EMG/Classifier modes to notify/indicate the communicator for data events
```javascript
Armband.setMode();
```

Set the vibrate command
```javascript
// mode:   0 -> Do not vibrate.
//         1 -> Vibrate for a short amount of time
//         2 -> Vibrate for a medium amount of time
//		   3 -> Vibrate for a long amount of time

Armband.vibrate(mode)
```

## TODO
* Normalize the gyroscope/accelerometer data, calculate Euler Angles
* Implement extended vibrate command
* Refactor initStart service/characteristic discovery
* Refactor some functions of the deserialisation class
* Fix the unresponsive-classifier state which Myo enters after unsyncing while emitting Classifier events over Bluetooth

repository: ManuelOverdijk/myonodebluetooth

repo_name: ManuelOverdijk/myonodebluetooth


text:
# UbuntuBatches

Some Ubuntu batches I use currently

These scripts are used to perform various tasks
and fix various problems. The content is divided on
folders in which every manager persists:
```
  General        --> Contains an installation procedure for fresh file ubuntu server
  KillAppsWEB    --> Removes the web APPs from an Ubuntu OS
  MaNGOS         --> Configures MaNGOS WoW server on the local network
  MiniDLNA       --> Installs MiniDLNA server when compiling it from source
  RefreshUNITY   --> What to do when your Unity initialization fails
  SteamCMD       --> Configures a SteamCMD game server
  VirtualBox     --> Run this before inserting guest additions in VB
  gksuFix        --> Simple fix for gksu is it does not work
  x11VNC         --> Configures x11VNC server on the port specified.
  OpenTTD        --> Install the game Open TTD in a folder of choice
```

When answering `y` to all installations is needed use: `yes y | sudo ./config.sh`.

gha_language: Shell


text:
# Log Analyzer Demo

The demo is an integration frame included 3 part: Grok, GeoIP and JsonWriter. It supports software and hardware emulation as well as running hardware accelerators on the Alveo U200.

## Prerequisites

- Alveo U200 installed and configured as per https://www.xilinx.com/products/boards-and-kits/alveo/u200.html
- Xilinx Vitis 2020.1 or later installed and configured
- Xilinx runtime (XRT) installed

## Building

The demonstration application and kernel is built using a command line Makefile flow.

### Step 1

Setup the build environment using the Vitis and XRT scripts:

```
    source <install path>/Vitis/HEAD/settings64.sh
    source /opt/xilinx/xrt/setup.sh
```

### Step 2

Call the Makefile. For example:

```
    export PLATFORM_REPO_PATHS=/opt/xilinx/platforms
    make run TARGET=hw PLATFORM=xilinx_u200_xdma_201830_2
```

The Makefile supports software emulation, hardware emulation and hardware targets ('sw_emu', 'hw_emu' and 'hw', respectively).

## Test Data

The `data` folder in this projects provides a sample input and corresponding golden result.
The Geo-IP information in this folder is also tailored to fit in git-repo.

To obtain full benchmark dataset, please refer to the `data/README.md`.

## Example Output

The testbench of process it via the engine and compare to the expected result, displaying the worst case difference. For example, the following is the key information from the software emulation:

```
    ----------------------log analyzer----------------
    DEBUG: found device 0: xilinx_u200_xdma_201830_2
    INFO: initilized context.
    INFO: initilized command queue.
    INFO: created program with binary build_dir.sw_emu.xilinx_u200_xdma_201830_2/logAnalyzer.xclbin
    INFO: built program.
    load log from disk to in-memory buffer
    load geoip database disk to in-memory buffer
    execute log analyzer
    The log file is partition into 1 slice with max_slice_lnm 102 and  takes 0.006000 ms.
    DEBUG: reEngineKernel has 4 CU(s)
    DEBUG: GeoIP_kernel has 1 CU(s)
    DEBUG: WJ_kernel has 1 CU(s)
    logAnalyzer pipelined, time: 1965.33 ms, size: 0 MB, throughput: 0 GB/s
    -----------------------------Finished logAnalyzer pipelined test----------------------------------------

```
## Profiling

The xclbin's Frequency is 231 MHz, and its hardware resource utilizations are listed in the following table.

| Name             | LUT     |  REG      | BRAM  | URAM  | DSP   |
| ---------------- | ------- |  -------- | ----- | ----- | ------|
| Platform         | 288185  |   414992  |  835  |   0   |   16  |
| GeoIP_kernel_1   |  29760  |    30549  |   24  |  16   |    8  |
| WJ_kernel_1      |  33366  |    33248  |   15  |   0   |    2  |
| reEngineKernel_1 |  41676  |    28726  |   66  |  48   |    3  |
| reEngineKernel_2 |  41664  |    28742  |   66  |  48   |    3  |
| reEngineKernel_3 |  41670  |    28760  |   66  |  48   |    3  |
| reEngineKernel_4 |  41660  |    28726  |   66  |  48   |    3  |

## Benchmark

- Input log: http://www.almhuette-raith.at/apache-log/access.log (1.2GB)
- logAnalyzer Demo execute time: 0.99 s, throughput: 1.2 GB/s
- Baseline `ref_result/ref_result.cpp` execute time: 53.1 s, throughput: 22.6 MB/s
- Accelaration Ratio: 53X

note:

1. The each line in the input log must has less than 4090 characters.
2. The baseline version is a single thread program.

## Known Issues

* This case fails hardware build with 2022.1 Vitis. Please use 2021.2 Vitis for it,

branch_name: refs/heads/main


text:
# RyverSecretSanta
A program that makes it easy to create a secret santa, all in your Ryver organization!

### How does it work?
RyverSecretSanta helps you set up a Ryver organization from scratch, or uses your existing one to manage a secret santa with your friends!

### Setup

Open the terminal application on your device.

Type: `git clone https://github.com/LukeG294/RyverSecretSanta.git`

Press return/enter

Once the repository is done cloning, type: `cd RyverSecretSanta` and press enter.

Make sure you have Python installed on your device. If not, download from https://www.python.org/

Type: `python3 main.py` and the program should walk you through the steps from there.

### Contributing

Visit issues to open an issue and make any changes you'd like to the code.


text:
# Serverless Stack Output Plugin

[![npm](https://img.shields.io/npm/v/serverless-stack-output.svg)](https://www.npmjs.com/package/serverless-stack-output)
[![license](https://img.shields.io/github/license/sbstjn/serverless-stack-output.svg)](https://github.com/sbstjn/serverless-stack-output/blob/master/LICENSE.md)
[![CircleCI](https://img.shields.io/circleci/project/github/sbstjn/serverless-stack-output.svg)](https://circleci.com/gh/sbstjn/serverless-stack-output)
[![Coveralls](https://img.shields.io/coveralls/sbstjn/serverless-stack-output.svg)](https://coveralls.io/github/sbstjn/serverless-stack-output)

A [serverless](https://serverless.com) plugin to store output from your AWS CloudFormation Stack in JSON/YAML/TOML files, or to pass the output to a JavaScript function for further processing.

## Usage

### Install

```bash
$ > yarn add serverless-stack-output
```

```bash
$ > npm install serverless-stack-output
```

### Configuration

```yaml
plugins:
  - serverless-stack-output

custom:
  output:
    handler: scripts/output.handler # Same syntax as you already know
    file: .build/stack.toml # toml, yaml, yml, and json format is available
```

### Handler

Based on the configuration above the plugin will search for a file `scripts/output.js` with the following content:

```js
function handler (data, serverless, options) {
  console.log('Received Stack Output', data)
}

module.exports = { handler }
```

### File Formats

Just name your file with a `.json`, `.toml`, `.yaml`, or `.yml` extension, and the plugin will take care of formatting your output. Please make sure the location where you want to save the file exists!

## License

Feel free to use the code, it's released using the [MIT license](LICENSE.md).

## Contribution

You are more than welcome to contribute to this project! 😘 🙆

To make sure you have a pleasant experience, please read the [code of conduct](CODE_OF_CONDUCT.md). It outlines core values and believes and will make working together a happier experience.

## Example

The plugins works fine with serverless functions, as well as when using custom CloudFormation resources. The following example configuration will deploy an AWS Lambda function, API Gateway, SQS Queue, IAM User with AccessKey and SecretKey, and a static value:

### Serverless.yml

```yaml
service: sls-stack-output-example

plugins:
  - serverless-stack-output

package:
  exclude:
    - node_modules/**

custom:
  output:
    handler: scripts/output.handler
    file: .build/stack.toml

provider:
  name: aws
  runtime: nodejs6.10

functions:
  example:
    handler: functions/example.handle
    events:
      - http:
          path: example
          method: get
          cors: true

resources:
  Resources:
    ExampleQueue:
      Type: AWS::SQS::Queue
      Properties:
        QueueName: example-queue
    ExampleUser:
      Type: "AWS::IAM::User"
      Properties:
        UserName: example-user
        Policies:
          - PolicyName: ExampleUserSQSPolicy
            PolicyDocument:
              Version: '2012-10-17'
              Statement:
                - Effect: "Allow"
                  Action:
                    - sqs:SendMessage
                  Resource:
                    - {"Fn::Join": [":", ["arn:aws:sqs:*", {"Ref": "AWS::AccountId"}, "example-queue"]]}
    ExampleUserKey:
      Type: AWS::IAM::AccessKey
      Properties:
        UserName:
          Ref: ExampleUser
  Outputs:
    ExampleUserKey:
      Value:
        Ref: ExampleUserKey
    ExampleUserSecret:
      Value: {"Fn::GetAtt": ["ExampleUserKey", "SecretAccessKey"]}
    ExampleStaticValue:
      Value: example-static-value
```

### Stack Output

#### TOML

```toml
ExampleUserSecret = "YourUserSecretKey"
ExampleUserKey = "YourUserAccessKey"
ExampleLambdaFunctionQualifiedArn = "arn:aws:lambda:us-east-1:AccountID:function:sls-stack-output-example-dev-example:9"
ExampleStaticValue = "example-static-value"
ServiceEndpoint = "https://APIGatewayID.execute-api.us-east-1.amazonaws.com/dev"
ServerlessDeploymentBucketName = "sls-stack-output-example-serverlessdeploymentbuck-BucketID"
```

#### YAML

```yaml
ExampleUserSecret: YourUserSecretKey
ExampleUserKey: YourUserAccessKey
ExampleLambdaFunctionQualifiedArn: 'arn:aws:lambda:us-east-1:AccountID:function:sls-stack-output-example-dev-example:9'
ExampleStaticValue: example-static-value
ServiceEndpoint: 'https://APIGatewayID.execute-api.us-east-1.amazonaws.com/dev'
ServerlessDeploymentBucketName: sls-stack-output-example-serverlessdeploymentbuck-BucketID
```

#### JSON

```json
{
  "ExampleUserSecret": "YourUserSecretKey",
  "ExampleUserKey": "YourUserAccessKey",
  "ExampleLambdaFunctionQualifiedArn": "arn:aws:lambda:us-east-1:AccountID:function:sls-stack-output-example-dev-example:9",
  "ExampleStaticValue": "example-static-value",
  "ServiceEndpoint": "https://APIGatewayID.execute-api.us-east-1.amazonaws.com/dev",
  "ServerlessDeploymentBucketName": "sls-stack-output-example-serverlessdeploymentbuck-BucketID"
}
```

repository: anttiviljami/serverless-stack-output

repo_name: anttiviljami/serverless-stack-output


text:
# /DATUMS/METRICS
## ***GET***

**Summary:** Get a list of running metrics, optionally searching with regex against input fields

### HTTP Request
`***GET*** /datums/metrics`

**Parameters**

| Name | Located in | Description | Required | Type |
| ---- | ---------- | ----------- | -------- | ---- |
| fully_qualified_moob | query | The fully qualified moob to query against | No | string |
| metric | query | The metric to query against | No | string |
| source | query | The source to query against | No | string |
| key | query | The key to query against | No | string |
| tags | query | The tags to query against | No | string |
| limit | query | The max number of items to return | No | number |
| sory_by | query | How to sort the results (alphabetically or by number of datums) | No | string |
| direction | query | Sort ascending or descending | No | string |

**Responses**

| Code | Description |
| ---- | ----------- |
| 200 | Success |
| 400 | Bad input |
| 401 | Unauthorized |

## ***POST***

**Summary:** Restarts the input metric

### HTTP Request
`***POST*** /datums/metrics`

**Parameters**

| Name | Located in | Description | Required | Type |
| ---- | ---------- | ----------- | -------- | ---- |
| payload | body | Restart payload | Yes |  |

**Responses**

| Code | Description |
| ---- | ----------- |
| 200 | Success |
| 400 | Bad input |
| 401 | Unauthorized |

repository: douglas-j-bothwell/slate

gha_license_id: NOASSERTION

repo_name: douglas-j-bothwell/slate


text:
[![](https://img.shields.io/badge/docs-dev-blue.svg)](https://pawbz.github.io/FocusedBlindDecon.jl/dev)
[![Build Status](https://travis-ci.org/pawbz/FocusedBlindDecon.jl.svg?branch=master)](https://travis-ci.org/pawbz/FocusedBlindDecon.jl)
[![codecov](https://codecov.io/gh/pawbz/FocusedBlindDecon.jl/branch/master/graph/badge.svg)](https://codecov.io/gh/pawbz/FocusedBlindDecon.jl)

# Focused Blind Deconvolution (FBD)

`FocusedBlindDecon` is a Julia package that implements the following methods.

**`lsbd!`** Least-squares blind deconvolution.

**`fibd!`** Focused interferometric blind deconvolution.

**`fpr!`** Focused phase retrieval.

**`fbd!`**=**`fibd!`**+**`fpr!`** Focused blind deconvolution.

These methods are described in the article below; if you make use of this code, please cite it.
```latex
@article{bharadwaj2019focused,
  title={Focused blind deconvolution},
  author={Bharadwaj, Pawan and Demanet, Laurent and Fournier, Aim{\'e}},
  journal={IEEE Transactions on Signal Processing},
  volume={67},
  number={12},
  pages={3168--3180},
  year={2019},
  publisher={IEEE}
}
```

## Installation
At the moment, `FocusedBlindDecon` depends on two unregistered packages `Misfits` and `Conv`.
For complete installation, enter these package manager commands in the REPL:
```julia
using Pkg
Pkg.add(PackageSpec(name="Misfits",url="https://github.com/pawbz/Misfits.jl.git"))
Pkg.add(PackageSpec(name="Conv",url="https://github.com/pawbz/Conv.jl.git"))
Pkg.add(PackageSpec(name="FocusedBlindDecon",url="https://github.com/pawbz/FocusedBlindDecon.jl.git"))
```

## Documentation & Tutorials

A detailed documentation and some tutorials are available here: [![](https://img.shields.io/badge/docs-dev-blue.svg)](https://pawbz.github.io/FocusedBlindDecon.jl/dev)

gha_language: Julia


text:
# Classifier Component Design Rationale

## Classifier Component

The classifier component will be used to classify tweet data against a number of different proposed classifications. The classifier results will then be stored into the database.

## Brexit Stance Classifier Design

### Overview

This classifier will be used to affirm a tweet's stance on Brexit.

Given a tweet categorise it as regarding:

* REMAIN
* LEAVE
* NEITHER

Using a neural network with various layers (to yet be confirmed) a set of training tweets will be given to it for the formation of the model. The tweets will be labelled using a tailored distant supervision technique of automatic labelling. After the model is formed the neural network will be used to classify the remaining tweets.

### Brexit Stance Automatic Labelling

The tweets will be gathered using a set of seed hashtags "#Brexit, #VoteLeave and #StrongerIn" which were three of the main hashtags used during the brexit campaign. The #VoteLeave and #StrongerIn hashtags will be used as the seed hashtags for the leave and remain stances respectively. For both of these hashtags, tweets containing these hashtags will be compared using **_Jaccards Coefficient_** to gather a list of commonly associated hashtags with each stance. After gathering a list of hashtags which co-occur with political stances; any hashtags which co-occur with both stances will be removed and a subset of high co-occuring hashtags will be selected for each of the stances. After gathering a non-bias set of hashtags for each brexit stance they will be used to automatically label tweets on which stance the tweet is most likely discussing (inclusive of some noise).

### Neural Network

****STRUCTURE TBD*** *

## Sentiment Classifier Design

### Overview

This classifier will be used to extract a tweet's sentiment orientation.

Given a tweet extract its sentiment polarity:

* POSITIVE
* NEGATIVE
* NEUTRAL

Using a neural network with various layers (to yet be confirmed) a set of training tweets will be given to it for the formation of the model. The tweets will be labelled using a tailored distant supervision technique of automatic labelling. The tweets will then be passed through Google's **_Word2vec/Doc2vec_** deep learning packages with the intention of converting them to a vector using the power of sentiment specic word embeddings (SSWE) which takes into consideration the context of the whole post by the user and not just the individual words that make up the post. The tweet SSWE vectors and corresponding polarity labels will then be fed into the Neural Network for training. After the model is formed the neural network will be used to classify the remaining tweets.

### Sentiment Polarity Automatic Labelling

Using a pre-established technique of automatic tweet sentiment labelling the classifier intends to use a set of "Positive" and "Negative" text-based emoticons as labels respective of the sentiment of the tweet.

### Neural Network

****STRUCTURE TBD*** *

gha_language: Python


text:
# Lecanora poriniformis Nyl. SPECIES

#### Status
SYNONYM

#### According to
Index Fungorum

#### Published in
Flora, Jena 48: 353 (1865)

#### Original name
Lecanora poriniformis Nyl.

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Ascomycota/Lecanoromycetes/Pertusariales/Ochrolechiaceae/Ochrolechia/Ochrolechia xanthostoma/ Syn. Lecanora poriniformis/README.md

repo_name: mdoering/backbone


text:
In the procuring, furnishing, donating, processing, distributing or using of human whole blood, plasma, blood products or blood derivatives for the purpose of injecting or transfusing in the human body, there shall be no implied warranty that the blood, plasma, products or derivatives are free from the virus of serum hepatitis as long as there is no known scientific test to detect the virus of serum hepatitis. [L 1969, c 185, §1]

Cross References

Advisory committees for infected health care workers, see §325-18.

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
#Simple authorisation for Rails

##Installation

Add the following to your gem file:

```
gem 'checkpoint'
```
and then run bundle install from your shell.

## How to use

By default all users get denied access to everything.

To enable a user to access/use a resource you must specify an authorisation rule to grant access. This is done using the "authorise" (or "authorize" for americans) method in the application controller.

So if for instance you wanted to grant access (to all users) to your posts index action you could do the following:

```ruby
#grant access to your posts controller 'index' action to all users
authorise "PostsController::index"

#or  authorize "PostsController::index"

```

Noticed how the pattern above is in the format of "ControllerName::action"

So if you wanted to grant action to your posts view action you could do the following:

```ruby
#grant access to your posts controller 'view' action to all users
authorise "PostsController::view"
```

If you want to grant access to all actions in your post controller you can use a wildcard ('*') char and do the following

```ruby
#grant access to your posts controller actions to all users
authorise "PostsController::*"
```

You can also do the same above by using a regular expression:

```ruby
#grant access to your posts controller actions to all users
authorise /\APostsController::.*\Z/
```

If you want to be able to grant access to your view action to only users who have signed in, you can do this by passing a block that returns true if the user is logged in.

```ruby
#grant access to your posts controller 'view' action to all users who have signed in
authorise "PostsController::view" do
  !current_user.nil?
end
```

In the example above the block uses the bindings of the controller that is being called, so therefore it can access anything that that particular controller access e.g. your current params hash etc...

Similarly you could grant access to everything to all admin users by doing the following:

```ruby
#grant access to everything to all admin users
authorise "*" do
  !current_user.nil? && current_user.admin?
end
```

Finally by passing an array you can authorise a range of controller actions in one go:

```ruby
#grant access your posts controller 'create' and 'update' actions to all users who have signed in
authorise ["PostsController::create", "PostsController::update"] do
  !current_user.nil?
end
```

## FAQ

### How do I enable devise?

```ruby
authorise "Devise::*"

```
### How do I enable an API Key?

```ruby
#grant access to all controllers in the Api namespace for requests which have the API key as a param
authorize "Api::*" do
  params[:api_key] == API_KEY
end

```

## License

Checkpoint is released under the MIT license:

* http://www.opensource.org/licenses/MIT

repository: digitalfrost/checkpoint

extension: markdown

repo_name: digitalfrost/checkpoint


text:
---
title: Aggregate
headline: Aggregate
bodyclass: docs
layout: docs
sidenav: doc-side-concepts-nav.html
type: markdown
---

Aggregate

Aggregate is the main building block of a business model.
From the application point of view it consists of the following:
1. Commands which arrive to it.
2. Events which appear in response to these commands.
3. How these events influence the state of an aggregate.

[Aggregates](http://martinfowler.com/bliki/DDD_Aggregate.html) guarantee consistency of data modifications in response to commands they receive. Aggregate is the most common case of Command Handler. It modifies its state and produces one or more events in response to a command. These events are used later to restore the state of the aggregate.
In Spine, aggregates are [defined as Java classes](/java/aggregate.md), and their states are [defined as protobuf messages](/biz-model/aggregate-states.md).


text:
---
header: clear
example: ModelStore.clear([modelName], [id])
---

Removes the model(s) from the [cache](#cache).  If you pass both the `modelName` and the `id` it will clear that model from the store.  If you only pass the `modelName` it will clear all of the models of that type in the store.  Passing no arguments will clear the entire model store.

gha_language: CSS


text:
---
comments: true
date: '2009-03-31 13:05:09'
layout: post
slug: php-meet-master-pages
status: publish
title: PHP, Meet Master Pages
wordpress_id: '107'
categories:
- software development
tags:
- php
- code
- layouts
- master pages
- zend framework
---

This was an article I began writing several months ago. I didn't want to abandon it, so I'm finishing it up now. It's merely an informational and doesn't contain a lot of depth. It's meant for the introductory users.

For those PHP developers who have been frustrated with how to create a standard layout for pages other than having to remember to put an opening div block after the header includes and a closing div block before the footer includes, listen up. Things are about to get much easier. In fact, those PHP developers who have done ASP.Net programming in the past, you're about to get much more pleased with PHP. The only drawback, which is more of a gain anyways, is you have to use the Zend Framework. Note that this topic is for those people who are not blessed withing already using a layout or template engine and are forced to do things the old way. Those of you who are using something like Smarty may not benefit from this, but keep reading anyways. :-D

Meet Zend_Layout. This little friendly class is going to rock your world. Imagine, for a second, that you can create a single file with all of the static content pre-layed and in an almost strictly-HTML format and stop having to use include() or require() statements to make sure headers, footers, and other static content are loaded into your files. Imagine further that you can use this same file to load up content that's dynamically generated and not have to worry about the order in which your application processes to place it on your page. Both of these critical parts of web application development can now be achieved through Zend_Layout.

So, you're probably wondering what horrific code I'm trying to get away from using. Imagine an application with code that looks like this:

{% codeblock headers.php %}
<?php
$siteTitle = "Joe's eCommerce Website";

echo <<<EOD
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

    <title>{$siteTitle}</title>
    <link rel="stylesheet" href="css/style.css" type="text/css" />
    <meta name="description" content="{$siteDescription}" />

EOD;

// Some nasty PHP code to generate a navigation bar right here.

echo <<<EOD

EOD;
?>
{% endcodeblock %}

{% codeblock footers.php %}
<?php

echo <<<EOD

About Us

FAQ

Privacy Policy

EOD;
?>
{% endcodeblock %}

Then, you're actual page that's supposed to do something looks like:

{% codeblock listProducts.php %}
<?php
require_once "headers.php";

// Do some code that displays something like a table

require_once "footers.php";
?>
{% endcodeblock %}

Or worse, suppose your file that actually does something looks like:

{% codeblock anotherWeirdFile.php %}
<?php
require_once dirpath(__FILE__)."/../../config/site.conf.php";
require_once $_sys['application_root']."/includes/common/headers.php";
require_once $_sys['application_root']."/includes/common/javascript.php";
require_once $_sys['application_root']."/includes/common/css.php";
require_once $_sys['application_root']."/includes/common/openingBody.php";

// Again, code to do real work

require_once $_sys['application_root']."/includes/common/closingBody.php";
require_once $_sys['application_root']."/includes/common/footers.php";
?>
{% endcodeblock %}

We can go further and show worse code samples than that, but I think you get the picture now, especially if you take into account an application where you have at least 25+ files all displaying data. Having to make sure that all of those files are 1) included at the top and bottom of your PHP files and 2) are in the correct order becomes a real big pain in the arse really quickly. Furthermore, the situation is complicated if you need to change the view based on certain criteria based in the processing section. You then have to do your processing first, and make sure that the data is returned rather than echo'ed straight to the response screen, or you have to buffer the output, capture the output and echo the buffer when rendering the view. It's all very nasty, and I've come across my fair share of poorly implemented rendering for PHP applications.

So, how do we fix this? Well, I will spare the details of how an application needs to be setup for use within the Zend Framework (because it's quite a detailed discussion). You'd be better off reading the Zend Framework documentation than reading what I'd have to say about it. The following is the only script like this in my software application. There's no repitition of this code, and none of my scripts have to include it via require_once().

{% codeblock lang:php %}
<!DOCTYPE html
    PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<?php
	// Set the title of the site last and the separator for the title
	$this->headTitle('CFEGroup');
	$this->headTitle()->setSeparator(' - ');

	echo $this->headTitle();
	echo $this->headStyle();
	if ($this->dojo()->isEnabled()) {
		$this->dojo()->setLocalPath('/js/dojo/dojo.js')
		             ->addStyleSheetModule('dijit.themes.tundra');
		echo $this->dojo();
	}
	echo $this->headScript();

	// Other Header information
	echo $this->partial('header.phtml');
?>

<?php
    // Display the user status block
    echo $this->layout()->userstatus;

    // Display the navigation bar
    echo $this->layout()->navwidget;

    // fetch 'content' key using layout helper:
    echo $this->layout()->content;

    // Display the footer
    echo $this->partial('footer.phtml');

    // Display any inline JavaScript (used by Dojo)
    echo $this->inlineScript();
?>

{% endcodeblock %}

As you can see, though, there is PHP in the script. However, the sheer number of lines of code that this normally occupies is a LOT less. Furthermore, hooks are in place that allow me to specify in the view script of the application whether I depend on additional resources (e.g. CSS or JavaScript). So, below is an example of a view script I use on one of my pages.

{% codeblock lang:php %}
<?php
// Enable Dojo for this view
$this->dojo()->enable()
             ->setDjConfigOption('parseOnLoad', true)
             ->requireModule('dijit.Dialog')
             ->requireModule('dijit.form.Form')
             ->requireModule('dijit.form.ComboBox')
             ->requireModule('dijit.form.TextBox')
             ->requireModule('dijit.form.Button');
?>

    <div dojoType="dijit.form.Form" name="deleteAddress" jsId="deleteAddress" id="deleteAddress" method="post"
          action="<?php echo $this->url(array(), 'addressDelete'); ?>">

        <input type="hidden" name="addressId" id="addressId" value="" />

            Are you sure you want to delete the following address?

            <button dojoType="dijit.form.Button" type="submit" onClick="dijit.byId('deleteAddressDialog').hide(); return false;"
                    iconClass="dijitEditorIcon dijitEditorIconCancel">No</button>
            <button dojoType="dijit.form.Button" type="submit"
                    iconClass="dijitCheckBoxIcon">Yes</button>

My Addresses

            <button dojoType="dijit.form.Button" iconClass="plusIcon" value="Add"
                    onClick="window.location = '<?php echo $this->url(array(), 'addressAdd'); ?>'">Add</button>

        Action
        Type
        Street 1
        Street 2
        City
        State
        Zip Code
        Country

    <?php if (empty($this->addresses)): ?>

                    No addresses were found. Please add an address by clicking the Add button above.

    <?php else: ?>
    <?php foreach($this->addresses as $address): ?>

                <button dojoType="dijit.form.Button" type="button" iconClass="dijitEditorIcon dijitEditorIconCut"
                        onClick="window.location.href = '<?php echo $this->url(array(
                            'addressId' => $address->getId()), 'addressEdit'); ?>'">Edit</button>
                <button dojoType="dijit.form.Button" type="button" iconClass="dijitEditorIcon dijitEditorIconDelete"
                        onClick="displayAddressDeleteDialog('<?php echo $address->getId(); ?>',
                                                            '<?php echo $address->getStreet1(); ?>',
                                                            '<?php echo $address->getStreet2(); ?>',
                                                            '<?php echo $address->getCity(); ?>',
                                                            '<?php echo $address->getState(); ?>',
                                                            '<?php echo $address->getZipCode(); ?>',
                                                            '<?php echo $address->getCountry(); ?>')">Delete</button>

            <?php echo Core_Enum::getEnumOption($address->getType(), new Cfegroup_Person_Address_Type()); ?>
            <?php echo $address->getStreet1(); ?>
            <?php echo $address->getStreet2(); ?>
            <?php echo $address->getCity(); ?>
            <?php echo $address->getState(); ?>
            <?php echo $address->getZipCode(); ?>
            <?php echo $address->getCountry(); ?>

    <?php endforeach; ?>
    <?php endif; ?>

{% endcodeblock %}

This view script is rendered in the echo $this->layout()->conent area. This facet of the Zend Framework makes it really powerful with respect to being able to completely change the look-and-feel of a web site without having to change anything but HTML. Furthermore, you can build in areas for plugins that are supposed to be rendered by doing something similar to the following:

{% codeblock lang:php %}

        <?php echo $this->layout()->pluginArea; ?>

        <?php echo $this->layout()->nav; ?>

    <?php echo $this->layout()->content; ?>

{% endcodeblock %}

The above is a small snippet of a layout. If it were a partial, though, that would still be acceptable and the full layout would render the partial.

In any case, this is just a small introduction to PHP Layouts. You'll find more information about layouts in the Zend Framework Reference manual and the many different books written on the Zend Framework.

repository: neraath/octopress

repo_name: neraath/octopress


text:
---
title: Make RadEditor Content Area to fill the width of the page
description: I need the editor content area to be full width in the page.
type: troubleshooting
page_title:
slug: editor-span-content-area-to-the-side-edges-of-browser
position:
tags: editor, CSS, content area, width, border
ticketid: 1584755
res_type: kb
---

## Environment

			Product
			RadEditor for ASP.NET AJAX

## Description
The solution answers the questions below and allows you to customize the appearance of RadEditor:
- I need the editor content area to be full-width of the page.
- I'd like the content area to span to the very edges of the page.

## Solution
Here is how with simple CSS to reduce the left and right padding and the border of the content area of RadEditor when its Width is 100%:

````ASPX
<style>
.RadEditor.reWrapper {
    border: none;
    padding: 0;
    position: absolute;
    left : 0;
}
</style>
<telerik:RadEditor runat="server" ID="RadEditor1" Width="100%"></telerik:RadEditor>
````

repository: telerik/ajax-docs

gha_language: C#

repo_name: telerik/ajax-docs


text:
---
layout: post
title: The Quest For Employability
Google Hashcode

---
Whilst searching for jobs a common theme regularly came up: what events do you do in regards to your degree, outside of your degree?

The reason they ask this is more than likely to make sure that you enjoy doing what you do, rather than just being in for the money. This led myself and a few friends to enter as many of these as possible before september 2018, the first being Google Hashcode. Below is a practice example they send to try and get you in the right frame of mind.

The Challenge

The practice issue Google provided was named 'Pizza' and the aim was to slice the pizza to the specification they provided you with. The pizza had two ingredients, mushroom and tomato, with each ingredient taking up one grid. You are provided with three specifications:

The minimum and maximum slice size

The minimum and maximum amount of each ingredient on each slice

The column and row size of the pizza

This leaves you something like the below, which is the small pizza grid specifications.

![_config.yml]({{ site.baseurl }}/images/Screen Shot 2018-02-25 at 17.58.11.png)

In this case each slice needed to have 1 of each ingredient per slice with a maximum slice size of 5. The aim is to create an algorithm to use as many of the grids as possible.

Our Solution

Spoiler alert: This may be the worst spoiler alert ever given, but if you want to try and figure it out for yourself don't read on.

We decided that initially we would go through horizontally pairing adjacent T and Ms and then do the same vertically. This initially left us with something like this:

![_config.yml]({{ site.baseurl }}/images/Screen Shot 2018-02-25 at 17.58.22.png)

Once the first was complete and the slices had been coupled the grids with no coupling would then look around and attack themselves to the most appropriate slice, depending on the given variables. If there were multiple slices it could attach to it would attack to the smallest, and if they were the same size, it would just attack to the one it checked first.

The grid below shows how the first in paired piece would look around:

![_config.yml]({{ site.baseurl }}/images/Screen Shot 2018-02-25 at 17.58.30.png)

As can be seen the 2nd and 4th checks are the most suitable, however as they are the same size the chosen slice is the first checked out of the two, so will join slice check two. After this process has been completed a couple of times the pizza will look like this.

![_config.yml]({{ site.baseurl }}/images/Screen Shot 2018-02-25 at 17.58.40.png)

After this process has ran through a couple of times the pizza will look like this. Leaving 41/42 of the pizza slices fitting the specification.

This solution was found in about 30 minutes due to time restraints, so the full 42 slices couldn't be filled.


text:
---
layout: post
title: "Nouvelles hebdomadaires de PostgreSQL - 27 mai 2012"
author: "chl"
categories: [PostgreSQL Weekly News]
redirect_from: "index.php?post/2012/06/01/Nouvelles-hebdomadaires-de-PostgreSQL-27-mai-2012"
---

Le PgDay argentin 2012 se tiendra à l'Université Nationale de Quilmes, à Bernal près de Buenos Aires, le 13 novembre. Les sujets couverts concerneront aussi bien les utilisateurs, développeurs et contributeurs, que les décideurs et hauts responsables. Pour plus d'informations à propos de la conférence, consultez le site suivant :

http://www.pgday.com.ar/quilmes2012?lang=en

Offres d'emplois autour de PostgreSQL en mai

Internationales :

http://archives.postgresql.org/pgsql-jobs/2012-05/threads.php;

Francophones :

http://forums.postgresql.fr/viewforum.php?id=4.

PostgreSQL Local

Le PGDay France aura lieu à Lyon, le 7 juin 2012 :

http://www.pgday.fr

La conférence PostgreSQL China 2012 aura lieu du 14 au 17 juin à Pékin :

http://wiki.postgresql.org/wiki/Pgconfchina2012

La 4ème Session PostgreSQL aura lieu le 4 octobre 2012 à Paris. Appel à conférenciers et plus d'informations sur :

http://www.postgresql-sessions.org/en/4/

La PostgreSQL Conference Europe 2012 aura lieu à Prague, République Tchèque, du 23 au 26 octobre. L'appel à sponsors est lancé :

http://2012.pgconf.eu/

PostgreSQL dans les média

Planet PostgreSQL :

http://planet.postgresql.org/

Planet PostgreSQLFr :

http://planete.postgresql.fr/

PostgreSQL Weekly News / les nouvelles hebdomadaires vous sont offertes cette semaine par David Fetter. Traduction par l'équipe PostgreSQLFr sous licence CC BY-NC-SA.

Proposez vos articles ou annonces avant dimanche 15:00 (heure du Pacifique). Merci de les envoyer en anglais à david (a) fetter.org, en allemand à pwn (a) pgug.de, en italien à pwn (a) itpug.org et en espagnol à pwn (a) arpug.com.ar.

(lien vers l'article original)

Revues de code

Correctifs appliqués

Tom Lane a poussé :

Document that we deviate from ISO 8601 by not using 'T' on output. Per discussion, we should explain that we follow RFC 3339 and not really the letter of the ISO 8601 spec for timestamp output format. Mostly Brendan Jurd's wording, though I tweaked it to clarify that we do take 'T' on input. Minor additional copy-editing and markup-tweaking, too.

http://git.postgresql.org/pg/commitdiff/8be950f5c0a2d8591cfc9955ad4ee4baf50d6131

Adjust documentation of ALTER TABLE CLUSTER ON for more consistency. Josh Kupershmidt

http://git.postgresql.org/pg/commitdiff/e79da56b85fa69055e872bdb79fb20f800175bc6

Update woefully-obsolete comment. The accurate info about what's in a lock file has been in miscadmin.h for some time, so let's just make this comment point there instead of maintaining a duplicative copy.

http://git.postgresql.org/pg/commitdiff/efae4653c98fd201a8a723bceabf182a1005ac0f

Move postmaster's RemovePgTempFiles call to a less randomly chosen place. There is no reason to do this as early as possible in postmaster startup, and good reason not to do it until we have completely created the postmaster's lock file, namely that it might contribute to pg_ctl thinking that postmaster startup has timed out. (This would require a rather unusual amount of time to be spent scanning temp file directories, but we have at least one field report of it happening reproducibly.) Back-patch to 9.1. Before that, pg_ctl didn't wait for additional info to be added to the lock file, so it wasn't a problem. Note that this is not a complete fix to the slow-start issue in 9.1, because we still had identify_system_timezone being run during postmaster start in 9.1. But that's at least a reasonably well-defined delay, with an easy workaround if needed, whereas the temp-files scan is not so predictable and cannot be avoided.

http://git.postgresql.org/pg/commitdiff/b94ce6e807ce5685bda1dcd36027091ceec6b5a0

Ensure that seqscans check for interrupts at least once per page. If a seqscan encounters many consecutive pages containing only dead tuples, it can remain in the loop in heapgettup for a long time, and there was no CHECK_FOR_INTERRUPTS anywhere in that loop. This meant there were real-world situations where a query would be effectively uncancelable for long stretches. Add a check placed to occur once per page, which should be enough to provide reasonable response time without adding any measurable overhead. Report and patch by Merlin Moncure (though I tweaked it a bit). Back-patch to all supported branches.

http://git.postgresql.org/pg/commitdiff/ed962fd712bbc0836437c8f789d9152aca5711b5

Fix array overrun in regex code. zaptreesubs() was coded to unconditionally reset a capture subre's corresponding pmatch[] entry. However, in regexes without backrefs, that array is caller-supplied and might not have as many entries as the regex has capturing parens. So check the array length and do nothing if there is no corresponding entry, much as subset() does. Failure to check this resulted in a stack clobber in the case reported by Marko Kreen. This bug appears to have been latent in the regex library from the beginning. It was not exposed because find() called dissect() not cdissect(), and the dissect() code path didn't ever call zaptreesubs() (formerly zapmem()). When I unified dissect() and cdissect() in commit 4dd78bf37aa29d04b3f358b08c4a2fa43cf828e7, the problem was exposed. Now that I've seen this, I'm rather suspicious that we might need to back-patch it; but will refrain for now, for lack of evidence that the case can be hit in the previous coding.

http://git.postgresql.org/pg/commitdiff/2a4c46e0baf2d51117cd4468b28705d01ffcbff9

Use binary search instead of brute-force scan in findNamespace(). The previous coding presented a significant bottleneck when dumping databases containing many thousands of schemas, since the total time spent searching would increase roughly as O(N2) in the number of objects. Noted by Jeff Janes, though I rewrote his proposed patch to use the existing findObjectByOid infrastructure. Since this is a longstanding performance bug, backpatch to all supported versions.

http://git.postgresql.org/pg/commitdiff/73cc7d3b240e1d46b1996382e5735a820f8bc3f7

Fix string truncation to be multibyte-aware in text_name and bpchar_name. Previously, casts to name could generate invalidly-encoded results. Also, make these functions match namein() more exactly, by consistently using palloc0() instead of ad-hoc zeroing code. Back-patch to all supported branches. Karl Schnaitter and Tom Lane

http://git.postgresql.org/pg/commitdiff/d3b97d1488ba868f6bab12eeaf0b9ae75fad2566

Prevent synchronized scanning when systable_beginscan chooses a heapscan. The only interesting-for-performance case wherein we force heapscan here is when we're rebuilding the relcache init file, and the only such case that is likely to be examining a catalog big enough to be syncscanned is RelationBuildTupleDesc. But the early-exit optimization in that code gets broken if we start the scan at a random place within the catalog, so that allowing syncscan is actually a big deoptimization if pg_attribute is large (at least for the normal case where the rows for core system catalogs have never been changed since initdb). Hence, prevent syncscan here. Per my testing pursuant to complaints from Jeff Frost and Greg Sabino Mullane, though neither of them seem to have actually hit this specific problem. Back-patch to 8.3, where syncscan was introduced.

http://git.postgresql.org/pg/commitdiff/532fe28dade9291b7a7f7de3920a4d997bbd86a1

Peter Eisentraut a poussé :

pg_ctl: Sort signal list in --help output. The list was neither logical nor numerical nor alphabetical. Let's go with alphabetical.

http://git.postgresql.org/pg/commitdiff/cdf8bcb8d93b4365f124e994c31687b39b619253

libpq: Add missing file to GETTEXT_FILES list. For the record, fe-print.c is also missing, but it's sort of deprecated, and the string internationalization there has some issues, and it doesn't seem worth fixing that. So let's leave that out.

http://git.postgresql.org/pg/commitdiff/4c39a09089130fb2eeccd6eacdc3d12aa69f84de

Add small example about pg_archivecleanup -x option. Every time I read this I had doubts about whether the argument to the -x option should include the dot (yes). A small example should clarify this.

http://git.postgresql.org/pg/commitdiff/92a953fbf8c90c3b316fbc275767efb6994f1589

pg_standby: Remove tabs from string literals. And align a bit better with the rest of the debug output.

http://git.postgresql.org/pg/commitdiff/72155b29a864d3621795f6cd1528d8e54cc3c671

Update SQL key word list to SQL:2011. For space reasons, drop SQL:1999 and SQL:2003. Only keep the latest two and SQL-92 for historical comparison.

http://git.postgresql.org/pg/commitdiff/ace397e9d24eddc56e7dffa921f506117b602d78

PL/Perl: Avoid compiler warning from clang. Use SvREFCNT_inc_simple_void() instead of SvREFCNT_inc() to avoid warning about unused return value.

http://git.postgresql.org/pg/commitdiff/a8b92b6090f14a3a84d2b904eff1794e21047fae

Suppress -Wunused-result warning about write(). This is related to aa90e148ca70a235897b1227f1a7cd1c66bc5368, but this code is only used under -DLINUX_OOM_ADJ, so it was apparently overlooked then.

http://git.postgresql.org/pg/commitdiff/27314d32a883e3c4667d8249c3d4760fed917a12

Update SQL features list. Set E081 Basic Privileges to supported, since by the letter of it, we support it, even though not all possible forms of USAGE privileges are implemented.

http://git.postgresql.org/pg/commitdiff/388d2516792bb22d461d0b2af38730bfdcbf9027

psql: Remove notice about readline from --version output. This was from a time when readline support wasn't standard. And it doesn't help analyzing current line editing library problems.

http://git.postgresql.org/pg/commitdiff/8e497c731b481aac15fed5cd006fcd64f2f00de0

Robert Haas a poussé :

Repair out-of-date information in src/backend/storage/buffer/README. In commit d526575f893c1a4e05ebd307e80203536b213a6d, we changed things so that buffer usage counts are incremented when the buffer is pinned, rather than when it is unpinned, but the README file didn't get the memo. Report by Amit Kapila.

http://git.postgresql.org/pg/commitdiff/219c024c64ced7ce497fe455b1e3dd7b70012775

Prevent pg_basebackup when integer_datetimes flag doesn't match. Magnus Hagander, reviewed by Fujii Masao, with slight wording changes by me.

http://git.postgresql.org/pg/commitdiff/304aa339b20df9f9ba6f4d93175e05098f6fd1c1

Release note improvements. Document some more things as incompatibilities, and improve wording of another item. Noah Misch

http://git.postgresql.org/pg/commitdiff/b536458e73a8d9294817228f06961913f6faa551

Fix error message for COMMENT/SECURITY LABEL ON COLUMN xxx IS 'yyy' When the column name is an unqualified name, rather than table.column, the error message complains about too many dotted names, which is wrong. Report by Peter Eisentraut based on examination of the sepgsql regression test output, but the problem also affects COMMENT. New wording as suggested by Tom Lane.

http://git.postgresql.org/pg/commitdiff/8fbe5a317de6c91826ae2c91f73f780bb0d6489e

Bruce Momjian a poussé :

Remove reviewers from 9.2 release notes; improve attributions.

http://git.postgresql.org/pg/commitdiff/8a46e25189b428e1ff8af5ba19c6f32287277575

9.2 release notes: GiST index improvements are for all geometric index types, per Alexander Korotkov.

http://git.postgresql.org/pg/commitdiff/007522e6b4c32d7ae67a2ff7f568eb2f0bd257f6

Fix reindexdb manual page to say --maintenance-db controls what is reindexed, not vacuumed (typo). Per report from Thomas REISS

http://git.postgresql.org/pg/commitdiff/e6b7170c33b4795cc519137528523bd3c4933edb

Fix markup for HISTORY generation.

http://git.postgresql.org/pg/commitdiff/0013a665b75a62f6110bff99273b1015b4aa60fe

Add 9.2 release note authorship mentions for Heikki and Alexander Korotkov, per Alexander Korotkov.

http://git.postgresql.org/pg/commitdiff/b9c895ee6f336084048f4c8cc76b81afb4535e58

Improve wording of 9.2 clog release note item.

http://git.postgresql.org/pg/commitdiff/13477c0197cb4826b03c559a23f4bc838e61d4fb

Mention Peter Geoghegan as primary author of pg_stat_statements changes.

http://git.postgresql.org/pg/commitdiff/db2cd074824d1cd3c7b7397b7c7230100d7a78a3

Adjust pg_upgrade to output a separate log file for pg_ctl output on Windows, to avoid opening a file by multiple processes.

http://git.postgresql.org/pg/commitdiff/476291bef0985e242685fcd37866fec7ab1b97c7

Remove PL/Perl null array 9.2 release note item, per Andrew Dunstan

http://git.postgresql.org/pg/commitdiff/eeef7bd2da8f99a5f5abd9d495663001c2fccd12

Change pg_stat_statements order of release note items, per Peter Geoghegan.

http://git.postgresql.org/pg/commitdiff/7672366a89dcccd0ba14eecdbc41b641480eb1e0

Clarify 9.2 release notes items about pg_stat_statements, to better document fix of double counting and read/write count addition, per Peter Geoghegan.

http://git.postgresql.org/pg/commitdiff/32cebaaed5127c1dd2ad616051065bf4c7652afa

On Windows, have pg_upgrade use different two files to log pg_ctl start/stop output, to fix file share error reported by Edmund Horner

http://git.postgresql.org/pg/commitdiff/d226e236c6ccdd27f1fd42aaab070762d1b70275

Have pg_upgrade only use one extra log file for Win32, not two.

http://git.postgresql.org/pg/commitdiff/45ca31d6a7eaf91dc65fd5cf2b140320feb3fa3f

Add pg_update C comment about problems with plpython_call_handler().

http://git.postgresql.org/pg/commitdiff/d4696fa68f88f371e9da77cc0319fa0b947fd911

Add C comment explaining why we can't exclude checking functions in the pg_catalog schema, even though they are not explicitly dumped (they are implicitly dumped, e.g. create language plperl).

http://git.postgresql.org/pg/commitdiff/20a3830b81d07aca1b8c3e954b4bc49d0847c51d

Improve pg_upgrade C comment.

http://git.postgresql.org/pg/commitdiff/4498a3407acfff83ab791d0d9764c70566ab840f

Magnus Hagander a poussé :

Add missing PQfinish() calls. Fujii Masao

http://git.postgresql.org/pg/commitdiff/77f93cb32d8711926b07030c1c73a57a7bc66911

Fix base backup streaming xlog from standby. When backing up from a standby server, the backup process will not automatically switch xlog segment. So we must accept a partially transferred xlog file in this case, but rename it into position anyway. In passing, merge the two callbacks for segment end and stop stream into a single callback, since their implementations were close to identical, and rename this callback to reflect that it stops streaming rather than continues it. Patch by Magnus Hagander, review by Fujii Masao

http://git.postgresql.org/pg/commitdiff/31d965819bdaa971ae007a67611e78ec1d185f14

Fix handling of pg_stat_statements.stat temporary file. Write the file to a temporary name and then rename() it into the permanent name, to ensure it can't end up half-written and corrupt in case of a crash during shutdown. Unlink the file after it has been read so it's removed from the data directory and not included in base backups going to replication slaves.

http://git.postgresql.org/pg/commitdiff/2b97db61dd0bffb0843eb2ea9be054d925e88ef1

Make pg_recievexlog by default loop on connection failures. Avoids the need for an external script in the most common scenario. Behavior can be overridden using the -n/--noloop commandline parameter.

http://git.postgresql.org/pg/commitdiff/16282ae688de2b320cf176e9be8a89e4dfc60698

Correctifs rejetés (à ce jour)

Pas de déception cette semaine :-)

Correctifs en attente

Alexander Korotkov sent in another revision of the patch to add conversion from pg_wchar to multibyte.

Gurjeet Singh sent in a patch to add a new syntax allowing joining multiple CREATE INDEX statements with commas, that signifying that the indexes are to be created all in one pass.

Heikki Linnakangas sent in a patch to speed up the new buffering GiST build code.

Andrew Dunstan sent in a patch to fix a problem with pg_dump and pg_restore --data-only.

Marti Raudsepp sent in a patch to mark as "skipped" sorts of 0 or 1 tuple in EXPLAIN.

Fujii Masao sent in a patch to add a pg_size_pretty(int) function.

Pavel Stehule sent in a patch to add a "shell" output format for psql which optimizes the output for use by the shell.


text:
# JavaScript 30

[The JavaScript 30](https://javascript30.com/) is an outstanding series of 30 video tutorials by Wes Bos.  Each tutorial builds a small, interesting project from scratch using plain JS, CSS & HTML.

You'll be using these tutorials as a chance to practice collaborative development. Using his tutorials as a starting point, you will work in teams of 2-3 to collaboratively turn each project into a full repository.

The first couple challenges you try to build as a group will be difficult.  You'll have many merge conflicts, difficulty dividing the work, and will certainly feel like it's much more work than just building the project.  And it will be more work!  But worth it.  Learning how to collaborate with forks, branches, milestones & issues on small projects you understand completely will help you understand the big picture of project management.

### Index

- [Collaborative Development](#collaborative-development)
  - [0. Independent Study](#0-Independent-study)
  - [1. Project Repository](#1-project-repository)
  - [2. Project Planning](#2-project-planning)
  - [3. Project Management](#3-project-management)
  - [4. Developing](#4-developing)
  - [5. Documenting](#5-documenting)
  - [Repeat!](#repeat)
- [The Challenges](#the-challenges)
  - [For Group Study](#for-group-study)
  - [For Solo Study](#for-solo-study)
- [Helpful Links](#helpful-links)

---

## Collaborative Development

Your main objective with these exercises is to practice working with others on one shared code base.  For each of the group challenges you should work in a group of 2-3 to break down the project into user stories and create a full project repository one step at a time.  A finished project repository will have:

- A `development-strategy.md` breaking down the finished project into steps.
- One milestone per user story, one issue per task, and a project board to organize the issues.
- One branch per user story, each merged into _master_
- The finished code for your project separated into multiple folders and files according to separation of concerns.

After finding a team and picking a challenge,  you should ...

### 0. Independent Study

Each person in your group should study the challenge independently, following the video tutorial and studying Wes Bos' finished example code.

### 1. Project Repository

Choose one of your team members to be the Repository Owner, they will create a new repository on their account named after the challenge.

Add the other team members as collaborators so they can manage issues on the main repository's project board.

Each team member should now fork the main repository.

### 2. Project Planning

Work together to write a `development-strategy.md`:

- How do you want to break this project into user stories? (it's okay if there is only one user story!)
- What's a good way to organize the code for this project? What folders & files make sense to have?
- What code do you need to write for each user story? Which folders and files will you need to work on?
- Include a wireframe for your finished project in the strategy file.

Using Pull Requests, make sure each team member has a copy of the complete `development-strategy.md` on their fork of the project.

### 3. Project Management

1. Create one milestone for each user story.
1. Create one issue for each task that needs to be completed (ie. one piece of code: a single listener, a single handler, a logic function, a style class, ...)
    - Assign it to the correct User Story milestone.
    - Label the issue based on it's concern (ie. handler, logic, listener, style, ..)
    - Assign each issue to one of your team members
1. Create a new project board in the main group repository and move all of your issues onto the board (the _Basic Kanban_ template project will do)

### Developing

Get coding!

- Develop each user story on a separate branch, merging to master only when it is complete.
 When they have completed their task they should send a pull request with their code to the main group repo.
-  By the time a user story is finished, each team member should have the same code on their fork & branch as the main repository.
- When a user story is fully merged onto it's branch of the main group repository, merge it to the master branch and move on to the next!

### Documenting

After all user stories are complete & merged to mast, and after all of your issues are closed, it's time to put on the finishing touches.

Fill out a complete README.md to document your project and turn on GitHub pages to share a live demo.

### Repeat!

There are 24 group projects, keep working your way through them all until you can collaborate in your sleep.

[TOP](#javascript-30)

---

## The Challenges

Like the title says, there are 30 challenges.  Most of them are full projects with HTML, CSS & JavaScript - these are for group study.  But a few of them are more focused on a specific JS skill - these are for you to study independently in your own repository.

As you work your way through the 30 challenges you should check them off in the lists below and provide a link to the repository with your solution. If it's a group project link to the main group repository, not your fork.

### For Group Study

> Each time you finish one of these challenges, check it off and provide a link to the main group repository - not your fork! (unless yours is the main group repo.)

- [ ] 01 - [drum kit](https://github.com/feridunAKYOL/01---drum-kit)
- [ ] 02 - [clock](https://github.com/feridunAKYOL/02---clock)
- [ ] 03 - [css variables](https://github.com/feridunAKYOL/03---css-variables)
- [ ] 05 - [flex panel gallery](https://github.com/feridunAKYOL/05---flex-panel-gallery)
- [ ] 06 - [type ahead](https://github.com/feridunAKYOL/07---type-ahead)
- [ ] 08 - [fun with html5 canvas](https://github.com/feridunAKYOL/08---fun-with-html5-canvas)
- [ ] 10 - [Hold Shift and Check Checkboxes](https://github.com/feridunAKYOL/10---Hold-Shift-and-Check-Checkbox)
- [ ] 11 - [Custom Video Player](https://github.com/feridunAKYOL/11---Custom-Video-Player)
- [ ] 12 - [Key Sequence Detection](https://github.com/feridunAKYOL/12---Key-Sequence-Detection)
- [ ] 13 - [Slide in on a Scroll](https://github.com/feridunAKYOL/13---Slide-in-on-a-Scroll)
- [ ] 15 - [LocalStorage](https://github.com/feridunAKYOL/15---LocalStorage)
- [ ] 16 - [Mouse Move Shadow](https://github.com/feridunAKYOL/16---Mouse-Move-Shadow)
- [ ] 17 - [Sort Without Articles](https://github.com/feridunAKYOL/17---Sort-Without-Articles)
- [ ] 19 - [Webcam Fun](https://github.com/feridunAKYOL/19---Webcam-Fun)
- [ ] 20 - [Speech Detection](https://github.com/feridunAKYOL/20---Speech-Detection)
- [ ] 21 - [Geolocation](https://github.com/feridunAKYOL/21---Geolocation)
- [ ] 22 - [Follow Along Link Highlighter](https://github.com/feridunAKYOL/22---Follow-Along-Link-Highlighter)
- [ ] 23 - [Speech Synthesis](https://github.com/feridunAKYOL/23---Speech-Synthesis)
- [ ] 24 - [Sticky Nav](https://github.com/feridunAKYOL/24---Sticky-Nav)
- [ ] 26 - [Stripe Follow Along Nav](https://github.com/feridunAKYOL/26---Stripe-Follow-Along-Nav)
- [ ] 27 - [Click & Drag](https://github.com/feridunAKYOL/27---Click-Drag)
- [ ] 28 - [Video Speed Controller](https://github.com/feridunAKYOL/28---Video-Speed-Controller)
- [ ] 29 - [Countdown timer](https://github.com/feridunAKYOL/29---Countdown-timer)
- [ ] 30 - [Whack a Mole](https://github.com/feridunAKYOL/30---Whack-a-Mole)

[TOP](#javascript-30)

---

### For Solo Study

> Each time you finish one of these, check it off and provide a link to the repository with your finished code

- [ ] 04 - [array cardio day 1](https://github.com/feridunAKYOL/04---array-cardio-day-1)
- [ ] 06 - [array cardio day 2](https://github.com/feridunAKYOL/06---array-cardio-day-2)
- [ ] 09 - [dev tools domination](https://github.com/feridunAKYOL/09---dev-tools-domination)
- [ ] 14 - [javascript reverences vs copying](https://github.com/feridunAKYOL/14---javascript-reverences-vs-copying)
- [ ] 18 - [Adding Up Times with Reduce](https://github.com/feridunAKYOL/18---Adding-Up-Times-with-Reduce)
- [ ] 25 - [Event Capture, Propagation, Bubbling](https://github.com/feridunAKYOL/25---Event-Capture-Propagation-Bubbling)

[TOP](#javascript-30)

---

## Helpful Links

- [Wes Bos' Code to Study](https://github.com/wesbos/JavaScript30)
- [study.hackyourfuture.be](https:study.hackyourfuture.be)

[TOP](#javascript-30)

---
---

###