text:
---
title: 'Exploring Delegation in Kotlin'
url: http://codemonkeyism.com/exploring-delegation-in-kotlin/
categories:
    - Kotlin
author: '@codemonkeyism'
date: Apr 04, 2016 09:49
---
I’m a huge fan of interfaces in Java and also of composition over inheritance. Inheritance is some magic wiring with tight coupling that creates lots of friction when evolving a code base. I’ve written about interfaces before several times, for example [here](http://codemonkeyism.com/how-to-improve-programming-with-interfaces/) or [here](http://codemonkeyism.com/generation-java-programming-style/). Looking at Kotlin I wanted to see what I can do with interfaces and composition.

Take this example:

```kotlin
interface HasName {
  fun getName():String
}

class Person(): HasName {
   override fun getName():String = "Stephan"
}

fun main(args: Array<String>) {
  val p = Person()
  // Prints 'Stephan'
  println(p.getName())
}

```

Why would one introduce a `HasName` interface in this case? It reduces dependencies and coupling. This makes reasoning about code easier and speeds up compilation, especially incremental compilation.

How would we use the `HasName` interface? A function that checks for a good name could look like this:

```kotlin
fun goodName(p:Person):Boolean {
  return p.getName() == "Stephan"
}
```

Now the function depends on the whole of person, not just the name part. The function can not operate on a lot of things, just persons. What about other things with `Name`, like Dogs? Rewritting the code to

```kotlin
fun goodName(n:HasName):Boolean {
   return n.getName() == "Stephan"
}
```

makes the function more reusable.

Inside our `Person class` we have the code for the `HasName` functionality. It woud be nicer to be able to reuse the functionality from somewhere else.

In Kotlin we can delegate Interfaces to objects:

```kotlin
interface HasName {
  fun getName():String
}

class NameMixin(val n:String): HasName {
  override fun getName() = n
}

class Person(n:NameMixin): HasName by n {
}

fun main(args: Array<String>) {
    val p = Person(NameMixin("Stephan"))
    // Prints 'Stephan'
    println(p.getName())
}

```

This looks a little unnatural to me, as the user of the `Person class` needs to know about the `NameMixin`. See if we can do better

```kotlin
class Person(n:String): HasName by NameMixin(n) {
}

fun main(args: Array<String>) {
  val p = Person("Stephan")
  // Prints 'Stephan'
  println(p.getName())
}

```

looks cleaner as the consumer of `Person` does not know about `NameMixin`.

Kotlin can also use data classes (Thanks to Christian Helmbold for pointing this out).

```kotlin
interface HasName {
    val name: String
}

data class NameMixin(override val name: String) : HasName

class Person(named : HasName) : HasName by named
```

If we want to have more control, we can use a Factory inside `Person`.

```kotlin
class Person(n:String): HasName by Person.name(n) {
  companion object Name {
    fun name(n:String) = NameMixin(n)
  }
}

```

The name of the `companion object`, in this case `Name`, is optional but helps to structure the factory methods.

The mixin can be accessed with `this`:

```kotlin
class Person(n:String): HasName by Person.name(n) {
  ...
  fun isStephan():Boolean {
    // Access name property
    return this.getName() == "Stephan"
  }
}
```

Using a `companion object` with a factory method is better, because it gives us more control in the creation of the Mixin. But the control is not optimal. I wish we had something like

```kotlin
// Not working Kotlin code!
class Person(n:String): HasName {
    val name delegates from HasName
}
```

where I have access to name and more control over it. It would also be nice to have a way to access other Mixins from a Mixin. But overall, some nice functionality in Kotlin.

repository: brianmadden/awesome-kotlin

path: /app/rss/articles/Exploring Delegation in Kotlin.md

filename: Exploring Delegation in Kotlin.md

repo_name: brianmadden/awesome-kotlin


text:
> [d2b](../README.md) › **Axis Configured Demos**

 # {#multiple_chart}
### [#](multiple_chart) Multi Chart
Here is a live interactive demo of multiple default axis charts without any extra configurations. Simply add another `generators` object with the desired graph types and respective data to create a new chart. The charts created are displayed in a stack-like manner. For example, the area chart is created first, then the bar/line, and then the bubble pack. This puts the area chart on the first/lower layer, then the bar/line chart is stacked on top, and lastly the bubble pack is stacked of the previous one, making it the last/top layer.

 # {#annotation}
### [#](#annotation) Annotation
Here is a live interactive demo of the default area axis chart with annotations without any extra configurations. You can annotate different points within the graph by creating an annotation object and setting it to a point object within the values array.

# {#axis_config}
### [#](#axis_config) Axis Config
Here is a live interactive demo of the default area axis chart with basic property configurations. Some of these configurations include axis labels, label orientations, label padding, tick mark sizes, and scaling.

 # {#area_curve}
### [#](#area_curve) Area Curve
Here is a live interactive demo of the curved area axis chart without any extra configurations.

# {#groups}
### [#](#groups) Groups
Here is a live interactive demo of the default area axis and line chart combo with group property configurations. You can assign multiple graphs into one group. Each group will share a color per graph, that way it is easier to see which graphs belong to which group. Additionally, multiple graph types can be included in a chart.

# {#horizontal_bar}
### [#](#horizontal_bar) Horizontal Bar
Here is a live interactive demo of the horizontal bar axis chart. It is similar in concept to the regular bar chart with a change to the `orient` property from `vertical` to `horizontal`.

# {#legend}
### [#](#legend) Legend
Here is a live interactive demo of the area axis chart combo with legend property configurations. Some of these configurations include legend icon clickability, orientation, and icon symbols.

# {#padding}
### [#](#padding) Padding
Here is a live interactive demo of the default area axis chart with padding configurations. Some of these configurations include chart padding, plane padding, and margins. These properties makes the charts and graphs easier to look at if the graphs start to look clustered within the chart.

# {#scale}
### [#](#scale) Scale
Here is a live interactive demo of the default area axis chart with axis scaling configurations. The scaling object is within the `x`-axis and/or the `y`-axis object. The type of axis declared will allow for different properties to be used. Certain properties are not interchangeable with all types. Like in the example below, a `type:"log"` axis is set and this allows the `base` property to be used. If `type:"log"` is set and a property from another type is used, for example the `exponent` property from `type:"pow"`, the graph will not render properly.

# {#scatter_sizes}
### [#](#scatter_sizes) Scatter Varying Sizes
Here is a live interactive demo of the default scatter axis chart with varying point size configurations. The `size` property inside the `generators` array is a multiplier for the size of all the points in the graph.

# {#stacked_bar}
### [#](#stacked_bar) Stacked Bar Chart
Here is a live interactive demo of the stacked bar chart without any extra configurations.

# {#transition}
### [#](#transition) Transition
Here is a live interactive demo of the axis chart with a transition configuration. If the button "Change Data!" is clicked, the axis chart will toggle between different data to demonstrate the transition animations. `.transition()` is used on the chart and chained with the desired `.duration(2000)` of microseconds.

 # {#typescript}
### [#](#typescript) Typescript
Here is a live interactive demo of the default area axis chart without any extra configurations using typescript. Typescript ensures proper types and properties are used when creating objects, arrays, etc.

branch_name: refs/heads/master

extension: md

gha_language: JavaScript

license_type: permissive


text:
---
layout: default
---

# 1997-03-23 - Re: "why privacy" revisit

## Header Data

From<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 727beb187156477625536471de7f96a0234342d61a54f20e6731bc4f67785aea

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1997-03-23 02:44:35 UTC

Raw Date: Sat, 22 Mar 1997 18:44:35 -0800 (PST)

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>Date: Sat, 22 Mar 1997 18:44:35 -0800 (PST)
To<EMAIL_ADDRESS>Subject: Re: "why privacy" revisit
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

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

 -=> Quoting<EMAIL_ADDRESS>to Harka <=-

 In> when i talk to people like the Direct Marketer's Assn., they honestly
 In> don't understand what the fuss is about. Their attitude is, quite
 In> literally, "What's the harm being done here?"

 In> what do you think the community interested in privacy protection can
 In> do to best illustrate to the general public the "harm" in the
 In> collection of personal information?

Information warfare. Collect information about DMA people, using
their own weapons against them. Then post it somewhere on the
Internet via remailers and cc themselves, Reuters and the New York
Times...

Ciao

Harka
___ Blue Wave/386 v2.30 [NR]

-----BEGIN PGP SIGNATURE-----
Version: 2.6.2

iQEVAgUBMzSWbzltEBIEF0MBAQFOzQf/SmUYerwG8oIDVe+PucyAybBAYpMBl+JT
eDl21Bs0jVa2+UXm8zDKQVDIkz004bTgpyX6vzockZ8cTUkW1UJJucjUfAXln1yB
HmdR9Go5mdurGbXf4QSN47nbfPc5V5sq8h7Ok2frFRqKLBejPSuEdP2pZo0OUPQD
bf0lE3l5lgTKlYqOzHt7NqHNAlcx3l0FOpflF+RR5DbLllBrIP7XYodMLMv+NR3T
V0oEk0woReL4+/O8iQ1oZuQ3MHNXkwCqR8w2wXnlou9ysfS58nTXgoNyFYKouGlN
Kc1bV2/G6mrG8PziTd3MsTL4TjdcmkdphZWVouo1LrEuhd3J5B4dBw==
=rbtn
-----END PGP SIGNATURE-----

If encryption is outlawed, only outlaws will have encryption...

{% endraw %}
```

## Thread

+ Return to [March 1997](/archive/1997/03)

+ Return to "[harka@nycmetro.com](/authors/harka_at_nycmetro_com)"

+ 1997-03-23 (Sat, 22 Mar 1997 18:44:35 -0800 (PST)) - Re: "why privacy" revisit -<EMAIL_ADDRESS>

license: MIT

gha_license_id: MIT


text:
# Frequently Asked Questions

We list some common troubles faced by many users and their corresponding
solutions here. Feel free to enrich the list if you find any frequent issues
and have ways to help others to solve them. If the contents here do not cover
your issue, please create an issue using the
[provided templates](https://github.com/open-mmlab/mmpretrain/issues/new/choose)
and make sure you fill in all required information in the template.

## Installation

- Compatibility issue between MMEngine, MMCV and MMPretrain

  Compatible MMPretrain and MMEngine, MMCV versions are shown as below. Please
  choose the correct version of MMEngine and MMCV to avoid installation issues.

  | MMPretrain version | MMEngine version  |   MMCV version   |
  | :----------------: | :---------------: | :--------------: |
  |    1.0.2 (main)    | mmengine >= 0.8.3 |  mmcv >= 2.0.0   |
  |       1.0.0        | mmengine >= 0.8.0 |  mmcv >= 2.0.0   |
  |      1.0.0rc8      | mmengine >= 0.7.1 | mmcv >= 2.0.0rc4 |
  |      1.0.0rc7      | mmengine >= 0.5.0 | mmcv >= 2.0.0rc4 |

  ```{note}
  Since the `dev` branch is under frequent development, the MMEngine and MMCV
  version dependency may be inaccurate. If you encounter problems when using
  the `dev` branch, please try to update MMEngine and MMCV to the latest version.
  ```

- Using Albumentations

  If you would like to use `albumentations`, we suggest using `pip install -r requirements/albu.txt` or
  `pip install -U albumentations --no-binary qudida,albumentations`.

  If you simply use `pip install albumentations>=0.3.2`, it will install `opencv-python-headless` simultaneously
  (even though you have already installed `opencv-python`). Please refer to the
  [official documentation](https://albumentations.ai/docs/getting_started/installation/#note-on-opencv-dependencies)
  for details.

## General Questions

### Do I need to reinstall mmpretrain after some code modifications?

If you follow [the best practice](../get_started.md#best-practices) and install mmpretrain from source,
any local modifications made to the code will take effect without
reinstallation.

### How to develop with multiple MMPretrain versions?

Generally speaking, we recommend to use different virtual environments to
manage MMPretrain in different working directories. However, you
can also use the same environment to develop MMPretrain in different
folders, like mmpretrain-0.21, mmpretrain-0.23. When you run the train or test shell script,
it will adopt the mmpretrain package in the current folder. And when you run other Python
script, you can also add `` PYTHONPATH=`pwd`  `` at the beginning of your command
to use the package in the current folder.

Conversely, to use the default MMPretrain installed in the environment
rather than the one you are working with, you can remove the following line
in those shell scripts:

```shell
PYTHONPATH="$(dirname $0)/..":$PYTHONPATH
```

### What's the relationship between the `load_from` and the `init_cfg`?

- `load_from`: If `resume=False`, only imports model weights, which is mainly used to load trained models;
  If `resume=True`, load all of the model weights, optimizer state, and other training information, which is
  mainly used to resume interrupted training.

- `init_cfg`: You can also specify `init=dict(type="Pretrained", checkpoint=xxx)` to load checkpoint, it
  means load the weights during model weights initialization. That is, it will be only done at the
  beginning of the training. It's mainly used to fine-tune a pre-trained model, and you can set it in
  the backbone config and use `prefix` field to only load backbone weights, for example:

```python
model = dict(
  backbone=dict(
      type='ResNet',
      depth=50,
      init_cfg=dict(type='Pretrained', checkpoints=xxx, prefix='backbone'),
  )
  ...
)
```

See the [Fine-tune Models](./finetune_custom_dataset.md) for more details about fine-tuning.

### What's the difference between `default_hooks` and `custom_hooks`?

Almost no difference. Usually, the `default_hooks` field is used to specify the hooks that will be used in almost
all experiments, and the `custom_hooks` field is used in only some experiments.

Another difference is the `default_hooks` is a dict while the `custom_hooks` is a list, please don't be
confused.

### During training, I got no training log, what's the reason?

If your training dataset is small while the batch size is large, our default log interval may be too large to
record your training log.

You can shrink the log interval and try again, like:

```python
default_hooks = dict(
    ...
    logger=dict(type='LoggerHook', interval=10),
    ...
)
```

### How to train with other datasets, like my own dataset or COCO?

We provide [specific examples](./pretrain_custom_dataset.md) to show how to train with other datasets.

repository: open-mmlab/mmpretrain

branch_name: refs/heads/main

gha_language: Python

repo_name: open-mmlab/mmpretrain


text:
# ebay-guitar-predict

This web app uses machine learning to predict the resale value of,
for the moment, electric guitars. The main data and model exploration
IPython notebooks are in a different but related repo for a blog post.
You can find that repo here:

[predict-guitar-value](https://github.com/jose-marquez89/predict-guitar-value)


text:
# Puppercoin Crowdsale

The following code creates an ERC20 token that will be minted through a Crowdsale contract which is leveraged from the OpenZeppelin Solidity library.    This contract will mint the tokens automatically and distribute them to buyers in one transaction.  The Crowdsale is required to enable refunds if successful and the goal is met, which is a maximum of 300 Ether.  The crowdsale will run for 24 weeks.  The Crowdsale will function over three smart contracts: PupperCoinSaleDeployer, PupperCoinSale and PupperCoin. These contracts have been deployed over the Kovan Test Networks with following addresses:

- **PupperCoinSaleDeployer Address: 0xc0312ad03f46D92e706Bf853CF9691f32e7e83B0**
- **PupperCoin Address: 0x1839c47F092b41276AfeE8db9F69B2eeEF857775**
- **PupperCoinSale Address: 0xbE3Eb231dEb7c9F93Bf5B0F8a00dA5cE01334428**

---

## Technologies

Language: Solidity

Developed with [Remix](https://remix.ethereum.org/) and [MetaMask](https://metamask.io/)

---

## Instructions
*For the purpose of this demonstration, the goal has been set to 3 Ether, the length of the Crowdsale has been shortened and all transactions are performed on a test network*

1. Compile PupperCoinSaleDeployer, PupperCoinSale and PupperCoin contracts
![compiler](Resources/compiler.png)

2. Deploy PupperCoinSaleDeployer contract
![deployer_contract](Resources/deployer_contract.gif)

3. Deploy PupperCoin and PupperCoinSale contracts
![coin_sale_contracts](Resources/coin_sale_contracts.gif)

4. Buy PupperCoin tokens and check out Crowdsale functionality
![buy_tokens](Resources/buy_tokens.gif)

5. Reach PupperCoin Crowdsale goal
![reach_goal](Resources/reach_goal.gif)

6. Close and finalize Puppercoin Crowdsale
![close_finalize](Resources/close.gif)

---

## Contributors

Drew Disbrow Marnell<EMAIL_ADDRESS>
---

## License

MIT License
Copyright (c) 2021 Drew Disbrow Marnell


text:
---
title: Release Notes for 0.1.4 PREVIEW
sidebar: overview_sidebar
keywords: introduction
permalink: rn_0104p.html
toc: false
tags: [getting_started]
folder: introduction
---

### 0.1.4 PREVIEW

Version | Handle  | Phase | State           | Release Date | Stability
--------|---------|-------|-----------------|--------------|----------------
0.1.4   | PREVIEW | Alpha | Released | 07/12/2018   | Volatile

The 0.1.4 PREVIEW release has the following highlights:
* Small update to the glossary
* Changed references to the specific "StratAuth" to a more generic "NHS Authentication Service" in the functional specification
* Added generic statement regarding reporting requirements
* Added reference to the IUC service specification in the UEC Landscape overview page
* Added content to the user stories overview page
* made the link to the FHIR profile website much more prominent by adding a clickable "specification version" to the sidebar. On clicking it links to the FHIR profile website

gha_language: CSS


text:
# bongloy-react-native

This is the Unofficial React Native library for Bongloy Payment Gateway API.

## Installation

```sh
npm install bongloy-react-native --save
# or
yarn add bongloy-react-native
```

## Usage

The package needs to be configured with your account's secret key, which is
available in the [Bongloy Dashboard](https://sandbox.bongloy.com/dashboard/api_keys). Require it with the key's
value:

<!-- prettier-ignore -->
```js
import bongloy from 'bongloy-react-native';

state = {
    params: {
      number: '6200000000000005',
      expMonth: 12,
      expYear: 24,
      cvc: '123',
    }
}

handlePayPress = async () => {
    try {
        bongloy.setDefaultPublishableKey({publishableKey: "pk_test_..."});
        const token = await bongloy.createToken(this.state.params)
        console.log(token);
    } catch (error) {
        console.log(error);
    }
}
```

## Documentation

See the [API docs](https://sandbox.bongloy.com/documentation).

repository: bongloy-community/bongloy-react-native

repo_name: bongloy-community/bongloy-react-native


text:
Rove
====
![Tests](https://github.com/mdiluz/rove/workflows/Tests/badge.svg) ![Docker](https://github.com/mdiluz/rove/workflows/Docker/badge.svg) [![rove](https://snapcraft.io//rove/badge.svg)](https://snapcraft.io/rove)

![Rove](https://github.com/mdiluz/rove/blob/master/data/icon.svg)

Rove is an asynchronous nomadic game about exploring as part of a loose community.

This repository contains the source code for the `rove-server` deployment and the `rove` command line client. See [mdiluz.github.io/rove](https://mdiluz.github.io/rove/) for game details, and [roveapi.proto](https://github.com/mdiluz/rove/blob/master/proto/roveapi/roveapi.proto) for the current server-client API.

repository: mdiluz/rove

gha_language: Go

repo_name: mdiluz/rove


text:
---
title: "Beta release for Python support"
excerpt: "Emmanuel Leblond (touilleMan) just released the first beta of his Python for Godot interface, which will allow developers to use Python 3 and its complete ecosystem as a scripting language in Godot 3.0."
categories: ["news"]
author: Rémi Verschelde
image: /storage/app/uploads/public/596/62b/1c4/59662b1c4ffa8859295653.png
date: 2017-07-12 08:59:44
---

*This is a guest post by Emmanuel Leblond (touilleMan), a Godot contributor and Python lover who develops a GDNative interface to use Python 3 as alternative scripting language in Godot. To answer the obligatory question: yes, the plan is still to ship Godot 3.0 with GDScript, VisualScript and C# support. Python support should also be ready by then and usable plug 'n play thanks to GDNative; its main advantage compared to the Python-like GDScript will be the access to the whole Python ecosystem.*

------

Who said Godot's only about waiting? Today we are releasing the [first beta version of Python for Godot](https://github.com/touilleMan/godot-python), the GDNative interface that enables you to use the full-blown Python 3 as a scripting language for Godot games. Now we need you to try it and give your feedback, so that it can be made as good as possible for the upcoming 3.0 release!

- [Release 0.9.0 page](https://github.com/touilleMan/godot-python/releases/tag/v0.9.0)
- [Direct link to 0.9.0 linux binary release](https://github.com/touilleMan/godot-python/releases/download/v0.9.0/godot-python-0.9.0.tar.bz2)
- [Repository for Godot Python](https://github.com/touilleMan/godot-python)

All core features of Godot are expected to work fine:

- Builtins (e.g. `Vector2`)
- Object classes (e.g. `Node`)
- Signals
- Variable export
- RPC synchronization

On top of that, mixing GDScript and Python code inside a project should work fine, have a look at the [Pong example](https://github.com/touilleMan/godot-python/tree/master/examples/pong) to see how you can convert one by one your existing GDScript code to Python fairly easily.

This release ships a recent build of Godot 3.0-alpha (yes, it's a beta based on an alpha...) and CPython 3.6.1 with the standard library and pip, ready to work with the Python ecosystem in its full glory (can't wait to see people experimenting game AI with [Pytorch](http://pytorch.org/)!).

The project is Linux-only so far, however you should be able to compile it from the sources if you are on macOS (let us know if you do so).
Binaries for all platforms will eventually be provided when Godot 3.0 gets stable.

As always, keep in mind this is a beta and you are expected to encounter issues and maybe crashes. If so, make sure to report them on the [project's bug tracker](https://github.com/touilleMan/godot-python/issues) ;-)

**PS:** A talk about Godot & Python was given last Monday at [EuroPython 2017](https://ep2017.europython.eu/conference/talks/bringing-python-to-godot-game-engine). You can watch the (for now unedited) recording [on YouTube](https://www.youtube.com/watch?v=h6MsqsJqnao&feature=youtu.be&t=2h35m09s); the edited version should be available later on [EuroPython's YouTube channel](https://www.youtube.com/c/EuroPythonConference).

repository: godotengine/godot-website

gha_language: HTML

repo_name: godotengine/godot-website


text:
# Collection of AutoHotKey scripts
AutoHotKey(http://ahkscript.org/) is a powerful, free, and open-source tool I used to customize some hotkeys.

To enable script when machine starts up:

1. Run > start shell:startup

2. Create a shortcut of the script you want

3. Place the shortcut under the folder you opened in Step 1. (Usually, \<UserFolder\>\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup)

repository: zarcen/dotwin

repo_name: zarcen/dotwin


text:
---
layout: page
title: Atari Surround Environment
permalink: /envs/gym/atari/surround/

redirect_from:
 - /envs/gym/atari-2600/surround/
 - /env/gym/atari/surround/
 - /env/gym/atari-2600/surround/

nav:
 - name: Overview
   permalink: '#overview'
 - name: Performances
   permalink: '#performances'
---

## Overview

<video autoplay muted loop controls>
  <source src="{{ 'assets/_pages/envs/gym/atari/surround.mp4' | absolute_url }}" type="video/mp4">
</video>

Like its predecessor Blockade, the object of Surround is to maneuver a square across the screen, leaving a trail behind. A player wins by forcing the other player to crash into one of the trails. Twelve game variations include options allow for speed-up, diagonal movement, wrap-around, and "erase" (the choice to not draw at a given moment). In addition, the sprites can be set to operate at a slower speed, or progressively speed up through five speeds.

*Description from [Wikipedia](https://en.wikipedia.org/wiki/Surround_(video_game))*

## Performances of RL Agents {#performances}

We list various reinforcement learning algorithms that were tested in this environment. These results are from [RL Database](https://github.com/seungjaeryanlee/rldb). If this page was helpful, please consider giving a star!

Star

### Human Starts

$human_table

### No-op Starts

$noop_table

### Normal Starts

$unspecified_table

repository: seungjaeryanlee/rldb

repo_name: seungjaeryanlee/rldb


text:
# Contributing

Contributions, issues and feature requests are very welcome. If you are using this app and improved it or fixed a bug, please consider submitting a PR!

## Guidelines

### Commit messages

This project uses [gitmoji](https://gitmoji.carloscuesta.me/) as the commit convention, because it's fun and provides an easy way of identifying the purpose or intention of a commit only by looking at the emojis used. All you have to do is to find the emoji corresponding to the purpose of your commit in [this list](https://gitmoji.carloscuesta.me/), followed by a short message explaining the update. You can also add a description if it's needed. That's all ;)

https://gitmoji.carloscuesta.me/

repository: zenika-open-source/FAQ

repo_name: zenika-open-source/FAQ


text:
# Post-install Steps

These are the first steps **after** you install WordOps. If you haven't installed it already, please check the [installation guide](installation-guide.md).

## Enable bash_completion

To enable WordOps commands auto-completion, run the following command after WordOps installation :

```bash
source /etc/bash_completion.d/wo_auto.rc
```

## Installing WordOps stacks (optional)

Before creating your first site with WordOps, you can install WordOps main stacks with the command

```bash
wo stack install
```

Here the list of WordOps components installed with the above

Component | Description |
----------|-------------|
Nginx     | WordOps web server |
PHP 7.2   | PHP7.2-FPM |
MariaDB 10.3 | Open-source version of MySQL |
WP-CLI    | The WordPress command-line tool
Composer  | PHP packages manager |
MySQLTuner | Command-line tool to tune MySQL |
phpMyAdmin | MySQL server web interface |
Adminer | lightweight phpMyAdmin alternative |
OpcacheGUI | web interface for Opcache monitoring |
Netdata | Monitoring suite |
Anemometer | MySQL Slow Query Monitor |


text:
[![Java CI with Maven](https://github.com/yannrichet/rsession/actions/workflows/maven.yml/badge.svg)](https://github.com/yannrichet/rsession/actions/workflows/maven.yml)

[![codecov](https://codecov.io/gh/yannrichet/rsession/branch/master/graph/badge.svg)](https://codecov.io/gh/yannrichet/rsession)
[![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.github.yannrichet/Rsession/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.github.yannrichet/Rsession)

# Rsession: R (3.5+) sessions wrapping for Java (8+) #

Rsession provides an easy to use java class giving access to remote or local R sessions.
The back-end engine should be:

 * "true" R (3.5, 3.6 and 4.x), through Rserve (locally spawned automatically if necessary, fully compatible with legacy R),
 * Renjin 3.5 (lower compatibility, but still very good),
 * and R2js, which is on-the-fly R translation to math.js, with lower compatibility and hack-style coding, but full BSD licence.

Rsession differs from R2js, Rserve or Renjin as it is a higher level API, and it includes server side startup of Rserve. It is also easier to use as it provides a multi session R engine for all these wrappers, whatever OS.

JRI is another alternative, but it does not provide multi-sessions feature.

## Example Java code ##
```java
import static org.math.R.*;
...

    public static void main(String args[]) {
        //Rsession r = new RserveSession(System.out, null, null);
        //Rsession r = new R2jsSession(System.out, null);
        Rsession r = new RenjinSession(System.out, null);

        double[] rand = (double[]) r.eval("rnorm(10)"); //create java variable from R command

        //...
        r.set("c", Math.random()); //create R variable from java one

        r.save(new File("save.Rdata"), "c"); //save variables in .Rdata
        r.rm("c"); //delete variable in R environment
        r.load(new File("save.Rdata")); //load R variable from .Rdata

        //...
        r.set("df", new double[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}}, "x1", "x2", "x3"); //create data frame from given vectors
        double value = (double) (r.eval("df$x1[3]")); //access one value in data frame

        //...
        r.toJPEG(new File("plot.jpg"), 400, 400, "plot(rnorm(10))"); //create jpeg file from R graphical command (like plot)

        String html = r.asHTML("summary(rnorm(100))"); //format in html using R2HTML
        System.out.println(html);

        String txt = r.asString("summary(rnorm(100))"); //format in text
        System.out.println(txt);

        //...
        System.out.println(r.installPackage("sensitivity", true)); //install and load R package
        System.out.println(r.installPackage("DiceKriging", true));

        r.end();
    }
