text:
---
layout: default
---

# 1997-09-29 - InfoWar 23 (Part III of 'The True Story of the InterNet')

## Header Data

From: "Bubba Sho'nuff"<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 7fbbc15c18c24d0f84c989467b88d775fb787519b0a261878ae70657809e63c8

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1997-09-29 04:10:56 UTC

Raw Date: Mon, 29 Sep 1997 12:10:56 +0800

## Raw message

```
{% raw  %}From: "Bubba Sho'nuff"<EMAIL_ADDRESS>Date: Mon, 29 Sep 1997 12:10:56 +0800
To<EMAIL_ADDRESS>Subject: InfoWar 23 (Part III of 'The True Story of the InterNet')
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/html

Title: The True Story of the Internet Part II

The True Story of the InterNet

Part III

InfoWar

Final Frontier of the Digital Revolution

Behind the ElectroMagnetic
Curtain

by TruthMonger<EMAIL_ADDRESS>

Copyright 1997 Pearl Publishing

InfoWar Table of Contents

Non-Conspiracy Theory

Non-Conspiracy Theory

A Player To Be Named Later glanced quickly over his shoulder,
to make certain that no one was paying any particular amount of
attention to him.
In one swift motion, he stepped sideways into the telephone booth,
and began removing his clothes. Seconds later, he emerged from
the telephone booth...as The Real Guy.

"Turn to your left, please." the police photographer
sounded bored. As soon as he had finished with the flasher, he
was off-shift and headed straight for The Stone Fox nude club
to watch his favorite ladies engage in legalized flashing.

The prisoner smiled as he saw the lady cop waiting to take him
downstairs for fingerprinting checking out his firmware.
"I told you I was The Real Guy." he said,
as the woman looked away, blushing.

FBI Calls Privacy Extremists Elitist
(09/25/97; 4:30 p.m. EDT) By David Braun, TechWire

MONTREAL -- Extremist positions on electronic encryption are not
only
threatening to normal law enforcement, but they are also elitist
and
non-democratic, said Alan McDonald, a senior counsel member with
the
Federal Bureau of Investigation, at the International Conference
on
Privacy in Montreal on Thursday.
...
Absolute positions on privacy were "pernicious on several
levels,"
McDonald added, in an attempt to daemonize citizens who value
their
privacy and resent attempts by government to build a surveillance
state.
...
Extreme privacy positions were ultimately elitist and nondemocratic
in that they
presumed the views of a knowing privacy cognoscenti should pre-empt
the
views of the nation's elected officials and the Supreme Court,
McDonald
said. He added that the elitist and non-democratic founding
fathers had
established this cursed tradition by their misuse of the term
"we the people"
and that it had taken many years to set things straight.
...
Extremists presumed that the citizens could not trust the
elected
government and the Supreme Court to make decisions or to correct

mistakes if any are made, McDonald said. He told those present
that
if the Waco investigation had shown the massacre of the Branch

Davidians to be a mistake, then the Supreme Court would have ruled

that the government must bring those killed back to life.
...
McDonald said efforts in the United States to enhance effective
law
enforcement search and seizure capabilities had proceeded without

harming legitimate privacy concerns.

Notwithstanding the substantial threats posed by national and

international organized crime, drug cartels, and terrorists, the
United
States had remained true to its Constitutional moorings, and its

commitment to a system of ordered liberties, McDonald said.
Handouts were given to those in attendance, showing that most
of
the drug czars and terrorists were concentrated in short stretches

of Interstate highways where local law enforcement agencies were

seizing their vehicles and money at an astounding rate, given
the
fact that almost all of them had gone to great lengths to disguise

themselves as ordinary, everyday citizens.
...
"When people don't know much about electronic surveillance,
they are
fearful of it. But when they know Congress passed laws and the
Supreme
Court reviewed them and that there are numerous constraints and

procedures, then it makes sense to them. It seems rational and

balanced," McDonald said.
He add that the way that the elitist, non-democratic privacy
extremists
rant and rave, you would believe that law enforcement agents went

around sticking toilet plungers up their assholes, or something.

The Real Guy reviewed his changes to David Braun's TechWire article.
He decided that his 'enhanced' version more clearly expressed
McDonald's views in a way that the common man could understand-or,
the common 'person' if they were one of those Left Coast troublemakers.

It was going to be a long and difficult task, but The Real Guy
knew that it was up to himself to bear the burden of informing
the Real World (tm) that there was, in fact, no grand conspiracy,
secret or otherwise, aimed at bringing the world totally under
the domination of the Evil One.
The biggest problem of bursting the bubble of the paranoid lunatics
running around stirring up the rabble with their far-fetched allegations,
was that the potential for their claims being true could be easily
substantiated by the real facts, as they existed.
Thus, these troublemakers could play on the irrational fears of
the sheeple in an attempt to undermine the years of effort that
had gone into convincing them to trust authority and to view their
government as benevolent public servants working in the best interests
of the citizens who elected them.

The Real Guy decided to make a list of the issues he would have
to address in order to build a solid foundation for his non-conspiracy
theory.

He began with a series of small, local items from the alternative
presses around the nation, knowing that much of the power of the
world-wide conspiracy theories being proclaimed were built upon
comparisons that the common man could understand.

For instance, there was an article on people who spent hundreds
of thousands of dollars campaigning for a $20,000 per year position
on the Austin Water Board. The article went on to document how
those who were elected to the Water Board were then in a position
to make decisions affecting multi-million dollar land development
projects, and how they all became filthy rich during their tenure
on the Water Board.
The Real Guy recognized this as just one of the many mean-spirited
attempts to slander successful people who had spent mountains
of money to gain a position where they could be of service to
their community, in order to repay the community for the millions
of dollars that they would be making in the future through graft
and bribery.

Then there was a state project involving the four-lane highway
outside a small town in Kansas which went...well, pretty much
nowhere, actually.
Tens of millions had been spent on its construction before someone
pointed out that there was really no need for the road, and that
it was a tremendous waste of taxpayer money, since there was really
nowhere to go in that particular direction, and nobody who wanted
to go there. And, just because the politicians and businessmen
involved all made vast sums of money in its construction before
the project was halted, the skeptics assumed that there was something
more involved than an honest mistake by well-meaning people.

On a federal level, events could also be misconstrued by those
who aimed their misanthropic cynicism toward using the details
surrounding the history of the government as building blocks to
suggest nefarious secret agendas going on in the political background.

These conspiratorial FUD artists would get great mileage out of
such simple coincidences as the only Catholic US President being
assassinated in the heart of the Baptist bible belt; the Vice
President under a President facing impeachment being removed to
put in place a politician who would pardon the criminal after
assuming his office; the head of the CIA accomplishing what the
head of the FBI was never able to do-assume control of the nation.

The Real Guy had his work cut out for him in a variety of areas
which were intertwined with one another, and which all provided
fertile ground for the cynics to plant seeds of doubt as to the
honesty and integrity of those who had seized control of the reins
of power.

One of these areas was the media.
Certainly, once mesmerism, or hypnosis, had become a recognized
method of manipulating human consciousness, it provided fodder
for those who thought that people seeking power and wealth would
stoop so low as to use this for private gain, at the expense of
the masses. When it became commonly known that 'bad' people had
developed this new mind-altering technology in the arena of 'brainwashing,'
then it was only a matter of time before the naysayers would try
to associate honest, free-enterprise advertising with this evil,
mind-manipulation technique designed to change the orientation
of people's thoughts and perceptions.
When many of the most successful advertising experts moved into
the political arena, it gave the paranoid even more food for feeding
their proclivity for mistrustful mental machinations.

When commercial advertising proved the tremendous financial rewards
that could be obtained by directing the public's attention in
the direction of a desired perception and opinion of a commercial
product, there were, naturally, a few bad apples who took advantage
of this mind-influencing technology to lead the public to believe
things which were not, in fact, true, with the goal of enriching
themselves at the expense of others.
Fortunately, most of the evil thieves who became rich by using
the power of advertising to defraud the public used their money
to better themselves, often running for public office in order
to make amends for their past misconduct.

Again, the cynics would try to twist the facts to intimate that
the many thugs, thieves and other assorted criminals who rose
to prominent positions in corporate and political areas was an
indication of the perversion of democracy by powerful financial
figures who had learned to manipulate public perception via media
spin-doctoring.
This view, fortunately, was put to rest when a criminal felon
who had amassed a fortune in the bootlegging business during Prohibition
used his ill-gotten gain to provide the American people with a
President who epitomized the American dream.

The handsome, photogenic youth with the all-American family proved
the triumph of reality over spin-doctoring by being everything
that the citizens could hope for, and more, even to the point
where his royal court was given the name Camelot by the media.

As a war-hero, he atoned for his father's sin of doing business
with the Nazis during the war in which he fought against them.

The Real Guy reread his last paragraph, thinking that perhaps
there was something a little askew with the logic in it, but since
he couldn't put his finger on what it was, he decided to review
it later, when his mind was fresher.

Regardless, he felt that another issue he would need to tackle
in order to take the wind out of the paranoid conspiracy theorists'
sails was the increasing lack of hard-core investigative journalism
in the mainstream press when it came to events involving government
malfeasance.

A few of the wacky weirdoes playing their conspiracy games attempted
to point to the lack of solid reporting in certain areas of major
news stories as evidence of an ongoing cover-up of nefarious activities
by people with shadowy agendas.
One example was the absence of any reporters doing serious research
into the reason that a large number of law enforcement related
personnel seemed to be absent from the scenes of crimes that took
place in their regular workplaces, including the BATF agents at
the site of the Oklahoma City bombing of the Murrah Federal Building.

Rather than being part of some grand conspiracy, The Real Guy
saw this as a simple issue of market-place economics. Media giants
realized that their readers and viewers would much rather have
reporting resources centered on matters of more interest to them,
such as researching the facts behind the death of Natalie Woods.

If the public had more interest in the presence of celebrities
at the site of a celebrity death than they had in the absence
of law enforcement agents in charge of preventing bombings at
the bombing of their own workplace, then it was certainly not
the fault of the media.
If major drug dealers would bring their planes into Florida during
the Miami Dolphin football games because they knew the Customs
agents would pay more attention to game instead of intercepting
drug smugglers, that was not the fault of the media.
'Saving the children' was important, but not important enough
to miss 'the game.'

The Real Guy knew that he would also have to address the entertainment
media's movement toward providing more and more programs canonizing
law enforcement agencies and officers, and paying tribute to the
benefits of living in a surveillance state.

 They wanted to see pictures of white officers
calling darkies 'Sir.' before they violated their Constitutional
rights and then imprisoned or shot them. The public wanted to
see footage of darkies being rousted in cars with bad mufflers
and imprisoned for possession of a joint-not pictures of people
of all races being shaken down and having their money and possessions
confiscated for possession of the same joint (after the darkie
had been booked and printed).

The paranoid conspiracy theorists railed against the media's portrayal
of LEA's as righteous crime fighters who killed and imprisoned
only 'bad' people who were going to do terrible things to mom,
her apple pie, and the flag. The Real Guy knew that the media
was only trying to present a balanced picture of virtual reality
for the public, since they got to see the LEA's murder men, women
and children on the news, so there was no need to replicate this
and their other atrocities in the field of entertainment.

The Real Guy recognized that the media's prime purpose was to
serve as the new, improved opiate of the masses. Since it was
impossible for people to live in real safety and security
in the Real World (tm), the media was burdened with the responsibility
for assuring that they could do so in the Virtual World (tm)
of Digital Reality (tm).

The Digital Revolution (tm) was designed as a gentler, kinder
revolution which would subtly replace Analog Reality with Digital
Reality (tm), without the need for violence and bloodshed, except
in cases of Thought Criminals who stubbornly refused to accept
the authority of the Mind Police, acting in the legitimate interests
of Attitude Enforcement.

The Real Guy knew that if there indeed was a conspiracy between
the secret government and the media czars that one could expect
to find hard evidence, such as a TV show that represented the
FBI as an organization whose focus was to protect children from
their parents being duped or forced into making their children
vulnerable to drug-dealing, terrorist pedophiles, thus needing
concerned federal agents to 'save' their children.
Well, OK...maybe that is a bad example, since that was the
plot of the first episode of the C-16 TV series about an elite
FBI team.

The more the Real Guy tried to find examples of LEA's being portrayed
realistically, whether local, state, federal or military, the
more it became obvious that he would be unable to prove his non-conspiracy
theory directly, since the entertainment media's portrayal of
them was so obviously one-sided.
Instead, he decided to point out the flip-side of the argument-namely,
that if there indeed was a secret conspiracy linking the secret
government and the mainstream media, then they would not allow
the conspiracy theorists to also state their case in a subtle,
subliminal manner on the airwaves of America.

Yes...that was the way to go.
Rather than trying to prove a negative, he would provide positive
proof that the wild-eyed conspiracy theorists were also allowed
media exposure to promote their own view of reality and virtual
reality.

Well, not The Real Guy, himself, since he was not really suited
to the task, but ? the Lunatic would be more than up for the job.

He headed back for the telephone booth where he had left his clothes,
taking along the aluminum foil hat that would allow ? the Lunatic
to work without outside interference. It was going to be a long
night, but at least he had plenty of Scotch and butts to help
counterbalance any side effects that ? the Lunatic's medication
might be having on him.

In an important project such as this, balance was important.

"The Xenix Chainsaw Massacre"

"WebWorld & the Mythical Circle of Eunuchs"

"InfoWar (Part III of 'The True Story of the InterNet')

Soviet Union Sickle of Eunuchs Secret WebSite

{% endraw %}
```

