text:
# Step 0 - Prerequisite

> Approximate time: 30-35 minutes

Before we get started with this lab, we need to setup the Raspberry Pi with Rasbian. The folks at [Raspberry Pi Foundation](https://raspberrypi.org) are pretty good with keeping their documentation up to date. The community support surrounding the Pi is also amazing. I've documented the process below, and also linked the respective articles on the foundation's website. It should be good to get you started.

> If you have landed on this repository from an email about the session, then just follow this section, and keep your Pi ready for the hands on lab. If you want to follow ahead on your own, you are more than welcome. Also refer the official documentation, **[Getting Started with AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/iot-gs.html)** for any unanswered questions you might have.

The whole setup should take under 45 minutes, with the longest time spent in downloading the Rasbian image and flashing the SD card.

For this lab a Raspberry Pi 3 B+ or 4 (1 GB or higher) is recommended. You can also use a Pi Zero W, but you'll have to have male headers attached on the GPIO pins.

### Where to buy a Raspberry Pi ?

If this is your first Pi ever, I recommended buying a kit. Even though Pi Zero seems cheaper and will work for this lab, **the regular Pi 4, more powerful and can be repurposed for a lot of different projects**. Here are [some projects](https://projects.raspberrypi.org/en/) you can do with the pi after this lab.

 * https://www.amazon.com
 * https://www.adafruit.com
 * https://www.element14.com
 * https://www.microcenter.com

#### Recommended Kits

> Check with your people manager if they are ready to reimburse the cost of the pi.

Regular Raspberry Pi is just a small single-board computer, it does not come with a power adapater or microSD card. That's where kits come in handy.

 * **[Pi + Power + Case + 32GB microSD card + Micro HDMI to HDMI Cable = $79.99](https://smile.amazon.com/CanaKit-Raspberry-4GB-Starter-Kit/dp/B07V4G63M1/) ~ Recommended**
 * [Pi + Power + Case + Micro HDMI to HDMI Cable = $59.99](https://smile.amazon.com/CanaKit-Raspberry-4GB-Basic-Starter/dp/B07VWBHPMM/) (if you already have a microSD card)

#### À la carte (Build your own kit)
You can also build your own kit using components you might already have. I've tried to list out needed components. All links below are from https://www.microcenter.com. Amazon is more expensive.

| Component | Substitute|Cost|
|-----------|------------|---:|
| [Raspberry Pi 4](https://www.microcenter.com/product/608166/raspberry-pi-4-model-b---1gb-ddr4)  | You can use a Raspberry Pi 3B+ | $35  |
| [Power Suppy](https://www.microcenter.com/product/608169/-raspberry-pi-4-official-15w-power-supply-us---white)  | Fast Charger 15W (5V/3A)
  - If you have any mobile phone fast charger and a USB-C cable, check the rating, it it says 5V~3A, it should be good.
 - Power hubs are generally restricted to 2.5A, so not a great option.  |$10   |
| [microSD card](https://www.microcenter.com/product/486146/-micro-center-16gb-microsdhc-class-10-flash-memory-card)  |  Any 8GB class 10 microSD card should do, format before using. |$4 |

If you already have a power supply & microSD card, you should be good with only buying a pi.

### Softwares

We are going to transfer files between the Pi and your local machine, and also test the API. Please install the softwares listed below.
 * `ssh` or [putty](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html)
 * `scp` or [WinSCP](https://winscp.net/eng/index.php)
 * `curl` or [Postman](https://www.getpostman.com/downloads/)

> `ssh`, `scp` & `curl` are present on Mac and Linux by default. If you have git bash on windows, they might be installed too, please verify.

## Preparing the Pi

We assume by now, you have your trusty raspberry pi with you.

Follow the steps below, links to original source material is also provided where needed. If this documentation feels dated, or inadequate, refer the source links.

### Setup SD Card

Pick a **Class 10 microSD** card with a minimum **8GB** capacity.

Since most IoT devices are remote, using the Lite (headless) version is recommended. It is smaller and uses less resources, without the GUI overhead.

 * Download [Rasbian Buster Lite](https://www.raspberrypi.org/downloads/raspbian/)
 * Download the latest version of [balenaEtcher](https://www.balena.io/etcher/) for your operating system and install it.

#### Flash SD card
 * Connect an SD card reader with the SD card inside.
 * Open balenaEtcher and select from your hard drive the Raspberry Pi `.img` file you wish to write to the SD card.
 * Select the SD card you wish to write your image to.
 * Review your selections and click **'Flash!'** to begin writing data to the SD card.
 * Once complete, etcher might auto eject the card, reinsert the card and move to the next step.

#### Enable SSH

[SSH access is disabled by default](https://www.raspberrypi.org/documentation/remote-access/ssh/README.md)

For headless setup, SSH can be enabled by placing a new file named `ssh`, without any extension, onto the `boot` partition of the SD card from another computer. When the Pi boots, it looks for the `ssh` file. If it is found, SSH is enabled and the file is deleted. The content of the file does not matter; it could contain text, or nothing at all.

If you have loaded Raspbian onto a blank SD card, you will have two partitions. The first one, which is the smaller one, is the `boot` partition. Place the file into this one.

Using command line, `cd` into the folder, `touch ssh` to create a new file.

This method also works for a GUI based Raspbian.

> **WARNING:** Since you are enabling SSH, please ensure you change the default password, else the pi is vunerable on public networks. More on how to do this below.

#### Setup WiFi on `/boot` before first boot

Setting up [wireless networking](https://www.raspberrypi.org/documentation/configuration/wireless/headless.md) on the pi.

You will need to define a `wpa_supplicant.conf` file for your particular wireless network. Put this file in the `/boot` folder (same location you put the `ssh` file), and when the Pi first boots, it will copy the file to the correct location in the Linux root file system and use those settings to start up wireless networking.

##### `wpa_supplicant.conf` file:

```
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
country=US

# Leave this for the lab.
network={
  ssid="J0hnny5"
  psk="Short$ircuit"
  id_str="lab"
}

# Use this for your home network, when preparing the pi
network={
  ssid="<HOME_NETWORK_NAME>"
  psk="<HOME_PASSWORD>"
  id_str="home"
}
```

> Substitute `<HOME_NETWORK_NAME>` & `<HOME_PASSWORD>`, with your current accessible local network SSID and password.

Keep both the networks configurations. They are set in order of preference, if the first is not found, it'll connect to the next available one.

### Boot, Identify Pi on network

Insert the SD card in the pi. Plug in the power cable into your pi, and **wait 1 minute** after boot to start looking for the pi on the network

#### Login to Router and identify

 * In a web browser navigate to your router's IP address e.g. `http://<IP_ADDRESS>`,
 * Log in to the router admin panel using your router's credentials.
 * Browse to the list of connected devices or similar (all routers are different), and you should see some devices you recognise.
 * Figure out which is your Raspberry Pi. Also note the connection type; if your Pi is connected with a wire there should be fewer devices to choose from.

#### Resolving `raspberrypi.local` with mDNS

 * Open terminal
 * Type `ping raspberrypi.local`
 * If the Raspberry Pi is reachable, `ping` will show its IP address
```
   PING raspberrypi.local (<IP_ADDRESS>): 56 data bytes
   64 bytes from <IP_ADDRESS>: icmp_seq=0 ttl=255 time=2.618 ms
```

> We'll be changing the `hostname` of your pi later. In a shared network, where all are called `raspberrypi`, you'll not be able to identify your pi.

A detailed write up for [identifing your IP](https://www.raspberrypi.org/documentation/remote-access/ip-address.md) is documented on the offical website.

### Use `raspi-config` to change default configuration

Once you know the IP address, login using `ssh` or `putty`. The default user on Raspbian is `pi` with the password `raspberry`.

```
 ssh<EMAIL_ADDRESS> password:
```

You'll be shown `raspi-config` on first boot, you can also run it from the command line using

```
sudo raspi-config
```
![raspi-screenshot](../assets/raspi-config.png)

You should see a blue screen with options in a grey box in the center. [`raspi-config`](https://www.raspberrypi.org/documentation/configuration/raspi-config.md) aims to provide the functionality to make the most common configuration changes.

### Select 4. Localization Options under `raspi-config`

#### Change Locale
Change locale to your local locale `en_US.UTF-8 UTF-8`.

#### Change Time Zone
Select your local time zone, starting with the region, e.g. `Americas`, then selecting a city, e.g. `New_York`. Type a letter to skip down the list to that point in the alphabet.

#### Change keyboard layout

This option opens another menu which allows you to select your keyboard layout. It will take a long time to display while it reads all the keyboard types. Changes usually take effect immediately, but may require a reboot.

Choose `US` keyboard, the default is UK and there are character set differences which can cause issues later.

#### Change WiFi Country

This option sets the country code for your WiFi network. e.g. Change it to `US` (it might already be done as part of `wpa_supplicant` configuration)

> After this step a reboot is recommended, before moving on to the last configuration change. This is due to keyboard layout change. After reboot the IP should still be the same.

### Select 2. Network Options under `raspi-config`

#### Change `hostname`
Set the visible name for this Pi on a network. This is **VERY IMPORTANT**, else you'll not be able to identify your pi in a shared network, especially if all are still called `raspberrypi`. Ensure you make note of the `hostname`, so after reboot you can search for it again, and connect to it.

> Vist [https://videogamena.me/](https://videogamena.me/) for fun server names. Just don't forget what you set it to be!

#### Change Password

The default user on Raspbian is `pi` with the password `raspberry`. You should change that to something more secure.

## Install & Upgrade libraries

```
sudo apt-get install python3-gpiozero vim python3-pip
```

### `gpizero`

A simple interface to GPIO devices with Raspberry Pi. Component interfaces are provided to allow a frictionless way to get started with physical computing. The library includes interfaces to many simple everyday components, as well as some more complex things like sensors, analogue-to-digital converters, full colour LEDs, robotics kits and more.

### `pip3`

Not all Python packages are available in the Raspbian archives, and those that are can sometimes be out-of-date. If you can't find a suitable version in the Raspbian archives, you can install packages from the Python Package Index (PyPI). To do so, use the pip tool.

### `vim`

`vi` is installed, but `vim` is easier to work with.

For all other editors. Please refer: [this link](https://xkcd.com/378/)

![vim](https://imgs.xkcd.com/comics/real_programmers.png)

### aws-iot-device-sdk-python

> Install `python3-pip` first

```
pip3 install AWSIoTPythonSDK
```

### System upgrade!
Now that you have your pi up and running, it is a good idea to update the system

```
sudo apt-get update
sudo apt-get full-upgrade
```
All the basic tools needed to get you pi for the lab are now set!

## Next --> [01 - Setup Hardware](../01-hardware)
This concludes prepping your pi. Let do some hardware wiring...

repository: varunmehta/dive-into-iot

repo_name: varunmehta/dive-into-iot


text:
---
title: Targeting your Adobe Campaign
description: Setting up segmentation includes creating segments, a brand, campaign, and experiences.
uuid: 520cd006-0aa8-43f3-b754-efb7397bb92f
contentOwner: User
products: SG_EXPERIENCEMANAGER/6.5/SITES
topic-tags: personalization
content-type: reference
discoiquuid: bbc2aac9-ccf1-40c3-be4f-d59c2d0d8a6c
exl-id: e56986b2-397e-4802-992b-05a9ea7b2e36
---
# Targeting your Adobe Campaign{#targeting-your-adobe-campaign}

To target your Adobe Campaign newsletter, you need to first set up segmentation, which is only available in the Classic UI. After that, you can create targeted experiences for Adobe Campaign.

## Setting up segmentation in AEM {#setting-up-segmentation-in-aem}

Setting up segmentation includes creating segments, a brand, campaign, and experiences. You can only create a segment in the classic UI. You can create brands, campaigns, and experiences in the touch-enabled UI.

>[!NOTE]
>
>Segment ID needs to be mapped to the one on the Adobe Campaign side.

### Creating Segments {#creating-segments}

To create segments:

1. Open the [segmentation console](http://localhost:4502/miscadmin#/etc/segmentation) at **<host>:<port>/miscadmin#/etc/segmentation**.
1. Create a new page and enter a title - for example, **AC Segments** - and select the **Segment (Adobe Campaign)** template.
1. Select the created page in the tree view on the left-hand side.
1. Create a segment, for example targeting male users, by creating a new page under the segment you created called Male and select the **Segment (Adobe Campaign)** template.
1. Open the created segment page and drag and drop a **Segment ID** from the sidekick onto the page.
1. Double-click the trait, enter the ID representing in this case, the male segment defined in Adobe Campaign - for example, **MALE** - and click **OK**. The following message should appear: `targetData.segmentCode == "MALE"`
1. Repeat the steps for another segment, for example, a segment targeting female users.

### Creating a Brand {#creating-a-brand}

To create a brand:

1. In **Sites**, navigate to the **Campaigns** folder (for example in We.Retail).
1. Click **Create Page** and enter a title for the page, for example We.Retail Brand and select the **Brand** template.

### Creating a Campaign {#creating-a-campaign}

To create a campaign:

1. Open the **Brand** page you just created.
1. Click **Create Page** and enter a title for your page, for example, We.Retail Campaign, and select the **Campaign** template and click **Create**.

### Creating Experiences {#creating-experiences}

To create experiences for segments:

1.
1. Create experiences for your segments by clicking **Create Page** and entering a title for your page, for example, Male as you are creating an experience for the Male segment, and select the **Experience** template.
1. Open the created Experience page.
1. Click **Edit**, then below Segments click **Add Item**.
1. Enter the path to the male segment, for example `/etc/segmentation/ac-segments/male` and click **OK**. The following message should appear: *Experience is targeted at: Male*
1. Repeat the previous steps to create an experience for all segments, for example the female target.

## Creating a newsletter with targeted content {#creating-a-newsletter-with-targeted-content}

After you have created segments, a brand, a campaign, and an experience, you can create a newsletter with targeted content. After creating the experience, you link experiences to your segments.

You can create the newsletter with targeted content in both the touch-enabled and classic user interface. This document describes the procedure for the touch-enabled UI.

To create a newsletter with targeted content:

1. Create a newsletter with targeted content: Below Email Campaigns in Geometrixx Outdoors, click or tap **Create** > **Page**, and select one of the Adobe Campaign Mail templates.

   >[!NOTE]
   >
   >[Email samples are only available in Geometrixx](/help/sites-developing/we-retail.md#weretail). Please download sample Geometrixx content from Package Share.

1. In the newsletter, add a Text and Personalization component.
1. Add text into the Text and Personalization component, such as "This is the default."
1. Click the arrow next to **Edit** and select **Targeting**.
1. Select your brand from the Brand drop-down menu and select your Campaign. (This is the brand and campaign you created earlier).
1. Click **Start Targeting**. You see your segments appear in the Audiences area. The default experience is used if none of the defined segments match.

   >[!NOTE]
   >
   >By default, the email samples included with AEM use Adobe Campaign as the targeting engine. For custom newsletters, you may need to select Adobe Campaign as the targeting engine. When targeting, tap or click + in the toolbar, enter a title for the new activity, and select **Adobe Campaign** as the targeting engine.

1. Click **Default** and then the Text and Personalization component you added and you see the Bullseye with an arrow in it. Click the icon to target this component.

   ![chlimage_1-165](assets/chlimage_1-165.png)

1. Navigate to another segment (Male), and click **Add offer** and click the plus icon +. Then edit the offer.
1. Navigate to another segment (Female) and click **Add offer** and the plus icon +. Then edit this offer.
1. Click **Next** to see Mapping, then click **Next** to see Settings, which does not apply to Adobe Campaign, and click **Save**.

   AEM automatically generates the correct targeting code for Adobe Campaign when the content is used in a delivery inside Adobe Campaign

1. In Adobe Campaign, create your delivery - select **Email delivery with AEM content** and select the local AEM account, as appropriate and confirm your changes.

   In the HTML view, the different experiences of targeted components are enclosed in Adobe Campaign targeting code.

   ![chlimage_1-166](assets/chlimage_1-166.png)

   >[!NOTE]
   >
   >If you also set the segments up in Adobe Campaign, clicking **Preview** will show you the experiences for each segment.

license: MIT

branch_name: refs/heads/main

extension: md

gha_language: Groovy

gha_license_id: MIT

license_type: permissive


text:
---
title: Pacta sunt servanda
date: '2012-12-06'
description: Introductory blogpost
categories: ['meta']
tags: ['introduction','english']

---

I've been thinking for some time about setting up a blog now.

There have been quite some opportunities where I've wanted to share some insights or interesting thoughts with the world and where I thought — *if only I had a blog, I'd write about this.* Only I didn't. Until now.

I do have quite a number of interests - linguistics, programming, music, politics, you name it; I hope this doesn't put off people who are only interested in the one or the other aspect. I'll group the blog entries into categories in case this helps.

I'm not yet quite decided on the language issue. English is undoubtedly going to reach a larger audience; the question is whether I do have such an international audience at all; most of my friends speak German and not all of them are that comfortable with reading English. I will probably decide on a case-by-case basis in which language to blog.

This is going to be new territory for me, but I'll try to do my best.

**P.S.** I chose the title of this entry solely out of love for pretentious Latin phrases.

**P.P.S.** The blogging engine I'm using (and, coincidentally, the hoster — at least for the time being) is the nice, very geeky [ruhoh](http://ruhoh.com) platform. It works as easily as editing my entries with [vim](http://www.vim.org) using [markdown](http://daringfireball.net/projects/markdown) and pushing the changes to [github](https://github.com).

branch_name: refs/heads/master


text:
Blue Button Generate
====================

Blue Button CCDA Generator

[![NPM](https://nodei.co/npm/@amida-tech/blue-button-generate.png)](https://nodei.co/npm/@amida-tech/blue-button-generate/)

blue-button-generate is a module to generate CCDA files from JSON data.  Currently it only supports [blue-button](https://github.com/amida-tech/blue-button) JSON data model.

## Usage

``` javascript
var fs = require('fs');
var bb = require('@amida-tech/blue-button');
var bbg = require('@amida-tech/blue-button-generate');

var xmlString = fs.readFileSync('test/fixtures/files/ccda_xml/CCD_1.xml', 'utf-8');
var record = bb.parseString(xmlString);

// ...
// changes to record
// ...

// get back xml as text
var updatedXmlString = bbg.generateCCD(record);

```

## Implementation

blue-button-generate uses javascript template objects for implementation.  Each template in CCDA is represented with an object. As an example Reaction Observation object is shown
``` javascript
var reactionObservation = exports.reactionObservation = {
    key: "observation",
    attributes: {
        "classCode": "OBS",
        "moodCode": "EVN"
    },
    content: [
        fieldLevel.templateId("2.16.840.1.1138<IP_ADDRESS>.4.9"),
        fieldLevel.id,
        fieldLevel.nullFlavor("code"),
        fieldLevel.text(leafLevel.sameReference("reaction")),
        fieldLevel.statusCodeCompleted,
        fieldLevel.effectiveTime, {
            key: "value",
            attributes: [
                leafLevel.typeCD,
                leafLevel.code
            ],
            dataKey: 'reaction',
            existsWhen: condition.codeOrDisplayname,
            required: true
        }, {
            key: "entryRelationship",
            attributes: {
                "typeCode": "SUBJ",
                "inversionInd": "true"
            },
            content: severityObservation,
            existsWhen: condition.keyExists('severity')
        }
    ]
};
```

This template is internally used with a call
```  javascript
js2xml.update(xmlDoc, input, context, reactionObservation);
```
where `xmlDoc` is the parent xml document (Allergy Intolerance Observation) and `input` is the immediate parent of [bluebutton.js](https://github.com/blue-button/bluebutton.js) object that describes Reaction Observation.  `context` is internally used for indices in text references.

### Motivation

This approach is an alternative to direct programming or text based templates such as in [bluebutton.js](https://github.com/blue-button/bluebutton.js) and is motivated by the following
* Each template directly follows the actual specification.  One can easily match each node in the template to the actual statements in the specification.
* Individual templates can be tested independently without any additional flags or programming.
* Required elements are specified in the template and get `nullFlavor` automatically when no data exists.
* No coding required to add new templates.
* It is also a step in the right direction for the possible future directions
 * Factoring out data model dependencies so that blue-button](https://github.com/amida-tech/blue-button) data model changes or other data models can be accomodated more easily
 * Automatic generation of templates from [blue-button](https://github.com/amida-tech/blue-button) like CCDA parsers.

### Template Structure

The following are the properties of the templates
* `key`: This is the name for the xml element.
* `attributes`: This describes the attributes of the element.  `attributes` can be an object of with `key` and `value` pairs for each attribute or it can be an array of such objects.  Each attribute object or can be a function with `input` argument that returns attributes.
* `text`: This is a function with `input` attribute that returns text value of the element.
* `content`: This is an array of other templates that describe the children of the element.  For a single child an object can be used.
* `dataKey`: This is the property of `input` that serves as the data for the template.
* `required`: This identifies if template is required or not.  If template is required and there is not value in the `input` a `nullFlavor` node is created.
* `dataTransform`: This is a function to transform the input.
* `existWhen`: This is a boolean function with `input` argument to describe it the elements should exists or not.

repository: amida-tech/blue-button-generate

gha_language: JavaScript

repo_name: amida-tech/blue-button-generate


text:
# Phapi
Phapi is a PHP based framework aiming at rapid and simplified API development as well as focusing at performance and keeping the code base small and simple.

### What's new in version 2
This version is [PSR-7 Http Message]() compliant and takes full advantage of that fact by relying on [middleware](https://github.com/phapi/pipeline) for almost every aspect of the framework. Error handling, routing, responding to the client as well as many other functions are all in fact middleware.

There is an [Dependency injection container](https://github.com/phapi/di) that's mainly used for configuration. Each endpoint has access to both the container as well as the [https://github.com/phapi/http](request and response) objects.

## Install with configuration (recommended)
The [phapi/phapi-configuration](https://github.com/phapi/phapi-configuration) project includes everything you need to set up a simple hello world example. **[Download the latest version](https://github.com/phapi/phapi-configuration/archive/master.zip)** of the package and extract it to an empty directory. This zip file includes all the default configuration. After you've extracted the zip file you need to run composer:

```bash
$ composer install
```

## Installation via Composer
Install the Phapi framework via [Packagist](https://packagist.org) and [Composer](https://getcomposer.org).

```shell
$ composer require phapi/phapi-framework:2.*
```

## Configuration
See the [documentation](http://phapi.github.io/docs/started/configuration/) for more information about configuration options and how to add extra packages.

## Documentation
The documentation can be found at [http://phapi.github.io/](http://phapi.github.io/).

## License
Phapi is licensed under the MIT License - see the [license.md](https://github.com/phapi/phapi-framework/blob/master/license.md) file for details

## Contribute
Contribution, bug fixes etc are [always welcome](https://github.com/phapi/phapi-framework/issues/new).

repository: phapi/phapi-framework

repo_name: phapi/phapi-framework


text:
# MobDevLib

[![CI Status](http://img.shields.io/travis/Mob_Developer/MobDevLib.svg?style=flat)](https://travis-ci.org/Mob_Developer/MobDevLib)
[![Version](https://img.shields.io/cocoapods/v/MobDevLib.svg?style=flat)](http://cocoapods.org/pods/MobDevLib)
[![License](https://img.shields.io/cocoapods/l/MobDevLib.svg?style=flat)](http://cocoapods.org/pods/MobDevLib)
[![Platform](https://img.shields.io/cocoapods/p/MobDevLib.svg?style=flat)](http://cocoapods.org/pods/MobDevLib)

## Example

To run the example project, clone the repo, and run `pod install` from the Example directory first.

## Requirements

## Installation

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

```ruby
pod "MobDevLib"
```

## Author

Mob_Developer<EMAIL_ADDRESS>
## License

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

repository: runryan/MobDevLib

repo_name: runryan/MobDevLib


text:
# Certificate Request Generator

This repository contains a single script which allows you to create a Certificate Request which can then be signed
by a CA produced by the project located here <TODO - ADD URL>:

This generator allows the creation of CN certificates as well as multi-domain certificates (SAN).

Wildcards are supported for both CN and SAN.

# Create a Certificate Request

1. Execute this command `./createRequest.sh <certName>` and answer the prompts.  Note that if you use SAN then the first SAN MUST be equal to the CN to be compatible with most SSL validators.
2. A tgz file is produced.  This file contains only the requests itself which is non-sensitive information (IE. Doesn't contain the private key).
3. The request can be signed by using the CA utilities located here : <TODO - ADD URL>.
4. Signing the request will produce the certificate and the chain.
5. Private key that goes with the certificate was produced in step 1 and is located in <certName/private/<certName>.key

repository: dickeyf/cert-requests

repo_name: dickeyf/cert-requests


text:
Hydroconf

Effortless configuration management for Rust. Keep your apps hydrated!

Hydroconf is a configuration management library for Rust, based on [config-rs]
and heavily inspired by Python's [dynaconf].

# Features
* Inspired by the [12-factor] configuration principles
* Effective separation of sensitive information (secrets)
* Layered system for multi environments (e.g. development, staging, production,
  etc.)
* Sane defaults, with a 1-line configuration loading
* Read from [JSON], [TOML], [YAML], [HJSON], [INI] files

The [config-rs] library is a great building block, but it does not provide a
default mechanism to load configuration and merge secrets, while keeping the
different environments separated. Hydroconf fills this gap.

[config-rs]: https://github.com/mehcode/config-rs
[dynaconf]: https://github.com/rochacbruno/dynaconf
[12-factor]: https://12factor.net/config
[JSON]: https://github.com/serde-rs/json
[TOML]: https://github.com/toml-lang/toml
[YAML]: https://github.com/chyh1990/yaml-rust
[HJSON]: https://github.com/hjson/hjson-rust
[INI]: https://github.com/zonyitoo/rust-ini

# Quickstart

Suppose you have the following file structure:

```
├── config
│   ├── .secrets.toml
│   └── settings.toml
└── your-executable
```

`settings.toml`:

```toml
[default]
pg.port = 5432
pg.host = 'localhost'

[production]
pg.host = 'db-0'
```

`.secrets.toml`:

```toml
[default]
pg.password = 'a password'

[production]
pg.password = 'a strong password'
```

Then, in your executable source (make sure to add `serde = { version = "1.0",
features = ["derive"] }` to your dependencies):

```rust
use serde::Deserialize;
use hydroconf::Hydroconf;

#[derive(Debug, Deserialize)]
struct Config {
    pg: PostgresConfig,
}

#[derive(Debug, Deserialize)]
struct PostgresConfig {
    host: String,
    port: u16,
    password: String,
}

fn main() {
    let conf: Config = match Hydroconf::default().hydrate() {
        Ok(c) => c,
        Err(e) => {
            println!("could not read configuration: {:#?}", e);
            std::process::exit(1);
        }
    };

    println!("{:#?}", conf);
}
```

If you compile and execute the program (making sure the executable is in the
same directory where the `config` directory is), you will see the following:

```sh
$ ./your-executable
Config {
    pg: PostgresConfig {
        host: "localhost",
        port: 5432,
        password: "a password"
    }
}
```

Hydroconf will select the settings in the `[default]` table by default. If you
set `ENV_FOR_HYDRO` to `production`, Hydroconf will overwrite them with the
production ones:

```sh
$ ENV_FOR_HYDRO=production ./your-executable
Config {
    pg: PostgresConfig {
        host: "db-0",
        port: 5432,
        password: "a strong password"
    }
}
```

Settings can always be overridden with environment variables:

```bash
$ HYDRO_PG__PASSWORD="an even stronger password" ./your-executable
Config {
    pg: PostgresConfig {
        host: "localhost",
        port: 5432,
        password: "an even stronger password"
    }
}
```

The description of all Hydroconf configuration options and how the program
configuration is loaded can be found in the
[documentation](https://docs.rs/hydroconf).

    Logo made by Freepik from www.flaticon.com

license: ISC

repository: pablogore/hydroconf

repo_name: pablogore/hydroconf


text:
# Analyzing Used Car Data from Germany

## By Danikelle Saraiva

This project was developed for the Data Science Academy, in order to demonstrate expertise with Exploratory Data Analysis and Explanatory Data Analysis.

## Dataset

The dataset was taken from the kaggle and contains details of the used cars in Germany that are for sale on ebay.

## Project Status:

In development :warning:

## License
This project is licensed under the MIT License - see the [LICENSE](https://github.com/dnksaraiva/used-cars-data-analysis/blob/main/LICENSE) file for details.

repository: dnksaraiva/used-cars-data-analysis

repo_name: dnksaraiva/used-cars-data-analysis


text:
### [CVE-2023-28762](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2023-28762)
![](https://img.shields.io/static/v1?label=Product&message=SAP%20BusinessObjects%20Intelligence%20Platform&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=%3D%20420%20&color=brighgreen)
![](https://img.shields.io/static/v1?label=Vulnerability&message=CWE-200%3A%20Exposure%20of%20Sensitive%20Information%20to%20an%20Unauthorized%20Actor&color=brighgreen)

### Description

SAP BusinessObjects Business Intelligence Platform - versions 420, 430, allows an authenticated attacker with administrator privileges to get the login token of any logged-in BI user over the network without any user interaction. The attacker can impersonate any user on the platform resulting into accessing and modifying data. The attacker can also make the system partially or entirely unavailable.

### POC

#### Reference
- https://www.sap.com/documents/2022/02/fa865ea4-167e-0010-bca6-c68f7e60039b.html

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

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
The ANTLR grammar file could be used to build parsers in different programming languages.

For details about ANTLR, see here: https://github.com/antlr/antlr4/blob/master/doc/getting-started.md

More details on how to write your own HIPML application based on the ANTLR grammar will be shared later.

repository: vitrayatech/hipml

repo_name: vitrayatech/hipml


text:
---
layout: post
title: Glass
---

It all started with the most epic demo ever:

Live video feed through thin glasses! *In the air!*

It is not easy to get Glass in France because Google sells it sparingly, and in the US only.
The equation was set:
> device from the future + scarcity = gadget-loving-geek getting really excited

I can haz Glass?
================

I now own a Google Glass (by the way, please don't say "glasses", it has only one glass).
![me with glass](/public/img/sylvain_with_glass.jpg)

Being a so-called "Glass Explorer", I chose to wear it all day, every day.
I wear it at work but also outside, in the streets, in the subway, in stores, at home.

> Basically, if I'm awake, I wear Glass.

You look silly with it!
=======================

I have seen different reactions:

- Some are curious and ask me to try it
- Some laugh at me, thinking I'm ridiculous with such a big frame on the side and no glass at all, besides the big block in front of my right eye
- Some gawk at me, not knowing what it is
- Some stare angrily at me, mostly being afraid of being filmed

Can you think of another device that can spark such a variety of reactions, from enthusiastic to defiant? How cool is that?
And it's really exciting to be part of the future-shaping, society-redefining community of Glass Explorers. Oh, and did I mention that you can take pictures of your cat with it?

What Glass can't do?
====================

Let me debunk some myths about Glass:

- It can't record everything you do continuously. The battery is just not capable of it.
- It can't do facial recognition. Google forbids this kind of app. Of course, there will be unofficial apps that will do it anyways.
- I can't see you naked through it. Just like there is no such thing as a "naked scanner" you can download for 1€ on your phone. Guys, seriously!

So, what can you do with Glass?
===============================

Glass is not always on. You have to activate it to see something on the screen.
You then see a screen showing the time. There you can either navigate on your timeline and see what you have done with Glass in the past, or you can speak an order. Yes, Glass is able to do voice recognition (english only for the moment). So you can say "take a picture" and *voilà*, it just took a picture of what you're looking at. You can do a google search, and the most relevant result will be printed on the screen AND spoken in your ear.

Here is an incomplete list of what you can do:

- Take a picture, in a fraction of time you would need to pull your smartphone out of your pocket.
- Record a video. In my personal experience, you can shoot about 20 minutes of video before the battery runs out.
- Search via Google. Just speak what you are looking for and a nice female voice will read you the answer. It tends to give a wikipedia abstract often.
- Make a phone call. Glass is connected to your smartphone via Bluetooth, so it becomes a hands-free headset. You can initiate or answer a call from Glass, no need to take your phone out of your pocket. And you can see who is calling, of course.
- Send a message (hangout, SMS, tweet, Facebook status). Voice recognition again, so english only, but it works well.
- Receive notifications of a new email, SMS, tweet or Facebook message. You hear a sound, and you have to activate Glass to see the notification on the screen.
- Get directions via the GPS you have in your phone. Speak a destination and the step-by-step directions are shown on the screen. Battery killer.
- Listen to music. You have to have a Google Play Music account and you hear it on the right ear only. Not the best experience.
- Translate text. One of the apps that really impressed me is [World Lens](http://questvisual.com). It replaces a text with its translation *in place*. Really cool wow effect when demoing. (it also exists on Android and iOS)

But, what about your phone?
===========================

I have a the [best phone](https://play.google.com/store/devices/details/Nexus_5_32GB_Black?id=nexus_5_black_32gb) on Earth.

Some sceptics ask me what I can do with Glass that I can't with a phone. My answer is this:

> Try to shoot a video of a ride on bike with your daughter with a smartphone.

Glass is about not getting in the way, and being able to fully live an experience while recording and sharing it with others.

gha_language: CSS


text:
## xLiMe Showcase

> A demonstrator showing the capabilities of the [xLiMe](http://xlime.eu) platform

## Building and running

To run the application locally, you need to configure the `app.baseXlimeServiceUrl` value in `app/script/app.js`. Then run:

  gulp serve

This will start a html server with your app and launch a browser.

## Licensing

This project is released using the BSD style license.

## Contributing

We welcome your bug reports, Pull Requests for improvements, docs and anything you think would improve the experience for other xLiMe users and developers.

repository: rdenaux/xlime-showcase

repo_name: rdenaux/xlime-showcase


text:
# oc-basecamp

Simple Project Collaboration tool based on required RainLabUser, RainLab.Forum, Responsive.Uploader plugins

- add simple user group permission to a forum channel, adding a new relationship between Channel and UserGroup.

To be used with the theme voilaah/oc-basecamp-theme
- filter channels and topics based on user group permissions.
- User can upload files and image inside the posts

repository: Voilaah/oc-basecamp

repo_name: Voilaah/oc-basecamp


text:
# Design Proposal for GUI/UI/UX

## Motivation

Motivation is having some GUI for interacting with data-describe components.

## Goals

The goal is to allow users:

 * Visiblity to what is available in data-describe
 * Easy Access to output form data-describe
 * A manner to display dashboard like functionality

## Non-Goals

There is no plan to create a Desktop native app.

## Design

The design will be broken into 2 parts:

1. Data Science Working View
2. Report View

#### 1. Data Science Working View

For this we will write custom jupyterlab extension. It should simply allow two following things:

- capture of graphs and output into a seperate jupyter lab window
- a menu for code shortcuts and to make it easy to navigate what is available. Also provide additional helpers similar to the contextual helper today.

An example of this may be found in [Dask Lab Extension](https://www.npmjs.com/package/dask-labextension)

#### 2. Report View

This is a more fullblown EDA report dashboard. For this we will create a seperate dashboard that collects all meaningful report elements and allows them to be displayed in a seperate app. **This part 2 is defered at this time** and Part 1 will be the focus. Most likely we will want to consider the Alternatives listed at that time. Likely candidates are Dash.

## Alternatives Considered

We looked at the following, and for reasons listed we did not use at this time. This doc is this very helpful comparision https://panel.holoviz.org/Comparisons.html

 * Panel https://panel.holoviz.org/ plotly library agnostic and is based on Bokeh widgets.
 * Dash is more about standalone, more scalable but require dashboards to be rewritten.
 * ipywidgets native to jupyter and highly customizable.
 * Viola an alternative to Bokeh server can deploy these other apps.
 * streamlit is alternative to the jupyter aware methods above.

 Other notable libraries

 * https://deck.gl/#/showcases/overview does some really nice data science modeling using WebGL
 * Facets (Which is used by TFDV) provides very useful ML visualizations https://pair-code.github.io/facets/ https://github.com/PAIR-code/facets  The visualizations are implemented as [Polymer web components](https://www.polymer-project.org/), backed by [Typescript](https://www.typescriptlang.org/) code and can be easily embedded into Jupyter notebooks or webpages.

## Related cases

https://github.com/brianray/data-describe/issues/51

gha_language: Python

gha_license_id: NOASSERTION


text:
## `zdesk organization-membership`

Run organization-membership subcommands

### Synopsis

    zdesk organization-membership COMMAND[ ... ]

### Description

Run organization-membership subcommands

repository: fprimex/zdesk-cli

repo_name: fprimex/zdesk-cli


text:
# Customized LXC templates for Proxmox
A set of customized LXC templates using the Debian Appliance Builder (DAB) provided by Proxmox. Currently this repo provides templates of Debian 10 (Buster) and Ubuntu 20.04 (Focal).

### Motivation

Proxmox already comes with a minimal Debian & Ubuntu template so why should one bother to create a customized Debian/Ubuntu template? Following are the reasons why I did it.

- Security (I don't have to rely on a template provided by a 3rd party)
- I have control over what packages get installed on top of a minimal installation.
- I can make changes to the configuration right from the beginning (e.g. ssh).
- Unattended upgrades (security) active by default.

### Install DAB
In order to start creating custom templates one has to install DAB first. Please note that this package is not available on regular Debian installations by default. For more information please refer to [https://pve.proxmox.com/wiki/Debian_Appliance_Builder](https://pve.proxmox.com/wiki/Debian_Appliance_Builder).

    apt update && apt install dab

### Clone repository

Once DAB is installed just clone the GIT repository to get the required files.

    git https://github.com/frieder/dab-templates.git
    cd dab-templates/...

### Make changes to the config files

Next customize the Makefile and dab.conf files in the template folders according to your needs. While most of the stuff should be fine for most people you may want to take a closer look at the following configurations:

* SSH root login is forbidden except with private key from a defined subnet. Check `files/ssh/sshd_config` if you want to have this changed.
* `files/id_rsa` & `files/id_rsa.pub` must be created (see the next section) or root login must be allowed or a local user must be created (either SSH config or Makefile). If absent it will be skipped.
* localtime is set to Europe/Berlin (Makefile)
* locale is set to en_GB.UTF-8 (Makefile)
* Python3 & vim (Makefile)
* Fixed IPs for several hosts (files/hosts).

If you require more information about the DAB makefile please visit the Proxmox [DAB wiki](https://pve.proxmox.com/wiki/Debian_Appliance_Builder), ask on the Proxmox [forum](https://forum.proxmox.com/) and check the DAB man pages.

### Create SSH public & private key

Before we can actually build the template we must create a private/public keyset. Just execute the following command (assuming /opt/dab-templates is the folder you cloned the GIT repository to).

    ssh-keygen -t rsa -b 4096 -C "user@workstation"
    Generating public/private rsa key pair.
    Enter file in which to save the key (/root/.ssh/id_rsa): /opt/dab-templates/files/id_rsa

When skipping the creation of the ssh keys the makefile will skip copying the pub file into the container.

### Create template

Creating a new LXC template is quite easy. Just execute the following command (inside the folder in which the Makefile and dab.conf file exists) and it will build everything that is required for the LXC template.

    make

To clean up the directory execute the following command. Please note that this will also remove the LXC template file so you may want to move the template to another location first (see the next section).

    make clean

### Post-processing

Usually the template will have a quite long file name. Since I always use minimal and 64bit templates I usually remove those parts from the file name. You however can choose any name you like. Once you are done with renaming the template move it to the Proxmox LXC template location so it can be used via the web console and CLI.

    mv debian-10.0-minimal_10.0_amd64.tar.gz /var/lib/vz/template/cache/debian-10.tar.gz

Enjoy.

repository: frieder/dab-templates

repo_name: frieder/dab-templates


text:
---
title: Eigenvector of Circulant Matrix and Fourier Matrix
sidebar:
  nav: docs-en
aside:
  toc: true
key: 20201126_en
tags: Linear_Algebra
lang: en
---

# Prerequisites

To understand this post well, it is recommended to have knowledge about the following topics:

* [Basic operations of vectors](https://angeloyeo.github.io/2020/09/07/basic_vector_operation_en.html)
* [Eigenvalues and eigenvectors](https://angeloyeo.github.io/2019/07/17/eigen_vector_en.html)
* [Linear algebra and Fourier transform](https://angeloyeo.github.io/2020/11/08/linear_algebra_and_Fourier_transform_en.html)
* [Eigenvalue decomposition (EVD)](https://angeloyeo.github.io/2020/11/19/eigen_decomposition_en.html)
* [Circulant matrices and convolution](https://angeloyeo.github.io/2020/11/25/permutation_and_circulant_matrix_en.html)

# Eigenvalues and eigenvectors of permutation matrices

The eigenvalues and eigenvectors of circulant matrices are closely related to those of permutation matrices.

Therefore, let's first calculate the eigenvalues and eigenvectors of a permutation matrix.

The permutation matrix we use is a matrix that performs a cyclic permutation as seen in the [Circulant matrices and convolution](https://angeloyeo.github.io/2020/11/25/permutation_and_circulant_matrix_en.html) article, as shown below:

$$P = \begin{bmatrix}  0 & 0 & \cdots & 0 & 1 \\   1 & 0 &\cdots & 0 & 0 \\  0 & \ddots &\ddots & \vdots & \vdots \\  \vdots & \ddots & \ddots & 0 & 0 \\  0 & \cdots & 0 & 1 & 0\end{bmatrix}$$

Calculating the eigenvalues and eigenvectors of a general $n\times n$ matrix $P$ can be difficult, so let's calculate the eigenvalues and eigenvectors of a $4\times 4$ permutation matrix $P_4$.

First, to calculate the eigenvalues of $P_4$, we can write the characteristic equation as follows:

$$det(P_4-\lambda I) = 0$$

$$\Rightarrow det\left(\begin{bmatrix}0 & 0 & 0 & 1 \\ 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0\end{bmatrix}-\lambda I\right)=0$$

$$\Rightarrow det\left(\begin{bmatrix}-\lambda & 0 & 0 & 1 \\ 1 & -\lambda & 0 & 0 \\ 0 & 1 & -\lambda & 0 \\ 0 & 0 & 1 & -\lambda\end{bmatrix}\right)=0$$

Determinants of matrices larger than $3\times 3$ can be calculated using the adjugate matrix.

That is,

$$\Rightarrow 1\times (-\lambda)\times det\left(\begin{bmatrix}-\lambda & 0 & 0 \\ 0 & -\lambda & 0 \\ 0 & 0 & -\lambda \end{bmatrix}\right)-1\times(1)\times det\left(\begin{bmatrix} 1 & -\lambda & 0 \\ 0 & 1 & -\lambda \\ 0 & 0 & 1 \end{bmatrix}\right) = 0$$

$$\Rightarrow \lambda^4 - 1 = 0$$

Therefore, the eigenvalues of $P_4$ are $\lambda = 1, -1, i, -i$.

Let's use this to calculate the eigenvectors.

1) When $\lambda = 1$,

We need to satisfy $P_4v=\lambda v$, so

$$(P_4-\lambda I)v = (P_4-I)v = 0$$

and if we assume $v = [v_1, v_2, v_3, v_4]^T$,

$$\begin{bmatrix}  -1 & 0 & 0 & 1 \\   1 & -1 & 0 & 0 \\   0 & 1 & -1& 0 \\   0 & 0 & 1 & -1\end{bmatrix}\begin{bmatrix}v_1\\v_2\\v_3\\v_4\end{bmatrix} = 0$$

should hold, so the eigenvector $v$ satisfying the relationship $v_1=v_4$, $v_1 = v_2$, $v_2=v_3$, $v_3 = v_4$ is

$$v=\begin{bmatrix}1\\1\\1\\1\end{bmatrix}$$

2) When $\lambda = -1$,

By following a similar method to the case when $\lambda = 1$,

$$\begin{bmatrix}  1 & 0 & 0 & 1 \\   1 & 1 & 0 & 0 \\   0 & 1 & 1& 0 \\   0 & 0 & 1 & 1\end{bmatrix}\begin{bmatrix}v_1\\v_2\\v_3\\v_4\end{bmatrix} = 0$$

should hold, and the eigenvector satisfying the relationship $v_1=-v_4$, $v_1 = -v_2$, $v_2=-v_3$, $v_3 = -v_4$ is

$$v=\begin{bmatrix}1\\-1\\1\\-1\end{bmatrix}$$

3) When $\lambda = i$,

Using a similar method as the above two cases, we can see that the eigenvector is

$$v = \begin{bmatrix}1 \\ i \\ i^2 \\ i^3 \end{bmatrix}$$

4) In the case of $\lambda=-i$, the eigenvector can be obtained through a method similar to the two methods above:

$$v = \begin{bmatrix}1 \\ (-i) \\ (-i)^2 \\ (-i)^3 \end{bmatrix}$$

Generally, the eigenvalues of a permutation matrix of size $n\times n$ can be expressed as $\lambda^n-1=0$, where $\lambda$ satisfies this equation [^1]:

[^1]: The sign inside the exponential of Lambda below can be either '+' or '-', but the sign is set to '-' considering the relationship with the Fourier matrix described later.

$$\lambda_k = \exp\left(-j\frac{2\pi}{n}k\right)\text{ for } k = 0, 1, \cdots ,n-1$$

The corresponding eigenvectors for each eigenvalue are as follows:

$$v_k = \begin{bmatrix}(\lambda_k)^0 \\ (\lambda_k)^1\\ \vdots \\ (\lambda_k)^{n-1}\end{bmatrix}\text{ for } k = 0, 1, \cdots ,n-1$$

# Eigenvectors of cyclic matrices

$$ C=  \begin{bmatrix}  x_0 & x_{n-1} & \cdots & x_2 & x_1 \\   x_1 & x_1 &\cdots & x_3 & x_2 \\  x_2 & \ddots &\ddots & \vdots & \vdots \\  \vdots & \ddots & \ddots & x_0 & x_{n-1} \\  x_{n-1} & \cdots & x_2 & x_1 & x_0\end{bmatrix} = \left(\sum_{i=0}^{n-1}x_i P^{i}\right)$$

The eigenvectors of a cyclic matrix are the same as those of a permutation matrix.

The eigenvalue $\lambda$ and eigenvector $v$ of $P$ satisfy the following equation:

$$Pv=\lambda v$$

If we denote the eigenvector of the cyclic matrix $C$ as $v$, it should satisfy the following equation with the eigenvalue $\xi$ of the cyclic matrix:

$$Cv=\xi v$$

Based on the relationship between cyclic matrices and permutation matrices, the above equation can be expressed as:

$$Cv = x_0 I v + x_1 P^1 v + \cdots + x_{n-1}P^{n-1}v$$

$$=x_0 \lambda^0 v + x_1 \lambda^1 v + \cdots + x_{n-1}\lambda^{n-1}v$$

$$=\left(\sum_{i=0}^{n-1}x_i\lambda^i\right)v = \xi v$$

In other words, the eigenvectors of cyclic matrices and permutation matrices are the same.

Understanding Fourier matrix based on the transformation of basis

Let's think about the 'basis' that represents vectors.

In the previous article about [basic vector operations](https://angeloyeo.github.io/2020/09/07/basic_vector_operation_en.html), we briefly mentioned the characteristics of vectors. The first two were that 'vectors are like arrows' and 'vectors are ordered sequences of numbers.'

  Figure 1. Geometric characteristics of vectors that are invariant to changes in the coordinate system

From Figure 1, we can see that we can represent a single vector using a completely different coordinate system.

Also, depending on the coordinate system used, the sequence of numbers used to represent the vector can be either concise or complex.

Therefore, we can easily handle data (i.e., vectors) by selecting an appropriate coordinate system.

The basic unit of the coordinate system mentioned here is called the 'basis.' In other words, if we choose the appropriate basis for our purpose, we can represent the same vector (i.e., given data) more easily or usefully.

The basis that we have commonly used so far can be called the standard basis. For example, for the vector $\vec{x}$ below,

$$\vec{x} = \begin{bmatrix}x_0\\x_1\\ \vdots \\ x_{n-1}\end{bmatrix}$$

using the standard basis means representing the vector $\vec{x}$ using basis vectors filled with 1 and 0 as shown below.

$$\begin{bmatrix}x_0\\x_1\\ \vdots \\ x_{n-1}\end{bmatrix}

= x_0 \begin{bmatrix}1\\0\\ \vdots \\ 0\end{bmatrix} + x_1 \begin{bmatrix}0\\1\\ \vdots \\ 0\end{bmatrix} + \cdots + x_{n-1} \begin{bmatrix}0\\0\\ \vdots \\ 1\end{bmatrix}$$

Meanwhile, according to what we have seen so far, any vector can be thought of as the product of a circulant matrix $C$ and a $\delta$ vector, which means that any signal can be seen as the result obtained by transforming the $\delta$ vector.

$$\vec{x} = C\delta=\left(\sum_{i=0}^{n-1}x_i P^{i}\right)\delta$$

(Under construction...)


text:
# node-dirty

## Purpose

A tiny & fast key value store with append-only disk log. Ideal for apps with < 1 million records.

## Installation

    npm install dirty

## Why dirty?

This module is called dirty because:

* The file format is newline separated JSON
* Your database lives in the same process as your application, they share memory
* There is no query language, you just `forEach` through all records

So dirty means that you will hit a very hard wall with this database after ~1 million records,
but it is a wonderful solution for anything smaller than that.

## Tutorial

    require('../test/common');
    var db = require('dirty')('user.db');

    db.on('load', function() {
      db.set('john', {eyes: 'blue'});
      console.log('Added john, he has %s eyes.', db.get('john').eyes);

      db.set('bob', {eyes: 'brown'}, function() {
        console.log('User bob is now saved on disk.')
      });

      db.forEach(function(key, val) {
        console.log('Found key: %s, val: %j', key, val);
      });
    });

    db.on('drain', function() {
      console.log('All records are saved on disk now.');
    });

Output:

    Added john, he has blue eyes.
    Found key: john, val: {"eyes":"blue"}
    Found key: bob, val: {"eyes":"brown"}
    User bob is now saved on disk.
    All records are saved on disk now.

## API

### new Dirty([path])

Creates a new dirty database. If `path` does not exist yet, it is created. You
can also omit the `path` if you don't want disk persistence (useful for testing).

The constructor can be invoked in multiple ways:

    require('dirty')('my.db');
    require('dirty').Dirty('my.db');
    new (require('dirty'))('my.db');
    new (require('dirty').Dirty)('my.db');

### dirty.path

The path of the dirty database.

### dirty.set(key, value, [cb])

Set's the given `key` / `val` pair. The state of the database is affected instantly,
the optional `cb` callback is fired when the record was written to disk.

`val` can be any JSON-serializable type, it does not have to be an object.

### dirty.get(key)

Retrieves the value for the given `key`.

### dirty.rm(key, cb)

Removes the record with the given `key`. This is identical to setting the `key`'s value
to `undefined`.

### dirty.forEach(fn)

Calls the given `fn` function for every document in the database. The passed
arguments are `key` and `val`. You can return `false` to abort a query (useful
if you are only interested in a limited number of records).

This function is blocking and runs at ~4 Mhz.

### dirty event: 'load' (length)

Emitted once the database file has finished loading. It is not safe to access
records before this event fires. Writing records however should be fine.

`length` is the amount of records the database is holding. This only counts each
key once, even if it had been overwritten.

### dirty event: 'drain' ()

Emitted whenever all records have been written to disk.

## License

node-dirty is licensed under the MIT license.

gha_language: ApacheConf


text:
# journalx

This application forwards log messages from Linux's `/dev/log` and `/dev/klog` to a GenEvent process. Based on [fhunleth/l2elog](https://github.com/fhunleth/l2elog).

>While this may seem completely backwards, when using the Nerves framework, Erlang takes a central role and much of the standard Linux userspace is either not needed or minimal. In this environment, most log messages originate in Erlang, but not all. This utility forwards the remainder of those messages so that messages from the kernel and any C programs aren't lost

## Installation

If [available in Hex](https://hex.pm/docs/publish), the package can be installed as:

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

        def deps do
          [{:journalx, "~> 0.0.1"}]
        end

  2. Ensure journalx is started before your application:

        def application do
          [applications: [:journalx]]
        end

## Usage

Add or remove an handler:

```
Journalx.add_handler(MyHandler)
Journalx.remove_handler(MyHandler)
```

Log event: `{:log, priority :: 0..7, message :: String.t}`

repository: eraserewind/journalx

repo_name: eraserewind/journalx


text:
---
layout: default
---

# 1996-12-19 - RE: The virus I got...

## Header Data

From: Internaut<EMAIL_ADDRESS>To: "'Vincent Padua'"<EMAIL_ADDRESS>Message Hash: d5a22bc5088fc8b7fed9d0983104090689673e16b0cb405bfc02529c303e3d04

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-12-19 06:19:04 UTC

Raw Date: Wed, 18 Dec 1996 22:19:04 -0800 (PST)

## Raw message

```
{% raw  %}From: Internaut<EMAIL_ADDRESS>Date: Wed, 18 Dec 1996 22:19:04 -0800 (PST)
To: "'Vincent Padua'"<EMAIL_ADDRESS>Subject: RE: The virus I got...
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

From: 	Mark<EMAIL_ADDRESS>Sent: 	Wednesday, December 18, 1996 04.37 PM
>Oh, and as far as I know, no virus was installed,
>though you should check for one just for good measure.

There was one, though I don't remember what it's name was. Maby it was Monkey. I already deleted it. --Internaut

{% endraw %}
```

## Thread

+ Return to [December 1996](/archive/1996/12)

+ Return to "[Internaut <unde0275@frank.mtsu.edu>](/authors/internaut_unde0275_at_frank_mtsu_edu_)"

+ 1996-12-19 (Wed, 18 Dec 1996 22:19:04 -0800 (PST)) - RE: The virus I got... - _Internaut<EMAIL_ADDRESS>


text:
# sa-arc-rec
Architectural reconstruction tools

## Install
Install Jupyter
```
pip3 install --upgrade pip

pip3 install jupyter
```

## Run
Run Jupyter Notebook
```
jupyter notebook
```
Now you can open the notebooks in your browser
### Abstraction & Presentation
You need to set Zeeguu-Core root folder `CODE_ROOT_FOLDER` at the top of the file.
```
abstraction_presentation.ipynb
```
### Dynamic analysis
Set your Zeeguu-Core root folder and default config at the top of the "Case study" section.
If you do not have data in your database yet, you will get "No results" in this part.
```
dynamic_analysis.ipynb
```
## Other
[Handy keyboard shortcuts for Jupyter](https://towardsdatascience.com/jypyter-notebook-shortcuts-bf0101a98330)

repository: kindaninja/sa-arc-rec

repo_name: kindaninja/sa-arc-rec


text:
---
layout: page
title: MCI Codes
---
ENiGMA½ supports a variety of MCI codes. Some **predefined** codes produce information about the current user, system,
or other statistics while others are used to instantiate a **View**. MCI codes are two characters in length and are
prefixed with a percent (%) symbol. Some MCI codes have additional options that may be set directly from the code itself
while others -- and more advanced options -- are controlled via the current theme. Standard (non-focus) and focus colors
are set by placing duplicate codes back to back in art files.

## Predefined MCI Codes
There are many predefined MCI codes that can be used anywhere on the system (placed in any art file). More are added all
the time so also check out [core/predefined_mci.js](https://github.com/NuSkooler/enigma-bbs/blob/master/core/mci_view_factory.js)
for a full listing. Many codes attempt to pay homage to Oblivion/2,
iNiQUiTY, etc.

| Code | Description  |
|------|--------------|
| `BN` | Board Name |
| `VL` | Version *label*, e.g. "ENiGMA½ v0.0.3-alpha" |
| `VN` | Version *number*, eg.. "0.0.3-alpha" |
| `SN` | SysOp username |
| `SR` | SysOp real name |
| `SL` | SysOp location |
| `SA` | SysOp affiliations |
| `SS` | SysOp sex |
| `SE` | SysOp email address |
| `UN` | Current user's username |
| `UI` | Current user's user ID |
| `UG` | Current user's group membership(s) |
| `UR` | Current user's real name |
| `LO` | Current user's location |
| `UA` | Current user's age |
| `BD` | Current user's birthdate (using theme date format) |
| `US` | Current user's sex |
| `UE` | Current user's email address |
| `UW` | Current user's web address |
| `UF` | Current user's affiliations |
| `UT` | Current user's *theme ID* (e.g. "luciano_blocktronics") |
| `UC` | Current user's login/call count |
| `ND` | Current user's connected node number |
| `IP` | Current user's IP address |
| `ST` | Current user's connected server name (e.g. "Telnet" or "SSH") |
| `FN` | Current user's active file base filter name |
| `DN` | Current user's number of downloads |
| `DK` | Current user's download amount (formatted to appropriate bytes/megs/etc.) |
| `UP` | Current user's number of uploads |
| `UK` | Current user's upload amount (formatted to appropriate bytes/megs/etc.) |
| `NR` | Current user's upload/download ratio |
| `KR` | Current user's upload/download *bytes* ratio |
| `MS` | Current user's account creation date (using theme date format) |
| `PS` | Current user's post count |
| `PC` | Current user's post/call ratio |
| `MD` | Current user's status/viewing menu/activity |
| `MA` | Current user's active message area name |
| `MC` | Current user's active message conference name |
| `ML` | Current user's active message area description |
| `CM` | Current user's active message conference description |
| `SH` | Current user's term height |
| `SW` | Current user's term width |
| `DT` | Current date (using theme date format) |
| `CT` | Current time (using theme time format) |
| `OS` | System OS (Linux, Windows, etc.) |
| `OA` | System architecture (x86, x86_64, arm, etc.) |
| `SC` | System CPU model |
| `NV` | System underlying Node.js version |
| `AN` | Current active node count |
| `TC` | Total login/calls to system |
| `RR` | Displays a random rumor |
| `SD` | Total downloads, system wide |
| `SO` | Total downloaded amount, system wide (formatted to appropriate bytes/megs/etc.) |
| `SU` | Total uploads, system wide |
| `SP` | Total uploaded amount, system wide (formatted to appropriate bytes/megs/etc.) |

A special `XY` MCI code may also be utilized for placement identification when creating menus.

## Views
A **View** is a control placed on a **form** that can display variable data or collect input. One example of a View is
a Vertical Menu (`%VM`): Old-school BBSers may recognize this as a lightbar menu.

| Code | Name                 | Description      |
|------|----------------------|------------------|
| `TL` | Text Label           | Displays text       |
| `ET` | Edit Text            | Collect user input  |
| `ME` | Masked Edit Text     | Collect user input using a *mask* |
| `MT` | Multi Line Text Edit | Multi line edit control |
| `BT` | Button               | A button |
| `VM` | Vertical Menu        | A vertical menu aka a vertical lightbar |
| `HM` | Horizontal Menu      | A horizontal menu aka a horizontal lightbar |
| `SM` | Spinner Menu         | A spinner input control |
| `TM` | Toggle Menu          | A toggle menu commonly used for Yes/No style input |
| `KE` | Key Entry            | A *single* key input control |

Peek at [/core/mci_view_factory.js](https://github.com/NuSkooler/enigma-bbs/blob/master/core/mci_view_factory.js) to
see additional information.

## Properties & Theming
Predefined MCI codes and other Views can have properties set via `menu.hjson` and further *themed* via `theme.hjson`.

### Common Properties

| Property    | Description  |
|-------------|--------------|
| `textStyle` | Sets the standard (non-focus) text style. See **Text Styles** below |
| `focusTextStyle` | Sets focus text style. See **Text Styles** below. |
| `itemSpacing` | Used to separate items in menus such as Vertical Menu and Horizontal Menu Views. |
| `height` | Sets the height of views such as menus that may be > 1 character in height |
| `width` | Sets the width of a view |
| `focus` | If set to `true`, establishes initial focus |
| `text` | (initial) text of a view |
| `submit` | If set to `true` any `accept` action upon this view will submit the encompassing **form** |

These are just a few of the properties set on various views. *Use the source Luke*, as well as taking a look at the default
`menu.hjson` and `theme.hjson` files!

### Text Styles

Standard style types available for `textStyle` and `focusTextStyle`:

| Style    | Description  |
|----------|--------------|
| `normal` | Leaves text as-is. This is the default. |
| `upper` | ENIGMA BULLETIN BOARD SOFTWARE |
| `lower` | enigma bulletin board software |
| `title` | Enigma Bulletin Board Software |
| `first lower` | eNIGMA bULLETIN bOARD sOFTWARE |
| `small vowels` | eNiGMa BuLLeTiN BoaRD SoFTWaRe |
| `big vowels` | EniGMa bUllEtIn bOArd sOftwArE |
| `small i` | ENiGMA BULLETiN BOARD SOFTWARE |
| `mixed` | EnIGma BUlLEtIn BoaRd SOfTWarE (randomly assigned) |
| `l33t` | 3n1gm4 bull371n b04rd 50f7w4r3 |

repository: SemperFu/enigma-bbs

repo_name: SemperFu/enigma-bbs


text:
---
layout: practice
author: Alex Serban, Koen van der Blom, Joost Visser
name: Provide Audit Trails
category: Deployment
index: 34
unique_id: audit_trails
difficulty: "advanced"
references: [CAIAG, AIHLEG, TTAID] #
comments: True
description:
image: #
photocredit: #

intent: Allow post-mortem behaviour analysis of the application. #
motivation: Concerns about the social implications of machine learning and artificial intelligence led to a rising interest to regulate and audit applications. #
applicability: Audit trails should be applied to any machine learning application.  #
related: [audits, deployment_log, interpretable] #
dependencies: #
survey_question: Q96 #
survey_items: Our ML applications provide comprehensive audit trails that allow critical assessment of model behaviour.

labels: [accountability]

---

The social implications that machine learning and more general artificial intelligence technologies may have on society call for tight regulations to ensure the consumer rights are respected. For example, the EU GDPR law, as well as the Credit score in the US, require the *right to an explanation* for automated decision making systems.

Post-mortem analysis and traceability of model behaviour is difficult in case teams do not design the application for audit trails.
A first step towards opening the applications for audits is to devise a strategy for auditing and make it part of the development life-cycle.

Such a strategy should include plans for storing and preserving audit trails of past decisions, together with data describing each stage of the development life-cycle.
For example, define and store design checklists (which describe why a model was preferred over others), keep records about the training data distribution (at the time of developing a model), keep records regarding the known failure modes of the model, and keep production logs that can trace back decisions to a model and the used training data.

Automating the audit artefacts -- such as automatic generation of reports -- will enhance your ability to adhere to the audit strategy and will facilitate communication across teams.

branch_name: refs/heads/source


text:
---
layout: post
title:  “Artemis”
date:   2018-02-08
tags: culture, entertainment, storytelling, books
categories: blog
---
Andy Weir’s *Artemis* can best be described as an organized crime thriller on the moon. It’s quite a departure from his Mars-survival-blog, *The Martian*, but enjoyable nonetheless. Those who enjoyed his first book for its intricate technical aspects might find themselves wanting when reading *Artemis*. The details and descriptions are there, but the plot is what drives the narrative, not the engineering.

Nonetheless, I enjoyed living in the head of protagonist Jazz Bashara. She has all the wit, gumption, and intellect of Mark Watney, and is in some ways more developed as a character. I don’t think I enjoyed this novel more or less than *The Martian*, I just enjoyed it differently. I’m excited to see what story Andy Weir engineers next.


text:
<img src="https://fokkoveegens.visualstudio.com/_apis/public/build/definitions/05fae6df-eb68-4b52-aac4-7ac9c84d0d32/17/badge">

# VSTSMigrateUsers
Easily migrate a Visual Studio Team Services (VSTS) account from using MSA's (Microsoft Accounts) to AAD (Azure Active Directory) accounts

# What it does
The output of this code is a (Windows) command line utility that is able to do two things:
* Copy direct group membership from one to another user inside VSTS (and do this for multiple users)
* Reassign Work Items from one to another user
* Copy Work Item Alerts from one to another user (excludes default Code Review Alerts, doesn't exclude already existing Alerts)

# What it does not
Some scenarios are hard to implement using the TFS API, so they are omitted in this tool
* Copy personal favorites (Build, Work Item Queries etc)
* Copy "My" Queries (exporting these is easy using Visual Studio > save as file)
* Any other account properties like profile picture, preferred e-mail address etc

# Prerequisites
On beforehand, the following tasks need to be done manually:
* Ensure the MSA and the AAD account are available in the VSTS instance, which can be verified using the following URL: https://[accountname].visualstudio.com/_user

# Configuration
The tool requires a configuration file as input. A sample configuration file is provided. The most important settings to change are:
* Provide your VSTS account (vstsUri)
* Provide the user mapping(s) (UserMapping)
* Change "contoso" to the subdomain of your VSTS account (vstsSecurityServiceGroup)
* It is recommended to leave other settings as they are

# Usage
To use it, open a command prompt and call the executable with the configuration file as a parameter:
```
VSTSPermCopy.exe .\sample.xml
```

# Note
Keep in mind that direct object permissions (like e.g. permissions given to a user on a Source Control folder) are not copied!

# Changes
I'm open to pull requests and feature requests.

repository: FokkoVeegens/VSTSMigrateUsers

gha_language: C#

repo_name: FokkoVeegens/VSTSMigrateUsers


text:
Find more information in the [HemOnc cookbook here](https://docs.google.com/document/d/19fqNqPS2oDbB5mwsoN4Zm3WSU0YOKGyfi5qZUyZLhgg/edit?usp=sharing).
Refresh of HemOnc:

Prerequisites:
- Schema DevV5 with copies of tables concept, concept_relationship and concept_synonym from ProdV5, fully indexed.
- Working directory HemOnc

1. Upload the source tables
2. Make sure that manual tables are populated with most recent content (see the https://github.com/OHDSI/Vocabulary-v5.0/blob/master/HemOnc/manual_work/readme_manual_tables.md)
3. Run load_stage.sql
4.  Run generic_update:
```sql
DO $_$
BEGIN
	PERFORM devv5.GenericUpdate();
END $_$;
```
5.  Run basic tables check (should retrieve NULL):
```sql
SELECT * FROM qa_tests.get_checks();
```

6. Run scripts to get summary, and interpret the results:
```sql
SELECT * FROM qa_tests.get_summary('concept');
```
```sql
SELECT * FROM qa_tests.get_summary('concept_relationship');
```
7. Run scripts to collect statistics, and interpret the results:
```sql
SELECT * FROM qa_tests.get_domain_changes();
```
```sql
SELECT * FROM qa_tests.get_newly_concepts();
```
```sql
SELECT * FROM qa_tests.get_standard_concept_changes();
```
```sql
SELECT * FROM qa_tests.get_newly_concepts_standard_concept_status();
```
```sql
SELECT * FROM qa_tests.get_changes_concept_mapping();
```
8. Run [manual_checks_after_generic.sql](https://github.com/OHDSI/Vocabulary-v5.0/blob/master/working/manual_checks_after_generic.sql), and interpret the results.

If no problems, enjoy!

license: Unlicense

gha_language: PLpgSQL

gha_license_id: Unlicense


text:
---
title: "WebRTC support, progress report #3"
excerpt: "WebRTC for the High Level Multiplayer API is here! Featuring a fully peer to peer mesh network. Documentation is now available for WebRTC classes, a tutorial and two new demos has been added."
categories: ["progress-report"]
author: Fabio Alessandrelli
image: /storage/app/uploads/public/5d0/a2c/54a/5d0a2c54aaced070739095.png
date: 2019-06-19 14:50:00
---

In the [last](https://godotengine.org/article/godot-webrtc-report2) two [reports](https://godotengine.org/article/godot-webrtc-report1) we laid out the basis for building a Godot application that uses WebRTC to communicate with other peers.

Now, the **WebRTC module got an interface to the High Level Multiplayer API**, so it can be used as a transport for **RPCs/RSETs**. The implementation is a **full p2p mesh**, meaning every player is connected with each other via a "direct" connection, and there is no need for a player to act as a server.

WebRTCMultiplayer
=================

![webrtc-multiplayer-docs.png](/storage/app/uploads/public/5d0/a2d/7ca/5d0a2d7caa88a877416904.png)

The **`WebRTCMultiplayer`** class interfaces WebRTC with the High Level Mulitplayer API. Due to the way WebRTC works, this class needs a **slightly more complex setup** before it can be used compared to other network peers, but as said it will **create a full p2p mesh** that is also **encrypted** at transport level. The idea, is that you will have a **[signaling server](http://docs.godotengine.org/en/latest/tutorials/networking/webrtc.html) assigning ids** to peers, and letting them know about each other.

To **setup** the multiplayer class one would need to:

- Call `initialize` with the id assigned by the signaling server.
- For each newly connected peer (as notified by the signaling server along with its id), create a new `WebRTCPeerConnection` and pass it with the given id to `add_remote_peer`. You can optionally add channels to it, but the first three (negotiated 1, 2, and 3) are reserved for the high level mutiplayer.
- Do the usual signaling procedure to exchange ICE candidates and session descriptions.

**Note 1**: You don't have to poll each `WebRTCPeerConnection` separately, just call `WebRTCMultiplayer.poll` and it will poll all connections added via `add_remote_peer`.

**Note 2** The `WebRTCMultiplayer` class does not fire `connection_succeded` and `server_disconnected` unless run in `server_compatibility` mode.

**Server compatibility mode** can be used to adapt games written using server/client architecture in mind (e.g. the ENet implementation). The connection will **still** be a **p2p mesh**, but one peer will be expected to have **id `1` (server)**, and all `peer_connected` signals will be suppressed until such a peer **connects**. When that happens, **`server_connected`** will be **emitted**, the connection state will be set to `CONNECTION_CONNECTED` and **then `peer_connected`** will be emitted **for each connected peer**.

You can **read more** about the `WebRTCMultiplayer` class in the [docs](http://docs.godotengine.org/en/latest/classes/class_webrtcmultiplayer.html).

WebRTC tutorials and demos
==========================

This blog post will be a bit shorter then the previous ones, but don't worry, there is much more reference material to learn from now!

You can find a [new WebRTC tutorial here](http://docs.godotengine.org/en/latest/tutorials/networking/webrtc.html) with two small examples.

Two new demos are available in the [godot demo repository](https://github.com/godotengine/godot-demo-projects/). The demos includes one with the two examples in the tutorial, and a **reference signaling server** using WebSocket, with two server implementations (GDScript, and **Node.js**) and two GDScript client implementation (raw, and **`WebRTCMultiplayer`**).

Documentation has been added for [WebRTCPeerConnection](http://docs.godotengine.org/en/latest/classes/class_webrtcpeerconnection.html), [WebRTCDataChannel](http://docs.godotengine.org/en/latest/classes/class_webrtcdatachannel.html), and the new [WebRTCMultiplayer](http://docs.godotengine.org/en/latest/classes/class_webrtcmultiplayer.html).

There is a port of the multiplayer bomber demo using the reference signaling server **[running live here](https://no-war.fales.me/)**. Have fun playing it with your friends (and/or studying its [source code]((https://github.com/Faless/bomber-rtc/))).

Future work
===========

Beside documenting the GDNative plugin build system and building binaries for macOS, the work on WebRTC is pretty much concluded for now, ready for the 3.2 release.

Future work in the network department includes **SSL server** support, basic [**Crypto**](https://github.com/godotengine/godot/pull/29871) support (generate keys, random bytes, certificates), **DTLS** support, built-in editor web server for **debugging HTML5** exported games, plus other neat features (in no particular order).

Stay tuned, for more Godot goodies, and as always, **thank you for your support**!

repository: godotengine/godot-website

repo_name: godotengine/godot-website


text:
# [Gulangco Plate](http://steefthebeef.github.io/gulangco-plate)
Yupp, another AngularJS project boilerplate and build tool!

Gulp + AngularJS + CoffeeScript = Elegance and Speed

Gulangco Plate comes prepackaged with [jQuery](http://jquery.com), [Twitter Bootstrap](http://getbootstrap.com), [AngularStrap](http://mgcrea.github.io/angular-strap), [Angular UI Router](https://github.com/angular-ui/ui-router) and some good-to-have native angular modules: ngAnimate, ngResource, ngSanitize and ngMock for testing purposes.

[LESS](http://lesscss.org) and [CoffeeScript](http://coffeescript.org) is supported out of the box. In fact, this whole project is written in CoffeeScript!

Angular unit testing, powered by [Karma Test Runner](http://karma-runner.github.io) and [Jasmine](http://jasmine.github.io) syntax is available by simply running `gulp test`, there are a few example tests included to get you going.

## Quick Start

```
- git clone git://github.com/SteefTheBeef/gulangco-plate
- cd gulangco-plate
- npm -g install gulp karma bower
- npm install
- bower install
- gulp build
```

## Directory Structure

```
gulangco-plate/
  |- gulp/
  |  |- config/
  |  |  |- karma.conf.coffee <test config>
  |  |  |- paths.coffee <file paths config>
  |  |- tasks/ <gulp tasks divided into separate files>
  |- less
  |  |- <all styles belong here>
  |- src/
  |  |- app/
  |  |  |- <controllers, views>
  |  |- common/
  |  |  |- <services and directives>
  |  |- config/
  |  |  |- registerModules.coffee <register angular modules and app dependecies>
  |  |- app.coffee <routes defined here and general app-logic>
  |- bower.json
  |- gulpfile.coffee <gulp tasks defined in this file>
  |- package.json
  |- index.html
```

## Gulp tasks
The most important ones are
```
- gulp build
- gulp compile
- gulp test
```
### Gulp build
this task does the following in order
```
- cleans build dir
- copies vendor(bower) files
- compiles CoffeeScript files
- compiles LESS into CSS files
- copies html templates
- injects js and css files into index.html
- starts http server
- watches and recompiles on file changes
```

### Gulp compile
Similar to build, but with a few differences, which are
```
- concat all html templates into angularJS templateCache
- concat and uglifies all JS and CSS files.
- does not watch for file changes
```

### Gulp test
Run unit tests

## License
MIT

repository: SteefTheBeef/gulangco-plate

repo_name: SteefTheBeef/gulangco-plate


text:
Airports
--------

Halibot package that gets weather conditions and delay information for a given airport.

Makes use of the REST API provided by the FAA. (See http://services.faa.gov/docs/services/airport/)

As it is the FAA, it only seems to work with American airports right now.

repository: halibot-extra/airports

repo_name: halibot-extra/airports