```
## Use it ##

### Using maven: ###

Use this maven dependency:

```xml
<dependencies>
...
    <dependency>
      <groupId>com.github.yannrichet</groupId>
      <artifactId>Rsession</artifactId>
      <version>3.1.7</version>
    </dependency>
...
</dependencies>
```

### Using only R2js backend: ###

No 2nd order dependency required. Only based on Nashorn engine bundled in Java >8, so just add `rsession.jar` in your classpath:

  * https://github.com/yannrichet/rsession/blob/master/dist/rsession.jar

Then instanciate R session using:
```java
Rsession r = new R2jsSession(System.out,null);
```

### Using only Renjin backend: ###

Add `rsession.jar:renjin-jar-with-dependencies.jar` in your classpath:

  * https://github.com/yannrichet/rsession/blob/master/dist/rsession.jar
  * https://github.com/yannrichet/rsession/blob/master/lib/renjin-jar-with-dependencies.jar

Then instanciate R session using:
```java
Rsession r = new RenjinSession(System.out,null);
...
```

### Using only Rserve backend: ###

Install R 3.5+ or 4.x from http://cran.r-project.org, then add `rsession.jar:Rserve*.jar:REngine*.jar` in your project classpath:

  * https://github.com/yannrichet/rsession/blob/master/dist/rsession.jar
  * https://github.com/yannrichet/rsession/blob/master/lib/REngine-2.1.0.jar
  * https://github.com/yannrichet/rsession/blob/master/lib/Rserve-1.8.1.jar

Then:
  * start Rserve on localhost `/usr/bin/R CMD /usr/lib/R/library/Rserve/libs/Rserve --vanilla --RS-enable-control --RS-port 6311`, and instanciate R session using:
      ```java
      Rsession r = new RserveSession(System.out,null,RserverConf.parse("R://localhost:6311"));
      ```
  * or use the auto-spawned Rserve (may fail for exotic configuration):
      ```java
      Rsession r = new RserveSession(System.out,null,null);
      ```
  * connect to remote Rserve (eg. previously started on <IP_ADDRESS> with `/usr/bin/R CMD /usr/lib/R/library/Rserve/libs/Rserve --vanilla --RS-enable-control --RS-port 6311`:
      ```java
      Rsession r = new RserveSession(System.out,null,RserverConf.parse("R://<IP_ADDRESS>:6311"));
      ```

![Analytics](https://ga-beacon.appspot.com/UA-109580-20/rsession)

repository: yannrichet/rsession

repo_name: yannrichet/rsession


text:
### [CVE-2020-9976](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-9976)
![](https://img.shields.io/static/v1?label=Product&message=iOS&color=blue)
![](https://img.shields.io/static/v1?label=Product&message=tvOS&color=blue)
![](https://img.shields.io/static/v1?label=Product&message=watchOS&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=%3C%20iOS%2014.0%20and%20iPadOS%2014.0%20&color=brighgreen)
![](https://img.shields.io/static/v1?label=Version&message=%3C%20tvOS%2014.0%20&color=brighgreen)
![](https://img.shields.io/static/v1?label=Version&message=%3C%20watchOS%207.0%20&color=brighgreen)
![](https://img.shields.io/static/v1?label=Vulnerability&message=A%20malicious%20application%20may%20be%20able%20to%20leak%20sensitive%20user%20information&color=brighgreen)

### Description

A logic issue was addressed with improved state management. This issue is fixed in iOS 14.0 and iPadOS 14.0, tvOS 14.0, watchOS 7.0. A malicious application may be able to leak sensitive user information.

### POC

#### Reference
- http://seclists.org/fulldisclosure/2020/Nov/19

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

repository: trickest/cve

repo_name: trickest/cve


text:
# Redux Manifest
A paginated table implementation using Redux and React

## Demos
### Basic Redux Manifest Example

To run the **Basic Redux Manifest Example**, run the following command in the terminal:
```bash
npm run example
```
This will serve the application on `localhost:8081`.  Navigate to that page in your browser to see the Basic Redux Manifest Example.

![Alt text](/docs/basic-redux-manifest-example.png?raw=true "Optional Title")

### Storybook

To run [Storybook](https://github.com/storybooks/storybook) to test and debug individual React Components, run the following command in the terminal:
```bash
npm run demo
```
This will serve **Redux-Manifest** Storybook on `localhost:9001`.  Navigate to that page in your browser to see Storybook.

![Alt text](/docs/redux-manifest-storybook.png?raw=true "Optional Title")

repository: rycnhoj/redux-manifest

repo_name: rycnhoj/redux-manifest


text:
# TouchTheBlock
Touch The Block is simple touch game. You should touch the black block to survive in game.
It is written with javascript with Object-Oriented style.

##If you want to review the code
+ check ./index.html
+ check ./gamestate.html
+ check ./asset/js/game/*

##Have Fun!

##Author
+ Author: Sung-ju Kim
+ Email<EMAIL_ADDRESS>+ github: https://github.com/goddoe

##License
> MIT License

repository: goddoe/TouchTheBlock

repo_name: goddoe/TouchTheBlock


text:
# 1 Protocol Conformance

>***Protocol Witness*** - Given a type `T` [declared to conform to
>protocol](#11-declaration-of-protocol-conformance) `P` and a protocol
>requirement *m* of `P`, the [protocol witness](#12-protocol-witness) for *m* is
>the implementation that is the [most
>specialized](#14-most-specialized-implementation) of the [unconditionally
>accessible implementations](#13-unconditionally-accessible-implementations) of
>*m* on `T`, as determined in the scope in which the declaration `T: P` is
>stated.

When a type is declared to conform to a protocol, a set of
implementations--*protocol witnesses*--is determined, one for each protocol
requirement of the protocol.  This document specifies how Swift determines the
set of protocol witnesses for a protocol conformance.

## 1.1 Declaration of Protocol Conformance
For a type `T` to conform to a protocol `P`, `T` must be declared to conform to
`P`, and `T` must have at least one unconditionally accessible implementation
for each protocol requirement of `P`.  A distinct set of protocol witnesses is
established for the conformance `T: P`.

A declaration that `T` conforms to `P` further constitutes, with respect to each
protocol `o`*i* from which `P` directly or indirectly inherits, a
declaration that `T` conforms to `o`*i* so long as `T` has not
already been declared to conform to `o`*i*.  Thus, for the
declaration of `T: P` to be valid, the declarations of each `T: o`*i*
must satisfy the requirement that `T` have at least one unconditionally
accessible implementation for each protocol requirement of
`o`*i*. For each conformance `T: o`*i*, a distinct set of
protocol witnesses is established.

In a given scope, a type can conform to a protocol in only one way.  A type `T`
cannot be declared to conform to a protocol `P` if, within the visible scope,
another declaration exists of `T: P`.  This rule holds true even where competing
declarations are conditional with disjoint conditions.

## 1.2 Protocol Witness

Given the declaration of conformance `T: P`, a **protocol requirement** *m* is a
statement in the declaration of `P` that `T` (or any other type seeking to
conform to `P`) must have a member satisfying the requirements of *m*.  A member
of `T` that satisfies the requirements of *m* is referred to as an
*implementation* of *m*.

Given `T: P` and a protocol requirement *m* of `P`, one and only one of `T`'s
implementations of *m* will actually be used as the implementation of *m*.  Such
implementation of *m* is referred to as the *protocol witness* for the *m*
requirement of the conformance `T: P`.

The protocol witness for *m* is the implementation that is the *most
specialized* of the *unconditionally accessible* implementations of *m* on `T`,
as determined in the scope in which the declaration `T: P` is stated.  If `T`
has only one unconditionally accessible implementation of *m*, that
implementation will be the protocol witness.  If `T` has more than one
unconditionally accessible implementation of *m*, the most specialized of those
implementations will be the protocol witness.

An implementation is not *declared* to be a protocol witness.  The identity of
the protocol witness for a protocol requirement is inferred from the entirety of
the scope, including all declarations made within the scope and those imported
into the scope.  Careful engineering is required in order to achieve the
intended witness for a given requirement.

## 1.3 Unconditionally Accessible Implementations

A type's possible implementation of a protocol requirement is available to serve
as the protocol witness for the requirement only if the implementation is an
*unconditionally accessible* member of the type in the scope in which the
protocol conformance is declared.  Given a declaration of `T: P` and an
implementation of a protocol requirement *m* of `P`, the implementation is
*unconditionally accessible* if and only if (i) `T` satisfies the conditions, if
any, to which the declaration of the implementation is subject, and (ii) per the
rules of access control, the implementation is visible in the scope in which `T:
P` is declared.

With respect to generic types, clause (i) of this rule is not fully implemented.
A generic type instantiated with its generic arguments specified as concrete
types may be referred to as a *concretization* of the generic type.  A
concretization is a type separate and apart from its generic type.  Swift's
existing implementation of protocols does not include the ability for a
concretization to develop its own, specialized conformance relationship with a
protocol.  Instead, a concretization uses the protocol conformances of its
generic type, without specialization for implementations available via the
concretization.  Thus, although a concretization may satisfy the conditions of a
generic where clause that would make an implementation unconditionally
accessible, the implementation subject to such where clause nevertheless is
unavailable to serve as a protocol witness for the shared conformance.
  * Although specialized implementations available to a concretization are not
    available to serve as protocol witnesses and cannot be accessed via the
    interface of a protocol, they remain members of the concretization.
    Accordingly, as members, they may be accessed directly on the concretization
    following the rules applicable to resolution of overloads.
  * Notwithstanding the general inability of concretizations to take advantage
    of specialized implementations, the `Collection` family of protocols in the
    Standard Library uses a private attribute to gain some access to specialized
    implementations for concretizations of generic types conforming to
    `BidirectionalCollection` and `RandomAccessCollection`.

## 1.4 Most Specialized Implementation
Among a type's unconditionally accessible implementations of a protocol
requirement, the most specialized implementation will serve as the protocol
witness for the requirement.  The relative specialization between two
implementations, `i`*1* and `i`*2*, is determined as
follows:

If `i`*1* is declared in an extension of a protocol and
`i`*2* is declared on T (whether in the declaration and/or an
extension), then `i`*2* is more specialized.

If `i`*1* is declared in an extension of protocol p1 and
`i`*2* is declared in an extension of protocol p2, then (i) if p2
inherits from p1, `i`*2* is more specialized, (ii) if p1 inherits
from p2, `i`*1* is more specialized, and (iii) otherwise,
`i`*1* and `i`*2* present an ambiguity (if there is no
other implementation that is more specialized than both `i`*1* and
`i`*2*, an error will be raised at compile time).

If `i`*1* and `i`*2* are both declared on T (whether in
the declaration and/or an extension) or are both declared in extensions of the
same protocol, then (i) if the declaration of `i`*1* is more
constrained than the declaration of `i`*2*, `i`*1* is more
specialized, (ii) if the declaration of `i`*2* is more constrained
than the declaration of `i`*1*, `i`*2* is more
specialized, and (iii) otherwise, `i`*1* and `i`*2*
present an ambiguity (if there is no other implementation that is more
specialized than both `i`*1* and `i`*2*, an error will be
raised at compile time).[^1]

[^1]: Given the way conditional declarations work or don’t work, I’m not sure
      these declared-on-same-type situations could arise in a meaningful
      way. Thoughts?

## 1.5 Set of Protocol Witnesses

Given a declaration that a type conforms to a protocol, the protocol witness for
the conformance is the set consisting of the protocol witness for each declared
requirement of the protocol.  Inherited requirements of a protocol are
irrelevant to determination of a protocol witness set.

There is only one protocol witness set for a protocol conformance declaration.
Such set is immutable, and is not subject to replacement.

If a protocol has no declared requirements, the protocol witness set for
conformances to the protocol is empty.

repository: dabrahams/SwiftRef

repo_name: dabrahams/SwiftRef


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

### Description

Cubism Core in Live2D Cubism Editor 4.2.03 allows out-of-bounds write via a crafted Section Offset Table or Count Info Table in an MOC3 file.

### POC

#### Reference
No PoCs from references.

#### Github
- https://github.com/ARPSyndicate/cvemon
- https://github.com/CVEDB/PoC-List
- https://github.com/CVEDB/awesome-cve-repo
- https://github.com/CVEDB/top
- https://github.com/OpenL2D/moc3ingbird
- https://github.com/hktalent/TOP
- https://github.com/nomi-sec/PoC-in-GitHub


text:
This component is designed to catch and handle errors avoiding a total collapse in the application. "Error boundaries are React components that catch JavaScript errors anywhere in their child component tree, log those errors, and display a fallback UI instead of the component tree that crashed"

For more information go to: https://reactjs.org/docs/error-boundaries.html

~~~javascript
<ErrorBoundary>
    <ExampleComponent/>
</ErrorBoundary>

~~~

repository: Lean-Tech/create-react-lean-tech

repo_name: Lean-Tech/create-react-lean-tech


text:
This file describes some common pitfalls and how to solve them. Please always refer to this before opening an issue.

## Both platforms

 ### Asset not available/not found when playing local files

 Flutter requires that files are specified on your pubspec.yaml file, under flutter > assets, check [this](https://github.com/luanpotter/bgug/blob/master/pubspec.yaml#L89) for an example. Also keep in mind that `AudioCache` class will look for files under the `assets` folder and this class must be used to play local files.

### How to pause/stop audio?

The basic class of this package is the AudioPlayer class, which represents a single player playing a single audio, and it has methods `pause` and `stop` and `resume` to be used as you wish.

If you are using the `AudioCache` class, though, it does not have a pause method because that class generates new audio players every time you play, in order to allow for simultaneously playing. So the `play` or `loop` methods on that class returns the instance of `AudioPlayer` created, and you can save that to a variable and call `pause`/`stop`/`resume` on that instead. There is also a mode where `AudioCache` uses the same, `fixedPlayer`, but that is also returned in the method. Please take a look at the docs and source code for the `AudioCache` class for more details. Also, cf. [this stack overflow question](https://stackoverflow.com/questions/59229935/when-using-flame-audioplayers-how-to-stop-audios-from-audiocache/59229936#59229936).

## Android

 - Can't play remote files on Android 9: Android 9 has changed some network security defaults, so it may prevent you from play files outside https by default, [this stackoverflow question](https://stackoverflow.com/questions/45940861/android-8-cleartext-http-traffic-not-permitted) is a good source to solving this.

## iOs

 - Project does not compile with plugin: First check your xcode version, for some unknow reason compilation seens to fail when using older versions of xcode. Also, always try to compile the example app of this plugin, we try to keep the example app always updated and working, so if you can't compile it, the problem may be on your xcode version/configuration.

 - Audio doens't keep playing on the background: Apparently there is a required configuration for that to happen on your app, you add the following lines to your `info.plist`:

 ```
  <key>UIBackgroundModes</key>
  <array>
  	<string>audio</string>
  </array>
