text:
A Reference Implementation of VAST Video Ads using JavaScript Ad Tags, with Unity

The JavaScript Ad Tag is a static script for requesting and displaying an ad within an HTML-based page. For implementing this, it is required to insert the JavaScript Ad Tag into the html code of a mobile web application or mobile in-app web controller.

Note that this method is intended for real time ad serving and presentation, between the Minimob ad servers and mobile devices.  It cannot be used for server-to-server batch retrieval of ads. For each ad impression, a separate request must be made to the ad servers, supplying all the required information plus any additional data, if available. By specifying values at the parameters included at the ad tag, an application can forward extra information towards the ad servers, which can be useful for delivering better targeted ads.

In case of preloading ads to an app, the lifetime of ads delivered should not exceed 5 minutes. If an application is open for periods longer than this duration, the app should refresh the presented ads at regular intervals well under that limit.

Prerequisites

Before you proceed, make sure that you already have:

Registered to Minimob

Created an app under Monetize > Video Ads

Created an ad zone under an app

Then, follow the instructions given in this guide for enabling your app to request and display video ads from Minimob.

Workflow overview

When developing your app, you need to carry out the following tasks:

Update the app’s manifest file

Import the Minimob ad-serving module to your project

Use the imported module for requesting, loading and displaying video ads from Minimob

Updating the app’s android manifest file

At the app’s android manifest file, add the following line in the <application> node (it enables hardware-accelerated rendering for all activities and views in the application):

android:hardwareAccelerated="true"

Furthermore, make sure that the following required permissions are added:

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.READ_PHONE_STATE" />

Importing the Minimob ad-serving module to your project

To import the code to Unity:

Download the minimobvideounity.unitypackage file

Open your unity project and go to Assets > Import Package > Custom Package

Select the minimobvideo.unitypackage file and click OK.

All the files that are needed will be automatically imported.

Requesting, loading and displaying video ads from Minimob

To play video ads from Minimob, you need to create an empty game object in your main scene and add the MinimobVideoAdPlayer script to it. Note that this script is a singleton and will remain in memory after you load another scene.

Two distinct video playing modes are supported:

Immediate Video ad: the video ad is played immediately after being downloaded (a single call is used for loading and showing a video ad)

Preloaded video ad: the video ad is preloaded and it is played upon a separate request (two separate calls are used, one for loading a video ad and another for showing the video ad)

Immediate Video ad

To play a video ad, you must use the CreateVideo method of MinimobAdServing. The method takes the following parameters:

The 1st parameter is the AdTagString that your get from your Minimob Dashboard for your AdZone.

The 2nd parameter is a string of custom tracking data that you want to pass.

The 3rd parameter is a callback that will be called when the AdZone is created.

The 4th parameter specifies whether the video will be preloaded or not.

At the point in your code where you want to show the video ad, include the following lines.

// Copy the JavaScript Ad Tag that is given at the corresponding Ad Zone under Monetize > Video Ads of the Minimob dashboard, and paste it at the adTagString
private string adTagString = "<script> \n" +
    " var mmAdTagSettings = { \n" +
    " imei: \"[imei]\", \n" +
    " android_id: \"[android_id]\", \n" +
    " gaid: \"[gaid]\", \n" +
    " idfa: \"[idfa]\", \n" +
    " idfv: \"[idfv]\", \n" +
    " category: \"[category]\", \n" +
    " age: \"[age]\", \n" +
    " gender: \"[gender]\", \n" +
    " keywords: \"[keywords]\", \n" +
    " lat: \"[lat]\", \n" +
    " lon: \"[lon]\", \n" +
    " device_width: \"[device_width]\", \n" +
    " device_height: \"[device_height]\", \n" +
    " mnc: \"[mnc]\", \n" +
    " mcc: \"[mcc]\", \n" +
    " wifi: \"[wifi]\", \n" +
    " ios_version: \"[ios_version]\", \n" +
    " android_version: \"[android_version]\", \n" +
    " placement_width: \"[placement_width]\", \n" +
    " placement_height: \"[placement_height]\", \n" +
    " preload: \"[preload]\", \n" +
    " custom_tracking_data: \"[custom_tracking_data]\"}; \n" +
    " \n" +
    " var mmAdTagSettings_auto = { \n" +
    " adzoneId:\"This-is-a-FAKE-adzoneId\", \n" +
    " templateId: \"video-fullscreen2.html\", \n" +
    " mobile_web: false, \n" +
    " video_supported: true, \n" +
    " appId: \"This-is-a-FAKE-adzoneId\", \n" +
    " bundleId: \"com.minimob.addemos\", \n" +
    " placement: \"video fullscreen interstitial\"}; \n" +
    " </script> \n" +
    " <script id=\"sdk-loader\" onerror=\"if(typeof(mmji)!='undefined'){mmji.noAds()}\" type=\"text/javascript\" src=\"http://s.rtad.bid/assets/video-fullscreen-mmji.js\"></script>";

// Get an instance of MinimobAdServing class
var videoPlayer = MinimobAdServing.GetInstance();

// Create a method and include the following
videoPlayer.CreateAdZone(adTagString, customTrackingData, () =>
{
    // Load and show the video when the AdZone is created
    videoPlayer.ShowVideo();
}
, false);

// Optionally, set the delegates for the supported events:
// ads available, ads NOT available, video playing, video finished, video closed
// This enables you to customize the user experience according to the needs of your app
// onAdsAvailableAction is called when there are ads available and will be invoked after a call to ShowVideo()
videoPlayer.onAdsAvailableAction = () =>
{
};
// onAdsNotAvailableAction is called when there are no ads available and it will be invoked after a call to ShowVideo()
videoPlayer.onAdsNotAvailableAction = () =>
{
};
// onVideoPlayingAction is called when the video starts playing
videoPlayer.onVideoPlayingAction = () =>
{
};
// onVideoFinishedAction is called when the video has finished playing.
// This means that the user watched the whole video and it is a good place to give a reward if you want to incentivize the action.
videoPlayer.onVideoFinishedAction = () =>
{
};
// onVideoClosedAction is called when the user closes the Video Ad before it has finished
videoPlayer.onVideoClosedAction = () =>
{
};

Preloaded video ad

To preload and play a video ad, you must use the CreateVideo method of MinimobAdServing. The method takes the following parameters:

The 1st parameter is the AdTagString that your get from your Minimob Dashboard for your AdZone.

The 2nd parameter is a string of custom tracking data that you want to pass.

The 3rd parameter is a callback that will be called when the AdZone is created.

The 4th parameter specifies whether the video will be preloaded or not.

At the point in your code where you want to preload the video ad, include the following lines.

// Copy the JavaScript Ad Tag that is given at the corresponding Ad Zone under Monetize > Video Ads of the Minimob dashboard, and paste it at the adTagString
private string adTagString = "<script> \n" +
    " var mmAdTagSettings = { \n" +
    " imei: \"[imei]\", \n" +
    " android_id: \"[android_id]\", \n" +
    " gaid: \"[gaid]\", \n" +
    " idfa: \"[idfa]\", \n" +
    " idfv: \"[idfv]\", \n" +
    " category: \"[category]\", \n" +
    " age: \"[age]\", \n" +
    " gender: \"[gender]\", \n" +
    " keywords: \"[keywords]\", \n" +
    " lat: \"[lat]\", \n" +
    " lon: \"[lon]\", \n" +
    " device_width: \"[device_width]\", \n" +
    " device_height: \"[device_height]\", \n" +
    " mnc: \"[mnc]\", \n" +
    " mcc: \"[mcc]\", \n" +
    " wifi: \"[wifi]\", \n" +
    " ios_version: \"[ios_version]\", \n" +
    " android_version: \"[android_version]\", \n" +
    " placement_width: \"[placement_width]\", \n" +
    " placement_height: \"[placement_height]\", \n" +
    " preload: \"[preload]\", \n" +
    " custom_tracking_data: \"[custom_tracking_data]\"}; \n" +
    " \n" +
    " var mmAdTagSettings_auto = { \n" +
    " adzoneId:\"This-is-a-FAKE-adzoneId\", \n" +
    " templateId: \"video-fullscreen2.html\", \n" +
    " mobile_web: false, \n" +
    " video_supported: true, \n" +
    " appId: \"This-is-a-FAKE-adzoneId\", \n" +
    " bundleId: \"com.minimob.addemos\", \n" +
    " placement: \"video fullscreen interstitial\"}; \n" +
    " </script> \n" +
    " <script id=\"sdk-loader\" onerror=\"if(typeof(mmji)!='undefined'){mmji.noAds()}\" type=\"text/javascript\" src=\"http://s.rtad.bid/assets/video-fullscreen-mmji.js\"></script>";

// Get an instance of MinimobAdServing class
var videoPlayer = MinimobAdServing.GetInstance();

// Create a method and include the following
videoPlayer.CreateAdZone(adTagString, customTrackingData, () =>
{
    // Load the video when the AdZone is created
    videoPlayer.LoadVideo();
}
, true);

// Optionally, set the delegates for the supported events:
// ads available, ads NOT available, video loading, video loaded, video playing, video finished, video closed
// This enables you to customize the user experience according to the needs of your app
// onAdsAvailableAction is called when there are ads available and will be invoked after a call to LoadVideo()
videoPlayer.onAdsAvailableAction = () =>
{
};
// onAdsNotAvailableAction is called when there are no ads available and it will be invoked after a call to LoadVideo()
videoPlayer.onAdsNotAvailableAction = () =>
{
};
// onVideoLoadingAction is called when the video is loading
videoPlayer.onVideoLoadingAction = () =>
{
};
// onVideoLoadedAction is called when the video has finished loading
videoPlayer.onVideoLoadedAction = () =>
{
};
// onVideoPlayingAction is called when the video starts playing
videoPlayer.onVideoPlayingAction = () =>
{
};
// onVideoFinishedAction is called when the video has finished playing.
// This means that the user watched the whole video and it is a good place to give a reward if you want to incentivize the action.
videoPlayer.onVideoFinishedAction = () =>
{
};
// onVideoClosedAction is called when the user closes the Video Ad before it has finished
videoPlayer.onVideoClosedAction = () =>
{
};

Once the video has finished loading, the onVideoLoadedAction callback will be invoked.

At the point in your code where you want to play the video, you need to call the ShowVideo() method.

if (videoPlayer != null)
{
    // Show the video
    videoPlayer.ShowVideo();
}

Ad Tag parameters

The JavaScript Ad Tag of an ad zone holds the following variables:

mmAdTagSettings: this variable contains parameters that are mainly used for passing device or user information; such information can then be utilized by Minimob in order to return more suitable and relevant ads.

mmAdTagSettings_auto: this variable contains parameters that are required by the platform; they are automatically generated by Minimob.

Warning: When copying the Ad Tag script of an Ad Zone and pasting it into your code, you should NOT delete or modify any of the parameters of the script. If you need to specify age, gender, category or any custom information, use the respective methods as described in the previous sections (see the inline comments at the code that you need to include).

The parameters of each variable are described below.

mmAdTagSettings Parameters

    Parameter
    Type
    Description
    Example

    imei
    String
    The International Mobile Station Equipment Identity number that uniquely identifies mobile phones

