text:
---
 layout: post
 title: Git Training
 subtitle: An interactive git tutorial meant to teach you how git works, not just which commands to execute.
 image: "img/timeline/writing.jpg"
---

# Learn `git` concepts, not commands

**An interactive git tutorial meant to teach you how git works, not just which commands to execute.**

So, you want to use git, right?

But you don't just want to learn commands, you want to understand what you're using?

Then this is meant for you!

### [Read and follow the tutorial on github](https://github.com/UnseenWizzard/git_training) or [dev.to](https://dev.to/unseenwizzard/learn-git-concepts-not-commands-4gjc)

---

> The original idea for this sprung from seeing colleagues struggle with some git concepts and is based on the general concept from Rachel M. Carmena's great blog post on [How to teach Git](https://rachelcarmena.github.io/2018/12/12/how-to-teach-git.html).
>
> While I find many git tutorials on the internet to be too focused on what to do instead of how things work, the most invaluable resource for both (and source for this tutorial!) are the [git Book](https://git-scm.com/book/en/v2) and [Reference page](https://git-scm.com/docs).
>
> So if you're still interested when you're done here, go check those out! I do hope the somewhat different concept of this tutorial will aid you in understanding all the other git features detailed there.

---


text:
# grafana-ctrl-docker

Docker image with help tool for run common setup operations for _Grafana_.

Operations like upload dashboards, datasources, ... from json file or loaded from
option in command line.

As docker image the base is curl image with shell-script entrypoint that "wraps"
operations/actions to grafana

# Configuration and run.

All main configuration values should be provided by environment variables to
docker. This is a description of them:

* `GRAFANA_ENDPOINT`: Protocol, host and port of grafana. Default value `http://grafana:3000`

* `GRAFANA_AUTH_BEARER`: Token used to authenticate to grafana.
  See [Grafana API auth docs](http://docs.grafana.org/http_api/auth/) for more info.

  Use of this configuration has preference over `GRAFANA_AUTH_USERPASSWD`

* `GRAFANA_AUTH_USERPASSWD`: User and password to connect with grafana. This
  will works only if grafana has enable basic auth. Default value `admin:admin`

  This variable has not effect if `GRAFANA_AUTH_BEARER` is defined.

* `GRAFANA_WAIT_TIMEOUT`: If defined must get a integer with number of seconds
  up to wait for _Grafana_ (TCP check)

* `CURL_OPTIONS`: Common options to use with curl. By default ${CURL_OPTIONS}

* `PATH_FIND_PATTERN`: _egrep pattern_ to apply filter when find for files with
  `--path` and similar options: Default value `.*\.json`

# Command allowed

This docker support a lits of commands to run perations over grafana. This is a
basic description. For more info run docker with `--help` option:

* `import-dashboards OPTIONS`: Import one or more dashboards to _Grafana_.
  Valid `OPTIONS` are:
    `--json JSON_BODY`: Use value of `JSON_BODY` as payload of _dashboard_
      specification.

    `--file JSON_FILE`: Similar to `--json` option but load payload from
      `JSON_FILE`

    `--path PATH`. similar to --file but search for all files in a path that
      match with `$PATH_FIND_PATTERN` _egrep pattern_.

    You can set any of these options multiple times to import more than one
    dashboard in one-shoot.

* `new-datasources OPTIONS`: Create one or more new _Data Sources_ in _Grafana_.
  Valid `OPTIONS` are:
    `--json JSON_BODY`: Use value of `JSON_BODY` as payload of _datasource_
      specification.

    `--file JSON_FILE`: Similar to `--json` option but load payload from
      `JSON_FILE`

    `--path PATH`. similar to `--file` but search for all files in a path that
      match with `$PATH_FIND_PATTERN` _egrep pattern_.

    You can set any of these options multiple times to create more than one
    datasource in one-shoot.

* `new-users OPTIONS`: create one or more new users.
  Valid `OPTIONS` are:
    `--json JSON_BODY`: Use value of `JSON_BODY` as payload of user
      specification with id USER_ID.

    `--file JSON_FILE`: Similar to `--json` option but load payload from
      `JSON_FILE`.

    `--path PATH`. similar to `--file` but search for all files in a path that
      match with `$PATH_FIND_PATTERN` _egrep pattern_

    You can set any of these options multiple times to create more than one
    user in one-shoot.

# JSON expected formats #

Before describe allowed _JSON_ formats is important to note that values of
**environment variables** can be replaced _on-fly_ **in files**.

Any string with `{{ENV_VAR_NAME}}` found in any json file will be replaced by
value of `ENV_VAR_NAME` **only** if `ENV_VAR_NAME` is defined.

## New user

This is an example of a valid JSON to create new user:

```json
{
  "name": "k",
  "email"<EMAIL_ADDRESS>  "login": "k",
  "password": "kpassword"
}
```

You can find more examples in [user tests path](test/users)

## New data source

This is an example of a valid JSON to create new data source:

```json
{
  "name": "Prometheus",
  "type": "prometheus",
  "access": "proxy",
  "url": "http://prometheus:9090",
  "password": "",
  "user": "",
  "database": "",
  "basicAuth": false,
  "isDefault": false,
  "jsonData": {}
}
```

You can find more examples in [datasource tests path](test/datasources)

If you are trying to get datasoruce data from other _Grafana_ instance, one
approach is use `/api/datasources` API to get the info. See
[Data Source HTTP API](http://docs.grafana.org/v4.6/http_api/data_source/) for
more information.

## Import Dashboard

This is an example of a valid JSON to import a dashboard:

```json
{
  "dashboard": {
    "annotations": {
      "list": [
        {
          "builtIn": 1,
          "datasource": "-- Grafana --",
          "enable": true,
          "hide": true,
          "iconColor": "rgba(0, 211, 255, 1)",
          "name": "Annotations & Alerts",
          "type": "dashboard"
        }
      ]
    },
    "editable": true,
    "gnetId": null,
    "graphTooltip": 0,
    "hideControls": false,
    "id": null,
    "links": [],
    "rows": [
      {
        "collapse": false,
        "height": "250px",
        "panels": [
          {
            "aliasColors": {},
            "bars": false,
            "dashLength": 10,
            "dashes": false,
            "datasource": "Elastic Search",
            "fill": 1,
            "id": 1,
            "legend": {
              "avg": false,
              "current": false,
              "max": false,
              "min": false,
              "show": true,
              "total": false,
              "values": false
            },
            "lines": true,
            "linewidth": 1,
            "links": [],
            "nullPointMode": "null",
            "percentage": false,
            "pointradius": 5,
            "points": false,
            "renderer": "flot",
            "seriesOverrides": [],
            "spaceLength": 10,
            "span": 12,
            "stack": false,
            "steppedLine": false,
            "targets": [
              {
                "bucketAggs": [
                  {
                    "field": "time",
                    "id": "2",
                    "settings": {
                      "interval": "auto",
                      "min_doc_count": 0,
                      "trimEdges": 0
                    },
                    "type": "date_histogram"
                  }
                ],
                "dsType": "elasticsearch",
                "metrics": [
                  {
                    "field": "select field",
                    "id": "1",
                    "type": "count"
                  }
                ],
                "refId": "A",
                "timeField": "time"
              }
            ],
            "thresholds": [],
            "timeFrom": null,
            "timeShift": null,
            "title": "Documents in logs-* (Elastic Search)",
            "tooltip": {
              "shared": true,
              "sort": 0,
              "value_type": "individual"
            },
            "type": "graph",
            "xaxis": {
              "buckets": null,
              "mode": "time",
              "name": null,
              "show": true,
              "values": []
            },
            "yaxes": [
              {
                "format": "short",
                "label": null,
                "logBase": 1,
                "max": null,
                "min": null,
                "show": true
              },
              {
                "format": "short",
                "label": null,
                "logBase": 1,
                "max": null,
                "min": null,
                "show": true
              }
            ]
          }
        ],
        "repeat": null,
        "repeatIteration": null,
        "repeatRowId": null,
        "showTitle": false,
        "title": "Dashboard Row",
        "titleSize": "h6"
      }
    ],
    "schemaVersion": 14,
    "style": "dark",
    "tags": [],
    "templating": {
      "list": []
    },
    "time": {
      "from": "now-6h",
      "to": "now"
    },
    "timepicker": {
      "refresh_intervals": [
        "5s",
        "10s",
        "30s",
        "1m",
        "5m",
        "15m",
        "30m",
        "1h",
        "2h",
        "1d"
      ],
      "time_options": [
        "5m",
        "15m",
        "1h",
        "6h",
        "12h",
        "24h",
        "2d",
        "7d",
        "30d"
      ]
    },
    "timezone": "",
    "title": "ElasticSearch Dashboard",
    "version": 1
  },
  "overwrite": true,
  "inputs": []
}
```

You can find more examples in [dashboards tests path](test/dashboards)

If you are trying to get _dashboard_ data from other _Grafana_ instance, better approach is export data using GUI: Go to dashboard you are getting for export, Click on Share, Export, View Json.

Copy all json displayed in frame to your favourite editor. This data as is can not be directly imported by `grafana-ctrl` tool. You need to wrap
JSON with next structure:

```json
{
  "dashboard": <<<YOUR DATA COPIED HERE>>>,
  "overwrite": true,
  "inputs": []
}
```

This new payload is _fully compatible_ with `grafna-ctrl` tool.

As last steep look for `dashboard.id` key in your new wrapped data and change existing value (for example `12`) with `null`.

For example if we try to export following _click path_ previously described, we can see something similar to:

```json
{
  "annotations": {
    "list": [
      {
        "builtIn": 1,
        "datasource": "-- Grafana --",
        "enable": true,
        "hide": true,
        "iconColor": "rgba(0, 211, 255, 1)",
        "name": "Annotations & Alerts",
        "type": "dashboard"
      }
    ]
  },
  "editable": true,
  "gnetId": null,
  "graphTooltip": 0,
  "hideControls": false,
  "id": 10,
  "links": [],
  "rows": [
    {
      "collapse": false,
      "height": "250px",
      "panels": [
        {
          "aliasColors": {},
          "bars": false,
          "dashLength": 10,
          "dashes": false,
          "datasource": "Elastic Search",
          "fill": 1,
          "id": 1,
          "legend": {
            "avg": false,
            "current": false,
            "max": false,
            "min": false,
            "show": true,
            "total": false,
            "values": false
          },
          "lines": true,
          "linewidth": 1,
          "links": [],
          "nullPointMode": "null",
          "percentage": false,
          "pointradius": 5,
          "points": false,
          "renderer": "flot",
          "seriesOverrides": [],
          "spaceLength": 10,
          "span": 12,
          "stack": false,
          "steppedLine": false,
          "targets": [
            {
              "bucketAggs": [
                {
                  "field": "time",
                  "id": "2",
                  "settings": {
                    "interval": "auto",
                    "min_doc_count": 0,
                    "trimEdges": 0
                  },
                  "type": "date_histogram"
                }
              ],
              "dsType": "elasticsearch",
              "metrics": [
                {
                  "field": "select field",
                  "id": "1",
                  "type": "count"
                }
              ],
              "refId": "A",
              "timeField": "time"
            }
          ],
          "thresholds": [],
          "timeFrom": null,
          "timeShift": null,
          "title": "Documents in logs-* (Elastic Search)",
          "tooltip": {
            "shared": true,
            "sort": 0,
            "value_type": "individual"
          },
          "type": "graph",
          "xaxis": {
            "buckets": null,
            "mode": "time",
            "name": null,
            "show": true,
            "values": []
          },
          "yaxes": [
            {
              "format": "short",
              "label": null,
              "logBase": 1,
              "max": null,
              "min": null,
              "show": true
            },
            {
              "format": "short",
              "label": null,
              "logBase": 1,
              "max": null,
              "min": null,
              "show": true
            }
          ]
        }
      ],
      "repeat": null,
      "repeatIteration": null,
      "repeatRowId": null,
      "showTitle": false,
      "title": "Dashboard Row",
      "titleSize": "h6"
    }
  ],
  "schemaVersion": 14,
  "style": "dark",
  "tags": [],
  "templating": {
    "list": []
  },
  "time": {
    "from": "now-6h",
    "to": "now"
  },
  "timepicker": {
    "refresh_intervals": [
      "5s",
      "10s",
      "30s",
      "1m",
      "5m",
      "15m",
      "30m",
      "1h",
      "2h",
      "1d"
    ],
    "time_options": [
      "5m",
      "15m",
      "1h",
      "6h",
      "12h",
      "24h",
      "2d",
      "7d",
      "30d"
    ]
  },
  "timezone": "",
  "title": "ElasticSearch Dashboard",
  "version": 1
}
```

And when we follow describe steps (wrap JSON with `dahsboard`, and adding
`inputs` and `"overwrite": true` fields) and change `"id": 10,` (line `19` in
snippet) to '"id": null', we have valid payload (example at begin of current
section)

# Running with docker-compose

Current project contains a simple `docker-compose.yml` to run and check tool
with _Grafana_.

Execute next command to start-up a _Docker compose_ environment with _Grafana_
and some items added:

```bash
docker-compose up --build grafana-ctl
```

Now you can browse to [Grafana exposed in localhost](htpp://localhost:3000),
authenticate with default user (`admin`/`admin`) and see users, data sources and
dashboards created by `grafana-ctrl` tool

To destroy environment run next command:

```bash
docker-compose down --rmi local -v --remove-orphans
```

See [Docker compose page](https://docs.docker.com/compose/) for more information.

repository: cyberluisda/grafana-ctrl-docker

branch_name: refs/heads/master

extension: md

gha_language: Shell

license_type: permissive

repo_name: cyberluisda/grafana-ctrl-docker


text:
# spdlog_vendor
CMake shim over the spdlog library: https://github.com/gabime/spdlog.git

## Quality Declaration files

Quality declaration for this package: [spdlog_vendor QD](QUALITY_DECLARATION.md).

Quality declaration for spdlog: [spdlog QD](SPDLOG_QUALITY_DECLARATION.md).

branch_name: refs/heads/rolling

gha_language: CMake


text:
![WobbingButton](https://github.com/c2mInc/WobbingButton/blob/master/wobbingbutton_logo.png?raw=true)

UIButton is not enough. Replace it with a lightweight control, the WobbingButton.

WobbingButton is a subclass of UIControl, it is a hassle free, storyboard friendly UI component.
You could set corner radius directly from storyboard as well as wobble scale, handle target functions as closures, drag drop nested components. Unchain the limits of UIButton.

![WobbingButton: A lightweight storyboard friendly UIButton replacement.](https://github.com/c2mInc/WobbingButton/blob/master/WobbingButton.gif?raw=true)

## Example

Try it!

`pod try 'WobbingButton'`

This will open up an example project which you'll have a quick insight about the library.

## Installation

WobbingButton is available through [CocoaPods](https://cocoapods.org). To install
it, simply add the following line to your Podfile:

```ruby
pod 'WobbingButton'
```
Alternatively drag and drop WobbingButton.swift file into your project.

### WobbingButton
`WobbingButton` is a UIControl subclass.

![](WobbingButton.png?raw=true)

### RoundedWobbingButton
`RoundedWobbingButton` is a WobbingButton subclass, it has rounded left and right corners.

![](RoundedWobbingButton.png?raw=true)

### WobbingIcon
`WobbingIcon` is too a WobbingButton subclass, it is best used with monochrome icons, set tintColor in storyboard.

![](WobbingIcon.png?raw=true)

### RoundedWobbingIcon
`RoundedWobbingIcon` is a WobbingIcon subclass and it is like a rounded version of WobbingIcon.

![](RoundedWobbingIcon.png?raw=true)

## Basic Usage

Drag a UIView into a viewcontroller, change its class type to `WobbingButton`, `RoundedWobbingButton`, `WobbingIcon` or `RoundedWobbingIcon`. Add a background color, you are set, start wobbling.

Sometimes it's quite useful to assign closures rather than adding target to methods. WobbingButton provides `onTapAction` and `onLongPressAction` closures to handle those actions gracefully. In addition to touch events like `.touchUpInside`, `.touchDown`, it works with tap and long press closures as well.

```swift
let wobbingButton = WobbingButton(frame: ...)
wobbingButton.onTapAction = { [weak self] in
  //  self?.wobbingButtonTapped()
}
```

Even long presses.
```swift
let wobbingButton = WobbingButton(frame: ...)
wobbingButton.onLongPressAction = { [weak self] in
  //  self?.wobbingButtonLongPressed()
}
```

## Requirements

* iOS 10.0+
* Xcode 8.0+
* Swift 4.0+

## Author
[Connected2.me](http://connected2.me) / <a<EMAIL_ADDRESS>Ekin @erkekin

Awesome logo: @berilKarabulut

## License

WobbingButton is available under the MIT license. See the LICENSE file for more info.

Copyright (c) 2018 erkekin<EMAIL_ADDRESS>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

 IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

license: MIT

gha_language: Swift

gha_license_id: MIT


text:
# Aldine Travel

This repository backs [Aldine Travel](http://www.aldinetravel.com/) (a [Flask](http://flask.pocoo.org/) app).

## Overview

This site is frozen via [Frozen-Flask](http://packages.python.org/Frozen-Flask/) then pushed to S3 which backs a CloudFront endpoint.

## Directories

* (Site)/s/
  * Static files. Usually loaded via static.DOMAIN.com via CloudFront
* (Site)/templates/
  * [Jinja2](http://jinja.pocoo.org/) templates for Flask.

## Copyright

Some shared libraries are available via an Apache License v2.0 (e.g. BootStrap)

All other work is Copyright 2012, Aldine Travel, Inc. All rights reserved.

repository: semenko/aldine-website

repo_name: semenko/aldine-website


text:
# _Calculator_

#### _Javascript Calculator, april 14 2020_

#### By _**zephyrus**_

## Description

_This is a sample calculator written in javascript_

## Setup/Installation Requirements

* visit https://github.com/zephyrvinay/calculator

_Follow the prompts to add subtract or multiply numbers_

## Known Bugs

_None_

## Support and contact details

<EMAIL_ADDRESS>
## Technologies Used

_Javascript, HTML, css_

### License

*This software is licensed under the MIT license*

Copyright (c) 2016 **_zephyrus_**

repository: zephyrvinay/calculator

repo_name: zephyrvinay/calculator


text:
# Automagically fix the Excel warning: The file you are trying to open is in a different format #

Open a fake Excel file with MS Excel in background (silence mode) and save again as XLSX format (Real Excel File).

## What is this? ##
In some case you can't open a Microsoft Office Excel file, excel show the message: "The file you are trying to open, 'example.XLS' is in a different format than specified by the file extension. Verify that the file is not corrupted and is from a trusted source before opening the file. Do you want to open the file now?".

While working with automatic process, developers need repair the file in execution time for read the Excel file from the next step (Pentaho Data Integration Process, Bash, etc). Ofcourse if you check 'yes' you can open the file, but in a automatic process you can't are click in 'yes' for force the opened.

With this script you can open the bad file and save again in XLSX format using Microsoft Excel in background (silence mode), ideal for use in automatic process !.

## Requeriments ##

- MS Windows 7 + MS Office 2007 or later

## Use ##

`powershell.exe -ExecutionPolicy Bypass -file "c:\Repair-FakeExcelWorkbook\Repair-FakeExcelWorkbook.ps1" "PATH_TO_FAKE_EXCEL_FILE" "PATH_TO_FIXED_EXCEL_FILE"`

## How to do it... ##

Carry out the following steps:

1. Download, unzip the software in `C:\Repair-FakeExcelWorkbook` folder
2. Try open  `C:\Repair-FakeExcelWorkbook\examples\example1.XLS`, can you see the warning?
3. Open cmd and execute a example: `powershell.exe -ExecutionPolicy Bypass -file "c:\Repair-FakeExcelWorkbook\Repair-FakeExcelWorkbook.ps1" "c:\Repair-FakeExcelWorkbook\examples\example1.XLS" "c:\Repair-FakeExcelWorkbook\examples\example1-fixed.xlsx"`
4. Try Open  `C:\Repair-FakeExcelWorkbook\examples\example1-fixed.xlsx`, you should not see the warning, this is a real Excel File :).

## How it works... ##

The file `C:\Repair-FakeExcelWorkbook\examples\example1.XLS` is a plain text file with the extension .XLS, is a fake Excel file. Excel detect this before open. The script use PowerShell and [the Excel ComObject call](http://msdn.microsoft.com/en-us/library/wss56bz7.aspx "COM call") for open the fake excel and save again in a real xlsx format.

## See also ##
- [https://gist.github.com/gabceb/954418](https://gist.github.com/gabceb/954418 "Powershell script to convert all xls documents to xlsx in a folder recursively")
- [http://msdn.microsoft.com/en-us/library/wss56bz7.aspx](http://msdn.microsoft.com/en-us/library/wss56bz7.aspx "Excel Object Model Overview")

repository: knxroot/Repair-FakeExcelWorkbook

repo_name: knxroot/Repair-FakeExcelWorkbook


text:
# HAML

## What is HAML ?

HAML is the JSON style markup language for describing article body.

* HAML stands for Hyper Article Markup Language
* HAML elements are the building blocks of Article pages
* HAML content can be auto generate by HTML
* Different sides(Android/iOS/Web) can parse HAML to render it as a native page

## Usage

```java
String html = "<h1>My First Heading</h1><li><a href=\"/about\">My first paragraph.</a></li>";
Haml.parse(html);
```

```bash
[
 {"text":{"lineType":"h1","text":"My First Heading"},"type":0},
 {"text":{"lineType":"li","text":"My first paragraph."},"type":0,
             "markups":[{"end":19,"height":0,"source":"/about","start":0,"tag":"a","width":0}]}
]
```

## Support

### HAML Element

* Text
* Image
* Table

## Art

Original Article:

![](screenshot/s2.png)

HAML:

![](screenshot/s1.png)

## Thanks

* [QingMang's RAML](https://github.com/qingmang-team/docs/blob/master/raml/intro.md)

## License

Apache License Version 2.0

Copyright (c) 2018-present, GavinLiu

repository: gavinliu/HAML

repo_name: gavinliu/HAML


text:
# RTSPServer

[![Build Status](https://travis-ci.org/kgbook/RTSPServer.svg?branch=dev)](https://travis-ci.org/kgbook/RTSPServer)
[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](https://github.com/kgbook/RTSPServer)

## Server

Push H.264/H.265 bitstream using live555.

## Client

Pull stream from RTSPServer using FFmpeg, support H.264/H.265 wrapper into MP4 container.

## Dependencies

- [FFmpeg](https://ffmpeg.org/)
- [live555](http://www.live555.com/)
- [spdlog](https://github.com/gabime/spdlog)
- [Boost](https://www.boost.org/) at least 1.66.0
- [fmt](https://github.com/fmtlib/fmt)
- [python](https://www.python.org/) 2.7 required
- [cmake](https://cmake.org/) 3.7 required
- pkg-config

## Build

- Assign `OFF` to `linux-cross` macro, if not cross compile,
  see [third_party/live555/CMakeLists.txt](third_party/live555/CMakeLists.txt).
- [fmt 5.3.0 version perhaps not work well on macOS 10.14.4](https://github.com/fmtlib/fmt/issues/1115),
  built as submodule if failed.

```shell
git submodule update --init --remote --recursive
chmod +x build.sh
bash build.sh
```

## Code Style

The project use automated checker named **cpplint** to make sure a C++ file
follows [Google's C++ styleguide](https://google.github.io/styleguide/cppguide.html).

False positives can be ignored by putting `// NOLINT` at the end of the line
or `// NOLINTNEXTLINE` in the previous line.

repository: codacy-badger/RTSPServer

branch_name: refs/heads/dev

repo_name: codacy-badger/RTSPServer


text:
---
title: "Phases of new product development for small business"
date: "2021-12-16T16:24:04.000Z"
template: blog
tags: Small Business
image: "./media/new-product-development-for-small-business.jpg"
---

Miami, FL. Dec 16, 2021

Starting a new product can be a very complicated task, requiring a lot of analysis and care.  Companies  can invest millions a year to be able to launch new products to the market that are competitive and of high quality so that they can satisfy the needs of the customers.

If you have an innovative idea, you may be wondering how you can get your company and team to develop this idea and turn it into a product. Well, you've come to the right place.

Next we’ll show you what is **new product development**, the benefits it gives to your company and the phases you must follow to guarantee its optimal development.

<title-2>What is new product development?</title-2>

 New product development  is the process of introducing a new product to the market. Your company might need to undertake this process due to changes in consumer preferences, increased competition, and technological advances, or to take advantage of a new opportunity.

New product development is the driving force behind companies and is vital to their organic growth. Insatiable consumer appetite, fierce global competition, changes in consumer behavior, and technology force companies to invest in new products for success or survival.

<title-2>Benefits of this process for small businesses</title-2>

<title-3>* Save Money:</title-3>

The new product development process is designed to eliminate these risks to your business by testing the potential of your idea and the current market situation.

Identifying the effectiveness of new products in the new product development process before they go to the market allows you to adapt your idea to market needs or withdraw it all together to save time and money.

<title-3>* Innovation and Idea Generation:</title-3>

The new product development process is the promoter and driver of new ideas for your company. Having a framework for testing the feasibility of your new product will naturally lead to its implementation.

Developing and nurturing a culture of  innovation  is crucial to the business growth of the company and its people.

<title-3>* Develop an effective business analysis:</title-3>

The commercial attractiveness of a new product can be formulated once its suitability for the market has been determined.

This can include cost projections and profit predictions, and how the company's overall objectives will be met with the launch of this new product, which should be compared with those of products launched in the past, either by the company or by competitors.

<title-3>* Formalizing and strengthening concept development processes:</title-3>

As in the case of a new company, it is necessary to properly define your product concept early in the life cycle of new product development. This must be done with the intended consumer in mind, and therefore the product must be described in terms that are meaningful to the consumer.

<title-3>* Concept testing:</title-3>

Once the idea is developed, it must be tested with market conditions and the  target market . The way to do this is to test it with target consumers through market research practices. This would consist of presenting consumers with a physical or symbolic representation of the product.

Sometimes a description in words or a simple picture is sufficient, but the results will be better if it is an authentic physical representation.  In this way, your company will be able to determine exactly how your ideas fit into the wider consumer market and are able to adapt accordingly.

<title-3>* You can avoid common pitfalls:</title-3>

This type of product testing and analysis enables your company to avoid common problems and adverse situations that are endemic to new products.

Identifying problems early means you can take steps to lessen the impacts of negative influences before they occur.

Including problems such as failing to meet minimum customer expectations, unforeseen development costs, excessive pricing, ineffective advertising, and market size that is smaller than previously estimated.

<title-2>Phases of new product development</title-2>

<title-3>1. Idea generation:</title-3>

Many aspiring entrepreneurs get stuck in the first phase: ideation and brainstorming. Often this is because they are waiting for a stroke of genius to reveal the perfect product to sell.

While building something fundamentally new can be creative, many of the best ideas are the result of iterating on an existing product.

In this first stage, you should focus on consumer problems, identify their root cause, and with the problem defined look for possible solutions by brainstorming with your team.

<title-3>2. Idea screening:</title-3>

This stage of new product development revolves around choosing the idea with the greatest potential for success. Put all available ideas on the table for internal review. That is, use people with industry knowledge and domain expertise for idea selection.

In the case of a new product development idea, you should prioritize conducting a proof of concept, as it helps to test the feasibility of the idea. There is no point in focusing on an idea that is not technically feasible to build.

<title-3>3. Concept  development  &  testing :</title-3>

Before starting the new product development process, priority should be given to building a detailed version of the idea and user stories. This evaluation of the value proposition is the first step toward concept development and testing.

At the very least, it ensures that problems in the approach are discovered earlier and that the team can course-correct sooner. It helps ensure that technical debt does not accumulate.

This phase involves quantifying the benefit/pain ratio, conducting a competitive analysis, recruiting key product features, creating a  value proposition  chart, and conducting a proof of concept.

<title-3>4.   Market strategy/business  analysis:</title-3>

This business analysis will help determine whether or not new product development efforts are worth the financial investment, i.e., whether it will create an ongoing stream of value.

To execute this phase, a cost-based pricing model must be performed and market-focused pricing must be taken into account.

<title-3>5. Product development:</title-3>

When the new product development idea is in place, the market strategy is documented and the business analysis is complete, it is time to move forward in the product development cycle.

In this phase, you should start with a prototype, then move on to have what we all know as a  minimum viable product .

<title-3>6. Market testing:</title-3>

This step in new product development aims to reduce the uncertainty surrounding the success of the software product. In other words, this step revolves around testing the feasibility of the new product or its marketing campaign.

In this testing stage, alpha testing is launched so that engineers can determine its features and evaluate its efficiency and once this stage is passed, a beta version is launched so that consumers can test certain features of your product.

<title-3>7. Market entry/commercialization:</title-3>

Favorable results in the development phase precede full-scale production and marketing. Here, the company launches its promotional campaign for the new product.

Market research conducted during the concept phase influences the timing and location of the product launch.

<youtube-video id="8A2kw19CUI4"></youtube-video>

New product development consists of converting new and unproven ideas into viable products. This product will be the creation of a company, which will give you a competitive advantage and help you monopolize the market.

The new product development process can be hugely beneficial to any innovative and forward-thinking company that aims to be effective rather than short-sighted.

 Developing a new product development for your business , you can save money, innovate, formalize processes, prove concept, and avoid the usual pitfalls. This puts your company in a strategic position to launch new products in the most efficient and cost-effective way possible.

**Cobuild Lab**

repository: cobuildlab/cobuildlab-web

branch_name: refs/heads/main

gha_language: JavaScript

repo_name: cobuildlab/cobuildlab-web


text:
# VPNStatus
VPNStatus, a replacement for macOS builtin VPN Status

# Blog post
[https://blog.timac.org/2018/0719-vpnstatus/](https://blog.timac.org/2018/0719-vpnstatus/)

# Description
VPNStatus, an application that replicates some functionalities of macOS built-in VPN status menu:

- list the VPN services and their status
- connect to a VPN service
- disconnect from a VPN service
- possibility to auto connect to a VPN service if the application is running

# Retry Delay

VPNStatus tries to reconnect to the VPN every 120s by default. You can change this value using a secret preference. To change the retry delay to 30s:

- Quit VPNStatus
- Run this command line in a Terminal window:

```
defaults write org.timac.VPNStatus AlwaysConnectedRetryDelay -int 30
```

repository: youlianchun/VPNStatus

repo_name: youlianchun/VPNStatus


text:
---
layout: post
author: KubeVirt Maintainers
title: KubeVirt v1.0 has landed!
description: We are very pleased to announce the release of KubeVirt v1.0!
navbar_active:
pub-date: July 11
pug-year: 2023
category: news
tags:
  [
    "KubeVirt",
    "v1.0",
    "release",
    "community",
    "cncf",
    "milestone",
    "party time"
  ]

---

The KubeVirt community is proud to announce the release of [KubeVirt v1.0](https://github.com/kubevirt/kubevirt/releases/tag/v1.0.0)! This release demonstrates the accomplishments of the community and user adoption over the years and represents an important milestone for everyone involved.

## A brief history
The KubeVirt project started in Red Hat at the end of 2016, with the question: Can virtual machines (VMs) run in containers and be deployed by Kubernetes?
It proved to be not only possible, but quickly emerged as a promising solution to the future of virtual machines in the container age.
KubeVirt joined the [CNCF](https://www.cncf.io/) as a Sandbox project in September 2019, and an Incubating project in April 2022.
From a handful of people hacking away on a proof of concept, KubeVirt has grown into 45 active repositories, with the primary [kubevirt/kubevirt](https://github.com/kubevirt/kubevirt) repo having 17k commits and 1k forks.

## What does v1.0 mean to the community?
The v1.0 release signifies the incredible growth that the community has gone through in the past six years from an idea to a production-ready Virtual Machine Management solution. The next stage with v1.0 is the additional focus on maintaining APIs while continuing to grow the project. This has led KubeVirt to adopt community practices from Kubernetes in key parts of the project.

Leading up to this release we had a shift in release cadence: from monthly to 3 times a year, following the Kubernetes release model. This allows our developer community additional time to ensure stability and compatibility, our users more time to plan and comfortably upgrade, and also aligns our releases with Kubernetes to simplify maintenance and supportability.

The theme 'aligning with Kubernetes' is also felt through the other parts of the community, by following their governance processes; introducing SIGs to split test and review responsibilities, as well as a SIG release repo to handle everything related to a release; and regular [SIG<EMAIL_ADDRESS>that now include SIG scale and performance and SIG storage alongside our weekly Community meetings.

## What’s included in this release?

This release demonstrates the accomplishments of the community and user adoption over the past many months. The full list of feature and bug fixes can be found in our [release notes](https://github.com/kubevirt/kubevirt/releases/tag/v1.0.0), but we’ve also asked representatives from some of our SIGs for a summary.

### SIG-scale
KubeVirt’s SIG-scale drives the performance and scalability initiatives in the community. Our focus for the v1.0 release was on sharing the performance results over the past 6 months. The benchmarks since December 2022 which cover the past two release - v0.59 (Mar 2023) and v1.0 (July 2023) are as follows:

[Performance benchmarks for v1.0 release](https://github.com/kubevirt/kubevirt/blob/release-1.0/docs/release-v1-perf-scale-benchmarks.md#performance-benchmarks-for-v1-release)

[Scalability benchmarks for v1.0 release](https://github.com/kubevirt/kubevirt/blob/release-1.0/docs/release-v1-perf-scale-benchmarks.md#scalability-benchmarks-for-v1-release)

Publishing these measurements provides the community and end-users visibility into the performance and scalability over multiple releases. In addition, these results help identify the effects of code changes so that community members can diagnose performance problems and regressions.

End-users can use the same tools and techniques SIG-scale uses to analyze performance and scalability in their own deployments. Since performance and scalability are mostly relative to the deployment stack, the same strategies should be used to further contextualize the community’s measurements.

### SIG-storage
SIG-storage is focused on providing persistent storage to KubeVirt VMs and managing that storage throughout the lifecycle of the VM. This begins with provisioning and populating PVCs with bootable images but also includes features such as disk hotplug, snapshots, backup and restore, disaster recovery, and virtual machine export.

For v1.0, SIG-storage delivered the following features: providing a flexible VM export API, enabling persistent SCSI reservation, provisioning VMs from a retained snapshot, and setting out-of-the-box defaults for additional storage provisioners. Another major effort was to implement Volume Populator alternatives to the KubeVirt DataVolume API in order to better leverage platform capabilities. The SIG meets every 2 weeks and welcomes anyone to join us for interesting storage discussions.

### SIG-compute
SIG-compute is focused on the core virtualization functionality of KubeVirt, but also encompasses features that don’t fit well into another SIG. Some examples of SIG-compute’s scope include the lifecycle of VMs, migration, as well as maintenance of the core API.

For v1.0, SIG-compute developed features for memory over-commit. This includes initial support for KSM and FreePageReporting. We added support for persistent vTPM, which makes it much easier to use BitLocker on Windows installs. Additionally, there's now an initial implementation for CPU Hotplug (currently hidden behind a feature gate).

### SIG-network
SIG-network is committed to enhancing and maintaining all aspects of Virtual Machine network connectivity and management in KubeVirt.

For the v1.0 release, we have introduced hot plug and hot unplug (as alpha), which enables users to add and remove VM secondary network interfaces that use bridge binding on a running VM. Hot plug API stabilization and support for SR-IOV interfaces is under development for the next minor release.

### SIG-infra
The effort to simplify the VirtualMachine UX is still ongoing and with the v1.0 release we were able to introduce the v1beta1 version of the instancetype.kubevirt.io API. In the future KubeVirt v1.1.0 release we are aiming to finally graduate the instancetype.kubevirt.io API to v1.

With the new version it is now possible to control the memory overcommit of virtual machines as a percentage within instance types. Resource requirements were added to preferences, which allows users to ensure that requirements of a workload are met. Also several new preference attributes have been added to cover more use cases.

Moreover, virtctl was extended to make use of the new instance type and preference features.

## What next for KubeVirt?
From a development perspective, we will continue to introduce and improve features that make life easier for virtualization users in a manner that is as native to Kubernetes as possible. From a community perspective, we are improving our new contributor experience so that we can continue to grow and help new members learn and be a part of the cloud native ecosystem. In addition, with this milestone we can now shift our attention on becoming a CNCF Graduated project.

gha_language: HTML


text:
![Multis Logo](./app/icon/app-icon.png)

[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fddresch%2Fmultis.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fddresch%2Fmultis?ref=badge_shield)
[![license](http://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/ddresch/multis/blob/master/LICENSE)
[![Build Status](https://travis-ci.org/ddresch/multis.svg?branch=master)](https://travis-ci.org/ddresch/multis)

# Multis Browser
This app helps to display HTML content on multiple displays connected to **one** machine.

## Use Case
You want to show your custom dashboards, selected websites or a timetable wall like the ones used on the airport using one machine and multiple monitors.

![Multis Welcome](./docs/images/matthew-smith-5934.jpg)
Photo by Matthew Smith on [Unsplash](https://unsplash.com/search/photos/airport-timetable?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText)

## Problem
First you think OK no big deal but if you start working on it, you'll see it's not that simple task.

See these postings as reference:

- [Blog Post by Oleksandr Tomin](https://alextomin.wordpress.com/2015/04/10/kiosk-mode-in-windows-chrome-on-multiple-displays/)
- [Still looking for driver independent solution](https://stackoverflow.com/questions/23234534/how-to-extend-chrome-browser-to-dual-display-on-fullscreen)

## Solution
Use Multis and setup you list of URLs to show on each attached display/monitor. Multis will open a browser instance for each URL in fullscreen mode on the corresponding monitor.

[DOWNLOAD LATEST RELEASE](https://github.com/ddresch/multis/releases/latest)

![Multis Welcome](./docs/images/welcome-screen.png)

![Multis Preferences](./docs/images/settings-screen.png)

**Attention:** in current version you need to restart Multis after your initial URL setup.

*Features*
- Manage multiple monitor kiosk setup
- Connect with [MQTT](http://www.mqtt.org) server to remotely manage your kiosk

## Future Ideas
Growing list of ideas, other packages to integrate etc.

- [Pretty logger](https://github.com/sindresorhus/electron-timber) for development
- List of URLs sortable via Drag'n'Drop
- More options per URL or monitor (e.g. fullscreen optional)
- Switch to [electron-builder]()
- Extended MQTT interface
- you name it ...

## Get Started

Run Multis on your local machine.
```
npm install
npm start
```

Build for deployment (currently MAC only)
```
npm run build-mac
```

## License
[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fddresch%2Fmultis.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fddresch%2Fmultis?ref=badge_large)

repository: ddresch/multis

gha_language: CSS

repo_name: ddresch/multis


text:
# Call expressions

> **Syntax**\
> _CallExpression_ :\
>    [_Expression_] `(` _CallParams_? `)`
>
> _CallParams_ :\
>    [_Expression_] ( `,` [_Expression_] )\* `,`?

A *call expression* calls a function.
The syntax of a call expression is an expression, called the *function operand*, followed by a parenthesized comma-separated list of expression, called the *argument operands*.
If the function eventually returns, then the expression completes.
For [non-function types], the expression `f(...)` uses the method on one of the [`std::ops::Fn`], [`std::ops::FnMut`] or [`std::ops::FnOnce`] traits, which differ in whether they take the type by reference, mutable reference, or take ownership respectively.
An automatic borrow will be taken if needed.
The function operand will also be [automatically dereferenced] as required.

Some examples of call expressions:

```rust
# fn add(x: i32, y: i32) -> i32 { 0 }
let three: i32 = add(1i32, 2i32);
let name: &'static str = (|| "Rust")();
```

## Disambiguating Function Calls

All function calls are sugar for a more explicit [fully-qualified syntax].
Function calls may need to be fully qualified, depending on the ambiguity of a call in light of in-scope items.

> **Note**: In the past, the terms "Unambiguous Function Call Syntax", "Universal Function Call Syntax", or "UFCS", have been used in documentation, issues, RFCs, and other community writings.
> However, these terms lack descriptive power and potentially confuse the issue at hand.
> We mention them here for searchability's sake.

Several situations often occur which result in ambiguities about the receiver or referent of method or associated function calls.
These situations may include:

* Multiple in-scope traits define methods with the same name for the same types
* Auto-`deref` is undesirable; for example, distinguishing between methods on a smart pointer itself and the pointer's referent
* Methods which take no arguments, like [`default()`], and return properties of a type, like [`size_of()`]

To resolve the ambiguity, the programmer may refer to their desired method or function using more specific paths, types, or traits.

For example,

```rust
trait Pretty {
    fn print(&self);
}

trait Ugly {
    fn print(&self);
}

struct Foo;
impl Pretty for Foo {
    fn print(&self) {}
}

struct Bar;
impl Pretty for Bar {
    fn print(&self) {}
}
impl Ugly for Bar {
    fn print(&self) {}
}

fn main() {
    let f = Foo;
    let b = Bar;

    // we can do this because we only have one item called `print` for `Foo`s
    f.print();
    // more explicit, and, in the case of `Foo`, not necessary
    Foo::print(&f);
    // if you're not into the whole brevity thing
    <Foo as Pretty>::print(&f);

    // b.print(); // Error: multiple 'print' found
    // Bar::print(&b); // Still an error: multiple `print` found

    // necessary because of in-scope items defining `print`
    <Bar as Pretty>::print(&b);
}
```

Refer to [RFC 132] for further details and motivations.

[RFC 132]: https://github.com/rust-lang/rfcs/blob/master/text/0132-ufcs.md
[_Expression_]: ../expressions.md
[`default()`]: ../../std/default/trait.Default.html#tymethod.default
[`size_of()`]: ../../std/mem/fn.size_of.html
[`std::ops::FnMut`]: ../../std/ops/trait.FnMut.html
[`std::ops::FnOnce`]: ../../std/ops/trait.FnOnce.html
[`std::ops::Fn`]: ../../std/ops/trait.Fn.html
[automatically dereferenced]: field-expr.md#automatic-dereferencing
[fully-qualified syntax]: ../paths.md#qualified-paths
[non-function types]: ../types/function-item.md

repository: rust-lang/reference

gha_language: Rust

repo_name: rust-lang/reference


text:
Introduction

The web severely lacks expression. To see what I mean, take a peek at a "modern" web app like GMail:

Modern web apps: built with <div> soup.</figcpation>

There's nothing modern about `<div>` soup. And yet,…this is how we build web apps. It's sad.
Shouldn't we demand more from our platform?

Sexy markup. Let's make it a thing.

HTML gives us an excellent tool for structuring a document but its vocabulary is limited to elements
the [HTML standard](http://www.whatwg.org/specs/web-apps/current-work/multipage/) defines.

What if the markup for GMail wasn't atrocious? What if it was beautiful:

    <hangout-module>
      <hangout-chat from="Paul, Addy">
        <hangout-discussion>
          <hangout-message from="Paul" profile="profile.png"
              profile="118075919496626375791" datetime="2013-07-17T12:02">

Feelin' this Web Components thing.

Heard of it?

          </hangout-message>
        </hangout-discussion>
      </hangout-chat>
      <hangout-chat>...</hangout-chat>
    </hangout-module>

  <button>Try the demo!</button>

How refreshing! This app totally makes sense too. It's **meaningful**, **easy to understand**,
and best of all, it's **maintainable**. Future me/you will know exactly what it does
just by examining its declarative backbone.

Help us custom elements. You're our only hope!

Getting started

[Custom Elements](http://w3c.github.io/webcomponents/spec/custom/)
**allow web developers to define new types of HTML elements**. The spec is one of several new API primitives landing under the [Web Components](http://w3c.github.io/webcomponents/explainer/) umbrella, but it's quite possibly the most important. Web Components don't exist
without the features unlocked by custom elements:

1. Define new HTML/DOM elements
2. Create elements that extend from other elements
3. Logically bundle together custom functionality into a single tag
4. Extend the API of existing DOM elements

Registering new elements

Custom elements are created using `document.registerElement()`:

    var XFoo = document.registerElement('x-foo');
    document.body.appendChild(new XFoo());

The first argument to `document.registerElement()` is the element's tag name.
The name **must contain a dash (-)**. So for example, `<x-tags>`, `<my-element>`, and `<my-awesome-app>` are all valid names, while `<tabs>` and `<foo_bar>` are not. This restriction allows the parser
to distinguish custom elements from regular elements but also ensures forward
compatibility when new tags are added to HTML.

The second argument is an (optional) object describing the element's `prototype`.
This is the place to add custom functionality (e.g. public properties and methods) to your elements.
[More on that](#publicapi) later.

By default, custom elements inherit from `HTMLElement`. Thus, the previous example is equivalent to:

    var XFoo = document.registerElement('x-foo', {
      prototype: Object.create(HTMLElement.prototype)
    });

A call to `document.registerElement('x-foo')` teaches the browser about the new element,
and returns a constructor that you can use to create instances of `<x-foo>`.
Alternatively, you can use the other [techniques of instantiating elements](#instantiating)
if you don't want to use the constructor.

If it's undesirable that the constructor ends up on the global window
object, put it in a namespace (var myapp = {}; myapp.XFoo = document.registerElement('x-foo');) or drop it on the floor.

Extending elements

Custom elements allows you to extend existing (native) HTML elements as well as other
custom elements. To extend an element, you need to pass `registerElement()` the name
and `prototype` of the element to inherit from.

Extending native elements

Say you aren't happy with Regular Joe™ `<button>`. You'd like to
supercharge its capabilities to be a "Mega Button". To extend the `<button>` element,
create a new element that inherits the `prototype` of `HTMLButtonElement` and `extends`
the name of the element. In this case, "button":

    var MegaButton = document.registerElement('mega-button', {
      prototype: Object.create(HTMLButtonElement.prototype),
      extends: 'button'
    });

To create element A that extends element B, element A
must inherit the prototype of element B.

Custom elements that inherit from native elements are called _type extension custom elements_.
They inherit from a specialized version of `HTMLElement` as a way to say, "element X is a Y".

Example:

    <button is="mega-button">

Extending a custom element

To create an `<x-foo-extended>` element that extends the `<x-foo>` custom element, simply inherit its prototype
and say what tag you're inheriting from:

    var XFooProto = Object.create(HTMLElement.prototype);
    ...

    var XFooExtended = document.registerElement('x-foo-extended', {
      prototype: XFooProto,
      extends: 'x-foo'
    });

See [Adding JS properties and methods](#publicapi) below for more information on creating element prototypes.

How elements are upgraded

Have you ever wondered why the HTML parser doesn't throw a fit on non-standard tags?
For example, it's perfectly happy if we declare `<randomtag>` on the page. According to the [HTML specification](http://www.whatwg.org/specs/web-apps/current-work/multipage/elements.html#htmlunknownelement):

  The HTMLUnknownElement interface must be used for HTML elements that are not defined by this specification.
  HTML spec

Sorry `<randomtag>`! You're non-standard and inherit from `HTMLUnknownElement`.

The same is not true for custom elements. **Elements with valid custom element names inherit from `HTMLElement`.** You can verify this fact by firing up the Console: Ctrl+Shift+J (or Cmd+Opt+J on Mac), and paste in the following lines of code; they return `true`:

    // "tabs" is not a valid custom element name
    document.createElement('tabs').__proto__ === HTMLUnknownElement.prototype

    // "x-tabs" is a valid custom element name
    document.createElement('x-tabs').__proto__ == HTMLElement.prototype

<x-tabs> will still be an HTMLUnknownElement in browsers that don't support document.registerElement().

Unresolved elements

Because custom elements are registered by script using `document.registerElement()`, **they can be
declared or created _before_ their definition is registered** by the browser. For example,
you can declare `<x-tabs>` on the page but end up invoking `document.registerElement('x-tabs')` much later.

Before elements are upgraded to their definition, they're called **unresolved elements**.
These are HTML elements that have a valid custom element name but haven't been registered.

This table might help keep things straight:

Name	Inherits from	Examples

Unresolved element	HTMLElement	<x-tabs>, <my-element>, <my-awesome-app>

Unknown element	HTMLUnknownElement	<tabs>, <foo_bar>

Think of unresolved elements as in limbo.
  They're potential candidates for the browser to upgrade later on. The browser says, "You have all the right qualities I'm looking for in a new element. I promise to upgrade you when I'm given your definition".

Instantiating elements

The common techniques of creating elements still apply to custom elements.
As with any standard element, they can be declared in HTML or created in DOM
using JavaScript.

Instantiating custom tags

**Declare** them:

    <x-foo></x-foo>

**Create DOM** in JS:

    var xFoo = document.createElement('x-foo');
    xFoo.addEventListener('click', function(e) {
      alert('Thanks!');
    });

Use the **`new` operator**:

    var xFoo = new XFoo();
    document.body.appendChild(xFoo);

Instantiating type extension elements

Instantiating type extension-style custom elements is strikingly close to custom tags.

**Declare** them:

    <button is="mega-button">

**Create DOM** in JS:

    var megaButton = document.createElement('button', 'mega-button');
    // megaButton instanceof MegaButton === true

As you can see, there's now an overloaded version of `document.createElement()`
that takes the `is=""` attribute as its second parameter.

Use the **`new` operator**:

    var megaButton = new MegaButton();
    document.body.appendChild(megaButton);

So far, we've learned how to use `document.registerElement()` to tell the browser about a new tag…but
it doesn't do much. Let's add properties and methods.

Adding JS properties and methods

The powerful thing about custom elements is that you can bundle tailored functionality
with the element by defining properties and methods on the element definition.
Think of this as a way to create a public API for your element.

Here's a full example:

    var XFooProto = Object.create(HTMLElement.prototype);

    // 1. Give x-foo a foo() method.
    XFooProto.foo = function() {
      alert('foo() called');
    };

    // 2. Define a property read-only "bar".
    Object.defineProperty(XFooProto, "bar", {value: 5});

    // 3. Register x-foo's definition.
    var XFoo = document.registerElement('x-foo', {prototype: XFooProto});

    // 4. Instantiate an x-foo.
    var xfoo = document.createElement('x-foo');

    // 5. Add it to the page.
    document.body.appendChild(xfoo);

Of course there are umpteen thousand ways to construct a `prototype`. If you're not
a fan of creating prototypes like this, here's a more condensed version of the same thing:

    var XFoo = document.registerElement('x-foo', {
      prototype: Object.create(HTMLElement.prototype, {
        bar: {
          get: function() { return 5; }
        },
        foo: {
          value: function() {
            alert('foo() called');
          }
        }
      })
    });

The first format allows for the use of ES5 [`Object.defineProperty`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty). The second allows the use of [get/set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/get).

Lifecycle callback methods

Elements can define special methods for tapping into interesting times of their existence.
These methods are appropriately named the **lifecycle callbacks**. Each has a specific name and purpose:

      Callback name
      Called when

      createdCallback
      an instance of the element is created

      attachedCallback
      an instance was inserted into the document

      detachedCallback
      an instance was removed from the document

      attributeChangedCallback(attrName, oldVal, newVal)
      an attribute was added, removed, or updated

**Example:** defining `createdCallback()` and `attachedCallback()` on `<x-foo>`:

    var proto = Object.create(HTMLElement.prototype);

    proto.createdCallback = function() {...};
    proto.attachedCallback = function() {...};

    var XFoo = document.registerElement('x-foo', {prototype: proto});

**All of the lifecycle callbacks are optional**, but define them if/when it makes sense.
For example, say your element is sufficiently complex and opens a connection to IndexedDB
in `createdCallback()`. Before it gets removed from the DOM, do the necessary
cleanup work in `detachedCallback()`. **Note:** you shouldn't rely on this,
for example, if the user closes the tab, but think of it as a possible optimization hook.

Another use case lifecycle callbacks is for setting up default event listeners
on the element:

    proto.createdCallback = function() {
      this.addEventListener('click', function(e) {
        alert('Thanks!');
      });
    };

People won't use your elements if
they're clunky. The lifecycle callbacks can help you be a good citizen!

Adding markup

We've created `<x-foo>`, given it a JavaScript API, but it's blank! Shall we
give it some HTML to render?

[Lifecycle callbacks](#lifecycle) come in handy here. Particularly, we can use
`createdCallback()` to endow an element with some default HTML:

    var XFooProto = Object.create(HTMLElement.prototype);

    XFooProto.createdCallback = function() {
      this.innerHTML = "I'm an x-foo-with-markup!";
    };

    var XFoo = document.registerElement('x-foo-with-markup', {prototype: XFooProto});

  <x-foo-with-markup></x-foo-with-markup>

Instantiating this tag and inspecting in the DevTools (right-click, select Inspect Element) should show:

    ▾<x-foo-with-markup>
       I'm an x-foo-with-markup!
     </x-foo-with-markup>

Encapsulating the internals in Shadow DOM

By itself, [Shadow DOM](/tutorials/webcomponents/shadowdom/) is a powerful tool for
encapsulating content. Use it in conjunction with custom elements and things get magical!

Shadow DOM gives custom elements:

1. A way to hide their guts, thus shielding users from gory implementation details.
2. [Style encapsulation](/tutorials/webcomponents/shadowdom-201/)…fo' free.

Creating an element from Shadow DOM is like creating one that
renders basic markup. The difference is in `createdCallback()`:

    var XFooProto = Object.create(HTMLElement.prototype);

    XFooProto.createdCallback = function() {
      // 1. Attach a shadow root on the element.
      var shadow = this.createShadowRoot();

      // 2. Fill it with markup goodness.
      shadow.innerHTML = "I'm in the element's Shadow DOM!";
    };

    var XFoo = document.registerElement('x-foo-shadowdom', {prototype: XFooProto});

  <x-foo-shadowdom></x-foo-shadowdom>

Instead of setting the element's `.innerHTML`, I've created a
Shadow Root for `<x-foo-shadowdom>` and then filled it with markup.
With the "Show Shadow DOM" setting enabled in the DevTools, you'll see a
`#shadow-root` that can be expanded:

    ▾<x-foo-shadowdom>
       ▾#shadow-root
         I'm in the element's Shadow DOM!
     </x-foo-shadowdom>

That's the Shadow Root!

Creating elements from a template

[HTML Templates](http://www.whatwg.org/specs/web-apps/current-work/multipage/scripting-1.html#the-template-element) are another new API primitive that fits nicely into the world of custom elements.

For those unfamiliar, the [`<template>` element](/tutorials/webcomponents/template/)
allows you to declare fragments of DOM which are parsed, inert at page load, and instantiated later at runtime. They're an ideal placeholder for declaring the structure of custom element.

**Example:** registering an element created from a `<template>` and Shadow DOM:

    <template id="sdtemplate">

I'm in Shadow DOM. My markup was stamped from a <template>.

    </template>

<template id="sdtemplate">

I'm in Shadow DOM. My markup was stamped from a <template>.

</template>

  <x-foo-from-template></x-foo-from-template>

These few lines of code pack a lot of punch. Let's understanding everything that is happening:

1. We've registered a new element in HTML: `<x-foo-from-template>`
- The element's DOM was created from a `<template>`
- The element's scary details are hidden away using Shadow DOM
- Shadow DOM gives the element style encapsulation (e.g. `p {color: orange;}` isn't
turning the entire page orange)

So good!

Styling custom elements

As with any HTML tag, users of your custom tag can style it with selectors:

    <app-panel>

Do

Re

Mi

    </app-panel>

<app-panel>

Do

Re

Mi

</app-panel>

Styling elements that use Shadow DOM

The rabbit hole goes much _much_ deeper when you bring Shadow DOM into the mix.
[Custom elements that use Shadow DOM](#shadowdom) inherit its great benefits.

Shadow DOM infuses an element with style encapsulation. Styles defined in a Shadow Root don't
leak out of the host and don't bleed in from the page. **In the case of a custom element, the element itself is the host.** The properties of style encapsulation also allow custom elements to
define default styles for themselves.

Shadow DOM styling is a huge topic! If you want to learn more about it, I recommend a few of my other articles:

- "[A Guide to Styling Elements](http://www.polymer-project.org/articles/styling-elements.html)" on [Polymer](http://www.polymer-project.org)'s documentation.
- "[Shadow DOM 201: CSS & Styling](/tutorials/webcomponents/shadowdom-201/)" here on html5rocks.com

FOUC prevention using :unresolved

To mitigate [FOUC](http://en.wikipedia.org/wiki/Flash_of_unstyled_content), custom elements spec
out a new CSS pseudo class, `:unresolved`. Use it to target [unresolved elements](#unresolvedels),
right up until the point where the browser invokes your `createdCallback()` (see [lifecycle methods](#lifecycle)).
Once that happens, the element is no longer an unresolved element. The upgrade process is
complete and the element has transformed into its definition.

CSS :unresolved is supported natively in Chrome 29.

**Example**: fade in "x-foo" tags when they're registered:

Keep in mind that `:unresolved` only applies to [unresolved elements](#unresolvedels),
not to elements that inherit from `HTMLUnknownElement` (see [How elements are upgraded](#upgrades)).

    <panel>
      I'm black because :unresolved doesn't apply to "panel".
      It's not a valid custom element name.
    </panel>

    <x-panel>I'm red because I match x-panel:unresolved.</x-panel>

  <panel>I'm black because :unresolved doesn't apply to "panel". It's not a valid custom element name.</panel>
  <x-panel>I'm red because I match x-panel:unresolved.</x-panel>

<button id="register-x-panel">Register <x-panel></button>

For more on `:unresolved`, see Polymer's [A Guide to styling elements](http://www.polymer-project.org/articles/styling-elements.html#preventing-fouc).

History and browser support

Feature detection

Feature detecting is a matter of checking if `document.registerElement()` exists:

    function supportsCustomElements() {
      return 'registerElement' in document;
    }

    if (supportsCustomElements()) {
      // Good to go!
    } else {
      // Use other libraries to create components.
    }

Browser support

`document.registerElement()` first started landing behind a flag in Chrome 27 and Firefox ~23. However, the specification has evolved quite a bit since then. Chrome 31 is the first to have
true support for the updated spec.

Custom elements can be enabled in Chrome 31 under "Experimental Web Platform features" in about:flags.

Until browser support is stellar, there's a [polyfill](http://www.polymer-project.org/platform/custom-elements.html) which is used by Google's [Polymer](http://polymer-project.org) and Mozilla's [X-Tag](http://www.x-tags.org/).

What happened to HTMLElementElement?

For those that have followed the standardization work, you know there was once `<element>`.
It was the bees knees. You could use it to declaratively register new elements:

    <element name="my-element">
      ...
    </element>

Unfortunately, there were too many timing issues with the [upgrade process](#upgrades),
corner cases, and Armageddon-like scenarios to work it all out. `<element>` had to be shelved. In August 2013, Dimitri Glazkov posted to [public-webapps](http://lists.w3.org/Archives/Public/public-webapps/2013JulSep/0287.html) announcing its removal, at least for now.

It's worth noting that Polymer implements a declarative form of element registration
with `<polymer-element>`. How? It uses `document.registerElement('polymer-element')` and
the techniques I described in [Creating elements from a template](#fromtemplate).

Conclusion

Custom elements give us the tool to extend HTML's vocabulary, teach it new tricks,
and jump through the wormholes of the web platform. Combine them with the other
new platform primitives like Shadow DOM and `<template>`, and we start to realize
the picture of Web Components. Markup can be sexy again!

If you're interested in getting started with web components, I recommend checking
out [Polymer](http://polymer-project.org). It's got more than enough to get you going.

gha_license_id: NOASSERTION


text:
# LiKy

A Javascript MVVM Library for Building Interface.

## Intro

[LiKy](https://github.com/kyleslight/LiKy) ( name combined with '狸' and 'Kyles' ) is a Javascript MVVM Library to help web developers building user interface. It is a project created by [Kyles Light](https://github.com/kyleslight) for learning and personal use. The core of LiKy is really tiny ( compressed size of version 0.0.2 is 13 KB ) but made easy to use.

LiKy is inspired by a series of awesome librarys such as [React](https://facebook.github.io/react/) , [Vue](https://vuejs.org/) and [Spine](http://spinejs.com/),  it contains a few ideas to make web development more simple and efficient :

- **Component**. The component holds the common methods and data shared by all LiKy instances created by it, it also supports inheritance. So you can divide your application into segments and give the each segment more reusability with the help of component.
- **Element and State**. You create a LiKy instance by binding it with a element name ( using CSS selector syntax ) and initial state object ( optional ). So the element will be rendered with the state. You can also trigger event and generate structure ( and other staffs ) by adding attributes to the element.

And that's it!

## Installation

It's easy to install LiKy with [npm](https://www.npmjs.com/package/liky) :

```bash
npm i --save liky
```

Or you can just include it in your `script` tag :

```vbscript-html
<script src="http://kyleslight.net/static/file/liky.min.js"></script>
```

## Getting Start

There is a [demo page](http://kyleslight.net/liky) to show you how to get start with it.

## Features

### Creating Component

To start with LiKy, create a component with common attributes object, the common attributes is optional :

```javascript
var Component = LiKy.createComponent();
```

Common attributes will be shared by all instance created by this component, it will hold the methods and component config data:

```javascript
var Component = LiKy.createComponent({
    $reactive: true,
    foo: function () {
        // do something
    }
});
```

### Binding Element

The component we created is a reusable constructor, it acts much like a Class. We can create a LiKy instance by passing it a element selector string and a initial state object ( optional ) to help it initialise and render with state, if we have an element like :

```html
<div id="app">
    {{message}}
</div>
```

We can bind it with state:

```javascript
Component.bindElement('#app', {
    message: 'Well, this is LiKy desu!'
});
```

After the initial render process, the element will be rendered  :

```html
<div id="app">
    Well, this is LiKy desu!
</div>
```

The component can bind more than one element :

```javascript
var Component = LiKy.createComponent({
    changeMessage: function () {
        // do something for your message
    }
});
Component.bindElement('#app1', {
    message: 'Some Text'
});
Component.bindElement('#app2', {
    message: 'Another Text'
});
```

So the common method and data can be reused by them.

### State

Any LiKy instance has a `state` object,  which is the Model of the term 'MVVM'.  You can access it just like normal Javascript object :

```javascript
// in your component method
var text = this.state.message;
this.state.message = 'Another Text';
```

`state` can be changed rapidly.  By default, the change will not trigger render process until you call `setState` method, in `loose` mode ( current version only `loose` mode is implemented ), you can pass the changed attributes to `setState`, or you can just write `setState()` to remind LiKy it's time to render :

```javascript
// in your component method

// way 1
this.state.todos.push('Another Todo');
this.setState({
    id: -1
}); // todos and id will all be changed

// way 2
this.state.todos.push('Another Todo');
this.state.id = -1;
this.setState(); // way 1 and way 2 did the same thing
```

### Template Syntax

The template engine of LiKy is implemented individually. But don't worry, the syntax is quite simple and acts like other template engine:

- **Text Replacement**: the place where you set `{{<YourStateAttribute>}}` will be replaced by your state attribute value string ( after HTML escaping ), if the value is `undefined`, it will display nothing.
- **Voidng Escaping**:  set `{{{<YourStateAttribute>}}}` if you do want to replace with `HTML` string ( mind it would cause safety issue ).
- **Looping**:  the element with `lk-for` will traverse state attribute ( it should be an array ), render all items in order. In `lk-for='<item> in <items>'`, `<items>` represents your state attribute, `<item>` is an median value in each looping process. The looping syntax support nested.
- **Control**: if you set `lk-if`, the elemen will/will not be render when the value ( state attribute ) is `true`/`false`. The `lk-not` does the opposite thing.

### Handling Events

If you have declared the methods in element attribute `lk-on` ( note the event name should be listed in https://developer.mozilla.org/en-US/docs/Web/Events ):

```html
<div id="app">
    <button lk-on="click:Clicked">Click</button>
</div>
```

the method will be delegated to the root element ( in this case `#app` ) automatically, remember to define the associated method in your component :

```javascript
LiKy.createComponent({
    clicked: function () {
        console.log('be clicked');
    }
}).bindElement('#app');
```

All things will be done as you imagine. If you have more than one event to be handle, declared it in this way :

```html
<input type="text" lk-on="input:inputed;blur:blured">
```

### Input State

The `state` attributes will be changed in two different ways : dynamically modified in common method or modified by input value. If an element have `value` and  `lk-state` attributes, any change in your Input element will automatically trigger the change of `state` ( not be render ):

```html
<input type="text" lk-state="content">
```

so you can access the real-time value of input in common method.

```javascript
// in your component method
var content = this.state.content; // real-time value
```

### Element Attributes

You can dynamically change your element attribute by setting `lk-attr` :

```html
<div class="block" lk-attr="class:color"></div>
```

So when you change  `color` in your `state`:

```javascript
// in your component method
this.setState({
    color: 'red'
});
```

The element will be :

```html
<div class="block red" lk-attr="class:color"></div>
```

- Note the initial class attribute will not be recovered. But if you change `color` to `blue`, the value `red` will be replaced.
- For other attributes, the value will be replaced by the value in your `state`.
- Use `lk-attr="class:class1,class2..."` to set multi-class.
- Use `lk-attr="attr1:value1;attr2:value2..."` to set multi-attribute.

## Issues

LiKy is still being constructed, it might not be stable. If you have any issue, just to https://github.com/kyleslight/LiKy/issues to remind me about that.

LiKy does not support IE 8 and below, which means you should be careful considering about LiKy if there is still a amount of your users visiting from those browsers.

## License
LiKy is [MIT licensed](https://opensource.org/licenses/MIT), so you are free to use it.

repository: kyleslight/LiKy

repo_name: kyleslight/LiKy


text:
Turn your Windows UWP app into a host for universal stickers extension apps. Apps that declare the Universal.Sticker.1 App extension will expose stickers & clipart to your app in a sticker control. Your users can browse stickers (images or any other types of file assets) and then place them in your app.

1. Add the App Extension Host declaration to your app for Universal.Stickers.1
2. Place a StickersControl on a Xaml page
3. Handle the StickersControl.StickerSelected event to place the sticker that the users selects into your app.

    xmlns:sr="using:StickerResources"

    <sr:StickersControl StickerSelected="OnStickerSelected"/>

repository: mscherotter/UniversalStickers

repo_name: mscherotter/UniversalStickers


text:
# mutation_fuzzer

Mutation based fuzzer using C language for the "Computer System Security" course at UCLouvain.

## Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes.

### Prerequisites

The mutation based fuzzer only works on Linux operating systems because of the use of the following libraries
```
#include <unistd.h> /* for fork */
#include <sys/types.h> /* for pid_t */
#include <sys/wait.h> /* for wait */
```

### Installing

You will first of all need to compile the program with the following command

```
/usr/bin/gcc -g /home/user/Desktop/fuzzer_proj/code/src/main.c -o /home/user/Desktop/fuzzer_proj/code/src/main
```

Make sure you are in the right directory before compiling

### Running

The executable file can be ran using the following command
```
./main testinput.img 100 0.02
```
testinput.img   is a input file that doesn't crash the converter program
100             is the number of test runs to make
0.02            means that the fuzzer randomly changes 1% of the bytes in the input file in order to
                create the next input file for the current test run.

### Explanation of the crash files
the following files can be found in the "crash" folder
1) 1201_14ff_15ff_crash.img
when the  12th byte is set to 01
the 14th to ff
and the 15th to ff (starting at 0)
the converter crashes
2) colortable.img
whe the 22th byte is changed (one of the colortable bytes), the converter crashes

## Authors

* **Zeyd Salef** - *Initial work* - [MA-Agentz](https://github.com/MA-Agent/)

## License

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


text:
# Canonical JSON serialization for Rust

![Build and Test](https://github.com/engineerd/cjson/workflows/Build%20and%20Test/badge.svg)
[![docs.rs](https://docs.rs/cjson/badge.svg?version=0.1.1)](https://docs.rs/cjson/0.1.1/cjson/)
[![Crates.io](https://img.shields.io/crates/v/cjson.svg)](https://crates.io/crates/cjson)

This is an implementation for a canonical JSON serializer that tries to be
compliant with [the OLPC minimal specification for canonical JSON][olpc].
Additionally, the implementation also tries to be fully compatible with the [Go
canonical JSON implementation][docker/go/canonical] used across the Docker and
Notary ecosystem. If you find any inconsistencies with the result of the
serialization, please open an issue.

Example - reading a JSON file and printing its canonical representation:

```rust
let res: serde_json::Value =
    serde_json::from_reader(input).expect("cannot deserialize input file");

println!(
    "{}",
    cjson::to_string(&res).expect("cannot write canonical JSON")
);
```

> Note: this crate aims to always be compilable to the `wasm32-unknown-unknown`
> and `wasm32-wasi` targets.

### Building and contributing

This project welcomes contributions of any kind, particularly additional test
cases.

To build:

```
$ cargo build
$ cargo test
```

The `testdata` directory is structured in the following way:

- in the root of the directory are JSON files whose name is represented by the
  SHA256 digest of their canonical JSON representation, as calculated using the
  [`github.com/docker/go/canonical`][docker/go/canonical] package. The test case
  will use compare the SHA256 digest obtained after serializing using this
  implementation, to the file name, and they are expected to be equal.

To add a new test case, you can use the [`canonjson`][canonjson] binary, which
is a CLI wrapper over the Go canonical JSON implementation:

```
$ go get github.com/technosophos/canonjson
$ canonjson target-file.json | sha256sum
```

At this point, rename `target-file.json` to the `<computed-SHA256>.json`, the
move it in the root of the `testdata` directory.

- the `errors` sub-directory contains valid JSON files (if the files are not
  valid JSON files, the tests will fail), but which contain characters that are
  not permitted in canonical JSON - so trying to represent them in canonical
  JSON should produce an error.

Finally, the `scripts/integration.sh` script contains a very rudimentary test of
the CLI from `main.rs` - and compares the digest of obtained there with the
digest obtained from serializing with the Go implementation. Ideally, we would
add more implementations of canonical JSON to test against. Note that you also
need the `canonjson` binary used earlier to execute this script.

### Notes and acknowledgement

- this implementation was initially based on the canonical JSON serialization
  used in the [Rust TUF crate][rust-tuf].

[olpc]: http://wiki.laptop.org/go/Canonical_JSON
[docker/go/canonical]: https://github.com/docker/go/tree/master/canonical/json
[canonjson]: https://github.com/technosophos/canonjson
[rust-tuf]: https://github.com/heartsucker/rust-tuf/

repository: iCodeIN/cjson

repo_name: iCodeIN/cjson


text:
# What's that for?

# Sample connecting to a PostgreSQL database

start:

    $> traffic-dumper.sh --targetserver the_target_server --targetport 5432 --localport 7777 > out.log
    $> psql --host localhost --port 7777 --user the_username my_database (in another window)

sample select executed against postgres via psql console:

    psql (9.0.1)
    Type "help" for help.

    my_database=>select 1;

output:

    waiting for incoming connections on port '7777' which will be forward to 'xxx:5432' ...
    established connection. starting to capture and forward messages ...

    [SERVER] >, bytes [<0x4e>]
    [SERVER] >, data  [N]
    [CLIENT] >, bytes [<0x0>....<0x2f>]
    [CLIENT] >, data  [<0x0><0x0><0x0><0x8><0x4>?<0x16>/]
    ...
    [CLIENT] >, data  [Q<0x0><0x0><0x0><0xe>select 1;<0x0>]
    [SERVER] >, bytes [...]
    [CLIENT] >, data  [X<0x0><0x0><0x0><0x4>]

# Sample connecting to www.google.com

start:

    $> traffic-dumper.sh --targetserver www.google.com --targetport 80 --localport 6666 > out.log
    $> telnet localhost 6666

now we use telnet to query against localhost

    telnet: Trying ...
    Connected to localhost.
    Escape character is '^]'.
    GET / HTTP/1.1
    Host: www.google.com
    \n
    \n

output:

    waiting for incoming connections on port '6666' which will be forward to 'www.google.com:80' ...
    established connection. starting to capture and forward messages ...

# Getting Traffic Dumper

just download the latest zip file

or built from scratch

    $> git clone https://github.com/niesfisch/traffic-dumper.git
    $> cd traffic-dumper.git
    $> mvn clean package

# How To

    traffic-dumper.sh --targetserver homer --targetport 1234 --localport 7777 > out.log

this will start a connection to host 'homer' on port '1234' which is connected to your local port '7777'

now start your application and connect it to localhost:7777

e.g. for postgres

    old: jdbc:postgresql://homer:5432/your_databsae
    new: jdbc:postgresql://localhost:7777/your_databsae

issue some SQL statements and watch the output generated

# Licence

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

# Release Notes

.... TBD

repository: niesfisch/traffic-dumper

gha_language: Java

repo_name: niesfisch/traffic-dumper


text:
---
title: "miRNA annotation"
author: "Lorena Pantano"
date: "10/02/2015"
output:
  knitrBootstrap::bootstrap_document:
    theme: readable
    highlight: zenburn
    theme.chooser: TRUE
    highlight.chooser: TRUE
  html_document:
    highlight: zenburn

---

# Methods
 * isomiRs are simulated with the script inside `seqcsluter`. see `mirannotation.sh`.
 * To see reproducibility, please check: `mirannotation.sh` script. `installer.sh` helps with installation of some specific tools that are less likely you have installed.
 * miRBase 21 is the version used.
 * scoring hits to precursor: in case the tool gives a score, the best score will be used. If not the first hit is the one used. If score is the same, the first hit is used. Tools that can be scored are: `bowtie, bowtie2, chimira_blast, GEM, microzer, miraligner, miraligner-python, novoaling, razer3, STAR`
 * only `miraligner*` and `srnabench `gives miRNA annotation, so these tools should have an advantage since they are parsing the hits to get the best annotation. Anyway, I am trying to get the best of all of them using the precursor name instead of the miRNA. In the last section, since the rest tools are only alignerts, I call miRNA the firs three names in the precursor (i.e hsa-let-7a in hsa-let-7a-1/2/3).

*Note* Future work is the use of the [python miraligner](http://seqcluster.readthedocs.org/mirna_annotation.html#miraligner-inside-seqcluster) version to annotate miRNA/isomiR from BAM files with precursor hits coming from any tool that gives a BAM file as output.

# Mapped
Proportion of mapped and no-mapped sequences
![](figure/mapped-mir-1.png)

# Size effect
How size affects the alignments
![](figure/size-mir-1.png)

# Isomirs effect
How changes in the mature miRNA affect the alignment:

* red: addition + mutation
* blue: addition
* green: mutation
* purple: just trimming precursor at different position

![](figure/iso-mir-1.png)

# Specificity at precursor level
How many were assigned to the correct miRNA using the precursor name as the true positive.
Red would be "not correct" and blue "correct". This is only considering mapped sequences.
![](figure/sp-precursor-1.png)

# Specificity at miRNA level
Same logic than before but with the miRNA names in case the tool gives the miRNA names, if not, only the three first field in the name are used as annotation (i.e hsa-let-7a-1 will ignore any character beyond 7a). This will increase the number of TP, since many miRNAs has multiple precursors being the same mature miRNA at the end.
![](figure/sp-mir-1.png)

repository: chapmanb/mypubs

repo_name: chapmanb/mypubs


text:
<meta name="google-site-verification" content="tZgbB2s-hTI0IePQQRCjHqL_Vf0j_XJmehXAHJerrn4" />

# Microsoft Azure PowerShell

This repository contains a set of PowerShell cmdlets for developers and administrators to develop, deploy and manage Microsoft Azure applications.

Take a test run now from Azure Cloud Shell!

[![](https://shell.azure.com/images/launchcloudshell.png "Launch Azure Cloud Shell")](https://shell.azure.com/powershell)

## Modules

Below is a table containing the various Azure PowerShell rollup modules found in this repository. For a full list of modules found in this repository, please see the [Azure PowerShell Modules](documentation/azure-powershell-modules.md) page.

| Description                                                     | Module Name       | PowerShell Gallery Link |
| --------------------------------------------------------------- | ----------------- | ----------------------- |
| Rollup Module for ARM Cmdlets                                   | `AzureRM`         | [![AzureRM](https://img.shields.io/powershellgallery/v/AzureRM.svg?style=flat-square&label=AzureRM)](https://www.powershellgallery.com/packages/AzureRM/) |
| Rollup Module for .NET Standard cmdlets                         | `Az` | [![Az](https://img.shields.io/powershellgallery/v/Az.svg?style=flat-square&label=Az)](https://www.powershellgallery.com/packages/Az/) |
| Rollup Module for Administrative Modules in Azure Stack         | `AzureStack`      | [![AzureStack](https://img.shields.io/powershellgallery/v/AzureStack.svg?style=flat-square&label=AzureStack)](https://www.powershellgallery.com/packages/AzureStack/) |
| Rollup Module for Service Management Cmdlets                  | `Azure`           | [![Azure](https://img.shields.io/powershellgallery/v/Azure.svg?style=flat-square&label=Azure)](https://www.powershellgallery.com/packages/Azure/) |

## Installation

For more detailed instructions on installing Azure PowerShell, please refer to the [installation guide](https://docs.microsoft.com/en-us/powershell/azure/install-azurerm-ps).

### PowerShell Gallery

Run the following command in an elevated PowerShell session to install the rollup module for Azure Resource Manager cmdlets:

```powershell
Install-Module -Name AzureRM
```

Run the following command in an elevated PowerShell session to install the new 'Az' module for ResourceManager cmdlets. This module runs on PowerShell 5.1 (with .Net Framework 4.7.2) ,  or PowerShell Core, and replaces AzureRM.  You should not install this module side-by-side with AzureRM:

```powershell
Install-Module -Name Az
```

To install the module containing the legacy RDFE cmdlets, run the following command in an elevated PowerShell session:

```powershell
Install-Module -Name Azure
```

If you have an earlier version of the Azure PowerShell modules installed from the PowerShell Gallery and would like to update to the latest version, run the following commands in an elevated PowerShell session. Update-Module installs the new version side-by-side with the old version. It does not remove the old version.

```powershell
# Update to the latest version of AzureRM
Update-Module -Name AzureRM

# Update to the latest version of Az
Update-Module -Name Az

# Update to the latest version of Azure
Update-Module -Name Azure
```

### Web Platform Installer

Download and install the [Microsoft Web Platform Installer](https://www.microsoft.com/web/downloads/platform.aspx). Once installed, open the program and search for _Microsoft Azure PowerShell_. Click the _Add_ button followed by the _Install_ button at the bottom to begin the installation process.

## Usage

For more detailed instructions on using Azure PowerShell, please refer to the [getting started guide](https://docs.microsoft.com/en-us/powershell/azure/get-started-azureps).

### Log in to Azure

To connect to Azure, use the [`Connect-AzureRmAccount`](https://docs.microsoft.com/en-us/powershell/module/azurerm.profile/connect-azurermaccount) cmdlet.

```powershell
# Interactive login - you will get a dialog box asking for your Azure credentials
Connect-AzureRmAccount

# Non-interactive login - you will need to use a service principal
Connect-AzureRmAccount -ServicePrincipal -ApplicationId "http://my-app" -Credential $PSCredential -TenantId $TenantId
```

To log into a specific cloud (_AzureChinaCloud_, _AzureCloud_, _AzureGermanCloud_, _AzureUSGovernment_), use the `Environment` parameter:

```powershell
# Log into a specific cloud - in this case, the Azure China cloud
Connect-AzureRmAccount -Environment AzureChinaCloud
```

### Getting and setting your session context

To view the context you are using in the current session, which contains the subscription and tenant, use the [`Get-AzureRmContext`](https://docs.microsoft.com/en-us/powershell/module/azurerm.profile/get-azurermcontext) cmdlet:

```powershell
# Get the context you are currently using
Get-AzureRmContext

# List all available contexts in the current session
Get-AzureRmContext -ListAvailable
```

To get the subscriptions in a tenant, use the [`Get-AzureRmSubscription`](https://docs.microsoft.com/en-us/powershell/module/azurerm.profile/get-azurermsubscription) cmdlet:

```powershell
# Get all of the subscriptions in your current tenant
Get-AzureRmSubscription

# Get all of the subscriptions in a specific tenant
Get-AzureRmSubscription -TenantId $TenantId
```

To change the subscription that you are using for your current context, use the [`Set-AzureRmContext`]() cmdlet:

```powershell
# Set the context to a specific subscription
Set-AzureRmContext -Subscription $SubscriptionName -Name "MyContext"

# Set the context using piping
Get-AzureRmSubscription -SubscriptionName $SubscriptionName | Set-AzureRmContext -Name "MyContext"
```

### Discovering cmdlets

Use the `Get-Command` cmdlet to discover cmdlets within a specific module, or cmdlets that follow a specific search pattern:

```powershell
# View all cmdlets in the AzureRM.Profile module
Get-Command -Module AzureRM.Profile

# View all cmdlets that contain "VirtualNetwork"
Get-Command -Name "*VirtualNetwork*"

# View all cmdlets that contain "VM" in the AzureRM.Compute module
Get-Command -Module AzureRM.Compute -Name "*VM*"
```

### Cmdlet help and examples

To view the help content for a cmdlet, use the `Get-Help` cmdlet:

```powershell
# View the basic help content for Get-AzureRmSubscription
Get-Help -Name Get-AzureRmSubscription

# View the examples for Get-AzureRmSubscription
Get-Help -Name Get-AzureRmSubscription -Examples

# View the full help content for Get-AzureRmSubscription
Get-Help -Name Get-AzureRmSubscription -Full

# View the help content for Get-AzureRmSubscription on https://docs.microsoft.com
Get-Help -Name Get-AzureRmSubscription -Online
```

## Reporting Issues and Feedback

### Issues

If you find any bugs when using the Azure PowerShell modules, please file an issue [here](https://github.com/Azure/azure-powershell/issues), making sure to fill out the provided template with the appropriate information.

Alternatively, be sure to check out the [Azure Support Community](https://azure.microsoft.com/en-us/support/forums/) if you have trouble with any of the cmdlets or Azure services.

### Feedback

If there is a feature you would like to see in Azure PowerShell, please use the [`Send-Feedback`](https://docs.microsoft.com/en-us/powershell/module/azurerm.profile/send-feedback) cmdlet, or file an issue [here](https://github.com/Azure/azure-powershell/issues), to send the team direct feedback.

## Contribute Code

If you would like to become an active contributor to this project please follow the instructions provided in [Microsoft Azure Projects Contribution Guidelines](https://azure.github.io/guidelines/).

More information about contributing to this repo can be found in [CONTRIBUTING md](https://github.com/Azure/azure-powershell/blob/preview/CONTRIBUTING.md) and the [Azure PowerShell Developer Guide](https://github.com/Azure/azure-powershell/blob/preview/documentation/development-docs/azure-powershell-developer-guide.md) folder.

## Learn More

* [Microsoft Azure Documentation](https://docs.microsoft.com/en-us/azure/)
* [PowerShell Documentation](https://docs.microsoft.com/en-us/powershell/)

---
_This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode<EMAIL_ADDRESS>with any additional questions or comments._

repository: bganapa/azure-powershell

branch_name: refs/heads/AzureRM

gha_language: C#

repo_name: bganapa/azure-powershell


text:
# Design Patterns PHP

This is a repository whith Design pattern in php,
with explanation.

## My objective
Provider the design patterns,

_coding very simply, near of skeleton but just my pattern is a minimal runable version_

You can find the uml diagram and file test more later

## What is in it ?

**Creational Patterns**
- *Abstract Factory pattern*
- *Builder pattern*
- *Factory Method pattern*
- *Prototype pattern*
- *Singleton pattern*

**Structural patterns**
- *Adapter pattern*
- *Bridge pattern*
- *Composite pattern*
- *Decorator pattern*
- *Facade pattern*
- *Flyweight pattern*
- *Proxy pattern*

**Behavorial patterns**
- *Chain of responsibility pattern*
- *Command pattern*
- *Interpreter pattern*
- *Iterator pattern*
- *Mediator pattern*
- *Memento pattern*
- *Template method pattern*

## source :
I take my source with this book :

__GOF Design patterns__

__Licence MIT__
#### Christophe CIATTI

repository: ChristopheCIATTI/DesignPatternsPHP

gha_language: PHP

repo_name: ChristopheCIATTI/DesignPatternsPHP


text:
# file-size-distro
Another Rosetta Code Program in Rust

My attempt for an entry on Rosetta Code's https://rosettacode.org/wiki/File_size_distribution (as of this writing, draft) task.

Should be run in terminal, will search and report on the directory the .exe is in if target is otherwise unspecified.

Currently only guaranteed to work on Win10! Will test and adapt for other platforms for fun later.


text:
## add zookeeper support

- push logs to kafka through zookeeper.
- use kafka-rb of https://github.com/ops-baidu/kafka-rb.git
- jiuze#baidu.com

## config example

    <match kafka.*.*>
      # plugin type (requried)
      type kafka

      # product & service (requried)
      product aqueducts
      service astream

      # buffer config (only requried in development mode, defalut value is ok for production.)
      host <IP_ADDRESS>
      port 2181

      # interval (optional, but it may affect the latency.)
      flush_interval 1s
    </match>

# Fluent::Plugin::Kafka

TODO: Write a gem description
TODO: Also, I need to write tests

## Installation

Add this line to your application's Gemfile:

    gem 'fluent-plugin-kafka'

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install fluent-plugin-kafka

## Usage

TODO: Write usage instructions here

## Contributing

1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Added some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request

repository: sdgdsffdsfff/fluent-plugin-kafka

repo_name: sdgdsffdsfff/fluent-plugin-kafka


text:
# iMsgQuickReply

iMsgQuickReply is a Pebble app that will allow you to send quick replies to your iMessage contacts. You will need an OS X computer, preferably running as a server.

Setup
=======

1. Please install iMsgBridge on your OS X computer,
  - Instructions available here: https://github.com/mkpascal/iMsgBridge/
2. Install iMsgQuickReply on your Pebble,
  - PBW available here: https://github.com/mkpascal/iMsgQuickReply/releases
3. Configure iMsgQuickReply on the Pebble Time app.
4. Fill the form with your server URL (ex: http://<IP_ADDRESS>:4567) and password (ex: changeme).
5. Restart the app on your watch and you're ready to go.

Notes
=======

This is not for everyone and is available just for experimental purposes. Also, please note that the data communication between the app and your server will not be encrypted by default.
I am not storing anything and every component of iMsgQuickReply is open source. The source code of the configuration page is available on the branch, gh-pages.

repository: mkpascal/iMsgQuickReply

repo_name: mkpascal/iMsgQuickReply