text:
# baud

Serial port with Modbus support.

Basic Modbus support:

- **Interactice RTU**: RTU commands are send interactively.

Low level advanced Modbus support:

- **RTU TCP Gateway Loop**: Modbus TCP requests received by the native port are translated to RTU and forwarded to serial port. Responses are translated back from RTU to TCP.
- **RTU Master Loop**: Modbus RTU requests received by the native port are padded with CRC and forwarded to serial port. Responses are checked and unpadded back.
- **RTU Slave Loop**: Modbus RTU requests received by the native port port are checked and unpadded from CRC and forwarded to socket. Responses are padded and forwarded back.

Some of these modes of operation feature samples below. See the unit tests for more usage samples.

## Installation and Usage

  1. Add `baud` to your list of dependencies in `mix.exs`:

    ```elixir
    def deps do
      [{:baud, "~> 0.4.0"}]
    end
    ```

  2. Build & test it:

  See [NOTES](NOTES.md) for platform specific instructions on setting up your development environment.

  ```shell
  #Serial port names are hard coded in test_helper.exs
  #A couple of null modem serial ports are required
  #com0com may work on Windows but not tested yet
  ./test.sh
  ```

  3. Use it to enumerate serial ports

    ```elixir
    alias Baud.Enum
    ["COM1", "ttyUSB0", "cu.usbserial-FTVFV143"] = Enum.list()
    ```

  4. Use it to interact with your serial port

    ```elixir
    #Do not prepend /dev/ to the port name
    #Try this with a loopback
    {:ok, pid} = Baud.start_link([portname: "cu.usbserial-FTYHQD9MA"])
    #Send data
    :ok = Baud.write(pid, "Hello");
    #Wait data is transmitted
    :ok = Baud.wait4tx(pid, 400)
    #Wait at least 5 bytes are available
    :ok = Baud.wait4rx(pid, 5, 400)
    #Check at least 5 bytes are available
    {:ok, 5} = Baud.available(pid);
    #Read 4 bytes of data
    {:ok, "Hell"} = Baud.read(pid, 4, 400);
    #Read all available data
    {:ok, "o"} = Baud.read(pid);
    #Send more data
    :ok = Baud.write(pid, "World!\n...");
    #Wait at least 1 byte is available
    :ok = Baud.wait4rx(pid, 1, 400)
    #Read all data up to first newline
    {:ok, "World!\n"} = Baud.readln(pid, 400);
    #Discard the trailing ...
    :ok = Baud.discard(pid)
    #Check nothing is available
    {:ok, 0} = Baud.available(pid);
    #Check the native port is responding
    :ok = Baud.echo(pid)
    #Close the native serial port
    :ok = Baud.close(pid)
    #Stop the server
    :ok = Baud.stop(pid)
    ```

  5. Use it to interact with your **RTU** devices.

    ```elixir
    {:ok, pid} = Baud.start_link([portname: "cu.usbserial-FTVFV143", baudrate: 57600])
    #force 0 to coil at slave 1 address 3000
    :ok = Baud.rtu(pid, {:fc, 1, 3000, 0}, 400)
    #read 0 from coil at slave 1 address 3000
    {:ok, [0]} = Baud.rtu(pid, {:rc, 1, 3000, 1}, 400)
    #force 10 to coils at slave 1 address 3000 to 3001
    :ok = Baud.rtu(pid, {:fc, 1, 3000, [1, 0]}, 400)
    #read 10 from coils at slave 1 address 3000 to 3001
    {:ok, [1, 0]} = Baud.rtu(pid, {:rc, 1, 3000, 2}, 400)
    #preset 55AA to holding register at slave 1 address 3300
    :ok = Baud.rtu(pid, {:phr, 1, 3300, 0x55AA}, 400)
    #read 55AA from holding register at slave 1 address 3300 to 3301
    {:ok, [0x55AA]} = Baud.rtu(pid, {:rhr, 1, 3300, 1}, 400)
    ```

  6. Use it to export your serial port to a socket in **raw** mode with no buffering so that the socket (being faster) receives bytes from the serial port (being slower) as they arrive unless a packetization timeout is configured.

    ```elixir
    alias Baud.Sock
    #Do not prepend /dev/ to the port name. Mode defaults to :raw
    {:ok, pid} = Sock.start_link([portname: "ttyUSB0", port: 5000])
    #use netcat to talk to the serial port
    #nc <IP_ADDRESS> 5000
    :ok = Sock.stop(pid)
    ```

  7. Use it to export your serial port to a socket in **text** mode with input buffering up the a newline at the serial port level to avoid to many context switches between Erlang and the native port due to the differences of socket and serial port speed.

    ```elixir
    alias Baud.Sock
    #Do not prepend /dev/ to the port name.
    {:ok, pid} = Sock.start_link([portname: "ttyUSB0", port: 5000, mode: :text])
    #use netcat to talk to the serial port
    #nc <IP_ADDRESS> 5000
    :ok = Sock.stop(pid)
    ```

  8. Use it to export your serial port to a socket in **tcp gateway** mode where TCP received in socket is translated back and forth to RTU on serial port.

    ```elixir
    alias Baud.Sock
    #Do not prepend /dev/ to the port name.
    {:ok, pid} = Sock.start_link([portname: "ttyUSB0", port: 5000, mode: :rtu_tcpgw])
    #modbus TCP commands sent to <IP_ADDRESS>:5000 will be forwarded as RTU to serial port
    :ok = Sock.stop(pid)
    ```

## Releases

Version 0.4.0

- [x] Added sample scripts (1 y 2)
- [x] Improved documentation
- [x] Update to modbus 0.2.0 (refactoring required)

Version 0.3.0

- [x] Integration test script for modport
- [x] Added test.sh to isolate tests run
- [x] RTU master, slave, and tcpgw loop modes
- [x] Serial port export to socket in raw, text, and modbus mode
- [x] RTU API matched to `modbus` package (1,2,3,4,5,6,15,16)
- [x] Improved timeout handling for shorter test times

Version 0.2.0

- [x] Interactive RTU: read/write up to 8 coils at once

Version 0.1.0

- [x] Cross platform native serial port (mac, win, linux)
- [x] Modbus (tcu-rtu), raw and text loop mode

## TODO

- [ ] loop* tests still show data corruption when run all at once
- [ ] Implement Modbus ASCII support (no available device)
- [ ] Implement DTR/RTS control and CTS/DSR monitoring
- [ ] Implement separate discard for input and output buffers
- [ ] Unit test 8N1 7E1 7O1 and baud rate setup against a confirmed gauge
- [ ] Get port names required for unit testing from environment variables
- [ ] Implement a clean exit to loop mode for a timely port close and to ensure test isolation
- [ ] Improve debugging: stderr messages are interlaced in mix test output
- [ ] Improve debugging: dev/test/prod conditional output
- [ ] Move from polling to overlapped on Windows
- [ ] Research why interchar timeout is applied when reading a single byte even having many already in the input buffer. Happens on MAC.
- [ ] Research how to bypass the 0.1s minimum granularity on posix systems
- [ ] Research Mix unit test isolation (OS resources cleanup)
- [ ] Research printf to embed variable sized arrays as hex strings

repository: mobileoverlord/baud

repo_name: mobileoverlord/baud


text:
# Authentication

While the API provides multiple methods for authentication, we strongly recommend using [OAuth](./oauth.md) for production applications. The [other methods](./basic.md) provided are intended to be used for scripts or testing (i.e., cases where full OAuth would be overkill).

Third party applications that rely on GitBook for authentication should not ask for or collect GitBook credentials. Instead, they should use the OAuth web flow.

repository: pks-os/api-guide

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: pks-os/api-guide


text:
# InfiniteScrollView [![CircleCI](https://circleci.com/gh/expo/react-native-infinite-scroll-view.svg?style=svg)](https://circleci.com/gh/expo/react-native-infinite-scroll-view)

InfiniteScrollView is a React Native scroll view that notifies you as the scroll offset approaches the bottom. You can instruct it to display a loading indicator while you load more content. This is a common design in feeds. InfiniteScrollView also supports horizontal scroll views.