Hashed MD5 or SHA1
    "d41d8cd98f00b204e9800998ecf8427e"

    android_id
    String
    [android only]

The Android ID of the device

Hashed MD5 or SHA1
    "d3b4f06fc2bd14b417f39f7d7e72f47f"

    gaid
    String
    [android only]

Raw (clear text) Google Advertising ID
    "3D016490-C470-4B04-99AD-B4FFF3330D46"

    idfa
    String
    [iOS only]

Raw (clear text) Apple’s Identifier For Advertisers (IFA/IDFA)
    "236A005B-700F-4889-B9CE-999EAB2B605D"

    idfv
    String
    [iOS only]

Raw (clear text) Apple’s Identifier For Vendor (IFA/IDFA)
    "599F9C00-92DC-4B5C-9464-7971F01F8370"

    category
    Integer

comma separated multiple values are allowed
    The category ID of advertised apps, as defined by IAB.

Category is used for filtering the ads. Several comma separated values can be specified to filter for multiple categories. Only ads from apps that belong to the specified categories will be served.
    "IAB1-1,IAB2"

    age
    Integer
    The age of the device user

If omitted (i.e. null), it implies "unknown".
    "37"

    gender
    String

M = male, F = female, O = known to be other
    The gender of the device user

If omitted (i.e. null), it implies "unknown".
    "F"

    keywords
    String

comma separated multiple values are allowed
    List of keywords to filter ads by (e.g. list of interests of the device user)
    "fashion,sailing"

    lat
    Float

from -90.0 to +90.0, where negative is south
    Latitude of the mobile device

Should be used together with the lon parameter.
    "+10.2"

    lon
    Float

from -180.0 to +180.0, where negative is west
    Longitude of the mobile device

Should be used together with the lat parameter.
    "-102.8"

    device_width
    Integer
    The width of the mobile device, in physical pixels
    "1440"

    device_height
    Integer
    The height of the mobile device, in physical pixels
    "2560"

    mnc
    Integer
    The mobile network code of the mobile network operator of the mobile device

It is used in combination with the mobile country code (MCC) to uniquely identify the mobile phone operator/carrier.
    "260"

    mcc
    Integer
    The mobile country code of the mobile network operator of the mobile device

It is used in combination with the mobile network code (MNC) to uniquely identify the mobile phone operator/carrier.
    " 310"

    wifi
    Boolean
    The network connection type of the mobile device

true: indicates that the device is currently connected to the internet via WiFi

false: indicates that the current network connection of the device is NOT via WiFi
    "true"

    ios_version
    String
    [iOS only]

The iOS version of the operating system of the device
    "7.1.2"

    android_version
    String
    [android only]

The android version of the operating system of the device
    "4.4.2"

    placement_width
    Integer
    The width of the advertising area within the app, where the ads are placed, in pixels
    "720"

    placement_height
    Integer
    The height of the advertising area within the app, where the ads are placed, in pixels
    "1280"

    preload
    Boolean
    true: indicates that the requested video ad will be preloaded

false: indicates that the requested video ad will NOT be preloaded
    "true"

    custom_tracking_data
    String
    Custom information, defined by the app developer
    "00000000-5a19-dc1b-ffff-ffffef05ac4a"

mmAdTagSettings_auto Parameters

    Parameter
    Type
    Description
    Example

    adzoneId
    string
    The unique id of the particular ad zone
    "56f1727aFAKEc3"

    templateId
    string
    The id of the template of the ad zone, i.e. the html code that will be used for rendering the ads.
     "video-fullscreen2.html"

    mobile_web
    string
    true: for web app supported ads

false: [default] for in-app supported ads
     false

    video_supported
    string
    true: [default] for allowing video media supported ads

false: for blocking video media supported ads
     true

    appId
    string
    The unique id of the app to which the particular ad zone belongs
     "56d57201FAKE2e"

    bundleId
    string
    The bundle id of the app, as it is registered to the app store
     "com.minimob.addemos "

    placement
    string
    The placement type of the ad
     "video fullscreen interstitial"

Examples

Here is an indicative example of an Ad Tag.

Warning: Dummy Ids have been used in this example, so do not use it as is. Please navigate to Minimob’s Monetization dashboard for Video Ads and use the ad tag that is displayed at the details of the corresponding Ad Zone.

<script>
    var mmAdTagSettings = {
        imei: "[imei]",
        android_id: "[android_id]",
        gaid: "[gaid]",
        idfa: "[idfa]",
        idfv: "[idfv]",
        category: "[category]",
        age: "[age]",
        gender: "[gender]",
        keywords: "[keywords]",
        lat: "[lat]",
        lon: "[lon]",
        device_width: "[device_width]",
        device_height: "[device_height]",
        mnc: "[mnc]",
        mcc: "[mcc]",
        wifi: "[wifi]",
        ios_version: "[ios_version]",
        android_version: "[android_version]",
        placement_width: "[placement_width]",
        placement_height: "[placement_height]",
        custom_tracking_data: "[custom_tracking_data]"
    };

    var mmAdTagSettings_auto = {
        adzoneId: "This-is-a-FAKE-adzoneId",
        templateId: "video-fullscreen2.html",
        mobile_web: false,
        video_supported: true,
        appId: "This-is-a-FAKE-appId",
        bundleId: "com.minimob.addemos",
        placement: "video fullscreen interstitial"
    };
</script>
<script id="sdk-loader" onerror="if(typeof(mmji)!='undefined'){mmji.noAds()}" type="text/javascript" src="http://s.rtad.bid/assets/video-fullscreen-mmji.js"></script>

Here is an indicative example of generated html code.

Warning: Dummy Ids have been used in this example.

<html>
    <head>
        <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
    </head>
    <body style="background-color:#000000">
        <script>
            var mmAdTagSettings = {
                imei: "d41d8cd98f00b204e9800998ecf8427e",
                android_id: "d3b4f06fc2bd14b417f39f7d7e72f47f",
                gaid: "af13cb72-fafa-4328-b86c-d48875a4561a",
                idfa: "[idfa]",
                idfv: "[idfv]",
                category: "[category]",
                age: "[age]",
                gender: "[gender]",
                keywords: "[keywords]",
                lat: "0.0",
                lon: "0.0",
                device_width: "1080",
                device_height: "1794",
                mnc: "260",
                mcc: "310",
                wifi: "false",
                ios_version: "[ios_version]",
                android_version: "23",
                placement_width: "1080",
                placement_height: "1794",
                preload: "false",
                custom_tracking_data: "[custom_tracking_data]"};

            var mmAdTagSettings_auto = {
                adzoneId:"This-is-a-FAKE-adzoneId",
                templateId: "video-fullscreen2.html",
                mobile_web: false,
                video_supported: true,
                appId: "This-is-a-FAKE-appId",
                bundleId: "com.minimob.addemos",
                placement: "video fullscreen interstitial"};
        </script>
        <script id="sdk-loader" onerror="if(typeof(mmji)!='undefined'){mmji.noAds()}" type="text/javascript" src="http://s.rtad.bid/assets/video-fullscreen-mmji.js"></script>
    </body>
</html>

License

This is free and unencumbered software released into the public domain.

Anyone is free to copy, modify, publish, use, compile, sell, or

distribute this software, either in source code form or as a compiled

binary, for any purpose, commercial or non-commercial, and by any

means.

In jurisdictions that recognize copyright laws, the author or authors

of this software dedicate any and all copyright interest in the

software to the public domain. We make this dedication for the benefit

of the public at large and to the detriment of our heirs and

successors. We intend this dedication to be an overt act of

relinquishment in perpetuity of all present and future rights to this

software under copyright law.

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 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.

For more information, please refer to http://unlicense.org

repository: minimob/video-ad-demo-unity

repo_name: minimob/video-ad-demo-unity


text:
# Bottlerocket OS

Welcome to Bottlerocket!

Bottlerocket is a free and open-source Linux-based operating system meant for hosting containers.

If you’re ready to jump right in, read our [QUICKSTART for Kubernetes](QUICKSTART-EKS.md) to try Bottlerocket in an Amazon EKS cluster or our [QUICKSTART for Amazon ECS](QUICKSTART-ECS.md) to try Bottlerocket in an Amazon ECS cluster.

Bottlerocket focuses on security and maintainability, providing a reliable, consistent, and safe platform for container-based workloads.
This is a reflection of what we've learned building operating systems and services at Amazon.
You can read more about what drives us in [our charter](CHARTER.md).

The base operating system has just what you need to run containers reliably, and is built with standard open-source components.
Bottlerocket-specific additions focus on reliable updates and on the API.
Instead of making configuration changes manually, you can change settings with an API call, and these changes are automatically migrated through updates.