## Thread

+ Return to [September 1997](/archive/1997/09)

+ Return to "["Bubba Sho'nuff" <bs@dev.null>](/authors/bubba_shonuff_bs_at_dev_null_)"

+ 1997-09-29 (Mon, 29 Sep 1997 12:10:56 +0800) - InfoWar 23 (Part III of 'The True Story of the InterNet') - _"Bubba Sho'nuff"<EMAIL_ADDRESS>


text:
![flyer](images/flyer_rl.jpg)
# Reinforcement Learning Pong on Cloud Machine Learning Engine

## Introduction

This is a code sample for the talk "Tensorflow and deep reinforcement learning, without a PhD" ([video](https://youtu.be/aRKOJHRbXeo) | [slides](https://goo.gl/CB8xNH))

Author: Yu-Han Liu

## Prerequisites

- Python 2.7 or Python 3
- [Google Cloud SDK](https://cloud.google.com/sdk/downloads#interactive)

## Installation

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

To verify that the packages are installed successfully, run the following command to see a round of Pong gameplay rendered on screen:

```
python -m trainer.task --render
```

This package comes with a trained checkpoint.  To play a game with it, run:

```
python -m trainer.task --render --restore --output-dir ./demo-checkpoint
```

You can also run the following command to train locally.
By default, outputs (checkpoints and TensorBoard summaries) are written to `/tmp/pong_output`:

```
python -m trainer.task
```

## Run training job

In order to submit the training job to the Google Cloud Machine Learning Engine from your laptop:

```
1) Install the GitHub tensorflow-rl-pong code and requirements on your laptop
2) Get a Google Cloud Account and enable billing (credit card)
3) Create a Google Cloud Platform project on Google Cloud
4) Install the GCP command line tools on your laptop
5) Create a Google Cloud Data bucket in order to store the code and the trained model on Google Cloud
6) On your laptop, you should edit the submit.sh and change the commented line
# GCS_BUCKET="gs://my-bucket/"
and replace my-bucket by your bucket id you've created in 5)
7) On your laptop, do bash submit.sh or eventually sudo bash submit.sh

```

## Monitor training job

1. You can monitor the training job and find the logs in the [cloud console](https://console.cloud.google.com/mlengine/jobs).

1. To monitor the progress of training, use TensorBoard:

    ```
    tensorboard --logdir gs://YOUR-BUCKET/JOB_NAME
    ```

    Here `JOB_NAME` is of the format of `"pong_[timestamp]"`, which you can find on the console.

1. To watch Pong gameplay with a trained model, run:

    ```
    python -m trainer.task --output-dir gs://YOUR-BUCKET/JOB_NAME --restore --render
    ```

    It might take about 10 minutes before the first checkpoint is saved, and it might take a few hours before the trained model can consistently win a some points.  It might take about 20 hours of training before the trained model can consistently win games.

---

*Disclaimer: This is not an official Google product but sample code provided for an educational purpose*

repository: ClaudeCoulombe/tensorflow-without-a-phd

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: ClaudeCoulombe/tensorflow-without-a-phd


text:
---
layout: default
title: "Frequently asked questions"
permalink: /faq-jobs
parent: Jobs
nav_order: 18
---
# Frequently asked questions
## Nested containers
The simplest way to have a containerised job execute containers itself is to define a PROMINENCE task using
the Singularity runtime and
make use of udocker inside the Singularity container.

Below is a trivial example with a job which installs and runs a udocker container inside a Singularity container:
```
name: udocker-in-singularity
resources:
  nodes: 1
  cpus: 1
  memory: 1
  disk: 10
tasks:
  - image: centos:7
    runtime: singularity
    cmd: |
      #!/bin/bash
      curl -L https://github.com/indigo-dc/udocker/releases/download/v1.3.1/udocker-1.3.1.tar.gz > udocker-1.3.1.tar.gz
      tar zxf udocker-1.3.1.tar.gz
      export PATH=`pwd`/udocker:$PATH
      udocker -q run eoscprominence/testpi
```
Of course, for real use cases a container image can be built with udocker pre-installed.

## Resources allocated to a job
Using `prominence describe` it's possible to see the resources (CPU cores, memory, disk and number of nodes) allocated to a job. This
can be done both while a job is running and once it has completed. This information is available in the `provisionedResources`
section of `execution`, for example:
```
...
  "execution": {
    "provisionedResources": {
      "cpus": 32,
      "disk": 10,
      "memory": 64,
      "nodes": 2
    },
...
```
This can be particularly useful for jobs where fixed sets of resources were not specified.

## Singularity apps
Singularity supports providing multiple *apps* within a single container (see e.g. [this](https://docs.sylabs.io/guides/3.7/user-guide/definition_files.html#apps)) and
this is supported by PROMINENCE with a task `app` attribute.
For example, here is an example running an app called `foo`:
```
{
  "resources": {
    "nodes": 1,
    "disk": 10,
    "cpus": 1,
    "memory": 1
  },
  "name": "singularity-app-test",
  "tasks": [
    {
      "image": "multiapp.sif",
      "runtime": "singularity",
      "app": "foo"
    }
  ]
}
```

repository: prominence-eosc/docs

repo_name: prominence-eosc/docs


text:
## Installation

- [Install go](https://golang.org/doc/install) version 1.11 or above and have `$GOPATH` set

```
go get github.com/hyperledger/burrow
cd $GOPATH/src/github.com/hyperledger/burrow
# We need to force enable module support to build from within GOPATH (our protobuf build depends on path, otherwise any checkout location should work)
export GO111MODULE=on
make build
```

This will build the `burrow` binary and put it in the `bin/` directory. It can be executed from there or put wherever is convenient.

You can also install `burrow` into `$BIN_PATH/bin` with `make install`, where `$BIN_PATH` defaults to `$HOME/go/bin`
if not set in environment.


text:
---
layout: post
title: Pesto
image: https://github.com/carlsoncookbook/carlsoncookbook.github.io/blob/master/images/pesto.png?raw=true
category: apps
---

Traditional Basil Pesto

Perfect topping for anything from chicken to bruschetta

Yields: approx. 1 cup

Ingredients:
* 2 cups fresh basil leaves, packed
* 1/2 cup freshly grated Romano or Parmesan-Reggiano cheese
* 1/2 cup extra virgin olive oil
* 1/3 cup pine nuts
* 3 cloves garlic, minced finely
* Salt, to taste
* Black pepper, to taste

Directions:
1. Place the basil leaves and pine nuts into the bowl of a food processor and pulse a several times.
2. Add the garlic and Parmesan or Romano cheese and pulse several times more. Scrape down the sides of the food processor with a rubber spatula.
3. While the food processor is running, slowly add the olive oil in a steady small stream. Adding the olive oil slowly, while the processor is running, will help it emulsify and help keep the olive oil from separating. Occasionally stop to scrape down the sides of the food processor.
4. Mix in the salt and black pepper to taste.

Note: Toss with pasta for a quick sauce, dollop over baked chicken, or spread onto crackers or toasted slices of bread.

license: MIT


text:
Before we begin, credit where credit is due. @howmanysmaII gave me various lerping and tweening algorithms, and they credit Fractality for various Lua functions, IBM + Google + Microsoft + Mozilla for the bezier curves, and Validark for rewriting certain equations.

Now, into the module.

# Why use this over Roblox’s TweenService?
## Customization and power.
This module offers 32 easing styles (compared to Roblox’s 11) and they all have the 3 easing directions as well, allowing you to find exactly the tween timing you desire.

This module allows you to choose what event the tween runs on, so you can use Stepped, RenderStepped, or Heartbeat depending on your needs instead of being locked to Heartbeat with Roblox’s service.

This module allows you to tween nearly any value, including NumberRanges and PhysicalProperties, which makes it far more useful and versatile.

This module has more accurate color lerping than TweenService’s Color3:Lerp() method.

This module has events for Stopped, Completed, and Resumed on Tween objects but Roblox only has Completed which doesn’t differentiate between finishing and stopping.

This module offers all the usual tween features like reversing, repeating, and PlaybackState as well, so there are only gained features, not sacrifices.

## Easier API.
It takes a dictionary (instead of a TweenInfo object) so you don’t need to make a new object and remember the parameter order every time you make a tween.

# API:

```plain
-- BoatTween

function BoatTween:Create(Object,Data)
	returns a Tween object

	Params:
	- Object
	The instance that is having it's properties tweened
	- Data
	A dictionary of the various settings of the tween
	{
		number Time = Any positive number
			How long the tween should take to complete

		string EasingStyle = Any TweenStyle from the list below
			The style that the tween follows
			(Note: Uses strings instead of Enum.EasingStyle to allow us to add styles that Roblox doesn't support)

		List of available styles:
				Linear				Quad					Cubic
				Quart				Quint					Sine
				Expo				Circ					Elastic
				Back				Bounce					Smooth
				Smoother			RidiculousWiggle		RevBack
				Spring				SoftSpring				Standard
				Sharp				Acceleration			Deceleration
				StandardProductive	EntranceProductive		ExitProductive
				StandardExpressive	EntranceExpressive		ExitExpressive
				FabricStandard		FabricAccelerate		FabricDecelerate
				UWPAccelerate		MozillaCurve

		string EasingDirection = "In" or "Out" or "InOut"
			The direction for the TweenStyle to adhere to

		number DelayTime = 0 -> math.huge
			The amount of time before the tween begins playback after calling :Play() on the tween
			(Note: doesn't affect :Resume() calls)

		number RepeatCount = -1 -> math.huge
			How many times the tween should repeat with -1 being infinity
			(Note: will wait the DelayTime in between replaying)

		boolean Reverses = false or true
			Whether the tween should reverse itself after completion
			(note: Waits the DelayTime before reversing)

		table Goal = dictionary
			A dictionary where the keys are properties to tween and the values are the end goals of said properties
			You may tween any property with value of the following types:
					number				boolean					CFrame
					Color3				UDim2					UDim
					Ray					NumberRange				NumberSequenceKeypoint
					PhysicalProperties	NumberSequence			Region3
					Rect				Vector2					Vector3

		string StepType = "Stepped" or "Heartbeat" or "RenderStepped"
			The event of RunService for the tween to move on
		}

-- Tween

function Tween:Play()
	Plays the tween, starting from the beginning
function Tween:Stop()
	Stops the tween, freezing it in its current state
function Tween:Resume()
	Plays the tween, starting from current position and time
function TweenObject:Destroy()
	Clears connections, stops playback, destroys objects

property Tween.Instance
	The object being tweened
property Tween.PlaybackState
	An Enum.PlaybackState representing the Tween's current state

event Tween.Stopped
	Fired when a Tween ends from the :Stop() function
event Tween.Completed
	Fired when a Tween ends due to :Play() being completed
event Tween.Resumed
	Fired when a Tween is played through the :Resume() function
```

## Example:

```Lua
local BoatTween = require(script.BoatTween)

local Tween = BoatTween:Create(workspace:WaitForChild("Part"),{
	Time = 4;
	EasingStyle = "EntranceExpressive";
	EasingDirection = "In";

	Reverses = true;
	DelayTime = 1;
	RepeatCount = 3;

	StepType = "Heartbeat";

	Goal = {
		Color = Color3.new(0.5,0.2,0.9);
		Position = Vector3.new(4,10,7);
		Transparency = 0.5;
	};
})
Tween:Play()
```

*Note: I didn’t test error cases carefully, because if you input invalid types and such that’s just your fault. TweenService would break too. Just don’t tell it to tween a Color3 to a Vector3 or something like that and you’ll be fine.*

Remember to :Destroy() your tweens after usage!

repository: howmanysmall/BoatTween

gha_license_id: MIT

repo_name: howmanysmall/BoatTween


text:
# tunemech
A song recommendation application

This application recommends new songs based on your current song list.

The songs are searched at the Spotify.

The recommendations are done based on the correlation of the songs with the user's list and the popularity of the songs in the whole database.

To be able to run the code client id and client secret should be add to the views.py at backend.

repository: halilozanakgul/tunemech

gha_language: JavaScript

repo_name: halilozanakgul/tunemech


text:
Solution to [Indexes - 4](https://www.hackerrank.com/challenges/indexes-4/problem)

A composite index is an index on two or more columns of a table. Its basic syntax is as follows.
```sql
CREATE INDEX index_name
on table_name (column1, column2);
```

**Answer**

CREATE INDEX index_name

ON table_name(column1, column2);


text:
User-visible changes in ERTP:

## Next Release

* Purses now support `getCurrentAmountNotifier()` that notifies of balance
  changes.

## Release v0.7.0 (21-July-2020)

* Rename `extent` to `value`
* Rename `produceIssuer` to `makeIssuerKit`

## Release v0.6.0 (29-June-2020)

* `purse.deposit()` now returns the amount of the deposit, rather than
  the purse's new balance.
* A deposit-only facet was added to purses, and can be created by
  calling `makeDepositFacet` on any purse.

## Release v0.5.0 (26-Mar-2020)

Changed most ERTP methods to now accept promises for payments. The
only method that does not accept a promise for a payment is `deposit`,
which only accepts payments.

## Release v0.4.0 (6-Mar-2020)

* We added the concept of a brand, because the assay (renamed to
  issuer) was serving two purposes: it was indicating the kind and was
  a trusted authority for payment and purse validity. This was a
  problem because where it was used to indicate the kind, like in
  `payment.getBalance()`, a user could grab an assay from the units,
  use it to claim their payment, and think they accomplished something
  security-wise.
* Relatedly, most of the methods from payments have been removed. The
  only method on payments that remains is `getAllegedBrand`. To get
  the current amount of assets in a payment, use the issuer:
  `issuer.getAmountOf(payment)`
* makeMint was renamed to 'produceIssuer' to emphasize that the issuer
  is most important and the mint is just the admin facet of the issuer.
* ProduceIssuer returns an object with properties like issuer, mint,
  amountMath (formerly unitOps), and brand rather than the old version
  that just returned a mint.
* Most configuration has been removed from ERTP in favor of a few
  built-in configurations: digital assets can be fungible (the
  default), or non-fungible. If digital assets are non-fungible, there
  is a choice between two settings: 'strSet' mathHelpers handle the
  math for extents that are sets of string IDS, and 'set' mathHelpers
  handle the math for extents that are sets of more complex objects
  (which might be opaque ids called handles or data). Zoe invites use
  'set' mathHelpers.
* CoreMintKeeper was rewritten to conserve currency and then inserted
  into issuer.js (formerly mint.js)
* We removed the issuer and purse methods with suffix 'All' and
  'Exactly' and replaced them with one method per job that takes an
  optional amount. If the optional amount is present, the code checks
  whether the balance it is working with is equal to that balance.
* The `coerce` method in AmountMath (formerly UnitOps) now only
  accepts amounts. This means that minting (i.e.
  `mint.mintPayment(moola(3))`) only accepts amounts and rejects raw
  extents.

## Release v0.3.1 (4-Feb-2020)

Update dependency on pixel-demo

## Release v0.3.0 (3-Feb-2020)

* Move a number of files out of ERTP and into their own packages in
  this monorepo, including:

  1. `@agoric/import-manager`
  2. `@agoric/make-promise`
  3. `@agoric/sparse-ints`
  4. `@agoric/insist`
  5. `@agoric/registrar`
  6. `@agoric/store`
  7. `@agoric/weak-store`
  8. `@agoric/sharing-service`
  9. `@agoric/same-structure`
  10. `@agoric/spawner` (formerly contractHost)
  11. `@agoric/pixel-demo`

## Release v0.2.0 (12/4/2019)

* Remove Zoe from ERTP and publish as @agoric/zoe

## Release v0.1.12 (11/13/2019)

* Added "myFirstDapp", a smart contract with the same interface as our
  autoswap (Uniswap) contract, but which does not have the same
  functionality. Instead, the developer building on Zoe is prompted to
  add their own custom logic at various points of the contract. By
  default, users can use the contract to trade one unit of one kind of
  digital assets for one unit of another kind of digital asset
  indefinitely as long as they alternate, but this behavior is meant
  to be altered by the smart contract developer.

## Release v0.1.11 (11/1/2019)

* Added documentation explaining how the "trait" pattern can be used
  to customize the functionality of ERTP interfaces like purses and
  payments.
* Fix a race condition in Zoe that occurred when the same assay is
  used multiple times in the smart contract's array of assays.

## Release v0.1.10 (10/31/2019)

* Updated how fees are calculated in autoswap so that conservation of
  supply is not violated.

## Release v0.1.9 (10/30/2019)

* Added a write up of Zoe and smart contracts. This documentation
  now lives at [https://agoric.com/Documentation/](https://agoric.com/Documentation/)
* Cleaned up Zoe and the smart contracts running on Zoe
* Renamed a number of terms:
   * descOps -> unitOps
   * assetDesc -> units
   * conditions/offerConditions -> offerRules
   * offerDesc -> payoutRules
   * label.description -> label.allegedName
   * handoff service to sharing service
* Updated the timer interface to match timerServices

## Release v0.1.8 (10/22/2019)

* Added the registrar naming service. Objects can be registered with a
  name. The name supplied by the user is concatenated with a random
  string to produce a value like `myName_4409`, if `myName` was the
  user-supplied string. Then, this full name can be used to `get` the
  object back from the registrar naming service. This can be used to
  give public names to objects meant to be shared.
* The contracts that run on Zoe have been updated. There are now six
  contracts: `automaticRefund`, used for testing and tutorials, which
  just gives the user their digital assets back, `autoswap`, a Uniswap
  implementation, `coveredCall` which involves an invite to make an
  offer that can act as an option, `publicAuction` which is a
  second-price auction, `publicSwap` which has the same swap logic
  as the `coveredCall` contract, but which doesn't use invites, and
  `simpleExchange` which is a naive decentralized exchange.
* Tests have been written for "higher order" contract uses. That is, a
  invite for one contract used as the underlying right in another
  contract.
* Exit conditions were added to Zoe. This allows the user to specify
  their exit conditions when they escrow an offer with Zoe.

## Release v0.1.7 (10/15/2019)

* Added configurable endowments in contract evaluation for `Zoe` and the
  `contractHost`.

## Release v0.1.6 (10/14/2019)

* [Renamed many aspects of ERTP](https://github.com/Agoric/ERTP/commit/a34dad171eb8693b807a7fd959b14e938fedf42a):
    1. `amount`, the description of an asset (e.g. 3 bucks), is now
       `assetDesc`, short for 'asset description'.
    2. `quantity`, the measure of "how much" is in an asset (the '3'
       of '3 bucks') is now `extent`. We did this so that we
       can reference the extent of non-fungible assets as easily as
       fungible assets.
    3. `assay`, the operations for manipulating labeled
       extents/quantities, is now `descOps`. `DescOps` are the set
       operations on asset descriptions. This change makes it clear
       that the `descOps` are not an institution in the same sense as
       the mint and are merely operations.
    4. `strategy`, the operations for manipulating unlabeled extents,
       is now `extentOps`. This change makes it clear that it is the
       operations on extents, and it acts on extents in the same way
       that `descOps` acts on descriptions.
    5. Purses and payments are now together called `assetHolders`.
       Assets are the intangible (i.e. there is no asset object) erights held by purses and payments.
    6. `issuer` has been renamed to `assay`. `assay` and `mint` are
       two facets of the same institution. The `mint` has the
       authority to create new assets. The `assay` is the
       public-facing facet that is often widely known and can be used
       to claim exclusive access to a payment or make an empty purse,
       among other things.
* Added [support for uploading contracts](https://github.com/Agoric/cosmic-swingset/blob/master/lib/ag-solo/contracts/README-contract.md) at the start of the Agoric testnet.
* Added an [initial version of Zoe](https://github.com/Agoric/ERTP/commit/a32426aab307d31bd0fe1b6e1241d4a270964e31), our offer-safety enforcement layer.
  More on this to come.

## Release v0.1.5 (10/4/2019)

* Updated to `@agoric/swingset-vat` v0.0.26. Also updated a number of
  other packages.

* Fixed two bugs: `issuer.split` was trying to `vouch` for the amounts
  that were passed into the `split` function. When these amounts were
  created in a different vat, `vouch` failed. We realized that
  `assay.vouch` was unnecessary and `assay.coerce` could be used
  instead. The second bug fix was to replace `E.resolve` (deprecated)
  with `Promise.resolve` when we did the update of
  `@agoric/swingset-vat`.

## Release v0.1.4 (9/3/2019)

Core ERTP:
* Created a "list strategy" for assays. The list strategy allows
  non-fungible assets to have set operations. For instance, for the
  pixelList assay, each pixel is defined by the x and y coordinates,
  but there can be multiple pixels in a purse or payment. These
  multiple pixels can be combined together because they are put in a
  list. Similarly, we can remove pixels from a purse or payment by
  removing them from the list.
* Updated to `@agoric/swingset-vat` v0.0.20 and `ses` v0.6.0

## Release v0.1.3 (8/27/2019)

Core ERTP:
* Extracted assay set operations/arithmetic into "strategies". We had
  several different assays that described various types of fungible
  and non-fungible digital assets. A lot of the code was reused, but
  what differed was the custom logic for the arithmetic or set
  operations. For instance, a fungible token just adds or substracts
  natural numbers, but a non-fungible token might put something in or
  take something out of a list. We extracted that logic such that we
  could reuse `assay.js` for many different types of assets.
* Added an 'import manager' that maps strings to imported code. The
  import manager allows code such as configuration functions to be
  imported rather than passed as parameters.

## Release v0.1.2 (8/20/2019)

Core ERTP:
* Enforced "payment linearity". Whenever a payment is deposited,
  burned, or claimed, the entire payment must be used up ("killed").
  When a payment is killed, it is removed from the ledger entirely,
  not just reduced to an empty amount, as was previously the case. Two
  new methods to support payment linearity are added to `issuer`:
  `combine(paymentArray)` and `split(payment, amountsArray,
  namesArray)`. The methods for depositing are now
  `depositExactly(amount, payment)`, which checks that the `amount` is
  equal to the `payment` balance, and `depositAll(payment)`. The
  methods for burning are now `burnExactly` and `burnAll`, and the
  methods for claiming are now `claimExactly` and `claimAll`.

## Release v0.1.1 (8/15/2019)

Core ERTP:
* Made the `makeMint` config act in a more "trait-like" manner.
  Instead of creating custom purses and payments by calling a function
  that returns the custom purse or payment, the "trait-like" style
  combines the core methods of a purse or payment with the custom
  methods, overriding any custom methods with the core methods if
  there is any overlap.

Pixel Demo:
* Fixed a bug in which `tapFaucet` did not return newly minted
  `pixelPayments` but instead returned previously created ones.

## Release v0.1.0 (8/14/2019)

Core ERTP:
* Refactored contracts to make it easier for users to check the terms of
  a contract
* Added an IDL to describe the user-facing ERTP interface for mints,
  issuers, purses, payments, assays, and the contractHost.
* Renamed `getExclusive` and `getExclusiveAll` to `claim` and
  `claimAll`
* Added `equals` as an assay method

Pixel Demo:
* Created a new representation of hierarchical rights for the pixel
  demo, which allows holders of higher-level rights to revoke rights
  held further down. This follows the pattern of owner, tenant, and
  subtenant relationships in real property.
* Made the gallery in the pixel demo use a long-lived contract host
  rather than creating a new contract host for each contract

## Release v0.0.9 (7/29/2019)

* Moved ERTP from the SwingSet repository
* Added pixel demo and handoff table to push ERTP design forward to
  non-fungible tokens with real uses

repository: Agoric/agoric-sdk

repo_name: Agoric/agoric-sdk


text:
# Docker Cloud Blue/Green command-line tool
Simple command line tool to resolve the next active target code for blue/green deployments on docker cloud

# Installation

    $ npm install -g dcbg

# Usage

```bash
dcbg
  --help                        Prints guide
  --user=[username]             Docker cloud username.
  --token=[token]               Docker cloud API token associated with the username.
  --target=[service].[stack]    The docker cloud internal domain name for the service in question.
  --lb=[loadbalancer]           The docker cloud hostname for the loadbalancer.  Must be on target stack.
  --options=(blue,green)        (optional) The suffix codes used for the service.  Defaults to blue,green
  --active                      (optional) Flag to return active code rather than next code
```

repository: thebigredgeek/dcbg

repo_name: thebigredgeek/dcbg


text:
[![Build Status](https://travis-ci.org/iaintshine/ruby-tracing-matchers.svg?branch=master)](https://travis-ci.org/iaintshine/ruby-tracing-matchers)

# Tracing::Matchers

The gem exposes RSpec-compatible convenient one-liners, matchers, which you can use to test OpenTracing instrumentations, without having to use production OpenTracing Tracer e.g. Jaeger. It's expected that the gem will be used together with [test-tracer](https://github.com/iaintshine/ruby-test-tracer) - an OpenTracing compatible test Tracer implementation.

## Documentation

For far more detailed documentation and usage examples check [matchers.rb](https://github.com/iaintshine/ruby-tracing-matchers/blob/master/lib/tracing/matchers.rb), [span_matchers.rb](https://github.com/iaintshine/ruby-tracing-matchers/blob/master/lib/tracing/matchers/span_matchers.rb), [specs](https://github.com/iaintshine/ruby-tracing-matchers/tree/master/spec/tracing) and [rubydoc.info](http://www.rubydoc.info/github/iaintshine/ruby-tracing-matchers/master/Tracing/Matchers).

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'tracing-matchers'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install tracing-matchers

## Available matchers

```ruby
expect(tracer).to have_traces(n)
                  .started
                  .finished
expect(tracer).to have_spans(n)
                  .started
                  .finished
expect(tracer).to have_span(operation_name)
                  .in_progress
                  .started
                  .finished
                  .with_tags(*tags)
                  .with_logs(**fields)
                  .with_log(**fields)
                  .with_baggage(*baggage)
                  .child_of(operation_name|span|span_context)
                  .following_after(operation_name|span)

expect(span).to have_tag(*tags)
expect(span).to have_tags(*tags)
expect(span).to have_log(**fields)
expect(span).to have_logs(**fields)
expect(span).to have_baggage(*baggage)
expect(span).to have_baggage_item(*baggage)
expect(span).to have_parent
expect(span).to be_child_of(opration_name|span|span_context)
expect(span).to follow_after(operation_name|span)
```

## Usage

High-level test examples.

```ruby
require 'tracing-matchers'

describe "traced code" do
  context "when we expect no traces" do
    it "does not have any traces" do
      expect(tracer).not_to have_traces
    end
  end

  context "when we expect traces to be present" do
    it "does have some traces started" do
      expect(tracer).to have_traces
    end
  end

  context "when we expect exactly N traces" do
    it "has N traces recorded" do
      expect(tracer).to have_traces(N)
    end
  end
end
```

```ruby
describe "traced code" do
  context "when we expect no spans" do
    it "does not have any spans" do
      expect(tracer).not_to have_spans
    end
  end

  context "when we expect spans to be present" do
    it "does have some spans started" do
      expect(tracer).to have_spans
    end
  end

  context "when we expect exactly N spans" do
    it "has N spans recorded" do
      expect(tracer).to have_spans(N)
    end
  end
end
```

Span-level test examples.

```ruby
describe "traced code" do
  context "when a new span was started" do
    it "is in progress" do
      expect(tracer).to have_span.in_progress
    end

    it "does have the proper name" do
      expect(tracer).to have_span("operation name")
    end

    it "does include standard OT tags" do
      expect(tracer).to have_span.with_tags('component' => 'ActiveRecord')
      expect(span).to have_tag('component', 'ActiveRecord')
    end

    it "does include a baggage item" do
      expect(tracer).to have_span.with_baggage('user_id', '1')
      expect(span).to have_baggage('user_id', '1')
    end

    it "does not have any log entries" do
      expect(tracer).not_to have_span.with_logs
    end
  end

  context "when an event was logged" do
    it "does have some log entries recorded" do
      expect(tracer).to have_span.with_logs
      expect(span).to have_log
    end

    it "includes all the event attributes" do
      expect(tracer).to have_span.with_log(event: "exceptional message", severity: Logger::ERROR)
      expect(span).to have_log(event: "exceptional message", severity: Logger::ERROR)
    end
  end

  context "when a span was finished" do
    it "is not in progress" do
      expect(tracer).to have_span.finished
    end
  end
end
```

Span context-level test examples.

```ruby
describe "traced code" do
  context "when a new span was started as child" do
    it "has a prent" do
      expect(tracer).to have_span("child span").child_of("root span")
      expect(span).to be_child_of("root span")
    end
  end
end
```

## Development

After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).

## Contributing

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


text:
# HKEX Short Update

"HKEX Short Update" is a Python program for detecting new securities eligible for short selling from [HKEX](https://www.hkex.com.hk/?sc_lang=zh-HK).

## Installation

Use the package manager [git](https://git-scm.com/) to install "HKEX Short Update".

```bash
git clone https://github.com/zachkongoyu/HKEX-Short-Update.git
```

## Usage

```bash
python update.py
```

## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

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

repository: zachkongoyu/HKEX-Short-Update

branch_name: refs/heads/main

repo_name: zachkongoyu/HKEX-Short-Update


text:
# Presenthor

[![Build Status](https://travis-ci.org/joubertredrat/presenthor.svg?branch=master)](https://travis-ci.org/joubertredrat/presenthor)
[![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/joubertredrat/presenthor/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/joubertredrat/presenthor/?branch=master)
[![Code Coverage](https://scrutinizer-ci.com/g/joubertredrat/presenthor/badges/coverage.png?b=master)](https://scrutinizer-ci.com/g/joubertredrat/presenthor/?branch=master)
[![Build Status](https://scrutinizer-ci.com/g/joubertredrat/presenthor/badges/build.png?b=master)](https://scrutinizer-ci.com/g/joubertredrat/presenthor/build-status/master)
[![Latest Stable Version](https://poser.pugx.org/redrat/presenthor/v/stable)](https://packagist.org/packages/redrat/presenthor)
[![Total Downloads](https://poser.pugx.org/redrat/presenthor/downloads)](https://packagist.org/packages/redrat/presenthor)
[![License](https://poser.pugx.org/redrat/presenthor/license)](https://packagist.org/packages/redrat/presenthor)

The crazy presenter pattern library

#### First question, why?

Because I'm a polemic person and I don't like serializes. Serialize is good? Yes, but for me, in many times is a big solution to solve a little problem.

#### Okay, how to install then?

Easy my friend, install from composer

```bash
composer require redrat/presenthor
```

#### How to use?

This library is separated in two parts, an `Item` and `Bag`.
All parts implements `OutputInterface`, then output `array` or json in string.

##### Item

An `Item` basically contains a data that will output `array` or `json` and you should to implement in your project based on `ItemInterface` or `ItemInjectableInterface`.

##### Bag

A `Bag` is a collection of `ItemInterface` and you can implement yours based on `ItemBagInterface` or use `ItemBag` implemented in this library.

#### Example

You can view an implementation example in https://github.com/joubertredrat/presenthor-example.

repository: joubertredrat/presenthor

gha_language: PHP

repo_name: joubertredrat/presenthor


text:
# blemish, unblemished, defect

## Facts:

The term “blemish” refers to a physical defect or imperfection on an animal or person. It can also refer to spiritual imperfections and faults in people.

* For certain sacrifices, God instructed the Israelites to offer an animal with no blemishes or defects.
* This is a picture of how Jesus Christ was the perfect sacrifice, without any sin.
* Believers in Christ have been cleansed from their sin by his blood and are considered to be without blemish.
* Ways to translate this term could include “defect” or “imperfection” or “sin,” depending on the context.

(See also: [believe](../kt/believe.md), [clean](../kt/clean.md), [sacrifice](../other/sacrifice.md), [sin](../kt/sin.md))

## Bible References:

* [1 Peter 01:19](rc://en/tn/help/1pe/01/19)
* [2 Peter 02:13](rc://en/tn/help/2pe/02/13)
* [Deuteronomy 15:19-21](rc://en/tn/help/deu/15/19)
* [Numbers 06:13-15](rc://en/tn/help/num/06/13)
* [Song of Solomon 04:07](rc://en/tn/help/sng/04/07)

## Word Data:

* Strong’s: H3971, H8400, H8549, G3470

repository: mandolyte/obsidian-ebook

repo_name: mandolyte/obsidian-ebook


text:
# docker-laravel

Keeping it uniform between development, staging and production environments is often something not easy. On the last years, our buddy Docker has become more and more mature and now it's becoming the standard.

We all love Laravel and Vue.JS, but why develop a Rock Star code with a Kick-Ass framework without a awesome environment?

No more "it worked on my machine"!

e with a Kick-Ass framework without a awesome environment?

No more "it worked on my machine"!

# What is does?
Ambientum can help you doing some amazing things, the 3 main scenarios are listed above:

Run Laravel and/or Vue.JS in Development.
Run Laravel and/or Vue.JS in Production (Continuous Integration included).
Replace local dependencies with Docker commands.

# What do I need to know before getting started?
Before staging with Ambientum, a few pieces of knowledge must be in place:

For replacing local commands:
The basics of Docker and Containers.
Being comfortable around the command line.
For running a development Laravel or Vue.JS environment:
Know how to operate docker-compose.

repository: tinfot/docker-laravel

repo_name: tinfot/docker-laravel


text:
Total number of alltoallv calls: 2

# Datatypes

1/2 calls use a datatype of size 4 while sending data
1/2 calls use a datatype of size 8 while sending data
1/2 calls use a datatype of size 4 while receiving data
1/2 calls use a datatype of size 8 while receiving data

# Communicator size(s)

2/2 calls use a communicator size of 4

# Message sizes

0/32 of all messages are large (threshold = 200)
32/32 of all messages are small (threshold = 200)
32/32 of all messages are small, but not 0-size (threshold = 200)

# Sparsity

2/2 of all calls have 0 send counts equals to zero
2/2 of all calls have 0 recv counts equals to zero

# Min/max
2/2 calls have a send count min of 1

2/2 calls have a recv count min of 1

2/2 calls have a send count min of 0 (excluding zero)

2/2 calls have a recv count min of 0 (excluding zero)

2/2 calls have a send count max of 1

2/2 calls have a recv count max of 1


text:
# ZPack
ZPack is a simple, general-purpose archive file format with lossless data compression. It is based on the ZIP/ZIP64 format by PKWARE.

Designed to be extremely fast, it exclusively uses the Zstandard compression algorithm for file compression (hence the name)

More about Zstandard/zstd at https://facebook.github.io/zstd
# Status
ZPack is still a relatively new format. Its implementation is also only recently developed, therefore the API is not perfect yet but it's already fully functional and can be used in your own projects. However, it should not be considered as stable and API changes can be made at any time. Be mindful when upgrading to a newer version.
# Documentation
The specifications for the ZPack file format can be found [here](docs/specs.txt)

The API documentation can be generated using the Doxyfile in docs/Doxyfile. An online copy of it can be found [here](https://leadrdrk.eu.org/zpack)
# Development
You are welcome to make any contributions in this project. Code that you wrote must be portable and compatible with C++11.
## Building
You can build both the library and the CLI using the CMake file in the root directory.

To include the library in your own project, add the /lib directory as a subdirectory in your own CMake file.
# License
ZPack is licensed under the [BSD 3-Clause license](LICENSE)

repository: moneytech/ZPack

repo_name: moneytech/ZPack


text:
# iOS Private CocoaPods

私有Cocoapods管理项目，介绍：

>CocoaPods is a great way to manage dependencies (mostly open source code) in your iOS or OS X project.

>It implements a Gemfile like configuration file (called a Podfile) where you declare your dependencies and provides all the means to keep those libraries up to date as your project grows.

> I want to cover a less common use of CocoaPods: creating your own Pods repository for internal use.

## 1. 个人私有库

- [https://bitbucket.org/](https://bitbucket.org/tinkl/podspec)申请免费使用库
- 申请名为[https://bitbucket.org/你的用户名/podspec](https://bitbucket.org/你的用户名/podspec)

## 2.添加repository到cocoapods（Add the repository to CocoaPods）

` pod repo add MyPrivatePods git@bitbucket.org:你的用户名/podspec.git`

>这里注意的是：需要把当前本机cocoapods升级到最新版本.
执行：`gem update cocoapods`

## 3. 创建podspecs文件(Create your Podspecs)

1. `pod spec create MyLibrary` 注意：MyLibrary是私有库名称
2. 目录下将会生成一个`MyLibrary.podspec`文件
3. 执行`pod spec lint MyLibrary.podspec`
>Now you need to edit that Podspec to make it complete and lint. Once you do, you can lint it to make sure the project compiles, by running
pod spec lint MyLibrary.If everything passes, you are good to go! If not, fix the errors in the Podspec and make sure it lints.

这里需要注意：可能会出现`The version should be included in the Git tag.`错误，处理方式是：看来CocoaPods验证spec文件时会匹配git地址的tag和配置的spec文件中的version，如果二者不比配，CocoaPods判断版本有可能不一致，就会显示这样一句warning。将spec文件中的s.version改成和tag改成一样的数字之后，这个warning顺利地被解决了。

cocoapods源码里有发现：
```
if tag && !tag.to_s.include?(version)
            warning '[source] The version should be included in the Git tag.'
          end
```

正常运行会显示出：
![](http://tinkl.qiniudn.com/tinkl16.pic.jpg)

## 4. 添加MyLibrary.podspec到repository (Adding the Podspec to your repository)

The final step is adding the Podspec to your private specs repository. To do that, you run` pod repo push MyPrivatePods MyLibrary.podspec`

This step will lint the library again, and copy it to you local repo, and push that repo to git. If you don’t want it to push, as an extra measure, you can add the --local-only parameter1.

![](http://tinkl.qiniudn.com/tinkl17.pic.jpg)

这里有个处理是：MyPrivatePods 名称对应的是`~/.cocoapods/repos`下的MyPrivatePods目录
执行到这里私有库基本完成，接下来就是集成到项目里了。

##5.分享给其它团队(Sharing with teammates)
To share these specs with your teammates, they only need to add the new specs repository to CocoaPods by running` pod repo add teambestSpec git@bitbucket.org:你的用户名/podspec.git`

这样会在`~/.cocoapods/repos`目录下新出现teambestSpec目录

## 6.Conclusions
CocoaPods is an amazing tool. For some companies dealing with internal reusable libraries is a daily business. Using CocoaPods as depicted has several benefits:

- Your internal specs can use the dependency management of CocoaPods, just as any open source library.
- Your projects use a single way of dependency management, both for open source libraries and internal ones.

It’s straightforward to share an internal specs repository with teammates.

## 7.集成到项目里:
Podfile文件:
```
platform :ios, "7.0"

pod "TKPhoto"
```
然后依次执行`pod install --verbose`

![](http://tinkl.qiniudn.com/tinkl1.pic_hd.jpg)
![](http://tinkl.qiniudn.com/tinkl2.pic_hd.jpg)
![](http://tinkl.qiniudn.com/tinklED9DDAFB-4E38-4304-99C6-F46C6F463259.png)
![](http://tinkl.qiniudn.com/tinkl3.pic.jpg)

题外资料：

-  [http://guides.cocoapods.org/making/private-cocoapods.html](http://guides.cocoapods.org/making/private-cocoapods.html)
-  [http://guides.cocoapods.org/syntax/podfile.html#pod](http://guides.cocoapods.org/syntax/podfile.html#pod)
- [http://stackoverflow.com/questions/25759170/how-to-add-a-private-cocoapod-as-a-dependency-in-another-pod-podspec-file?rq=1](http://stackoverflow.com/questions/25759170/how-to-add-a-private-cocoapod-as-a-dependency-in-another-pod-podspec-file?rq=1)

repository: nicolastinkl/repo

repo_name: nicolastinkl/repo


text:
# World Models
This repo reproduces the [original implementation](https://github.com/hardmaru/WorldModelsExperiments) of [World Models](https://arxiv.org/abs/1803.10122). This implementation uses TensorFlow 2.2.

## Docker
The easiest way to handle dependencies is with [Nvidia-Docker](https://github.com/NVIDIA/nvidia-docker). Follow the instructions below to generate and attach to the container.
```
docker image build -t wm:1.0 -f docker/Dockerfile.wm .
docker container run -p 8888:8888 --gpus '"device=0"' --detach -it --name wm wm:1.0
docker attach wm
```

## Visualizations
To visualize the environment from the agents perspective or generate synthetic observations use the [visualizations jupyter notebook](WorldModels/visualizations.ipynb). It can be launched from your container with the following:
```
jupyter notebook --no-browser --port=8888 --ip=<IP_ADDRESS> --allow-root
```

Real Frame Sample             |  Reconstructed Real Frame  |  Imagined Frame
:-------------------------:|:-------------------------:|:-------------------------:|
![alt-text-1](imgs/true_frame.png "Real Frame")| ![alt-text-2](imgs/reconstructed_frame.png "Reconstructed Frame") | ![alt-text-3](imgs/imagined.png "Imagined Frame")

Ground Truth (CarRacing)             |  Reconstructed
:-------------------------:|:-------------------------:
 |

Ground Truth Environment (DoomTakeCover)   |  Dream Environment
:-------------------------:|:-------------------------:
 |

## Reproducing Results From Scratch
These instructions assume a machine with a 64 core cpu and a gpu. If running in the cloud it will likely financially make more sense to run the extraction and controller processes on a cpu machine and the VAE, preprocessing, and RNN tasks on a GPU machine.

### DoomTakeCover-v0
**CAUTION** The doom environment leaves some processes hanging around. In addition to running the doom experiments, the script kills processes including 'vizdoom' in the name (be careful with this if you are not running in a container).
To reproduce results for DoomTakeCover-v0 run the following bash script.
```
bash launch_scripts/wm_doom.bash
```

### CarRacing-v0
To reproduce results for CarRacing-v0 run the following bash script
```
bash launch_scripts/carracing.bash
```

## Disclaimer
I have not run this for long enough(~45 days wall clock time) to verify that we produce the same results on CarRacing-v0 as the original implementation.

Average return curves comparing the original implementation and ours. The shaded area represents a standard deviation above and below the mean.

![alt text](imgs/og_carracing_comparison.png "CarRacing-v0 comparison")

For simplicity, the Doom experiment implementation is slightly different than the original
* We do not use weighted cross entropy loss for done predictions
* We train the RNN with sequences that always begin at the start of an episode (as opposed to random subsequences)
* We sample whether the agent dies (as opposed to a deterministic cut-off)

|  |\tau | Returns Dream Environment        | Returns Actual Environment
|------|------|------|------|
|   D. Ha Original  | 1.0 | 1145 +/- 690 | 868 +/- 511 |
|   Eager  |  1.0 | 1465 +/- 633 | 849 +/- 499 |

repository: JiwooShin-git/WorldModels

repo_name: JiwooShin-git/WorldModels


text:
UPGRADE FROM 1.11 to 1.12
=========================

Deprecation of DoctrineCacheBundle
----------------------------------

With DoctrineCacheBundle [being deprecated](https://github.com/doctrine/DoctrineCacheBundle/issues/156),
configuring caches through it has been deprecated. If you are using anything
other than the `pool` or `id` cache types, please update your configuration to
either use symfony/cache through the `pool` type or configure your cache
services manually and use the `service` type.

Service aliases
---------------

 * Deprecated the `Symfony\Bridge\Doctrine\RegistryInterface` and `Doctrine\Bundle\DoctrineBundle\Registry` service alias, use `Doctrine\Common\Persistence\ManagerRegistry` instead.
 * Deprecated the `Doctrine\Common\Persistence\ObjectManager` service alias, use `Doctrine\ORM\EntityManagerInterface` instead.

repository: OmarDakkak/ProjAWA

repo_name: OmarDakkak/ProjAWA


text:
# What is Generalized Metadata Service (GMS)? [WIP]

## Central vs Distributed
Any entity such as `datasets` or `users` which are [onboarded](../how/entity-onboarding.md) to GMA can be designed to be served through a separate microservice.
These microservices are called GMS. Although we've a central GMS ([datahub-gms](../../gms)) which serves all entities,
we could easily have multiple GMS, each has responsible for a specific entity such as `dataset-gms`, `user-gms` etc.

repository: clojurians-org/simple-datahub

gha_language: TypeScript

repo_name: clojurians-org/simple-datahub


text:
vwutil
======

a few utility scripts for working with vowpal wabbit

## vw-validate.py

validate a file of examples, dumping errors to stdout

    > cat bad_examples | python vw_validate.py
    Errors for example 0 ('1754 foo 29625274|x:2a: ('''Ch...’)
        Importance is not a float: 'foo'
        Extra : in namespace: 'x:2a:'
        Count must be a float: '2a'

## eval-classification.sh

Report classification performance against a set of examples

    > bash eval-classification.sh bfgs.model test.vw -ACC -REC -PRC -ROC -t 0
        ACC    0.93630   pred_thresh  0.000000
        PRE    0.60821   pred_thresh  0.000000
        REC    0.23453   pred_thresh  0.000000
        ROC    0.70345

## eval-regression.sh

Report regression performance against a set of examples

    > bash eval-regression.sh bfgs.model test.vw
        RMSE: 79.757854
        RSQR: 0.277733

## csv2vw.py

Convert csv data to vw format.

Given a csv file with a header like datasets/chredlin.csv:

    "","race","fire","theft","age","involact","income","side"
    "60626",10,6.2,29,60.4,0,11.744,"n"
    "60640",22.2,9.5,44,76.5,0.1,9.323,"n"
    "60613",19.6,10.5,36,73.5,1.2,9.948,"n"

Convert it to vw input by calling csv2vw with the id variable name and the value to predict.

    > cat datasets/chredlin.csv | python csv2vw.py "" "involact"
    0.000000 60626|a fire:6 age:60 race:10 theft:29 income:11 side-n:1
    0.100000 60640|a fire:9 age:76 race:22 theft:44 income:9 side-n:1
    1.200000 60613|a fire:10 age:73 race:19 theft:36 income:9 side-n:1
    0.500000 60657|a fire:7 age:66 race:17 theft:37 income:10 side-n:1
    0.700000 60614|a fire:8 age:81 race:24 theft:53 income:9 side-n:1

repository: nuance/vwutil

repo_name: nuance/vwutil


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

### Description

APT before <IP_ADDRESS> does not properly validate inline GPG signatures, which allows man-in-the-middle attackers to install modified packages via vectors involving lack of an initial clearsigned message.

### POC

#### Reference
- http://packages.debian.org/changelogs/pool/main/a/apt/current/changelog

#### Github
No PoCs found on GitHub currently.

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
karma-haml-attribute-concatentation-preprocessor
================================================
> A Karma preprocessor that concatenates multiline haml attributes so that the haml-js preprocessor
doesn't choke on them.

The `haml-js` preprocessor can't handle multi-line attributes, which are valid haml
([3 year old open issue](https://github.com/creationix/haml-js/issues/74)). There is a
[patch](https://github.com/StemboltHQ/karma-haml-preprocessor/commit/f2846df2fcbb4f9614b273af3b4d8ae430e223ea)
floating around to support using the `haml` executable instead of `haml-js` for `haml` preprocessing
in Karma, but it is _much much_ slower if you have a lot of templates. This approach allows you
to continue using `haml-js` without modifying your original sources by concatenating multi-line
attributes before they get processed into HTML. The final HTML should be identical to what you
would get out of the Ruby `haml` processor.

## Installation

`karma-haml-attribute-concatenation-preprocessor` should be kept as a devDependency in your
`package.json`.
```json
{
  "devDependencies": {
    "karma-haml-attribute-concatenation-preprocessor": "^0.1.1"
  }
}
```

You can of course manage this as usual via `npm`:
```
npm install --save-dev karma-haml-attribute-concatenation-preprocessor
```

## Configuration
```js
// karma.conf.js
module.exports = function(config) {
  config.set({
    files: [
      '*.haml'
    ],
    preprocessors: {
      '**/*.haml': ['haml-attribute-concatenation', 'haml']
    }
  });
};
```


text:
# Customization overview

You can customize anything in this package by following same file structure as the package's one. Webpack will try to resolve customized files first so you can just "replace" any default source file.

Just import original module from `vue-admin-front/src` if you want to extend its functionality.

Package structure:

* `config.default.js` - default configuration file (see [configuration](/configuration.md) section for more information)
* `webpack.config.js` - Webpack configuration file (set `webpackConfigModifier` option in your custom config to extend default config)
* `index.js` - dev server entry, exports Express application instance to a `module.exports`
* `src` - admin panel sources
    * `components` - all reusable components should be here
    	* `app` - application layout components
    		* `logo.vue` - top-left corner logotype
    		* `sidebar-menu.vue` and `sidebar-menu-item.vue` - sidebar main navigation (better do not touch it: these components strongly depend on configuration fetched from a server API and they are not designed to be customized by any other way)
    		* `sidebar-user.vue` - current user and logout button
		* `displays` - display components, usable as a `Display` component with `type` prop set to a display component file name (`<display type="field-name"></display>`), [read more here](custom-displays.md)
        * `entity` - components exposed within all entity page components as `Entity{FileName}`
        * `fields` - fields, usable as a `Field` component with `type` prop set to a field component file name (`<field type="field-name"></field>`), [read more here](custom-fields.md)
        * `modals` - modal components, can be used within any component as `this.$modal.open('modal-name', props)`, `this.$modal.close()`, [read more here](custom-modal-windows.md)
        * `shared` - components registered globally via `Vue.component('file-name', component)`
    * `filters` - Vue.js filters, registered globally via `Vue.filter('file-name', filter)`
    * `directives` - Vue.js directives, registered globally via `Vue.directive('file-name', directive)`
    * `lang` - translations, files named `{lang}.js` (`en` and `ru` are supported by default, see [vue-i18n](https://github.com/kazupon/vue-i18n) for more information); you can add your custom translations based on default ones to provide different languages support
    * `pages` - route components, each file here will be pointed to the corresponding route same as its file name (excluding files and folders starting with underscore `_`)
        * `entities` - entity pages, create folder to extend or replace default pages
            * `_generic` - default entity page components (mind the underscore `_` - this folder's routes are registered explicitly in `router.js`; you can copy this folder with a name of your entity to fully replace default pages with custom ones), [read more here](extending-entity-pages.md)
                * `index.vue` - entity list
                * `item.vue` - entity create/edit form
	* `styles`
		* `skins` - there you can add your custom AdminLTE skin style, just create a file and set a `skin` field in `initial-state.js` same as a file name
		* `admin-lte.less` - [AdminLTE](https://adminlte.io) style imports (rewriting is not recommended, but you can change AdminLTE or Bootstrap variables in `variables.less`)
		* `bootstrap.less` - [Bootstrap 3](https://getbootstrap.com/docs/3.3/) style imports (rewriting is not recommended, but you can change AdminLTE or Bootstrap variables in `variables.less`)
		* `variables.less` - LESS variables for AdminLTE and Bootstrap 3, there you can completely or partially redefine default values
		* `shared.styl` - shared stylus variables included everywhere, [read more here](global-style-variables.md)
		* `wysiwyg.styl` - WYSIWYG ([CKEditor](https://ckeditor.com/)) field default styles (keep in mind that it is highly recommended to provide a CSS file generated from your frontend styles and [passed with API meta data](/server-api-prerequisities.md) or as a [WYSIWYG field prop](/fields.md#wysiwyg))
    * `app.vue` - application root component
    * `entry.js` - application entry file
    * `http.js` - configured, ready-to-use http service ([Axios](https://github.com/axios/axios))
    * `i18n.js` - translation plugin config ([vue-i18n](https://github.com/kazupon/vue-i18n))
    * `initial-state.js` - exports initial Vuex store state (you can change such things as a page title and AdminLTE skin here)
    * `router.js` - [vue-router](https://github.com/vuejs/vue-router) config
    * `store.js` - [vuex](https://github.com/vuejs/vuex) store config
    * `layout.pug` - application layout template
    * `ckeditor-config.js` - [CKEditor](https://ckeditor.com/) 4 configuration

## Use cases and examples

* Add some HTTP headers to a standard `http.js`:
    ```javascript
    // admin/src/http.js

    import http from 'vue-admin-front/src/http';
    http.defaults.headers['X-Custom-Header'] = 'Value';
    export default http;
    ```
* Add custom page:
    ```html
    <!-- admin/src/pages/custom-page.vue -->
    <script> export default {} </script>
    <template lang="pug">
        .custom-page
            h1 My custom page
            p URL: /admin/custom-page
    </template>
    <style lang="stylus">
        .custom-page
            background blue
    </style>
    ```
* Add global component:
    ```html
    <!-- admin/src/components/shared/my/component.vue -->
    <script> export default {} </script>
    <template lang="pug">
        .my-component
            p My component is accessible everywhere as my-component
    </template>
    <style lang="stylus">
        .my-component
            background blue
    </style>
    ```
* Extend default `en` translation
    ```javascript
    // admin/src/lang/en.js

    import lang from 'vue-admin-front/src/lang/en';
    lang.messages.myMessage = 'My message';
    export default lang;
    ```
* Create custom users create/edit form page
    ```html
    <!--
        Completely replace original component
        admin/src/pages/entity/users/item.vue
    -->
    <script>
        export default {
            routePath: ':id'
        };
    </script>
    <template lang="pug">
        .user-edit-page
            p Your are not welcome here
    </template>
    <style lang="stylus">
        .user-edit-page
            font-size 80px
            p
                text-align center
    </style>
    ```

    ```javascript
    // Add some functionality provided by original component
    // admin/src/pages/entity/users/item.js

    import baseComponent from 'src/pages/entity/_generic/item.vue';

    export default {
        routePath: ':id',
        extends: baseComponent,
        computed: {
            // hide some fields if user is not admin
            hiddenFields() {
                if (this.item.role !== 'admin') return ['only_for_admin'];
            }
        }
    };
    ```

repository: mrTimofey/vue-admin

gha_language: Vue

repo_name: mrTimofey/vue-admin


text:
# Contributing to IAM middleware package

## Table of Contents

1. [Commit style](#commit-style)
1. [Code Formatting](#code-formatting)

### Commit Style

Commits need to adhere to semantic release format in order to release/not release new versions correctly.
Please check https://semantic-release.gitbook.io/semantic-release/#commit-message-format.

### Code Formatting

In CI, `yarn prettier:check` verifies the formatting of the code. To ensure your code is formatted correctly, please
run `yarn fmt` before committing it.

repository: kiwicom/js-iam-middleware

repo_name: kiwicom/js-iam-middleware


text:
## What is TGBoost

It is a **T**iny implement of **G**radient **Boost**ing tree, based on  XGBoost's scoring function and SLIQ's efficient tree building algorithm. TGBoost build the tree in a level-wise way as in SLIQ (by constructing Attribute list and Class list). Currently, TGBoost support  parallel learning on single machine,  the speed and memory consumption are comparable to XGBoost.

TGBoost supports most features as other library:

- **Built-in loss** , Square error loss for regression task, Logistic loss for classification task

- **Early stopping** , evaluate on validation set and conduct early stopping

-  **Feature importance** , output the feature importance after training

- **Regularization** , lambda, gamma

- **Randomness**, subsample，colsample

- **Weighted loss function** , assign weight to each sample

Another two features  are novel:

- **Handle missing value**, XGBoost learn a direction for those with missing value, the direction is left or right. TGBoost take a different approach: it enumerate missing value go to left child, right child and missing value child, then choose the best one. So TGBoost use Ternary Tree.

-  **Handle categorical feature**, TGBoost order the categorical feature by their statistic (Gradient_sum / Hessian_sum) on each tree node, then conduct split finding as numeric feature.

## Installation

The current version is implemented in pure Java, to use TGBoost you should first install [JDK](http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html). For Python user, Python binding is also provided:

```
git clone git@github.com:wepe/tgboost.git
cd python-package
sudo python setup.py install
```

## To Understand TGBoost

For those want to understand how TGBoost work, and dive into Gradient Boosting Machine, please refer to the Python implementation of TGBoost: [tgboost-python](https://github.com/wepe/tgboost/tree/tgboost-python), the python source code is relatively easy to follow.

## Example

Here is an example, download the data [here](https://pan.baidu.com/s/1dGDr7pR)

```python

import tgboost as tgb

file_training = "~/data/train.csv"
file_validation = "~/data/val.csv"
file_testing = "~/data/test.csv"
file_output = "~/data/prediction.csv"
categorical_features = ["PRI_jet_num"]
early_stopping_rounds = 10
maximize = True
eval_metric = "auc"
loss = "logloss"
eta = 0.1
num_boost_round = 200
max_depth = 7
scale_pos_weight = 1
subsample = 0.8
colsample = 0.8
min_child_weight = 1
min_sample_split = 10
reg_lambda = 1.0
gamma = 0
num_thread = -1

tgb.run(file_training, file_validation, file_testing, file_output, categorical_features, early_stopping_rounds,
        maximize, eval_metric,loss, eta, num_boost_round, max_depth, scale_pos_weight, subsample, colsample,
        min_child_weight, min_sample_split, reg_lambda, gamma, num_thread)

```

## Reference

- [XGBoost: A Scalable Tree Boosting System](https://arxiv.org/abs/1603.02754)
- [SLIQ: A Fast Scalable Classifier for Data Mining](http://citeseerx.ist.psu.edu/viewdoc/download?doi=<IP_ADDRESS>.7734&rep=rep1&type=pdf)

- [GBDT算法原理与系统设计简介](http://wepon.me/files/gbdt.pdf)

repository: srepho/tgboost

repo_name: srepho/tgboost


text:
# JSON Streaming Protocol Reader

[![Greenkeeper badge](https://badges.greenkeeper.io/FireBlinkLTD/json-streaming-reader.svg)](https://greenkeeper.io/)
[![CircleCI](https://circleci.com/gh/FireBlinkLTD/json-streaming-reader.svg?style=svg)](https://circleci.com/gh/FireBlinkLTD/json-streaming-reader)
[![codecov](https://codecov.io/gh/FireBlinkLTD/json-streaming-reader/branch/master/graph/badge.svg)](https://codecov.io/gh/FireBlinkLTD/json-streaming-reader)

Simple [JSON streaming](https://en.wikipedia.org/wiki/JSON_streaming) protocol parser that allows to handle each record individually.

## Supported Stream Types

### [Line-delimited JSON](https://en.wikipedia.org/wiki/JSON_streaming#Line-delimited_JSON)

Fully supported.

### [Concatenated JSON](https://en.wikipedia.org/wiki/JSON_streaming#Line-delimited_JSON#Concatenated_JSON)

Supported for non-primitive types. Only objects, arrays and their combination as records are supported.

So, following string value will be parsed correctly:

```
{a: 1}[213]
```

while next will not:

```
{a: 1}null"string"123
```

### [Record separator-delimited JSON](https://en.wikipedia.org/wiki/JSON_streaming#Line-delimited_JSON#Record_separator-delimited_JSON)

Not supported.

### [Length-prefixed JSON](https://en.wikipedia.org/wiki/JSON_streaming#Line-delimited_JSON#Length-prefixed_JSON)

Not supported.

## Usage

If you use NPM:

```bash
npm i --save json-streaming-reader
```

If you use YARN:

```bash
yarn add json-streaming-reader
```

Then just import `JsonStream` like this:

```typescript
// if you use JavaScript:
const JsonStreamReader = require('json-streaming-reader').JsonStreamReader;

// or if you use TypeScript:
import {JsonStreamReader} from 'json-streaming-reader'
```

And pipe the reading stream to it like this:

```javascript
const jsonStream = new JsonStreamReader();
readStream.pipe(jsonStream);

jsonStream.on('data', (data) => {
    // do something with the record
    // NOTE: `data` is an object with single field `record` that hosts actual value.
    const {record} = data.record;

    console.log(record);
});
```

repository: FireBlinkLTD/json-streaming-reader

repo_name: FireBlinkLTD/json-streaming-reader


text:
# go-fail
HTTP Server that fails when needed

## What it does
The program offers a `/fail` endpoint that allows you to set a probability `p` that the HTTP request will fail.
"failing" in this sense means the client does not receive a HTTP response at all. It does NOT mean returning a status 500 or whatever
as that technically does not "fail" on a TCP level. The failure actually crashes the app as this is the cheapest way to abort the connection.
It relies on an outer health check to resurrect the app.

## Why is it useful?
The primary use is for load balancing backend resiliency tests.
E.g. what happens if 1 out of 3 instances fail? Does the load balancer retry on another one? Will it disable the broken instance for a while? How many retries does it? etc.

## How to build
```
go build
```

## How to run
You can either just run the binary or push it to CloudFoundry with the given `manifest.yml`

## How to use
You can provide a URL parameter `p` to set the probability of the app to fail.
```
curl http://myhost:8080/fail?p=25
```
e.g. this would fail in 25% of requests.


text:
# Prestashop Module - Boilerplate
Simplify the creation of PrestaShop modules unleashing the power of PHP packages without worrying about the package version.

## Installation

1. Create a new module using this boilerplate. We suggest to use PHP 7.3 (this was the maximum version before PrestaShop 8)

```bash
composer create-project dartmoon/prestashop-module yourmodulename
```

This will trigger the customization command: just answer the questions!

For the module name we suggest not to use hyphens or other other "word-delimiting" characters.

2. Install the module inside PrestaShop (execute the following command from the root of your PrestaShop installation)

```bash
php bin/console prestashop:module install yourmodulename
```

Done!

## Usage
Write your module as you would have done before!

## Install PHP package
Nothing different from what you usually do!

```bash
composer require namespace/package
```

After the installation is completed the prefixing process will start. It will scan the vendor directory and prefix all classed with the prefix you configured inside the `composer.json` file.

Keep in mind that not all packages work well after they have been prefixed (even if the majority of them will), for this reason you can follow the next step and decide to exlude some folders from the prefixing process.

## Prevent prefixing of some packages
If your installed package does not work well once prefixed you can exclude it from the prefixing process.

To do so you need to edit the file `scooper.inc.php`.

Behind the scenes we are using [PHP-Scoper](https://github.com/humbug/php-scoper), so you can follow their documentation for configuration.

## Build
Once you have completed your package, it's time to build it.

To do so you just need to execute

```bash
composer build-module
```

The building process will create a zip file inside the root of your module with all the production code. That is your compiled module.

### Changing the copyright notice
Inside the root of your module, you will find a file called `copyright.txt` which contains the copyright notice to apply in the header of each file of your module.

To change it, simply edit that file.

### Excluding files from the build
Sometimes you have some development files inside your module that you don't want to include in the build. To exclude them you can simply use edit the `excludes.txt` file.

We already compiled it with some sensible default values!

## License

This project is licensed under the MIT License - see the LICENSE.md file for details

repository: dartmoon-io/prestashop-module

repo_name: dartmoon-io/prestashop-module


text:
---
layout: creature
name: "Displacer Beast"
tags: [grande, monstruosidad, cr3, manual-de-monstruos]
cha: 8 (-1)
wis: 12 (+1)
int: 6 (-2)
con: 16 (+3)
dex: 15 (+2)
str: 18 (+4)
size: Large monstrosity
alignment: legal maligna
challenge: "3 (700 XP)"
senses: "Visión en la oscuridad 60 pies (18 mts)"
speed: "40 ft."
hit_points: "85 (10d10+30)"
armor_class: "13 (armadura natural)"
---

***Avoidance.*** If the displacer beast is subjected to an effect that allows it to make a saving throw to take only half damage, it instead takes no damage if it succeeds on the saving throw, and only half damage if it fails .

***Displacement.*** The displacer beast projects a magical illusion that makes it appear to be standing near its actual location, causing attack rolls against it to have disadvantage. If it is hit by an attack, this trait is disrupted until the end of its next turn. This trait is also disrupted while the displacer beast is incapacitated or has a speed of 0.

### Acciones

***Multiataque.*** The displacer beast makes two attacks with its tentacles.

***Tentáculos.*** Ataque de arma cuerpo a cuerpo: +6 al ataque, alcance 10 pies (3 mts), un objetivo. Impacto: 7 (1d6 + 4) puntos de daño contundente más 3 (1d6) puntos de daño perforante.


text:
# const_fixedp

[![docs.rs](https://docs.rs/const_fixedp/badge.svg)](https://docs.rs/const_fixedp)
[![codecov.io](https://codecov.io/gh/unleashed/const_fixedp/coverage.svg?branch=main)](https://codecov.io/gh/unleashed/const_fixedp/branch/main)
[![Build Status](https://github.com/unleashed/const_fixedp/actions/workflows/ci.yaml/badge.svg)](https://github.com/unleashed/const_fixedp/actions/workflows/CI/)
[![Security audit](https://github.com/unleashed/const_fixedp/actions/workflows/audit.yaml/badge.svg)](https://github.com/unleashed/const_fixedp/actions/workflows/Dependencies/)
[![Licensing](https://github.com/unleashed/const_fixedp/actions/workflows/license.yaml/badge.svg)](https://github.com/unleashed/const_fixedp/actions/workflows/Licensing/)
[![Clippy check](https://github.com/unleashed/const_fixedp/actions/workflows/clippy.yaml/badge.svg)](https://github.com/unleashed/const_fixedp/actions/workflows/Clippy/)
[![Rustfmt](https://github.com/unleashed/const_fixedp/actions/workflows/format.yaml/badge.svg)](https://github.com/unleashed/const_fixedp/actions/workflows/Rustfmt/)

This crate offers a basic const unsigned fixed point arithmetic type.

Please check out the [documentation](https://docs.rs/const_fixedp) for examples.

## Status

This library is currently _experimental_. At this stage it is meant to explore
const-related features of rustc. If you are looking for a complete fixed point
solution you should look elsewhere in crates.io, but if you are willing to
contribute towards a better, more complete const-powered fixed point library,
then you are more than welcome!

Please report any issues at the [issue tracker](https://github.com/unleashed/const_fixedp/issues).

## MSRV

Many features that we'd wish to have available on stable Rust haven't stabilised
or landed yet. The crate itself is pretty much experimental, so there is no MSRV
policy other than "always run the latest stable version".

### Nightly compilers

It's fair game to play with nightly compiler versions implementing unstable
features _as long as_ the crate works as intended on the latest stable version.

## Contributing

Contributions are very much appreciated. This crate started out as an experiment
with generic const type parameters but ended up being potentially interesting
to others.

There are certain shortcomings, incomplete features, improvements to be done
after Rust lands support, and other tasks that anyone can do to improve the
usefulness of such a const fixed point library.

Please fork and submit pull requests!

gha_language: Rust


text:
# ColorSplitter

Website: http://comfreek.github.io/ColorSplitter/

Demo: http://comfreek.github.io/ColorSplitter/release/index.html

Idea from SoftwareRecommendations.SE: [Web app to extract all colours of an image](http://softwarerecs.stackexchange.com/a/14864/583)

## Screenshot
![Screenshot of ColorSplitter fed with the Google logo](https://raw.githubusercontent.com/ComFreek/ColorSplitter/screenshots/google-logo-screenshot.PNG)

## Description
ColorSplitter is a web app to show each and every color an image uses.

The user simply selects a file, which then gets analyzed on the client-side. No data is sent to a server.

## Supported browsers

These browsers are known to work with ColorSplliter:

- Google Chrome 39.0.2171.93 (on Android)
- Google Chrome 41.0.2258.2 canary (on Windows)
- Opera 26.0.1656.60
- Firefox Nightly 37.0a1 (2014-12-25)

  (Note that the number of pages and the current page number are erroneously not shown, however, the rest of the web app is still usable.)

## How to install (for end users)
1. Download the latest release: https://github.com/ComFreek/ColorSplitter/releases.
2. Extract the contents of the ZIP folder to your favorite location.
3. Open `index.html` in a supported browser.

## How to install (for developers)

1. Download this repository, either via Git or via the [ZIP download GitHub offers](https://github.com/ComFreek/ColorSplitter/archive/master.zip).

2. Install NodeJS.

3. Execute `npm install && gulp` inside the project's directory.

4. Open `release/index.html` in a supported browser.

## Author, License
[ComFreek](https://github.com/ComFreek), [@ComFreek](http://twitter.com/ComFreek)
MIT License (c) 2014 ComFreek

repository: Happy-Ferret/ColorSplitter

repo_name: Happy-Ferret/ColorSplitter


text:
> [Go to French version](/fr/Règlements/Codification%20des%20règlements%20du%20Canada/1001-1100/C.R.C.,%20ch.%201013.md)

# Regulations Respecting the Remuneration and Expenses of Chairmen and Members of Industrial Inquiry Commissions and Conciliation Boards and of Conciliation Commissioners and Mediators

**C.R.C., c. 1013**

Enabling authorities:
- [CANADA LABOUR CODE](/en/Acts/Revised%20Statutes%20of%20Canada/L/L-2.md)

----------

[Repealed, SOR/2010-213, s. 1]

## Short Title
> [Repealed, SOR/2010-213, s. 1]

**1** [Repealed, SOR/2010-213, s. 1]

## Remuneration
> [Repealed, SOR/2010-213, s. 1]

**2** [Repealed, SOR/2010-213, s. 1]

**3** [Repealed, SOR/2010-213, s. 1]

**4** [Revoked, SOR/90-701, s. 1]

url: https://raw.githubusercontent.com/TravisMadill/CanadianLaws/776186d75e6e345dc5a0f1cd9243028efa9ac34c/en/Regulations/Consolidated Regulations of Canada/1001-1100/C.R.C., c. 1013.md

repository: TravisMadill/CanadianLaws

repo_name: TravisMadill/CanadianLaws


text:
# Abort Ajax requests using jQuery

## Question

Using jQuery, how can I **cancel/abort an Ajax request** that I have not yet received the response from?

## Answer

Most of the jQuery Ajax methods return an XMLHttpRequest (or the equivalent) object, so you can just use `abort()`.

See the documentation:

*   [abort Method](http://msdn.microsoft.com/en-us/library/ms535920%28VS.85%29.aspx) ([MSDN](http://en.wikipedia.org/wiki/Microsoft_Developer_Network)). Cancels the current HTTP request.
*   [abort()](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/abort) ([MDN](http://en.wikipedia.org/wiki/Mozilla_Developer_Network)). If the request has been sent already, this method will abort the request.

    var xhr = $.ajax({
        type: "POST",
        url: "some.php",
        data: "name=John&location=Boston",
        success: function(msg){
           alert( "Data Saved: " + msg );
        }
    });

    //kill the request
    xhr.abort()

**UPDATE:** As of jQuery 1.5 the returned object is a wrapper for the native XMLHttpRequest object called jqXHR. This object appears to expose all of the native properties and methods so the above example still works. See _[The jqXHR Object](http://api.jquery.com/jQuery.ajax/#jqXHR)_ (jQuery API documentation).

**UPDATE 2:** As of jQuery 3, the ajax method now returns a promise with extra methods (like abort), so the above code still works, though the object being returned is not an `xhr` any more. See the [3.0 blog here](http://blog.jquery.com/2016/01/14/jquery-3-0-beta-released/).

**UPDATE 3**: `xhr.abort()` still works on jQuery 3.x. Don't assume the _update 2_ is correct. [More info on jQuery Github repository](https://github.com/jquery/jquery/issues/2084#issuecomment-308173243).

repository: stackflow-io/stackflow

repo_name: stackflow-io/stackflow


text:
# LR2Graphite
[LoadRunner](<https://software.microfocus.com/en-us/products/loadrunner-load-testing/overview>) response time metrics export tool to [Graphite](https://graphite.readthedocs.io/en/latest/).

## Why?
When using LoadRunner in combination with another load test tool like Gatling, JMeter, etc. it would be nice to unify performance test metrics like response time statistics into a single datasource like Graphite.
Works excellent in combination with [Targets-io](https://github.com/dmoll1974/targets-io) tool.

## What?
By using an [AutoIt](https://www.autoitscript.com/site/) script or executable the LoadRunner analysis MS Access database is being queried and the results are exported into Graphite.
Metrics are aggregated per 10 seconds (configurable) and exported to Graphite in "buckets". Currently not supported but when using [Statsd](https://github.com/etsy/statsd) the aggregation can be skipped.

## Which metrics can be exported?
At the moment the following response time metrics can be exported per transaction:
- average
- minimum
- maximum
- (99th) percentile (configurable [0-100])

## How to use?
Standalone, manually or included in a pipeline. For example: [LoadRunner integration in Jenkins](https://wiki.jenkins-ci.org/display/JENKINS/HP+Application+Automation+Tools)

Compiled executable can be run with (pipeline) or without command line options (manually/interactive)
Manually (interactive):
```
LR2Graphite.exe
```
Manually (command line):
```
LR2Graphite.exe <path to LR mdb> <Graphite host> <Graphite port> <timezone offset (hours)>
```
Jenkins (but preferably use LRlauncher.exe if possible):
```
LR2Graphite.exe <path to Jenkins job workspace> <Graphite host> <Graphite port> <timezone offset (hours)>
e.g. LR2Graphite.exe "%WORKSPACE%" <IP_ADDRESS> 2003 0
```

## Prerequisites
- Analysed LoadRunner testrun with a MDB file. Note: do not select OUTPUT.MDB
- Graphite instance to export metrics to

OS: Windows
AutoIt for editing code and debugging.

## Add-ons: support tooling
- LR2Graphite_modify_test_start_time.exe
- LRlauncher.exe

### LR2Graphite_modify_test_start_time
Simple tool for debugging purposes to manipulate the start time of a LoadRunner test to n hours in the past.
```
Usage: LR2Graphite_modify_test_start_time.exe <number of hours in the past>
```
### Targets-io LRlauncher
Tool for creating a performance test pipeline:
- starting a LoadRunner test (command prompt CLI or via Jenkins)
- sending start, keepalive and end test events to Targets-io
- running LR2Graphite to export metrics to Graphite (so implicitely to Targets-io)
- validate requirements of test result via Targets-io

Targets-io LRlauncher is described in more detail in this [Wiki](https://github.com/ogarling/LR2Graphite/wiki).


text:
 VMware has ended active development of this project, this repository will no longer be updated.

# Greenplum Database Bootstrap Builder
#### Packer-Based AWS Greenplum Environment Build Tool for the Greenplum Database

**Requirements:**

* Packer
* S3 tools

Modifications Required:

1. Install Packer
2. Clone Repo
4. execute: `packer build -force gpdb-bootstrap-multi.json`
  or to build either vbox or vmware add "-only=vbox" or "-only=vmware" or "-only=aws"

This will generate the OVA which can then be imported into VirtualBox, and/or a zip file for use with VMware
and/or a AWS AMI

#### AMIs from the last run
* us-east-1: ami-6cd5fd7b
* us-west-1: ami-3d8edb5d
* us-west-2: ami-e6ec4186

#### Base AMI Notes and changes

* 20160927 - ami-29084f3e
  * yum update
  * added :git, epel, dkms
  * kernel-2.6.32-642.4.2
  * ixgbevf 3.2.2 for enhanced networking in AWS
  * AWS CLI Bundle installed
  * Set sriovNetSupport to simple
  * added make_greenplum_ready.pl utility script to /root which will raid and format additional devices as one xfs volume
* 20160923 - ami-c74105d0
  * Changed AMI Image to be 40G

repository: vmware-archive/greenplum-bootstrap

repo_name: vmware-archive/greenplum-bootstrap


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

### Description

Unrestricted file upload vulnerability in op/op.AddFile2.php in SeedDMS (formerly LetoDMS and MyDMS) before 4.3.4 allows remote attackers to execute arbitrary code by uploading a file with an executable extension specified by the partitionIndex parameter and leveraging CVE-2014-2279.2 to access it via the directory specified by the fileId parameter.

### POC

#### Reference
- http://packetstormsecurity.com/files/125726

#### Github
No PoCs found on GitHub currently.