It conforms to [ScrollableMixin](https://github.com/expo/react-native-scrollable-mixin) so you can compose it with other scrollable components.

[![npm package](https://nodei.co/npm/react-native-infinite-scroll-view.png?downloads=true&downloadRank=true&stars=true)](https://nodei.co/npm/react-native-infinite-scroll-view/)

## Installation

```sh
npm install --save react-native-infinite-scroll-view
```

## Usage

Compose InfiniteScrollView with the scrollable component that you would like to get events from. In the case of a basic ListView, you would write:

```js
import React from 'react';
import {
  ListView,
} from 'react-native';
import InfiniteScrollView from 'react-native-infinite-scroll-view';

class ExampleComponent extends React.Component {
  _loadMoreContentAsync = async () => {
    // Fetch more data here.
    // After fetching data, you should update your ListView data source
    // manually.
    // This function does not have a return value.
  }

  render() {
    return (
      <ListView
        renderScrollComponent={props => <InfiniteScrollView {...props} />}
        dataSource={...}
        renderRow={...}
        canLoadMore={this.state.canLoadMoreContent}
        onLoadMoreAsync={this._loadMoreContentAsync}
      />
    );
  }
}
```

A more complete example that uses a `ListView.DataSource`, [react-redux](https://github.com/reactjs/react-redux), and supports pagination would look something like this:

```js
import React from 'react';
import {
  ListView,
  RefreshControl,
} from 'react-native';
import InfiniteScrollView from 'react-native-infinite-scroll-view';
import { connect } from 'react-redux';

class ExampleComponent extends React.Component {
  static propTypes = {
    // Assume data shape looks like:
    // {items: ["item1", "item2"], nextUrl: null, isFetching: false}
    listData: PropTypes.object.isRequired,

    // dispatch is automatically provided by react-redux, and is used to
    // interact with the store.
    dispatch: PropTypes.func.isRequired,
  };

  constructor(props, context) {
    super(props, context);

    this.state = {
      dataSource: new ListView.DataSource({
        rowHasChanged: this._rowHasChanged.bind(this),
      }),
    };

    // Update the data store with initial data.
    this.state.dataSource = this.getUpdatedDataStore(props);
  }

  async componentWillMount() {
    // Initial fetch for data, assuming that listData is not yet populated.
    this._loadMoreContentAsync();
  }

  componentWillReceiveProps(nextProps) {
    // Trigger a re-render when receiving new props (when redux has more data).
    this.setState({
      dataSource: this.getUpdatedDataSource(nextProps),
    });
  }

  getUpdatedDataSource(props) {
    // See the ListView.DataSource documentation for more information on
    // how to properly structure your data depending on your use case.
    let rows = props.listData.items;

    let ids = rows.map((obj, index) => index);

    return this.state.dataSource.cloneWithRows(rows, ids);
  }

  _rowHasChanged(r1, r2) {
    // You might want to use a different comparison mechanism for performance.
    return JSON.stringify(r1) !== JSON.stringify(r2);
  }

  _renderRefreshControl() {
    // Reload all data
    return (
      <RefreshControl
        refreshing={this.props.listData.isFetching}
        onRefresh={this._loadMoreContentAsync.bind(this)}
      />
    );
  }

  _loadMoreContentAsync = async () => {
    // In this example, we're assuming cursor-based pagination, where any
    // additional data can be accessed at this.props.listData.nextUrl.
    //
    // If nextUrl is set, that means there is more data. If nextUrl is unset,
    // then there is no existing data, and you should fetch from scratch.
    this.props.dispatch(fetchMoreContent(this.props.listData.nextUrl));
  }

  render() {
    return (
      <ListView
        renderScrollComponent={props => <InfiniteScrollView {...props} />}
        dataSource={this.state.dataSource}
        renderRow={...}
        refreshControl={this._renderRefreshControl()}
        canLoadMore={!!this.props.listData.nextUrl}
        onLoadMoreAsync={this._loadMoreContentAsync.bind(this)}
      />
    );
  }
}

const mapStateToProps = (state) => {
  return {listData: state.listData};
};

export default connect(mapStateToProps)(ExampleComponent);
```

## Tips and Caveats

- Horizontal scroll views are supported
- When you load more content in an infinite ListView, the ListView by default will render only one row per frame. This means that for a short amount of time after loading new content, the user could still be very close to the bottom of the scroll view and may trigger a second load.
- Known issue: Make sure your initial data reaches the bottom of the screen, otherwise scroll events won't trigger. Subsequent loads are not affected. See [expo/react-native-infinite-scroll-view#9](https://github.com/expo/react-native-infinite-scroll-view/issues/9) for more details.

## Implementation

InfiniteScrollView uses the `onScroll` event to continuously calculate how far the scroll offset is from the bottom.

license: MIT


text:
# Titanium.Network.BonjourService

<TypeHeader/>

## Overview

You can obtain a `BonjourService` instance by calling <Titanium.Network.createBonjourService>
or from the `service` list from a [BonjourBrowser](Titanium.Network.BonjourBrowser)
`updatedservices` event.

You can only publish Bonjour services attached to a socket which is currently listening;
you cannot publish a service for a remotely connected socket.  If you stop the Bonjour
service and wish to close the socket it uses, it is strongly recommended that you stop
the service first.  When a window which publishes a Bonjour service is closed, you must
stop the service if the associated socket is also to be closed, or if it is no longer
necessary to publish.  Unlike other network operations, Bonjour service resolution and
publishing is synchronous, so be aware that your code may block while resolution is going
on.  In particular, you may wish to display UI elements indicating background activity
before beginning resolution.

<ApiDocs/>

repository: jasonkneen/titanium-docs

repo_name: jasonkneen/titanium-docs


text:
# @metamodern/static
**[Deprecated] Build a next-gen static site with pre-rendered markup and bundled/minified assets**

> **Deprecation Warning**: *This experimental library is no longer in active development and will not be updated in response to Node.js version  releases or security vulnerabilities identified in the dependency tree.*

license: ISC

repository: metamodern-design/static

gha_language: JavaScript

gha_license_id: ISC

repo_name: metamodern-design/static


text:
# Ruby Quiz - Challenge #4 - Turn Humanitarian eXchange Language (HXL) Tabular Records into Named Tuples

Let's turn tabular data using the Humanitarian eXchange Language (HXL)
hashtag convention from array of array of strings
to array of named tuples (also known as hash dictionaries).

---
Aside: What's Humanitarian eXchange Language (HXL)?

[Humanitarian eXchange Language (HXL)](https://github.com/csvspecs/csv-hxl)
is a (meta data) convention for
adding agreed on hashtags e.g. `#org,#country,#sex+#targeted,#adm1`
inline in a (single new line / row)
between the last header row and the first data row
for sharing tabular data across organisations
(during a humanitarian crisis).
Example:

```
What,,,Who,Where,For whom,
Record,Sector/Cluster,Subsector,Organisation,Country,Males,Females,Subregion
,#sector+en,#subsector,#org,#country,#sex+#targeted,#sex+#targeted,#adm1
001,WASH,Subsector 1,Org 1,Country 1,100,100,Region 1
002,Health,Subsector 2,Org 2,Country 2,,,Region 2
003,Education,Subsector 3,Org 3,Country 2,250,300,Region 3
004,WASH,Subsector 4,Org 1,Country 3,80,95,Region 4
```

---

The challenge: Code a parse method that passes the RubyQuizTest :-).

``` ruby
def parse( recs )
  # ...
end
```

For the starter level 1 turn:

``` ruby
parse( [["Organisation", "Cluster", "Province" ],
        [ "#org", "#sector", "#adm1" ],
        [ "Org A", "WASH", "Coastal Province" ],
        [ "Org B", "Health", "Mountain Province" ],
        [ "Org C", "Education", "Coastal Province" ],
        [ "Org A", "WASH", "Plains Province" ]] )
```

into

``` ruby
[{"org" => "Org A", "sector" => "WASH",      "adm1" => "Coastal Province"},
 {"org" => "Org B", "sector" => "Health",    "adm1" => "Mountain Province"},
 {"org" => "Org C", "sector" => "Education", "adm1" => "Coastal Province"},
 {"org" => "Org A", "sector" => "WASH",      "adm1" => "Plains Province"}]
```

Bonus: For a greater level 2 challenge with three extra rules:

- Skip / ignore extra header rows (e.g. one or more rows before hashtag line / row)
- Skip / ignore "untagged" fields / columns (e.g. `""`) in the hashtag line / row in the named tuple hash dictionary
- Fold repeat (duplicate) fields / columns (e.g. `#sex+#targeted`) into a list / array

Turn:

``` ruby
parse( [["What","","","Who","Where","For whom",""],
        ["Record","Sector/Cluster","Subsector","Organisation","Country","Males","Females","Subregion"],
        ["","#sector+en","#subsector","#org","#country","#sex+#targeted","#sex+#targeted","#adm1"],
        ["001","WASH","Subsector 1","Org 1","Country 1","100","100","Region 1"],
        ["002","Health","Subsector 2","Org 2","Country 2","","","Region 2"],
        ["003","Education","Subsector 3","Org 3","Country 2","250","300","Region 3"],
        ["004","WASH","Subsector 4","Org 1","Country 3","80","95","Region 4"]] )
```

into

``` ruby
[{"sector+en"    => "WASH",
  "subsector"    => "Subsector 1",
  "org"          => "Org 1",
  "country"      => "Country 1",
  "sex+targeted" => ["100", "100"],
  "adm1"         => "Region 1"},
 {"sector+en"    => "Health",
  "subsector"    => "Subsector 2",
  "org"          => "Org 2",
  "country"      => "Country 2",
  "sex+targeted" => ["", ""],
  "adm1"         => "Region 2"},
 {"sector+en"    => "Education",
  "subsector"    => "Subsector 3",
  "org"          => "Org 3",
  "country"      => "Country 2",
  "sex+targeted" => ["250", "300"],
  "adm1"         => "Region 3"},
 {"sector+en"    => "WASH",
  "subsector"    => "Subsector 4",
  "org"          => "Org 1",
  "country"      => "Country 3",
  "sex+targeted" => ["80", "95"],
  "adm1"         => "Region 4"}]
```

Start from scratch or, yes, use any library / gem you can find.

To qualify for solving the code challenge / puzzle you must pass the test:

```ruby
require 'minitest/autorun'

class RubyQuizTest < MiniTest::Test

  def test_level1
    recs = [
        ["Organisation", "Cluster", "Province" ],
        [ "#org", "#sector", "#adm1" ],
        [ "Org A", "WASH", "Coastal Province" ],
        [ "Org B", "Health", "Mountain Province" ],
        [ "Org C", "Education", "Coastal Province" ],
        [ "Org A", "WASH", "Plains Province" ]]

    recs_expected = [
          {"org" => "Org A", "sector" => "WASH",      "adm1" => "Coastal Province"},
          {"org" => "Org B", "sector" => "Health",    "adm1" => "Mountain Province"},
          {"org" => "Org C", "sector" => "Education", "adm1" => "Coastal Province"},
          {"org" => "Org A", "sector" => "WASH",      "adm1" => "Plains Province"}]

    assert_equal recs_expected, parse( recs )
  end # method test_level1

  def test_level2
    recs = [
        ["What","","","Who","Where","For whom",""],
        ["Record","Sector/Cluster","Subsector","Organisation","Country","Males","Females","Subregion"],
        ["","#sector+en","#subsector","#org","#country","#sex+#targeted","#sex+#targeted","#adm1"],
        ["001","WASH","Subsector 1","Org 1","Country 1","100","100","Region 1"],
        ["002","Health","Subsector 2","Org 2","Country 2","","","Region 2"],
        ["003","Education","Subsector 3","Org 3","Country 2","250","300","Region 3"],
        ["004","WASH","Subsector 4","Org 1","Country 3","80","95","Region 4"]]

    recs_expected = [
 {"sector+en"    => "WASH",
  "subsector"    => "Subsector 1",
  "org"          => "Org 1",
  "country"      => "Country 1",
  "sex+targeted" => ["100", "100"],
  "adm1"         => "Region 1"},
 {"sector+en"    => "Health",
  "subsector"    => "Subsector 2",
  "org"          => "Org 2",
  "country"      => "Country 2",
  "sex+targeted" => ["", ""],
  "adm1"         => "Region 2"},
 {"sector+en"    => "Education",
  "subsector"    => "Subsector 3",
  "org"          => "Org 3",
  "country"      => "Country 2",
  "sex+targeted" => ["250", "300"],
  "adm1"         => "Region 3"},
 {"sector+en"    => "WASH",
  "subsector"    => "Subsector 4",
  "org"          => "Org 1",
  "country"      => "Country 3",
  "sex+targeted" => ["80", "95"],
  "adm1"         => "Region 4"}]

    assert_equal recs_expected, parse( recs )
  end # method test_level2
end # class RubyQuizTest
```

Post your code snippets on the "official" Ruby Quiz Channel,
that is, the [ruby-talk mailing list](https://rubytalk.org).

Happy hacking and data wrangling with Ruby.

repository: planetruby/quiz

repo_name: planetruby/quiz


text:
# nf-core/hgtseq: Changelog

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [1.1.0](https://github.com/nf-core/hgtseq/releases/tag/1.1.0) - Beary Rose

### `Added`

- [#31](https://github.com/nf-core/hgtseq/pull/31) - Fixed issue where _single_unmapped_ reads also include _both_unmapped_ reads, by creating a local module with two steps samtools flag filtering

### `Fixed`

- [#31](https://github.com/nf-core/hgtseq/pull/31) - Sync `TEMPLATE` with `tools 2.8` and all nf-core/modules updated

### `Dependencies`

| Dependency | Old version | New version |
| ---------- | ----------- | ----------- |
| `samtools` | 1.15.1      | 1.17        |
| `multiqc`  | 1.13        | 1.14        |

### `Deprecated`

## [1.0.0](https://github.com/nf-core/hgtseq/releases/tag/1.0.0) - Dalmatian Daffodil

Initial release of nf-core/hgtseq, created with the [nf-core](https://nf-co.re/) template.

repository: nf-core/hgtseq

gha_language: Nextflow

gha_license_id: MIT

repo_name: nf-core/hgtseq


text:
# HTML Forms

## Materials for this day
 - https://developer.mozilla.org/en-US/docs/Web/Guide/HTML/Forms/My_first_HTML_form
 - https://css-tricks.com/video-screencasts/99-overview-of-html5-forms-types-attributes-and-elements/
 - http://www.smashingmagazine.com/2011/11/extensive-guide-web-form-usability/

### Videos
| Material | Time |
|:---------|-----:|
| [Styling HTML 5 Forms #1 - Introduction](https://www.youtube.com/watch?v=HiHHvTcHiEk) | 6:26 |
| [Styling HTML 5 Forms #2 - Styling Radio Buttons](https://www.youtube.com/watch?v=hOU4Aqci2zs) | 6:58 |
| [Styling HTML 5 Forms #3 - Styling Checkboxes](https://www.youtube.com/watch?v=9mW9RDMF-wU) | 5:37 |
| [Styling HTML 5 Forms #4 - Styling Text Inputs](https://www.youtube.com/watch?v=3Bhrx2DumvI) | 6:18 |
| [Styling HTML 5 Forms #5 - Styling Select Boxes](https://www.youtube.com/watch?v=IPtyr11fjcI) | 3:37 |
| [Styling HTML 5 Forms #6 - Validation Styles](https://www.youtube.com/watch?v=nO94Y1YgQUo) | 6:05 |

#### [Full playlist](https://www.youtube.com/playlist?list=PL4cUxeGkcC9g5_p_BVUGWykHfqx6bb7qK)

## Assignment Review
 - `<form>` element
 - `action` attribute
 - `method` attribute
 - `<input>` element
 - `type` attribute
   - text
   - email
   - tel
   - number
   - date
   - search
   - color
   - range
 - `value` attribute
 - `name` attribute
 - `<textarea>` element
 - `<label>` element
   - `for` attribute
 - custom attribures
   - placeholder
   - autofocus
   - maxlength
   - min, max, step
   - required
   - novalidation
 - submit
 - validation

## Workshop
 - Build a following design
 - Make sure you are using the simpliest selectors as possible.
 - Try to avoid code duplication.
 - Use paint, gimp, or something similar to figure out the sizes and colors.

![first problem](1.png)

[psd file](form.psd)

repository: gaborveres-planorama/teaching-materials

repo_name: gaborveres-planorama/teaching-materials


text:
---
id: 160
title: Canary Token
date: 2016-02-15T14:18:42+00:00
author: Brett Johnson
layout: post
permalink: /BrettsITBlog/2016/02/canary-token/
categories:
  - Reviews
---
On the 28th of Jan, I got a notification on my phone that episode 396 of the Risky Business podcast was ready to be streamed for my drive home commute. The sponsored interview with Haroon Meer on a free service called Canary Tokens from Thinkst really got my attention. It was said that Canary Tokens were simple to implement service to produce an alert when activated, they could be placed into directory structures, DNS lookup, Word documents etc.

What got my attention is how easy this could be to set and forget, just generate the token and wait for a designated mailbox to got ‘bing';.

Setting up the tokens couldn';t be easier. All you need to do is enter an email address and a description, set the type of token that you want and hit generate. Afterwards you get a number of options for your token.  As fast as I could, I copied the DNS of my new token and ran it through _nslookup_ as soon as the second time out occurred I had an email that my token was hit.

{% highlight text %}
One of your canarydrops was triggered.

Channel: DNS
Time : 2016-02-15 02:23:58.035387
Memo : DNS Test token
Source IP:
{% endhighlight %}

The key with the creation is to have a good description, since it could be a while before the token is hit. Tokens can be turned off with a management link on the bottom of the email.

The implementation of tokens is very straightforward. The directory option for creating a token is a desktop.ini file with

[.ShellClassInfo]
IconResource=\\%USERNAME%.%USERDOMAIN%.INI.kdh1.canarytokens.com\resource.dll

Very simple to scatter

In the word document it';s part of the footer2.xml file contained as part of the .docx file. Again this is something that is simple to place throughout your network. There is no need for macros or adjusting the security settings in office.

There is a great deal of flexibility, some great examples are given on the podcast. For those of you who are concerned about supplying your email address and getting spammed. So far I have not received one email from Thinkst asking me to join a webex, attend an ‘exclusive'; event or look at a single product, it really has been great, in fact the only emails I have received have been from when I triggered my tokens.

I';m not a security expert and I think that this actually makes tokens more valuable to me as they are an easy detection system to scatter throughout my network. They cost nothing and don';t consume any resources.

If you have event 15 minutes free I highly suggest that you check out Canary Tokens.

A few links for you to check out

Canary Tokens

Thinkst

Risky Business

Patrick Gray Twitter

Haroon Meer Twitter

repository: SDBrett/jekyllblog

repo_name: SDBrett/jekyllblog


text:
# Modeling with AWS CloudFormation

Additional AWS resources, referred to as "addons" in the CLI, are any additional AWS services that a [service manifest](../../manifest/overview.en.md) does not integrate by default. For example, an addon can be a DynamoDB table, an S3 bucket, or an RDS Aurora Serverless cluster that your service needs to read or write to.

## How do I add an S3 bucket, a DDB Table, or an Aurora Serverless cluster?

Copilot provides the following commands to help you create certain kinds of addons:

* [`storage init`](../../commands/storage-init.en.md) will create a DynamoDB table, an S3 bucket, or an Aurora Serverless cluster.

You can run `copilot storage init` from your workspace and be guided through some questions to help you set up these resources.

## How to do I add other resources?

For other types of addons, you can add your own custom CloudFormation templates according to the following instructions.

Let's say you have a service named `webhook` in your workspace:
```bash
.
└── copilot
    └── webhook
        └── manifest.yml
```
And you want to add a custom DynamoDB table to `webhook`. Then under the `webhook/` directory, create a new `addons/` directory and add a CloudFormation template for your instance.
```bash
.
└── copilot
    └── webhook
        ├── addons
        │   └── mytable-ddb.yaml
        └── manifest.yaml
```
Typically each file under the `addons/` directory represents a separate addon and is represented as an [AWS CloudFormation (CFN) template](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-anatomy.html). For example, if we want to also add an S3 bucket addon to our service then we could either run `storage init` or create our own custom, separate `mybucket-s3.yaml` file.

When your service gets deployed, Copilot merges all these files into a single AWS CloudFormation template and creates a nested stack under your service's stack.

## What does an addon template look like?
An addon template can be any valid CloudFormation template.
However, by default, Copilot will pass the `App`, `Env`, and `Name` [Parameters](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/parameters-section-structure.html); you can customize your resource properties with [Conditions](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/conditions-section-structure.html) or [Mappings](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/mappings-section-structure.html) if you wish to.

### Connecting addon resources to your workloads
Here are several possible ways to access addon [Resources](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/resources-section-structure.html) from your ECS task or App Runner instance:

* If you need to add additional policies to your ECS task role or App Runner instance role, you can define an [IAM ManagedPolicy](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-managedpolicy.html) addon resource in your template that holds the additional permissions, and then [output](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/outputs-section-structure.html) it. The permission will be injected into your task or instance role.
* If you need to add a security group to your ECS service, you can define a [Security Group](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-security-group.html) in your template, and then add it as an [Output](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/outputs-section-structure.html). The security group will be automatically attached to your ECS service.
* If you'd like to inject a secret to your ECS task, you can define a [Secret](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-secretsmanager-secret.html) in your template, and then add it as an [Output](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/outputs-section-structure.html). The secret will be injected into your container and can be accessed as an environment variable as capital SNAKE_CASE.
* If you'd like to inject any resource value as an environment variable, you can create an [Output](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/outputs-section-structure.html) for any value that you want to be injected as an environment variable to your ECS tasks. It will be injected into your container and accessed as an environment variable  as capital SNAKE_CASE.

### Writing a template
When writing your own template, you must:

* Include the `Parameters` section with `App`, `Env`, `Name`.
* Include at least one `Resource`.

Here is an example template for a DynamoDB table addon:
```yaml
# You can use any of these parameters to create conditions or mappings in your template.
Parameters:
  App:
    Type: String
    Description: Your application's name.
  Env:
    Type: String
    Description: The environment name your service, job, or workflow is being deployed to.
  Name:
    Type: String
    Description: The name of the service, job, or workflow being deployed.

Resources:
  # Create your resource here, such as an AWS::DynamoDB::Table:
  # MyTable:
  #   Type: AWS::DynamoDB::Table
  #   Properties:
  #     ...

  # 1. In addition to your resource, if you need to access the resource from your ECS task
  # then you need to create an AWS::IAM::ManagedPolicy that holds the permissions for your resource.
  #
  # For example, below is a sample policy for MyTable:
  MyTableAccessPolicy:
    Type: AWS::IAM::ManagedPolicy
    Properties:
      PolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Sid: DDBActions
            Effect: Allow
            Action:
              - dynamodb:BatchGet*
              - dynamodb:DescribeStream
              - dynamodb:DescribeTable
              - dynamodb:Get*
              - dynamodb:Query
              - dynamodb:Scan
              - dynamodb:BatchWrite*
              - dynamodb:Create*
              - dynamodb:Delete*
              - dynamodb:Update*
              - dynamodb:PutItem
            Resource: !Sub ${ MyTable.Arn}

Outputs:
  # 1. You need to output the IAM ManagedPolicy so that Copilot can add it as a managed policy to your ECS task role.
  MyTableAccessPolicyArn:
    Description: "The ARN of the ManagedPolicy to attach to the task role."
    Value: !Ref MyTableAccessPolicy

  # 2. If you want to inject a property of your resource as an environment variable to your ECS task,
  # then you need to define an output for it.
  #
  # For example, the output MyTableName will be injected in capital snake case, MY_TABLE_NAME, to your task.
  MyTableName:
    Description: "The name of this DynamoDB."
    Value: !Ref MyTable
```

On your next release, Copilot will include this template as a nested stack under your service!

!!! info
    We recommend following [Amazon IAM best practices](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html) while defining AWS Managed Policies for the additional resources, including:

    * [Grant least privilege](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#grant-least-privilege) to the policies defined in your `addons/` directory.
    * [Use policy conditions for extra security](https://docs.aws.amazon.com/IAM/latest/UserGuide/best-practices.html#use-policy-conditions) to restrict your policies to access only the resources defined in your `addons/` directory.

### Customizing the `Parameters` section

AWS Copilot always requires the `App`, `Env`, and `Name` parameters to be defined in your template. However, if
you'd like to define additional parameters that refer to resources in your service stack you can do so with a
`addons.parameters.yml` file.

```term
.
└── addons/
    ├── template.yml
    └── addons.parameters.yml # Add this file under your addons/ directory.
```

In your `addons.parameters.yml`, you can define additional parameters that can refer to values from your workload stack. For example:
```yaml
Parameters:
  ServiceName: !GetAtt Service.Name
```
Finally, update your template file to refer to the new parameter:
```yaml
Parameters:
  # Required parameters by AWS Copilot.
  App:
    Type: String
  Env:
    Type: String
  Name:
    Type: String
  # Additional parameters defined in addons.parameters.yml
  ServiceName:
    Type: String
```

branch_name: refs/heads/mainline

gha_language: Go


text:
# Dapper Logging integration

The tool consists of simple decorators for the `DbConnection` and `DbCommand` which track the execution time and write messages to the `ILogger<T>`. The `ILogger<T>` can be handled by any logging framework (e.g. Serilog).
The result is similar to the default EF Core logging behavior.

The lib declares a helper method for registering the `IDbConnectionFactory` in the IoC container.
The connection factory is SQL Provider agnostic. That's why you have to specify the real factory method:
```
  services.AddDbConnectionFactory(prv => new SqlConnection(conStr));
```
After registration, the `IDbConnectionFactory` can be injected into classes that need a SQL connection.
```
private readonly IDbConnectionFactory _connectionFactory;
public GetProductsHandler(IDbConnectionFactory connectionFactory)
{
    _connectionFactory = connectionFactory;
}
```
The `IDbConnectionFactory.CreateConnection` will return a decorated version that logs the activity.
```
using (DbConnection db = _connectionFactory.CreateConnection())
{
    //...
}
```
The lifetime of the factory can be configured during the registration in DI.
Also, you can alter the default messages using the `DbLoggingConfigurationBuilder` and fluent api.

## Samples

The code is simpler than this explanation 🙂. Please check the _Samples_.
There you can find a comparison of EF Core and Dapper. It should show the similarities in logging behavior.


text:
# Contribution Guidelines

To facilitate efficient development, it will be helpful to run your own bot
on our test server. We have test versions of Notion and a MongoDB instance.
To get setup, please follow these guidelines:

## Create your own bot to use in your local dev environment

1. Visit the [Discord Developer Portal](https://discord.com/developers/applications)
2. Sign in with your Discord credentials
3. Create a new application, call it whatever you want
4. On the left, select "Bot" and create a bot user
5. Switch on "Presence Intent" and "Server Members Intent"
6. Save your changes
7. On the left, select "OAuth2"
8. Under "Scopes", select "bot"
9. Permissions. Enable only these permissions:

-   Manage Server
-   Manage Roles
-   Manage Channels
-   Kick Members
-   Ban Members
-   Manage Emojis
-   Manage Webhooks
-   View Channels
-   All of the permissions under "Text Permissions"
-   No permissions under "Voice Permissions"

10. Select and copy the generated URL under "Scopes." Make sure the value
    of permissions in the URL reads<PHONE_NUMBER>
11. Send the URL via Discord DM to nonsense to have it added to the test
    Discord server

## Clone the repo to local

1. Create a new feature branch from the dev branch
2. Copy the .env file and name it whatever you want; add it to your local
   .gitignore
3. Request the test Notion token and MongoDB URI from one of the repo
   maintainers, copy your bot's token (found under the bot tab in the
   developer's portal) and replace the relevant values in your copied .env
   file, making sure to update the file name where it is required in `app.js`
4. `npm install`
5. Run your bot and test your connections

## Develop!

Work on your features/assignments. Tests should be written for new features
that are added. We are using Jest as the test library, so please familiarize
yourself with Jest if you are not already familiar with it. If you need help
with writing tests, please ask, as we have a couple devs on board who have
experience in this area.

When you feel the feature is ready to be battle tested, lint and test your
code and run it through Prettier prior to pushing it. Submitting a PR will
trigger this workflow anyway. However, the less we have to do to fix merge
conflicts and failed workflows, the better.

Once the branch is ready to be merged, push it to the repo and create a PR
to the dev branch. From this point, it will follow the details set out in
WORKFLOW.md.

branch_name: refs/heads/DEGEN


text:
# spak docs

## Quick Links

- [App API](#app-interface)
- [App providers](./app-providers.md)
- [Philosophy of `spak`](./philosophy.md)
- [Application components](./app-component.md)
- [Application action and events](./app-actions-and-events.md)
- [Application hooks](./app-hooks.md)
- [Application configuration (including registries)](./app-config.md)
- [App Specifications](./specifications.md)
- [Custom functionality via AppDelegate](./app-delegate.md)
- [App Bootstrapper/Component Lifecycle](./app-run.md)
- [App workflows](./app-workflows.md)
- [Bundled decorators](./decorators.md)
- [Testing your components](./testing.md)
- [Commong Issues and Tips](./tips.md)

## `App`

`App` is the root level object/class of your system that all modules in the project can depend on for application resources (providers). In addition the action dispatcher and event bus are also exposed.

`App` is an exported class, but you should never need to `new` up an instance. Instead most modules will simply call a `static` method which in turns message the instance.
If you need access to the instance itself, you can always call `instance()`.

```javascript
// I could do this.
var user = App.instance().user();
// But I think this is better.
var user = App.user();
```

## `App` interface

```typescript
interface App {
    static run(AppComponents, AppConfig, AppDelegate);
    static terminate();
    static session(): ClientSession;
    static user(): User;
    static localize(key: string): String;
    static logger(namespace: string): Logger;
    static events: EventBus;
    static dispatchAction(actionName: string, opts: Object);
    static config: AppConfig;
    static bootstrapper: Bootstrapper;
    static container: IocContainer;
}
```

All of the above `static` methods also can be referenced off the instance, but as shown above, this is usually unnecessary.

repository: jfkhoury/spak

repo_name: jfkhoury/spak


text:
# HA Cluster bootstrap salt formula

Formulas for bootstrapping and managing a high availability cluster
using crmsh.

Mainly adapted to SUSE / openSUSE Linux distributions, but should be
usable on other distributions with minor modifications.

## Usage

To use, configure the cluster options using pillar data as described
in `pillar.example`. To create multiple clusters, different pillar
data can be applied to different groups of nodes with different nodes
as the init node.

**Important!** The hostnames and minion names of cluster nodes need to
be the same for the cluster join procedure to work correctly, and the
nodes need to be able to reach each other by hostname / minion
name. To see an example of how this is configured, see
`test/salt/common/hosts.sls` in this repository.

## Integration with other formulas

The following formula pillars support HA cluster bootstrap-

* [firewalld-formula](https://github.com/saltstack-formulas/firewalld-formula)

``` yaml
    extends:
       firewalld:
         services:
           cluster-formula:
             short: hacluster
             description: HA cluster firewall rules
             ports:
               tcp:
                 - 30865
                 - 5560
                 - 7630
                 - 21064
               udp:
                 - 5405
                 - 5407
         zones:
           public:
             services:
               - hacluster
```

* [packages-formula](https://github.com/saltstack-formulas/packages-formula>)

``` yaml
     extends:
       packages:
         pkgs:
           wanted:
             - crmsh
             - resource-agents
             - fence-agents
             - sbd
```

## Test

The `Vagrantfile` and `test/` folder in this repository provides a
sample cluster configuration that uses the formula to create the HA
cluster.

This has been tested with Vagrant 2.1.2 on openSUSE Leap 15, but
should hopefully work with other versions as well.

``` bash
cd habootstrap-formula
vagrant up
./test/run
```

These steps will create the cluster nodes (salt master, and two ha
cluster nodes). In order to play with the formula, the file
`test/pillar/cluster.sls` can be changed to apply different options to
the cluster nodes (check the options in `pillar.example`).

To add more nodes to the cluster, new nodes information must be added
to `Vagrantfile`, `test/salt/common/hosts.sls` and `test/salt/top.sls`
files.

To access to the different nodes and play with them run:

``` bash
vagrant ssh {nodename}
```

### Troubleshooting

> Note: This advice is specific to openSUSE / SUSE distributions. For
> other distributions, the specific commands needed may be different.

To run the tests, `libvirt` must be installed and the daemon running:

``` bash
zypper in libvirt
systemctl start libvirtd
```

### Known issues
* Failure running [join-the-cluster](./cluster/join.sls):

> Note: The current solution is to query **hawk** status. This doesn't exactly
> represent the state of **pacemaker** (hawk initialization is independent).
> Increasing the `join_timer` to wait pacemaker may help in some cases.

TODO: Replace to query **hawk** by checking **pacemaker** directly.

repository: MalloZup/habootstrap-formula

gha_license_id: NOASSERTION

repo_name: MalloZup/habootstrap-formula


text:
## `zdesk triggers definitions`

Run triggers definitions subcommands

### Synopsis

    zdesk triggers definitions COMMAND[ ... ]

### Description

Run triggers definitions subcommands

repository: fprimex/zdesk-cli

branch_name: refs/heads/main

repo_name: fprimex/zdesk-cli


text:
<!--
 Copyright (c) 2020 Luuk de Gram

 This software is released under the MIT License.
 https://opensource.org/licenses/MIT
-->

# OTP
![Test](https://github.com/Luukdegram/otp/workflows/Test/badge.svg)

OTP is a one-time-password library supporting both HOTP and TOTP according to [`RFC 4226`](https://tools.ietf.org/html/rfc4226) and [`RFC 6238`](https://tools.ietf.org/html/rfc6238).

Currently only the generation of codes is supported. Verification has to be done by the implementation.

**note**

This library's primary goal was to get more familair with the Zig language.

## Example
```zig
const std = @import("std");
const otp = @import("otp");
const warn = std.debug.warn;

pub fn main() !void {
    const hotp = otp.Hotp.init();
    const code = try hotp.generateCode("secretkey", 0);
    warn("code: {}\n", .{code});
}
```
You can use the `build.zig` file as reference point on how to link the library to your own project.

### Tests
You can run the tests using the following command
```shell
zig build
```

repository: Luukdegram/otp

repo_name: Luukdegram/otp


text:
![Turtle Logo](https://raw.githubusercontent.com/mr-coxall/turtle-logo/master/icon.png)
## Turtle Logo Extension Overview

### Turtle Logo blocks
![Turtle Logo Blocks](https://raw.githubusercontent.com/mr-coxall/turtle-logo/master/assets/Turtle_Logo_Blocks_small.png)

### Introductory Turtle Logo Lessons for Students
You can get a set of introductory lessons for students to **Turtle Logo** here:
- Lesson #1 → "Hello, World!" [YouTube](https://youtu.be/HW2zt7gOTXs) - [Arcade tutorial & restricted IDE](http://arcade.makecode.com/?lockedEditor=1#tutorial:https://github.com/Mr-Coxall/makecode-arcade-turtle-logo-lesson1)
- Lesson #2 → Moving Turtle   [YouTube](https://youtu.be/6Iy0KVbIkzs) - [Arcade tutorial & restricted IDE](http://arcade.makecode.com/?lockedEditor=1#tutorial:https://github.com/Mr-Coxall/makecode-arcade-turtle-logo-lesson2)
- Lesson #3 → Turning Turtle  [YouTube](https://youtu.be/lnFRWyLXDUI) - [Arcade tutorial & restricted IDE](http://arcade.makecode.com/?lockedEditor=1#tutorial:https://github.com/Mr-Coxall/makecode-arcade-turtle-logo-lesson3)
- Lesson #4 → Pen color       [YouTube](https://youtu.be/tOWJ47YGXX0) - [Arcade tutorial & restricted IDE](http://arcade.makecode.com/?lockedEditor=1#tutorial:https://github.com/Mr-Coxall/makecode-arcade-turtle-logo-lesson4)
- Lesson #5 → Pen Up          [YouTube](https://youtu.be/sIrBfOgNz9k) - [Arcade tutorial & restricted IDE](http://arcade.makecode.com/?lockedEditor=1#tutorial:https://github.com/Mr-Coxall/makecode-arcade-turtle-logo-lesson5)
- Lesson #6 → Looping         [YouTube](https://youtu.be/xs2HbVJ8KQI) - [Arcade tutorial & restricted IDE](http://arcade.makecode.com/?lockedEditor=1#tutorial:https://github.com/Mr-Coxall/makecode-arcade-turtle-logo-lesson6)

### Advanced Turtle Logo Lessons for Students
You can get a set of advanced lessons, using variables and sprites for students to **Turtle Logo** here:
- Lesson #1 → "Hello, World!"  [YouTube](https://youtu.be/qTC16Zdyr0s) - [Restricted IDE](http://arcade.makecode.com/?lockedEditor=1#tutorial:https://github.com/Mr-Coxall/makecode-arcade-turtle-logo-lesson1-advanced)
- Lesson #2 → Moving Turtle    [YouTube](https://youtu.be/mutWUDvQsAo) - [Restricted IDE](http://arcade.makecode.com/?lockedEditor=1#tutorial:https://github.com/Mr-Coxall/makecode-arcade-turtle-logo-lesson2-advanced)
- Lesson #3 → Turning Turtle   [YouTube](https://youtu.be/6zzq0y3baXo) - [Restricted IDE](http://arcade.makecode.com/?lockedEditor=1#tutorial:https://github.com/Mr-Coxall/makecode-arcade-turtle-logo-lesson3-advanced)
- Lesson #4 → Pen color        [YouTube](https://youtu.be/XbgNxCnBZ1c) - [Restricted IDE](http://arcade.makecode.com/?lockedEditor=1#tutorial:https://github.com/Mr-Coxall/makecode-arcade-turtle-logo-lesson4-advanced)
- Lesson #5 → Pen Up           [YouTube](https://youtu.be/ysTdV30WCdg) - [Restricted IDE](http://arcade.makecode.com/?lockedEditor=1#tutorial:https://github.com/Mr-Coxall/makecode-arcade-turtle-logo-lesson5-advanced)
- Lesson #6 → Looping          [YouTube](https://youtu.be/L8Mw3eyVer0) - [Restricted IDE](http://arcade.makecode.com/?lockedEditor=1#tutorial:https://github.com/Mr-Coxall/makecode-arcade-turtle-logo-lesson6-advanced)

### MakeCode Arcade Extension
This MakeCode Arcade Extension adds "Turtle Logo" programming language to make code.
This code uses a previous version ([https://github.com/microsoft/pxt-screen-turtle](https://github.com/microsoft/pxt-screen-turtle)) but I needed some specific changes as requested by the elementary teacher I was working with:
- needed to minimize the number of blocks
- needed to change some block names, to help student's
- needed to use cartesian coordinates, (0,0) being in the center of the screen

See an example in actions at:
> Open this page at [https://mr-coxall.github.io/turtle-logo/](https://mr-coxall.github.io/turtle-logo/)

## Use as Extension

This repository can be added as an **extension** in MakeCode.

* open [https://arcade.makecode.com/](https://arcade.makecode.com/)
* click on **New Project**
* click on **Extensions** under the gearwheel menu
* search for **https://github.com/mr-coxall/turtle-logo** and import

This repository can be added as an **extension** in MakeCode.

## Edit this project ![Build status badge](https://github.com/mr-coxall/turtle-logo/workflows/MakeCode/badge.svg)

To edit this repository in MakeCode.

* open [https://arcade.makecode.com/](https://arcade.makecode.com/)
* click on **Import** then click on **Import URL**
* paste **https://github.com/mr-coxall/turtle-logo** and click import

## Blocks preview

This image shows the blocks code from the last commit in master.
This image may take a few minutes to refresh.

![A rendered view of the blocks](https://github.com/mr-coxall/turtle-logo/raw/master/.github/makecode/blocks_new.png)

#### Metadata (used for search, rendering)

* for PXT/arcade
<script src="https://makecode.com/gh-pages-embed.js"></script><script>makeCodeRender("{{ site.makecode.home_url }}", "{{ site.github.owner_name }}/{{ site.github.repository_name }}");</script>

repository: Mr-Coxall/turtle-logo

gha_language: TypeScript

repo_name: Mr-Coxall/turtle-logo


text:
---
layout: post
title: The World of Consumer Understanding
description: Keep pace with consumers and their needs to unlock growth opportunities
summary: Keep pace with consumers and their needs to unlock growth opportunities
date: 2020-06-03T15:54:20.213Z
tags:
  - branding
---
Unlocking growth through developing deep understanding of people lives

We have entered new age in marketing where brand and consumer relationships have evolved from what they used to be. To unlock growth opportunities in this new age of brand and consumer relationship, we must keep pace by developing a deep understanding and empathy of people's lives. To demystify the complex world of consumer, we need to:

* Place ourselves in the lives of our consumer and demonstrate empathy.
* Use consumer understanding and data to define segments,
* Apply our understanding of consumer segment to develop differentiated strategies and tailored experiences.
* Synthesize multiple sources of information across the consumer journey to generate actionable insights,
* connect the data dots to uncover opportunities, barriers and drive business decisions

With consumers become increasingly digital savvy and shifting expectation, it is essential to entrench culture of consumer centricity to build enduring connection with consumers and win their hearts and minds. Consumer centricity is about putting our consumers at the heart of everything we do so we can work together as an organisation to design and deliver experiences that appeal to them most. It is about understanding our consumer segment, getting under their skin and finding the underlying reasons that compel them to act.

Key to become consumer centric:

* visible consumer focused leadership
* understand your consumer
* design consumer experiences
* set metrics that matter
* feedback drives continuous improvement

To deliver consumer centric experiences, we must begin with empathy. Empathy enables us to not only experience and understand another person's circumstances, but it also puts us in our consumers' shoes to experience what they are feeling. Consumer centricity requires us to focus on the needs of our most valuable consumers which can be identified through segmentation. Segmentation is not just based on demographics but also based on behaviors, attitudes, and underlying motivations. The benefits of segmentation are:

* identifies where to focus resources and efforts for maximum returns
* informs marketing strategies and activities
* helps us better understand our consumer at a granular level
* provides an anchor to develop marketing activities that respond to consumer needs and trends accordingly

In defining the consumer segments, we need to ask 3 key questions:

1. Whom we are already attracting? We need to analyse past performance to determine type of consumers and deliver higher yield than the rest
2. What are the growth segment? We need to layer secondary research on growth trends to identity segments with greatest future growth potential
3. Which segment do we have a right to win in? We need to evaluate potential consumer segments to establish if we can meet their needs.

After defining consumer segments, we then need to find ways to grow them. One critical way to unlock growth is by actionable insights. Insights is an "Aha!" moment that have profound implications - a penetrating discovery about consumer motivations that can be applied to unlock growth. This insights come when:

* we combine bits of data around a subject
* we include seemingly irrelevant data and suddenly see the significance
* we make connections or see a pattern that was not previously apparent

However, people often confuse information (what the consumer said or did) with insights (why the consumer said or did).  Here, information is defined as a statement or fact; often comes straight from research report or debrief; is something you or someone else observed/heard; with no or little interpretation. Meanwhile insight is expressed as want, need, belief or feeling; is an accurate representation of the consumer's reality, offer a fresh perspective, even if obvious once found out; opens up opportunities.

To generate actionable insight we need to synthesize multiple source of information or data. We can leverage on 2 key approach:

1. Clustering and theming where we distill the most important theme from research and analysis
2. Digging where we probe to uncover hidden motivation and beliefs.

Clustering and theming is about

* connecting thoughts and pieces of information together to form groups of connected thoughts.
* spotting patterns
* applying a label to provide a galvanising theme for the cluster.

A good cluster is driven by consumers' needs, connects across different data sources, and looks beyond the obvious. A good theme goes beyond facts to capture a rich underlying message. It expresses the consumer sentiments "I need or I want" that opens up different routes and new lines of thinking. Tips for clustering and theming:

* leverage all the information gathered in data analysis
* look for connections and key themes
* synthesise, summarise and label the clusters based on the themes. It is an iterative process
* use language that resonates
* look for the rich opportunities for insight generation that is linked to business objectives.

We also should ask "why" to dig beneath the surface. Digging involves drilling down deep into a nominated cluster to unearth greater understanding and potential insight. One of the key reasons we dig for insights is because what consumer say is not always true - digging helps us understand the meaning behind what consumer say, to discover what they think and feel. Some questions : Why? Why is that important? Why does that matter? Afterwards, ask why again...

Somethings to look out for in digging to know if you have found powerful insights: there's a dominant theme, several data sources lead to the same "nugget", or it can be expressed in strong, emotional consumer language. When do we stop digging for insights? It is important to balance quality and depth of the insight. The optimal situation is where we have an insight that is interesting, relevant and differentiates. Insights can be big or small:

* Big insights can unlock a whole new way of looking at a brand or category;
* Small, executional insights are what drive everyday behaviors, actions and transactions.

Big or small, insights are all actionable. Generating insights is more art than science. How do we know when we have an actionable insights? We can use simple screener to help understand whether we identified good and actionable insight:

* Does it really tap into underlying consumer motivations and needs?
* Is it easy to see the potential business applications?
* Does it address the issue and how is it relevant to the brand?
* Is there an "Aha!" when the significance of what has been discovered is realized?
* Is the insight clear and simple? Does it contain one specific idea?
* Is it the WHY and not the WHAT?

We can also use the 4R tool to help screen for actionable insights:

* Reaction: can you think of different ways to generate ideas using this insight?
* Relevance: is it relevant to the business objective?
* Resonance: Does it resonate with the consumer segment?
* Reach: Can it be leveraged for impact?

We need to establish clear relationship between customer segments, insights and marketing ideas in order to bring customer segment to life. The consumer journey is a great place to start for ideation. It helps us understand our consumers' current and future needs. We can understand their current needs through examining where they currently are on the journey and identify how to deliver their future needs through examining the next steps on the journey, ensuring we are building connections every steps on the way. In summary, we start with our segment, cluster, theme and dig to uncover our "aha!" insights and utilise our consumer journey to generate ideas to deliver against the needs of our segments.

gha_language: HTML


text:
Vue Stripe 💳

[![Financial Contributors on Open Collective](https://opencollective.com/vue-stripe-checkout/all/badge.svg?label=financial+contributors)](https://opencollective.com/vue-stripe-checkout) ![npm bundle size](https://img.shields.io/bundlephobia/min/@vue-stripe/vue-stripe?style=flat-square) ![npm](https://img.shields.io/npm/dw/@vue-stripe/vue-stripe?style=flat-square) ![GitHub Workflow Status](https://img.shields.io/github/workflow/status/vue-stripe/vue-stripe/Deploy?style=flat-square) [![saythanks](https://img.shields.io/badge/say-thanks-ff69b4.svg)](https://opencollective.com/vue-stripe-checkout)

Welcome to [version 4](https://randomcodetips.com/vue-stripe-checkout-whats-next/) of **Vue Stripe**, an easy to implement, and well maintained **Vue.js** components/plugins for **Stripe Checkout**, and **Stripe Elements**.

You can support this project by giving it a star, or following the author. You can also send your love through [Open Collective](https://opencollective.com/vue-stripe-checkout#section-contribute) :heart:.

### LEGACY

Old version (version 3) is still available [here](https://www.npmjs.com/package/vue-stripe-checkout).

## Documentation

- [Website (https://vuestripe.com)](https://vuestripe.com)
- [Stripe Checkout](https://vuestripe.com/stripe-checkout/getting-started)
- [Stripe Elements](https://vuestripe.com/stripe-elements/getting-started)
- [Stripe Elements Plugin](https://vuestripe.com/stripe-elements/plugin)

## Contributors

### Code Contributors

This project exists thanks to all the people who contribute. [[Contribute](CONTRIBUTING.md)].

### Financial Contributors

Become a financial contributor and help us sustain our community. [[Contribute](https://opencollective.com/vue-stripe-checkout/contribute)]

#### Individuals

#### Organizations

Support this project with your organization.  [[Contribute](https://opencollective.com/vue-stripe-checkout/contribute)]

**SPECIAL THANKS TO THE FOLLOWING SPONSOR(S):**

[](https://mightyminds.org)
[](https://mycure.md)
[](http://myteamops.com)

Made with :heart: by Jofferson Ramirez Tiquez


text:
# Fan control
A simple daemon for Raspberry PI, that toggles fan depending on current temperature.

## Usage
Just run

```fan_control```

## Pins
Transistor's gate should be connected to Raspberry's PIN 18(GPIO 24).

Raspberry's 5/3.3V power PINs can be used as a power source.

## Acknowledgements
GPIO-related code copied from https://github.com/tranter/blogs/blob/master/gpio/part5/demo1.c


text:
This mod provides a Prometheus exporter for Minecraft. It exports metrics
related to the Minecraft server and the JVM for consumption by the open-source
systems monitoring toolkit, [Prometheus]. The mod is intended for server-side
use, and does not need to be installed client-side. This currently has builds
for the following versions:

- Minecraft 1.20.1 with Forge 47.1.0.
- Minecraft 1.19.3 with Forge 44.1.0.
- Minecraft 1.19.2 with Forge 43.0.0.
- Minecraft 1.18.1 with Forge 39.0.0.
- Minecraft 1.16.5 with Forge 36.2.0.
- Minecraft 1.15.2 with Forge 21.2.0.
- Minecraft 1.14.4 with Forge 28.1.0.
- Minecraft 1.12.2 with Forge 14.23.0.

Is there a newer version of Minecraft not listed? Let me know by opening an
[issue on GitHub].

Installation
------------

The Prometheus Exporter mod only needs to be installed on the server. It can be
downloaded from [GitHub] and [Curse Forge]. To install it, copy the JAR
(*Prometheus-Exporter-{MC Version}-forge-{Mod Version}.jar*) to the server
*mods/* directory. Since this mod does not add anything to the Minecraft world,
it can be safely upgraded by simply replacing an older version with a newer
version.

Configuration
-------------

The mod configuration is located at *world/serverconfig/prometheus_exporter-server.toml*.
It will be automatically generated upon server start if it does not already
exist. The default configuration can be seen in the example [prometheus_exporter-server.toml].

Exporter Output
---------------

A sample output from the exporter can be seen in the example [output.txt].
Please note as of version 1.0.0 the "mc_world_tick_seconds" metric has been
renamed to "mc_dimension_tick_seconds".

Dashboards
----------

Known compatible Grafana dashboards:

- [Minecraft Server Stats] built by [randombk].

[Curse Forge]: https://www.curseforge.com/minecraft/mc-mods/prometheus-exporter
[GitHub]: https://github.com/cpburnz/minecraft-prometheus-exporter/releases
[Minecraft Server Stats]: https://grafana.com/grafana/dashboards/16508-minecraft-server-stats/
[Prometheus]: https://prometheus.io/
[issue on GitHub]: https://github.com/cpburnz/minecraft-prometheus-exporter/issues
[output.txt]: https://github.com/cpburnz/minecraft-prometheus-exporter/blob/mc1.20.1/examples/output.txt
[prometheus_exporter-server.toml]: https://github.com/cpburnz/minecraft-prometheus-exporter/blob/mc1.20.1/examples/prometheus_exporter-server.toml
[randombk]: https://github.com/randombk

repository: cpburnz/minecraft-prometheus-exporter

gha_language: Java

repo_name: cpburnz/minecraft-prometheus-exporter


text:
# LUC CS Academics Website

> The official Loyola University Chicago Computer Science academic offerings website

![GH Pages Deployment](https://github.com/LoyolaChicagoCS/coursedescriptions/actions/workflows/main.yml/badge.svg)

## Where is This Site Located?

This site can be found at https://academics.cs.luc.edu

## How to Contribute

### Filing Issues

If you spot any issues with the site, feel free to open an issue at https://github.com/LoyolaChicagoCS/coursedescriptions/issues

### Developing Using Sphinx

If you want to develop this site further follow the steps below:

#### Developing with VS Code Dev Container (Reccomended)

1. Install `Docker`
2. Install the [Remote - Containers](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers) VS Code extension
3. Open the project in the provided `dev container`
4. Run `pip install -r requirements.txt`

#### Developing without VS Code Dev Container

1. Install `Python 3.9+`
2. Run `pip install -r requirements.txt`

## Deploying Site to GitHub Pages

If you wish to deploy the site to GitHub Pages, a GitHub Action workflow has already been made to simplify this process.

1. Enable `Actions` on your fork of this project
2. Enable `GitHub Pages` on your fork of this project
3. If you use a different production branch name other than `main`, change the [workflow](.github/workflow/main.yml) to point to that branch

gha_language: Python


text:
# How STS works - high level

When a customer creates a STS cluster via the ROSA CLI it now queries an API for required IAM policies for the Y stream install. The API provided by Clusters Service watches for changes in [this](https://gitlab.cee.redhat.com/service/app-interface/-/blob/master/data/services/ocm/shared-resources/common.yml) file. When this file changes a new [ConfigMap](https://gitlab.cee.redhat.com/service/app-interface/-/blob/master/resources/services/ocm/aws-sts-policies.configmap.yaml) is templated which Clusters Service pods (OCM) will read.

## How to update STS

When policies and/or permissions need to be updated, execute the following.

1. Create a PR to this repo with the desired changes to the policies.
2. Once merged, Create an MR to [Cluster Services](https://gitlab.cee.redhat.com/service/app-interface/-/blob/master/data/services/ocm/shared-resources/common.yml#L19) to update the referenced commit hash to consume new changes.
3. Cluster service will restart pods automatically making policy changes available almost immediately.

repository: openshift/managed-cluster-config

repo_name: openshift/managed-cluster-config


text:
# EOS Secondary Indexes

## Overview
Using the multi-index table secondary indexes

This source code is for the Advanced EOS Series of blog posts found at; SteemIt | [Medium](https://medium.com/@mitchpierias/advanced-eos-series-part-3-secondary-indexes-1798f339cbb8)

## Deployment
> Assuming you've logged into your cleos wallet and created an account for the contract code.

```
eosiocpp -o ./timeline.wasm ./timeline.cpp
eosiocpp -g ./timeline.abi ./timeline.cpp
cleos set contract timeline . ./timeline.wasm ./timeline.abi
```

## Usage
```
cleos push action timeline inventory '["user"]' -p timeline
```

## timeline::post
Source: timeline.cpp

Posts a message for the specified user at the specified index

### Parameters

Input parameters:

 * `account_name` (user account_name)

 * `uin64_t` (message index)

 * `std::string` (message string)

Implied parameters:

 * `account_name` (name of the party signing the contract)

## timeline::get
Source: timeline.cpp

Gets the post at the specified index

### Parameters

Input parameters:

 * `uin64_t` (message index)

Implied parameters:

 * `account_name` (name of the party signing the contract)

## timeline::inventory
Source: timeline.cpp

Finds items for the specified user account prints to console.

### Parameters

Input parameters:

 * `account_name` (user account_name)

Implied parameters:

 * `account_name` (name of the party signing the contract)

repository: mozillo/advanced-eos-examples

repo_name: mozillo/advanced-eos-examples


text:
Arrays now have a `.find` and a `.findIndex`, which are really helpful. Some of my projects I don't even need to load in a utility library like lodash. Let's take a look at what `.find` and `.findIndex do`. A very common use case is when you have some data that comes back from an API.

Here I've got some data that comes back from an API. It's a posts array, where each item inside of the post is an object. Often we want to find an entire object inside of this array from an API:

```js
const posts = [
	{
		"code":"DFKJdodfi",
		"caption":"Dunno Dog'",
		"likes":42,
		"id":"328943249723",
		"display_src":"https://i.ytimg.com/vi/uFTcXaTezyA/hqdefault.jpg"
	},
	{
		"code":"BAIDfidslkaf",
		"caption":"Doggin' Around",
		"likes":40,
		"id":"2190828475324",
		"display_src":"https://i.ytimg.com/vi/uFTcXaTezyA/hqdefault.jpg"
	},
	{
		"code":"BAAJqdslkaf",
		"caption":"Strait Doggin'",
		"likes":50,
		"id":"2190823079324",
		"display_src":"https://i.ytimg.com/vi/uFTcXaTezyA/hqdefault.jpg"
	}
]
```

Now, because it's an object, we can't simply say:

```js
posts['BAAJqdslkaf']
```

Since it's an object. we don't have any keys to grab things from an array because an array is always indexed based.

What we actually need to do is use `.find`, which is a callback where you return `true` or `false` until you actually find what you're looking for. It's going to loop over every single post that we have, and I'm going to look for the specific one that I want.

```js
const post = posts.find(post => {
    console.log(post)
})
```
That will loop over the API's objects and return every post.

Then I want to say post.code, should give me all of the codes:

```js
const post = posts.find(post => {
    console.log(post.code)
})
```

Then we can look for our specific post:

```js
const post = posts.find(post => {
    console.log(post.code)
    if(post.code === 'BAAJqdslkaf') {
        return true
    }
    return false;
});
```

We should now have a variable called `post`, and that is the actual post from our object, so now we have the entire post and we can go ahead and grab the `caption`, or the `source`, or the `id` or the number of likes from that post.

This can be done a lot easier. This is just explicit, so you can see what's going on, but we can actually just use this:

```js
const post = posts.find(post => post.code === 'BAAJqdslkaf');
console.log(post);
```

One other improvement we can do is that it probably isn't hard coded like that. We probably want to put in a variable called code:

```js
const code = 'BAAJqdslkaf';
const post = posts.find(post => post.code === code);
console.log(post);
```

That is good for finding the actual thing inside of the array. If you want to find multiple things, how would you do that? You can use `.filter`, and that would give you an array of objects instead.

### .findIndex()

Next up, we have .findIndex. That's really helpful when you actually have the item you want, but you want to know where in the array it is actually.

Let's say we want to delete one of our posts, and all that we know is that we have the `id` or the `code` here. We need to find out where in this so we can delete it.

```js
const code = 'BAAJqdslkaf';
const postIndex = posts.findIndex((post) => {
	if(post.code === code) {
		return true;
	}
	return false;
});
console.log(postIndex);
```

Now we should be able to find what the `index` is of that post: It's the 3rd post in there.

We can refactor this right down:

```js
const code = 'BAAJqdslkaf';
const postIndex = posts.findIndex(post => post.code === code);
console.log(postIndex);
```

Why? Because we can only return as the `post.code` is equal to our code.

Now that we actually have the `index`, we could go ahead and just take that out of there. We're going to look at a `.spread` example in the future where it shows a great way, how do you just slice out one item from an array.

url: https://raw.githubusercontent.com/karlhorky/es6-articles/89ffe3fbc56f54798d761864f4e9f6b6cf2ca175/26 - Array. find() and .findIndex().md

path: /26 - Array. find() and .findIndex().md

filename: 26 - Array. find() and .findIndex().md


text:
# Recurrence

A simple library to handle recurring events.

[![Tests](https://github.com/fnando/recurrence/workflows/ruby-tests/badge.svg)](https://github.com/fnando/recurrence/actions?query=workflow%3ATests)
[![Gem](https://img.shields.io/gem/v/recurrence.svg)](https://rubygems.org/gems/recurrence)
[![Gem](https://img.shields.io/gem/dt/recurrence.svg)](https://rubygems.org/gems/recurrence)

## Installation

    gem install recurrence

## Usage

```ruby
require "rubygems"
require "recurrence"

# Daily
r = Recurrence.new(every: :day)
r = Recurrence.new(every: :day, interval: 9)
r = Recurrence.new(every: :day, repeat: 7)
r = Recurrence.daily(options = {})

# Weekly
r = Recurrence.new(every: :week, on: 5)
r = Recurrence.new(every: :week, on: :monday)
r = Recurrence.new(every: :week, on: [:monday, :friday])
r = Recurrence.new(every: :week, on: [:monday, :wednesday, :friday])
r = Recurrence.new(every: :week, on: :friday, interval: 2)
r = Recurrence.new(every: :week, on: :friday, repeat: 4)
r = Recurrence.weekly(on: :thursday)

# Monthly by month day
r = Recurrence.new(every: :month, on: 15)
r = Recurrence.new(every: :month, on: 31)
r = Recurrence.new(every: :month, on: 7, interval: 2)
r = Recurrence.new(every: :month, on: 7, interval: :monthly)
r = Recurrence.new(every: :month, on: 7, interval: :bimonthly)
r = Recurrence.new(every: :month, on: 7, repeat: 6)
r = Recurrence.monthly(on: 31)

# Monthly by week day
r = Recurrence.new(every: :month, on: :first, weekday: :sunday)
r = Recurrence.new(every: :month, on: :third, weekday: :monday)
r = Recurrence.new(every: :month, on: :last,  weekday: :friday)
r = Recurrence.new(every: :month, on: :last,  weekday: :friday, interval: 2)
r = Recurrence.new(every: :month, on: :last,  weekday: :friday, interval: :quarterly)
r = Recurrence.new(every: :month, on: :last,  weekday: :friday, interval: :semesterly)
r = Recurrence.new(every: :month, on: :last,  weekday: :friday, repeat: 3)

# Yearly
r = Recurrence.new(every: :year, on: [7, 4]) # => [month, day]
r = Recurrence.new(every: :year, on: [10, 31], interval: 3)
r = Recurrence.new(every: :year, on: [:jan, 31])
r = Recurrence.new(every: :year, on: [:january, 31])
r = Recurrence.new(every: :year, on: [10, 31], repeat: 3)
r = Recurrence.yearly(on: [:january, 31])

# Limit recurrence
# :starts defaults to Date.current
# :until defaults to 2037-12-31
r = Recurrence.new(every: :day, starts: Date.current)
r = Recurrence.new(every: :day, until: '2010-01-31')
r = Recurrence.new(every: :day, starts: Date.current, until: '2010-01-31')

# Generate a collection of events which always includes a final event with the given through date
# :through defaults to being unset
r = Recurrence.new(every: :day, through: '2010-01-31')
r = Recurrence.new(every: :day, starts: Date.current, through: '2010-01-31')

# Remove a date in the series on the given except date(s)
# :except defaults to being unset
r = Recurrence.new(every: :day, except: '2010-01-31')
r = Recurrence.new(every: :day, except: [Date.current, '2010-01-31'])

# Override the next date handler
r = Recurrence.new(every: :month, on: 1, handler: Proc.new { |day, month, year| raise("Date not allowed!") if year == 2011 && month == 12 && day == 31 })

# Shift the recurrences to maintain dates around boundaries (Jan 31 -> Feb 28 -> Mar 28)
r = Recurrence.new(every: :month, on: 31, shift: true)

# Getting an array with all events
r.events.each {|date| puts date.to_s }  # => Memoized array
r.events!.each {|date| puts date.to_s } # => reset items cache and re-execute it
r.events(starts: '2009-01-01').each {|date| puts date.to_s }
r.events(until: '2009-01-10').each {|date| puts date.to_s }
r.events(through: '2009-01-10').each {|date| puts date.to_s }
r.events(starts: '2009-01-05', until: '2009-01-10').each {|date| puts date.to_s }

# Iterating events
r.each { |date| puts date.to_s } # => Use items method
r.each! { |date| puts date.to_s } # => Use items! method

# Check if a date is included
r.include?(Date.current) # => true or false
r.include?('2008-09-21')

# Get next available date
r.next   # => Keep the original date object
r.next! # => Change the internal date object to the next available date
```

## Troubleshooting

If you're having problems because already have a class/module called Recurrence
that is conflicting with this gem, you can require the namespace and create a
class that inherits from `Recurrence_`.

```ruby
require "recurrence/namespace"

class RecurrentEvent < Recurrence_
end

r = RecurrentEvent.new(every: :day)
```

If you're using Rails/Bundler or something like that, remember to override the
`:require` option.

```ruby
# Gemfile
source "https://rubygems.org"

gem "recurrence", require: "recurrence/namespace"
```

## Maintainer

- Nando Vieira (http://nandovieira.com)

## Contributors

- https://github.com/fnando/recurrence/graphs/contributors

## License

(The MIT License)

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.

THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 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: fnando/recurrence

gha_language: Ruby

repo_name: fnando/recurrence


text:
# Demo

```hbs template
<EuiText @textAlign="center" @size="xl" @grow={{true}}>
  <div>
    <EuiTextAlign @textAlign="left">
      <h1>
        This is Heading One
      </h1>
    </EuiTextAlign>
    <EuiTextAlign @textAlign="right">
      <p>
        Far out in the uncharted
        <EuiTextColor @color="subdued">
          backwaters
        </EuiTextColor>
        of the
        <EuiTextColor @color="secondary">
          unfashionable
        </EuiTextColor>
        end of the
      western spiral arm of the Galaxy lies a small unregarded yellow sun. When
      suddenly some wild
        <EuiTextColor @color="warning">
          JavaScript code appeared!
        </EuiTextColor>
        {' '}
        <code>
          const whoa = "!"
        </code>
      </p>
    </EuiTextAlign>
    <pre>
      <code>
        const completelyUnexpected = "the audacity!";
      </code>
    </pre>
    <p>
      Orbiting this at a distance of roughly ninety-two million miles is an
      utterly insignificant little blue green planet whose ape- descended life
      forms are so amazingly primitive that they still think digital watches are
      a pretty neat idea.
    </p>
    <EuiTextAlign @textAlign="left">
      <ul>
        <li>
          <EuiTextColor>
            Default color
          </EuiTextColor>
        </li>
        <li>
          <EuiTextColor @color="subdued">
            Subdued color
          </EuiTextColor>
        </li>
        <li>
          <EuiTextColor @color="secondary">
            Secondary color
          </EuiTextColor>
        </li>
        <li>
          <EuiTextColor @color="accent">
            Accent color
          </EuiTextColor>
        </li>
        <li>
          <EuiTextColor @color="danger">
            Danger color
          </EuiTextColor>
        </li>
        <li>
          <EuiTextColor @color="warning">
            Warning color
          </EuiTextColor>
        </li>
        <li>
          <EuiTextColor @color="ghost">
            Ghost color
          </EuiTextColor>
        </li>
      </ul>
    </EuiTextAlign>
    <p>
      This planet has - or rather had - a problem, which was this: most of the
      people living on it were unhappy for pretty much of the time. Many
      solutions were suggested for this problem, but most of these were largely
      concerned with the movements of small green pieces of paper, which is odd
      because on the whole it was not the small green pieces of paper that were
      unhappy.
    </p>
    <h2>
      This is Heading Two
    </h2>
    <ol>
      <li>
        Number one
      </li>
      <li>
        Number two
      </li>
      <li>
        Dolphins again
      </li>
    </ol>
    <p>
      But the dog wasn’t lazy, it was just practicing mindfulness, so it
      had a greater sense of life-satisfaction than that fox with all its silly
      jumping.
    </p>
    <p>
      And from the fox’s perspective, life was full of hoops to jump{' '}
      <em>
        through
      </em>
      , low-hanging fruit to jump
      <em>
        for
      </em>
      , and dead car
      batteries to jump-
      <em>
        start
      </em>
      .
    </p>
    <h3>
      This is Heading Three
    </h3>
    <p>
      So it thought the dog was making a poor life choice by focusing so much on
      mindfulness. What if its car broke down?
    </p>
    <h4>
      This is Heading Four
    </h4>
    <p>
      So it thought the dog was making a poor life choice by focusing so much on
      mindfulness. What if its car broke down?
    </p>
    <h5>
      This is Heading Five
    </h5>
    <p>
      <small>
        So it thought the dog was making a poor life choice by focusing so much
        on mindfulness. What if its car broke down?
      </small>
    </p>
    <h6>
      This is Heading Six
    </h6>
    {{! <EuiHorizontalRule /> }}
    <dl>
      <dt>
        The Elder Scrolls: Morrowind
      </dt>
      <dd>
        The opening music alone evokes such strong memories.
      </dd>
      <dt>
        TIE Fighter
      </dt>
      <dd>
        The sequel to XWING, join the dark side and fly for the Emporer.
      </dd>
      <dt>
        Quake 2
      </dt>
      <dd>
        The game that made me drop out of college.
      </dd>
    </dl>
  </div>
</EuiText>
```

repository: gwak/ember-eui

repo_name: gwak/ember-eui


text:
# pick-mobile

This is the front-end of our mobile app, Pick. It was built in AngularJS and Ionic, and it provides an Android and iOS compatible user interface. The back end is built in Rails 4, and uses a zipcode API and Soundcloud's API for location filtering and user profile information. The back-end was tested with RSpec.

The app allows local musicians to connect with one another based on musical talents, preferred genre, and location.

Users are shown a shuffled deck of user profile 'cards' based on their search criteria. Profile cards have users' genres, musical talents, and Soundcloud info on them.

If a user swipes right on a card, the app records that as a sign of interest. If they swipe left, the app places the card back in the deck in case the user changes their mind later on.

When two users swipe right on each other, they can see each others' profiles in the 'Picks' tab. From here, users can view the Soundcloud profiles of their 'Picks' and send messages to each other using Soundcloud.

The app is not currently deployed to the Google Play Store or IOS App Store, but will be in the near future!

![Launch](./resources/readme-images/Launch-Optimized.png)

> The launch page upon opening the app

![Profile](./resources/readme-images/Profile-Optimized.png)

> User's profile page

![Menu](./resources/readme-images/Menu-Optimized.png)

> The pick icon doubles as the menu button.

![EditProfile](./resources/readme-images/EditProfile-Optimized.png)

> The same user's profile editor

![EditRoles](./resources/readme-images/EditRoles-Optimized.png)

> Editing user's roles with prepopulated checkboxes

![EditSearch](./resources/readme-images/EditSearch-Optimized.png)

> Editing roles we're looking for (similar to above)

![Soundcloud](./resources/readme-images/Soundcloud-Optimized.png)

> The soundcloud profile attatched to the user

![Start](./resources/readme-images/Start-Optimized.png)

> The first card in our deck of potential musicians based on our search criteria and location

![Left](./resources/readme-images/Left-Optimized.png)

> We can swipe left to pass

![Right](./resources/readme-images/Right-Optimized.png)

> And right to approve

![Picks](./resources/readme-images/Picks-Optimized.png)

> When both parties have swiped right (Approved) we can see the match made here