```

 - Can't play stream audio: One of the know reasons for streams not playing on iOs, may be because the stream is been gziped by the server, as reported [here](https://github.com/luanpotter/audioplayers/issues/183).

 ## macOS

 - Project does not compile with plugin: First check your xcode version, for some unknow reason compilation seens to fail when using older versions of xcode. Also, always try to compile the example app of this plugin, we try to keep the example app always updated and working, so if you can't compile it, the problem may be on your xcode version/configuration.

 - Can't play stream audio: One of the reasons for streams not playing on macOS, may be because the stream is been gziped by the server, as reported [here](https://github.com/luanpotter/audioplayers/issues/183).


text:
# FACT irf
Tools to calculate IRFs (instrument response functions) for the FACT telescope.

# Joint Crab Data and the FACT Open Data Release

The FACT open data release contains 17.7 hours of Crab Nebula observations taken in October 2013 by the First G-APD Cherenkov Telescope (FACT)
FACT is located on the Roque des los Muchachos on the Canary island of La Palma off the west coast of Africa. It is an imaging atmospheric
cherenkov telescope protoyping silicon-photomultipliers.
FACT data is stored in FITS files from the raw data level up to higher levels containing the results of our analysis.
All of the data used here is publicly available, including the simulated data used for gauging the instrument response. For more information about the data visit [https://fact-project.org/data](https://fact-project.org/data) or read the corresponding section in the paper.

All of FACT's software is open source and can be accessed at [https://github.com/fact-project/](https://github.com/fact-project/).

For more information about FACT's data do not hesitate to contact

 * Max Nöthe<EMAIL_ADDRESS> * Kai Brügge<EMAIL_ADDRESS>
Or contact the fact-online mailing list at

 *<EMAIL_ADDRESS>
 For the joint crab publication we manually selected a smaller dataset
 due to some runs having bad weather and getting a dataset with roughly equal
 number of excess events for each experiment.

```
python irf/scripts/fact_dl3_to_gadf.py -c 0.8 -t 0.03 ../gamma_diffuse_showers.hdf5 ../gamma_diffuse_precuts.hdf5 ../crab_dl3.hdf5 fact_dl3 --start '2013/11/04 00:00' --end '2013/11/07' -e 20131104_196 -e 20131105_175 -e 20131105_176 -e 20131105_199 -e 20131105_201

