text:
---
category: Watch
---

# watchTriggerable

Watch that can be triggered manually

## Usage

A `watch` wrapper that supports manual triggering of `WatchCallback`, which returns an additional `trigger` to execute a `WatchCallback` immediately.

```ts
import { watchTriggerable } from '@vueuse/core'
import { nextTick, ref } from 'vue'

const source = ref(0)

const { trigger, ignoreUpdates } = watchTriggerable(
  source,
  v => console.log(`Changed to ${v}!`),
)

source.value = 'bar'
await nextTick() // logs: Changed to bar!

// Execution of WatchCallback via `trigger` does not require waiting
trigger() // logs: Changed to bar!
```

### `onCleanup`
When you want to manually call a `watch` that uses the onCleanup parameter; simply taking the `WatchCallback` out and calling it doesn't make it easy to implement the `onCleanup` parameter.

Using `watchTriggerable` will solve this problem.
```ts
import { watchTriggerable } from '@vueuse/core'
import { ref } from 'vue'

const source = ref(0)

const { trigger } = watchTriggerable(
  source,
  async (v, _, onCleanup) => {
    let canceled = false
    onCleanup(() => canceled = true)

    await new Promise(resolve => setTimeout(resolve, 500))
    if (canceled)
      return

    console.log(`The value is "${v}"\n`)
  },
)

source.value = 1 // no log
await trigger() // logs (after 500 ms): The value is "1"
```

repository: vueuse/vueuse

repo_name: vueuse/vueuse


text:
# antoniomdk's dotfiles

My personal configuration files for zsh, neovim, tmux, iterm, macOS, tmuxinator...

## Features

### Neovim

#### Editor

Powerful fully-featured editor.

* Special support for: C++, Python, Scala and Haskell (other filetypes are supported as well)
* Code linting
* Syntax checker
* Code completion
* File browser
* Formatting tools
* Fuzzy searching
* Tag management and exploration
* Mnemonic mappings
* Gruvbox theme
* A lot of more feautures...

![vim1](assets/screenshot_vim1.png)

![vim1](assets/screenshot_vim3.png)

#### Tmux integration for REPLs

![vim1](assets/screenshot_vim2.png)

It is possible to make the editor work with external REPLs in a simple way.

- Support for most REPL: ipython, R, ihaskell, scala...

