text:
---
title: Calculation of Analysis of Means limits
author: Steve Simon
source: http://www.pmean.com/07/AnomCalculations1.html
date: 2007-03-06
categories:
- Blog post
tags:
- Analysis of means
- Incomplete page
output: html_document
---
This page shows some of the details for calculating an analysis of means
(ANOM) chart.

<!---More--->

### Resistivity example

This [data set][nis1] comes from the National Institutes of Standards and Technology.

The first three digits of the data values are constant, so you need to be careful in calculating means and standard deviations. Do not round with this data set. Resistivity measurements were recorded five times on five separate instruments. There is some concern that the instruments may have small but important differences in resistivity.

```{}
Instrument
       1        2        3        4        5
196.3052 196.3042 196.1303 196.2795 196.2119
196.1240 196.3825 196.2005 196.1748 196.1051
196.1890 196.1669 196.2889 196.1494 196.1850
196.2569 196.3257 196.0343 196.1485 196.0052
196.3403 196.0422 196.1811 195.9885 196.2090`
```
Compare these five instruments using an ANOM chart.

```{}
      mean         var      stdev
1 196.2431 0.007651577 0.08747329
2 196.2443 0.019037095 0.13797498
3 196.1670 0.008784212 0.09372413
4 196.1481 0.010863213 0.10422674
5 196.1432 0.007823043 0.08844797`
```

The average of the five means is 196.1892 and the average of the five variances is 0.01083183. The square root of this value, 0.1040761, is the pooled standard deviation.

The formulas for the decision limits in an ANOM chart are