Some notable features include:
* [API access](#api) for configuring your system, with secure out-of-band [access methods](#exploration) when you need them.
* [Updates](#updates) based on partition flips, for fast and reliable system updates.
* [Modeled configuration](#settings) that's automatically migrated through updates.
* [Security](#security) as a top priority.

## Contact us

If you find a security issue, please [contact our security team](https://github.com/bottlerocket-os/bottlerocket/security/policy) rather than opening an issue.

If you're interested in contributing, thank you!
Please see our [contributor's guide](CONTRIBUTING.md).

We use GitHub issues to track other bug reports and feature requests.
You can look at [existing issues](https://github.com/bottlerocket-os/bottlerocket/issues) to see whether your concern is already known.

If not, you can select from a few templates and get some guidance on the type of information that would be most helpful.
[Contact us with a new issue here.](https://github.com/bottlerocket-os/bottlerocket/issues/new/choose)

If you just have questions about Bottlerocket, please feel free to [start or join a discussion](https://github.com/bottlerocket-os/bottlerocket/discussions).

We don't have other communication channels set up quite yet, but don't worry about making an issue or a discussion thread!
You can let us know about things that seem difficult, or even ways you might like to help.

## Variants

To start, we're focusing on the use of Bottlerocket as a host OS in AWS EKS Kubernetes clusters and Amazon ECS clusters.
We’re excited to get early feedback and to continue working on more use cases!

Bottlerocket is architected such that different cloud environments and container orchestrators can be supported in the future.
A build of Bottlerocket that supports different features or integration characteristics is known as a 'variant'.
The artifacts of a build will include the architecture and variant name.
For example, an `x86_64` build of the `aws-k8s-1.17` variant will produce an image named `bottlerocket-aws-k8s-1.17-x86_64-<version>-<commit>.img`.

Our first supported variants, `aws-k8s-1.15`, `aws-k8s-1.16`, and `aws-k8s-1.17`, support EKS as described above.
We also have a new `aws-ecs-1` variant designed to work with ECS.

## Architectures

Our supported architectures include `x86_64` and `aarch64` (written as `arm64` in some contexts).

## Setup

:walking: :running:

Bottlerocket is best used with a container orchestrator.
To get started with Kubernetes, please see [QUICKSTART-EKS](QUICKSTART-EKS.md).
To get started with Amazon ECS, please see [QUICKSTART-ECS](QUICKSTART-ECS.md).
These guides describe:
* how to set up a cluster with the orchestrator, so your Bottlerocket instance can run containers
* how to launch a Bottlerocket instance in EC2

To build your own Bottlerocket images, please see [BUILDING](BUILDING.md).
It describes:
* how to build an image
* how to register an EC2 AMI from an image

To publish your built Bottlerocket images, please see [PUBLISHING](PUBLISHING.md).
It describes:
* how to make TUF repos including your image
* how to copy your AMI across regions
* how to mark your AMIs public or grant access to specific accounts
* how to make your AMIs discoverable using [SSM parameters](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html)

## Exploration

To improve security, there's no SSH server in a Bottlerocket image, and not even a shell.

Don't panic!

There are a couple out-of-band access methods you can use to explore Bottlerocket like you would a typical Linux system.
Either option will give you a shell within Bottlerocket.
From there, you can [change settings](#settings), manually [update Bottlerocket](#updates), debug problems, and generally explore.

**Note:** These methods require that your instance has permission to access the ECR repository where these containers live; the appropriate policy to add to your instance's IAM role is `AmazonEC2ContainerRegistryReadOnly`.

### Control container

Bottlerocket has a ["control" container](https://github.com/bottlerocket-os/bottlerocket-control-container), enabled by default, that runs outside of the orchestrator in a separate instance of containerd.
This container runs the [AWS SSM agent](https://github.com/aws/amazon-ssm-agent) that lets you run commands, or start shell sessions, on Bottlerocket instances in EC2.
(You can easily replace this control container with your own just by changing the URI; see [Settings](#settings).)

You need to give your instance the SSM role for this to work; see the [setup guide](QUICKSTART-EKS.md#enabling-ssm).

Once the instance is started, you can start a session:

* Go to AWS SSM's [Session Manager](https://console.aws.amazon.com/systems-manager/session-manager/sessions)
* Select “Start session” and choose your Bottlerocket instance
* Select “Start session” again to get a shell

If you prefer a command-line tool, you can start a session with a recent [AWS CLI](https://aws.amazon.com/cli/) and the [session-manager-plugin](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-working-with-install-plugin.html).
Then you'd be able to start a session using only your instance ID, like this:

```
aws ssm start-session --target INSTANCE_ID
```

With the [default control container](https://github.com/bottlerocket-os/bottlerocket-control-container), you can make [API calls](#api) to configure and manage your Bottlerocket host.
To do even more, read the next section about the [admin container](#admin-container).

### Admin container

Bottlerocket has an [administrative container](https://github.com/bottlerocket-os/bottlerocket-admin-container), disabled by default, that runs outside of the orchestrator in a separate instance of containerd.
This container has an SSH server that lets you log in as `ec2-user` using your EC2-registered SSH key.
(You can easily replace this admin container with your own just by changing the URI; see [Settings](#settings).

To enable the container, you can change the setting in user data when starting Bottlerocket, for example EC2 instance user data:

```
[settings.host-containers.admin]
enabled = true
```

If Bottlerocket is already running, you can enable the admin container from the default [control container](#control-container) like this:

```
enable-admin-container
```

If you're using a custom control container, or want to make the API calls directly, you can enable the admin container like this instead:

```
apiclient -u /settings -m PATCH -d '{"host-containers": {"admin": {"enabled": true}}}'
apiclient -u /tx/commit_and_apply -m POST
```

Once you're in the admin container, you can run `sheltie` to get a full root shell in the Bottlerocket host.
Be careful; while you can inspect and change even more as root, Bottlerocket's filesystem and dm-verity setup will prevent most changes from persisting over a restart - see [Security](#security).

## Updates

Rather than a package manager that updates individual pieces of software, Bottlerocket downloads a full filesystem image and reboots into it.
It can automatically roll back if boot failures occur, and workload failures can trigger manual rollbacks.

The update process uses images secured by [TUF](https://theupdateframework.github.io/).
For more details, see the [update system documentation](sources/updater/).

### Update methods

There are several ways of updating your Bottlerocket hosts.

For EKS variants of Bottlerocket, we recommend using the [Bottlerocket update operator](https://github.com/bottlerocket-os/bottlerocket-update-operator) for automated updates.
You can also use one of the methods below for direct control of updates.

For the ECS preview variant of Bottlerocket, we recommend updating hosts using one of the methods below, until further automation is ready.

#### Update API

The [Bottlerocket API](#api) includes methods for checking and starting system updates.  You can read more about the update APIs in our [update system documentation](sources/updater/README.md#update-api).

#### Updog

You can update Bottlerocket using a CLI tool, `updog`, if you [connect through the admin container](#admin-container).

Here's how you can see whether there's an update:

```
updog check-update
```

Here's how you initiate an update:

```
updog update
reboot
```

(If you know what you're doing and want to update *now*, you can run `updog update --reboot --now`)

#### Bottlerocket Update Operator

If you are running the Kubernetes variant of Bottlerocket, you can use the [Bottlerocket update operator](https://github.com/bottlerocket-os/bottlerocket-update-operator) to automate Bottlerocket updates.

### Update rollback

The system will automatically roll back if it's unable to boot.
If the update is not functional for a given container workload, you can do a manual rollback:

```
signpost rollback-to-inactive
reboot
```

## Settings

Here we'll describe the settings you can configure on your Bottlerocket instance, and how to do it.

(API endpoints are defined in our [OpenAPI spec](sources/api/openapi.yaml) if you want more detail.)

### Interacting with settings

#### Using the API client

You can see the current settings with an API request:
```
apiclient -u /settings
```

This will return all of the current settings in JSON format.
For example, here's an abbreviated response:
```
{"motd":"...", {"kubernetes": ...}}
```

You can change settings by sending back the same type of JSON data in a PATCH request.
This can include any number of settings changes.
```
apiclient -m PATCH -u /settings -d '{"motd": "my own value!"}'
```

This will *stage* the setting in a "pending" area - a transaction.
You can see all your pending settings like this:
```
apiclient -u /tx
```

To *commit* the settings, and let the system apply them to any relevant configuration files or services, do this:
```
apiclient -m POST -u /tx/commit_and_apply
```

Behind the scenes, these commands are working with the "default" transaction.
This keeps the interface simple.
System services use their own transactions, so you don't have to worry about conflicts.
For example, there's a "bottlerocket-launch" transaction used to coordinate changes at startup.

If you want to group sets of changes yourself, pick a transaction name and append a `tx` parameter to the URLs above.
For example, if you want the name "FOO", you can `PATCH` to `/settings?tx=FOO` and `POST` to `/tx/commit_and_apply?tx=FOO`.
(Transactions are created automatically when used, and are cleaned up on reboot.)

For more details on using the client, see the [apiclient documentation](sources/api/apiclient/).

#### Using user data

If you know what settings you want to change when you start your Bottlerocket instance, you can send them in the user data.

In user data, we structure the settings in TOML form to make things a bit simpler.
Here's the user data to change the message of the day setting, as we did in the last section:

```
[settings]
motd = "my own value!"
```

### Description of settings

Here we'll describe each setting you can change.

**Note:** You can see the default values (for any settings that are not generated at runtime) by looking at [defaults.toml](sources/models/defaults.toml).

When you're sending settings to the API, or receiving settings from the API, they're in a structured JSON format.
This allows modification of any number of keys at once.
It also lets us ensure that they fit the definition of the Bottlerocket data model - requests with invalid settings won't even parse correctly, helping ensure safety.

Here, however, we'll use the shortcut "dotted key" syntax for referring to keys.
This is used in some API endpoints with less-structured requests or responses.
It's also more compact for our needs here.

In this format, "settings.kubernetes.cluster-name" refers to the same key as in the JSON `{"settings": {"kubernetes": {"cluster-name": "value"}}}`.

#### Top-level settings

* `settings.motd`: This setting is just written out to /etc/motd. It's useful as a way to get familiar with the API!  Try changing it.

#### Kubernetes settings

See the [setup guide](QUICKSTART-EKS.md) for much more detail on setting up Bottlerocket and Kubernetes.

The following settings must be specified in order to join a Kubernetes cluster.
You should [specify them in user data](#using-user-data).
* `settings.kubernetes.cluster-name`: The cluster name you chose during setup; the [setup guide](QUICKSTART-EKS.md) uses "bottlerocket".
* `settings.kubernetes.cluster-certificate`: This is the base64-encoded certificate authority of the cluster.
* `settings.kubernetes.api-server`: This is the cluster's Kubernetes API endpoint.

The following settings can be optionally set to customize the node labels and taints.
* `settings.kubernetes.node-labels`: [Labels](https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/) in the form of key, value pairs added when registering the node in the cluster.
* `settings.kubernetes.node-taints`: [Taints](https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/) in the form of key, value and effect entries added when registering the node in the cluster.
  * Example user data for setting up labels and taints:
    ```
    [settings.kubernetes.node-labels]
    label1 = "foo"
    label2 = "bar"
    [settings.kubernetes.node-taints]
    dedicated = "experimental:PreferNoSchedule"
    special = "true:NoSchedule"
    ```

The following settings are optional and allow you to further configure your cluster.
* `settings.kubernetes.cluster-domain`: The DNS domain for this cluster, allowing all Kubernetes-run containers to search this domain before the host's search domains.  Defaults to `cluster.local`.

The following settings are set for you automatically by [pluto](sources/api/) based on runtime instance information, but you can override them if you know what you're doing!
* `settings.kubernetes.max-pods`: The maximum number of pods that can be scheduled on this node (limited by number of available IPv4 addresses)
* `settings.kubernetes.cluster-dns-ip`: The CIDR block of the primary network interface.
* `settings.kubernetes.node-ip`: The IPv4 address of this node.
* `settings.kubernetes.pod-infra-container-image`: The URI of the "pause" container.

#### Amazon ECS settings

See the [setup guide](QUICKSTART-ECS.md) for much more detail on setting up Bottlerocket and ECS.

The following settings are optional and allow you to configure how your instance joins an ECS cluster.
Since joining a cluster happens at startup, they need to be [specified in user data](#using-user-data).
* `settings.ecs.cluster`: The name or [ARN](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) of your Amazon ECS cluster.
  If left unspecified, Bottlerocket will join your `default` cluster.
* `settings.ecs.instance-attributes`: [Attributes](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-constraints.html#attributes) in the form of key, value pairs added when registering the container instance in the cluster.
  * Example user data for setting up attributes:
    ```
    [settings.ecs.instance-attributes]
    attribute1 = "foo"
    attribute2 = "bar"
    ```

The following settings are optional and allow you to further configure your cluster.
These settings can be changed at any time.
* `settings.ecs.logging-drivers`: The list of logging drivers available on the container instance.
  The ECS agent running on a container instance must register available logging drivers before tasks that use those drivers are eligible to be placed on the instance.
  Bottlerocket enables the `json-file`, `awslogs`, and `none` drivers by default.
* `settings.ecs.allow-privileged-containers`: Whether launching privileged containers is allowed on the container instance.
  If this value is set to false, privileged containers are not permitted.
  Bottlerocket sets this value to false by default.
* `settings.ecs.loglevel`: The level of verbosity for the ECS agent's logs.
  Supported values are `debug`, `info`, `warn`, `error`, and `crit`, and the default is `info`.
* `settings.ecs.enable-spot-instance-draining`: If the instance receives a spot termination notice, the agent will set the instance's state to `DRAINING`, so the workload can be moved gracefully before the instance is removed. Defaults to `false`.

#### Updates settings

* `settings.updates.metadata-base-url`: The common portion of all URIs used to download update metadata.
* `settings.updates.targets-base-url`: The common portion of all URIs used to download update files.
* `settings.updates.seed`: A `u32` value that determines how far into the update schedule this machine will accept an update.  We recommend leaving this at its default generated value so that updates can be somewhat randomized in your cluster.
* `settings.updates.version-lock`: Controls the version that will be selected when you issue an update request.  Can be locked to a specific version like `v1.0.0`, or `latest` to take the latest available version.  Defaults to `latest`.
* `settings.updates.ignore-waves`: Updates are rolled out in waves to reduce the impact of issues.  For testing purposes, you can set this to `true` to ignore those waves and update immediately.

#### Network settings

##### Proxy settings

These settings will configure the proxying behavior of the following services:
* For all variants:
    * [containerd.service](packages/containerd/containerd.service)
    * [host-containerd.service](packages/host-ctr/host-containerd.service)
* For Kubernetes variants:
    * [kubelet.service](packages/kubernetes-1.18/kubelet.service)
* For the ECS variant:
    * [docker.service](packages/docker-engine/docker.service)
    * [ecs.service](packages/ecs-agent/ecs.service)

* `settings.network.https-proxy`: The HTTPS proxy server to be used by services listed above.
* `settings.network.no-proxy`: A list of hosts that are excluded from proxying.

The no-proxy list will automatically include entries for localhost.

If you're running a Kubernetes variant, the no-proxy list will automatically include the Kubernetes API server endpoint and other commonly used Kubernetes DNS suffixes to facilitate intra-cluster networking.

#### Time settings

* `settings.ntp.time-servers`: A list of NTP servers used to set and verify the system time.

#### Kernel settings

* `settings.kernel.lockdown`: This allows further restrictions on what the Linux kernel will allow, for example preventing the loading of unsigned modules.
  May be set to "none" (the default), "integrity", or "confidentiality".
  **Important note:** this setting cannot be lowered (toward 'none') at runtime.
  You must reboot for a change to a lower level to take effect.
* `settings.kernel.sysctl`: Key/value pairs representing Linux kernel parameters.
  Remember to quote keys (since they often contain ".") and to quote all values.
  * Example user data for setting up sysctl:
    ```
    [settings.kernel.sysctl]
    "user.max_user_namespaces" = "16384"
    "vm.max_map_count" = "262144"
    ```

#### Host containers settings
* `settings.host-containers.admin.source`: The URI of the [admin container](#admin-container).
* `settings.host-containers.admin.enabled`: Whether the admin container is enabled.
* `settings.host-containers.admin.superpowered`: Whether the admin container has high levels of access to the Bottlerocket host.
* `settings.host-containers.control.source`: The URI of the [control container](#control-container).
* `settings.host-containers.control.enabled`: Whether the control container is enabled.
* `settings.host-containers.control.superpowered`: Whether the control container has high levels of access to the Bottlerocket host.

##### Custom host containers

[`admin`](https://github.com/bottlerocket-os/bottlerocket-admin-container) and [`control`](https://github.com/bottlerocket-os/bottlerocket-control-container) are our default host containers, but you're free to change this.
Beyond just changing the settings above to affect the `admin` and `control` containers, you can add and remove host containers entirely.
As long as you define the three fields above -- `source` with a URI, and `enabled` and `superpowered` with true/false -- you can add host containers with an API call or user data.

You can optionally define a `user-data` field with arbitrary base64-encoded data, which will be made available in the container at `/.bottlerocket/host-containers/$HOST_CONTAINER_NAME/user-data`.
(It was inspired by instance user data, but is entirely separate; it can be any data your host container feels like interpreting.)

Here's an example of adding a custom host container with API calls:
```
apiclient -u /settings -X PATCH -d '{"host-containers": {"custom": {"source": "MY-CONTAINER-URI", "enabled": true, "superpowered": false}}}'
apiclient -u /tx/commit_and_apply -X POST
```

Here's the same example, but with the settings you'd add to user data:
```
[settings.host-containers.custom]
enabled = true
source = "MY-CONTAINER-URI"
superpowered = false
```

If the `enabled` flag is `true`, it will be started automatically.

All host containers will have the `apiclient` binary available at `/usr/local/bin/apiclient` so they're able to [interact with the API](#using-the-api-client).

In addition, all host containers come with persistent storage at `/.bottlerocket/host-containers/$HOST_CONTAINER_NAME` that is persisted across reboots and container start/stop cycles.
The default `admin` host-container, for example, stores its SSH host keys under `/.bottlerocket/host-containers/admin/etc/ssh/`.

There are a few important caveats to understand about host containers:
* They're not orchestrated.  They only start or stop according to that `enabled` flag.
* They run in a separate instance of containerd than the one used for orchestrated containers like Kubernetes pods.
* They're not updated automatically.  You need to update the `source`, disable the container, commit those changes, then re-enable it.
* If you set `superpowered` to true, they'll essentially have root access to the host.

Because of these caveats, host containers are only intended for special use cases.
We use it for the control container because it needs to be available early to give you access to the OS, and we use it for the admin container because it needs high levels of privilege and because you need it to debug when orchestration isn't working.

Be careful, and make sure you have a similar low-level use case before reaching for host containers.

#### Platform-specific settings

Platform-specific settings are automatically set at boot time by [early-boot-config](sources/api/early-boot-config) based on metadata available on the running platform.
They can be overridden for testing purposes in [the same way as other settings](#interacting-with-settings).

##### AWS-specific settings

AWS-specific settings are automatically set based on calls to the Instance MetaData Service (IMDS).

* `settings.aws.region`: This is set to the AWS region in which the instance is running, for example `us-west-2`.

### Logs

You can use `logdog` through the [admin container](#admin-container) to obtain an archive of log files from your Bottlerocket host.
SSH to the Bottlerocket host, then run:

```bash
sudo sheltie
logdog
```

This will write an archive of the logs to `/tmp/bottlerocket-logs.tar.gz`.
You can use SSH to retrieve the file.
Once you have exited from the Bottlerocket host, run a command like:

```bash
ssh -i YOUR_KEY_FILE \
    ec2-user@YOUR_HOST \
    "cat /.bottlerocket/rootfs/tmp/bottlerocket-logs.tar.gz" > bottlerocket-logs.tar.gz
```

For a list of what is collected, see the logdog [command list](sources/logdog/src/log_request.rs).

## Details

### Security

:shield: :crab:

To learn more about security features in Bottlerocket, please see [SECURITY FEATURES](SECURITY_FEATURES.md).
It describes how we use features like [dm-verity](https://gitlab.com/cryptsetup/cryptsetup/wikis/DMVerity) and [SELinux](https://selinuxproject.org/) to protect the system from security threats.

To learn more about security recommendations for Bottlerocket, please see [SECURITY GUIDANCE](SECURITY_GUIDANCE.md).
It documents additional steps you can take to secure the OS, and includes resources such as a [Pod Security Policy](https://kubernetes.io/docs/concepts/policy/pod-security-policy/) for your reference.

In addition, almost all first-party components are written in [Rust](https://www.rust-lang.org/).
Rust eliminates some classes of memory safety issues, and encourages design patterns that help security.

### Packaging

Bottlerocket is built from source using a container toolchain.
We use RPM package definitions to build and install individual packages into an image.
RPM itself is not in the image - it's just a common and convenient package definition format.

We currently package the following major third-party components:
* Linux kernel ([background](https://en.wikipedia.org/wiki/Linux), [packaging](packages/kernel/))
* glibc ([background](https://www.gnu.org/software/libc/), [packaging](packages/glibc/))
* Buildroot as build toolchain ([background](https://buildroot.org/), via the [SDK](https://github.com/bottlerocket-os/bottlerocket-sdk))
* GRUB, with patches for partition flip updates ([background](https://www.gnu.org/software/grub/), [packaging](packages/grub/))
* systemd as init ([background](https://en.wikipedia.org/wiki/Systemd), [packaging](packages/systemd/))
* wicked for networking ([background](https://github.com/openSUSE/wicked), [packaging](packages/wicked/))
* containerd ([background](https://containerd.io/), [packaging](packages/containerd/))
* Kubernetes ([background](https://kubernetes.io/), [packaging](packages/kubernetes-1.15/))
* aws-iam-authenticator ([background](https://github.com/kubernetes-sigs/aws-iam-authenticator), [packaging](packages/aws-iam-authenticator/))
* Amazon ECS agent ([background](https://github.com/aws/amazon-ecs-agent), [packaging](packages/ecs-agent/))

For further documentation or to see the rest of the packages, see the [packaging directory](packages/).

### Updates

The Bottlerocket image has two identical sets of partitions, A and B.
When updating Bottlerocket, the partition table is updated to point from set A to set B, or vice versa.

We also track successful boots, and if there are failures it will automatically revert back to the prior working partition set.

The update process uses images secured by [TUF](https://theupdateframework.github.io/).
For more details, see the [update system documentation](sources/updater/).

### API

There are two main ways you'd interact with a production Bottlerocket instance.
(There are a couple more [exploration](#exploration) methods above for test instances.)

The first method is through a container orchestrator, for when you want to run or manage containers.
This uses the standard channel for your orchestrator, for example a tool like `kubectl` for Kubernetes.

The second method is through the Bottlerocket API, for example when you want to configure the system.

There's an HTTP API server that listens on a local Unix-domain socket.
Remote access to the API requires an authenticated transport such as SSM's RunCommand or Session Manager, as described above.
For more details, see the [apiserver documentation](sources/api/apiserver/).

The [apiclient](sources/api/apiclient/) can be used to make requests.
They're just HTTP requests, but the API client simplifies making requests with the Unix-domain socket.

To make configuration easier, we have [early-boot-config](sources/api/early-boot-config/), which can send an API request for you based on instance user data.
If you start a virtual machine, like an EC2 instance, it will read TOML-formatted Bottlerocket configuration from user data and send it to the API server.
This way, you can configure your Bottlerocket instance without having to make API calls after launch.

See [Settings](#settings) above for examples and to understand what you can configure.

The server and client are the user-facing components of the API system, but there are a number of other components that work together to make sure your settings are applied, and that they survive upgrades of Bottlerocket.

For more details, see the [API system documentation](sources/api/).

branch_name: refs/heads/ouchi

extension: md

gha_language: Rust

gha_license_id: NOASSERTION

license_type: permissive


text:
# youtube-playlist-bandit
Quick way to pull down your favorite YouTube music playlists as audio files.

Mostly just a wrapper around [youtube-dl](https://github.com/rg3/youtube-dl), using the power of golang to download large playlists faster than the original library.

license: MIT

repository: MaxwellPayne/youtube-playlist-bandit

branch_name: refs/heads/master

repo_name: MaxwellPayne/youtube-playlist-bandit


text:
Deprecated
==
This library is no longer actively maintained and may break at some point in the near future.

fullcontact-objc
================

Ever wanted to call FullContact's API from your own iOS or OS X application?  Now you can.

fullcontact-objc is a library for iOS and Mac OS X. It's built on top of [AFNetworking](https://github.com/AFNetworking/AFNetworking) and provides connectivity to the [FullContact Developer API](http://www.fullcontact.com/developer/docs/) endpoints.

###Why we love it…
fullcontact-objc makes it painless to access the FullContact Developer API in your iOS or Mac OS X apps.

Currently this library has support for the following FullContact endpoints:

| Endpoint | What it Does | Documentation | Supported in
| ------------- |-------------| ------------- | -------------
| Person API     | Returns social profile data from an email address, phone number, Twitter handle, or Facebook ID | [Person API](http://www.fullcontact.com/developer/docs/person) | FCAPI+Person.h
| Name API      | Normalize, parse, compare, and deduce names from an email address or other source | [Name API](http://www.fullcontact.com/developer/docs/name) | FCAPI+Name.h
| Location API  | Normalizes and provides related info for semi-structured location data | [Location API](http://www.fullcontact.com/developer/docs/location) | FCAPI+Location.h
| Card Reader API | Returns human-transcribed, structured contact data from an image of a business card | [Card Reader API](http://www.fullcontact.com/developer/docs/card-reader) | FCAPI+CardReader.h
| Disposable Email API     | Detects disposable and sub-addressed email addresses | [Disposable Email API](http://www.fullcontact.com/developer/docs/email) | FCAPI+Email.h
| Icon API      | Returns free social media icons via an HTTPS request | [Icon API](http://www.fullcontact.com/developer/docs/icon) | FCAPI+Icon.h
| Batch Process API     | Batch several API requests into a single request to improve performance | [Batch Process API](http://www.fullcontact.com/developer/docs/batch) | FCAPI+Batch.h
| Stats API     | View and keep track of your FullContact API account usage | [Stats API](http://www.fullcontact.com/developer/docs/stats) | FCAPI+Stats.h

## Requirements

fullcontact-objc requires either [iOS 5.0](http://developer.apple.com/library/ios/#releasenotes/General/WhatsNewIniPhoneOS/Articles/iPhoneOS4.html) and above, or [Mac OS 10.7](http://developer.apple.com/library/mac/#releasenotes/MacOSX/WhatsNewInOSX/Articles/MacOSX10_6.html#//apple_ref/doc/uid/TP40008898-SW7) ([64-bit with modern Cocoa runtime](https://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtVersionsPlatforms.html)) and above.

###Installation

1. Add fullcontact-objc as a git submodule to your project.
2. Add [AFNetworking](https://github.com/AFNetworking/AFNetworking) as a submodule to your project and switch to the [1.x branch](https://github.com/AFNetworking/AFNetworking/tree/1.x).
3. Include fullcontact-objc wherever you need it with `#import "FCAPI.h"` or any of it's subcategories.

### ARC

fullcontact-objc uses ARC.

If you are using fullcontact-objc in your non-arc project, you will need to set a `-fobjc-arc` compiler flag on all of the source files.

To set a compiler flag in Xcode, go to your active target and select the "Build Phases" tab. Now select all fullcontact-objc source files, press Enter, insert `-fobjc-arc` and then "Done" to enable ARC for fullcontact-objc.

## Using the Library
### Initializing the API
To initialize the API, simply import FCAPI.h.  Ensure you have the following constants defined:

1. `kAPIUrl` is "https://api.fullcontact.com"
2. `kAPIVersion` is "v2"
3. `kAPIKey` is the API Key that you obtained from FullContact.

Then call:

```objective-c
FCAPI *api = [[FCAPI alloc] initWithBaseURL:[NSURL URLWithString:kAPIUrl] andVersion:kAPIVersion andAPIKey:kAPIKey];
```

### Calling the API
To use the API after it is initialized, simply import the category that you wish to use and invoke one of the methods.  For example, if you'd like to look up a person by their email address you could do the following:

Add the following to your imports:

```
#import "FCAPI+Person.h"
```

After initializing your API instance, call the lookupByEmail method as follows:

```objective-c
[api lookupByEmail<EMAIL_ADDRESS>success:^(FCResponse *response) {
      //response.response will contain your JSON payload which you can handle here
}
failure:^(FCResponse *response, NSError *error) {
      //handle the error that may have been returned
}];
```
### Running Tests
To run fullcontact-objcTest, simply locate the `TestContstants.h` file in the fullcontact-objcTest project and insert your API key as the value for `kAPIKey`.  After doing this you can run tests for both iOS and OSX architectures.

*Note that Card Reader tests only function for the iOS platform at this time.*

##Need Help - No Problem!
We're always available to help in any way we can.  Check out our [Support Page](http://support.fullcontact.com) to access our Knowledge Base or contact our Support group.

##Got an Idea?
We love ideas!  Submit your ideas, suggestions, or feedback on our [API Developer Forum](http://support.fullcontact.com/forums/187136-api-developer-forum) or fork our repo.  We review pull requests regularly and look forward to seeing what you come up with!

## License

fullcontact-objc is available under the Apache License Version 2.0 license. See the [LICENSE](LICENSE) file for more info.

[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/fullcontact/fullcontact-objc/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

repository: fullcontact/fullcontact-objc

gha_language: Objective-C

repo_name: fullcontact/fullcontact-objc


text:
# Installation

Installing the plugin(s) is same as any other Go plugins. Please follow the Go documentation on installing plugins.

Builds of the plugins are available through [Github releases](https://github.com/ind9/gocd-s3-artifacts/releases)

gha_language: Java


text:
<img src="https://lexica.io/assets/images/Lexica_Logo.svg" alt="Lexica" />

## Introduction
This repository contains frontend code for **Lexica virtual dialogue system admin portal**.

## Getting Started

## Licence
[MIT License](https://github.com/tomlai19852004/lexica-virtual-agent-admin-frontend/blob/master/LICENSE.md)

## Contributing
Contributions are welcome!

gha_language: TypeScript

gha_license_id: MIT


text:
---
layout: post
title: "4-Steps to Get Started in Machine Learning: The Top-Down Strategy for Beginners to Start and Practice"
date:   2016-08-04 00:00 IST
categories: ["machine learning"]
tags: ["machine learning"]
comments: true
analytics: true
---

<span/>

## 1. Reference:

[4-Steps to Get Started in Machine Learning: The Top-Down Strategy for Beginners to Start and Practice](http://machinelearningmastery.com/4-steps-to-get-started-in-machine-learning/)

## 2. Conclusion: Using before theory

This article shows that learn machine learning from Top-Down.
**Firstly**, learn how to use it.
**Finally**, learn the deeply about the algorithm.
I think it's a good and fast way for beginners.

## 3. Top-Down approach

 1. Learn the high-level process of applied machine learning.
 2. Learn how to use a tool enough to be able to work through problems.
 3. Practice on datasets, a lot.
 4. Transition into the details and theory of machine learning algorithms.

## 4. Applied Machine Learning Process

* Problem Definition
* Analyze Data
* Prepare Data
* Evaluate Algorithms
* Improve Results
* Present Results

## 5. Use the Weka Machine Learning Workbench

* [How to run your first classifier](http://machinelearningmastery.com/how-to-run-your-first-classifier-in-weka/)
* [How to design and run your first experiment](http://machinelearningmastery.com/design-and-run-your-first-experiment-in-weka/)
* [How to tune an algorithm rigorously in a designed experiment](http://machinelearningmastery.com/how-to-tune-a-machine-learning-algorithm-in-weka/)
* [How to use ensemble methods in Weka](http://machinelearningmastery.com/improve-machine-learning-results-with-boosting-bagging-and-blending-ensemble-methods-in-weka/)

## 6. Practice, Practice, Practice, on Datasets

## 7. Transitioning Deeper


text:
---
published: true
layout: post
title: "Неуспешно кандидатстване за Poplus"
category: sponsorship
---

Кандидатства се за финансиране от [Poplus](http://poplus.org/) за преизполване на техния софтуер. Poplus e проект на MySociety, които ни помагат по проекта Питай ги“.

> I hope you are well! I wanted to thank you for taking the time to apply to Poplus for some funding for your project. I know how hard you're working at the moment and on very little funds. I'm sad to have to tell you that your proposal, great as it was, couldn't be funded as we simply didn't have the money to fund everything, as much as we wanted to do that!
>
>I've attached a formal letter from the governance committee outlining the decision and also our commitment to try and help you, and your project, in other ways. Please do get in touch with me if any of the support offers interest you.
>
>I wish you all the best with your project, and hopefully we'll be speaking soon about continuing its progress together somehow.

Ето и [споменатато официално писмо](https://drive.google.com/file/d/0B4QEIaPHnvx6d3FydVRxRnJaaTBZajdiYXZPeHZNY1d1RFNv/view?usp=sharing).

Хубавото е, че са харесали проекта и предлагат помощта си за да потръгне „Следи парламента“.

Една от опциите е да ни помогнат с намирането на финансиране от други източници.

Всеки неуспех носи по нещо хубаво.


text:
---
id: kaios
title: KaiOS Platform
sidebar_label: KaiOS
---

## Requirements

-   [KaiOSrt](https://developer.kaiostech.com/simulator) for emulator

After installation you can launch it via Applications:

## Run

Run on Simulator

```
rnv run -p kaios
```

Run on Device

```
rnv run -p kaios -d
```

Run in Browser

```
rnv run -p kaios --hosted
```

repository: AlecRuste/renative

repo_name: AlecRuste/renative


text:
# CatBoardInterface
### By **Dusty McCord**  April 3rd 2020

ASP.NET core API application to track and display animals in an animal shelter.

## Specifications user stories:

* As a user, I want to be able to GET a list of all animals in the shelter.
* As a user, I want to be able to POST a new animal to the shelter Database.
* As a user, I want to be able to Get details of a specific animal.
* As a user, I want to be able to PUT and DELETE Animal entries in the database.

## API End Points
```
GET /api/Animals
POST /api/Animals
GET /api/Animals/{AnimalId}
PUT /api/Animals/{AnimalId}
DELETE /api/Animals/{AnimalId}
```

## Further Explorations include
* installed swagger with Nswg
* [Versioned API](https://neelbhatt.com/2018/04/21/api-versioning-in-net-core/)

## Setup/Installation Requirements
_Make sure you have these tools installed on your computer:_
*  [Git version control](https://git-scm.com/downloads)
*  [MySql](https://azure.microsoft.com/en-us/free/mysql/)
*  [Microsoft .Net Core 2.2](https://docs.microsoft.com/en-us/dotnet/framework/install/)
*  [.Net Script](https://dotnet.microsoft.com/download/dotnet-core/2.2)

### Prerequisites

1. [.NET Framework](https://dotnet.microsoft.com/download/thank-you/dotnet-sdk-2.2.106-macos-x64-installer)
2. Text Editor (Visual Studio Code)

### Installing
_In your terminal_

* Clone the project from GitHub by typing:
```sh
git clone  https://github.com/dustatron/AnimalShelter
```

* Navigate to the project folder by typing:
```sh
cd AnimalShelter/ApiAnimalShelter
```
* Restore the project with this terminal command:
```sh
dotnet restore
```

Build the database by entering the command:
```sh
dotnet ef database update
```

Run the program by typing:
```sh
dotnet run
```
Navigate to the MVC project
```sh
cd ../MvcAnimalShelter
```
Run the MVC project to see the front end by typing:
```sh
dotnet run
```
View MVC project by going to this address in your browser:
```sh
http://localhost:5010/
```
View Endpoint by entering the follow address in your browser:
```sh
http://localhost:5000/swagger
```

## Technologies Used

* C#
* ASP.NET core MVC 2.2
* RestSharp API
* Entity Framework
* Newtonsoft.Json
* MySqlConnector
* Razer
* Git
* Nswag
* [Materializecss](https://materializecss.com/)

## Known Bugs
Currently there's no known bugs.

## Contact Info
Currently there's no known bugs, however, if there are any issues running this website I would love feedback! Please email us at
*<EMAIL_ADDRESS>

## License

Licensed under the MIT license.

© 2020 Dusty McCord.

repository: dustatron/AnimalShelter

gha_language: C#

repo_name: dustatron/AnimalShelter


text:
---
layout: post
title: 'Friday Links #191'
---
**Programming**

[Coming Soon: TFS Express](http://blogs.msdn.com/b/bharry/archive/2012/02/23/coming-soon-tfs-express.aspx)
[Tinker — Social Code Collaboration](https://tinker.io/22681/2)
[ASP.NET Web API and ELMAH Integration](http://www.tugberkugurlu.com/archive/asp-net-web-api-and-elmah-integration)
[JavaScript libraries related to different file types](https://github.com/bebraw/jswiki/wiki/File-Formats)
[Valid JavaScript variable names · Mathias Bynens](http://mathiasbynens.be/notes/javascript-identifiers)
[ResponsiveSlides.js · Responsive jQuery slideshow](http://responsive-slides.viljamis.com/)
[C# + ReSharper = Awesome: Tip #10 of 10 – Generate Equality Members](http://feedproxy.google.com/~r/alvinashcraft/~3/bmYmg3PE0Hk/)
[Introducing the New Developer Experience - The Visual Studio Blog - Site Home - MSDN Blogs](http://blogs.msdn.com/b/visualstudio/archive/2012/02/23/introducing-the-new-developer-experience.aspx)
[Introducing the New Developer Experience, Part #2 - The Visual Studio Blog - Site Home - MSDN Blogs](http://blogs.msdn.com/b/visualstudio/archive/2012/02/24/introducing-the-new-developer-experience-part2.aspx)

**Applications**

[Springpad: a free app that helps you remember](http://springpadit.com/home/;jsessionid=2B720D3D842C4B6F7DA442FEA08135FE.SPAD_NODE14)
[ESBUnitConv: The Only Unit Conversion Tool You Need [Windows]](http://feedproxy.google.com/~r/Makeuseof/~3/gQi4X20q634/)
[Love NPR? Check out “Infinite Player”, which streams NPR programming tailored to your interests](http://feedproxy.google.com/~r/Freewaregeniuscom/~3/furJE1YAvDg/)

**Science and Technology**

[Final push' on polio](http://www.bbc.co.uk/go/rss/int/news/-/news/health-17072769)
[Circling The Globe In A Solar Car](http://www.wired.com/autopia/2012/02/circling-the-globe-in-a-solar-car/)
[One step closer to a new kilogram](http://www.sciencedaily.com/releases/2012/02/120220090610.htm)
[Vaccine Could Cut Heroin Addiction](http://rss.slashdot.org/~r/slashdot/eqWf/~3/CCYs_Mf_o_c/vaccine-could-cut-heroin-addiction)
[Have Bad Cars Gone Extinct? – Slashdot](http://tech.slashdot.org/story/12/02/22/0314208/have-bad-cars-gone-extinct)
[World's longest kidney transplant chain completed](http://feeds.sciencedaily.com/~r/sciencedaily/~3/t0Wpa2K9vJg/120220102128.htm)
[Russian Scientists Revive Plant From 30,000-Year-Old Seeds](http://rss.slashdot.org/~r/slashdot/eqWf/~3/-JPlHMQgY_o/russian-scientists-revive-plant-from-30000-year-old-seeds)
[With New Standard, Wi-Fi Could Become As Widespread As Cellular](http://www.popsci.com/technology/article/2012-02/wi-fi-could-become-widespread-cellular)
[Replacing electricity with light: First physical 'metatronic' circuit created](http://www.sciencedaily.com/releases/2012/02/120223183809.htm)
[Video: Wireless Devices Swim Through Your Bloodstream and Fix You Up, 'Fantastic Voyage' Style](http://www.popsci.com/technology/article/2012-02/new-wireless-devices-can-swim-through-bloodstream-and-fix-you-fantastic-voyage-style)

**On the Web**

[Should All Web Traffic Be Encrypted?](http://www.codinghorror.com/blog/2012/02/should-all-web-traffic-be-encrypted.html)
[Fluent Is a Badass Web-Based Gmail Client](http://lifehacker.com/5887691/fluent-brings-sparrow+like-minimalist-styling-to-gmail)
[Jpg.to Is the Most Efficient Way to Find Funny, Time-Wasting Images](http://lifehacker.com/5887795/jpgto-is-the-most-efficient-way-to-find-funny-time+wasting-images)

**Stuff I Just Like**

[Enter The $5 LED Lightbulb](http://toolmonger.com/2012/02/22/enter-the-5-led-lightbulb/)
[Solar Plane Pilot Midway Through 72-Hour Sim](http://www.wired.com/autopia/2012/02/solar-impulse-pilot-midway-through-72-hour-flight-simulation/)
[Google to Sell Heads-Up Display Glasses by Year's End - NYTimes.com](http://bits.blogs.nytimes.com/2012/02/21/google-to-sell-terminator-style-glasses-by-years-end/?hp)
[Raspberry Pi – A Credit-Card Sized ARM Computer – Yours For Only $25](http://feedproxy.google.com/~r/Makeuseof/~3/UMd16-CEXbk/)

gha_language: HTML


text:
---
layout: post
title: World clothing
---

![Clothing photo](/images/clothing.jpg)

## Different CLOTHING ALL AROUND THE WORLD

 We wear our culture clothing at a festival we celebrate as a culture. Some people wear their cultural clothing at a church or temples. We wear them to represent who we are and our culture.

[Click Here for more](https://www.livescience.com/28945-american-culture.html)


text:
We have seen methods where the containers have used the IP address of host to communicate with each other, but there are solutions to inter-connect the containers by using their own IPs. If we are using the containers own IPs for routing then it is important that we shall be able to distinguish based on IP which container is running on Host1 and which one is running on on Host2. Steps below illustrate how to use static route to enable multi-host docker network communication.

## Prerequistie
* two VMs(Host1 and Host2) with the same subnet
* docker 1.6 installed on each host

## Reconfigure docker0 bridge
Since we route traffic based on containers' IPs, we have to avoid IP address conflicts, so we will allocate different subnets for Host1 and Host2.
On Host1, run this commands:

```
[root@Host1 ~]# ifconfig docker0 <IP_ADDRESS>/18
[root@Host1 ~]# service docker restart
```
run the same command on Host2:

```
[root@Host2 ~]# ifconfig docker0 <IP_ADDRESS>/18
[root@Host2 ~]# service docker restart
```
After this, `docker daemon` will use the subnets configured to allocate IP for each new container.

## Add route and reset iptables
On Host1, we need to forward packets which destination is `<IP_ADDRESS>/18` to Host2, also we have to reset iptables rules. Run these commands on Host1:

```
[root@Host1 ~]# route add -net <IP_ADDRESS> netmask <IP_ADDRESS> gw <IP_ADDRESS>
[root@Host1 ~]# iptables -t nat -F POSTROUTING
[root@Host1 ~]# iptables -t nat -A POSTROUTING -s <IP_ADDRESS>/18 ! -d <IP_ADDRESS>/16 -j MASQUERADE
```
On Host2, run the opposite commands:

```
[root@Host1 ~]# route add -net <IP_ADDRESS> netmask <IP_ADDRESS> gw <IP_ADDRESS>
[root@Host1 ~]# iptables -t nat -F POSTROUTING
[root@Host1 ~]# iptables -t nat -A POSTROUTING -s <IP_ADDRESS>/18 ! -d <IP_ADDRESS>/16 -j MASQUERADE
```
By default, `docker` sets up a rule to the nat table to masquerade all IP packets that are leaving the machine. In this test case, we definitely don’t want this, therefore we delete all MASQUERADE rules with -F option. At this point we already would be able to make the connection from one container to other and vice verse, but the containers would not be able to communicate with the outside world, therefore an iptables rule needs to be added to masquerade the packets that are going outside of <IP_ADDRESS>/16.

## Test with qperf
On Host1, start `qperf_server` container:

```
[root@Host2 ~]# docker run -ti --rm --name qperf_server -p 4000:4000 -p 4001:4001 qperf /bin/bash
[root@1c70fed0cc70 /]# qperf -lp 4000
```

On Host2, start `qperf_client` container and run the the test script:

```
[root@Host2 ~]# docker run -ti --rm --name qperf_client qperf /bin/bash
[root@a55793ee24f5 /]# ./qperf_test.sh
```

Such kind of direct routing from one vm to other vm works great and easy to set up, but cannot be used if the hosts are not on the same subnet.


text:
# Example 2 - SOS or SOS

Send the distress signal properly in Morse code using the Arduino built-in LED.

In this example you will learn how to send prosigns, which are Morse code
patterns created by combining multiple letters as one.

The distress signal SOS is a prosign and in Morse code it does not look like
three letters, but one!

repository: imfrancisd/MorseCodeMachine

repo_name: imfrancisd/MorseCodeMachine


text:
# description
1. node web template is WEB structure.
2. Express is web framework.
3. Swig is view template engine.

# Guid
1. need install nodejs V6 .  (請先安裝 nodejs )
2. need install redis (do session share).
redis windows ref https://github.com/MSOpenTech/redis/releases

# Getting started
1. npm install
2. gulp clean
3. gulp dev
4. gulp build
5. node ./service/appCore/test.js  or npm start

# Folder
service/appCore 		//app server core code

service/config/** 		// runtime config of app server.

service/configTmp/** 	// environment template of app server.

service/controller      // controller layer of MVC

service/model 		    // model layer of MVC

service/views      		// view layer of MVC

service/webResource/**	// web resource (babel coffee react sass)

web/dist                // build output

# gulp CLI
gulp					// default action.
gulp info				// pring current environment info.
gulp production			// change environment to production.
gulp test				// change environment to test.
gulp dev				// change environment to dev devlopers.
gulp clean				// delete temp and dist floder.
gulp babel				// compile babel to javascript and merge js model.
gulp coffee				// compile coffeeScript to javascript and merge js model.
gulp sass				// compile sass to css and merge css model and minfy.
gulp build				//

# module
redis : Redis client.
express-session  : server-side session storage, MemoryStore.
connect-redis : is a Redis session store backed by node_redis. (Persistence)
cookie-parser : express cookie manager module.

# redis
1. install & download
windows : https://github.com/MSOpenTech/redis/releases
linux : http://redis.io/download

2. redis start
redis windows start : redis-server redis.windows.conf
redis client :  redis-cli

3. find all keys
 KEYS *

4. find data
GET [your key]

#nginx load balancer
1. set nginx.conf
```
#user  nobody;
worker_processes  4;

#error_log  logs/error.log;
#error_log  logs/error.log  notice;
#error_log  logs/error.log  info;

#pid        logs/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;

    #log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
    #                  '$status $body_bytes_sent "$http_referer" '
    #                  '"$http_user_agent" "$http_x_forwarded_for"';

    #access_log  logs/access.log  main;

    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;

	#壓縮功能
    gzip  on;

	upstream app-server {
		#Use Least Connections strategy (最少連接數策略)
		least_conn;
		server <IP_ADDRESS>:1337 weight=1;
		server <IP_ADDRESS>:1338 weight=1;
		#weigth  權值越高被分配到的機率越大
		#server <IP_ADDRESS>:8080 weight=1;
		#server <IP_ADDRESS>:9080 weight=1;
	}

    server {
        listen       80;
        server_name  localhost;
		charset utf-8;
        #charset koi8-r;

        #access_log  logs/host.access.log  main;

		# Browser and robot always look for these
		# Turn off logging for them
		#location = /favicon.ico { log_not_found off; access_log off; }
		#location = /robots.txt  { log_not_found off; access_log off; }

		# Handle static files so they are not proxied to NodeJS
		# You may want to also hand these requests to other upstream
		# servers, as you can define more than one!
		#location ~ ^/(images/|img/|javascript/|js/|css/|stylesheets/|flash/|media/|static/|robots.txt|humans.txt|favicon.ico) {
		#  root /var/www;
		#}
		#location ~ .*\.(htm|gif|jpg|jpeg|bmp|png|ico|txt|js|css|eot|svg|ttf|woff)$    //可用靜態資源型態
        #{
        #     root public;   //這是指nginx底下有新增一個資料夾叫public
        #     expires      7d;
        #}

        location / {
            #root   html;
            #index  index.html index.htm;
			proxy_set_header X-Real-IP $remote_addr;
			proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
			proxy_set_header Host $http_host;
			proxy_set_header X-NginX-Proxy true;

			proxy_pass http://app-server/;
			proxy_redirect off;

			# Handle Web Socket connections
			proxy_http_version 1.1;
			proxy_set_header Upgrade $http_upgrade;
			proxy_set_header Connection "upgrade";
        }

        #error_page  404              /404.html;

        # redirect server error pages to the static page /50x.html
        #
        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }

        # proxy the PHP scripts to Apache listening on <IP_ADDRESS>:80
        #
        #location ~ \.php$ {
        #    proxy_pass   http://<IP_ADDRESS>;
        #}

        # pass the PHP scripts to FastCGI server listening on <IP_ADDRESS>:9000
        #
        #location ~ \.php$ {
        #    root           html;
        #    fastcgi_pass   <IP_ADDRESS>:9000;
        #    fastcgi_index  index.php;
        #    fastcgi_param  SCRIPT_FILENAME  /scripts$fastcgi_script_name;
        #    include        fastcgi_params;
        #}

        # deny access to .htaccess files, if Apache's document root
        # concurs with nginx's one
        #
        #location ~ /\.ht {
        #    deny  all;
        #}
    }

    # another virtual host using mix of IP-, name-, and port-based configuration
    #
    #server {
    #    listen       8000;
    #    listen       somename:8080;
    #    server_name  somename  alias  another.alias;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}

    # HTTPS server
    #
    #server {
    #    listen       443 ssl;
    #    server_name  localhost;

    #    ssl_certificate      cert.pem;
    #    ssl_certificate_key  cert.key;

    #    ssl_session_cache    shared:SSL:1m;
    #    ssl_session_timeout  5m;

    #    ssl_ciphers  HIGH:!aNULL:!MD5;
    #    ssl_prefer_server_ciphers  on;

    #    location / {
    #        root   html;
    #        index  index.html index.htm;
    #    }
    #}

}
```

repository: oceanTsai/node-template

repo_name: oceanTsai/node-template


text:
Using "Endswitch". Syntactic Sugar!

You have two ways of creating a switch. First, there's the way we have made all the past exercises:

switch ($i) {

}
But we can also make it this way:

switch ($i):

endswitch;
This is called alternative syntax. It exists to provide syntactic sugar

There's no difference when using either the curly brace syntax (first example) or alternative syntax (second example), it only provides readability, thus it's usually used when mixing HTML and PHP code in the same file.

Instructions
In the editor you have the code of the previous exercise. Make the code use the alternative syntax rather than the curly-brace syntax.

url: https://raw.githubusercontent.com/akgnitd/CodeAcademy/48ab6aa37fbdd61e567972cbccb0a06004877966/PHP/X3 Control Flow Switch/5Using Endswitch. Syntactic Sugar/readme.md

repository: akgnitd/CodeAcademy

repo_name: akgnitd/CodeAcademy


text:
# budavolgyi-balint-cv
My cli npm package CV

## Install

```bash
$ npm install -g budavolgyi-balint-cv
```

## Usage

```bash
$ budavolgyi-balint-cv
```

## No install version

Hello there! My name is *Budavölgyi Bálint*.

I am a junior web developer with experience in planning, building, and maintaining modern websites, webshops, mobile and web applications.

Welcome to my CV!

- [Screenshot](#screenshot)
- [Education](#education)
- [Experience](#experience)
- [Dev Skills](#dev-skills)
- [Portfolio](#portfolio)
- [Contact](#contact)

### Screenshot

![Screenshot of my cli CV](/images/screenshot.png)

### Education

- Web development and online marketing certifications - [https://github.com/bala92x/certs](https://github.com/bala92x/certs)
- English language exam
  - Intermediate level
  - BME
  - 2013
- Recreation Management and Health Promotion
  - BSc
  - Nyugat Magyarországi Egyetem
  - 2010 - 2013
- Graduation
  - Dr. Mező Ferenc Gimnázium
  - 2006 - 2010

### Experience

- AZ Ügynökség/Kaméleonline - since 2017 August
  - Web Developer
  - [https://kameleonline.hu](https://kameleonline.hu)
- Own side projects - since 2017 January

### Dev Skills
(years of experience in the installable version)

- Javascript
  - Vanilla JS
  - Node.js
    - Express
    - Meteor
  - jQuery
  - React
    - React Native
    - Gatsby
  - AngularJS
  - Handlebars
  - Testing
    - Mocha
    - Jest
    - Enzyme
- PHP
  - Laravel
  - WordPress
- HTML5
- CSS3
  - Bootstrap
  - SCSS
- Databases and Query Languages
  - MySQL
  - MongoDB
  - Firebase
  - GraphQL
- Tools, Services, etc.
  - Git
  - Webpack
  - Redux
  - Heroku
  - Google (Ads, Analytics, Search Console)

### Portfolio

- Open Source
    - shor10
        - description: Link shortener app with Meteor and React
        - source: https://github.com/bala92x/shor10
        - demo: https://shor10.herokuapp.com
    - expensify
        - description: Expense manager application with React, Redux, and Firebase
        - source: https://github.com/bala92x/expensify
        - demo: https://bala-expensify.herokuapp.com
    - chat-app
        - description: Simple Node.js based chat app with socket.io integration
        - source: https://github.com/bala92x/chat-app
        - demo: https://brit-tudosok-chat.herokuapp.com
    - score-keeper
        - description: Simple score keeper app with Meteor and React
        - source: https://github.com/bala92x/score-keeper
        - demo: https://bala-score-keeper.herokuapp.com
    - indecision-app
        - description: Simple decision maker app with React
        - source: https://github.com/bala92x/indecision-app
        - demo: http://bala-indecision-app.herokuapp.com
    - task-manager
        - description: Node.js task manager API with JWT authorization
        - source: https://github.com/bala92x/task-manager
        - demo: https://bala-task-manager.herokuapp.com
    - More open source projects: https://github.com/bala92x
- Projects I contributed to
    - Agora Lakópark
        - description: Website of an 11 building residential park, with complex administration backend
        - url: https://agorapark.hu
        - framework: Laravel 5.3
    - Pannon Oktatási Központ
        - description: Website of an educational institution, with administration backend and the opportunity of signing up for courses
        - url: https://www.oktatasioldal.hu
        - framework: Laravel 5.4
    - Auto Finesse webshop
        - description: Webshop of car detailing products. Hundreds of products, several payment options and Facebook Shop synchronization
        - url: https://afshop.hu
        - CMS: WordPress
    - Micsoda esküvő
        - description: Portfolio site of a marriage celebrant
        - url: https://kulonlegesszertartas.hu
        - CMS: WordPress
    - More projects I contributed to: https://brandingpage.hu

### Contact

- Name: Budavölgyi Bálint
- Email<EMAIL_ADDRESS>- Former CV (hungarian): [http://cv.balavel.hu/](http://cv.balavel.hu/)

### Thank you for your time! I look forward to hearing from you soon.

gha_language: JavaScript


text:
# Common recurrent neural network architectures
There are multiple ways to define a [recurrent neural network](recurrent_neural_networks.md).

## RNN with Recurrent connection between hidden units producing output every time step.

This is an universal network, which means it can compute any function that a touring machine can with a finite state.

![](../.images/machine_learning/hidden_state_recurrence.png)

$$
a^{(t)} = b = Wh^{(t-1)} + Ux^{(t)} \\
h^{(y)} = \tanh(a^{(t)}) \\
o^{(t)} = c + Vh^{(t)} \\
\tilde{y}^{(t)} = \text{softmax}(o^{(t)})
$$

This maps an input sequence to a output sequence of the same length. The total loss for a sequence is the sum of losses over all the time steps. The gradient computation involves performing an forward propagation pass moving left to right on the unfolded graph, followed by backward pass right to left on the unfolded graph.

The runtime cost is $O(\tau)$ and cannot be parallelized since the operations are sequential. The space cost is also $O(\tau)$ since we need to keep intermediate values during the backward pass. The algorithm to perform back-propagation is called [back-propagation trough time](backpropagation_trough_time.md)

## RNN with recurrent connection between output and hidden units producing output every time step.

We propagate only the output to the next hidden state. Thus the hidden states are connected only by their predictions.  This network is less powerful than the one that has a recurrent connection between hidden states, but it is cheaper to train.

![](../.images/machine_learning/recurrent_nn_output_to_hidden_state.png)

## RNN producing a single outcome after reading the whole sequence

This is used to summarize an entire sequence and produce a fixed representation for future processing.

![](../.images/machine_learning/rnn_single_output.png)

branch_name: refs/heads/main


text:
EnVistas
========

A temp repo for converting [VISTAS](https://bitbucket.org/nikmolnar/vistas/overview) into a backend for [ENVISION](http://envision.bioe.orst.edu/Default.aspx).

###Build
Download the dependencies (target.zip) at https://bitbucket.org/nikmolnar/vistas/downloads. You need to define a few environment variables:

-VISTAS_DIR, this is the directory containing the unzipped dependencies.

-BOOST_DIR, self-explanatory

The current build will copy all .dll files from the dependencies folder into the executable directory.

Your .envx file then needs the following configuration:
```
<visualizers>
  <visualizer
    name = 'EnVistas'
    path = 'OUTPUT_PATH\EnVistas.dll'
    id = '0'
    use = '1'
    type = '6'
    initInfo = ''
  />
</visualizers>
```
`OUTPUT_PATH` is simply the output directory of your Envision build.

repository: ratanasv/EnVistas

repo_name: ratanasv/EnVistas


text:
# Logic.js

This project is work in progress.

## Problem
The primary goal of these libs / apps at the current scope is to be educational.

I've seen educational sources use custom-made diagrams and animations of logic gate structures.
They may be quite time-consuming to make, quality can be shitty, aren't interactive or easily replicated by the audience.
There are already some solutions to this, but they are proprietary and/or not free, as far as I know. (Not tested them out yet)
* https://logic.ly
* https://simulator.io

## Solution
The solution I'm working on would be FOSS and much more advanced.

## Here's what I had in mind

* The application(s) would be separated to multiple libraries for maximum benefit to open-source community, games also.

" The library only comes with needed basic components (logic gates) out of the box and supports abstractions (packages), exporting and importing for further needs and maximizing reality.

* For export / import there could be developed a readable markup language.
Initially thought of an assembly like language, but we need something more readable.

* Step-by-step debugging.

That is where the current scope would end, but ideas for next milestone, which are needed to keep in mind, are as follows:

* Porting APIs to C++ to provide more performant execution environment for more complicated simulations.

* Creating compiler for the language for even more performance if someone with no life really wants to program using the previously mentioned language.

# Current state of the project

* Fundamental logic and gates are done. Needs a lot of reality checking.

* Currently working on diagram drawing. A lot of work there.

* Needs to be separated to a new repository to satisfy the modularity goal.

## Help needed

1. Code review (most important)
2. Project management and documentation (I'll still lead)
3. Testing and unit testing
4. Visualization library
5. Editor web application (first real-life implementation)

If you find yourself capable of doing some or all of the above (in order of importance), I'm honored to get a helping hand or a partner.
All comments and ideas are welcome too.


text:
Galois Theory
------

(Section 53) Galois Theory

(Recall)

Let F \le E \le \bar{F}, \alpha \in E , and let \beta be a conjugate of \alpha over F, irr(\alpha F) has \beta as a zero also. Then there is an isomorphism \psi_{\alpha , \beta } mapping F(\alpha ) onto F(\beta ) that leaves F fixed and maps \alpha onto \beta.

If F \le E \le \bar{F} and \alpha \in E, then an automorphism \sigma of \bar{F} that leaves F fixed must map \alpha onto some conjugate of \alpha over F.

If F \le E, the collection of all automotphisms of E leaving F fixed forms a group G(E/F) . For any subset S of G(E/F) , the set of all elements of E left fixed by all elements of S is a field E_{s} . Also, F \le E_{G(E/F)} .

A field E , F \le E \le \bar{F}, is a splitting field over F iff every isomorphism of E onto a subfield of \bar{F} leaving F fixed is an automorphism of E. If E is a finite extension and a splitting field over F, then |G(E/F)| = {E : F} .

If E is a finite extension of F, then {E : F} divides [E : F] . If E is also separable over F, then {E : F} = [E : F]. Also, E is separable over F iff irr( \alpha , F ) has all zeros of multiplicity 1 for every \alpha \in E.

If E is a finite extension of F and is separable splitting field over F, then |G(E/F)| = {E:F} = [E : F].

(subsection) Normal Extensions

(Def 53.1) A finite extension K of F is a finite normal extension of F if K is a separable splitting field over F.

(Thm 53.2) Let K be a finite normal extension of F, and let E be an extension of F, where F \le E \le K \le \bar{F}. Then K is a finite normal extension of E< and G(K/E) is precisely the subgroup of G(K/F) consisting of all those automorphisms that leave E fixed.

Moreover, two automorphisms \sigma and \tau in G(K/F) induce the same isomorphisms of E onto a subfield of \bar{F} iff they are in the same left coset of G(K/E) in G(K/F).

(subsection) Main Theorem

(Def 53.5) If K is a finite normal extension of a field F, then G(K/F) is the Galois group of K over F.

(Main theorem of Galois Theory) (Thm 53.6) Let K be a finite normal extension of a field F, with Galois group G(K/F) . For a field E< where F \le E \le K, let \lambda(E) be the subgroup of G(K/F) leaving E fixed. Then \lambda is a one-to-one map of the set of all such immediate fields E onto the set of all subgroups of G(K/F). The following properties hold for \lambda.

\lambda (E) = G(K/E)

E = K_{G(K/E)} = K_{\lambda (E)}

For H \le G(K/F) , \lambda(E_{H}) = H

[K : E] = |\lambda (E)} and [E : F] = (G(K/F) : \lambda(E) ), the number of left cosets of \lambda(E) in G(K/F).

E is a normal extension of F iff \lambda(E) is a normal subgroup of G(K/F). When \lambda(E) is a normal subgroup of G(K/F), then G(E/F) \simeq G(K/F) / G(K/E).

The diagram of subgroups of G(K/F) is the inverted diagram of intermediate field of K over F.

(prop) The Galois group G(K/F) is the group of polynomial f(x) over F.

(subsection) Galois Groups over Finite fields

(Thm 53.6) Let K be a finite extension of degree n of a finite field F of p^{r} elements. Then G(K/F) is cyclic of order n, and is generated by \sigam_{p^{r}} , where for \alpha \in K, \sigma_{p^{r}} (\alpha) = \alpha^{p^{r}}.

filename: Galois Theory.md


text:
#
 Workspace for Pip.Services Samples

This is a workspace for [Pip.Services V3](http://www.pipservices.org) samples implemented in all supported programming languages. It container the following components:

- **service-quickstart-lang** - QuickStart sample
- **service-beacons-lang** - Sample data microservice
- **client-beacons-lang** - Client library to sample data microservice
- **sample-beacons-lang** - Step-by-step guide to create a sample data microservice
- **facade-sample-lang** - Sample facade

## Installation

Clone this workspace to local disk
```bash
> git clone https://github.com/pip-services-samples/pip-services-samples-ws.git
```

## Usage

Clone module repositories
```bash
./checkout.ps1
```

## Acknowledgements

Pip.Services are created and maintained by:
- **Dmitry Levichev**
- **Danil Prisyazhniy**
- **Sergey Seroukhov**


text:
# ListCase

Example of Clean Architecture implementation for Android.

In this example you can find how to:

1. make standard list of items with pagination support using [RxJava 2](https://github.com/ReactiveX/RxJava) (new data automatic retrieving while scrolling the list)
2. use [Retrofit](https://github.com/square/retrofit) for networking
3. use [Moxy](https://github.com/Arello-Mobile/Moxy) for MVP
4. use [Cicerone](https://github.com/terrakok/Cicerone) for navigation
5. use [Dagger 2](https://github.com/google/dagger) for DI
6. organize package structure

## Application description

The application retrieves the list of popular Android repositories from GitHub:

![Alt text](/screenshot.png?raw=true "ListCase screenshot")

Project details web page is opened on list item click.

License
-----
    Copyright (C) 2017. Alexander Bilchuk

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

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

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.

repository: sandrfx/ListCase

repo_name: sandrfx/ListCase


text:
## README ##

### Snap Receipts ###

This is web application for receipt tracking and digitizing your receipts. The app reads text data from an uploaded image using the Tesseract OCR Library. User interface created with AJAX and jQuery. Receipt location is geocoded and tracked with Google Maps

![Image of Snap Receipts](https://github.com/jzntam/Snap_Receipts/blob/master/snap.gif)


text:
## James Gawley's Professional Profile

Based on the [Indigo Minimalist Jekyll Template](https://github.com/sergiokopplin/indigo) by Sérgio Kopplin @sergiokopplin - [Theme Demo](http://sergiokopplin.github.io/indigo/)

## Base Theme Features

- Home Page
- Blog
- Projects
- About
- Responsive layout with option for narrow/wide
- Tagging
- Animated header
- Social links

## Added customizations
- Custom Permalinks for blog posts and projects
- Minimal header for pages other than Home
- Hidden drafts
- Individual tag pages

---

## License

[MIT](http://kopplin.mit-license.org/) License © Sérgio Kopplin


text:
# Stock Market application

## Overview

This is my implementation of the stock market chart application, which is the 4th basejump on freecodecamp.

You can view a running version of the app here:

[https://stockchartr.herokuapp.com/](https://stockchartr.herokuapp.com/)

# Quick Start Guide

### Prerequisites

In order to use the voting application, you must have the following installed:

- [Node.js](https://nodejs.org/)
- [NPM](https://nodejs.org/)
- [MongoDB](http://www.mongodb.org/)
- [Git](https://git-scm.com/)

### Installation & Startup

To install the stockmarket app, simply enter the below in the terminal window:

```bash
$ git clone https://github.com/paycoguy/stock-market.git your-project
```

This will install the app components into the `your-project` directory.

### Starting the App

To start the app, make sure you're in the project directory and type `node server.js` into the terminal. This will start the Node server and connect to MongoDB.

You should the following messages within the terminal window:

```
Node.js listening on port 8080...
```

Next, open your browser and enter `http://localhost:8080/`. Congrats, you're up and running!

## Features

| Features
|:---------
| MongoDB
| Express
| React
| Node.js
| Mongoose
| Webpack

## License

MIT License. [Click here for more information.](LICENSE.md)

repository: andrealonzo/stock-market

repo_name: andrealonzo/stock-market


text:
---
layout: post
title: Fourth week with Software Engineering
---

What did you do this past week?

I completed project 2's coding with my partner very soon, just one day after the project was released so we will have lots of time to prepare for the Career Fair next week. We also learned new material in class. We had Chris Martin from Bloomberg as guest speaker and his presentation was so inspiring and wonderful.

What's in your way?

I'm still learning Python and completing the project's requirements. I'm still e beginner to Python and it's a bad story.

What will you do next week?

I'll continue focus on learning Python and JavaScript. The College of Natural Science career fair is on Tuesday and I hope to get couple opportunities there thought I don't expect much.

I feel more confident this week and I learned many new stuffs. It's a long time and I'm have the pair programming again. And like Professor Downing said, it's extremely useful and effective. Using one monitor and one keyboard, we could quickly find out the way to solve the problem and build the effective algorithm for the project. We also found out the bugs and typos in really quickly. My partner is quite smart and intelligent and I learned a lot from her, not only from her academic knowledge, her coding style but also her characteristics. Although I'm not a hard-to-talk-to person, I think I should be more open-minded to people around me so that I could learn more. The Career Fair is on Tuesday and I don't expect much from that. Besides some good companies, I feel that many companies come there only to show off. We'll see what could I get this time.

Tip of the week:  “A closed mind is like a closed book; just a block of wood.”
 - Chinese proverb.