```

repository: fact-project/irf

repo_name: fact-project/irf


text:
# Introduction

28/05/2017

# Who I am?

Hi! My name is Iván Barbecho Delgado, I'm from Extremadura and I was born on 25.04.1994 and I'm finishingthe degree computer engineering in School of Technology of University of Extremadura. Currentlly, I'm working on a project of RoboLab, this consist in implementing a system of recognition and localization the objetcs for the robot Shelly, a robot of attention to the elderly people.

# What will I make?

First, I have studied the project learnbop. After of this, I have changed my timeline, because I thought that I should make a prototype of the user interface before of define a domain-specific language (DSL). In this way, I can define a DSL more pinpoint. Below is the prototype I've done

This prototype have 4 sections, these am "Program (With Text)", "Program (Visual)", "New Funtion" and "Existing functions".

### Program (With Text)

In this section, the user can program the Learnbot, in written form, using the funtions that have been  previously defined. This program is sent to Learnbot to be executed. On the right you can see the robot's camera.

![Image of section Program (With Text)](img/programtext.png)

### Program (Visual)

In this section, the user can program the Learnbot, in visual form, using the funtions that have been  previously defined. This funtions are show on the left, similar to Scratch. This program is sent to Learnbot to be executed.

![Image of section Program (Visual)](img/programvisual.png)

### New Funtion

In this section, the user can append other functions to the DSL in a simple way.

![Image of section New Funtion](img/NewFuntion.png)

### Existing functions

By last, In this section the user can edit the existing functions to the DSL in a simple way.

![Image of section Existing functions](img/existingfunctions.png)

Once the prototype was studied, I can start to define the DSL.

A simple structure to store the functions is save a code of function in a file, whose filename is the the name of function. These files will be saved in directories, whose directory name is a type of funtion.

This funtions will be load in a dictionary whose key will be the name of function and the will be stored the type and the code.

The next step will be make the parser of the DSL.

Finally, I will writen the documentation about all work done in GSoC.

* * *

Iván Barbecho Delgado (@ibarbech)

repository: robocomp/web

gha_language: SCSS

repo_name: robocomp/web


text:
# PN5_60894

**Created At:** 9/23/2019 9:58:53 AM
**Updated At:** 10/6/2019 11:03:58 AM
**Original Doc:** [pn5_60894](https://docs.jbase.com/75024-5-7-4-release-notes/pn5_60894)
**Original ID:** 459571
**Internal:** No

### Description

**listf -xml** fails on Linux

### Previous Release Behavior

The **listf -xml** command did not produce complete xml output.

This was primarily due to the jBASE **stat** command conflicting with the Linux one.

### Current Release Behavior

**listf -xml** produces correct xml output.

repository: CBarouch/docs

repo_name: CBarouch/docs


text:
## Cryptonomics Notes

### Table of contents

* [1 Great Reads](#1-great-reads)
* [2 Basics](#2-basics)
* [3 Mechanism Design](#3-mechanism-design)

### 1 Great Reads

* https://medium.com/l4-media/making-sense-of-cryptoeconomics-c6455776669
* https://en.wikipedia.org/wiki/Mechanism_design

### 2 Basics

**Cryptoeconomics** is the use of incentives and cryptography to design new kinds of systems, applications, and networks. Cryptoeconomics shares an interlap with mechanism design (aka reverse game theory). Mechanism design starts with a desired outcome and then work backwards to design a game that, if players pursue their own self interest, will produce the outcome we want.

Cryptoeconomics is what distinguishes blockchains with a coin and what makes them different from other technologies. This can be seen in the case of Bitcoin whose design relies on economic incentives and penalties. Economic rewards for miners to contribute blocks, economic costs/penalties in undermining the system ([cost of 51% attack](https://gobitcoin.io/tools/cost-51-attack/ "hardware and mining costs")) and cryptography protocols to secure the system. This cryptoeconomics provides a security guarantee for the distributed system through the high economic costs required to subvert it.

According to Vlad Zamfir, "Cryptoeconomics is the application of incentive mechanism design to information security problems".

Watch [BIP001 Vlad Zamfir Video](https://www.youtube.com/watch?v=u6VSPD5TrP4&feature=youtu.be&t=6m11s "What's cryptoeconomics")

Study:
[Vickrey Auctions](https://en.wikipedia.org/wiki/Vickrey_auction#Proof_of_dominance_of_truthful_bidding "Vickrey Auctions")
[State Channels](http://www.jeffcoleman.ca/state-channels/ "State Channels")

### 3 Mechanism Design

Mechanism Design vs. Game Theory

• **Game Theory**: What is the outcome of strategic interaction between individuals in a given game, i.e., economic environment/institution?

• **Mechanism Design**: How do we design the game, i.e., economic environment/institution to obtain a certain outcome?

Mechanism Design studies solution concepts of playing private information games with the features:
- that a game "designer" chooses the game structure rather than inheriting one
- that the designer is interested in the game's outcome

Watch [Eric Maskin - An Introduction to Mechanism Design @ Warwick Economics Summit 2014](https://www.youtube.com/watch?v=XSVoeETsEcU "What's mechanism design")

repository: WizardOfAus/WizardsEthereumWorkshop

repo_name: WizardOfAus/WizardsEthereumWorkshop


text:
# Tech Leading - Facilitation

## Articles

- [Jacob King - Disciplines of Meaningful Meetings (How the Big Guys do it)](https://cleverchecklist.com/blog/thoughts/disciplines-of-meaningful-meetings/)

- [Kate Heddleston - Argument Cultures and Unregulated Aggression](https://kateheddleston.com/blog/argument-cultures-and-unregulated-aggression)
Takeaway: Dominance is more concerned with winning than with truth. People make decisions from a place of emotion rather than logic (our brains are not rational or logical).  Understand when the idea is to expand ideas and when the goal is to narrow them down. Have a process in place to prevent unnecessary arguing.  Have people argue for ideas they didn't suggest.

- [Kate Matsudaira - How to Run an Effective Meeting](http://katemats.com/how-to-run-an-effective-meeting/)
Takeaway: Set goals for the meeting - defined outcomes. Have someone else take the notes. Track key conclusions and get the note taker to read them out at the end to make sure none were missed.

- [Kate Matsudaira - Handling Technical Disagreements with Finesse](http://katemats.com/handling-technical-disagreements-with-finesse/)
Takeaway: Rarely one right answer to the problem. Don't be defensive. Make your opposer feel heard by repeating back their proposal with the good points about it. Focus on the pros, cons and risks of the solutions – not the solutions themselves.

## Training Courses and Videos

- [Stephen Haunts - Pluralsight - How to Run Effective Meetings](https://app.pluralsight.com/library/courses/run-effective-meetings) 💲

- [Tomek Kaczanowski - Problem-solving techniques for groups](https://vimeo.com/126778448) [25:29]
Takeaway: Break into smaller groups. Use 5 whys. Use Ishikawa/Fishbone diagrams for breadth first discussions. Use de Bono's thinking hats. Presence of leaders can influence decision making as people don't want to disagree with their leaders.

💲 - *paid for content*

repository: PeterCookDev/TechLeading

repo_name: PeterCookDev/TechLeading


text:
## Usage
 - Install [Python 3].
 - Clone the repository.
 - Run `pip install moviepy youtube_dl`.
 - Install [Docker] on your device.
 - In a separate terminal, run `docker --name gentle --network host -P lowerquality/gentle`.
 - To use, run `python src/build_dataset.py <playlist file>`
 - Add `train` to format the dataset for training
 - Add `val` to format the dataset for validation
 - Add `predict` to format the dataset for prediction
 - If you're receiving an `ImportError: DLL load failed` for `_mklinit`, upgrade numpy with `pip install --upgrade numpy`.

## Dataset structure
 - The playlist file should be a `.txt` file, with each line containing a URL for one YouTube video.
 - The video will be placed into the `videos` folder
 - The audio from the video is placed into the `audio` folder
 - The transcript from YouTube subtitles is placed into the `transcripts` folder
 - The JSON alignment is placed into the `jsons` folder
 - The training words are placed into `dataset/[word]/train/`
 - The validation words are placed into `dataset/[word]/val/`
 - The prediction words are placed into `predict/[word]`
 - A list of videos in the dataset can be found in `src/downloads.txt`

## Dependencies
 - [Python 3]
 - [Moviepy] for video processing
 - [Gentle] for producing JSON alignments
 - [YoutubeDL] for downloading videos and metadata from YouTube
 - [Docker] for accessing the [Gentle] Docker image

[Python 3]: <https://www.python.org/downloads/>
[MoviePy]: <https://zulko.github.io/moviepy/>
[Gentle]: <http://lowerquality.com/gentle/>
[YoutubeDL]: <https://youtube-dl.org/>
[Docker]: <https://www.docker.com/>

repository: bedia-tv/lippy

repo_name: bedia-tv/lippy


text:
# Arctic Bio Map Server v2

This is the server backend code that is used for communicating with the Arctic Bio Map (ABM) mobile client.

It is also used by the ABM Front-End Portal for visualizing the sightings information for researchers.

This server is written in Python 2.7.

## Development

Checkout a copy of the [repository from BitBucket](https://bitbucket.org/geosensorweblab/arctic-biomap-server). Install Python 2.7 on your system if it is not already; Linux and Mac OS X may already have a copy installed.

Then install `tornado` and `sqlalchemy`.

    $ pip install tornado
    $ pip install sqlalchemy
    $ pip install mysql-python

Create a new database in MySQL:

    $ mysql -uroot
    mysql> create database abm;
    mysql> ^D

Start up a local server with:

    $ cd backend
    $ python server.py DATABASE_URL="" COOKIE=""

`DATABASE_URL` must be a database connection URL like `mysql://USER:PASS@HOST/DB`. `COOKIE` must be a random hex string. If COOKIE changes, then all users signed into the server through their browser will be logged out.