- Automatic layout creation by [tmuxinator](https://github.com/tmuxinator/tmuxinator)

> See [vim-slime](https://github.com/jpalardy/vim-slime) for details
>

#### Custom Mappings

> <Leader> key has been changed to ","

| Key Mapping | Description                                             |
| ----------- | ------------------------------------------------------- |
| Ctr-h/j/k/l | Window splits navigation                                |
| Ctr-p       | Open explorer                                           |
| Ctr-t       | Open tag bar                                            |
| <Leader>f   | Format code                                             |
| <Leader>A   | Jump to header/implementation file. Only for C/C++ code |
| <Leader>a   | Toggle align-code mode                                  |
| Ctr-space   | Fuzzy searching through files                           |
| Ctr-b       | Fuzzy searching through buffers                         |
| Ctr-a       | Ag searching                                            |
| Ctr-f       | Find in buffer                                          |
| <Leader>ww  | Select/Swap window.                                     |
| <Shift>K    | Show C/C++ docs                                         |

### Terminal

#### Theme

I love gruvbox theme so I use it both for Neovim and iTerm2. I put the .itermcolors file [here](gruvbox.itermcolors) for you to use it easily.

> Note: If you are on macOS and not using [iTerm2](https://iterm2.com/), please, install it :)

#### Enhanced ls

![exa](assets/enhanced_ls.gif)

I prefer [exa](https://github.com/ogham/exa) over ls, so I have aliases for **l, la** and **ll**

#### Enhanced cd

![exa](assets/enhanced_cd.gif)

Interactive directory navigation thanks to [fzf](https://github.com/junegunn/fzf) and [enhancd](https://github.com/b4b4r07/enhancd)

#### Fast navigation

![exa](assets/fasd.gif)

Ultra fast navigation through directories and files thanks to [fasd](https://github.com/clvv/fasd)

### Tmuxinator

Default tmuxinator projects to use Neovim with the most common REPLs:

| Language | Project Name | Command executed |
| :------: | :----------: | :--------------: |
|  Python  | python-repl  |     ipython      |
|    R     |    r-repl    |        R         |
|  Scala   |  scala-repl  |      scala       |
| Haskell  | haskell-repl | stack exec ghci  |
|   Ruby   |  ruby-repl   |       irb        |

## Requirements

I use Homebrew package manager, which allows me to deal with dependencies easily. If you use it too, run **install.sh** script to install the required packages.

If you use Linux or Homebrew isn't for you, follow the install instructions of each package to get everything working. In case you don't want to use some tool, just don't install it, but make sure the aliases and other related files are changed.

> Note: **Neovim requires FZF** for some IDE features so, you should install it. FZF can be replaced by Unite, CtrP or any similar plugin, but it is not supported out of the box.

**Neovim** requires python2 and python3 support to work correctly. Make sure your system has both Python versions installed and run the following:

```bash
pip2 install neovim
pip3 install neovim
```

TODO

...

license: MIT

repository: antoniomdk/dotfiles

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: antoniomdk/dotfiles


text:
---
id: cli
title: aim CLI
sidebar_label: command line interface
---
aim CLI is a git-like tool that allows to push, pull the results of experiments.

## aim init
Initializes the aim repository.
```sh
# cd to the repo for the model training code
aim init
```
Creates `.aim` folder in the folder where all the tracking info is saved.

## aim remote
Adds remote to the aim repo to push the training info to.
```sh
aim remote add -n origin -u <origin url>
```
List the remotes addes to the repo
```sh
aim remote ls
```
Remove remote from the list of remotes
```sh
aim remote rm -n origin
```

Other options
- `-n` or `--name` name of the remote (such as `origin`)
- `-u` or `--url` url of the remote ()

## aim commit
Commit the run to remote.
```sh
aim commit -m "<Commit Message>"
```
**Note**: work can only be pushed after it's committed

## aim push
Push the Training Info to the remote
```sh
aim push -r <remote_name>
```
Other options
- `-r` or `--remote` the name of the remote to push to

## aim branch
Create different experiment branches for your project.
```sh
aim branch add -n <branch_name>
```
Checkout to an existing branch
```sh
aim branch checkout -n <branch_name>
```
List all the branches
```sh
aim branch ls
```
Delete branch
```sh
aim branch rm -n <branch_name>
```

## aim auth
Aim auth allows the users to seamlessly auth in their remote servers
```sh
aim auth -a <remote_address>
```
Will produce the key that need to be copy-pasted in the settings of the user


text:
# Xylohypha ferruginosa (Corda) S. Hughes, 1960 SPECIES

#### Status
ACCEPTED

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

#### Published in
in Deighton, Mycol. Pap. 78: 43 (1960)

#### Original name
Torula ferruginosa Corda, 1829

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# 05.Shell Arithmetic Expansion

Arithmetic Expansion
Arithmetic expansion allows the evaluation of an arithmetic expression and the substitution of  the  result.   The  format  for  arithmetic
       expansion is:

              $((expression))

       The  expression  is  treated  as  if it were within double quotes, but a double quote inside the parentheses is not treated specially.  All
       tokens in the expression undergo parameter expansion, string expansion, command substitution, and quote removal.  Arithmetic expansions may
       be nested.

       The  evaluation is performed according to the rules listed below under ARITHMETIC EVALUATION.  If expression is invalid, bash prints a mes-
       sage indicating failure and no substitution occurs.

repository: SC-CS-KS/KS-Shell

repo_name: SC-CS-KS/KS-Shell


text:
**STRUCT**

# `GitCommit`

```swift
public struct GitCommit: Decodable, Equatable
```

> A platform agnostic reference to a git commit.

## Properties
### `sha`

```swift
public let sha: String?
```

> The SHA for the commit.

### `author`

```swift
public let author: GitCommitAuthor
```

> Who wrote the commit.

### `committer`

```swift
public let committer: GitCommitAuthor
```

> Who shipped the code.

### `message`

```swift
public let message: String
```

> The message for the commit.

### `parents`

```swift
public let parents: [String]?
```

> SHAs for the commit's parents.

### `url`

```swift
public let url: String
```

> The URL for the commit.

repository: f-meloni/swift

gha_language: Swift

gha_license_id: MIT

repo_name: f-meloni/swift


text:
# Jeremiah 12 General Notes
## Structure and formatting

Some translations set each line of poetry farther to the right than the rest of the text to make it easier to read. The ULT does this with the poetry in 12:1-13.

## Special concepts in this chapter

### Jeremiah complains that evil men prosper

Jeremiah complains that evil men prosper. He questions Yahweh’s justice. Yahweh’s response: if Jeremiah is upset by the people of Anathoth, how will he face enemies in Jerusalem? (See: [[../bible/kt/evil]] and [[../bible/kt/justice]])

### Yahweh’s grace to the other nations

Yahweh gives a gracious offer to the Gentile nations. If the other nations who have been against Judah leave their idols and worship God, then God will allow them to return to their lands. (See: [[../bible/kt/grace]])

repository: mandolyte/uw-obsidian

branch_name: refs/heads/main

repo_name: mandolyte/uw-obsidian


text:
---
layout: article
title: "Lostcast 215: Early Burnout"
author: matt
tags: [lostcast]
podcast:
  title: "Lostcast 215"
  subtitle: "Early Burnout"
  summary: "Early Access time restrictions, burn out, and how to pace yourself after a release."
  duration: "1:00:29"
  length: 3629
  filesize: 53MB
  pubDate: "Tue, 21 Mar 2017 13:00:00 GMT"
  mp3url: http://media.lostdecadegames.com/lostcast/lostcast_215.mp3
  keywords: html5, games, lost decade games, gamedev, podcast, indie, lostcast
---
_**Lostcast** is the Lost Decade Games podcast, where [Geoff and Matt](/about/) talk about running a small, independent game studio._

{{ page.podcast.summary }}

<a class="download-podcast" href="{{ page.podcast.mp3url }}">
	Download {{ page.podcast.title }} ({{ page.podcast.duration }}, {{ page.podcast.filesize }})
</a>

## Show notes

* [Lostcast 211: Podcast Direct](http://www.lostdecadegames.com/lostcast-211/)
* [Let's Play [Geoff's Tactics Prototype]](https://www.youtube.com/watch?v=lQTN-4PKWqc)
* [Let's Play [Project Skirmish] 5](https://www.youtube.com/watch?v=X09lGCikEbI)
* [Lostcast 212: Spaceboy Zack](http://www.lostdecadegames.com/lostcast-212/)
* [Positech Games](http://www.positech.co.uk/)
* [Finishing a Game](http://makegames.tumblr.com/post/1136623767/finishing-a-game)
* [Killing the "Lucky Indie" myth: How to build a sustainable microstudio.](https://www.youtube.com/watch?v=1BCg31KVJok)
* [Join us on Discord](https://discord.gg/jNHav65)
* You were played out by [Hallway to Hell](http://music.gamechops.com/track/hallway-to-hell-castlevania-heart-of-fire)

Thanks for listening! Subscribe below:

repository: lostdecade/manor

repo_name: lostdecade/manor


text:
# Sharptile

C# representation of the [Tiled](https://www.mapeditor.org) map editor's
[JSON format](http://doc.mapeditor.org/en/stable/reference/json-map-format/).
Nothing more, nothing less. This is useful for importing an exported Tiled map
into a C#-based game engine like Unity.

There are multiple versions of Tiled's JSON map format. Currently Sharptile
targets version 1.2.

## Current Limitations

- Only supports maps with the *Tile Layer Format* property set to **CSV**
- Only supports one JSON map format (currently v1.2)

## Using in Unity

While Sharptile is intentionally minimal and uses no Unity APIs, usage in Unity
was the reason for its creation. After adding the *.cs* files to your project,
use an editor script like the following to import a map.

```csharp
using Sharptile;
using System.IO;
using UnityEditor;
using UnityEngine;

class TiledTest
{
    [MenuItem("Tiled/Import Map")]
    static void ImportTiledMap()
    {
        var path = Path.Combine(Application.dataPath, "map.json");
        var json = File.ReadAllText(path);
        var map = JsonUtility.FromJson<Map>(json);
        // Do something with the map...
    }
}
```

Creating the necessary game objects and components to actually *show* the map is
left up to you. For more comprehensive Tiled support in Unity look no further
than [Tiled2Unity](http://www.seanba.com/Tiled2Unity).

repository: lelogrott/imprima

repo_name: lelogrott/imprima


text:
---
title: Ignore items from array destructuring
category: Tip
date: 2021-02-28 14:57:00 +7
layout: layouts/post.njk
topics: JavaScript
---

When destructuring an array, you can skip certain items by using blanks:

```js
const dateTime = '2021-02-28T14:57:00';

// Ignore the date part
const [, time] = dateTime.split('T');

// Ignore the seconds
const [hours, minutes] = time.split(':');

hours; // '14'
minutes; // '57'
```

If you are working in a team, then it's a good idea to add comments for skipped items. It also makes the code more readable:

```js
const [
    ,
    // date
    time,
] = dateTime.split('T');

const [hours, minutes /* seconds */] = time.split(':');
```

## See also

-   [Get characters of a string](/get-characters-of-a-string)
-   [Pick the first and last items of an array](/pick-the-first-and-last-items-of-an-array)
-   [Use an underscore to name unused argument](/use-an-underscore-to-name-unused-argument)


text:
#
#

# Library to send EMail with attachments
Arduino (support W5100 like must be set, and ENC28J60 via UIPEthernet), esp8266 (SPIFFS, LittleFS and SD) (core <=2.4.2 must be set) and esp32 (SPIFFS, LITTLEFS, Ffat and SD), Arduino WiFiNINA SAMD devices (Arduino MKR WiFi 1010, Vidor 4000 UNO WiFi Rev.2 ecc.) (SD).

### Complete english tutorial
#### [Send email with attachments (EMailSender v2.x library): Arduino Ethernet](https://www.mischianti.org/2020/06/09/send-email-with-attachments-v2-x-library-arduino-ethernet-part-1/)
#### [Send email with attachments (EMailSender v2.x library): esp32 and esp8266](https://www.mischianti.org/2020/06/16/send-email-with-attachments-emailsender-v2-x-library-esp32-and-esp8266-part-2/)

### Tutorial completo in italiano
#### [Inviare email con allegati (libreria v2.x): Arduino Ethernet](https://www.mischianti.org/it/2020/06/09/inviare-email-con-allegati-libreria-v2-x-arduino-ethernet-part-1/)
#### [Inviare email con allegati (libreria v2.x): esp32 e esp8266](https://www.mischianti.org/it/2020/06/16/inviare-email-con-allegati-libreria-v2-x-esp32-e-esp8266-part-2/)

## Change log
 - 20/05/2022: v3.0.1 Put inside scope the client declaration (if you don't use SSLClient) for backward compatibility
 - 18/05/2022: v3.0.0 Add STM32 support. Add SSLClient integration to allow send Email with SSL encryption (like Gmail) with ethernet (tested with STM32, ESP32, w5500, and enc28j60), minor fix
 - 12/04/2021: v2.4.3 Fix multiple email send
 - 12/04/2021: v2.4.1 Add support for LITTLEFS and Ffat on esp32 and fix certificate verification from esp32 core 1.0.5
 - 18/03/2021: v2.3.0 Add support for LittleFS on esp8266
 - 02/01/2021: v2.2.0 New support for SAMD devices via WiFiNINA (Arduino MKR WiFi 1010, Arduino Vidor 4000 and Arduino UNO WiFi Rev.2 ecc.).
 - 01/01/2021: v2.1.5 Add possibility to use EHLO instead of HELO, and SASL login.
 - 27/11/2020: v2.1.4 Add more constructor to allow more structure for distribution list (now const char*, char* and String array are supported)

23/11/2020: v2.1.3 Add management of name on EMail from

## Installation Tutorial:

To download.
click the DOWNLOADS button in the top right corner, rename the uncompressed folder EMailSender.
Check that the EMailSender folder contains `EMailSender\\.cpp` and `EMailSender.h`.
Place the EMailSender library folder your `<arduinosketchfolder>/libraries/` folder.
You may need to create the libraries subfolder if its your first library.
Restart the IDE.

# EMailSender library to send EMail.
With this library you can send email with attach:
Arduino
Network supported
	- w5100 like shield with Ethernet library
	- enc28J60 with UIPLibrary
Storage support
	- SD

esp8266
you must pay attention, older core from 2.4.2 must be activated
Storage supported
	- SD
	- SPIFFS
	- LittleFS

esp32
Storage supported
	- SD
	- SPIFFS
	- LITTLEFS
	- Ffat

Constructor:
Default value is quite simple and use GMail as smtp server.
```cpp
	EMailSender<EMAIL_ADDRESS>"password");
```

If you want use onother provider you can use more complex (but simple) contructor
```cpp
	EMailSender(const char* email_login, const char* email_password, const char* email_from, const char* smtp_server, uint16_t smtp_port);

```

You must connect to WIFI :P.

Create a message with the structure EMailMessage
```cpp
    EMailSender::EMailMessage message;
    message.subject = "Subject";
    message.message = "Hi, How are you<br>Fine.";
```

Create array of attachments
```cpp
// 		Two file
    EMailSender::FileDescriptior fileDescriptor[2];
    fileDescriptor[1].filename = F("test.txt");
    fileDescriptor[1].url = F("/test.txt");
    fileDescriptor[1].mime = MIME_TEXT_PLAIN;
    fileDescriptor[1].storageType = EMailSender::EMAIL_STORAGE_TYPE_SD;

    fileDescriptor[0].filename = F("logo.jpg");
    fileDescriptor[0].url = F("/logo.jpg");
    fileDescriptor[0].mime = "image/jpg";
    fileDescriptor[0].encode64 = true;
    fileDescriptor[0].storageType = EMailSender::EMAIL_STORAGE_TYPE_SD;

    EMailSender::Attachments attachs = {2, fileDescriptor};
```

Send message:
```cpp
    EMailSender::Response resp =<EMAIL_ADDRESS>message, attachs);
```

Then check the response:
```cpp
    Serial.println("Sending status: ");
    Serial.println(resp.code);
    Serial.println(resp.desc);
    Serial.println(resp.status);
```

From version 2.1.1 new features distribution list to send CC and CCn email.

Example output:

```cpp
Connection: ESTABLISHED
Got IP address: <IP_ADDRESS>
Sending status:
1
0
Message sent!
```

https://downloads.arduino.cc/libraries/logs/github.com/xreef/EMailSender/


text:
---
title: "Product School"
date: 2016-12-17
excerpt: "Spoke for the official Norfolk Free Code Camp Facebook group!"
header:
    image: https://fvcproductions.files.wordpress.com/2016/10/img_2266.jpg
---

![Product School](https://cdn.evbuc.com/eventlogos/110662633/pslogoeventimage.png)

## Name

Product School

## Location

Times Square - New York, NY

## Date

October 15, 2016 to December 17, 2016

## Role

Inaugural Class - Summer of Code

## About

Product School is an education startup that offers Product Management courses in San Francisco, Silicon Valley, New York and Los Angeles.

- 8 week part-time product management course
- taught by Christopher Andersson, founder of New York Code Company and the previous Senior Director of Product at InVision
- one of youngest students ever admitted at 20 years old due to relevant prior experience
- received the `Software Product Management Certification` at the end of the course

Overall, my experience with Product School was pretty great. I learned a lot of practical material from my instructor, [Christopher Andersson](https://linkedin.com/in/christopherandersson).

To be honest, though, I initially thought the content was too mediocre and was considering dropping the class. Despite this, I was encouraged that it would be worth it if I stuck with it.

Soon enough, Chris started to open up more and acted more transparent about what content would be most relevant. I felt I came with a better idea of what being a product manager is actually like and how to better leverage my existing skills for that position. The students in my class were also all very bright and fun to be around.

I think with a little more improvements to the content/slides, Product School's PM class can be made even greater.

### Certification

Product Management Certificate from Product School : Accredible : Certificates, Badges and Blockchain Credentials.

Part-time courses in product, coding, and data analytics for managers

gha_language: CSS


text:
ASP.NET CORE
============
This is a minimal .NET Core ASP.NET core Hello World!

Please be aware that this does not do any routing, so all urls will be
matched. This is purely in order to do the absolutely minimal work in
order to return 'Hello World!'.

Restore dependencies:
---------------------
```
dotnet restore
```

Run application:
----------------
```
dotnet run -c Release
```

Server will be online @ http://localhost:5000


text:
# Opacity
In this challenge we will learn about opacity classes of tailwind. Basically opacity is the quality of lacking transparency or translucence.

Requirements for the challenge:
1)In this challenge you have to create at least 4 divs with same background color.
2)After this add opacity-100, opacity-75, opacity-50 etc classes to depict decreasing opacity of the divs.

Below is the link for your reference:
https://tailwindcss.com/docs/opacity#app

repository: pooja-gera/TheWireUsChallenge

path: /CSS Tricks/CSST_DAY_101/README.md

repo_name: pooja-gera/TheWireUsChallenge


text:
---
layout: post
date:	2010-08-10 17:52:00
title:  Ancient Light Photowalk,Malleswaram, 010810 Part 2 Nandeeswara Teerttha
tags: [archived-posts]
categories: archives
permalink: /:categories/:year/:month/:day/:title/
---
For the Nandeeswara Temple, that was excavated in the early '90's, and which I personally believe to be part of the Kaadu Malleswara complex, let me begin with the brass lamp that the priests use to show Arathi for the ShivalingA:

...that's ancient light, too; snEha deepam...or an oil lamp.

This temple is actually a kalyANi or sacred wellspring, shaped into a water tank.

<lj-cut text="Nandeeswara TeerthhA" (the="(the" spring="spring" of="of" nandi)="Nandi)" here's="Here's" the="the" entrance="entrance" to="to" the="the" temple:="temple:"

It was nice to see that Nature had crowned the gOpurA with a Peepal sapling:

The terrace design is the same as in the Kaadu Malleswara Temple:

The garbha grihA, or inner sanctum,  is very beautiful:

the water comes out of the NandimukhA (mouth of Nandi) ...

....and pours into the copper kalashA, whence it drips steadily on to the LingA:

Here's a video showing the water dripping on the lingA, coming down from the mouth of Nandi:

<lj-embed id="462"/>

The entrance has this shlOkA:

Transliteration and translation:

muktEshwarAya phaladAya gaNEshwarAya
geethapriyAya vrishabhEshwarA vAhanAya.
mAthanga charma vasanAya mahEshwarAya
dAridrya dukkha dahanAya namah shivAya.

(the God who gives salvation, who grants boons, the god of Ganesh;
one who likes music, who has a bull as His vehicle:
One who wears the skin of an elephant as a dress, the great God,
One who destroys poverty and sorrow, salutations to Shiva.)

The navagrahA (nine planets) shrine is also small and beautiful:

Entering the temple, one sees the small Nandi and the bali peetthA (sacrificial stone) on the steps of the kalyANi:

The temple bell had a lovely deep tone (I know, because I rang it as some of the photographers had just got it to be still!)...

This rathA (symbolic chariot) is made of rosewood:

Behind the Nandi are an assortment of items used in the rites:

And some amount of plastic/waste disposal is also done:

Outside the temple is the original kalyANi, covered with an iron grille that I manage to push my lens through:

The designs on the stone steps are elegant, as one steps on them:

On the steps to the kalyANi are renderings of snakes, tortoises and fish, that have been covered by brass:

There are quite a number of tortoises in the water; here's one on the steps, quite a large specimen!

Here are some of them, playing waterball with a morsel of food that a devotee had thrown in:

<lj-embed id="463"/>

Here is a brass fish:

and its real-life counterpart:

So, when I saw this:

I wondered whether there might not be actual water-snakes in the tank, too!

It wasn't just these creatures enjoying the temple; here, a young couple get a moment of togetherness:

And here are two Homo sapiens photographensis, comparing their shots at the end of the clicking!

But the evening couldn't end without us having a group photograph (alas, two of us had already left!)

...and a trip to Adiga's, just around the corner...for masAl dosAs and filter kApi!

After this, a few of us went to Malleswaram market, and I liked this image of the market through the grilles:

</lj-cut>

Let me close with this image of the VinAyakA shrine at Malleswaram market...

A very enjoyable photowalk, that combined religion, heritage, history, people, and photography... thanks to Chandrachoodan and Ancient Light!


text:
# Lab - Continuous Deployment with Release Management in Azure DevOps

## Description

In previous labs, the application called PartsUnlimited, was committed to a Git repo in Azure DevOps, you have adopted the **Continuous Integration** practice and have created a build definition that builds the app and runs unit tests whenever code is pushed to the master branch. Now we are going to modify your existing Release Pipeline to enable continuous deployment of the application to an Azure Web App.

## Pre-requisites

## Task 1. Modify the Release Pipeline for the Parts Unlimited Website

Initially the app will be deployed to a `dev` deployment slot.
The `staging` slot will require an approval before the app is deployed into it.
Once an approver approves the `staging` slot, the app will be deployed to the `production` site.

In this step, you will modify the Release Pipeline for the PartsUnlimited Website.
You'll use the CI build output as the input artifact for the Release and then define how the release moves through `stages` with approvals
in between.

### Step 1

In Azure DevOps, edit the Release Pipeline created in a previous lab. The template has a single Stage.

> A **Stage** is simply a logical grouping of tasks - it may or may not correspond to a set of machines.
For this Release Pipeline, you will create 3 Stages: **dev**, **staging** and **production**.

The infrastructure required for all 3 stages is described in the ARM Template.
The ARM Template will be applied during deployment in the Dev Stage before deploying the website to Dev.

### Step 2

Click the name label "Stage 1", a dialog appears at the right-hand side of the screen. Change the name to "Dev".

![Rename Stage 1](media/12.png)

> You can also use a separate stage, for example called **setup infrastructure**, to execute the ARM deployment task.
> If you setup your Release Pipeline in this way, you can next create dev stage and clone this stage to staging and production
It will not be necessary to run any infrastructure tasks during Staging or Production deployments in this case.

### Step 3

Navigate to the tasks of the **Dev** stage and click on the "**+**" button in **Run on agent** to add a task for this stage.
In the "Deploy" group, click the **Add** button next to "Azure Resource Group Deployment" to add the task.

> Hint: Ensure that the Azure Resource Group Deployment task happens before the Deploy Azure App Service task. Otherwise there is no infrastructure to deploy the App Service to!

![Add Azure Resource Group Deployment](media/42.png)

### Step #4

Click on the "Azure Resource Group Deployment" task. Configure it as follows:

> `Azure Subscription`: select the Azure subscription endpoint that you created earlier
>
> `Action`: select "Create or Update Resource Group"
>
> `Resource Group`: enter `$(ResourceGroupName)` into the box, you will create a variable named this shortly.
>
> `Location`: select an Azure location
>
> `Template location`: Linked artifact
>
> `Template`: click the "..." button and browse to the FullEnvironmentSetupMerged.json file in the ARMTemplates folder.

![Select ARM template file](media/43.png)

> `Template Parameters`: click the "..." button and browse to the FullEnvironmentSetupMerged.param.json file in the ARMTemplates folder.

![Select ARM template param file](media/56.png)

> `Override Template Parameters`: Enter the following in a single line:

`-WebsiteName $(WebsiteName) -PartsUnlimitedServerName $(ServerName) -PartsUnlimitedHostingPlanName $(HostingPlan) -CdnStorageAccountName $(StorageAccountName) -CdnStorageContainerName $(ContainerName) -CdnStorageAccountNameForDev $(StorageAccountName)-dev -CdnStorageContainerNameForDev $(ContainerName)-dev -CdnStorageAccountNameForStaging $(StorageAccountName)-stage -CdnStorageContainerNameForStaging $(ContainerName)-stage -PartsUnlimitedServerAdminLoginPassword (ConvertTo-SecureString -String '$(AdminPassword)' -AsPlainText -Force) -PartsUnlimitedServerAdminLoginPasswordForTest (ConvertTo-SecureString -String '$(AdminTestPassword)' -AsPlainText -Force)`

You will shortly define the values for each parameter, like `$(ServerName)`, in the Stage variables.

> **Note**: If you open the FullEnvironmentSetupMerged.param.json file, you will see empty placeholders for these parameters. You could hard code values in the file instead of specifying them as "overrides". Either way is valid. If you do specify  values in the params file, remember that in order to change values, you would have to edit the file, commit and create a new build in order for the Release to have access the new values.

### Step #5

Click on the "Variables" tab to enter the Stage variables. Variables can either apply to the entire Release Pipeline (set scope to **Release**) or to a specific stage (set scope to the name of the stage).

![Click Variables](media/44.png)

### Step #6

Create the following variables, adding values too. Set the Scope of all variables to **Dev**.

- **WebsiteName** - Name of the website in Azure
- **ServerName** - Prefix for the name of the database servers. Will have `-dev` or `-stage` added for dev/staging
- **HostingPlan** - Name of the hosting plan for the website
- **StorageAccountName** - Storage account name prefix. Will have `-dev` or `-stage` added for dev/staging
- **ContainerName** - Container name prefix. Will have `-dev` or `-stage` added for dev/staging
- **AdminPassword** - Admin password for production database server (don't forget to encrypt this one!)
- **AdminTestPassword** - Admin password for dev and staging database servers (don't forget to encrypt this one!)
- **ResourceGroupName** - Name of the Resource Group.

![Edit variables](media/50.png)

> **Note**: Use unique values for your variables by adding something custom at the end like your initials. Example for WebsiteName : pudncorejstr. Remember the name will be used for a global DNS entry, which should be globally unique.
>
> **Note**: You can hide passwords and other sensitive fields by clicking the padlock icon to the right of the value text box.

### Step #7

Save the definition.
Now that the infrastructure deployment is configured, we can modify the initial task.

### Step #8

Click on the Dev stage in the Release Pipeline and select the Dev stage Deployment process. The App Service Name is linked to the "AzureRM Web App Deployment" Task.

![Change App service name](media/63.png)

Enter `$(WebsiteName)` to use a variable. You defined this variable earlier when deploying
the ARM Template. You will shortly "promote" it to a Release variable so that it can be used in all Stages in the Release.

### Step #9

Now select the "Deploy Azure App Service" Task and check **Deploy to slot or App Service Environment**.
Enter `$(ResourceGroupName)` into the Resource Group Box. Enter "dev" for the Slot. This will deploy the site to the "dev" deployment slot. This allows you to deploy the site to an Azure deployment slot without affecting the Production site.

### Step #10

Click the ellipsis (...) button, next to the "Package" box, to set the Web Deploy Package location. Browse to the PartsUnlimited.Website.zip file and click OK.

![Select drop zip](media/10.png)

> **Note**: It is a good practice to run smoke tests to validate the website after deployment, or to run load tests. The code-base you are using does not have any such tests defined. For more information on smoke tests options or load test options, please see: [https://docs.microsoft.com/en-us/azure/devops/test/load-test/overview?view=azure-devops#alternatives](https://docs.microsoft.com/en-us/azure/devops/test/load-test/overview?view=azure-devops#alternatives). A simple solution to run a Web Smoke test is this extension which you can install to your Azure DevOps organization: [https://marketplace.visualstudio.com/items?itemName=OneLuckiDev.release-web-smoke-test-task](https://marketplace.visualstudio.com/items?itemName=OneLuckiDev.release-web-smoke-test-task).

### Step #11

Promote the WebSite Stage variables to a Release Variables

Click on the "Variables" tab.
Variables can be defined on Release level and stage level.
Set the `WebsiteName` and `ResourceGroupName` variables scope to Release. This will make them available for all stages.

![Promote variables](media/53.png)

Click Save to save the Release Pipeline.

### Step #12

## Test the Dev stage with ARM Template Deployment

You will shortly clone the Dev Stage into both Staging and Prod stages.
However, before you do that it's a good idea to test that the Dev Stage is correctly configured by creating a new Release.

Before moving on, it is a good idea to test the template so far.

### Step #13

Click on "Create Release" to start a new release.

![Create release](media/45.png)

### Step #14

Verify if the latest build is selected from the artifacts drop-down. Click "Create" to start the release.

![Create release](media/46.png)

### Step #15

Click the "Release-x" (where x is the number of your current Release) link to open the release.

![Open running release](media/21.png)

### Step #16

It will show the overview of the pipeline and activity in the pipeline. Click the **in progress** link of the Dev stage.

![Running deployment](<media/RunningDeployment.png>)

### Step #17

You should see a successful release after a few minutes.

![Monitor release](<media/DeploymentLogs.png>)

### Step #18

If you log into the Azure Portal, you will see the Resource Group has been created.
You can check that the site was in fact deployed successfully by navigating to the site url.

> Since you deployed to the dev slot, you will need to navigate to `http://{siteName}-dev.azurewebsites.net` where siteName is the name of your Web App in Azure.

![Review resource group](media/52.png)

![View the site](media/27.png)

By default you will only receive email notifications on failed release. This can be changed in settings for each stage. Click the **pre-deployment conditions** on the Dev Stage card.

![Pre-deployment conditions](<media/PreDeploymentConditions.png>)

Switch on **Pre-deployment approvals** and add one or more approvers. Approvers will be notified through email when a new release is pending for them.

## Clone the Dev stage to Staging and Production

Now that you have verified that the Dev Stage is configured correctly, you can clone it to Staging and Production.

### Step #19

From the release that deployed your application, click on the PartsUnlimited link and then the Edit link to open the Release Pipeline.

![Edit Release Pipeline](<media/EditReleaseDefinitionFromRelease.png>)

> **Note:** It is possible to change the settings/parameters for a Release without changing the actual Release Pipeline (i.e. the Release is an instance of the Release Pipeline that you can edit). You want to make sure that you are editing the Release Pipeline, not a Release.

### Step #20

Hover the mouse cursor over the Dev Stage card and select "Clone" in the below right corner.

![](media/28.png)

Click on the new stage and give it the name "Staging"

![](media/58.png)

### Step #21

In the Dev Stage, you did not define any approvers. Click the **Pre-deployment conditions** to edit the approvers.

![](media/59.png)

### Step #22

For Staging you should configure approvers. In "Pre-deployment approvals" section choose people who will approve deployments to the staging stage.

![](media/13.png)

### Step #23

Delete the "Azure Deployment" task from the "Staging" stage. This is not required in this Stage since the ARM template deployed the infrastructure for all 3 stages in the "Dev" stage.

### Step #24

Click the Variables tab of the Release Pipeline (it should have an exclamation mark in red).

### Step #25

Delete all the variables with the scope "Staging". These are used by the "Azure Resource Group Deployment" task which you just deleted, so they are not necessary in this Stage.

### Step #26

On the Azure App Service Deploy task, set the Slot to `staging`.

![Change slot to staging](<media/ChangeSlotToStaging.png>)

> **Note**: If you had stage-specific variables, you would be able to set Staging-specific values. It is not necessary in this case.

### Step #27

When we cloned dev to staging we set one person for staging's pre-approvals. We can adjust it even further by clicking the **pre-deployment approvals** button (left side of the stage block) or the **post-deployment approvals** button (right side of the stage block). For this HOL, you can be both pre and post approver.

![](media/59.png)

### Step #28

In this case, you want to pause the deployment coming in. This ensures that if someone is testing in the Staging stage,
they don't suddenly get a new build unexpectedly.

### Step #29

Clone the Staging stage to Production.
- Untick "Deploy to Slot" (i.e. the site will be deployed to the production slot).
- Update the approvers - again, you can be both approvers.

### Step #30

Save the Release Pipeline.

**Configure Continuous Deployment for this Release Pipeline**

### Step #31

Click on the Triggers link  of the build artifact of the Release Pipeline.

![](media/60.png)

### Step #32

Set trigger to enabled (it can be that it is enabled by default, then no action is required).

![](media/61.png)

> Selecting the build as the trigger means that any time the artifact build
completes, a new release will automatically start using the latest build.

### Step #33

Set "Stage triggers" to the following settings:
- Deployment to "Dev" stage should be triggered after release is created.
- Deployment to "Staging" can be triggered on successful deployment to "Dev".
- Deployment to "Production" can be triggered on successful deployment to "Staging".

![](media/35.png)

> **Note:** Since the incoming build for this release is a CI build, you probably don't want to deploy the build all the way to Production. Setting the Release to stop at Dev means that you will need to create a new Release with Production as the target stage if you want to deploy to Production. This is of course configurable according to your own preference.

## Task 2. Trigger a Release.

Now that you have configured the Release Pipeline, you are ready to trigger a complete release.

With an Azure Service Endpoint to deploy to, and a package to deploy (from your CI build), we need to modify the Release Pipeline.
The Release Pipeline defines how your application moves through the various Stages, including Tasks to update infrastructure, deploy your application, run scripts and run tests.
You can also configure incoming or outgoing approvals for each Stage.

### Step #1

Click on "Create Release" to create a new Release.

### Step #2

Select the latest build, click Create.

> **Note**: You can adjust whether to deploy this release to a particular stage or change automatic deployment of a stage to manual if you wish to do so.

### Step #3

Once the Dev stage has completed deployment, you will see a notification that
an approval is pending (you will also have received an email notification if you ticked "Send an email notification to the approver whom the approval is pending on" option in settings for this stage).
Check the dev slot of the PartsUnlimited site in Azure to ensure that the Dev
stage is good, and then click Approve.

![](media/37.png)

### Step #4

You can also see pending approvals in the overview pane:

![](media/32.png)

### Step #5

Optionally enter a comment and click the Approve button.

### Step #6

This will trigger the release into the Staging stage.
> **Note**: You can reassign the approval if required.

### Step #7

Once the Staging deployment has completed, you will need to approve that staging is OK.

### Step #8

This will then trigger the pre-approval for Production.
Once you've approved that, deployment into the Production stage will begin.

## Congratulations!

You've completed this lab!

>**Note:** Deployment of schemas and data is beyond the scope of this lab.
>It is recommended that you investigate  SQL Server Data Tools (SSDT) for managing database schema deployments.

## Further Reading

[Release Management in Azure DevOps](https://docs.microsoft.com/en-us/azure/devops/pipelines/get-started/what-is-azure-pipelines?view=azure-devops)

## Next Step
[Back to Labs overview](../../Readme.md).

repository: Delta-N/PracticalDevOps

gha_language: C#

repo_name: Delta-N/PracticalDevOps


text:
# Data structure: Array (dynamic)

A dynamic array is a **random access** and **variable size** data structure.
The program allocate a specified size for the array, and allow the user to
keep on adding elements. If an element would outbound the array's size, the
structure expand itself by a **growth factor**.

```text
Schematic representation:

           get <─────┐  ┌───── set
                     |  V
        ┌─────┬─────┬─────┬─────┬─────┬....┬....┐
        | ... | ... | ... | ... | ... |    |    |
        └─────┴─────┴─────┴─────┴─────┴....┴....┘
        <----------------------------->
                    capacity
        <-------------------------------------->
                    actual size
```

## Complexity

| Operation | Complexity |
|:---------:|:----------:|
|   Access  |    O(1)    |
|   Search  |    O(n)    |
| Insertion |    search time + O(1)    |
| Appending |    O(1) is the last element is known; O(n) otherwise |
| Deletion  |    search time + O(1)     |


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

### Description

An issue was discovered in DOYO (aka doyocms) 2.3(20140425 update). There is a CSRF vulnerability that can add a super administrator account via admin.php?c=a_adminuser&a=add&run=1.

### POC

#### Reference
- https://github.com/millken/doyocms/issues/1

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

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
+++
Description = "Neutron RFE Process"
author = "mestery"
categories = ["OpenStack", "Neutron", "Process"]
date = "2015-06-01T11:02:20-05:00"
socialsharing = true
tags = ["OpenStack", "Neutron", "Process"]
title = "Neutron RFE Process"
url = ""

+++

**[Updated 6-2-2015 with the full process for filing RFEs in Neutron.]**

Starting with the development of the Juno release, the Neutron project moved to
using a [specs repository][1] similar to how other projects were using them. In
our quest to enforce a [waterfall design model][2], we also added an
appropriate [spec template][3] which was filled with things such as "Problem
Description", "REST API Impact", "IPv6 Impact", "Community Impact", and
everyone's favorite sections on "Testing" and "Documentation." We deployed this
with the best of intentions and the greatest of hopes. And we used this process
for both Juno and the Kilo cycle.

How did the process work? At best, it lengthened the pipeline we had in place
to gate the incoming feature fire-hose. At worst, it turned off potential
committers. In the interest of [stepping out of the way][4], it was time to
change the process and refocus on what we really wanted to solve.

Who Are the Users Of Neutron?
-----------------------------

Asking this question was at the heart of what reforming the process. The old
process was not easy for non-developers to contribute to. It required you to
clone a gerrit repository and take the time to actually fill in a lengthy
document, including detailed design decisions. This wasn't going to work for
someone who was not inclined to code. In reality, we had very little feedback
from operators and users on our specs process. I blame the template.

In reality, we would love to get feedback from users. These are the people who
we are designing the software for. The new process had to take this into account
from the start.

The Request For Enhancement (RFE) Process
-----------------------------------------

Over the past month, the Neutron team has been iterating on the new process.
I'm happy to announce we've merged the patches for this and we are now going to
give it a new try. And what is this new process? A quick summary is as follows:

* A [slimmed down spec template][5] which focuses on the "what" instead of the
  "how."
* A process which emphasizes filing [RFE bugs][6] instead of detailed design
  documents.
* The removal of deadlines. No more deadlines for filing RFEs or specs.

The RFE process is meant to allow users to express their desires for new
features using Launchpad. A quick review of these RFE bugs can be done and they
can turn into features should the need arise. The process is streamlined as
well with no additional deadlines. Overall, a win-win for all interested
parties.

The entire new process, as documented in the [Neutron blueprint][7] process
file, is as follows.

>> 1. The bug is submitted and will by default land in the "New" state.
>> 2. As soon as a member of the neutron-drivers team acknowledges the bug, it
>>    will be moved into the "Confirmed" state. No priority, assignee, or
>>    milestone is set at this time.
>> 3. The bug goes into the "Triaged" state once a discussion around the RFE
>>    has taken place.
>> 4. The neutron-drivers team will evaluate the RFE and may advise the
>>    submitter to file a spec in neutron-specs to elaborate on the feature
>>    request.
>> 5. The PTL will work with the Lieutenant for the area being identified by
>>    the RFE to evaluate resources against the current workload.
>> 6. In either case (a spec being required or not), once discussion has
>>    happened the bug will get an assignee, priority and milestone.
>> 7. Once a patchset targeting the bug is submitted the bug will move into the
>>    "In Progress" state.
>> 8. When all patches targeting the bug are merged or abandoned, the bug will
>>    be moved to the "Completed" state.

The Future
----------

As with most things in OpenStack, the only constant is change. We'll try this
out for the Liberty release and we'll make adjustments during the Mxx release
design summit. But with a focus on allowing users to express their interest in
features, the process is already a vast improvement over the prior way to
submit code into Neutron.

[1]: http://git.openstack.org/cgit/openstack/neutron-specs/
[2]: https://en.wikipedia.org/wiki/Waterfall_model
[3]: https://github.com/openstack/neutron-specs/blob/8630afb8f0aa9be6f3ccbf3be761e054412d3c6a/specs/template.rst
[4]: http://ttx.re/stepping-out-of-the-way.html
[5]: https://github.com/openstack/neutron-specs/blob/master/specs/template.rst
[6]: https://bugs.launchpad.net/neutron/+bugs?field.tag=rfe
[7]: https://github.com/openstack/neutron/blob/master/doc/source/policies/blueprints.rst

repository: mestery/siliconloons

gha_language: JavaScript

repo_name: mestery/siliconloons


text:
<!-- NEWS.md is maintained by https://cynkra.github.io/fledge, do not edit -->

# emdash 1.6.0

- Update the test database to also include inferred labels. (thanks @shankari!)
- Update tests that had values depended on the previous test database.
- The `mod_mapview` server module now drops all list columns in its `data_sf` argument. This change is required to remove `inferred_label` (see asiripanich#69) from the map data which is a spatial feature object.
- Unify the default `datatable_options` in one place.
- `run_app()` now checks if `getOption("emdash.config_file")` returns anything, otherwise it uses the default config file, `inst/config-default.yml`, for the `config_file` argument.
- Data from specific users can be removed from the dashboard by specifying their ids or emails in a txt file. Use `remove_from_participants_col` and `remove_from_participants_file` file in the emdash configuration file.
- The dashboard no longer shows the bike checkin table (which is specific to the CanBikeCO study) and the polar bear table by default.
- Editable table feature: switched to object ID to identify which Checkinout entry to delete. It used to use user_id, but that did not delete database entries because it was not converted to BSON before querying.
- Use GitHub Actions to build emdash Docker image and push to Docker Hub

# emdash 1.5.0

- Add a test MongoDB database to the R CMD check that runs GitHub Actions.
- Fix the mismatch between the colors on the map and the legend. Unfortunately, this is a quick fix only, by going back to using the mapview's default palatte, which seems to be the only option that works. (#56)
- Refactor `run_app()`.
- Fix `summarise_trips_without_trips()`, the function was using the min and max dates for all trips, rather than the min and max for each user. (#54)
- Better document the options in the YAML config file.
- The color label of the map is now configurable from the config file by changing the `map_trajectory_colors_variable` field. By default this field is set to 'user_id'. To color label by travel mode change to `mode_confirm`.
- Fixes bad column names that can crash the dashboard on the first reload of the trip data. (#57)
- Add a boolean option for displaying `user_email` on the trip table. See `trips_table_merge_user_email` in the config file. (#57)

# emdash 1.4.1

- The plot is now synced all the tables. (#55)
- Correct a variable name. In config, `col_labels_for_participts` get renamed to `cols_to_remove_from_participts_table`.

# emdash 1.4.0

- Trip loading and location loading now depend on the number of (MongoDB) documents in the date range and the specified max documents per trip found in config-default.yml. See #49 for an explanation of this feature.
- Make supplement tables editable. This option can be configured using the configuration file of your dashboard.

# emdash 1.3.0

- Trips can be filtered using the date range selector from the sidebar. This only affects the "Trip Trend" plot in the Dashboard panel and the trips displayed on the Maps panel. By default, only trips from the last 30 days since the last recorded trips are selected. Also, the max number of days the user can select must not be more than the `max_windows_for_mod_load_trips` option in your config file.
- Fix minor issue with filtering trip table entries using the config.yml.

# emdash 1.2.6

- The map no longer shows detailed trajectories of the participants by default. See issues #29 and #40 related to this in problem.
- Add some addition fields to ignore

# emdash 1.2.5

- Added minor cosmetic changes to the dashboard (#24)
- YAML file made to configure options for the dashboard.
- Moved anon_locations and cols_to_remove_from_ (trips and map_popup) to the YAML
- Added `save_config_file()` for saving the default app config file.
- Added version number to the dashboard UI

# emdash 1.2.4

- Display user labels generically in the dashboard (#23, @shankari).

# emdash 1.2.3

- Updated the author list.

# emdash 1.2.2

- Added support for displaying the server communication status on the participant table.

# emdash 1.2.1

-  Hid the "source" column from the trip table and the map.

# emdash 1.2.0

- Fixed [#15](https://github.com/asiripanich/emdash/issues/15).
- Fixed the issue with trips didn't show when loading the map without adjusting any of the filter options.

# emdash 1.1.0

## Major changes

- The map now displays trips' trajectories, `generate_trajectories()` is used to generate them. Warning: this is curently performed at loading - future versions could wait to do this until "show trajectories" is selected on the map view and after desired trip filters are applied
- New data columns for local timestamps, duration in min, distances in mi and km. Some of these and others are later hidden from view in tables/map filter/map popup.
- Add a column visibility button to the tables.

# emdash 1.0.0

## Major changes

- the dashboard now works with the standard e-mission database. To continue to use the dashboard for `rciti` branches please checkout the d41daeca03e42d053ecadf5fe4b84a861ce36aeb commit on master.

## Features

- `run_app()` gains an `anon_locations` argument which allows the user ids of sensed trips to be anonymously displayed on the map.

# emdash <IP_ADDRESS>00

* Added a `NEWS.md` file to track changes to the package.

repository: asiripanich/emdash

gha_language: R

gha_license_id: NOASSERTION

repo_name: asiripanich/emdash


text:
# Purdue CAM2: Image Team Training, Summary

This folder contains training information for new members joining the CAM2 Image Team. The goal is to focus on generic topics for general machine learning. Then we will dive in to topcis aimed at our current research.

## Week 1:

This attempts to cover fundamental topics which are generic to all machine learning disciplines.

The concept goals are:

- Linear Regression
- Install Torch7
- Install Caffe

The programming goals are:

- (Optional) Linear Regression in Torch7 & Caffe

## Week 2:

This week will cover logistic regression, model selection, and optimization. We will also learn to "grab" data using the "archiver.py" file.

The concept goals are:

- Logisitic Regression
- Model Selection
- Stochastic Gradient Descent (online v.s. batch learning)

The programming goals are:

- Logisitc Regression in Torch7 & Caffe
- Upload 500 Images of new CAM2 data

## Week 3:

This week will cover neural networks and convolutional neural networks. We will also learn to label the data you gathered.

The concept goals are:

- Neural Networks
- Convolution
- Labeling Standard

The programming goals are:

- Neural Network in Torch7 & Caffe
- Upload (at least) 30 Labeled Images

## Week 4:

This week we will go implement a deep learning model on your computer, preferrably in Caffe. If you want to implement Faster-RCNN in MATLAB, I can only try to help you.

- Faster-RCNN (FRCNN) \[[pdf](https://arxiv.org/abs/1506.01497)\]\[[github](https://github.com/rbgirshick/py-faster-rcnn)\]
- Single Shot Detector (SSD) \[[pdf](https://arxiv.org/abs/1512.02325)\]\[[github](https://github.com/weiliu89/caffe/tree/ssd)\]


text:
# OpenapiJsClient.NetCordaCoreContractsTimeWindow

## Properties

Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**fromTime** | **String** | JSR310 encoded time representation of Instant | [optional]
**untilTime** | **String** | JSR310 encoded time representation of Instant | [optional]
**midpoint** | **String** | JSR310 encoded time representation of Instant | [optional]

repository: corda/samples

repo_name: corda/samples


text:
---
layout: chapter
title: "Tools"
subtitle: "Free and Open Source Software for Geospatial (<i>FOSS4G</i>)"
section: tools
---

We use FOSS4G software such as GDAL, QGIS, and several command line tools from Mapbox, such as `tippecanoe`.


text:
# Express on Serverless

Now you can run Node.js express on AWS Lambda, using Serverless framework!

## What's this?

I want to run express on AWS Lambda and deploy it using Serverless.
This can be run with express, koa or other Node.js servers as far as it is [requestListener](https://nodejs.org/api/http.html#http_http_createserver_requestlistener)

## Features

- [x] express
- [x] GET/POST request
- [x] POST json with body-parser
- [x] POST urlencoded with body-parser
- [x] POST binary file with multer
(need to enable API Gateway [binary support](https://aws.amazon.com/jp/blogs/compute/binary-support-for-api-integrations-with-amazon-api-gateway/))

## Setup

Install npm modules and generate template.

```bash
npm install -g serverless
npm install -S express express-on-serverless
serverless create --template aws-nodejs
```

Modify handler.js and serverless.yml

```javascript
// handler.js
const express = require('express')
const app = express()

app.get('/test', (req, res) => {
  res.send("I'm fine!")
})

exports.index = require('express-on-serverless')(app)

// Used when run locally
if(!module.parent){
    let port = process.env.PORT || 3000;
    app.listen(port)
    console.log("Listening on port %s",port);
}
```

```yaml
# serverless.yml
service: aws-nodejs

provider:
  name: aws
  runtime: nodejs4.3

functions:
  index:
    handler: handler.index
    events:
      - http:
          path: /
          method: any
      - http: any {proxy+}
```

## Local Testing

Assuming you used the example above, the Express app will start and listen on port 3000 (`process.env.PORT`) if the server is started directly instead of loaded as a module by Lambda. To start the server locally, you can use the default `start` command built in to either `npm` or `yarn`:

    npm start

    # Same behavior, if you prefer yarn
    yarn start

## Deploying to Amazon Web Service

First, [configure your AWS credentials](https://serverless.com/framework/docs/providers/aws/guide/credentials/#using-aws-access-keys) if you haven't already.

The same command is used for both the initial deploy as well as updates.

```
serverless deploy
```

Now you can access `https://API_GATEWAY_HOST/dev/test` !

See `serverless deploy --help` for a summary of available options and the [official serverless docs for deploy](https://serverless.com/framework/docs/providers/aws/guide/deploying/ for the full docs on serverless deployment).

## Checking on what happened in AWS

`serverless` creates new changes in CloudFormation, API Gateway, and Lambda. Check out the AWS Console for each service to review the impact of your changes.

 * [CloudFormation](https://console.aws.amazon.com/cloudformation/home#/stacks?filter=active)
 * [API Gateway](http://console.aws.amazon.com/apigateway/home)
 * [Lambda](https://console.aws.amazon.com/lambda/home?#/functions?display=list)

## Conclusion

It's too easy!!

repository: toduq/express-on-serverless

repo_name: toduq/express-on-serverless


text:
# rafega
Flow process architechture package in Go.

Based on the _classical_ FBP as described in J. Paul Morrison book: *[Flow-Based Programming, 2nd Edition](http://www.jpaulmorrison.com/fbp/book.html)* (of great inspiration) and other existing systems like [Apache Storm](https://storm.apache.org).

repository: jllopis/rafega

repo_name: jllopis/rafega


text:
# Divorce Respondent Frontend [![License: MIT](https://img.shields.io/github/license/hmcts/div-respondent-frontend)](https://opensource.org/licenses/MIT) [![Build Status](https://img.shields.io/github/checks-status/hmcts/div-respondent-frontend/master)](https://github.com/hmcts/div-respondent-frontend)

This repo is the Frontend App for the 'Acknowledgement of Service' stage of the Divorce process and allows the Respondent to respond to the initial Divorce application.

## Setup

**Config**

For development only config, rename the `config/dev_template.yaml` file to `config/development.yaml`. Running the app with the node environment set to `dev` will ensure this file is used.
This file is not version controlled so any config here will not be pushed to git.

Note that the application will not work if an invalid LanuchDarkly SDK Key in provided. So either get a valid key from azure divorce key store,
or disable it altogether by setting `featureToggles` `enabled` to `false` in `config/default.yml` (be careful not to commit this).

**Install dependencies:**

```sh
yarn install
```

**Start application:**

Run the following to start the redis server:

```sh
docker-compose up
```

Then run the following in separate terminals

```sh
yarn mocks
```

```sh
yarn dev
```

The application will now be running on ```https://localhost:3000```.

**NOTE**: might not work in Chrome.

## Testing

**Unit**

```sh
yarn test:unit
```

**Validation**

```sh
yarn test:validation
```

**Mocks**

Run the following, each in a separate terminal window
```sh
yarn dev
yarn mocks
yarn test:mocks
```

**Running tests locally against a PR/AAT**

* Connect to the VPN

* Make a copy of `config/example-local-aat.yml` as `config/local-aat.yml` (which is ignored by git)

* Substitute any secret values in ***local-aat.yml*** from SCM - Do not add/commit secrets to the example file!

* If you want to point to a PR, modify `tests.e2e.url` accordingly.

* Run ```NODE_ENV=aat yarn test:functional```. This would enable your tests to pick up the new `local-aat.yml`.

+### Running additional tests in the Jenkins PR Pipeline

1. Add one or more appropriate labels to your PR in GitHub. Valid labels are:

- ```enable_full_functional_test```
- ```enable_fortify_scan```

2. Trigger a build of your PR in Jenkins.  Fortify scans will take place asynchronously as part of the Static Checks/Container Build step.
- Check the Blue Ocean view for live monitoring, and review the logs once complete for any issues.
- As Fortify scans execute during the Static Checks/Container Build step, you will need to ensure this is triggered by making a minor change to the PR, such as bumping the chart version.

## Local Development
RFE has facility to enable you develop and test out features locally without the limitations of either login via IDAM,
VPN connection or having to progress the case via other apps like DN or PFE.

### Mocking 🤡
You can, while developing locally, mock out the case data and have the app render the expected screens
and go through the required steps.

To use this mocking facility, have a look at the `/mocks` folder in the root location.

* Have your mock session data prepared ready, this is the case data your screens and session data expects to have for the
  behaviour you are developing
* Add an entry in the `IdamLogin.template.html` file
* Define the content in the `IdamLogin.content.json` file
* Add an entry in the `IdamLogin.step.js` file
* Define your mock response in the any one of the following folders, most popular is the COS one, (you can add others as suite your needs)
  * `/case-maintenance`
  * `/case-orchestration`
  * `/evidence-management`
  * `/fees-and-payments`
Basically you are simulating requests to an external service

You can also test out flow of your mocked screens by writing mock tests, these tests
can be placed in the `/test/mocks` folder.

Note that these are **strictly local mock tests** and **do not run on the CI build**.
You'd have to run them locally by running the script

```cmd
yarn test:mocks
```
Make sure to run the command if you make a change in any of these files to get feedback

### Uses
* When you want to locally test the feature(s) you are developing
* Helps with IDAM limitations or VPN, you can test and hash out features locally and have quick feedback it all holds together
* Some features require the case to have done through many stages, PFE, DN, CCD then back to RFE, which these mocking, you can prepare your session data in expected state and carry on development
* Can serve as a template, source code or examples of flows tha should work when writing proper functional tests which runs in the CI environment

All tests of this nature are tag as `@mock`

⚠ Locally mock tests are just one other tool in your tool box. You must make sure unit tests are written for all
functions, modules and pages you add as you develop. These also run on the CI environment, you can also run unit test as described in the `Testing` section above

### Functional Test 🧗🏽♀
To write your functional or e2e test, place your `Features` and `Scenarios` in the `e2e` folder in `/test/e2e`
All tests of these nature are tagged with `@functional` for clarity and they are part of the CI build pipeline.
They **will run** when you check in.

Please read above in the `Running tests locally against a PR/AAT` section on how to set this up
if you want to run from your local machine but point to AAT or your PR. You will need VPN access for this to work.

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

repository: hmcts/div-respondent-frontend

repo_name: hmcts/div-respondent-frontend


text:
## Setup

Ensure [yarn](https://yarnpkg.com/) is installed on your local machine.

Then execute:

**`yarn install`**

To install all app dependencies.

## Run Development Build

Execute:

**`yarn start`**

Runs the app in the development mode.

Open [http://localhost:3000](http://localhost:3000) to view it in the browser.

The page will reload if you make edits.

You will also see any lint errors in the console.

## Formatting and Linting

Excute:

**`yarn format`**

Auto-formats the codebase.

**`yarn lint`**

Performs lint check.

## Other Available Scripts

In the project directory, you can run:

**`yarn generate-component --name=<component name>`**

Auto generates the template code for a component.

E.g. `yarn generate-component --name=RoundButton` generates the template code for the `RoundButton` component.

**`yarn generate-data`**

Auto generates event data using [faker.js](https://www.npmjs.com/package/faker).

**`yarn build`**

Builds the app for production to the `build` folder.

It correctly bundles React in production mode and optimizes the build for the best performance.

The build is minified and the filenames include the hashes.

Your app is ready to be deployed!

repository: JermyTan/eventology

repo_name: JermyTan/eventology


text:
---
layout: post
title:  "Sinatra Refrigerator Inventory app"
date:   2017-08-14 17:19:16 +0000
---

The refrigerator ("Fridge") inventory app provides a database and web interface for users to:
* Create an account which manages user's Fridges and Items contained within.
    * Each user can **ONLY** modify content of his/her own fridge (and its contents within).  The **EXCEPTION** is with shared accounts.  A fridge rarely belongs to just one person, so multiple people can "co-own" a fridge with this app's built-in account ```linking``` feature.
    * A user can create, read, update, and delete (CRUD) any items in a fridge to which he or she is an owner or co-owner of said fridge.
    * A user is also able to perform CRUD operators on any fridges themselves to which he/she owns/co-owns.
    * A user, in addition to sharing fridges with other users, can also view the accounts to which he/she is currently sharing and use an ```unlinking``` feature to unlink any user that is currently linked.
    * A user is also able to update his/her own information, as well as update current password, and delete his/her account.
    * User inputs are validated for users, fridges, and items creation.

This app was built with Sinatra, extended with [Rake tasks](https://github.com/ruby/rake) for working with an SQL database using [ActiveRecord ORM](https://github.com/rails/rails/tree/master/activerecord).

## Usage

After checking out the repo, run ```bundle install``` to install Ruby gem dependencies.

You can start one of Rack's supported servers using the [shotgun](https://github.com/rtomayko/shotgun) command ```shotgun``` and navigate to `localhost:9393` in your browser.

## Models
The Fridge Inventory app database includes four model classes: ```User, UserFridge, Fridge, and Item```

1. User:
```
  has_many :user_fridges
  has_many :fridges, through: :user_fridges
  has_many :items, through: :fridges
```
    Has attributes:
    * First Name
    * Last
    * Username
    * Email
    * Password (Secured with [Bcrypt](https://github.com/codahale/bcrypt-ruby) hashing algorithm)

2. UserFridge (join table):
```
  belongs_to :user
  belongs_to :fridge
```
    Has attributes:
    * user_id
    * fridge_id

3. Fridge
```
    has_many :items
    has_many :user_fridges
    has_many :users, through: :user_fridges
```
    Has attributes:
    * name
4. Item
```
    has_many :items
    has_many :user_fridges
    has_many :users, through: :user_fridges
```
    Has attributes:
    * name
    * quantity
    * category
    * note
    * Sell by date
    * Expiration date
    * amount (grams)
    * fridge_id

extension: markdown


text:
## `pydgraph` - Python Dependencies Graph
A directed graph for all python dependencies present in local system

### Motivation

Its very interesting problem to solve and find out how various python packages are dependent on each other and does it make sense to bundle some of the very common packages used along with base python distribution. It is interesting to understand the dependency strucutre but also to understand the community structure of these modules and what kind of network they form. Any other phenomenon exist when we analyze this graph. This analysis can be used to optimize the imports, remove cyclic dependencies between modules. Similar approach can be extended to other programming languages like `java`, `ruby`, `perl` etc.

### Pre-requisites
You can install pre-requisite python modules to run this application by installing modules listed in `requirements.txt`

```bash
# activate your virtualenv, if you have one.
pip install -r requirements.txt
```

### Running the project
```bash
./run.sh
```
#### Raw output graph
![Alt text](./pydgraph/raw.png?raw=true "Generated graph")

### List of files

```
├── LICENSE
├── README.md
├── requirements.txt               <---- pre-requisites
├── pydgraph
│   ├── README.md
│   ├── __init__.py
│   ├── app
│   │   ├── __init__.py
│   │   ├── main.py
│   ├── crawler                    <---- crawler module
│   │   ├── __init__.py
│   │   ├── crawler.py
│   │   ├── graph.py
│   │   └── parser.py              <---- recursively parses the dependency tree to generate the graph(gml)
│   ├── package_installer          <---- installs anaconda packages, not needed to run this project
│   │   ├── anaconda_package_list_macos.csv
│   │   └── install_packages.py
│   ├── resources                   <----- generated dependecy tree
│   │   ├── data.txt
│   │   ├── pydgraph.gml            <----- generated graph from dependency tree
│   │   └── requirements.txt
│   └── run.sh                      <---- main executable
├── pydgraph_analysis
│   ├── G-Betweenness-Modularity.png
│   ├── GNew-InDegree.png
│   ├── GNew-OutDegree.png
│   └── graph_analysis.ipynb        <---- python notebook for analysis
└── report                          <---- project proposal and report folder
    ├── ACM-Reference-Format.bst
    ├── Makefile
    ├── README.md
    ├── compile.py
    ├── introduction.tex
    ├── main.bib
    ├── main.pdf                    <---- generated project report
    ├── main.tex                    <---- project report latex file
    ├── references.bib              <---- project report reference file
    ├── relatedwork.tex
    ├── requirements.tex
    └── technicalsolution.tex
```

#### Crawler
Pydgraph uses `pipdeptree` to generate dependency tree from current virtual environment.
The generated dependency graph is stored in `pydgraph/resources` folder. If you delete
 this folder or contents of this folder, crawler module will regenerate the dependency tree from the python modules installed in current virtual environment. Along with the dependency tree the `parser` generates the `pydgraph.gml` which contains the actual directed graph built from the dependency tree built from previous step. Further, this `pydgraph.gml` can be used to analyze the various graph models and community structure, friendship paradox etc. Current crawler has a limitation of not able to crawl all packages available on [pypi](https://pypi.org/). Further, version can be enhanced to crawl all packages available on [pypi](https://pypi.org/) without manually installing them locally.

#### Analysis
[Analysis Notebook](./pydgraph_analysis/graph_analysis.ipynb) has the details of graph analysis.

#### Project report
[Project report](./report/main.pdf) contains project proposal and final report. **Final report is yet to be completed**.

### Project location
https://github.com/avadhoot-agasti/netsci-project

## Authors

* **Abhishek Gupta**  -<EMAIL_ADDRESS>* **Avadhoot Agasti** -<EMAIL_ADDRESS>

repository: avadhoot-agasti/netsci-project

gha_language: TeX

repo_name: avadhoot-agasti/netsci-project


text:
# deej

Arduino and Go project for controlling application volumes on Windows and Linux PCs with physical sliders (like a DJ!)

**_New:_ `deej` has been re-written as a Go application! [More details](#whats-new) | [Download](https://github.com/omriharel/deej/releases)**

**_New:_ join the [deej Discord server](https://discord.gg/nf88NJu) if you need help or have any questions!**

[![Discord](https://img.shields.io/discord/702940502038937667?logo=discord)](https://discord.gg/nf88NJu)

[**Video demonstration on YouTube**](https://youtu.be/VoByJ4USMr8)

[**See some awesome versions built by people around the world!**](./community.md) | [**_New:_ Design collection on Thingiverse**](https://thingiverse.com/omriharel/collections/deej)

![The OG shoebox build](assets/build.jpg)

## Table of contents

- [What's new](#whats-new)
- [How it works](#how-it-works)
  - [Hardware](#hardware)
    - [Schematic](#schematic)
  - [Software](#software)
- [Slider mapping (configuration)](#slider-mapping-configuration)
- [Build your own!](#build-your-own)
  - [Bill of Materials](#bill-of-materials)
  - [Thingiverse collection](#thingiverse-collection)
  - [Build procedure](#build-procedure)
  - [Extra](#extra)
- [How to run](#how-to-run)
  - [Requirements](#requirements)
  - [Download and installation](#download-and-installation)
  - [Building from source](#building-from-source)
- [Community](#community)
- [Long-ish term roadmap](#long-ish-term-roadmap)
- [License](#license)

## What's new

`deej` is now written in Go, and [distributed](https://github.com/omriharel/deej/releases) as a single executable (of course you can still [build from source](#building-from-source) if that's your thing).

This means you no longer have to maintain a Python environment. You can even build one for your friends, give them a simple download link and they'll be good to go!

In addition, check out these features:

- **Fully backwards-compatible** with your existing `config.yaml` and Arduino sketch
- **Faster** and more lightweight, consuming around 10MB of memory
- Control your **microphone's input level** by assigning `mic` to a slider (experimental support)
- Runs from your system tray
- **Helpful notifications** will let you know if something isn't working
- New `system` flag lets you assign the "system sounds" volume level (Windows-only)
- Supports everything the Python version did

> **Migrating from the Python version?** Great! You only need to keep your `config.yaml` file. Download the executable from the [releases page](https://github.com/omriharel/deej/releases/latest), place it alongside the configuration file and you're done.

> **Prefer to stick with Python?** That's totally fine. It will no longer be maintained, but you can always find it in the [`legacy-python` branch](https://github.com/omriharel/deej/tree/legacy-python).

## How it works

### Hardware

- The sliders are connected to 5 (or as many as you like) analog pins on an Arduino Nano/Uno board. They're powered from the board's 5V output (see schematic)
- The board connects via a USB cable to the PC

#### Schematic

![Hardware schematic](assets/schematic.png)

### Software

- The code running on the Arduino board is a [C program](./arduino/deej-5-sliders-vanilla/deej-5-sliders-vanilla.ino) constantly writing current slider values over its serial interface
- The PC runs a lightweight Go client [`cmd/main.go`](./cmd/main.go) in the background. This client reads the serial stream and adjusts app volumes according to the given configuration file

## Slider mapping (configuration)

`deej` uses a simple YAML-formatted configuration file named [`config.yaml`](./config.yaml), placed alongside the deej executable.

The config file determines which applications are mapped to which sliders, and which COM port/baud rate to use for the connection to the Arduino board.

**This file auto-reloads when its contents are changed, so you can change application mappings on-the-fly without restarting `deej`.**

It looks like this:

```yaml
slider_mapping:
  0: master
  1: chrome.exe
  2: spotify.exe
  3:
    - pathofexile_x64.exe
    - rocketleague.exe
  4: discord.exe

# set this to true if you want the controls inverted (i.e. top is 0%, bottom is 100%)
invert_sliders: false

# settings for connecting to the arduino board
com_port: COM4
baud_rate: 9600

# limits how often deej will look for new processes
process_refresh_frequency: 5
```

- `master` is a special option to control the master volume of the system _(uses the default playback device)_
- _New:_ `mic` is a special option to control your microphone's input level _(uses the default recording device)_. **Please note: this is an experimental feature that might not suit every hardware set-up out there.**
- `system` is a special option on Windows to control the "System sounds" volume in the Windows mixer
- Process names aren't case-sensitive, meaning both `chrome.exe` and `CHROME.exe` will work
- You can create groups of process names (using a list) to either:
    - control more than one app with a single slider
    - choose whichever process in the group that's currently running (i.e. to have one slider control any game you're playing)

## Build your own!

Building `deej` is very simple. You only need a few relatively cheap parts - it's an excellent starter project (and my first Arduino project, personally). Remember that if you need any help or have a question that's not answered here, you can always [join the deej Discord server](https://discord.gg/nf88NJu).

Build `deej` for yourself, or as an awesome gift for your gaming buddies!

### Bill of Materials

- An Arduino Nano, Pro Micro or Uno board
  - I officially recommend using a Nano or a Pro Micro for their smaller form-factor, friendlier USB connectors and more analog pins. Plus they're cheaper
  - You can also use any other development board that has a Serial over USB interface
- A few slider potentiometers, up to your number of free analog pins (the cheaper ones cost around 1-2 USD each, and come with a standard 10K Ohm variable resistor. These _should_ work just fine for this project)
  - **Important:** make sure to get **linear** sliders, not logarithmic ones! Check the product description
  - You can also use circular knobs if you like
- Some wires
- Any kind of box to hold everything together. **You don't need a 3D printer for this project!** It works fantastically with just a piece of cardboard or a shoebox. That being said, if you do have one, read on...

### Thingiverse collection

With many different 3D-printed designs being added to our [community showcase](./community.md), it felt right to gather all of them in a Thingiverse collection for you to browse. If you have access to a 3D printer, feel free to use one of the designs in your build.

**[Visit our community-created design collection on Thingiverse!](https://thingiverse.com/omriharel/collections/deej)**

> You can also [submit your own](https://discord.gg/nf88NJu) design to be added to the collection. Regardless, if you do upload your design to Thingiverse, _please add a `deej` tag to it so that others can find it more easily_.

### Build procedure

- Connect everything according to the [schematic](#schematic)
- Test with a multimeter to be sure your sliders are hooked up correctly
- Flash the Arduino chip with the sketch in [`arduino\deej-5-sliders-vanilla`](./arduino/deej-5-sliders-vanilla/deej-5-sliders-vanilla.ino)
  - _Important:_ If you have more or less than 5 sliders, you must edit the sketch to match what you have
- After flashing, check the serial monitor. You should see a constant stream of values separated by a pipe (`|`) character, e.g. `0|240|1023|0|483`
  - When you move a slider, its corresponding value should move between 0 and 1023
- Congratulations, you're now ready to run the `deej` executable!

### Extra

The application now sends over the usb the following string for audio sessions per slider.
`1|0|1|1` ending with \r\n. 1 means the slider has an active session, 0 means not.
This is send in a periodic interval of the process_refresh_frequency.

## How to run

### Requirements

#### Windows

- Windows. That's it

#### Linux

- Install `libgtk-3-dev`, `libappindicator3-dev` and `libwebkit2gtk-4.0-dev` for system tray support

### Download and installation

- Head over to the [releases page](https://github.com/omriharel/deej/releases) and download the [latest version](https://github.com/omriharel/deej/releases/latest)'s executable and configuration file (`deej.exe` and `config.yaml`)
- Place them in the same directory anywhere on your machine
- (Optional, on Windows) Create a shortcut to `deej.exe` and copy it to `%APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup` to have `deej` run on boot

### Building from source

If you'd rather not download a compiled executable, or want to extend `deej` or modify it to your needs, feel free to clone the repository and build it yourself.  If you go this route, make sure to check out the [developer scripts](./scripts).

Like other Go packages, you can also use the `go get` tool: `go get -u github.com/omriharel/deej`.

If you need any help with this, please [join our Discord server](https://discord.gg/nf88NJu).

## Community

[![Discord](https://img.shields.io/discord/702940502038937667?logo=discord)](https://discord.gg/nf88NJu)

While `deej` is still a very new project, a vibrant community has already started to grow around it. Come hang out with us in the [deej Discord server](https://discord.gg/nf88NJu), or check out awesome builds made by our members in the [community showcase](./community.md).

The server is also a great place to ask questions, suggest features or report bugs (but of course, feel free to use GitHub if you prefer).

## Long-ish term roadmap

- Serial communications rework to support two-way data flows for better extensibility
- Basic GUI to replace manual configuration editing
- Feel free to open an issue if you feel like something else is missing

## License

`deej` is released under the [MIT license](./LICENSE).

repository: pcjacobse/deej

repo_name: pcjacobse/deej


text:
# Reserved usernames

[![Latest Version on Packagist](https://img.shields.io/packagist/v/divine/reserved-usernames.svg?style=flat-square)](https://packagist.org/packages/divine/reserved-usernames)
[![Quality Score](https://img.shields.io/scrutinizer/g/divine/reserved-usernames.svg?style=flat-square)](https://scrutinizer-ci.com/g/divine/reserved-usernames)
[![Total Downloads](https://img.shields.io/packagist/dt/divine/reserved-usernames.svg?style=flat-square)](https://packagist.org/packages/divine/reserved-usernames)

Common prefixes for "role-based" email addresses that represent a position, job, or group of people in the company rather than an individual. These were sourced from several places.

Forked from https://github.com/mixmaxhq/role-based-email-addresses

## Installation

You can install the package via composer:

```bash
composer require divine/reserved-usernames
```

## Usage

``` php
use Divine/ReservedUsernames;

// Initiate
$ru = new ReservedUsernames();

// Get reserved username list
$list = $ru->get();

// Check reserved username, returns true on fail
$check = $ru->check('account');

```

### Changelog

Please see [CHANGELOG](CHANGELOG.md) for more information what has changed recently.

## Contributing

Please see [CONTRIBUTING](CONTRIBUTING.md) for details.

## Credits

- [Divine](https://github.com/divine)
- [All Contributors](../../contributors)

## License

The MIT License (MIT). Please see [License File](LICENSE.md) for more information.

repository: divine/reserved-usernames

gha_language: PHP

repo_name: divine/reserved-usernames


text:
App::Sqitch::GUI version 0.020
==============================
Ștefan Suciu
2016-08-17

GUI for Sqitch - Simple SQL change management.

Please see [Sqitch](http://sqitch.org) for a detailed description of the
command line application.

Requirements
------------

- Perl v5.10.01 or newer;
- Sqitch v0.9996 or newer;
- wxPerl, Moo and other modules;

Note: Moose is not a requirement starting with v0.020.

Status
------

Draft - Limited functionality:

- Add project;
- Set a default project;
- Load a project and view it's details;

Test usage
----------

    % git clone https://github.com/stefansbv/sqitch-gui.git
    % cd sqitch-gui

    # Install prereqs
    % dzil authordeps --missing | cpanm
    % dzil listdeps --missing | cpanm

    % PERL5LIB=lib perl bin/sqitch-gui

After the application start, if there is no project configured yet, a
dialog is automaticaly opened.  Click on the `Add` button and select a
path to an existing Sqitch project.  The path should be updated in the
list.  Click on the close button.

Select a project and Press the `Load` button.

Still much work to do but some feedback, in this stage, would be
awesome...

Screenshots
-----------

The Project Panel

![The Project Panel](images/sqitch-gui-1.png)

The Plan Panel

![The Plan Panel](images/sqitch-gui-2.png)

The Change Panel

![The Change Panel](images/sqitch-gui-3.png)

Implementation notes
--------------------

Sqitch is a command line program.  The user runs `sqitch`, with the
appropriate parameters each time he wants to execute a command.  This
is very different from a graphical user interface.  A program with a
GUI once started expects and executes the commands from the user until
it is closed.

To integrate Sqitch into Sqitch::GUI there are a few problems that
have to be solved:

The `sqitch` command is executed from a project directory from
where it reads some configurations and the plan file.  To be useful
Sqitch::GUI needs to keep the list of repositories in a configuration
file located in standard places in order to be able to find, read and
update it.

Command line parameter options, technically, can be used for GUI
executable but is better to use only configurations instead.

Each command from the Sqitch interface should have a dedicated button
in the GUI, but some of the commands take options (sometimes required
ones, like `sqitch show`).

User Interaction - some commands require confirmation from the user.
This can be implemented by using custom dialogs for each command.

License And Copyright
---------------------

Copyright (C) 2012-2016 iovation Inc.

Copyright (C) 2016 Ștefan Suciu.

The license is the same as for Sqitch:

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.

repository: sqitchers/sqitch-gui

repo_name: sqitchers/sqitch-gui


text:
# MOS Installation + Drivers

> If you already installed the MOS tools, you are free to skip this part and go back to where ever you came from

We will need the MOS tool to send commands and data to our device. The installation that you require depends on your operating system.
You can follow the official steps from the Mongoose OS site if you like to: [Mongoose OS Startup Guide](https://mongoose-os.com/docs/quickstart/setup.md) or follow the steps down here.

### Windows
Download mos.exe from the official mongoose-os website or [click here](https://mongoose-os.com/downloads/mos-release/win/mos.exe) to start your download directly.

It is recommended to save the mos.exe file on your `c:\` drive under the folder `c:\mos`. This allows for easier and quicker access.
I also recommend that you add `mos.exe` to your startup path. Which can be done by following these steps:

> //TODO I need access to a windows machine for proper screenshots

### MacOS
For MacOS we recommend using brew (just like the mongoose startup guide is recommending) you can download and install brew from here: [brew - the missing package manager for macOS](https://brew.sh/)

After that you will need to add the MongooseOS 'tap' which allows you to download the mos package.

Open up a Terminal (we expect that you know how).

```sh
brew tap cesanta/mos
brew install mos
```

Make sure to test your installation by running:

```sh
mos version
```

You should see something like this:

![version](./images/mongoose_version.png)

### Ubuntu Linux

For Linux, you will only need to do some basic steps including adding the repoistory from which to donwload the mongoose os command line tool:

```sh
sudo add-apt-repository ppa:mongoose-os/mos
sudo apt-get update
sudo apt-get install mos
```

After that you can run the following command to test your setup

```sh
mos version
```

## Installing drivers for your controller

For our guide we used the DevKitC board with an ESP-Wroom-32 chip. You will need the drivers required for your board, which depends on the USB to UART Bridge chip on your board. For our board it was the `CP2102N` chip. The drivers for this chip can be found on the Silicon Labs website by [clicking here](https://www.silabs.com/products/development-tools/software/usb-to-uart-bridge-vcp-drivers).

The installation is straight-forward click next. If you finished the installation and hook up your board to the computer you test if the drivers where setup correctly by running:

### Linux/Unix (MacOS)
```sh
ls /dev/cu.SLAB*
```

This should show you something like:

![ls result for dev/cu.SLAB*](./images/dev_cu_result.png);

### Windows

For windows devices you can check if everything works by going to your hardware and devices menu ...

> //TODO Requires a Windows os for checking and making screenshots

## Installing the AWS CLI
If you are going to use the ESP32 with AWS you will need the AWS CLI to connect to the cloud.

You can install the AWS CLI from the following page [https://aws.amazon.com/cli/](https://aws.amazon.com/cli/). For Linux/Unix you will need Python which can be installed from here [https://www.python.org/](https://www.python.org/) and then you should install the AWS CLI with PIP:

```sh
pip install awscli
```

## Last words

When you finished setting up the basics, you can go back to the guided tutorials and start following the steps however there are some tips:

- Create a folder for your project files
- You can run `mos` to start the web based User Interface which might be easier if you are not familiar with the Command Line
- We used a Macbook with MacOS Mojave 10.14 to create the guides and projects. Be aware of this.

repository: becloudway/iot-in-the-cloud-workshop

repo_name: becloudway/iot-in-the-cloud-workshop


text:
---
title: Organizing with Tags
tags: [getting started, alerts, dashboards, events, videos]
sidebar: doc_sidebar
permalink: tags_overview.html
summary: Learn how to use tags to speed up searching and query display and how to manage entity tags.
---
A tag is custom metadata that adds application-specific meaning to Wavefront _entities_: alerts, dashboards, events, and sources and _metrics_. Tags group together entities and metrics according to categories you define.

For an overview of how tags can help you organize your data and improve searches, watch this video:

## Why Tags?

You use tags to limit the number entities and metrics you are working with or querying at once. Limiting the number of entities reduces information overload. Limiting the number of metrics reduces the time to display results.

In the Wavefront UI and API you can use entity tags to filter alert, dashboard, event, and source entities. In the Wavefront UI, entity tags display as gray labeled icons ![tag](images/tag.png#inline) in the filter bar and below each entity in the entity browser.

In ts() and events() queries, you can filter:

-   Metrics with _source_ and _point_ tags
-   Events with:
    - _alert_ and _event_ entity tags
    - _system_ severity, subtype, and type tags added by alerts

## Tag Types

The table summarizes where the two types of tags are used and where they are added and updated.

<colgroup>
<col width="16%"/>
<col width="28%"/>
<col width="28%"/>
<col width="28%"/>
</colgroup>

Tag Type
Used in UI and API
Used in Queries
Where Added and Updated

alert
[Alert Management](alerts.html) and [Preventing Alerts from Firing](maintenance_windows_managing.html)
[Basic events() Queries](events_queries.html)
Wavefront UI and API

dashboard
[Managing Dashboards](dashboards_managing.html)

Wavefront UI and API

Dashboards added by Wavefront have system tags that start with `~`, e.g. `~integration.aws` or `~welcome.tutorial`.

event
[Managing Events](events.html)
[Basic events() Queries](events_queries.html)
system tags added by alerts

entity tags added in the Wavefront UI and API

point

[Wavefront Data Format](wavefront_data_format.html) and [Point Tags in Queries](query_language_point_tags.html)
Wavefront proxy
[Configuring Wavefront Proxy Preprocessor Rules](proxies_preprocessor_rules.html)

Telegraf agent

[Wavefront CLI](wavefront_cli.html)

source
[Managing Sources](sources_managing.html) and [Managing Maintenance Windows](maintenance_windows_managing.html#using-maintenance-windows)
[Getting Started with Wavefront Query Language](query_language_getting_started.html)
Wavefront UI and API

## Tag Paths

All tag types support the ability to organize tags in a hierarchy. The hierarchy is defined by separating tag components with a dot ".". For example: **MyService.MyApp**. Dashboards provided by Wavefront start with a tilde at the beginning of the tag, for example, **~welcome.**, **~integration.**, and **~system.**. To improve readability, tags retain case for display but they are treated as case-insensitive for searching, sorting, etc.

### Selecting and Searching Tag Paths

In the UI you operate on tag paths by selecting a component at a specific node in the hierarchy.  For example:
* Select all Wavefront dashboards by clicking **wavefront**
* Select only tutorial dashboards by expanding the **wavefront** node and selecting **wavefront.tutorial**.

In queries, you achieve the same effect by using trailing wildcards "**.\***" when you specify tag paths. For example, to match all tags starting with **alertTagPath.**, enter **alertTagPath.\***. This string matches alerts named **alertTagPath.tpc1**, **alertTagPath.tpc1.tpc11**, etc.

When you create maintenance windows you can use tag paths and wildcards to put a group of of alerts in maintenance.

## Managing Entity Tags

Entity tags are tags that apply to Wavefront entities: alerts, dashboards, events, and sources.

While every Wavefront user can view Wavefront entities, you must have [Alert, Dashboard, Event, or Source Tag Management permission](permissions_overview.html) to manage those entities. If you do not have permission, the UI menu selections, buttons, and links you use to perform management tasks are not visible.

### Adding Entity Tags

To add tags to one or more entities:

1.  Open an entity browser.
    - For some entities, you select **Browse > <entity>**, where **<entity>** is **Sources** or **Events**.
    - For other entities, such as Alerts, you click the entity.
2.  Choose which entities to tag:
    -   Check the checkboxes next to the entities and click the **+ Tag** button.
    -   Click **+** at the bottom and select a tag or click **Create New Tag**.

        ![source tags](images/source_tags.png)

3.  In the **Add Tag** dialog, click the **Create Tag** button at the bottom.
4. Type a tag name. Tag names can contain alphanumeric (a-z, A-Z, 0-9), dash (-), underscore (\_), and colon (:) characters. Tag names are *case sensitive*. For example, the tags **MyApp** and **myapp** are stored as distinct tags. However, mixed case tag paths are collapsed into one path; **MyService.myapp** and **myservice.myapp** are collapsed into **Myservice.myapp**.
5. Click **Add**.

### Searching for Entity Tags

When you have many tags in your environment, you can search for tags by typing tag names in the Search box below the Tags heading in the filter bar on the left. As you type, the list of tags is filtered by the search string.

**Note** When you search for tags, the search process is *case insensitive*. For example, searching for the tag **myapp** returns **MyApp** and **myapp.**.

### Filtering by Entity Tags

To filter by a tag, click a tag icon. You can click the icon in the filter bar on the left or below an entity in an entity browser.

repository: mmozum/docs

repo_name: mmozum/docs


text:
# Masterpiece

To be considered for advancement to the rank of master, you must complete a master project. The code for all projects must be reviewed by a master mentor. The masterpiece does not have to use technologies taught in this course but should demonstrate principles learned. It should demonstrate good design (both visual and technical) and show good coding technique. The master project may fall into these categories:

- A standalone project.
- A notable contribution to an open-source project.

Projects for work or private repositories will not be considered.

*Work In Progress*


text:
##Tamagotchi
A simple CLI implementation of the Tamagotchi Game developed by serenagabbio

## To install dependencies
npm install

## To start the game
npm start

## Interaction
You can interact with your creature tiping:
  f: to give him food
  t: to give him water
  c: to clean him
  h: to cure him

## To exit the game
Ctrl+c

repository: serenagabbio/bootcamp-tamagotchi

repo_name: serenagabbio/bootcamp-tamagotchi


text:
# Changelog
All notable changes to this project will be documented in this file.

## [0.1.0] - 2019-11-13
### Changed
- **BREAKING**: Convert SDK to adhere to the [WayScript HTTP Trigger](https://docs.wayscript.com/library/triggers/http-trigger) specification.

### Added
- Changelog

## [0.0.3] - 2019-07-02
### Fixed
- setup.py on Windows

## [0.0.2] - 2019-07-01
### Added
- Can now specify which function to run

## [0.0.1] - 2019-04-17
### Released SDK

[Unreleased]: https://github.com/wayscript/wayscript-python/compare/0.1.0...HEAD
[0.1.0]: https://github.com/wayscript/wayscript-python/compare/0.0.3...0.1.0
[0.0.3]: https://github.com/wayscript/wayscript-python/compare/v0.0.2...0.0.3
[0.0.2]: https://github.com/wayscript/wayscript-python/compare/0.0.1...v0.0.2
[0.0.1]: https://github.com/wayscript/wayscript-python/releases/tag/0.0.1

repository: ryanmaynard/wayscript-python

repo_name: ryanmaynard/wayscript-python