text:
# relative-path

Portable, relative paths for Rust.

[![Build Status](https://api.travis-ci.org/udoprog/relative-path.svg?branch=master)](https://travis-ci.org/udoprog/relative-path)
[![Build status](https://ci.appveyor.com/api/projects/status/x2spyavt5fe6lbeq?svg=true)](https://ci.appveyor.com/project/udoprog/relative-path/branch/master)

[Documentation](https://docs.rs/relative-path)

## Relative Paths

This library provides two structures: `RelativePath` and `RelativePathBuf`.
These are analogous to the `Path` and `PathBuf` structures provided through standard Rust.

While `Path` provides an API that adapts to a given platform, `RelativePath` does not, making the
representations it provide platform-neutral.

The representation of Rust's `Path` is not portable since it permits different things across
platforms.

Windows permit using drive volumes (e.g. `"c:\"`) and backslash (`\`) as a separator.
Using this to store relative paths would make it possible for software developers working to target
Windows to build projects which work on their platform, but not others.

`RelativePath` only uses `/` as a separator. Anything else will be considered part of distinct
components.

Conversion to `Path` can only happen if it is known which path it is relative to, through the
`to_path` function. This is where the 'relative' part of the name comes from.

```rust
let relative_path = RelativePath::new("foo/bar");
let path = Path::new("C:\\");
let full_path = relative_path.to_path(path);
```

This would for example, permit relative paths to portably be used in project manifests or
configurations, where files are references from some specific, well-known point in the filesystem.

The following is a simple example configuration for a made up project:

```toml
lib = "src/lib.rs"
bin = "src/bin/hello.rs"
```

The corresponding Rust struct could look like this:

```rust
#[derive(Deserialize)]
pub struct Manifest {
    lib: RelativePathBuf,
    bin: RelativePathBuf,
}
```

## Portability Note

`RelativePath`, similarly to `Path`, makes no guarantees that the components represented in them
makes up legal file names.

`NUL` is not permitted on unix platforms - this is a terminator in C-based filesystem APIs. Slash
(`/`) is also used as a path separator.

Windows has a number of [reserved characters][windows].

[windows]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx

## TODO

 * Verify that relative paths are - indeed - portable.
 * Better function documentation with examples.
 * Support more `Path`-like functions.

repository: ratmice/relative-path

repo_name: ratmice/relative-path


text:
# String splitting

TODO: ADD MORE

- The example solution uses `str.split()` to break the passed in markdown string into a list of lines broken up by the `\n` character. The alternate Python example solution uses `str.splitlines()` for the same effect across all line end characters. [markdown](../exercise-concepts/markdown.md)
- the example uses `str.split` with and without seperators to break the passed in string into "rows" and then "elements" [matrix](../exercise-concepts/matrix.md)

repository: exercism/python

branch_name: refs/heads/main

extension: md

gha_language: Python

gha_license_id: MIT

license_type: permissive

repo_name: exercism/python


text:
## Technical Phone Interview
----

1. What is overfitting?
Ans.
   - Model remembering the training data and not performing well on the test data is called overfitting.

2. When do you know overfitting has occurred without looking at the test data?
Ans.
   - We can use validation set to see if the model overfits the training data.
   - If validation error graph is more then training error graph then model overfits the training data.

3. How to prevent over-fitting?
Ans.
   - We can prevent over-fitting by regularization.

4. What are the types of regularization?
Ans.
   - Dropouts and L2 regularization are some types of regularizations

5. What are Dropouts?
Ans.
   - The signal from some of the nodes are skipped.
   - This prevents weights from exploding or having higher value.

6. What is batch-normalization?
Ans.
	- batch-normalization is a normalization of the batch data being processed
   - If the data in it's raw format is normalized to get good results then same is the idea to normalize the data in the intermediary layers

7. Why do we use batch-normalization?
Ans.
    - It helps in reducing the training time and getting fast towards the global minima.

license: MIT

repository: sweetpand/Algorithms

path: /InterviewChallenges/Deep Learning Engineer Interview/SelfDrivingCarEngineer/Technical Phone Interview/README.md

branch_name: refs/heads/master

repo_name: sweetpand/Algorithms


text:
# Simple Linear Example

This example is showing a Predictive Horizontal Pod Autoscaler (PHPA) using a linear regression model.

## Requirements

To set up this example and follow the steps listed here you need:

- [kubectl](https://kubernetes.io/docs/tasks/tools/).
- A Kubernetes cluster that kubectl is configured to use - [k3d](https://github.com/rancher/k3d) is good for local
testing.
- [helm](https://helm.sh/docs/intro/install/) to install the PHPA operator.
- [jq](https://stedolan.github.io/jq/) to format some JSON output.

## Usage

If you want to deploy this onto your cluster, you first need to install the Predictive Horizontal Pod Autoscaler
Operator, follow the [installation guide for instructions for installing the
operator](https://predictive-horizontal-pod-autoscaler.readthedocs.io/en/latest/user-guide/installation).

This example was based on the [Horizontal Pod Autoscaler Walkthrough](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale-walkthrough/).

1. Run this command to spin up the app/deployment to manage, called `php-apache`:

```bash
kubectl apply -f deployment.yaml
```

2. Run this command to start the autoscaler, pointing at the previously created deployment:

```bash
kubectl apply -f phpa.yaml
```

3. Run this command to see the autoscaler working and the log output it produces:

```bash
kubectl logs -l name=predictive-horizontal-pod-autoscaler -f
```

4. Run this command to increase the load:

```bash
kubectl run -i --tty load-generator --rm --image=busybox --restart=Never -- /bin/sh -c "while sleep 0.01; do wget -q -O- http://php-apache; done"
```

5. Watch as the number of replicas increases.
6. Run this command to see the replica history for the autoscaler stored in a configmap and tracked by the autoscaler:

```bash
kubectl get configmap predictive-horizontal-pod-autoscaler-simple-linear-data -o=json | jq -r '.data.data | fromjson | .modelHistories["simple-linear"].replicaHistory[] | .time,.replicas'
```

As the load is increased the replica count will increase as the PHPA detects average CPU utilization of the pods has
gone above 50%, so will provision more pods to try and bring this value down. As the replica count changes the PHPA
will store the history of replica changes that have been made, and will feed this data into the linear regression model
every time the autoscaler runs too. This results in two values, the raw replica count calculated at the instant the
autoscaler has run, and a predicted value that the model has calculated based on the replica count history. The resource
will then be scaled to the greater of these two values (though there are other options than picking the maximum, see
the [decisionType configuration option for more
details](https://predictive-horizontal-pod-autoscaler.readthedocs.io/en/latest/reference/configuration/#decisiontype)).

An example of how this predictive scaling looks is this graph:

![Calculated HPA values vs linear regression predicted values](../../docs/img/getting_started_linear_regression.svg)

This shows the replica count decreasing, with the raw calculated replica counts and predicted replica counts compared.
As the raw calculated replica count drops of drastically the linear regression takes a smoother scale down approach
based on calculated history.

## Explained

This example uses the following YAML to define the autoscaler:

```yaml
apiVersion: jamiethompson.me/v1alpha1
kind: PredictiveHorizontalPodAutoscaler
metadata:
  name: simple-linear
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: php-apache
  minReplicas: 1
  maxReplicas: 10
  behavior:
    scaleDown:
      stabilizationWindowSeconds: 0
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          averageUtilization: 50
          type: Utilization
  models:
    - type: Linear
      name: simple-linear
      linear:
        lookAhead: 10000
        historySize: 6
```

- `scaleTargetRef` is the resource the autoscaler is targeting for scaling.
- `minReplicas` and `maxReplicas` are the minimum and maximum number of replicas the autoscaler can scale the resource
between.
- `syncPeriod` is how frequently this autoscaler will run in milliseconds, so this autoscaler will run every 10000
milliseconds (10 seconds).
- `behavior.scaleDown.stabilizationWindowSeconds` handles how quickly an autoscaler can scale down, ensuring that it
will pick the highest evaluation that has occurred within the last time period described, by default it will pick the
highest evaluation over the past 5 minutes. To stop this from happening we have set the downscale stablilization to
`0` to disable it.
- `metrics` defines the metrics that the PHPA should use to scale with, in this example it will try to keep average
CPU utilization at 50% per pod.
- `models` contains the statistical models we're applying to the resulting replica count, this this example it's just
a linear regression model that stores the past 6 replica counts (`historySize: 6`) and uses that to predict what the
replica count will be 10000 milliseconds (10 seconds) in the future (`lookAhead: 10000`).

gha_language: Go


text:
# Monochaetia (Saccardo) Allescher, 1902 GENUS

#### Status
ACCEPTED

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

#### Published in
Rabenh. Krypt. -Fl. (Leipzig), Edn 2 1(7): 665 (1902)

#### Original name
null

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
## About

The Fragment Audio Server is a program written with the C language which is able to do very fast real-time audio synthesis.

It is recommended to use Fragment with the Fragment Audio Server enabled

The advantage of using the audio server is that it provide the **best audio performances** along with **audio devices choice**, **multiple audio outputs**, sample rate choice, **granular synthesis** / sampler, subtractive and PM synthesis method, **distributed sound synthesis** over multiple machines or cores, realtime scheduling under Linux and more...

The Fragment web-client communicate with FAS by sending data through the network when the FAS option (the waveform icon in the main toolbar) is enabled, FAS can run on any machines independently of the Fragment application, it gather the pixels data from Fragment in real-time, compute things and deliver the audio through the selected audio device.

On the [Raspberry PI](https://www.raspberrypi.org) ~700 additive synthesis oscillators can play at the same time with an optimized system

## How-to

FAS audio server is packaged with the graphical launcher which can be downloaded on the Fragment [homepage](https://www.fsynth.com/).

The graphical launcher provide a graphical user interface to configure the audio server settings **per sessions**, it also allow to start the audio server & the web client easily.

![FGL: Fragment Graphical Launcher](images/fgl.png)

### Quick launch

1. Add a session by clicking on the [+] button (the launcher save settings per sessions)
2. Select the created session by clicking on it
3. Check "Start app. when server start"
4. Click on the "Start" button to launch the session, the audio server should start and the web client should start as well

### Manual launch

The audio server can be compiled from the sources which are available on [GitHub](https://github.com/grz0zrg/fas).

The audio server can be launched manually by executing it, it will listen to <IP_ADDRESS>:3003 by default and will use the default audio device, see the [GitHub](https://github.com/grz0zrg/fas) README file for all the command-line arguments that the program support.

Once the audio server is started, a link between the audio server and the Fragment application has to be done, the connection can be enabled/disabled by clicking on the waveform icon on the main toolbar.

repository: erlscript/fsynth

repo_name: erlscript/fsynth


text:
### > "Hello world"

I am a fat and balding middle-age man living in the sunny island-city
[Singapore](https://en.wikipedia.org/wiki/Singapore).

> PS: It is not part of [China](https://en.wikipedia.org/wiki/China)!

I am officially known as [`William`](https://www.babynames.com/name/william),
but a lot of my friends also know me as `eterna2` or `e2` for short.

#### Cats :heart_eyes_cat:

I love animals! I have 5 :smile_cat: at home and used to look after the
community :smirk_cat: in my area (until they all passed away :crying_cat_face:).

![Kopi & Horlicks](https://github.com/eterna2/eterna2/raw/master/assets/kopi_horlicks.jpg) ![Zaizi](https://github.com/eterna2/eterna2/raw/master/assets/zaizi.jpg) ![Pernzi](https://github.com/eterna2/eterna2/raw/master/assets/pernzi.jpg) ![Fatfat](https://github.com/eterna2/eterna2/raw/master/assets/fatfat2.jpg)

#### `eterna2`

I have been using this handle since 1999. It was inspired by a random news
article on the [the first virtual cementery in the world](https://pazeterna.com/).

I am a big fan of
- [DnD](https://dnd.wizards.com/dungeons-and-dragons/what-is-dd)
- [Rifts](http://palladium-store.com/1001/category/Rifts-RPG.html)
- [Battletech](https://www.catalystgamelabs.com/battletech/)
- and many more tabletop RPGs ...

`Paz Eterna` is my longest running DnD character ever (it lasted thru multiple
editions) and one of my chief inspiration for many of my artworks.

![Paz Eterna the necromancer](https://github.com/eterna2/eterna2/raw/master/assets/061227_eterna_pencil2.jpg)


text:
---
layout: default
---

# 1996-06-24 - Re: Federal Key Registration Agency

## Header Data

From: Carl Ellison<EMAIL_ADDRESS>To: Michael Froomkin<EMAIL_ADDRESS>Message Hash: 892c8c65324c2f9df99d889d4694106d188d82553cc8cd17d6c13ae513d8959a

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1996-06-24 00:34:38 UTC

Raw Date: Mon, 24 Jun 1996 08:34:38 +0800

## Raw message

```
{% raw  %}From: Carl Ellison<EMAIL_ADDRESS>Date: Mon, 24 Jun 1996 08:34:38 +0800
To: Michael Froomkin<EMAIL_ADDRESS>Subject: Re: Federal Key Registration Agency
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

At 21:20 -0400 6/20/96, Michael Froomkin wrote:
>[...] AG Reno's assertion
>that it would take the government a year to break one DES message with a
>"supercomputer".  She presumably believes this.  We know the number for
>known plaintext attacks, but assuming you don't have a known plaintext,
>what's a more reasonable assumption?

If the plaintext is ASCII text, the time is the same but the machine is a
little more expensive.  What you do is process 8 or more blocks of
ciphertext in parallel, matching the high order bit of each byte to 0.
With 8 blocks, you get 64 high order bits -- more than the number of key
bits -- so you're not likely to guess wrong.

If the signal is audio instead of text, I don't know what you look for.
That depends on the compression algorithm.

If the signal is compressed text, again I would need to see the comressor
output.

If all you have is one or two blocks of text (e.g., a bank transaction) you
decrypt and decide whether the result is just impossible.  If it's possible
(and there will be many) you send the trial key on to a second processor (a
more general one) to try that key on the whole message to decide if the
message is still possible.

If that processor likes a given key, you send the result to a human -- who
chooses among all the possibles.

In other words, this doesn't have to be one-step-to-success.  All you're
doing is pruning the keyspace to something more manageable.

 - Carl

+------------------------------------------------------------------------+
|Carl M. Ellison<EMAIL_ADDRESS>   http://www.clark.net/pub/cme          |
|PGP: E0414C79B5AF36750217BC1A57386478 & 61E2DE7FCB9D7984E9C8048BA63221A2|
|  "Officer, officer, arrest that man!      |
+-------------------------------------------- Jean Ellison (aka Mother) -+

{% endraw %}
```

## Thread

+ Return to [June 1996](/archive/1996/06)

+ Return to "[Carl Ellison <cme@ACM.ORG>](/authors/carl_ellison_cme_at_acm_org_)"
+ Return to "[Michael Froomkin <froomkin@law.miami.edu>](/authors/michael_froomkin_froomkin_at_law_miami_edu_)"
+ Return to "["Perry E. Metzger" <perry@piermont.com>](/authors/perry_e_metzger_perry_at_piermont_com_)"
+ Return to "[Raph Levien <raph@cs.berkeley.edu>](/authors/raph_levien_raph_at_cs_berkeley_edu_)"
+ Return to "[s1113645@tesla.cc.uottawa.ca](/authors/s1113645_at_tesla_cc_uottawa_ca)"
+ Return to "[William Knowles <erehwon@c2.org>](/authors/william_knowles_erehwon_at_c2_org_)"

+ 1996-06-20 (Thu, 20 Jun 1996 20:07:52 +0800) - [Re: Federal Key Registration Agency](/archive/1996/06/4313ee9583701c6723f14cdb1c8bf8984eb3859de92d74dfb0f7891118964de4) - _William Knowles<EMAIL_ADDRESS>  + 1996-06-20 (Fri, 21 Jun 1996 07:23:49 +0800) - [Re: Federal Key Registration Agency](/archive/1996/06/d8fa3b07d49ec401ce0b0f5c87fa30dfcf91b0ea5e9ade122c94fdaaa59ef083) -<EMAIL_ADDRESS>    + 1996-06-21 (Fri, 21 Jun 1996 14:57:40 +0800) - [Re: Federal Key Registration Agency](/archive/1996/06/c290ebecbdfee3b2c6436311058275809451b8142f6cf3285f1bee1437a8bfd4) - _Michael Froomkin<EMAIL_ADDRESS>      + 1996-06-21 (Sat, 22 Jun 1996 05:40:52 +0800) - [Re: Federal Key Registration Agency](/archive/1996/06/8899f3debde98d882f263d4e8a228672069a2af51a3fc49ae2a4835d07f7f9fd) - _"Perry E. Metzger"<EMAIL_ADDRESS>      + 1996-06-22 (Sat, 22 Jun 1996 12:23:58 +0800) - [Re: Federal Key Registration Agency](/archive/1996/06/f9048c3fe62c9d19057dd45e1da25356cd5fe64580482cb658c23c1028ffdc10) - _Raph Levien<EMAIL_ADDRESS>    + 1996-06-24 (Mon, 24 Jun 1996 08:34:38 +0800) - Re: Federal Key Registration Agency - _Carl Ellison<EMAIL_ADDRESS>


text:
Packages

 Assignment Question

1. Build a calculator package that has separate module for:
   1. sin, cos, tan, tanh, softMax, sigmoid, relu log and exp
   2. The modules shall include their derivatives as well
   3. If we do import calculator, we should be able to access all the above function (except deviratives)
   4. For derivates we must do: from package import derivatives.
   5. Outputs are returned as well as printed using only f-string
   6. Write simple test cases to check the outputs of each operator and their derivative

 Assignment Solution

### Approach

Here in this we have to develop a calculator package which can perform operations like sin, cos, tan, tanh, softmax, relu, log and exp and can also give derivatives of those.

#### Tree

This is the module structure which we have followed, There are seperate folders for each function. Each file has 2 functions implemented i.e. the main function and its derivative function.

#### File Description

`init.py`: This file calls all the main funcaitionalities so that when we do `import calculator`, it will automatically import these functions.

`derivative.py`: This file imports all the derivatives of the main functionality, so when we do `from calculator import derivative`, all these derivative functions will be imported.

### Test Cases

Here we have defined test cases to check each functionality i.e. the main one and the derivative one. Then we have checked for proper annotations and doc string in the code. We have also checked for proper readme files.

---

 Made with ❤ & 🍻 by KillerStrike

path: /12. Packages/README.md


text:
gradle-versioneye-plugin
========================

Plugin for [Gradle](http://www.gradle.org/) to update your project dependencies status on [VersionEye](https://www.versioneye.com) based on the resolved dependency configurations of your Gradle project.

It works quite similar to the [VersionEye plugin for Maven](https://github.com/versioneye/versioneye_maven_plugin).

[![Dependency Status](https://www.versioneye.com/java/org.standardout:gradle-versioneye-plugin/badge.svg)](https://www.versioneye.com/java/org.standardout:gradle-versioneye-plugin)

Minimum Requirement
-----

The VersionEye servers are using [LetsEncrypt](https://letsencrypt.org/) for SSL certificates. Old Java versions don't support that certificate. The minimum required version is 8u101. More details on [StackOverflow](https://stackoverflow.com/questions/34110426/does-java-support-lets-encrypt-certificates/34111150#34111150).

Usage
-----

The simplest way to apply the plugin to your Gradle build is to use the **Gradle 2.1** plugin mechanism:

```groovy
plugins {
    id "org.standardout.versioneye" version "1.5.0"
}
```

For **Gradle 1.x and 2.0** add the artifact to your buildscript classpath via jCenter or Maven Central:

```groovy
buildscript {
	repositories {
		jcenter()
	}
	dependencies {
		classpath 'org.standardout:gradle-versioneye-plugin:1.5.0'
	}
}

apply plugin: 'org.standardout.versioneye'
```

### API key

You need to provide your [VersionEye](https://www.versioneye.com) API key for the plugin to be able to communicate with the VersionEye API. You do this through a Gradle property, e.g. by specifying it in the **gradle.properties** file in **~/.gradle/** or the project directory, or via the command line. However, it is strongly recommended not to place it somewhere where it is publicly accessible (e.g. in a public GitHub repository).

```
versioneye.api_key=1234567890abcdef
```

If logged in to VersionEye, you can get or generate your API key [here](https://www.versioneye.com/settings/api).

#### Environment variable

Starting from version 1.3, if no Gradle property for the API key is defined, the plugin will fall back to the value found in the `VERSIONEYE_API_KEY` environment variable.

### Gradle tasks

The **versioneye** plugin comes with two main Gradle tasks that are relevant for you:

* ***versioneye-create*** - Creates a project on [VersionEye](https://www.versioneye.com) and write the project ID to your project's **gradle.properties** (so they can be used with ***versioneye-update***)
* ***versioneye-update*** - Updates the dependencies for the project on [VersionEye](https://www.versioneye.com) that is identified by the project ID and your API key

Alternatively you can use the CamelCase versions of these tasks, ***versionEyeCreate*** and ***versionEyeUpdate*** which can be abbreviated on the command line (see [the Gradle documentation](http://www.gradle.org/docs/current/userguide/tutorial_gradle_command_line.html)), e.g. `gradle vEU` or `gradle vEyeU` for executing ***versionEyeUpdate***.

Example call creating a VersionEye project - in this case the API key is provided via the command line:

```
gradle -Pversioneye.api_key=1234567890abcdef -info versioneye-create
```

#### Additional checks

Based on the information retrieved from VersionEye you can do a number of additional checks with the following tasks:

* ***versionEyeLicenseCheck*** (since 1.3) - Check if there are any violations of your license white list
* ***versionEyeSecurityCheck*** (since 1.3) - Check if there are any dependencies with known security vulnerabilities
* ***versionEyeSecurityAndLicenseCheck*** (since 1.3) - Check both security vulnerabilities and license violations

Executing any of these tasks will update the project on VersionEye.

### Project configuration

#### VersionEye project

Once you create a VersionEye project with ***versioneye-create***, it will add the `versioneye.projectid` property to the **gradle.properties** file in your project directory. But you can also provide these settings manually in any way Gradle supports specifying properties (e.g. if you already have an existing VersionEye project).

#### Organisation and Team

When creating a project you can directly associate it with a specific organisation and team.
All you need to do is provide the corresponding Gradle properties for ***versioneye-create***:

* ***versioneye.organisation*** - the organisation namespace
* ***versioneye.team*** - the team name

These properties can be defined via **gradle.properties** file or via the command line, for example:

```
gradle -Pversioneye.api_key=1234567890abcdef -Pversioneye.organisation=myorg -Pversioneye.team=myteam versioneye-create
```

#### Which dependencies?

There are two main modes, you can use only the **declared** dependencies or additionally the **transitive** dependencies:

* **declared** - only first level dependencies are included (default)
* **transitive** - the declared and all transitive dependencies

Configuration example:
```groovy
versioneye {
  dependencies = transitive
}
```

To further customize which dependencies are analyzed, you can exclude specific configurations, for example to exclude the dependencies that are only needed for tests with the Gradle Java plugin:
```groovy
versioneye {
  exclude 'testCompile', 'testRuntime'
}
```

Please note that if you exclude a configuration that is extended by another configuration that you did not exclude, this will have no effect (e.g. if you exclude *runtime* but don't exclude *testRuntime*).

**Tip:** If there are dependencies showing up you have no idea where they are coming from, use `gradle dependencies` to get an overview of all configurations and the dependencies contained in them. Use it to identifiy the configurations that you don't want to include.

Since version 1.3, the plugins that you use for your build script are also included in the dependencies reported to VersionEye. If you don't want that, you can disable this feature in the configuration:

```groovy
versioneye {
  includePlugins = false
}
```

##### Multi-project builds (since 1.4)

If you have a multi-build project that you want to handle as one single VersionEye project, you should apply the plugin only to the root project and configure the plugin to include dependencies from sub-projects as well:

```groovy
versioneye {
  includeSubProjects = true
}
```

#### Unknown licenses

If you want the license check to fail when dependencies with unknown license are encountered, you need to enable it in the configuration like this:

```groovy
versioneye {
  licenseCheckBreakByUnknown = true
}
```

#### VersionEye Enterprise

If you want to connect to a VersionEye Enterprise installation instead of *versioneye.com*, you can adapt the base URL used to access the API:

```groovy
versioneye {
  baseUrl = 'https://www.versioneye.com' // this is the default
}
```

#### Dependency scopes

The dependency scope in VersionEye is used to organize dependencies in different groups, for instance compile time dependencies or test dependencies.

Your project dependencies in Gradle are organised in dependency configurations, for instance in most projects there is a `compile` configuration. The dependency scope is determined based on the information in which configurations it is present.
The default strategy tries to identify the primary configuration of a dependency and use that as a scope.
This works best for standard project setups, so if you feel that you can provide a more optimal grouping, you can provide your own implementation.

The `DEFAULT` strategy is configured if you do not override the setting. Another provided strategy is the `CONFIGURATIONS` strategy.
It uses the configuration associations as is. You can enable it like this:

```groovy
versioneye {
  determineScopeStrategy = CONFIGURATIONS
}
```

You can provide your own implementation by providing a closure that calculates an Iterable of scope names from the Set of configuration names.
Build script dependencies here have the configuration name `'plugin'` associated.

```groovy
versioneye {
  determineScopeStrategy = { Set<String> configs ->
    def scopes = []

    //TODO determine scopes based on the configuration names

    scopes
  }
}
```

### Using the current SNAPSHOT

If you want to test the latest version with changes that have not been released yet, you can configure your project to use the latest SNAPSHOT:

```groovy
buildscript {
  repositories {
    maven {
      url 'http://oss.sonatype.org/content/repositories/snapshots/'
    }
    jcenter()
  }
  dependencies {
    classpath 'org.standardout:gradle-versioneye-plugin:1.6.0-SNAPSHOT'
  }
}

apply plugin: 'org.standardout.versioneye'
```

License
-----

[The MIT License (MIT)](http://opensource.org/licenses/MIT)

repository: stempler/gradle-versioneye-plugin

gha_language: Groovy

repo_name: stempler/gradle-versioneye-plugin


text:
# Proposal
I would like to build off of my tic tac toe game (the bunny game). I would like to build it so that the tic tac toe game is not the only thing that is available to do. I'd like to add a scoring system where the more you win, the more you get in-game currency to buy stuff from the shop. I'd like to add more mini-games like bunnies trying to catch carrots from the sky.
I would also like to add a player character that the player can (nice to have) name and (must have) purchase cosmetics from the shop with in-game currency.

## Needs to Have
- Tic-tac-toe game
- Classes (carrots falling from the sky) (at least a part of the carrot game started)
- Scoring system
- Currency + shop
- Customization option

## Nice to Have
- Introductory storyline
- Interactive (e.g. mouse hovering button to highlight, clicking player character, etc.)/animations
- More mini-games
- A lobby of sorts where the player can run around with their character
- NPCs that the player can interact with
- Savefiles
- Player text input
- Choosing team

license: Unlicense


text:
# amCharts Plugin: Polar Scatter

Version: 1.0.0

## Description

Enhances Radar/Polar chart type with ability to use it as an circular XY scatter
chart.

## Installation

To enable, include `polarScatter.min.js` on your web page.

I.e.:

```
<script src="//www.amcharts.com/lib/3/plugins/tools/polarScatter/polarScatter.min.js"></script>
```

## Usage

The plugin works by ditching pre-defined categories and creating it's own
categories at specific angles.

To set plugin settings, use `polarScatter` block:

```
"polarScatter": {
  "minimum": 0,
  "maximum": 359,
  "step": 1
}
```

Parameters are as follows:

Parameter | Default | Description
--------- | ------- | -----------
maximum | 359 | End value
minimum | 0 | Start value
step | 1 | Granularity of your data

The actual positions of the scatter points go into `series` array under
specific graph:

```
"graphs": [ {
  "title": "Trial #1",
  "balloonText": "[[category]]: [[value]] m/s",
  "bullet": "round",
  "lineAlpha": 0,
  "series": [[83,5.1],[44,5.8],[76,9],[2,1.4],[100,8.3],[96,1.7],[68,3.9],[0,3],[100,4.1],[16,5.5],[71,6.8],[100,7.9],[9,6.8],[85,8.3],[51,6.7],[95,3.8],[95,4.4],[1,0.2],[107,9.7],[50,4.2],[42,9.2],[35,8],[44,6],[64,0.7],[53,3.3],[92,4.1],[43,7.3],[15,7.5],[43,4.3],[90,9.9]]
}, {
  "title": "Trial #2",
  "balloonText": "[[category]]: [[value]] m/s",
  "bullet": "round",
  "lineAlpha": 0,
  "series": [[178,1.3],[129,3.4],[99,2.4],[80,9.9],[118,9.4],[103,8.7],[91,4.2],[151,1.2],[168,5.2],[168,1.6],[152,1.2],[149,3.4],[182,8.8],[106,6.7],[111,9.2],[130,6.3],[147,2.9],[81,8.1],[138,7.7],[107,3.9],[124,0.7],[130,2.6],[86,9.2],[169,7.5],[122,9.9],[100,3.8],[172,4.1],[140,7.3],[161,2.3],[141,0.9]]
} ]
```

Each entry in the `series` array is a two-unit array. The first number is a
category/angle/circular position, the second one is value.

Use graph's regular settings to modify appearance like bullets, colors, etc:

http://docs.amcharts.com/3/javascriptcharts/AmGraph

### OMG!

The plugin works by adding a lot of categories, which creates a value axis for
each of those. Using default settings (360 categories around the circle) it may
look a bit off.

There's no other solution but to upgrade to the latest version of the
JavaScript Charts. Since version 3.19.5 it supports a `valueAxis` property
`axisFrequency` which allows controlling the number of axes/labels on the polar
chart.

The plugin will automatically set it for you if you don't do it. But if you
feel like tinkering with it you can do so like this:

```
"valueAxes": [ {
  "gridType": "circles",
  "minimum": 0,
  "axisFrequency": 30
} ]
```

## Examples

http://codepen.io/team/amcharts/pen/c7dffa24ca45a567d664328201014e68

## License

All software included in this collection is licensed under Apache License 2.0.

This basically means you're free to use or modify it, even make your own
versions or completely different products out of them.

Please see attached file "license.txt" for the complete license or online here:

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

## Contact us

*<EMAIL_ADDRESS>* Web: http://www.amcharts.com/
* Facebook: https://www.facebook.com/amcharts
* Twitter: https://twitter.com/amcharts

## Changelog

### 1.0
* Initial release

repository: myungguan/nrentkingm

repo_name: myungguan/nrentkingm


text:
# ***ArcGIS* Hub** for GeoDevs

John ([@geogangster](@https://twitter.com/geogangster))
Patrick ([@hamhandedly](https://twitter.com/hamhandedly))

slides: [`http://bit.ly/2AOXtk8`](http://bit.ly/2AOXtk8)

---

![screenshot of webinar tools](gotomeeting.png)

---

## Agenda

1. What _is_ Hub?
2. How you can customize it
3. How citizens can program against it
4. How we can **all** collaborate
 * within a city
 * across the :earth_americas:

[`http://bit.ly/2jgH0h5`](http://bit.ly/2jgH0h5)

---

## first, _why_ **ArcGIS Hub**?

Story time!

![removable storage](https://upload.wikimedia.org/wikipedia/commons/7/79/Forty_years_of_Removable_Storage.jpg)

[`http://bit.ly/2jgH0h5`](http://bit.ly/2jgH0h5)

---

## Demo

* Open Data >>> Initiatives

[`http://bit.ly/2jgH0h5`](http://bit.ly/2jgH0h5)

---

## So...why _Hub_?

* Open Data++

[`http://bit.ly/2jgH0h5`](http://bit.ly/2jgH0h5)

---

## ArcGIS Hub

* Data + Initiatives + Community

[`http://bit.ly/2jgH0h5`](http://bit.ly/2jgH0h5)

---

## Under the hood...

```bash
git clone https://github.com/Esri/cedar.git
```
* Sharing charts across the platform
* New interactive browser chart building experience is coming
* Built on top of D3

[`http://bit.ly/2jgH0h5`](http://bit.ly/2jgH0h5)

---

* Better support for multi-series charts
* joining datasets
* better default styling

[`http://bit.ly/2jgH0h5`](http://bit.ly/2jgH0h5)

---

## How do i _turn on_ :bulb: ArcGIS Hub ?

* Demo - creating Initiative pages

[`http://bit.ly/2jgH0h5`](http://bit.ly/2jgH0h5)

---

* bring your own data
* more flexible, automated configuration
* we guide you to citizen engagement
* pages are [customizable](https://hub.arcgis.com/pages/site-customization)

[`http://bit.ly/2jgH0h5`](http://bit.ly/2jgH0h5)

---

## _configurable apps_

* maps loaded dynamically
* use [shared themes](https://blogs.esri.com/esri/arcgis/2017/02/27/introducing-a-new-app-styling-capability-in-arcgis-online/)

[`http://bit.ly/2jgH0h5`](http://bit.ly/2jgH0h5)

---

## Demo

* community admin tools

[`http://bit.ly/2jgH0h5`](http://bit.ly/2jgH0h5)

---

## What about citizen coders?

[`http://bit.ly/2jgH0h5`](http://bit.ly/2jgH0h5)

---

## ArcGIS API for Python

* no license required
* distributed via Conda
* integrates with your favorite open source packages

[`http://bit.ly/2jgH0h5`](http://bit.ly/2jgH0h5)

---

## Demo

* Jupyter Notebook analysis

[`http://bit.ly/2jgH0h5`](http://bit.ly/2jgH0h5)

---

# Anonymous _or_ [Authenticated](https://developers.arcgis.com/documentation/core-concepts/security-and-authentication/)

* citizens can interact with datasets anonymously

* Hub engagement tools allow regular folks to unlock premium capabilities too

[`http://bit.ly/2jgH0h5`](http://bit.ly/2jgH0h5)

---

## _Way down_ under the hood...

```bash
git clone https://github.com/Esri/arcgis-rest-js.git
```
* Node.js and browser agnostic
* TypeScript / Vanilla JS
* Promise based

[`http://bit.ly/2jgH0h5`](http://bit.ly/2jgH0h5)

---

* ArcGIS for Developers - angular
* ArcGIS Hub - ember

[`http://bit.ly/2jgH0h5`](http://bit.ly/2jgH0h5)

---

## Hub Ready Apps

a continuum.

hardcoded > configurable > _hub ready_

[`http://bit.ly/2jgH0h5`](http://bit.ly/2jgH0h5)

---

* **ArcGIS Content** using Item config and Group Permissions
* **ArcGIS Identity** for authentication and Community
* **Shared Theme** & global navigation for consistent branding and design
* **Durable State** using URL of current view
* **Accessibility** for impaired users following WCAG & a11y
* **Indicator Aware** for Initiative configuration

---

* **Telemetry** to track usage and performance
* **Data Citations** link back to Data
* **Discussions** for collaboration and feedback
* **Connected Apps** between Hub Initiatives
* **App Switcher** between related Hub apps
* **Global** Profile for saving views and collaboration
* **Versions** for collaborative editing and publishing

---

## A _Hub Ready_ example/prototype

[MyStreet](https://github.com/Esri/MyStreet/)

[`http://bit.ly/2jgH0h5`](http://bit.ly/2jgH0h5)

---

## more lego pieces

* [sonar](https://github.com/Esri/sonar)
* [koop](koopjs.github.io)

[`http://bit.ly/2jgH0h5`](http://bit.ly/2jgH0h5)

---

## How do i keep up?

* https://hub.arcgis.com/pages/changelog

[`http://bit.ly/2jgH0h5`](http://bit.ly/2jgH0h5)

---

## resources

Slides: [`http://bit.ly/2jgH0h5`](http://bit.ly/2jgH0h5)

* [Welcome to ArcGIS Hub Blog](https://blogs.esri.com/esri/arcgis/2017/06/27/welcome-to-arcgis-hub/)
* [2017 UC Teaser](https://www.youtube.com/watch?v=7OrvBKEqQiU)
* [Hub Python Tutorials](https://github.com/esridc/Hub-Tutorials/)
* [Python API Documentation](https://developers.arcgis.com/python/)
* [Hosted Jupyter Notebooks](http://notebooks.esri.com/)
* [`arcgis-rest-js` Documentation](http://arcgis-rest-js.surge.sh/)
* [ArcGIS for Developers](https://developers.arcgis.com/labs/)

---

* [StoryMap accessiblity blog](https://blogs.esri.com/esri/arcgis/2017/12/07/map-journal-accessibility/)
* [Customizing Hub pages](https://hub.arcgis.com/pages/site-customization)
* [ArcGIS REST API doc](http://resources.arcgis.com/en/help/arcgis-rest-api/index.html#//02r3000000tq000000) - new port coming soon
* [Configurable app examples](https://github.com/Esri/configurable-app-examples-4x-js)
* [Ice Age Flooding](https://wadnr.maps.arcgis.com/apps/Cascade/index.html?appid=84ea4016ce124bd9a546c5cbc58f9e29
)

---

idea, question, issue, or success story?

[@geogangster](https://twitter.com/geogangster) / [@hamhandedly](https://twitter.com/hamhandedly)

Slides: [`http://bit.ly/2AOXtk8`](http://bit.ly/2AOXtk8)

---

repository: jgravois/presentations

branch_name: refs/heads/gh-pages

gha_language: JavaScript

repo_name: jgravois/presentations


text:
---
title: 2020-06.x Release Notes
keywords: release notes
sidebar: doc_sidebar
permalink: 2020.06.x_release_notes.html
summary: New and updated features.
---

These release notes give an overview of the changes for Release 2020.06 of the Wavefront service. We also just released a new version (6.1) of the Wavefront proxy. See the [Wavefront Proxy Release Notes](proxies_versions.html) for details.

## Role-Based Access Control

Starting with this release, Wavefront has full support for global [role-based access control (RBAC)](users_roles.html).

* Assign **users**  to **groups**.
* Assign **permissions** to **roles**.
* Assign **roles** to **groups** (preferred) or to individual users.

If your environment includes groups that have been assigned permissions, the permissions will be migrated to a role with the same name and that role will be assigned to the group. The Wavefront customers success team will contact all customers that are undergoing that transition.

There are no changes to the access control for individual objects (dashboards and alerts). You can continue to grant access only to individual accounts and to groups.

## Obsolete and Deprecated APIs

The following APIs are now obsolete because permissions are no longer a part of user groups:
```
/api/v2/usergroup/grant/{permission}
/api/v2/usergroup/revoke/{permission}
```

When you search group APIs, you will no longer get a permission as a parameter because permissions are now associated with roles.
```
/api/v2/search/usergroup
/api/v2/search/usergroup/{facet}
/api/v2/search/usergroup/facets
```

The `Users` API is deprecated and will become obsolete in 1 year. Use the `Accounts` API instead.

## Tracing Changes

### Tracing Documentation and README Updates

To make our tracing SDKs more accessible to users, we've revised:
* Updated information about [Wavefront Observability SDKs](wavefront_sdks.html) so it's easier to find the SDK you need.
* Updated several README files in the [Wavefront Github Repository](https://github.com/wavefrontHQ) so it's easier to find and use our SDKs.
This work is ongoing -- Use PRs or email<EMAIL_ADDRESS>with comments.

### Histogram to Tracing Drilldown

You can drill down to a corresponding trace from a Histogram chart.

### Search for Traces by Trace ID

[Search for a trace using the trace ID](trace_data_query.html#get-started-with-trace-queries). This search does not always return results because Wavefront performs intelligent sampling, and because we keep trace data only for 7 days.

### Span Operators from, followsFrom, childOf

You can use the new operators to find the relationship between spans. See [Use Spans to Examine Applications and Services](spans_function.html#use-spans-to-examine-applications-and-services) for details.

## Other Changes

### Version Info Moves to Gear Icon (About)

You can now access version information from the gear icon by selecting About. In earlier Wavefront releases, this information was at the bottom of each page.

### Users Can't See Alert Events if They Don't Have Access

Wavefront supports [access control](access.html) for alerts. Users with Alerts permissions can revoke access to individual alerts for the Everyone group and give access to individual accounts or groups.

Starting with this release, accounts and groups that don't have access to an alert will no longer see events related to that alert.

### Alert Notification Iterators for Source Tags

Added the following iterators to the [alert notification template](alert_target_customizing.html):
- recoveredHostSourceTags
- newlyFailingHostSourceTags
- inMaintenanceHostSourceTags
- failingHostSourceTags

### AWS Integration Changes

* This release includes **new metrics** for Amazon Relational Database Service (RDS) in the AWS integration:

  - aws.rds.allocatedstorage
  - aws.rds.capacity (Aurora only)
  - aws.rds.backtrackconsumedchangerecords (Aurora only)

  This change means that the [list of minimum required permissions](integrations_aws_metrics.html#giving-wavefront-limited-access) now includes `rds:DescribeDBClusters`

repository: srujann/docs

repo_name: srujann/docs


text:
---
layout: post
title: Working with multirheaded in Ruby Chap 1
---
#  In this chap 1 I will explain some terms when working with `Concurrency` in `Ruby`
### [ 1. Process ](#process)
## [ 2. Thread ](#thread)
## [ 3. GIL ](#gil)
## [ 4. Concurrency ](#concurrency)
## [ 5. Parallelism ](#parallelism)
## [ 5. Context Switch ](#context-switch)

---
# Process
  - #### Definition

      - In computing, a process is the `instance` of a `computer program` that is being executed by one or many threads. It's contains the program code and its activity. ([Wiki](<https://en.wikipedia.org/wiki/Process_(computing)>))

  - #### Pro
    - Don't share memory => Can't mutate data from one process in another.
    - Much easier to code and debug
    - Forking child process may help avoid unwanted memory leaks. Once the process finishes, it releases all the resource.

  - #### Cons
    - Since process don't share memory, they use a lot of memory.
    - Process are slow to create and destroy.

---
# Thread
  - #### Definition

      - A Thread of execution is the smallest sequence of programmed instruction that can be managed independently by a scheduler, which is typically a part of the operating system. ([Wiki](<https://en.wikipedia.org/wiki/Thread_(computing)>))

  - #### Pro
    - Uses less memory than process, it's possible to run thousand of threads.
    - They are also fast to create and destroy
    - Threads are useful when there are slow blocking I/O operations.
    - Can acess the memory area from other threads if necessary.

  - #### Cons
    - Requires very careful synchronization to avoid race-conditions, usually by using locking primitives, which sometimes may lead to deadlocks.
    - All this makes it quire difficult to write, test and debug thread-safe code.
    - The more threads you spawn, the more time and resources they'll be spending by **switching the context** and spending less time doing the actual job.

---
# GIL(Global Interpreter Lock)
  - A **global interpreter lock** (**GIL**) is a mechanism used in computer-language interpreters to synchronize the execution of threads so that only one native thread can execute at a time. An interpreter that uses GIL always allows exactly one thread to execute at a time, even if run on a multi-core processor. Some popular interpreters that have GIL are CPython and Ruby MRI ([Wiki](<https://en.wikipedia.org/wiki/Global_interpreter_lock>)).

---
# Concurrency
  - Progarmming as the compostion of independently executing process
  - Concurrency is about dealing with lots of thing at once

---
# Parallelism
  - Progarmming as the simultaneous executions of (possibly related) computations.
  - Parallelism is about doing with lots of thing at once

---
# Context Switch
  - When the operating system pauses the execution of one thread to resume execution of another it's called `context switch`

---
# NOTE
  - Only one `unit` of Ruby code can execute at any given time.
  - Ruby is a `Shared memory` language
  - All available are references


text:
---
layout: post
title: 'Perfomance Analysis #1: Data URIs'
description: 'The idea of this article is to demystify some concepts about Data URIs related to perfomance. The data URI is a uniform resource identifier (URI) scheme that provides a way to include data in-line in web pages...'
language: 'en'
---

tl;dr: The idea of this article is to demystify some concepts about Data URIs related to perfomance.

**What's Data URI?**

The data URI is a uniform resource identifier (URI) scheme that provides a way to include in-line data on web pages.

It's a form of file literal or [here document](https://en.wikipedia.org/wiki/Here_document). This technique allows normally separate elements such as images and style sheets to be fetched in a single HTTP request, instead use multiple HTTP requests.

In short: It's a base64 encoded data (e.g. images) resulting in bites. It can be used to improve performance (or in some cases decrease perfomance).

**About Cache**

Data URIs have cache limitations. Why? It's part of the file that it is included. A good approach is to use in CSS files, because you can work around in a custom/specified cache. In scenarios where use inline approach, will be cached only the part of the HTML cache control header. Then if the HTML isn't cached yet, the entire content of markup will be downloaded every time (including data URIs content-length).

This is bad.

HTML may have no cache or a very very limited cache. So just imagine a case where a page have ten img tags using Data URIs (let's assume each image have 9kb), it'll agreggate **~108kb** uncacheable data (~12kb for each one) on your HTML file.

Note: Base64 encoding incurs transfer size overhead of [1.37 times the original data, with another 814 bytes of header data](https://en.wikipedia.org/wiki/Base64#MIME).

**Data URIs are slower in mobile**

Data URI vs. Binary Image Materialization is an old topic on web and you are probably tired of hearing about it again and again. However it's cool to demystify some myths/beliefs.

I made some tests comparing Data URI materialization with Binary materialization and I got surprisingly unexpected results.

**Data URI**

- Android 2.2: 1702ms
- Android 4.2: 167ms
- iPhone iOS 5: 491ms
- iPhone iOS 7: 201ms

**Binary Image**

- Android 2.2: 142ms
- Android 4.2: 44ms
- iPhone iOS 5: 51ms
- iPhone iOS 7: 32ms

**But why it happens?**

Data URI content must be decoded back into it's original form by the browser. This operation consumes CPU & battery on mobile devices (browser must decode the image each time a page renders).

Binary images, on the other hand, require no extra decoding step and are faster for browsers to materialize. The downside of binary images is the connection overhead required to download them.

Note: Recent browsers use optimizations to improve networking performance, in particular connection keep-alive and pipelining, as well as establishing multiple server connections. If you’ve done a good job optimizing your pages, chances are that the images are being downloaded from a warm, established connection, reducing [TTFB](https://en.wikipedia.org/wiki/Time_To_First_Byte) and increasing throughput.

**Browser Support**

(In case of doubt; worth mention)

- • Chrome (all versions)
- • Safari (all versions)
- • Edge (all versions)
- • Firefox 2+
- • Opera 7.2+ (not longer than 4100 characters)
- • Internet Explorer 8+ (data URIs must be smaller than 32KB)

## Further Readings and References

Good to know/read:

- • [Nicholas Zakas’ great post (Data URIs explained)](https://www.nczonline.net/blog/2009/10/27/data-uris-explained/)
- • [On Mobile, Data URIs are 6x Slower than Source Linking](http://dev.mobify.com/blog/data-uris-are-slow-on-mobile/)
- • [Performance check: CBC’s logo as pure CSS, Data URI and simple PNG on the scale](http://www.bbinto.me/aspnet/performance-check-the-weight-of-cbcs-logo-as-pure-css-data-uri-and-simple-png/)
- • [High Performance Web Apps. Use Data URIs. Theory](http://ovaraksin.blogspot.com.br/2012/04/high-performance-webapps-use-data-uris.html)
- • [High Performance Web Apps. Use Data URIs. Practice](http://ovaraksin.blogspot.com.br/2012/04/high-performance-webapps-use-data-uris_15.html)


text:
# Interative Hybrid Probabilistic Model Counting [![Build Status](https://travis-ci.org/SteffenMichels/IHPMC.svg?branch=master)](https://travis-ci.org/SteffenMichels/IHPMC)

[Interative Hybrid Probabilistic Model Counting (IHPMC)](http://www.steffen-michels.de/ihpmc/) is a probabilistic inference algorithm developed at the [Institute for Computing and Information Sciences](http://www.ru.nl/icis/) of the [Radboud University Nijmegen](http://www.ru.nl/) by Steffen Michels. The algorithm offers inference for hybrid models with bounded error. This is a unique selling point compared to other methods, for example based on sampling, which do, if at all, only provide weak guarantees on the error. This is achieved by iteratively evaluating a hybrid probability tree and computing bounds on probabilities. Details can be found in the publication:

Steffen Michels, Arjen Hommersom, Peter J. F. Lucas <br />
[Approximate Probabilistic Inference with Bounded Error for Hybrid Probabilistic Logic Programming](http://www.steffen-michels.de/articles/ijcai16.pdf)

The input language is similar to [Probabilistic Constraint Logic Programming (PCLP)](http://www.steffen-michels.de/pclp), but does only support precise distributions.

## Installation

The inference tool based on IHPMC is written in Haskell and there is a Cabal package file. You can install the package with:

    cabal install

There are also binary packages available:
 * [IHPMC Linux x64](http://www.steffen-michels.de/ihpmc/ihpmc_linux_x64.tar.gz)
 * [IHPMC Windows x64](http://www.steffen-michels.de/ihpmc/ihpmc_windows_x64.zip)

## Usage

The algorithm comes with two version "ihpmc_float" and "ihpmc_exact". The former uses floating point arithmetic and the latter exact rational number arithmetic to compute probabilities. Floating point arithmetic is usually the better choice. It is more efficient, but can result in rounding errors. However, those rounding errors usually only become problematic, when conditioning on events with very small probability. Note, that even when using "ihpmc_exact" rounding error occur when computing CDF values for continuous distributions.

The models used for the experiments of the paper "Approximate Probabilistic Inference with Bounded Error for Hybrid Probabilistic Logic Programming" are included in "examples". You can run one of the models for instance with (after installing with Cabal):

    ihpmc_float examples/diagnostic_10_01_30.pclp -i 10000

or, in case you use the binary package:

    bin/ihpmc_float examples/diagnostic_10_01_30.pclp -i 10000

This will compute the result for 10000 iterations. The expected output is:

    Stopping after 10000 iterations.
    iteration 10000: 0.3884685469174709 (error bound: 0.08105175979731041)

Instead of the number of iterations, it is also possible to specify a timeout (-t) or a maximal allowed error (-e) as stop condition. The conditions can also be combined. For instance, with the following options inference will stop after 2000 iterations, after 1000ms or if the maximal error of the approximation is at most 0.01 (whatever occurs first):

    ihpmc_float examples/diagnostic_10_01_30.pclp -i 2000 -t 1000 -e 0.01

repository: SteffenMichels/IHPMC

gha_language: Haskell

repo_name: SteffenMichels/IHPMC


text:
# ansible-role-kmod-tpe

RHEL/CentOS - Trusted Path Execution Linux Kernel Module

Trusted Path Execution is a security feature that denies users from executing
programs that are not within a root owned path, or optionally the binary itself
root owned, or are world writable or within a world write path. This closes the
door on a whole category of exploits where a malicious user tries to execute his
or her own code to attack the system.

Additionally, this module also provides non-root view restrictions on process list,
kernel modules, kallsyms and calling set(u|g)id.

## Requirements

 - nexcess.repo.elrepo

## Role Variables

Default role variables can be found in 'defaults/main.yml'; supported variables below:

```
# kmod_tpe_lock: True|False
# when enabled, tpe sysctl entries can not be changed without a reboot

# kmod_tpe_log_floodburst: integer, quantative
# number of log entries before logging is disabled

# kmod_tpe_log_floodtime: integer, seconds
# seconds until re-enabling logging after floodburst

# kmod_tpe_log_max: integer, quantitative
# maximun parent processes in a single log entry

# kmod_tpe_log: True|False
# log denied executions

# kmod_tpe_log: True|False
# increase verbosity of logging output

# kmod_tpe_kill: True|False
# kill the offending process and its parent when it gets denied

# kmod_tpe_hardcoded_path: list, full paths
# a list of directories, colon separated, that TPE will be restricted to; nothing outside

# kmod_tpe_paranoid: True|False
# enforce trusted path restrictions on the root

# kmod_tpe_check_file: True|False
# check file owner/mode in addition to directory

# kmod_tpe_strict: True|false
# enforce some TPE features even on trusted users (no world write on exec paths or binaries)

# kmod_tpe_dmz_gid: integer, uid value
# users in this gid can't exec anything at all

# kmod_tpe_admin_gid: integer, uid value
# files belonging to this group are treated as if they're owned by root

# kmod_tpe_trusted_gid: integer, uid value
# gid of trusted users for which TPE is not enforced

# kmod_tpe_trusted_invert: True|False
# inverts trusted_gid from a whitelist to blacklist; only users in trusted_gid
# will have TPE restrictions applied

# kmod_tpe_softmode: True|False
# do not deny any executions, just log what would have been denied.

# kmod_tpe_xattr_soften: True|False
# check extended attributes for a soften flag
# e.g setfattr -n security.tpe -v "soften_exec" /usr/bin/ansible

# kmod_tpe_extras_ignore_softmode: True|False
# ignores softmode=true to allow extras_* to operate in TPE softmode

# kmod_tpe_extras_proc_kallsyms: True|False
# denies non-root users from viewing /proc/kallsyms

# kmod_tpe_extras_ps: True|False
# denies non-root users from viewing processes they don't own

# kmod_tpe_extras_ps_gid: integer, uid value
# gid of users who aren't ps view restricted (wheel gid 10)

# kmod_tpe_extras_lsmod: True|False
# denies non-root users from viewing loaded kernel modules

# kmod_tpe_extras_harden_ptrace: True|False
# denies non-root users from running ptrace operations

# kmod_tpe_extras_harden_symlink: True|False
# denies non-root users from following symlinks to files owned by a different user

# kmod_tpe_extras_harden_hardlinks: True|False
# denies non-root users from creating hardlinks to files owned by other users and special files (devices etc...)

# kmod_tpe_extras_restrict_setuid: True|False
# users not in the trusted_gid are denied calls to setuid
```

## Dependencies

 - nexcess.repo.elrepo

## Example Playbook

    - hosts: servers
      roles:
        - role: nexcess.kmod.tpe
	  kmod_tpe_extras_ignore_softmode: True
          kmod_tpe_extras_proc_kallsyms: True
          kmod_tpe_extras_ps: True
          kmod_tpe_extras_lsmod: True

## License

MIT

## Acknowledgements

 - Corey Henderson - https://github.com/cormander/tpe-lkm/

Creator and maintainer of kmod-tpe port from grsecurity

 - Brad Spengler - http://grsecurity.net/

Trusted Path Execution is a feature of grsecurity for which code was borrowed from that
project to make this module.

## Author Information
Ryan MacDonald<EMAIL_ADDRESS>https://github.com/nexcess
<EMAIL_ADDRESS>        https://github.com/rfxn

repository: Clanwarz-zz/ansible-role-kmod-tpe

repo_name: Clanwarz-zz/ansible-role-kmod-tpe


text:
---
title: Paper accepted to DistributedML’21
subtitle:
summary: 2nd Workshop on Distributed Machine Learning, co-located with CoNEXT 2021
authors:
- admin
tags: []
categories: []
date: "2021-12-07T00:00:00Z"
featured: false
draft: false

# Featured image
# To use, add an image named `featured.jpg/png` to your page's folder.
image:
  caption: ""
  focal_point: ""

projects: []
---

Our paper [**FL_PyTorch : Optimization Research Simulator for Federated
Learning**](https://dl.acm.org/doi/pdf/10.1145/3488659.3493775), a joint work with [**Konstantin Burlachenko**](https://burlachenkok.github.io/) and [**Peter Richtárik**](https://richtarik.org/) got accepted to 2nd Workshop on Distributed Machine Learning, co-located with CoNEXT 2021.

repository: SamuelHorvath/academic-kickstart

repo_name: SamuelHorvath/academic-kickstart


text:
# coprh-nlp-2021
Colorado Pragmatic Research in Health 2021 Conference: May 24 - 26, 2021

Natural Language Processing

## Notes about presentation

* Pragmatic approach to research - reuse existing data where possible; avoid primary data collection
* Uses of NLP - not necessarily how to do NLP
* How to apply NLP to audience's research
* Who can help attendees learn more about NLP or use NLP in their research project.
* Dr. Kwan speaking about social media for research at same time as my presentation
* Should have quiz questions, questions to ponder, exercises, etc. to keep audience engaged.
## How to setup python

Download Anaconda python distribution from: https://www.anaconda.com/products/individual#Downloads

Then run the following steps

```bash
conda create -n coprh python=3.7
conda activate coprh
conda config --add channels conda-forge
#conda install -c fastai fastbook sentencepiece
conda install -c conda-forge rise jupyter_nbextensions_configurator jupytext jupyterlab
conda install -c fastchan fastai
jupyter nbextension enable hide_input/main
```

https://colab.research.google.com/github/fastai/fastbook/blob/master/10_nlp.ipynb


text:
# uv_callback

[![Build Status](https://travis-ci.org/litesync/uv_callback.svg?branch=master)](https://travis-ci.org/litesync/uv_callback)

Module to call functions on other libuv threads.

It is an alternative to uv_async with some differences:

 * It supports coalescing and non coalescing calls
 * It supports synchronous and asynchronous calls
 * It supports the transfer of an argument to the called function
 * It supports result notification callback

# Usage Examples

## Sending progress to the main thread

In this case the calls can and must coalesce to avoid flooding the event loop if the
work is running too fast.

The call coalescing is enabled using the UV_COALESCE constant.

### In the receiver thread

```C
uv_callback_t progress;

void * on_progress(uv_callback_t *handle, void *value, int size) {
   printf("progress: %d\n", (int)value);
}

uv_callback_init(loop, &progress, on_progress, UV_COALESCE);
```

### In the sender thread

```C
uv_callback_fire(&progress, (void*)value, NULL);
```

⚠ Do **NOT** send pointers with UV_COALESCE, only scalar values

## Sending allocated data that must be released

In this case the calls cannot coalesce because it would cause data loss and memory leaks.

So instead of UV_COALESCE it uses UV_DEFAULT.

### In the receiver thread

```C
uv_callback_t send_data;

void * on_data(uv_callback_t *handle, void *data, int size) {
  do_something(data);
  free(data);
}

uv_callback_init(loop, &send_data, on_data, UV_DEFAULT);
```

### In the sender thread

```C
uv_callback_fire(&send_data, data, NULL);
```

## Firing the callback synchronously

In this case the thread firing the callback will wait until the function
called on the other thread returns.

It means it will not use the current thread event loop and it does not
even need to have one (it can be used in caller threads with no event loop
but the called thread needs to have one).

The last argument is the timeout in milliseconds.

If the called thread does not respond within the specified timeout time
the function returns `UV_ETIMEDOUT`.

### In the called thread

```C
uv_callback_t send_data;

void * on_data(uv_callback_t *handle, void *args, int size) {
  int result = do_something(args);
  free(args);
  return (void*)result;
}

uv_callback_init(loop, &send_data, on_data, UV_DEFAULT);
```

### In the caller thread

```C
int result;
uv_callback_fire_sync(&send_data, args, (void**)&result, 1000);
```

## Firing the callback and getting the result asynchronously

In this case the thread firing the callback will receive the result in its
own callback when the function called on the other thread loop returns.

Note that there are 2 callback definitions here, one for each thread.

### In the called thread

```C
uv_callback_t send_data;

void * on_data(uv_callback_t *handle, void *data, int size) {
  int result = do_something(data);
  free(data);
  return (void*)result;
}

uv_callback_init(loop, &send_data, on_data, UV_DEFAULT);
```

### In the calling thread

```C
uv_callback_t result_cb;

void * on_result(uv_callback_t *handle, void *result, int size) {
  printf("The result is %d\n", (int)result);
}

uv_callback_init(loop, &result_cb, on_result, UV_DEFAULT);

uv_callback_fire(&send_data, data, &result_cb);
```

# Non-static objects

If the `uv_callback_t` object is allocated on memory then you can inform which function should be used to release it using the `uv_callback_init_ex` function:

```C
uv_callback_t *cb = malloc(sizeof(uv_callback_t));
if (!cb) ...
uv_callback_init_ex(loop, &cb, get_values, UV_DEFAULT, free, NULL);
```

You can discard it on the same thread it was created using the `uv_callback_stop` function just before closing the loop handles and then `uv_callback_release` on the callback of the `uv_close`. The object will be released when the reference counter reaches 0.

```C
void on_close(uv_handle_t *handle) {
   if (uv_is_callback(handle)) {
      uv_callback_release((uv_callback_t*) handle);
   }
}

void on_walk(uv_handle_t *handle, void *arg) {
   uv_close(handle, on_close);
}

...

   /* run the event loop */
   uv_run(&loop, UV_RUN_DEFAULT);

   /* the event loop stopped */
   uv_callback_stop_all(&loop);
   uv_walk(&loop, on_walk, NULL);
   uv_run(&loop, UV_RUN_DEFAULT);
   uv_loop_close(&loop);
```

You can also inform in the last argument which function should be used to release the result from the callback, if it is not used.

```C
void * get_data(uv_callback_t *handle, void *arg, int size) {
  struct my_data *result = malloc(sizeof(struct my_data))
  result->data1 = calc1(arg);
  result->data2 = calc2(arg);
  free(arg);
  return result;
}

void thread_init() {
  uv_callback_t *cb = malloc(sizeof(uv_callback_t));
  if (!cb) ...
  uv_callback_init_ex(loop, &cb, get_data, UV_DEFAULT, free, free);
  ...
}
```

Check the [test](test/test.c) for more usage examples.

# Requirement

⚠ For `uv_callback` to work you must **NOT** use `uv_async` handles in the same loops that use `uv_callback`!

This requirement applies to the [this commit](https://github.com/litesync/uv_callback/commit/f9e54ca561e40cb61398534c3b069c800c537a41) that ensures that the order of calls will be preserved.

If you want to use uv_async handles with uv_callback, use the [previous commit](https://github.com/litesync/uv_callback/commit/f19aba8b9c21f860f9e00fd5654baa6aeff81a76). It preserves the
order of calls only within a single callback handle, not globally.

# License

MIT

# Contact

contact AT litereplica DOT io

gha_language: C


text:
---
layout: project
type: project
image: images/l.jpg
title: Object Oriented Project
permalink: projects/ICS111_Final
date: 2015
labels:
  - ICS 111
  - Java
summary: For ICS 111, we had to form groups and combine our code to create a final project.
---

<img class="ui medium right floated rounded image" src="/images/l.jpg">

This project was that final project for ICS 111. We worked in groups to create a video of objects moving around the screen. The project uses txt files to give directions on how the objects on the screen should move.

I was in charge of creating the video which can be seen here(https://youtu.be/jx2UC2_bxx4)
I also made the code for cksimao_animator which can be found here(https://github.com/cksimao/projectcodes/blob/master/cksimao_Animator.java)
I also helped organizing the main(https://github.com/cksimao/projectcodes/blob/master/main.java).

With this project, we learned how to work in groups to create a project and had to present in front of a large group.


text:
# Palindrome Checker (C#)

A web app, built with C#, that allows users to enter a string and check whether said string is a palindrome (that is, whether it is identical when read forward and when read backwards).

## Installation

1. Install .NET, if not already present on your local machine.

2. Clone this repository.

3. In your preferred shell, navigate to the Palindromes folder and run the following commands:

 ```
 $ dotnet restore
 ```
(above not required for .NET Core 2.0 SDK or newer releases)

 ```
 $ dotnet run
 ```

4. Navigate to localhost:5000 in your preferred browser.

## Specifications

1. App routes users to the home page, where users may submit a string to be examined.

2. When a string is submitted, the string is displayed below the form along with a message confirming whether or not the string is a palindrome. Capitalization and whitespace are ignored when determining this.
    1. Example Input: "Aha"
    2. Example Output: "Congrats, your input is a palindrome!".

    3. Example Input: "race car"
    4. Example Output: "Congrats, your input is a palindrome!"

    5. Example Input: "hello"
    6. Example Output: "Not a palindrome, sorry!"

### Built With

* [Atom](https://atom.io/) - Open-source, hackable code editor running on the Electron framework.

### Support and Contact Details
If you encounter any bugs or would like to make suggestions regarding this project, please feel free to open an issue within the repository.

### License

This project is distributed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details.

repository: eswotinsky/palindrome-checker

repo_name: eswotinsky/palindrome-checker


text: If $a$, $b$ and $d$ are the lengths of a side, a shortest diagonal and a longest diagonal, respectively, of a regular nonagon (9-sided polygon). Find an expression that relates $a$, $b$, and $d$.

repository: NAUMathStat/problem-of-the-week

repo_name: NAUMathStat/problem-of-the-week


text:
# MDC Instrumentation for Logback version 1.0 and higher

This module integrates instrumentation with Logback by injecting the trace ID and span ID from a
mounted span using a custom Logback appender.

## Quickstart

### Add these dependencies to your project

Replace `OPENTELEMETRY_VERSION` with the [latest
release](https://search.maven.org/search?q=g:io.opentelemetry.instrumentation%20AND%20a:opentelemetry-logback-mdc-1.0).

For Maven, add to your `pom.xml` dependencies:

```xml
<dependencies>
  <dependency>
    <groupId>io.opentelemetry.instrumentation</groupId>
    <artifactId>opentelemetry-logback-mdc-1.0</artifactId>
    <version>OPENTELEMETRY_VERSION</version>
  </dependency>
</dependencies>
```

For Gradle, add to your dependencies:

```kotlin
dependencies {
  runtimeOnly("io.opentelemetry.instrumentation:opentelemetry-logback-mdc-1.0:OPENTELEMETRY_VERSION")
}
```

### Usage

The following demonstrates how you might configure the appender in your `logback.xml` configuration:

```xml
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
  <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
    <encoder>
      <pattern>%d{HH:mm:ss.SSS} trace_id=%X{trace_id} span_id=%X{span_id} trace_flags=%X{trace_flags} %msg%n</pattern>
    </encoder>
  </appender>

  <!-- Just wrap your logging appender, for example ConsoleAppender, with OpenTelemetryAppender -->
  <appender name="OTEL" class="io.opentelemetry.instrumentation.logback.mdc.v1_0.OpenTelemetryAppender">
    <appender-ref ref="CONSOLE"/>
  </appender>

  <!-- Use the wrapped "OTEL" appender instead of the original "CONSOLE" one -->
  <root level="INFO">
    <appender-ref ref="OTEL"/>
  </root>

</configuration>
```

> It's important to note you can also use other encoders in the `ConsoleAppender` like [logstash-logback-encoder](https://github.com/logfellow/logstash-logback-encoder).
> This can be helpful when the `Span` is invalid and the `trace_id`, `span_id`, and `trace_flags` are all `null` and are hidden entirely from the logs.

Logging events will automatically have context information from the span context injected. The
following attributes are available for use:

- `trace_id`
- `span_id`
- `trace_flags`

gha_language: Java


text:
goscribble
==========

An MPD Audioscrobbler

Usage
-----
You must be granted a valid API key by last.fm in order to use this.
Go to http://www.last.fm/api/account and create a new application. Copy your `API Key`, and `secret` and paste them in `lastfmclient/lastfmclient.go`, and then:

    go build
    ./goscribble -lastfm_password="yourpassword" -lastfm_username="yourusername"

repository: amir/goscribble

repo_name: amir/goscribble


text:
**xfunction** - Java library which provides set of extensions for standard Java APIs:

- ThrowingRunnable, ThrowingSupplier, ThrowingFunction and others
- functions to convert lambdas which throw checked exceptions to unchecked ones
- currying for lambdas
- preconditions
- [prefix trie](https://en.wikipedia.org/wiki/Trie) collection
- XML query/update utilities using [XPath](https://en.wikipedia.org/wiki/XPath)
- functions to delete/copy folders recursively
- md5 function which returns String in HEX format (instead of byte[])
- extension for HttpClient.Builder which allows to make insecure connections
- ...

**xfunction** has zero dependencies on any other libraries.

# Requirements

Java 8+

# Download

[Release versions](xfunction/release/CHANGELOG.md)

Or you can add dependency to it as follows:

Gradle:

```
dependencies {
  implementation 'io.github.lambdaprime:id.xfunction:22.0'
}
```

In case you still using Java 8:

```
dependencies {
  implementation 'io.github.lambdaprime:id.xfunction-jdk8:15.0'
}
```

# Documentation

[Documentation](http://portal2.atwebpages.com/xfunction)

# Contributors

lambdaprime<EMAIL_ADDRESS>

repository: lambdaprime/xfunction

repo_name: lambdaprime/xfunction


text:
# update-email

Update the email for users in your app who login using email and password.

## Update email flow in app

1. Your app calls the Graphcool mutation `updateEmail(email: String!, password: String!, newEmail: String!)`
2. If `newEmail` passed is not a valid format, an error is returned
3. If a user with the passed `email` and `password` combination is not found, an error is returned
4. If a user with the passed `email` exists and the `password` matches, the user's `email` field is updated to the new email
5. The mutation returns the id and new email of the updated user

## Setup the Email Update Function

* Create a new Schema Extension Function and paste the schema from `schema-extension.graphql` and code from `update-email.js`.
* add a PAT to the project *called the same as your function*. The token can be obtained from the Authentication tab in the project settings.

## Test the Code

First, you need to create a new user with the `signup` function. Then, go to the Graphcool Playground:

```sh
graphcool playground
```

Run this mutation to change a user's email:

```graphql
mutation {
  # replace __EMAIL__ , __NEW_EMAIL__ , and __PASSWORD__
  updateEmail(email: "__EMAIL__", password: "__PASSWORD__", newEmail: "__NEW_EMAIL__") {
    id
    email
  }
}
```

If the email/password combo are valid, and the newEmail is a valid format, you should see that it updates the user's email field and returns the user's id and new email.

repository: Manivela/graphcool-templates

repo_name: Manivela/graphcool-templates


text:
# jschip8

A chip8 emulator in Javascript.

![jschip8](https://raw.githubusercontent.com/dimiro1/jschip8/master/screenshot.png "jschip8")

# Running

```
$ npm install
```

```
$ gulp
```

Run a server in this dir. The easiest is with python. Simply type:

Python 3
```
$ python -m http.server
```

Python 2
```
$ python -m SimpleHTTPServer
```

Or just put this dir in apache.

# The Game

For now you can change the game in src/index.js and running gulp again.

# Bugs

There are some bugs related to drawing and colision detection.

# References

* http://devernay.free.fr/hacks/chip8/C8TECH10.HTM
* http://mattmik.com/chip8.html
* http://www.chip8.com/
* http://en.wikipedia.org/wiki/CHIP-8

license: ISC


text:
# PlatypusJS
The Platypus Platform is a JavaScript client and server applications platform for rapid development of enterprise-level information systems.
The platform uses two application programming languages:
* JavaScript (compatible with the ECMA-262-3 standard) is used to write program logic.
* SQL is used to access data.

Application creation and editing, deployment, debugging and maintenance are performed using the Platypus Application Designer IDE based on the NetBeans Platform. However, individual files, for example, JavaScript modules, can be edited in any text editor.

The IDE includes following development tools:

* Application database structure visual editor.
* SQL queries visual editor.
* JavaScript code editor.
* User interface forms visual editor.

The platform offers a set of features, making development process extremely productive:
* JavaScript modules automatic dependencies resolving, manual resolving is also avaliable.
* SQL queries with named parameters and SQL clauses re-use.
* Data model and ORM (Object-Relation Mapping) for JavaScript.
* Desktop cross-platform as well as HTML5 web-browser user interface presentation sharing the same code and the GUI layout.
* The GUI widgets which directly interact with the data model, allowing implementation of a CRUD (Create-Read-Update-Delete) user interface with visual configuration and without or just a little coding.
* Built-in security support, including users authentication and authorization, constraints of access to application resources.
* Application database schema structure and initial applicaton data migrations tools.

repository: AlexeyKashintsev/PlatypusJS

repo_name: AlexeyKashintsev/PlatypusJS


text:
**Pages:** | [***Home***](https://rickyroze.github.io/SoftDesFinalProject/) | [Google Maps](https://rickyroze.github.io/SoftDesFinalProject/MapPage "Google Maps API page") | [Process and Implementation](https://rickyroze.github.io/SoftDesFinalProject/TechnicalPage "Technical Page") | [Outcomes and Application](https://rickyroze.github.io/SoftDesFinalProject/ResultsPage "Results") | [Our Story](https://rickyroze.github.io/SoftDesFinalProject/OurStory "Our Story") |
### Geographic and Satellite Information

The GIS portion of our code starts by parsing metadata. A world file (.wld) looks like this

    4.0200000000
    0.0000000000
    0.0000000000
    -4.0200000000
<PHONE_NUMBER>234660
    4427796.8562399521

These values represent the x resulution, rotation, y resolution and UTM northing and easting of the top left corner. In this case, each pixel is 4.2m in the x and y direction. This can then be used to find the position of a given pixel in the real world in UTM coordinates. From this the python utm library allows us to translate those coordinates to GPS. The code snippet below shows how the data gathered from the world file is used to relate pixel coordinates to real-world position.

    def get_utm(self,x,y):
        """Returns the UTM coordinates for given pixel locations x and y in the
        image"""

        utm_easting = self.easting + x*self.x_width*self.scale
        utm_northing = self.northing + y*self.y_width*self.scale

        return utm_easting, utm_northing

  The user is also able to zoom in and out. In the user interface, this effect is acheived by scaling up the image by a set
  scale factor each time the program reads in a scroll wheel input and then moving the top left corner such that the center of
  the zoom is the location of the cursor. The scale factor of the model is also changed such that the function above will still
  return accurate coordinates allowing the length and area finding capabilities to function on zoomed images.

[***Home***](https://rickyroze.github.io/SoftDesFinalProject/)

repository: aidenclpt/SoftDesFinalProject

repo_name: aidenclpt/SoftDesFinalProject


text:
To implement a concurrent TCP day-time server.

Methodology/Algorithm:

- Server:
1. Include necessary files.
2. We need to create a socket using Socket function with the family AF_INET, and type as SOCK_STREAM.
3. Initialize the server address at 0.
4. Assign the AF_INET, address and the port number.
5. Bind the address and port using bind function.
6. Listen on the socket till connection is made with client.
7. Within an infinite loop, using the recvfrom function receive message from client and print it on the Console.

- Client:
1. Include the header files.
2. Create socket with AF_INET for IPv4 connection and SOCKSTREAM for TCP connection.
3. Initialize server address to 0.
4. Assign sin_family to AF_INET.
5. Get Server IP address and port number from console.
6. Using gethostbyname function assign it to a hostent structure. And assign it to sin_addr of the server address structure.
7. Request connection from server.
8. Within an infinite loop, read message from console and send message to server.

repository: stutisehgal/Computer-Networking

path: /Concurrent TCP-IP Day-Time Server/README.md

repo_name: stutisehgal/Computer-Networking


text:
# Markdown lint tool

A simple tool to lint markdown files and flag style issues.

## Creating Rules

    rule "MD000", "Rule name" do
      check do |doc|
        # check code goes here
        # return a list of line numbers that break the rule, or an empty list
        # (or nil) if there are no problems.
      end
    end

* doc - Object containing a repsresentation of the markdown document
* doc.lines - The raw markdown file as an array of lines
  * You can look up a line given an element with doc.element_lines
* doc.parsed - Kramdown internal representation of the doc
* doc.elements - All elements in the doc
* element.options - hash containing:
  * `:type` - symbol describing the type of element
  * `:location` - line number of element
  * other stuff that varies by element

## Contributing

1. Fork it ( http://github.com/mivok/mdl/fork )
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request

repository: cirosantilli/markdownlint

repo_name: cirosantilli/markdownlint


text:
#### Bubble Sort: easy but naive way of sorting data. Take a look at the example

    Given [5,2,3,7] we want it in accending order

      1) We compare adjacent elements to see if one is out of order.

      2) If they are in the wrong order than we swap the values and move to the next element.

      3) 💡We know the list is sorted if we go through the list and made no swaps.

#### TIME & SPACE COMPLEXITY:🤔
*Big O Notation describes how your algorithm scales when your input size becomes huge.
*Your main concern is the worst case scenario. In the worst case scenario how will your algorithm grow in the number of steps(time) and space used.

Worst case scenario is that our array is in decending order and we want to make it accending
Say were Given arr=[7,5,3] arr has 3 elements so well say n=3
                    ^index

**1st iteration**
7 > 5 so swap them
[7,5,3] -> [5,7,3]
 ^index

**2nd iteration**
7 > 3 so swap them
[5,7,3] -> [5,3,7]
   ^index

**3rd iteration **
7 is the end of the list so we just move back to start
[5,3,7]
     ^index

**4th iteration MOVE BACK TO BEGINNING **
5 > 3 so swap them
[5,3,7] -> [3,5,7]
 ^index

**5th iteration **
5 < 7 so leave it
[3,5,7]
   ^index

**6th iteration**
7 is the end of the list so we go to the start
[3,5,7]
     ^index

**7th iteration**
3 < 5 so leave it
[3,5,7]
 ^index

**8th iteration**
5 < 7 so leave it
[3,5,7]
   ^index

**9th iteration**
7 is the end of the list and we havent made any swaps this time so the array is sorted
[3,5,7]
     ^index

 In this case We did 9 iterations to sort the array.
 So given N=3 elements we took 9 iterations in the worst case scenario of the array being in decending order.

 3^2 = 9 so we can describe our algorithm as being O(n^2) because in the worst case we take n^2 steps where n is our input size.

 "This algorithm runs in O(n^2) with respect to the input size n."

 We could optimize this slightly by not looking at the last element since that one should be sorted by the time we get there but Its not much faster than O(n^2) and other algorithms are much better.

 This algorithm takes O(1) space because no matter how big the input is. The space taken up will always be constant and not grow as the input does.


text:
---
title: "Weekly 10/2020"
date: "2020-05-15"
draft: true
description: ""
---

How did you start off with investing? What motivated you to begin?
What do you think is worth investing in? Ie: housing, stock, cryptocurrency, bonds...
What do you look for when you're interested in buying a house/apartment? What tells you it's a good purchase?
How do you normally go about buying that apartment? I remember you talking about a loan from Nordea.
Same question for stocks. What do you look for when deciding to buy a stock? Do you consider dividends? Do you have a checklist with certain criteria?
How do you normally go about buying stocks?
Do you have any market preferences? I remember you said that you've invested in the American markets. Nasdaq?
Do you recommend investing in stocks right now?
What are some of the mistakes you've experienced? What are the valuable lessons you've learned from your investments?

gha_language: TypeScript


text:
---
layout: common-errors
title: iamRoleStatements should be an array of objects
image: /assets/social-cards/common-errors.png
description: "iamRoleStatements should be an array of objects, where each object has Effect, Action, Resource fields. Specifically, statement 0 is missing the following properties: Resource"
---

#### Error Message

> iamRoleStatements should be an array of objects, where each object has Effect, Action, Resource fields. Specifically, statement 0 is missing the following properties: Resource

#### Problem

An IAM role statement block in your `serverless.yml` should have `Effect`, `Action` and `Resource`. Serverless Framework is not able to parse one or more of these fields.

#### Solution

Ensure that the `Effect`, `Action`, and `Resource` fields are specified. If they are there, check the formatting and indention of each line. It should look something like this:

``` yml
...

provider:
  iamRoleStatements:
    - Effect: 'Allow'
      Action:
        - 's3:ListBucket'
      Resource: '*'

...
```

repository: seed-run/homepage

gha_language: SCSS

repo_name: seed-run/homepage