## Tests

Tests are available in the `backend/tests` directory. They are Shell scripts so will only work on Mac/Unix systems. Be sure to install [jq](https://stedolan.github.io/jq/) for your OS.

## abm-server.conf

This is a configuration file for Upstart on Ubuntu. Edit the file to point to the location of your production installation and then install the file in `/etc/init`. Then you can control the server with `initctl`:

    $ sudo initctl status abm-server
    $ sudo initctl start abm-server
    $ sudo initctl stop abm-server
    $ sudo initctl restart abm-server

The script will also automatically start the server when the host starts up.

## License

This project is MIT Licensed.

repository: johan--/arctic-biomap-server

extension: markdown

repo_name: johan--/arctic-biomap-server


text:
GitHub Africa
=============

Project to help highlight GitHub usage in Africa

Methodology
-----------

Using GitHub API's we searched for all GitHub user's who had an African country or city listed in their profile.  This is obviously an imperfect method but does help illustrate where GitHub usage in Africa is occuring.  We feel this provides a good proxy where opensource and modern software practices is growing in Africa.

These scripts in this repo where used to generate the [github-africa-users](https://github.com/codeafrica/github-africa/blob/master/data/github-africa-users-20141231.csv) list.  We used this data to create the GitHub Africa User's Map at: [codeafrica.org](http://codeafrica.org)

About
-----

This is part of the [CodeAfrica](http://codeafrica.org) initiative supported by [Ona](http://company.ona.io) and [Yeleman](http://yeleman.com) - software companies building world class open source software in Nairobi, Kenya and Bamako, Mali.

Usage
-----

* Create a virtualenv and `pip install -r requirements.pip` inside.
* Copy `secret.py.example` to `secret.py`
* Edit `secret.py` with a `clientID` and `secretID` from your github profile/auth page
* Add your username and password (in clear) to `secret.py`
* Launch `./auth.py` and export the `GITHUB_TOKEN` variable as suggested.
* You can now clear/remove `secret.py`
* Launch `step1_search_by_location.py`
* Launch `step2_cleanup_users.py`
* Launch `step3_extend_users.py`
* Launch `step4_cleanup_dates.py`
* Launch `step5_export_for_map.py`

Main per-user data is located in `step4.json`.
The Step5 creates a CSV file usable with Mapbox Studio to create a simple map based on number of users per country/city.

repository: ambalde/github-africa

repo_name: ambalde/github-africa


text:
# data-pull

## Dependencies
- [pyCMR](https://github.com/nasa/pyCMR)
- [gensim](https://radimrehurek.com/gensim/install.html)

repository: montaguegabe/data-pull

repo_name: montaguegabe/data-pull


text:
# Web Bluetooth Demos

Check your [browser and platform implementation status](https://github.com/WebBluetoothCG/web-bluetooth/blob/gh-pages/implementation-status.md) first.

### Hosted here: https://webbluetoothcg.github.io/demos/

- [Bluetooth LED Display](/bluetooth-led-display/)
- [Bluetooth Printer](/bluetooth-printer/)
- [Bluetooth Racing Cars](/bluetooth-racing-cars/)
- [Bluetooth Rename Tool](/bluetooth-rename/)
- [Bluetooth Toy BB-8](/bluetooth-toy-bb8/)
- [Bluetooth Toy Plane](/bluetooth-toy-plane/)
- [Heart Rate Sensor](/heart-rate-sensor/)
- [PLAYBULB Candle](/playbulb-candle/)

### Hosted Elsewhere

- [Chrome's Web Bluetooth Samples](https://googlechrome.github.io/samples/web-bluetooth/index.html) by [@beaufortfrancois](https://github.com/beaufortfrancois) and [others](https://github.com/GoogleChrome/samples/commits/gh-pages/web-bluetooth).
- [CoolBeans for Node.js](https://github.com/monteslu/coolbeans) by [@monteslu](https://github.com/monteslu)
- [BB-8 Controlled via Web Bluetooth and Web Audio](https://nimbleape.github.io/demos/bluetooth-toy-bb8/) by [@nimbleape](https://github.com/nimbleape)
- [Parrot Mini Drone Controller](https://github.com/poshaughnessy/web-bluetooth-parrot-drone) by [@poshaughnessy](https://github.com/poshaughnessy)
- [BB-8 Control](https://github.com/operasoftware/bb8) by [@operasoftware](https://github.com/operasoftware)
- [Physical Web Light Switch](https://github.com/hardillb/physical-web-lightswitch) by [@hardillb](https://github.com/hardillb)
- [purple-eye](https://github.com/urish/purple-eye) by [@urish](https://github.com/urish)
- [Eddystone Beacon Configuration](https://beaufortfrancois.github.io/sandbox/web-bluetooth/eddystone-url-config/index.html) by [@beaufortfrancois](https://github.com/beaufortfrancois)
- [webble-mip](https://github.com/urish/webble-mip) by [@urish](https://github.com/urish)
- [MakeBlock mBot Robot](https://github.com/binomed/mbot-webbluetooth) by [@binomed](https://github.com/binomed)
- [Remote Lego project](https://github.com/devmil/remotelego) by [@devmil](https://github.com/devmil)
- [nrf52-Quadcopter](https://github.com/NordicSemiconductor/nrf52-quadcopter) by [@NordicSemiconductor](https://github.com/NordicSemiconductor)
- [Sphero Ollie Robot](https://github.com/binomed/sphero_ollie-web-bluetooth) by [@binomed](https://github.com/binomed)
- [noble with Web Bluetooth](https://github.com/monteslu/nobleweb) by [@monteslu](https://github.com/monteslu)
- [Smart Bluetooth Bulb](https://github.com/urish/web-lightbulb) by [@urish](https://github.com/urish)
- [bleno Pizza Builder](https://github.com/strangesast/bleno-web-pizza-example) by [@strangesast](https://github.com/strangesast)
- [ReactJS Heart Rate Monitor](https://github.com/yossi-eynav/ble-heart-rate-demo) by [@yossi-eynav](https://github.com/yossi-eynav)
- [Lend me your ears!](https://github.com/lachendeKatze/relay-click) by [@lachendeKatze](https://github.com/lachendeKatze)
- [Rowing Monitor](https://github.com/GoogleChrome/rowing-monitor) by [@andreban](https://github.com/andreban)
- [SBrick Web Controller](https://github.com/360fun/SBrick-Web-Controller) by [@360fun](https://github.com/360fun)
- [Walk the Lexington Battle Road](https://www.youtube.com/watch?v=O7KF0-aVvl8) ([article](https://developer.telerik.com/content-types/tutorials/get-ready-web-bluetooth/)) by [@jlooper](https://github.com/jlooper)
- [Update device firmware via Nordic's DFU](https://github.com/thegecko/web-bluetooth-dfu/) by [@thegecko](https://github.com/thegecko)
- [Nordic Thingy:52 Web App](https://github.com/NordicSemiconductor/webapp-nordic-thingy) by [@NordicSemiconductor](https://github.com/NordicSemiconductor)
- [BLE Keyboard & Mouse Dongle](https://github.com/DeqingSun/BLE-Keyboard-Mouse-Dongle) by [@DeqingSun](https://github.com/DeqingSun)
- [Connect to the Myo armband](https://github.com/charliegerard/myo-web-bluetooth.js) by [@charliegerard](https://github.com/charliegerard)
- [Mercedes-Benz car emulator demo](https://www.youtube.com/watch?v=97MlLkfLVf0) by [Mercedes-Benz Digital Challenge](http://www.mercedes-benz-challenge.com/)
- [Connect to BBC micro:bit](https://github.com/ngammarano/microbit-web-bluetooth) by [@ngammarano](https://github.com/ngammarano)

repository: WebBluetoothCG/demos

branch_name: refs/heads/gh-pages

repo_name: WebBluetoothCG/demos


text:
# metaMIC: Reference-free Misassembly Identification and Correction of metagenomic assemblies
metaMIC is a fully automated tool for identifying and correcting misassemblies of (meta)genomic assemblies with the following three steps. Firstly, metaMIC extracts various types of features from the alignment between paired-end sequencing reads and the assembled contigs. Secondly, the features extracted in the first step will be used as input of a random forest classifier for identifying misassembled metagenomic assemblies. Thirdly, metaMIC will localize misassembly breakpoints for each misassembled contig and then correct misassemblies by splitting into parts at the breakpoints.

## Requirements and Installation
Make sure you have the dependencies below installed and accessible in your $PATH.

### Prepare dependencies

- [python 3.6-3.9](https://www.python.org/downloads/)
- [pandas](https://pandas.pydata.org/)
- [numpy](https://numpy.org/)
- [pysam](https://pypi.org/project/pysam/0.8.4/)
- [biopython](https://pypi.org/project/biopython/)
- [bwa 0.7.17](https://sourceforge.net/projects/bio-bwa/files/)
- [samtools 1.9](https://sourceforge.net/projects/samtools/files/samtools/)
- [jellyfish](http://www.cbcb.umd.edu/software/jellyfish/)
- [scikit-learn](https://scikit-learn.org/stable/)
- [scipy](https://www.scipy.org/)

1. install python modules: pandas, numpy, pysam
```
conda install -c bioconda pandas numpy pysam biopython
```
or

```
pip install pysam pandas numpy biopython
```

2. download and install samtools, bwa, jellyfish
```
conda install -c bioconda samtools bwa jellyfish
```
or

```
wget https://github.com/samtools/samtools/releases/download/1.9/samtools-1.9.tar.bz2
tar -jxvf samtools-1.9.tar.bz2
cd samtools-1.9
./configure
make
make install
export PATH=`pwd`:$PATH
```

```
wget https://sourceforge.net/projects/bio-bwa/files/latest/download/bwa-0.7.17.tar.bz2
tar -jxvf bwa-0.7.17.tar.bz2
cd bwa-0.7.17
make
export PATH=`pwd`:$PATH
```

```
wget http://www.cbcb.umd.edu/software/jellyfish/jellyfish-1.1.10.tar.gz
tar zxvf jellyfish-1.1.10.tar.gz
cd jellyfish-1.1.10
./configure
make
make install
export PATH=`pwd`/bin:$PATH
```

### Installation

##### Install metaMIC via git

```
git clone https://github.com/ZhaoXM-Lab/metaMIC.git
```
- install and download [training models](https://zenodo.org/record/4781819#.YKm_omYzZTY)

```
cd metaMIC
python setup.py install
metaMIC -h

# downloading models
metaMIC download_model
```

## Quick Start
- First map paired-end reads to assembled contigs

```
bwa index $contig_file
bwa mem -a -t 8 $contig_file $read1 $read2 | samtools view -h -q 10 -m 50 -F 4 -b | samtools sort > $bam_file
```
- generate pileup file

```
samtools mpileup -C 50 -A -f $contig_file $bam_file |  awk '$3 != "N"' > $pileup_file
```
- run metaMIC

#### For metagenomics

```
# Step 1: extract features [output file: feature_matrix/window_fea_matrix.txt,feature_matrix/contig_fea_matrix.txt]

metaMIC extract_feature --bam $bam_file -c $contig_file -o $output_dir --pileup $pileup_file -m meta

# Step 2: misassembly breakpoint identification and correction;
# output directory must be same as the above $output_dir
# [output file: metaMIC_corrected_contigs.fa, misassembly_breakpoint.txt, anomaly_score.txt]

metaMIC predict -c $contig_file -o $output_dir -a MEGAHIT -m meta
```
#### For isolate genomes

```
# Step 1: extract features [output file: feature_matrix/window_fea_matrix.txt]

metaMIC extract_feature --bam $bam_file -c $contig_file -o $output_dir --pileup $pileup_file -m single

# Step 2: misassembly breakpoint identification and correction;
# output directory must be same as the above $output_dir
# [output file: metaMIC_corrected_contigs.fa, misassembly_breakpoint.txt, anomaly_score.txt]

metaMIC predict -c $contig_file -o $output_dir -m single
```
#### Training on new datasets

If you want to generate a new training model on a novel dataset. Contig labels and name of new training models should be provided.
The Step 1 is the same as above, then the contig_fea_matrix.txt will be used as the training datasets.

```
# Step 1: extract features [output file: feature_matrix/window_fea_matrix.txt,feature_matrix/contig_fea_matrix.txt]

metaMIC extract_feature --bam $bam_file -c $contig_file -o $output_dir --pileup $pileup_file -m meta

# Step 2: Generating new training models
# output directory must be same as the above $output_dir
# format of contig_label file should be:
# contig1\t0
# contig2\t1
# contig3\t0
# ...
# contig100\t0

metaMIC train -o $output_dir -a $New_model_name --label $contig_label
```

For more details about the usage of metaMIC, [read the docs](http:)

## Example

##### example data

- R.sphaeroides_pileup.out
- R.sphaeroides.bam
- velvet_ctg.fasta

```
cd example
sh download.sh
metaMIC extract_feature --pileup R.sphaeroides_pileup.out --bam R.sphaeroides.bam -c velvet_ctg.fasta -m single -o test
metaMIC predict -c velvet_ctg.fasta -o test -m single
```

## Output
The output folder will contain
1. Misassembly score for each contig: **metaMIC_contig_score.txt** (for only metagenomics)
2. predicted misassembly breakpoints for misassembled contigs: **misassembly_breakpoint.txt**
3. Anomaly scores for each position in contigs: **anomaly_score.txt**
4. Fasta file of corrected contigs: **metaMIC_corrected_contigs.fa**
5. Some intermediate files

For more details about the output, [read the docs](http:)

## Complete option list
metaMIC:

```
usage: metaMIC [-h]  ...

Reference-free Misassembly Identification and Correction of metagenomic
assemblies

optional arguments:
  -h, --help       show this help message and exit

metaMIC subcommands:

    extract_feature
                   Extract features from inputs.
    predict        Predict.
    train          Train model.

usage: metaMIC extract_feature [-h] [-t THREADS] [--bam BAMFILE] [--r1 READ1]
                               [--r2 READ2] [-p READ] -c ASSEMBLIES -o OUTPUT
                               --pileup PILEUP -m MODE [-l MIN_LENGTH]
                               [--samtools SAMTOOLS] [--jellyfish JELLYFISH]

optional arguments:
  -h, --help            show this help message and exit
  -t THREADS, --threads THREADS
                        Maximum number of threads [default: 8]
  --bam BAMFILE         index bam file for alignment
  --r1 READ1            read1
  --r2 READ2            read2
  -p READ, --r READ     smart pairing (ignoring #2 fasta/q)
  -c ASSEMBLIES, --contig ASSEMBLIES
                        fasta file of assembled contigs
  -o OUTPUT, --output OUTPUT
                        output directory for metaMIC results
  --pileup PILEUP       path to pileup file [samtools mpileup]
  -m MODE, --mode MODE  Applied to single genomic/metagenomic assemblies
                        [meta/single]
  -l MIN_LENGTH, --mlen MIN_LENGTH
                        Minimum contig length [default: 5000bp]
  --samtools SAMTOOLS   path to samtools
  --jellyfish JELLYFISH
                        path to jellyfish

usage: metaMIC predict [-h] -o OUTPUT -m MODE -c ASSEMBLIES [-a ASSEMBLER]
                       [-l MIN_LENGTH] [-s SPLIT_LENGTH] [--nb BREAK_COUNT]
                       [--rb BREAK_RATIO] [--at ANOMALY_THRED]

optional arguments:
  -h, --help            show this help message and exit
  -o OUTPUT, --output OUTPUT
                        output directory for metaMIC results
  -m MODE, --mode MODE  Applied to single genomic/metagenomic assemblies
                        [meta/single]
  -c ASSEMBLIES, --contig ASSEMBLIES
                        fasta file of assembled contigs
  -a ASSEMBLER, --assembler ASSEMBLER
                        The assembler-specific model or user-trained model
                        used for assembled fasta file [MEGAHIT/IDBA_UD/[new
                        training model specified by users]]
  -l MIN_LENGTH, --mlen MIN_LENGTH
                        Minimum contig length [default: 5000bp]
  -s SPLIT_LENGTH, --slen SPLIT_LENGTH
                        Minimum length of splitted fragments [default: 1000bp]
  --nb BREAK_COUNT      Threshold of read breakpoint counts for correcting
                        misassemblies in metagenomics
  --rb BREAK_RATIO      Threshold of read breakpoint ratio for correcting
                        misassemblies in metagenomics
  --at ANOMALY_THRED    Threshold of anomaly score for correcting
                        misassemblies in metagenomics

usage: metaMIC train [-h] -o OUTPUT [--label LABEL] [-a ASSEMBLER]
                     [-t THREADS]

optional arguments:
  -h, --help            show this help message and exit
  -o OUTPUT, --output OUTPUT
                        output directory for metaMIC results
  --label LABEL         Misassembly label of contigs for training assemblies
  -a ASSEMBLER, --assembler ASSEMBLER
                        The name of the directory of the trained model.
  -t THREADS, --threads THREADS
                        Maximum number of CPUs [default: 8]
```

repository: nick-youngblut/metaMIC

repo_name: nick-youngblut/metaMIC


text:
# Generative

https://edwardscam.github.io/generative/

Messing around with generative algorithms. See examples folder for demos.
Select a pattern and hit draw! You can tweak parameters as you go.

---

## Patterns

### Infinity Cycle
This is a mutant sinusoid that animates as it draws. You can modify the phase, rotation speed, and several other parameters.

### Roots
This algorithm attemps to re-create the behavior of tree branches or roots. At each branch, it makes partially-random decisions about where to draw the next line (but also partially dependent on the parameters you set). There is a "decay" factor, which affects the width, length, and flexibility of a branch. So as you get further from the root, your branches get shorter but they can bend more. Branches will attempt to fill in the entire boundary, but will also try very hard to not intersect with other branches.

### Chipboard
This one takes a square, and attempts to fill in that square by chopping it into quarters and recursively repeating this process on each sub-square (until it reaches a minimum size, which you can modify). There's an element of randomness as to how it chops up each square, which you can also modify. The end result is it kind of looks like a big ol' motherboard.

---

## Local setup

* `npm install`
* `npm run start`
* open `http://localhost:8080/`

repository: edwardsCam/generative

repo_name: edwardsCam/generative


text:
# Contributing

## Table of contents

- [Introduction](#introduction)
- [How to contribute](#how-to-contribute)
- [How to raise an issue](#how-to-raise-an-issue)

## Introduction

Thank you very much for being here! First of all, I want to let you know that contributions are more than welcome and really appreciated.

In case you want to contribute, even with a small bug fix, you will be featured into the [credits](https://github.com/JustWhit3/useful-guides/blob/main/README.md#:~:text=on%20VS%20Code.-,Credits,Repository%20leaders,-Gianluca%20Bianco) file.

## How to contribute

To add your contribution, please follow these guidelines:

1) Fork your own copy of the repository.
2) Work on your changes / improvements in the forked repo.
3) **Test** if your changes / improvements are correctly implemented and all the other features are not compromised.
4) Finally, make the pull request.

Once your pull request will be submitted, I will carefully review it and, if it will be considered as an improvement, I will confirm it.

## How to raise an issue

If you find any bug or something you think doesn't work correctly, you are free to open an issue.

Once the issue is received, I will analyze it and once is solved I will respond asking confirmation about my fixing. In this case, if any answer is received in 7 days, the issue will be automatically closed.


text:
[![Docker Pulls](https://img.shields.io/docker/pulls/cloudonmymind/hexo-aws.svg)](https://hub.docker.com/r/cloudonmymind/hexo-aws/)

Hexo with AWS CLI and SDK
============

Hello!  This is a docker repository for an image containing [Hexo](https://hexo.io/) and the AWS CLI and SDK

This can be downloaded from [Docker Hub](https://hub.docker.com/r/cloudonmymind/hexo-aws/)

The image is currently used in the pipeline to build this blog: www.thecloudonmymind.com !

## Components

The components of this image are:
* node:13-slim
* Git
* AWS cli
* AWS sdk
* Hexo CLI

## Usage

The current intended use of this image is to pull hexo repo's from git and then push these to AWS S3.  For an example usage please visit: https://github.com/paulmarsicloud/hexo-cloudonmymindblog/blob/master/.circleci/config.yml

repository: cloudonmymind/docker-hexo-aws-base

repo_name: cloudonmymind/docker-hexo-aws-base


text:
# **Traffic Sign Recognition**

## Writeup

---

**Build a Traffic Sign Recognition Project**

The goals / steps of this project are the following:
* Load the data set (see below for links to the project data set)
* Explore, summarize and visualize the data set
* Design, train and test a model architecture
* Use the model to make predictions on new images
* Analyze the softmax probabilities of the new images
* Summarize the results with a written report

Datasets for training, validation and test:
-train.p
-valid.p
-test.p

---
### Writeup / README

### Data Set Summary & Exploration

#### Basic summary of the dataset.

The pandas library has been used to calculate summary statistics of the traffic signs dataset:
* The size of training set is: 34799
* The size of the validation set is: 4410
* The size of test set is: 12630
* The shape of a traffic sign image is: 32x32
* The number of unique classes/labels in the data set is: 43

### Design and Test a Model Architecture

#### 1. Preprocessing
An original data is in a range between 0 and 255. Therefore the images have been normalized to have zero mean and one standard deviation.

#### 2. Model architecture
The final model consisted of the following layers:

| Layer         		|     Description	        					|
|:---------------------:|:---------------------------------------------:|
| Input         		| 32x32x3 RGB image   							|
| Convolution 5x5     	| 1x1 stride, valid padding, outputs 28x28x6 	|
| RELU					|												|
| Max pooling	      	| 2x2 stride,  outputs 14x14x6 				    |
| Convolution 5x5	    | 1x1 stride, valid padding, outputs 10x10x16   |
| ReLU                  |                                               |
| Max pooling           | 2x2 stride, valid padding, 5x5x16             |
| Fully connected		| Input size: 400, output size: 120             |
| ReLU                  |                                               |
| Fully connected       | Input size: 120, output size: 84              |
| Softmax				| Input size: 84, output size: 43 |
|						|												|

#### 3. Model Training
To train the model, the Adam optimizer with a loss function = cross entropy has been used. The used hyperparameters are the following:
* learning rate: 0.002
* number of epochs: 30
* batch size: 256
Dropout has been used for two fully connected layers:
* keeping probability: 0.4

#### 4. Results
My final model results were:
* training set accuracy: 0.995
* validation set accuracy: 0.955
* test set accuracy: 0.944

* As the first step LeNet architecture has been used for non-processed dataset. As it was expected the network did not perform well.
* After normalizing input dataset the network had over 98% accuracy on a training dataset, but accuracy on a validation set was below 90%. Based on this observation we could say that the network was overfitting.
* After adding dropout in two fully connected layers it was possible to hit over 92% accuracy. At this step different convnet architectures have been tried:
	* more convolutional layers
	* different filter sizes
	* padding: same and valid
* However, these steps did not bring any significant improvement in accuracy. Validation accuracy 95.5% and test accuracy 94.4% have been achieved by tuning hyperparameters(batch size, learning rate, keep_prob) for initial LeNet architecture with dropout.

### Test a Model on New Images

#### 1. Results for five German traffic signs found on the web
Here are five German traffic signs that I found on the web:
*  Right-of-way at the next intersection
*  Stop Sign
*  Bumpy Road
*  Road Work
*  Wild Animals Crossing

The first and fourth images are expected to be simple to classify. Since signs are slighly rotated the second and third images might be hard to classify. The last image is mirrored version of the signs that in the training dataset. Therefore, it could be hard to classify. Note that if we did augment the training data, two above problems could be solved.

#### 2. Prediction Results
Here are the results of the prediction:

| Image			        |     Prediction	        					|
|:---------------------:|:---------------------------------------------:|
| Right-of-way    		| Right-of-way   								|
| Stop     			    | Stop										    |
| Bumpy Road		    | Bicycles crossing                             |
| Road Work	      		| Road Work					 					|
| Wild Animals Crossing | Right-of-way     							    |

The model was able to predict 3 out of 5 images(accuracy 60%). The results show that augmenting the training data might be very helpful.

#### 3. Certainty of softmax probabilities
The code for making predictions in my final model is located in the 16th cell of the Ipython notebook.

| Probability         	|     Prediction	        					|
|:---------------------:|:---------------------------------------------:|
| 0.99        			| Right-of-way  								|
| 0.99     				| Stop										    |
| 0.95					| Bicycles crossing								|
| 1.00	      			| Road Work						 				|
| 0.65				    | Right-of-way      							|

For the first, second and fourth images the network made correct predictions with certainty almost 100%. For the third image the network made a wrong prediction with certainty more than 95%. The second softmax probability was a true image sign, however it had only about 3% probability. For the last image the network gave 65% and 34% probabilities for "right-of-way at the next intersection" and "children crossing" traffic signs correspondingly. However, the true image is "wild animals crossing" traffic sign.