![](http://www.pmean.com/new-images/07/AnomCalculations101.gif)

where

![](http://www.pmean.com/new-images/07/AnomCalculations102.gif)

In this example, I is 5 and N-I is 20. The value of h from the [table of critical values for a balanced ANOM](AnomTable05Part1.html) is 2.80. The ANOM decision limits are

![](http://www.pmean.com/new-images/07/AnomCalculations103.gif)

and the ANOM chart looks like this:

![](http://www.pmean.com/new-images/07/AnomCalculations104.gif)

All five means are inside the decision limits, so you would conclude that no individual mean differs from the overall average.

You can also use an ANOM chart for the standard deviations. I will not show the formulas or the calculations for this chart, but here is what it looks like:

![](http://www.pmean.com/new-images/07/AnomCalculations105.gif)

All standard deviations are inside the decision limits, so you would conclude that no individual standard deviation differs from the pooled standard deviation.

### Toy slingshot

I asked a group of three volunteers to collect some data on their accuracy at hitting a target with a toy slingshot. They took three shots with their dominant hand and measured the distance of each shot from the target. Then they took three shots with their non-dominant hand and took three shots at the target. Their results are recorded below

```{}
Name Shot1 Shot2 Shot3
J-D       62       20       14
J-N       21        9       37
A-D       20       24       37
A-N       43       40       26
M-D       17       75       29
M-N       27       21       59`
```

My intention was to treat these six rows as if they represented six separate individuals (I did not have enough volunteers!). This is perhaps a bit of an oversimplification, and some time in the future I want to analyze the data as a two factor study. For this weblog entry, though, I want to plot these results using an analysis of means chart with a factor having six levels.

The summary statistics are easily computed.

```{}
Name   Mean      Var     Stdev
J-D   32.00   684.00     26.15
J-N   22.33   197.33     14.05
A-D   27.00    79.00      8.89
A-N   36.33    82.33      9.07
M-D   40.33   937.33     30.62
M-N   35.67   417.33     20.43
```

The average of the six means is 32.28. The average variance is 399.6, and the square root of this value, 19.99, represents the pooled standard deviation.

In this example, I is 6 and N is 18. The critical value h is 3.07. The upper decision limit is 64.62, as shown below

![](http://www.pmean.com/new-images/07/AnomCalculations106.gif)

and the lower decision limit is -0.06, as shown below

![](http://www.pmean.com/new-images/07/AnomCalculations107.gif)

We round the lower decision limit up to zero because a negative result is impossible in this experiment. Here is a graph showing the individual means and the ANOM limits.

![](http://www.pmean.com/new-images/07/AnomCalculations108.gif)

Even though there is some disparity in the mean values, these disparities are well within the limits of sampling error.

Although an ANOM chart for the standard deviations is theoretically possible, you should not calculate such a chart unless you have more observations contributing to each individual standard deviation.

### Hypothetical change in sample size

For a process with as much randomness as this, it may make sense to ask each individual to shoot at the target five or ten times. What would the decision limits look like if these individual means and standard deviations were based on ten runs rather than three?

In this case, the value of I would remain the same (6) but the value of N would increase to 60. The critical value for h would be 2.71. The upper decision limit is 47.92

![](http://www.pmean.com/new-images/07/AnomCalculations109.gif)

and the lower decision limit is

![](http://www.pmean.com/new-images/07/AnomCalculations110.gif)

### Improvement in toy slingshot experiment

The group then worked on the process and made some improvements. Here is the data after the process was improved

```{}
J-D 52 12 18
J-N  5  2 34
A-D  9 22 17
A-N 22 19  8
M-D 25 29 10
M-N 27  3 15
```

The summary statistics for each group are

```{}
Name   Mean      Var     Stdev
J-D   27.33   465.33     21.57
J-N   13.67   312.33     17.67
A-D   16.00    43.00      6.56
A-N   16.33    54.33      7.37
M-D   21.33   100.33     10.02
M-N   15.00   144.00     12.00
Avg   18.28   186.56
```

The square root of the average variance, 13.65, represents the pooled standard deviation. The decision limits are

![](http://www.pmean.com/new-images/07/AnomCalculations111.gif)

and

![](http://www.pmean.com/new-images/07/AnomCalculations112.gif)

which we round to zero. The ANOM chart is

![](http://www.pmean.com/new-images/07/AnomCalculations113.gif)

Again, all data points are inside the decision limits.

### Analysis of proportions

The analysis simplifies somewhat if your data is a set of proportions rather than a set of means. You no longer need to compute a pooled standard deviation, but instead use a formula for variation that is a simple function of the average proportion. You also do not need to calculate degrees of freedom, and can treat them as an infinite number of degrees of freedom. This is effectively the same thing as replacing a t-distribution with a normal distribution. Here is the formula.

![](http://www.pmean.com/new-images/07/AnomCalculations114.gif)

A worker is asked to compare four different hearing tests to assure that they are of comparable difficulty.

```{}
Test-1 86%
Test-2 56%
Test-3 90%
Test-4 86%`
```

The results represent the percentage of words out of fifty that are identified correctly. The average of these four proportions is 0.795. The decision limits are computed as

![](http://www.pmean.com/new-images/07/AnomCalculations115.gif)

and the ANOM chart looks like

![](http://www.pmean.com/new-images/07/AnomCalculations116.gif)

The second test appears to be more difficult than average.

**On your own.**

1. A different group of volunteers was asked to shoot a toy rocket at a target (data shown below). Six different people recorded their accuracy on two consecutive shots. Calculate an ANOM chart for this data.

```{}
A 14 39
B 60 20
C 26  9
D  9 12
E 36 21
F 53 18
```

2. The following data is fictional. Twenty separate laboratories were sent identical images of a sperm smear with exactly 100 sperm cells and were asked to estimate the proportion of normal cells on the image using WHO-3 standards (data shown below). Calculate an ANOM chart for these proportions. Don't peek but the answers are available on a [separate web page](PControlChartAnswers.asp).

```{}
25 23 22 18 24 30 22 28 29 15
19 35 33 35 33 17 19 19 40 26
```
You can find an [earlier version][sim1] of this page on my [old website][sim2].

[sim1]: http://www.pmean.com/07/AnomCalculations1.html
[sim2]: http://www.pmean.com

[nis1]: http://www.itl.nist.gov/div898/strd/anova/SiRstv.html

repository: pmean/build-website

repo_name: pmean/build-website


text:
# Tron Cosplay

## Sources
* Disc from https://www.thingiverse.com/thing:1032216
* Disc base from https://www.thingiverse.com/thing:1083616

## 3D Printer Monitoring
* Configured the pi zero to run [_Motion_](https://motion-project.github.io/) to view the print as it works.
* Changes to config file at `/etc/motion/motion.conf` to allow network streaming:
```
daemon on
stream_localhost off
stream_maxrate 50
framerate 60
width 1920
height 1040
stream_quality 50
ffmpeg_output_movies off
on_event_end bash /home/pi/scripts/print_done.sh
```

The `/home/pi/scripts/print_done.sh` file must be placed. The script is very simple:
```
#!/bin/bash
IFTTT_KEY="YOUR_KEY"
ACTION_NAME="YOUR_ACTION_NAME"
HOOK="https://maker.ifttt.com/trigger/$ACTION_NAME/with/key/$IFTTT_KEY"
curl -X POST $HOOK
```

Get it running with `systemctl start motion`
Troubleshoot with `cat /var/log/motion/motion.log`

branch_name: refs/heads/main

extension: md

license_type: permissive


text:
---
layout: default
---

# 1994-02-14 - RE: REAL WORLD ENCRYPTION

## Header Data

From: Blanc Weber<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 3dcdf2ba39fb71ca948f7819006c1200c7208976ea075a8a974d0406c22d147b

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1994-02-14 21:49:12 UTC

Raw Date: Mon, 14 Feb 94 13:49:12 PST

## Raw message

```
{% raw  %}From: Blanc Weber<EMAIL_ADDRESS>Date: Mon, 14 Feb 94 13:49:12 PST
To<EMAIL_ADDRESS>Subject: RE: REAL WORLD ENCRYPTION
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

* intend to use these tools, or is your interest only theoretical?

.  I would use the tools when these became essential; in my
circumstance, not necessarily every day (not yet)
.  It also would depend on the tools; they presently appear unreliable,
unstable

*how much you are willing to reorganize your life in order to take
advantage of these techniques.

.  It wouldn't take much adjusting to go from the potential to the
actual based on my inclinations, if the techniques are convincingly
effective in serving to enhance the possibilities in the real world,
without making it too difficult to continue to interact with it.  Is it
secrecy alone which could accomplish this?  I would agreeable to
experiment with prototypes in order to work on real solutions which are
effective in making the separation from the present attachment to
government-regulated toolboxes.

 *what factors would increase or decrease your use of cryptographic
products and services.

.  depends on how desperate the situation has become (how socialist & coercive)
.  the kind of equipment required (what special items; what cost)
.  portability; mobility (can I use any phone anywhere; do I need to
take a laptop with me or would there be an "ATM" type card to use; how, where)
.  ease of use (I don't write code, I don't know Unix; automated
set-ups & procedures)
.  conflicts or difficulties in coordinating procedures with the rest
of the world, or at least wherever I may be at the time

Concerns:

.  these are all dependent on electricity,
.  the electric/utility companies are not anarchist
.  power outages & access during those times
.  what problems would one face with the government from the use of
such tools; how apparent could it become that one is using a system
which operates within "their" territory, yet outside of their influence
.  what if they find out; do I call EFF

*creating a digital bank/open an account in a digital bank:

.  just how would digital money be translated (exchanged) into other
currency when needed it,
.  so that it would be possible to do business with those who are not
also using digital cash;  what sort of interactions between differing
systems to expect, to deal with
.  who would 'man' the bank (if it matters)
.  where would it be located (do we need to know)
.  what if it's raining & cold outside (ha-ha)

Basically, regarding digital banks & currency, I'm interested in any
alternatives to the present situation, but am not very knowledgeable of
just how these procedures would work or be managed, so that a customer
like myself would understand what they were doing (follow the
reasoning) and be confident that they could manage their accounts;
also, how the value of this kind of 'cash' is established (relative to what?).

Blanc

{% endraw %}
```

## Thread

+ Return to [February 1994](/archive/1994/02)

+ Return to "[Blanc Weber <blancw@microsoft.com>](/authors/blanc_weber_blancw_at_microsoft_com_)"

+ 1994-02-14 (Mon, 14 Feb 94 13:49:12 PST) - RE: REAL WORLD ENCRYPTION - _Blanc Weber<EMAIL_ADDRESS>

license: MIT

branch_name: refs/heads/master

gha_license_id: MIT


text:
This extension provides integration between Ninject and Moq, creating a "lightweight" auto-mocking container.
In your tests, you should use the MockingKernel instead of the StandardKernel. It adds the following features to Ninject:

1. The following syntax will bind a service to the mocked object of a Mock<T>:

    Bind<IService>().ToMock();

2. If you request a service that has no binding, instead of creating an implicit self-binding, the MockingKernel
   will create an instance of Mock<T> and return the mocked object associated with it.

3. A Reset() method is available, which clears the Ninject cache of any activated instances, regardless of whether they
   remain in scope. You can call this method after each test to ensure that instances are reactivated, without having
   to dispose and re-initialize the kernel each time.

Hat tip to [Scott Reynolds](http://github.com/scottcreynolds) for the idea, and to [Sean Chambers](http://github.com/schambers) for dogfooding.

extension: markdown


text:
# electron-osx-appearance

> APIs for accessing the OS X Appearance Settings.

Requires:
* **Electron >=0.37.8**

## Why?

* Simple function calls instead of having to remember the name and types of each setting you need to access.

## Install

```
$ npm install --save electron-osx-appearance
```

## Usage

```js
const osxPrefs = require('electron-osx-appearance');

if (process.platform === 'darwin') {
	osxPrefs.isDarkMode();

	osxPrefs.onDarkModeChanged(() => {
		// Handle the event
	});
}

// ...
```

**Note**: This module is a wrapper around **OS X specific** methods from Electron's `systemPreferences` module.

## Methods

### `unsubscribe(id)`

* `id` Integer

Remove subscriber with `id`.

### `isDarkMode()`

Returns `true` if the system is in Dark Mode, and `false` otherwise.

### `onDarkModeChanged(callback)`

* `callback` Function

Substribe to the Dark Mode changed event. Runs `callback` when event is fired.

Returns the `id` with which you can then unsubscribe with.

### `isTintBlue()`

This method return `true` if the system is using the blue tint, `false` otherwise.

### `getTint()`

Return a `String` with the system's current Tint.

Possible values are `'blue'` or `'graphite'`.

### `onTintChanged(callback)`

* `callback` Function

Subscribe to the Tint changed event. Runs `callback` when event is fired.

Returns the `id` with which you can then unsubscribe with.

### `getHighlightColour()`

Returns an RGB `array` of the system's current Highlight Colour.

If none is found, returns `[9, 92, 220]` as default.

### `onHighlightColourChanged(callback)`

* `callback` Function

Subscribe to the Highlight Colour changed event. Runs `callback` when event is fired.

Returns the `id` with which you can then unsubscribe with.

### `getSidebarIconSize()`

Returns `String` with the system's current Sidebar Icon Size.

Possible values are `small`, `medium` or `large`.

### `onSidebarIconSizeChanged(callback)`

* `callback` Function

Subscribe to the Sidebar Icon Size changed event. Runs `callback` when event is fired.

Returns the `id` with which you can then unsubscribe with.

### `getScrollbarVisibility()`

Returns a `String` with the system's current Scrollbar Visibility.

Possible values are `automatic`, `whenscrolling` or `always`.

### `onScrollbarVisibilityChanged(callback)`

* `callback` Function

Subscribe to the Scrollbar Visibility changed event. Runs `callback` when event is fired.

Returns the `id` with which you can then unsubscribe with.

### `isScrollbarPaging()`

Returns `true` if the system is using Scrollbar Paging, `false` otherwise.

### `onScrollbarPagingChanged(callback)`

* `callback` Function

Subscribe to the Scrollbar Paging changed event. Runs `callback` when event is fired.

Returns the `id` with which you can then unsubscribe with.

## License

MIT © Daniel Pham

repository: ColinMcNeil/weatherapp

repo_name: ColinMcNeil/weatherapp


text:
# Dependencies

Nargo allows you to upload packages to GitHub and use them as dependencies.

## Specifying a dependency

```
hello_world = { tag = "v0.5", git = "https://github.com/kevaundray/hello-world-noir"}
```

Specifying a dependency requires a tag to a specific commit and the git url to the url containing the package.

Currently, there are no requirements on the tag contents. If requirements are added, it would follow semver 2.0 guidelines.

> Note: Without a `tag` , there would be no versioning and dependencies would change each time you compile your project.

repository: BriungRi/book

repo_name: BriungRi/book


text:
# Kasper

The "Thoughts From The Hive" theme, based on Casper, the default theme for [Ghost](http://github.com/tryghost/ghost/).

## Credits
Thanks to the Ghost team, jnicol, matthieua, and daneden for building:
Ghost https://github.com/TryGhost/Casper, ParticleGround https://github.com/jnicol/particleground, WOW.js https://github.com/matthieua/WOW, and Animate.css https://github.com/daneden/animate.css, respectively.

repository: KomCreative/Kasper

repo_name: KomCreative/Kasper


text:
*Note!* This issue tracker should only be used for actionable and constructive feedback that impacts Make School as an organization or any given group of stakeholders (staff, students, etc.). If you encounter a situation which is highly personal (i.e: which only applies to your individual situation, or which you do not want shared publicly), and you're not sure who to reach out to, please contact a member of Student Experience for guidance.

*Additional Note:* This issue tracker can not be used for emergent or urgent requests, or complaints regarding [Code of Conduct](https://docs.google.com/document/d/1a1i2jwXqx__URpWvUf8z8E9iwcdJ05QsPnbjs7Z83Us/preview#heading=h.xlozhda52bcz) violations. Should one of these issues arise, please fill out the [Student Reporting Form](http://make.sc/student-reporting-form) or reach out to a member of Student Experience or another staff member you trust via Slack or email.

## Issues

Additions to this segment of the repository are extraordinarily welcome, and encouraged. With the goal of constant growth and experience, Make School as an organization is dedicated to iteration and improvement. As you consider issues you may have or ideas for improvement, please follow the below guidelines to ensure that we can ensure it is taken into consideration:

1. **What is an 'Issue'?**

- Put simply, an "issue" is any piece of actionable or constructive feedback about facets of Make School which you would like to see improved. "Issues" can be in regards to:

  1. Curriculum
  2. Student Experience
  3. Academic Support
  4. Organization-wide Processes
  5. Concentrations
  6. Or any combination of the above, or anything we've missed, so long as it:

      1. Would improve the organization as a whole or the experience of a whole group of stakeholders (i.e: staff, or students)
      2. Is constructive (i.e: not an insult, rant, etc.)

2. **How do I submit an Issue?**

- In order to submit an issue, navigate to the [issues](https://github.com/MakeSchool/institutional-plan/issues) segment of our repository (if you aren't there already!) and click on "New Issue" - it's a bright green button in the upper right-hand corner of the page!

- Select the category your issue falls under! If you aren't quite sure, pick the one that you think is the closest.

- Fill out our issues template (it will autopopulate in the body of the issue) with your specific information, and add a descriptive title.

  Examples of good titles:

  1. "Outline of Proposed Events for Spring 2021"
  2. "Concern with Current Lesson Plan for Async JavaScript, BEW 1.3"

  We want to know what your concern or idea is as soon as we check out the title! This will help moderators of the Issues forum comb through and find high priority issues, or things that are more quickly implemented, so that we can allocate time to your ideas as efficiently as possible!

- Provide a clear and concise description of your concern or idea. Think about implementation, and try to consider "side effects". This isn't to make this process difficult for you, rather, to give you the chance to sell your idea or concern so that we understand how to proceed with fixing or working on it!

- What is your intended outcome? Think about this like a coding problem - what behavior do you *want* to see? If you're proposing an event, what would you like the benefit to be? More chances to socialize or network? To strengthen our community?

  *Note*: There aren't really wrong answers. This is another step to ensuring that your idea or concern can be addressed, or so that we can point you in the right direction if it's something we are already working on or doing.

  With that being said, this is a chance for you to consider the desired outcome, and recognize whether what you're asking for is really the "root" of your concern. For example, if you request a curriculum change because a class feels difficult, it's possible that what's needed is more TA support. If we understand the desired outcome, we can have a dialogue to get to the root of any problems we may find.

3. **What happens next?**

Once you've submitted an issue, a member of Student Council will tag it, and flag the corresponding department head or staff member. The department your issue corresponds to (i.e: Student Experience, or Curriculum) will take some time to consider what's being asked, and ask clarifying questions. If your issue is something we can move forward with fixing or implementing, you will be provided with a point of contact and an approximate "due date" at which this issue should be resolved, or by which you can follow up to check in.

Clarifying questions may be asked in the thread, so pay attention to your Github notifications to stay informed!

4. **What if my issue came from a feedback form?**

A very important part of *Issues* is that they might not be directly posted by you, but you might want to check in here to see about a concern that you raised as a part of mid or end-of-term feedback forms.

If this is the case, we'll send out notifications to students via Slack to update the student body which concerns from feedback forms have been posted, along with their ID #'s so that you can follow the thread and stay informed on what's happening with your feedback.

5. **I have more questions, who do I ask?**

If you have questions about this process, reach out to a member of Student Council! They'll either be able to answer your specific questions, or direct you to the appropriate staff member who can!

repository: KitsuneNoctus/makeschool

repo_name: KitsuneNoctus/makeschool


text:
# Hydnellum hybridum (Bull.) Banker, 1913 SPECIES

#### Status
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Mycologia 5(4): 198 (1913)

#### Original name
Hydnum hybridum Bull., 1791

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Basidiomycota/Agaricomycetes/Thelephorales/Bankeraceae/Hydnellum/Hydnellum ferrugineum/ Syn. Hydnellum hybridum/README.md

repo_name: mdoering/backbone


text:
# 12.1 Exercises

1. Elide

2. Min-heap pust the smallest element at the root of each subtree. It can be used to print the keys in sorted order in the same way it can be used to sort a list; however, it will do so in $O(n\lg n)$ instead of $O(n)$ because it does not constrain the subtrees with respect to eachother.

3. ```
   INORDER-TREE-WALK-POINTER(x)
      last = NIL
      while x != NIL
         if last == x.p
            last = x
            if x.left == NIL
               if x.right == NIL
                  print x.key
                  x = x.p
               else
                  x = x.right
            else
               x = x.left

         if last == x.left
            last = x
            print x.key
            if x.right == NIL
               x = x.p
            else
               x = x.right

         // last == x.right
         last = x
         x = x.p
   ```

4. Just move `print x.key` up or down a line (respectively).

5. Because printing the sorted list can be done in worst-case linear time, construction must be $\Omega(n)$ or else contradict the results for comparison sort.

repository: TheYargonaut/algorithms-text-answers

repo_name: TheYargonaut/algorithms-text-answers


text:
---
layout: post
title: Malware Taxonomy, Part 1 of 3. Background Info
---
I've been working on this post for quite some time and I found that it has become to unwieldy due too the amount of content I wanted to cover, so I will be releasing it in three parts: Part 1. Background Info; Part 2. Categories of Malware; and Part 3. How to Identify Malware.

In my last article I gave a brief overview of the different types of malware analysis and the people who perform this noble task. But, that probably left you wondering about the types of malware out there in the wild. It is imperative that analysts know how to identify, classify, and describe attributes of different types of malware so they can effectively triage systems, implement countermeasures, and develop intelligence that can be shared with the community. Removing a rootkit can be vastly different than eradicating a virus or quarantining a worm and performing these functions incorrectly can lead to reinfection, or a secondary outbreak. Knowing how to properly identify and handle different types of malware can help avoid these pitfalls.

> Trivia: The term “in the wild” originates from “The WildList International”, an organization who maintains a list of malware that exists outside of research laboratories, also known as “zoos”. WildList International has been receiving reports from security researchers at antivirus and security companies since 1996. The current list is available here: http://www.wildlist.org/CurrentList.txt

## TL;DR:

### Malware History:
Most reference books on malware start their timelines in 1981 with ELK Cloner, but people have been experimenting with malware since the 1970's.
-	https://en.wikipedia.org/wiki/Timeline_of_computer_viruses_and_worms
-	http://malware.wikia.com/wiki/Timeline_of_noteworthy_computer_malware

### Classifying Malware:
Advanced Malware Analysis describes malware taxonomy as <cite>"the process of classifying malware into different groups using a systematic approach based on its characteristics or attributes"</cite> [2].

#### Why Classify Malware?
- Malware analysis yields an understanding of a sample's purpose, directive, and primary function, organizing this data results in recognizable relationship patterns between groups.
- Familiarity with these patterns allows you to identify a sample's class and predict its behavior.
- New classes are created when a sample's characteristics/attributes don't fit into an existing class facilitating expansion of our understanding of malware.
-  Expedites analysis - allows you to make educated guesses about your samples functionality based on its classification, then confirm your hypothesis.

#### Is there a Standard for Malware Taxonomy?
- The short answer, No. But, there are a few classification systems available (see the AV & MAEC sections below).

##### Anti-virus Industry CARO/EICAR:
- Antivirus (AV) vendors (and Windows Defender) use Computer Antivirus Research Organization (CARO) and European Institute for Computer Antivirus Research (EICAR).
- CARO and EICAR were established in 1990's and collaborated on the EICAR test file which validates the integrity of an AV engine.
- Both organizations use a basic naming convention that includes family name, platform, and capabilities...unfortunately, these names are not standard across the AV industry, which makes it hard to share information.

##### MAEC/MISP
MITRE created <cite>"Malware Attribute Enumeration and Characterization (MAEC™) (pronounced “mike”) [which] is a community-developed structured language for encoding and sharing high-fidelity information about malware based upon attributes such as behaviors, artifacts, and relationships between malware samples" </cite> [4].

- Defines data types like boolean, dictionary, strings, etc.
- Defines top-level objects like behavior, collection, malware action, family, and instance
- Defines relationship types
- Provides a vocabulary specification
- Uses JSON (allows for machine tagging)

#### What are Classifications Based on?
##### In general:
- Operating system, or platform
- Infection vector
- Spreading mechanism
- Fuzzy hash
- Objective:
  - mass: infect as many systems as possible, most common, less sophisticated, detect/prevent with countermeasures
  - targeted: target an entity, less common, more sophisticated, circumvent countermeasures

##### CARO/EICAR:
- Type: describes what malware does on a system
- Platform: describes the operating system the malware targets, but also indicates programming languages and file formats
- Family: characteristics, attribution to malware author (note: often not uniform between vendors)
- Variant letter: sequential versioning across families (ex: AF, then AE)
- Additional information: extra info regarding the malware, such as components

##### MISP Taxonomy:
- Malware Categories and Obfuscation Classification - https://github.com/MISP/misp-taxonomies/tree/master/malware_classification

##### MITRE (MAEC):
- Attributes - https://collaborate.mitre.org/ema/index.php/ema:Attributes
- Capabilities - https://collaborate.mitre.org/ema/index.php/ema:Capabilities
- Behaviors - https://collaborate.mitre.org/ema/index.php/ema:Behaviors

> #### Note:
- Malware typically doesn't fall into just one category.
- A Malware author's main concern when coding is directive (do the coded instructions achieve the author's purpose?).
- Most malware exhibits two or more behaviors, so you should tag samples with every class it belongs to [2].

That's it for Part 1: Malware Taxonomy, Background Info. If there's anything I missed, please let me know via email (ragingroosterrem@gmail.com). Thanks for reading!

### References:
1. http://www.wildlist.org/
2. Advanced Malware Analysis
3. Practical Malware Analysis
4. https://maecproject.github.io/
5. https://securityintelligence.com/how-to-choose-the-right-malware-classification-scheme-to-improve-incident-response/
6. http://www.caro.org/index.html
7. http://www.eicar.org
8. https://www.microsoft.com/en-us/wdsi/help/malware-naming


text:
# ~/.config/bash

[Formerly] the jewel of my dotfiles. 💎

As of April 2022, the good stuff has been ported to [fish].

[Formerly]: https://github.com/zgracem/dotconfig/tree/cee87f6/bash
[fish]: https://github.com/zgracem/dotconfig/tree/master/fish

***

`./bashrc.bash` should be symlinked from `~/.bashrc`, and sources the following:

- `./_*.bash`
- `./*.d/*.bash`

repository: zgracem/dotconfig

gha_language: Shell

repo_name: zgracem/dotconfig


text:
#  `Regex` with `filter()`

```scala
object PhoneNumber {
  private val VALID_PHONE_NUMBER = raw"^1?([2-9]\d{2}[2-9]\d{6})$$".r

  def clean(input: String): Option[String] = {
    val cleaned = input.filter(_.isDigit)
    Option(cleaned) collect { case VALID_PHONE_NUMBER(cleaned) => cleaned }
  }
}
```

This approach starts by defining the [regex pattern][regex-pattern] for a valid phone number in a [raw string][raw-string].
- `^1?` means that the `String` being checked starts with `1` one or zero times.
- `[2-9]` means the next character must be `2` through `9`.
- `\d{2}` means the next two characters must be digits (with no limit to their value, so `0` through `9`.)
- `[2-9]` means the next character must be `2` through `9`.
- `\d{6}` means the next six characters must be digits (with no limit to their value, so `0` through `9`.)
- `$$` is the only escape in the raw string.
`$` means the end of the string, so the `String` being matched must have the preceeding six digits as the last part of the `String`.

The input `String` calls the [`filter()`][filter] method.
Each character is passed to `filter()`, which in turn passes the character to the [`isDigit`][isdigit] method.
Only the characters that are digits survive to be passed as a `String` to [`Option()`][option].
If there are no digits, then `Option` returns `None`.

Otherwise, the cleaned `String` is passed to [`collect()`][collect].
The `case` returns the cleaned `String` if it matches the valid phone number pattern.
If the phone number does not match the valid pattern, then `None` is returned.

[regex-pattern]: https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html#java.util.regex.Pattern
[raw-string]: https://docs.scala-lang.org/overviews/core/string-interpolation.html
[filter]: https://www.scala-lang.org/api/2.13.4/scala/collection/StringOps.html#filter(pred:Char=%3EBoolean):String
[isdigit]: https://www.scala-lang.org/api/2.13.4/scala/Char.html#isDigit:Boolean
[option]: https://www.scala-lang.org/api/2.13.4/scala/Option.html
[collect]: https://www.scala-lang.org/api/2.13.4/scala/Option.html#collect[B](pf:PartialFunction[A,B]):Option[B]

repository: exercism/scala

gha_language: Scala

repo_name: exercism/scala


text:
# Design patterns in Python

### SOLID
  - Single responsibility principle
  - Open closed principle
  - Liskovs Substitution principle
  - Interface Segragation principle
  - Dependency inversion principle

#### Single Responsibility Principle

A class ought to have one and only one responsibility. Keep your component as granular as possible. Do one thing and do it well.
Violating this principle makes chaning or extending the class very difficult.

#### Open closed principle

Code should be open for extension, but closed for modification. Once you have written a class, try to leave it alone, do not add new functionality. No new member
variables, methods, or interfaces. Keep it as a guideline, bug fixes and some imporovements are ok.

To make new functionality, use your class in new ways. Use extension, not modification. Extension refers to creating a derived class. Base class should not be changed.
To change how something is accomplished extend the original class. Inheritance setups a has a relationship. Delegation creates a new class with new functionality, and you
delegate from the old class. Composition, structure your original code in such as a way as you have pluggable components, plug and play.

Choose three ways:
1. Inheritance - template design pattern
2. Delegation - observer, chain of responsibility (state changes etc)
3. Composition - If you take in member variables to determine behaviour - strategy pattern

You can use multiple ways together to achieve the open/closed principle effect.

1. Interface segregation principle
Interface is effectively a contract that binds the class to implmenting certain beahviours
Do not mix too many different behaviours

2. Dependency Inversion principle
Program to an interface not an implementation
Depend on abstractions, abstract base classes, a method without an implementation, exposing an interface.
Never make any assumptions about the inside / implementation

#### Principle of least knowledge
Only talk to friends not friends of friends (strangers) - Law of Demeter
promotes loose coupling
friends include params of methods, objects, global vars

#### The hollywood principle
Dont call us we will call you.
High level object to low level object, using events
Low level objects should not communicate up, like pinging etc.
Observer design pattern is an implementation

#### The principle of single responsibility

keep classes focused in what they do.

#### Liskovs substitution principle
- The inheriting or derived class from a Base class should be predicable in behaviour.
- The interface contract is the same, i.e. you can subsititue the base calss with derived flag.
- Breaking this contract would happen where the derived class methods change their parameters, i.e. its invoked differently.
- The api of both classes should ideally match, then you are observing or respecting Liskovs substitution principle.
- If you start having isinstance checks in your derived methods this should be a RED flag that you are breaking this principle.
-

#### Interface Segragation principle
- Clients should not have to implement bulky interfaces
- Keep the interface focussed and granular
- By declaring custom functions, you can pass a derived class through.

```python
class Eagle(Flying, Feeding):

  # here you can overide the methods that will inherit from the inherited interfaces

  # call functions
  eat_food(eagle)

  # or another example using a base class
  class Mammal:
    def aerial(self):
      raise NotImplementedError

   # then a derived class
   class Human(Mammal):
    def aerial(self):
      pass
      # because humans cant fly

```

#### Dependency Inversion Principle

- Clients should only depend on abstractions and not on implmentation
- Higher level modules should not depend on lower level modules

#### Global Object pattern

Module is a logical unit that can be imported and consists of functions, variables.

Use __ at beginning to indicate its a private label.

#### Factory and Abstract pattern

Seperate the creation from their use, can be class creation or object creation.

class creation use inheirtence
Object creation often uses delegation

---

 ```python

class Product:
  def __init__(self, name, price):
    self.__name = name
    self.__price = price

  def get_price(self):
     return self.__price

 class AppleIpad(Product):

  def __init__(self, generation):
    Product.__init__(self, 'AppleIpad')

class ProductFactory()

  @staticmethod
  def create(item_name, *args):
    if item_name == "AppleIpad":
      return AppleIpad("gen2")

 ```
## Structural design patterns
  focus on how classes and components can be composed to form new complex structures
### Adapter pattern

- It is a structural object pattern
- Adapters let classes work together that couldn't otherwise because of incompatible interfaces
- It works by creating a third class that is the adapter and it inherits from the common interface
- This then must __init__ and take the old legacy class and store a reference to it locally
- All expected contract methods, i.e. the shape of interface, must then delegate the calls to legacy
- methods.

### decorator pattern
- Use this when you need to add behaviour at runtime
- Inheritence will not work as it is static
- Wrap each object with another. derived from abstract classes
- Think of the application as wrapping functions around functions, like the HOC pattern in JS

### Facade pattern
- A class that hides a complex system
- makes the subsystem easier to use, unified interface to a more complex sub interfaces
- decouple complex, granular systems from clients
- **watch out**: should not be only way to access system
- can be a bunch of microservies, facade stands infront, hides complexity.

#### Behavioural patterns

##### Strategy pattern
- Focus on communication with the external world
- Define a family of algorithms that achieve the same objective
- Sorting is a perfect use case in high level languages for using the strategy pattern
- Uses composition as oppose to inheritence to pass through these different objects
- In the case of a sorting algorithm this would be telling the sort function how to sort, i.e. ignore case, or sort lexicographical or sort reverse etc.
- You could apply it like passing a function with some functionality that acts on the first arguments you pass through.
- The python sorted function uses the key named argument which can change how your list is sorted, this is the strategy pattern

##### Chain of Responsibility
- Design of UI, passing event propogation in event handlers
- Set up a way of passing a request between objects
- Have every handler implement the same interface
- Usually needs a nextHanlder pointer, and handler function

##### Command pattern
- commonly used in applying the undo feature so common
- uses the abc module in Python

```python

from abc import ABC, abstractmethod

class Command(ABC):
  @abstractmethod
  def execute(self):
    pass

  @abstractmethod
  def undo(self):
    pass

class italic(Command):
  def execute(self):
    print("italic")
  def undo(self):
    print("undo italic)

commands_executed = []

def execute(command):
  command.execute()

  commands_executed.append(command)

def undo():
  if len(commands_executed) == 0:
    print("At most recent change")
  command = commands_executed.pop()
  command.undo()

execute(italic) # commands_executed [italic]

undo() # commands_executed [] prints undo italic
```

repository: oreillyross/developer-notes

repo_name: oreillyross/developer-notes


text:
# Cloud SQL sample for Google App Engine Java 11

This sample demonstrates how to use [Cloud SQL](https://cloud.google.com/cloudsql/) on Google App
Engine standard Java 11
More configuration information [at this page](https://cloud.google.com/sql/docs/mysql/connect-app-engine)

## Setup

* If you haven't already, Download and initialize the [Cloud SDK](https://cloud.google.com/sdk/)

    `gcloud init`

* If you are using the Google Cloud Shell, change the default JDK to Java11:

```
   sudo update-alternatives --config java
   # And select the usr/lib/jvm/java-11-openjdk-amd64/bin/java version.
   # Also, set the JAVA_HOME variable for Maven to pick the correct JDK:
   export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64
```

* If this is your first time creating an App engine application:
```
   gcloud app create
```

* If you haven't already, Setup
[Application Default Credentials](https://developers.google.com/identity/protocols/application-default-credentials)

    `gcloud auth application-default login`

* [Create an instance](https://cloud.google.com/sql/docs/mysql/create-instance)

* [Create a Database](https://cloud.google.com/sql/docs/mysql/create-manage-databases)

* Note the **Instance connection name** under Overview > properties

## Configuring the Env Variables in app.yaml

Edit the [app.yaml](src/mail/appengine/app.yaml) file and change the 4 env variables to match your environment

```
env_variables:
  DB_INSTANCE: PROJECT:us-central1:INSTANCE
  DB_DATABASE: DBNAME
  DB_USER: root
  DB_PASSWORD: password
```

## Cloud SQL Driver dependencies

See the dependencies in the pom.xml: the first one is the standard Cloud SQL driver
and the second one (1.0.12 or later for Java11 support) is the Google SQL Socket factory
that is used to connect to the Java11 runtime socket configured for accessing Google
Cloud SQL.

```
    <dependency>
      <groupId>org.postgresql</groupId>
      <artifactId>postgresql</artifactId>
      <version>5.1.47</version>
    </dependency>

    <dependency>
      <groupId>com.google.cloud.sql</groupId>
      <artifactId>mysql-socket-factory</artifactId>
      <version>1.0.12</version>
    </dependency>
```

## Deploying

```bash
$ mvn clean package appengine:deploy -Dapp.deploy.projectId=<your-project-id>
```

## Cleaning up

* [Delete your Instance](https://cloud.google.com/sql/docs/mysql/delete-instance)

repository: ludoch/samples

gha_language: Java

repo_name: ludoch/samples


text:
Arrays are collections of values. Every array has the following properties (it also has those every value has):
### Index properties
Elements in an array can be accessed by their index (zero-based). You can use the `get(index)` property, or the `1` property for index 1
(works for every other index too).
```
//result is "c"
["b", "c"].1;
//result is 7
var a = [1,5,7].get(2);
```

### length
Returns: how many elements are stored in this array.
### getOrDefault
Same as get, but when the index does not exist it returns a specified default value. Parameter 1: the index. Parameter 2: what is returned
if the index was not found (e.g. index -1). Returns: the value at the given index, or the default value.
### set
Sets an index to a new value. Parameter 1: the index to set. Parameter 2: the new value. Returns: what was at this index before.
### cut
Returns a sub-array of the original. Parameter 1: The index to skip to. `[1,2,3].cut(1)` is `[2,3]`.
### remove
Currently not working because of a bug. Removes the element at the given index and returns it. Parameter 1: the index to remove.
### add
Returns the sum of the array elements.
### mul
Returns the product of the array elements.
### repeat
Returns an infinite array that contains the original elements and repeats them. `[1,2,3].repeat()` is `[1,2,3,1,2,3,1,2,3,1,2,3` and so on.
### sort
Sorts this array. Reurns: this array.
### zip
Makes one array of a two-dimensional one using an operator function. Parameter 1: the operator. `[[1,2,3],[4,5,6]].zip(+)` is `[5,7,9]`.
### link
Concatenates two arrays. Parameter 2: the second array. `[1,2,3].link([4,5,6])` is `[1,2,3,4,5,6]`.

repository: coalang-soft/doc

repo_name: coalang-soft/doc


text:
# data-structures-and-algorithms
This Repo is DeltaV's 401 class' challenge. It is both a test of our problem solving skills along with our ability to work with others. Mix that in with a bit of whiteboarding practice and this is the final product. Each challenge will have its title as well as a description underneath of the exersise. Finally a photo of the whiteboard is added to that day before the next challenge header.

## Reverse an array
In this challenge we were asked to:
Write a function called reverseArray which takes an array as an argument. Without utilizing any of the built-in methods available to your language, return the provided array argument with elements in reversed order.

### Solution
![DeltaV 401 class whiteboard](/assets/reverse_Array.JPG)

## Shift an array
In this challenge we were asked to:
Write a function called insertShiftArray which takes in an array and the value to be added. Without utilizing any of the built-in methods available to your language, return an array with the new value added at the middle index.

### Solution
![Challenge 2 whiteboard](/assets/array_shift.jpg)

## Binary Search
In this challenge we were asked to:
Write a function called BinarySearch which takes in 2 parameters: a sorted array and the search key. Without utilizing any of the built-in methods available to your language, return the index of the array’s element that is equal to the search key, or -1 if the element does not exist.

### Solution
![Challenge 3 whitebaord](/assets/array_binary_search.jpg)

repository: etitler/data-structures-and-algorithms

repo_name: etitler/data-structures-and-algorithms


text:
# Phyllocelis Syd. GENUS

#### Status
ACCEPTED

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Annls mycol. 23(3/6): 353 (1925)

#### Original name
Phyllocelis Syd.

### Remarks
null


text:
# == DEPRECATED ==

This bot has been replaced by https://github.com/tendrilinc/oncall-slack-bot

---

# PagerDuty OnCall Slack bot

## Local development

1. `vagrant up`
1. `vagrant ssh`
1. `cd /vagrant`
1. `npm install`
1. `npm test`

## Deploying

Follow these steps to configure the slash command in Slack:

1. Navigate to https://<your-team-domain>.slack.com/services/new
1. Search for and select "Slash Commands".
1. Enter a name for your command and click "Add Slash Command Integration".
1. Copy the token string from the integration settings and use it in the next section.
1. After you complete the deployment to AWS, enter the provided API endpoint URL in the URL field.

Follow these steps to encrypt your Slack token for use in this function:

1. Create a KMS key - http://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html.
1. Give your function's role the permission for the kms:Decrypt action.
1. Encrypt the Slack token using the AWS CLI: `$ aws kms encrypt --region <region> --key-id alias/<KMS key name> --plaintext "<SLACK_TOKEN>"`
1. Copy the base-64 encoded, encrypted key (CiphertextBlob) to the relevant `kmsEncyptedSlackToken` configuration key value in `index.js`.
1. Obtain a read-only PagerDuty API V2 key - https://support.pagerduty.com/hc/en-us/articles/202829310-Generating-an-API-Key
1. Encrypt the PagerDuty API key using the AWS CLI: `$ aws kms encrypt --region <region> --key-id alias/<KMS key name> --plaintext "<PAGERDUTY_KEY>"`
1. Copy the base-64 encoded, encrypted key (CiphertextBlob) to the relevate `kmsEncryptedPagerDutyApiToken` configuration key value in `index.js`.
1. Obtain a Slack API token for testing and development: https://api.slack.com/docs/oauth-test-tokens
1. Encrypt the Slack API token using the AWS CLI: `$ aws kms encrypt --region <region> --key-id alias/<KMS key name> --plaintext "<API_TOKEN>"`
1. Copy the base-64 encoded, encrypted token (CiphertextBlob) to the relevate `kmsEncryptedSlackApiToken` configuration key value in `index.js`.

Example role permission:
```json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "kms:Decrypt"
      ],
      "Resource": [
        "<your KMS key ARN>"
      ]
    }
  ]
}
```

Follow these steps to deploy the AWS Lambda function:

1. `aws configure`
1. `serverless deploy`
1. Update the URL for your Slack slash command with the invocation URL for the created API resource in the prod stage.
1. `serverless invoke --function slack --path event.json`

## Todo

* allow filtering by policy
* allow filtering by escalation level

repository: tendrilinc/pagerduty-oncall-slack-bot

repo_name: tendrilinc/pagerduty-oncall-slack-bot


text:
# elkvs
ETS powered key-value REST accessible storage example

## Quickstart

Install dependencies with `mix deps.get`

Run tests with `mix test`

Start application with `iex -S mix`

License
-------

This project is under the **MIT** License. See the [LICENSE](LICENSE) file for the full license text.

repository: pmyarchon/elkvs

repo_name: pmyarchon/elkvs


text:
# Spotted

![Image](https://i.imgur.com/buuPQel.png)

Update of TGPArchers mod
https://github.com/TGPArcher/Spotted

- Lowered the Alert-level on events that has no raid-points if they are identified
- Ally help and Royal Aid should no longer be delayed
- Any quest-related incident will be ignored

![Image](https://i.imgur.com/pufA0kM.png)

![Image](https://i.imgur.com/Z4GOv8H.png)

Have you ever wondered how do raiders/caravans/animals manage to reach your colony unnoticed?
Well this mod fixes that by adding a chance for your colonists to spot them valuable time before they reach your colony.
But sometimes they are more sneaky, to counter this new buildings have been added to the game which increase the chance to spot any movement outside your colonies.
Make sure your colonist know everything which moves around, don't get caught unprepared.

More details:
 * Buildings are unlocked by researching the Spotted Research Tree
 * With every research every movement spotted has more details.
 * Every colonist increases discovery chance with 0.5%
 * Spotting capabilities of buildings can be seen on their stats
 * Discovery power and range is cumulative so building more structures will increase your chance.
 * Discovery chance is adjusted with difficulty, higher difficulties requiring more spotting buildings or colonists

Requirements:
 This mod requires HugsLib in orderd to run.
 Install HugsLib and place it higher on the listitem

License:
 Do what you want, but give the author credit.

![Image](https://i.imgur.com/PwoNOj4.png)

-  See if the the error persists if you just have this mod and its requirements active.
-  If not, try adding your other mods until it happens again.
-  Post your error-log using https://steamcommunity.com/workshop/filedetails/?id=818773962]HugsLib and command Ctrl+F12
-  For best support, please use the Discord-channel for error-reporting.
-  Do not report errors by making a discussion-thread, I get no notification of that.
-  If you have the solution for a problem, please post it to the GitHub repository.

gha_language: C#


text:
# Astoria-arch Lean Coffee App

### The goal is to build a lean-coffee app that we can use as a group to suggest and vote on popular topics for discussion prior to the meetup. This will allow us to brainstorm more interesting topics and organize who will be in each discussion and at what time they will happen.

```ruby
  git clone git@github.com:astoria-arc/lean-coffee.git
  cd lean-coffee
  git checkout -b my_feature

  server:
  bundle install
  rake db:create
  rake db:migrate
  rails s -p 3001

  client
  cd client
  yarn install
  yarn start

  visit http://localhost:3000
  ```
  ### Tech Stack:
   - Rails-API
   - React
   - Redux
   - GraphQL
   - Typescript
   - Material-UI

repository: omardeleo/lean-coffee

repo_name: omardeleo/lean-coffee


text:
# Iframely API for Responsive Embeds and Unified Meta

You send Iframely an URL via HTTP GET request. Iframely will return you semantics `meta` and embeds `links`, which both mimic the `<head>` elements of the web page requested.

Iframely will generate those elements from a variety of sources, including oEmbed, Twitter Cards, Open Graph, microformats and custom domain parsers.

Embed codes are given in `html` values for each link or, for the primary media option only, duplicated at the root level. The embed codes will be wrapped into responsive divs whenever possible.

## API Request

[>> http://iframe.ly/api/iframely?url=… &api_key= …](http://iframe.ly/api/iframely?url=http://iframe.ly/ACcM3Y).

 - `url` and `api_key` parameters are required.
 - `url` needs to be URL-encoded.
 - `api_key` isn’t required if URL is from `iframe.ly/*` domain.

If you're making API calls via JavaScript, and your site uses SSL, change API address to `https://`. For server-server communications, HTTP is generally faster as it doesn't require additional handshakes.

## API Response

[>> Here’s Iframely API response for Coub](http://iframe.ly/api/iframely?url=http://iframe.ly/ACcM3Y)

    {
        "id": "ACcM3Y",                 -- short ID if you request iframe=true
        "url": "http://coub.com/view/2pc24rpb",

		-- rel use cases and html  code for primary variant of embed,
		"rel": ["player", "ssl"],	-- check it for `autoplay` if you request it
		"html": "

"

        "meta": {                       -- meta object with the semantics
            "title": "PARADISE BEACH",  -- e.g. title and others
            "description": "Ilya Trushin",
            "author_url": "http://coub.com/trucoubs",
            "author": "Ilya Trushin",
            "site": "Coub",
            "canonical": "http://coub.com/view/2pc24rpb",
            "keywords": "living photo, ... , media"
        },

        -- Plus list of embed src links with functional rels . For example,
        "links": {
            "player": [{                -- List of player embed widgets
                "media": {              -- Media query aspects
                    "aspect-ratio": 1.777778
                },
                                        -- SRC of embed.
                "href": "//coub.com/embed/2pc24rpb",
                "rel": ["player", "ssl", "html5"],
                "type": "text/html"     -- link’s MIME type
                -- Plus generated HTML code for simplicity of use.
                "html": "

"
            }, {
                ...
                -- Might have multiple variations of the same player.
                -- E.g. one that 'autoplay's, one as MP4 video, one with https src.
            }],
            "thumbnail": [{
                "media": {
                    "height": 360,      -- Exact sizes here.
                    "width": 640
                },                      -- We repeat the same rel
                "rel": ["thumbnail"],   -- as iframely.js needs it.
                "type": "image",        -- "use href as src of image"
                "href": "http://cdn1.aka ... med_1381670134_00040.jpg"
            }, {
                ...
            }],

                                        -- Also possible:
                                        -- app, image (as rel)
            ...                         -- reader, survey
                                        -- logo (sometimes)
            "icon": [{
                ...
            }]
        },

 - `rel` is the primary information about the use case of the embeds. Primary rels are Player, Thumbnail, App, Image, Reader, Survey, Summary, Icon and Logo. [See the detailed description of rels](https://iframely.com/docs/links).

 - `meta` will contain list of semantic attributes in unified naming format. See what Iframely unifies as [meta semantics](https://iframely.com/docs/meta).

Array values that only have one element will be wrapped as single object (i.e. without `[]`).

*For open source users:*

 - The API response format of [Iframely open-source](https://github.com/itteco/iframely) is a little different by default as it does not have the links array grouped by rel. This is for legacy reasons. To achieve exact same grouped response as in Cloud API, add `&group=true` to your request.


text:
# ads_block_router

***This scripts for fast block ads on your router***

For block ADS **DD-WRT** open
Administration->Commands->Save Startup
```sh
sleep 5; wget http://winhelp2002.mvps.org/hosts.txt -O - -q | grep <IP_ADDRESS> | sed 's/^\(.*\)#.*$/\1/' > /etc/hosts; killall -HUP dnsmasq
```

For block ADS **OPENWRT**
copy paste your roter in ssh next code:
```sh
cat << 'EOF' > /etc/init.d/ads_block
#!/bin/sh /etc/rc.common
START=99
STOP=99
boot(){
   sleep 10
   start
}
start() {
    echo "starting ADS block"
    wget http://winhelp2002.mvps.org/hosts.txt -O - -q | grep <IP_ADDRESS> | sed 's/^\(.*\)#.*$/\1/'  > /tmp/hosts_ads
    NHOSTS=`uci show dhcp | grep addnhost | wc -l`
    if [ "$NHOSTS" =  "0" ]
    then
        uci add_list<EMAIL_ADDRESS>        uci commit dhcp
    fi
    /etc/init.d/dnsmasq restart
    echo "started ADS"
}
stop() {
    echo "stoping ADS block"
    rm /tmp/hosts_ads
    uci delete<EMAIL_ADDRESS>    uci commit dhcp
    /etc/init.d/dnsmasq restart
    echo "stoped ADS"
}
EOF
chmod +x /etc/init.d/ads_block
/etc/init.d/ads_block enable
/etc/init.d/ads_block start
```

For block ADS **ASUS Merlin**
enable JFFS, copy paste your roter in ssh next code:
```
wget http://winhelp2002.mvps.org/hosts.txt -O - -q | grep <IP_ADDRESS> | sed 's/^\(.*\)#.*$/\1/'  > /jffs/configs/hosts_ads
echo "addn-hosts=/jffs/configs/hosts_ads" > /jffs/configs/dnsmasq.conf.add
```


text:
![Logo](https://raw.github.com/lucaspcamargo/qnite/master/brand/logo.png)

Integration layer for Kinect on Qt. Integrates NiTE2 and OpenNI2 to QtQuick 2 for common usecases.

## Design

![Class Diagram](https://raw.github.com/lucaspcamargo/qnite/master/doc/uml.png)

repository: lucaspcamargo/qnite

repo_name: lucaspcamargo/qnite


text:
---
layout: default
---

# 1995-09-30 - ESM under ULTRIX?

## Header Data

From<EMAIL_ADDRESS>(Dan Bailey)

To<EMAIL_ADDRESS>Message Hash: 02b22ae60ee73ac0b2d0445bb933ba0ba2a4fc7c6da2ab8c3d551dc5c1850872

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1995-09-30 02:15:12 UTC

Raw Date: Fri, 29 Sep 95 19:15:12 PDT

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Dan Bailey)
Date: Fri, 29 Sep 95 19:15:12 PDT
To<EMAIL_ADDRESS>Subject: ESM under ULTRIX?
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

I'm having some trouble getting ESM to work under DEC Ultrix.  Has
anyone gotten this to work?  My first problem was that Ultrix doesn't
understand one of the constants passed to an ioctl.  With the help of
a Linux box, I got the value of the constant and plugged it in.
	Now ESM compiles, says randomizing........, then does a carriage
return and just dies.  Ctrl-C doesn't work, Ctrl-Z doesn't work.
Further I know that it's dying somewhere before the ioctl.  Anyone one
know how to make this work?  For reference,
> uname -a
ULTRIX bigwpi.WPI.EDU 4.5 0 RISC
>

						Dan

***************************************************************
#define private public<EMAIL_ADDRESS>Worcester Polytechnic Institute and The Restaurant at the End of the Universe
***************************************************************

{% endraw %}
```

## Thread

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

+ Return to<EMAIL_ADDRESS>(Dan Bailey)](/authors/dan_at_milliways_org_dan_bailey_)"

+ 1995-09-30 (Fri, 29 Sep 95 19:15:12 PDT) - ESM under ULTRIX? -<EMAIL_ADDRESS>(Dan Bailey)_


text:
---
layout: post
title: "Bugbear Chief"
date: 2017-09-10
tags: [medium, humanoid, cr3, monster-manual]
---

**Medium humanoid (goblinoid), chaotic evil**

**Armor Class** 17 (chain shirt, shield)

**Hit Points** 65 (10d8+20)

**Speed** 30 ft.

|   STR   |   DEX   |   CON   |   INT   |   WIS   |   CHA   |
|:-----:|:-----:|:-----:|:-----:|:-----:|:-----:|
| 17 (+3) | 14 (+2) | 14 (+2) | 11 (0) | 12 (+1) | 11 (0) |

**Skills** Intimidation +2, Stealth +6, Survival +3

**Senses** darkvision 60 ft.

**Languages** Common, Goblin

**Challenge** 3 (700 XP)

***Brute.*** A melee weapon deals one extra die of its damage when the bugbear hits with it (included in the attack).

***Surprise Attack.*** If the bugbear surprises a creature and hits it with an attack during the first round of combat, the target takes an extra 7 (2d6) damage from the attack.

***Heart of Hruggek.*** The bugbear has advantage on saving throws against being charmed, frightened, paralyzed, poisoned, stunned, or put to sleep.

**Actions**

***Multiattack.*** The bugbear makes two melee attacks

***Morningstar.*** Melee Weapon Attack: +5 to hit, reach 5 ft., one target. Hit: 11 (2d8 + 3) piercing damage.

***Javelin.*** Melee or Ranged Weapon Attack: +5 to hit, reach 5 ft. or range 30/120 ft., one target. Hit: 9 (2d6 + 3) piercing damage in melee or 5 (1d6 + 3) piercing damage at range.

gha_language: Vue


text:
# VRM Avatar Editor
Web Application Editting VRM Avatar

This is WIP.
Unintended behavior may occur.

## Usage
1. Access this link.
https://gatosyocora.github.io/vrm-avatar-editor/
2. Select or Drag & Drop VRM file to browser window.
3. Check or Edit avatar.
4. [WIP] Click "Export VRM" if export editted avatar .

## Environment
* Vue.js
* TypeScript

## Library
* three-vrm [[MITLicense](https://github.com/pixiv/three-vrm/blob/dev/LICENSE)]
* core.js [[MITLicense](https://github.com/zloirock/core-js/blob/master/LICENSE)]
* three.js [[MITLicense](https://github.com/mrdoob/three.js/blob/dev/LICENSE)]
* vue.js [[MITLicense](https://github.com/vuejs/vue/blob/dev/LICENSE)]
* vue-class-component [[MITLicense](https://github.com/vuejs/vue-class-component/blob/master/LICENSE)]
* vue-property-decorator [[MITLicense](https://github.com/kaorun343/vue-property-decorator/blob/master/LICENSE)]
* vue-router [[MITLicense](https://github.com/vuejs/vue-router/blob/dev/LICENSE)]
* vuetify [[MITLicense](https://github.com/vuetifyjs/vuetify/blob/master/LICENSE.md)]


text:
How to contribute
============================================

1. Open issues and tag them appropriately based on bug/feature request etc
2. Follow PEP-8 compliance for code review
3. `py.test` is used for testing, write integration/unit tests where necessary
4. +1 required by @csanders-git or @zmallen for merge
5. CI (eventually) required for merge

FTW contributors (sorted alphabeticaly)
============================================

* **[Chaim Sanders](https://github.com/csanders-git)**

  * HTTP request/response parser
  * Rule Design

* **[Ezekiel Templin](https://github.com/ezkl/)**

	* Rule design
  * Documentation

* **[Jared Stroud](https://github.com/jaredestroud/)**
  * HTTP Library

* **[Zack Allen](https://github.com/zmallen/)**

  * Rule design
  * Testing format
  * Framework refactoring
  * Error handling


text:
# Nonlinear Optimization Algorithms Multilang [![Build Status](https://travis-ci.org/rgolubtsov/nonlinear-optimization-algorithms-multilang.svg?branch=master)](https://travis-ci.org/rgolubtsov/nonlinear-optimization-algorithms-multilang)

The following implementations are on the workbench (:small_blue_diamond: – complete, :small_orange_diamond: – planned/postponed, :cd: – in progress):

* The Hooke and Jeeves (original) :small_blue_diamond: **Traditional (K&R) C**: `nlp-unconstrained-cli/hooke-jeeves/__orig/`
* The Hooke and Jeeves :small_blue_diamond: **ISO C (C99)**: `nlp-unconstrained-cli/hooke-jeeves/c/`
* The Hooke and Jeeves :small_blue_diamond: **ISO C++ (C++98)**: `nlp-unconstrained-cli/hooke-jeeves/cc/`
* The Hooke and Jeeves :small_blue_diamond: **Objective-C 2.0**: `nlp-unconstrained-cli/hooke-jeeves/objc/`
* The Hooke and Jeeves :small_blue_diamond: **FORTRAN 77 (MIL-STD 1753)**: `nlp-unconstrained-cli/hooke-jeeves/f77/`
* The Hooke and Jeeves :small_blue_diamond: **ISO Fortran 95**: `nlp-unconstrained-cli/hooke-jeeves/f95/`
* The Hooke and Jeeves :small_blue_diamond: **Perl 5 (5.10+)**: `nlp-unconstrained-cli/hooke-jeeves/perl/`
* The Hooke and Jeeves :small_blue_diamond: **JavaScript (ECMA-262 5.1)**: `nlp-unconstrained-cli/hooke-jeeves/js/`
* The Hooke and Jeeves :small_blue_diamond: **Java (Java SE 7)**: `nlp-unconstrained-cli/hooke-jeeves/java/`
* The Hooke and Jeeves :small_blue_diamond: **Go**: `nlp-unconstrained-cli/hooke-jeeves/go/`
* The Hooke and Jeeves :small_blue_diamond: **Python 2 & 3**: `nlp-unconstrained-cli/hooke-jeeves/python/`
* The Hooke and Jeeves :small_blue_diamond: **Vala**: `nlp-unconstrained-cli/hooke-jeeves/vala/`

---

* The Nelder-Mead (original) :small_blue_diamond: **FORTRAN 77 (MIL-STD 1753)**: `nlp-unconstrained-cli/nelder-mead/__orig/`
* The Nelder-Mead :small_blue_diamond: **ISO C (C99)**: `nlp-unconstrained-cli/nelder-mead/c/`

---

This project is aimed at implementing nonlinear programming algorithms as the (un-)constrained minimization problems with the focus on their numerical expression using various programming languages.

The idea behind is to collect some of nonlinear programming (NLP) algorithms/methods which are well known and developed, and when they have low or moderate level of complexity during their coding in programming languages in an analytical form. Furthermore, such NLP-algorithms will have to be applied to one or more test problems in numerical expression, and then the user will be able to get solutions for those problems and watch the digits.

All of these algorithms should be coded in a series of programming languages. Not every subsequent selected algorithm must be implemented in every particular language chosen for the previous one, but in some of them (the standard C is an exception) which are widely used nowadays. The main requirement here is the resulting output containing the solution for any kind of test problem must be the same for all implementations. I.e. output blocks made after computations produced by the C code, Java code, Fortran code and so on should be identically equal each other with respect to computed precision, precision expression, layout and spacing emitted to standard out (or user console).

*Consider this project as a somewhat __educational__ approach to the subject of implementing math algorithms in programming languages rather than it might be considered otherwise as bringing something important to scientific applications and investigations.*

Why NLP-algorithms, exactly? – The answer is why not? Indeed, NLP optimization methods and techniques are widely used everywhere. Their complexity ranges are quite different. They are suitable and fit the most optimization models more precisely and accurately than their linear optimization counterparts. – That's why.

There are two main conventional groups of NLP optimization methods: constrained and unconstrained. In this project it is considered to be implemented first two unconstrained minimization methods: (1) The algorithm of **Hooke and Jeeves** and (2) The **Nelder-Mead** algorithm.

 But it's planned they have to be created and populated accordingly somewhen during development process.

---

**TODO:** Extend the **Overview** section and provide other related sections (design, building, running, etc.) just like in [this readme doc](https://github.com/rgolubtsov/virtblkiosim/blob/master/README.md "VIRTual BLocK IO SIMulating (virtblkiosim)") or whatsoever. :cd:

license: Unlicense

gha_language: C

gha_license_id: Unlicense


text:
# Hints

A [doubly linked list](https://en.wikipedia.org/wiki/Doubly_linked_list) is a mutable data structure. As F# is a functional-first language, immutability is generally preferred, but there are language features that allow the use of mutation where it is required.

- The `mutable` keyword can be placed before `let` bindings and [record](https://docs.microsoft.com/en-us/dotnet/articles/fsharp/language-reference/records) fields, allowing you to assign new values to them.

- [Class](https://fsharpforfunandprofit.com/posts/classes) properties can be made mutable by specifying a property setter with the `set` keyword.

Mutable bindings must be re-assigned with `<-`

```fsharp
let mutable x = "initial value"
x <- "new value"
```

repository: exercism/fsharp

gha_language: F#

repo_name: exercism/fsharp


text:
# SonarQube Ansible role

![Basic role syntax check](https://github.com/nemonik/sonarqube-role/workflows/Basic%20role%20syntax%20check/badge.svg)

An Ansible role for ensuring the configuration of [SonarQube](https://www.sonarqube.org/).

## Requirements

Requires Kubernetes, MetalLb and private Docker Registry installed.

## Role Variables

| Variable                   | Required | Default         | Choices       | Comments                                         |
|----------------------------|----------|-----------------|---------------|--------------------------------------------------|
| docker_timeout             | yes      | 300             | Integer value | Number of seconds before docker pull timeout     |
| docker_retries             | yes      | 60              | Integer value | Number of tries for docker pull                  |
| docker_delay               | yes      | 10              | Integer value | Delay in seconds between pull retries            |
| default_retries            | yes      | 60              | Integer value | Default number of retries                        |
| default_delay              | yes      | 60              | Integer value | Default delay in seconds between retries         |
| gitlab_host                | no       | not defined     | IP address    | If define will integrate authentication with     |
| gitlab_port                | no       | not defined     | Integer value | If defined will integrate authentication with    |
| vault_gitlab_root_password | no       | not defined     | String value  | Needed for integration with GitLab               |
| sonarqube_version          | yes      | 8.3.1-community | version       | Docker image tag                                 |
| sonarqube_host             | yes      | <IP_ADDRESS>   | ip address    | IP address                                       |
| sonarqube_port             | yes      | 9000            | Integer value | The port to listen on                            |
| images_cache_path          | no       | not defined     | Path          | Path to folder used to cache saved Docker images |

## Example Playbook

An example can be found used in my Hands-on DevOps course's [ansible/master-playbook.yml](https://github.com/nemonik/hands-on-DevOps/blob/master/ansible/master-playbook.yml).

```
- hosts: masters
  remote_user: vagrant
  roles:
    - k3s-server
    - docker-registry
    - metallb
    - gitlab
    - sonarqube
```

The above Ansible playbook uses my [K3s-server role](https://github.com/nemonik/k3s-server-role) to install Lightweight Kubernetes (K3s), my [metallb role](https://github.com/nemonik/metallb-role) to install MetalLB and my [Docker Registry role](https://github.com/nemonik/docker-registry-role) to install a private Docker registry.

For more information and to see this role put into action checkout my [Hands-on DevOps class](https://github.com/nemonik/hands-on-DevOps) project.

## License

3-Clause BSD License

## Author Information

Michael Joseph Walsh<EMAIL_ADDRESS>

repository: nemonik/sonarqube-role

repo_name: nemonik/sonarqube-role


text:
[![Join our Telegramm group](https://img.shields.io/badge/Join%20us-Telegram-blue?&logo=telegram&?link=http://right&link=http://t.me/artipie)](http://t.me/artipie)

[![EO principles respected here](https://www.elegantobjects.org/badge.svg)](https://www.elegantobjects.org)
[![DevOps By Rultor.com](http://www.rultor.com/b/artipie/vertx-server)](http://www.rultor.com/p/artipie/vertx-server)
[![We recommend IntelliJ IDEA](https://www.elegantobjects.org/intellij-idea.svg)](https://www.jetbrains.com/idea/)

[![Javadoc](http://www.javadoc.io/badge/com.artipie/vertx-server.svg)](http://www.javadoc.io/doc/com.artipie/vertx-server)
[![License](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/artipie/vertx-server/blob/master/LICENSE)
[![codecov](https://codecov.io/gh/artipie/vertx-server/branch/master/graph/badge.svg)](https://codecov.io/gh/artipie/vertx-server)
[![Hits-of-Code](https://hitsofcode.com/github/artipie/vertx-server)](https://hitsofcode.com/view/github/artipie/vertx-server)
[![Maven Central](https://img.shields.io/maven-central/v/com.artipie/vertx-server.svg)](https://maven-badges.herokuapp.com/maven-central/com.artipie/vertx-server)
[![PDD status](http://www.0pdd.com/svg?name=artipie/vertx-server)](http://www.0pdd.com/p?name=artipie/vertx-server)

This is a http server based on [HttpServer](https://vertx.io/docs/apidocs/index.html?io/vertx/reactivex/core/http/HttpServer.html)
from [Vert.x Core](https://vertx.io/docs/vertx-core/java/), used by [artipie](https://github.com/artipie/artipie)
project and by some artipie`s adapters (for example, [maven-adapter](https://github.com/artipie/maven-adapter),
[rpm-adapter](https://github.com/artipie/rpm-adapter)) to implement integration tests.

This is the dependency you need:

```xml
<dependency>
  <groupId>com.artipie</groupId>
  <artifactId>vertx-server</artifactId>
  <version>[...]</version>
</dependency>
```

Read the [Javadoc](http://www.javadoc.io/doc/com.artipie/vertx-server)
for more technical details.
If you have any question or suggestions, do not hesitate to [create an issue](https://github.com/artipie/vertx-server/issues/new) or contact us in
[Telegram](https://t.me/artipie).
Artipie [roadmap](https://github.com/orgs/artipie/projects/3).

## Usage example

```java
final Vertx vertx = Vertx.vertx();
final int port = 8080;
final Slice slice = ...; // some Slice implementation
final VertxSliceServer server = new VertxSliceServer(vertx, slice, port);
server.start();
```

## How to contribute

Please read [contributing rules](https://github.com/artipie/artipie/blob/master/CONTRIBUTING.md).

Fork repository, make changes, send us a pull request. We will review
your changes and apply them to the `master` branch shortly, provided
they don't violate our quality standards. To avoid frustration, before
sending us your pull request please run full Maven build:

```
$ mvn clean install -Pqulice
```

To avoid build errors use Maven 3.2+.

repository: olenagerasimova/vertx-server

repo_name: olenagerasimova/vertx-server


text:
# functional-programming-scala-practical2
📚 Functional Programming Languages : Lecture 2 (Scala)

**Sometime back I wrote a [blog series on Scala](http://renien.com/articles/introduction-to-scala/). I hope it will help you to understand more about Scala and Functional Programming.**

You can find [Functional Programming Languages : Lecture 1 (Scala)](https://github.com/Renien/functional-programming-scala-practical1).


text:
---
layout: post
title: Plushy Redux
subtitle: A program to produce the expected results for my Plushy led project
tags: [projects, electronic textiles, computer science, coding]
comments: true
---
For this project I created a program that, depending on the status of the button and switch, produced the same results as [the physical plushy led project I sewed](https://hannahtager.github.io/2019-09-30-Plushy/).

A user can input either 0 (off) or 1 (on) for the status of the button and the switch. All leds should light up only in the case that both the button and switch are on. Otherwise, the three leds should not work.

As a tip to my former self, I would be more careful with indentation. Correctly indenting can be very helpful with nested ifs.

![Screenshot of the output of Hannah's plushy redux program](https://hannahtager.github.io/img/plushyReduxOutput.png)


text:
---
layout: creature
name: "Infernal Enforcer"
tags: [medium, humanoid, cr5, nerzugals-extended-bestiary]
cha: 19 (+4)
wis: 15 (+2)
int: 10 (+0)
con: 14 (+2)
dex: 16 (+3)
str: 12 (+1)
size: Medium humanoid (any race)
alignment: any alignment
challenge: "5 (1,800 XP)"
languages: "Any three languages"
skills: "Acrobatics +7, Arcana +4, Insight +6, Persuasion +8"
senses: "passive Perception 12"
saving_throws: "Wis +6, Cha +8"
speed: "40 ft."
hit_points: "78 (12d8 + 24)"
armor_class: "15"
---

***Infernal Blade.*** The enforcer has an infernal blade
bound to it. This weapon ignores all resistances and
deals an extra 3 (1d6) fire damage with each attack
(included in the attack). In addition, while the
enforcer is wielding this blade, it cannot be
disarmed.

***Spellcasting.*** The enforcer is a 6th-level spellcaster.
Its spellcasting ability is Charisma (spell save DC
16, +8 to hit with spell attacks). It regains these
expended spellslots when it finishes a short or long
rest. The enforcer has the following warlock spells
prepared:

* Cantrips (at will): blade ward, eldritch blast, mage hand

* 1st-3rd level (3 3rd-level slots): armor of Agathys, crown of madness, fear, hellish rebuke, hex, spider climb

### Actions

***Multiattack.*** The enforcer makes two attacks with its
felblade and one with its felstrike.

***Felblade.*** Melee Weapon Attack: +7 to hit, reach 5
ft., one target. Hit: 6 (1d6 + 3) piercing damage
plus 3 (1d6) fire damage.

***Felstrike.*** Melee Weapon Attack: +7 to hit, reach 5
ft., one target. Hit: 6 (1d6 + 3) bludgeoning
damage plus 3 (1d6) fire damage.

***Infernal Onslaught (3/Short Rest).*** The enforcer
performs a swift series of punches to launch bursts
of flame at up to four targets within 60 feet. Each
of those creatures must make a DC 16 Dexterity
saving throw, saving 17 (5d6) fire damage on a
failed save, or half as much damage on a successful
save.

repository: krfurlong/bestiary

gha_language: HTML

gha_license_id: NOASSERTION

repo_name: krfurlong/bestiary


text:
How to Contribute
=================

This project welcomes your contribution. There are several ways to help out:

* Create an [issue](https://github.com/jaymoulin/jdownloader/issues/) on GitHub,
if you have found a bug or have an idea for a feature
* Write test cases for open bug issues
* Write patches for open bug/feature issues

Issues
------

* Submit an [issue](https://github.com/jaymoulin/jdownloader/issues/)
  * Make sure it does not already exist.
  * Clearly describe the issue including steps to reproduce, when it is a bug.
  * Make sure you note the version you use.

Additional Resources
--------------------

* [Existing issues](https://github.com/jaymoulin/jdownloader/issues/)
* [General GitHub documentation](https://help.github.com/)
* [GitHub pull request documentation](https://help.github.com/send-pull-requests/)

repository: jaymoulin/docker-jdownloader

repo_name: jaymoulin/docker-jdownloader


text:
This module powers the Shipp suite.

Warning: This is used for a single personal project. It is not and won't be supported.

## Development Container

* For M1 Macs, BuildX enables builds for ARM processors. It must be installed.
`$ docker buildx install`

* Build the container and specify the platform (it will use buildx)
`$ docker build --platform linux/arm64/v8 -t shipp-server .`

* Enter the development environment
`$ ./dev.sh`

repository: shippjs/shipp-server

gha_language: JavaScript

repo_name: shippjs/shipp-server


text:
# vidi-lang
The Vidi Programming Language is a language I designed. This repository contains the code for an interpreter I made for
this language. The interpreter is made in C++. Learn more about the language at the site below:

https://samuelhoward.github.io/vidi-site/

After cloning this repository, you can start running Vidi code after running `make` by using `./vidic <ProgramName.vd>`. Example programs are in the
`Examples` directory. If you make local changes to the language, simply run `make` to rebuild the interpreter. You will of course
need to be able to use gcc and make to be able to do this.

repository: SamuelHoward/vidi-lang

repo_name: SamuelHoward/vidi-lang


text:
# Eclipse

To view / edit Java source files from Eclipse:
 - Create a new Java Project
 - Untick "Use default location"
 - Browse to the jdk/ folder, which contains the src, make and test folders. For example /home/openjdk/dev/jdk9/jdk on a Ubuntu VM, or smb://server/user/dev/jdk9/jdk if you are using a [share from VM into the host machine](../virtual-machines/sharing_host_folder_with_guest_vm.md). Press OK and be patient.
 - Alternatively choose a sub-folder of the above, such as java.base/share/classes to work with a smaller sub-set.

Un-tick Eclipse's **Build automatically** setting to prevent build errors.


text:
### foo
Type: `String`
Default value: `undefeined`

A string value that is used to do something with whatever.

### bar
Type: `Array`
Default value: `[]`

A string value that is used to do something else with whatever else.

## Usage Examples

### Example foo
Transform a string with an object of replacement patterns

```js
frep.strWithObj(String, Object)
```

Parameters:

* `String`: The string to modify with the given replacement patterns.
* `Object`: Object of replacement patterns, where each key is a string or a RegExp `pattern`, and each value is the `replacement` string or function to be called for each match.
* A new string is returned with some or all matches replaced by the given replacement patterns.

Given the following:

```js
var frep = require('frep');

var str = 'ABC'
var replacements = {
  'A': 'AAA',
  'B': 'BBB',
  'C': 'CCC',
  'D': 'DDD',
  'E': 'EEE',
  'F': 'FFF'
};

frep.strWithObj(str, replacements));
// => AAABBBCCC
```

repository: jonschlinkert/grunt-readme

repo_name: jonschlinkert/grunt-readme


text:
# jsStorage
A simple javascript library to use as storage with the same API the :
 * localStorage
 * sessionStorage
 * cookies
 * window.name

## How to use it

All jsStorage's storages have the same methods with the localStorage Object, plus some shortcuts of them.
So it is really easy to use them.

### Add the script in your page

First you need to insert jsStorage on your page.

You can add it on your page's head or body.

```html
<script src="jsStorage-0.2.0.min.js"></script>
```

### jsStorage call

You can call jsStorage using the variables *jS* or *jsStorage*.

For example lets set up a cookie storage.

```javascript
// Using the jS
var cookieStorage = new jS('cookie');
// Save a value
cookieStorage.setItem("name", "test-value");
// Get a value
var value = cookieStorage.getItem("name");
console.log(value); // Outputs : test-value
```

Also a ready to use object with all the storages can be accesed from the variable *storage*.

```javascript
// Using the storage variable to store a cookie
storage.cookieStorage.setItem("name", "test-value");
// Or something on localStorage
storage.localStorage.setItem("name", "test-value");
// sessionStorage is also here
storage.sessionStorage.setItem("name", "test-value");
// and also the tab session storage hack "window.name" (cross-domain)
storage.windowNameStorage.setItem("name", "test-value");
```

The *storage* variable has as default storage the localStorage or if it is not supported,
it loads the cookieStorage for compatibility.

```javascript
// Save something on localStorage or is it not supported on cookieStorage
storage.setItem("name", "test-value");

// Check the storage type
if(typeof window.localStorage !== "undefined")
  console.log(storage.type()); // Outputs : local
else
  console.log(storage.type()); // Outputs : cookie
```

If any of these variables is not availiable, jsStorage will not override them. So you can easily use use jsStorage with other libraries.

```html
<script>
	// Variable storage is defined
	var storage = "something";
</script>

<!-- Load jsAppend -->
<script src="jsStorage-0.2.0.min.js"></script>

<script>
	// Print storage
	console.log(storage); // Output : "something"
</script>
```

### jsStorage storages

As you have already understund, the jsStorage ports the *cookies* and the *window.name* to localStorage like Objects
and extends the localStorage and the sessionStorage for simple usage.

We have 4 storages :
* `localStorage` the localStorage storage
* `sessionStorage` the sessionStorage storage
* `cookieStorage` a port of the cookie mechanic on a localStorage like object
* `windowNameStorage` a port of the window.name storage mechanic on a localStorage like object

And also we have a defaultStorage object for fast accesing the selected storage.
* `defaultStorage` the sellected storage to use by default

#### defaultStorage

The *defaultStorage* is the storage set as active on a jsStorage instance.

```javascript
// Use localStorage by default
var s = new jsStorage('local');
// Default setItem in local storage
s.setItem("test", "a"); // Saved in localStorage

// Change default storage to cookie
s.useCookieStorage();
// Now default storage is cookies
s.setItem("test", "b"); // Saved as a cookie

// Access a specific storage
s.localStorage.getItem("test"); // Returns a
```

##### defaultStorage's methods

* defaultStorage.setItem(name, value);
* defaultStorage.set(name, value);
* defaultStorage.getItem(name);
* defaultStorage.get(name);
* defaultStorage.removeItem(name);
* defaultStorage.remove(name);
* defaultStorage.del(name);
* defaultStorage.key(n);
* defaultStorage.length();
* defaultStorage.clear();
* defaultStorage.type();

##### localStorage's methods

* localStorage.setItem(name, value);
* localStorage.set(name, value);
* localStorage.getItem(name);
* localStorage.get(name);
* localStorage.removeItem(name);
* localStorage.remove(name);
* localStorage.del(name);
* localStorage.key(n);
* localStorage.length();
* localStorage.clear();
* localStorage.type();
* localStorage.setDomain(domain);

##### sessionStorage's methods

* sessionStorage.setItem(name, value);
* sessionStorage.set(name, value);
* sessionStorage.getItem(name);
* sessionStorage.get(name);
* sessionStorage.removeItem(name);
* sessionStorage.remove(name);
* sessionStorage.del(name);
* sessionStorage.key(n);
* sessionStorage.length();
* sessionStorage.clear();
* sessionStorage.type();
* sessionStorage.setDomain(domain);

##### cookieStorage's methods

* cookieStorage.setItem(name, value);
* cookieStorage.set(name, value);
* cookieStorage.getItem(name);
* cookieStorage.get(name);
* cookieStorage.removeItem(name);
* cookieStorage.remove(name);
* cookieStorage.del(name);
* cookieStorage.key(n);
* cookieStorage.length();
* cookieStorage.clear();
* cookieStorage.type();
* cookieStorage.setDomain(domain);

##### windowNameStorage's methods

* windowNameStorage.setItem(name, value);
* windowNameStorage.set(name, value);
* windowNameStorage.getItem(name);
* windowNameStorage.get(name);
* windowNameStorage.removeItem(name);
* windowNameStorage.remove(name);
* windowNameStorage.del(name);
* windowNameStorage.key(n);
* windowNameStorage.length();
* windowNameStorage.clear();
* windowNameStorage.type();
* windowNameStorage.setDomain(domain);
* windowNameStorage.setPath(path);
* windowNameStorage.setExpiration(days);

repository: GramThanos/jsStorage

repo_name: GramThanos/jsStorage


text:
# GraphMetrics
[![Go Reference](https://pkg.go.dev/badge/github.com/graphmetrics/graphmetrics-go.svg)](https://pkg.go.dev/github.com/graphmetrics/graphmetrics-go)
[![Go Version](https://img.shields.io/github/go-mod/go-version/graphmetrics/graphmetrics-go)](https://github.com/GraphMetrics/graphmetrics-go)
[![Go Report](https://goreportcard.com/badge/github.com/GraphMetrics/graphmetrics-go)](https://goreportcard.com/report/github.com/GraphMetrics/graphmetrics-go)

This is the Go SDK for GraphMetrics.

## Usage
We provide middlewares that are easily to plug in your server.
If your server is not currently supported, please open an issue so we can fix that.

### gqlgen
```go
import (
    "github.com/99designs/gqlgen/graphql/handler"
    "github.com/graphmetrics/graphmetrics-go"
    graphmetricsgqlgen "github.com/graphmetrics/graphmetrics-go/gqlgen"
)
var srv *handler.Server

gm := graphmetricsgqlgen.NewExtension(&graphmetrics.Configuration{
	// SEE CONFIGURATION SECTION
})
defer gm.Close() // Keep a reference to the extension and call Close on server shutdown

srv.Use(gm)
```

## Configuration
The SDK needs a few elements to be properly configured using the `graphmetrics.Configuration`.

- `ApiKey`: Your environment api key
- `ServerVersion`: (Optional) The version of the server, necessary to catch regressions between releases
- `ClientExtractor`: (Optional) Function that retrieves the client details from the context, necessary to differentiate queries coming from different clients
- `Logger`: (Optional) A structure logger that respects the interface, otherwise golang "log" is used. Adapters are provided for popular logger, see the [logger-go package](https://github.com/GraphMetrics/logger-go).

### Client extractor

The client extractor fetches the client details from the context. By default, no details are fetched.
We provide helper functions for the Apollo client, please let us know if you would like to see other clients supported.

The first step of the extraction is to add the `http` middleware to your server.
The exact way of doing that depends on your server implementation, but generally looks like:
```go
import (
    "github.com/go-chi/chi"
    "github.com/graphmetrics/graphmetrics-go/client"
)

r := chi.NewRouter()

r.Use(client.ApolloMiddleware)
```

Then you can pass the extractor function in the configuration:
```go
graphmetrics.Configuration{
    ClientExtractor: client.ApolloExtractor,
}
```

### Advanced configuration

- `FieldBufferSize`: As we do not want to slow down your queries, we process the field metrics async in a goroutine with a buffered channel in between.
Usually this buffer is big enough to handle spikes, but it might not be if you have very large and fast queries.
In which case, metrics are dropped and a warning is emitted. Please contact us if that happens and try increasing the buffer in the meantime.
- `OperationBufferSize`: Same as `FieldBufferSize` but for operations.
- `StopTimeout`: Change the maximum time the plugin will wait for sending the last metrics when the server is stopping.
We suggest leaving it at default (10s) unless you need to kill your process faster.

repository: GraphMetrics/graphmetrics-go

repo_name: GraphMetrics/graphmetrics-go


text:
# Personalized Drug Target Inference via Network Propagation

by Ortal Shnaps & Eyal Perry.

Application of the method described in http://psb.stanford.edu/psb-online/proceedings/psb16/shnaps.pdf

To run: ./inferer.py

See inferer.py source for configurations and data sources.