text:
layout: default
scripts:
permalink: works-cited/
title: Works Cited
type: title-page

prev: Resource Library
next:

---
## Works Cited

### Applications

- [https://revealprecision.com/](https://revealprecision.com/)
- [https://en.unesco.org/waterquality-IIWQ/activities-projects/monitoring-water-quality-wastewater](https://en.unesco.org/waterquality-IIWQ/activities-projects/monitoring-water-quality-wastewater)
- [https://appliedsciences.nasa.gov/join-mission/training/english/arset-monitoring-and-modeling-floods-using-earth-observations](https://appliedsciences.nasa.gov/join-mission/training/english/arset-monitoring-and-modeling-floods-using-earth-observations)
- [https://www.statista.com/topics/1143/mining/#topicHeader__wrapper](https://www.statista.com/topics/1143/mining/#topicHeader__wrapper)
- [https://www.sciencedirect.com/science/article/abs/pii/S0169136899000074](https://www.sciencedirect.com/science/article/abs/pii/S0169136899000074)
- [https://www.weforum.org/reports/unlocking-the-potential-of-earth-observation-to-address-africa-s-critical-challenges](https://www.weforum.org/reports/unlocking-the-potential-of-earth-observation-to-address-africa-s-critical-challenges)
- [https://climate-adapt.eea.europa.eu/en/metadata/adaptation-options/use-of-remote-sensing-in-climate-change-adaptation](https://climate-adapt.eea.europa.eu/en/metadata/adaptation-options/use-of-remote-sensing-in-climate-change-adaptation)
- [https://www.science.org/content/article/satellite-images-can-map-poverty](https://www.science.org/content/article/satellite-images-can-map-poverty)
- [https://rampml.global/](https://rampml.global/)
- [https://www.3ieimpact.org/sites/default/files/2021-01/3ie-NLT-Marketing-flyer.pdf](https://www.3ieimpact.org/sites/default/files/2021-01/3ie-NLT-Marketing-flyer.pdf)
- [https://www.tandfonline.com/doi/abs/10.1080/01431161.2010.496809?journalCode=tres20](https://www.tandfonline.com/doi/abs/10.1080/01431161.2010.496809?journalCode=tres20)
- [https://ij-healthgeographics.biomedcentral.com/articles/10.1186/s12942-019-0180-1](https://ij-healthgeographics.biomedcentral.com/articles/10.1186/s12942-019-0180-1)
- [https://www.sciencedirect.com/science/article/abs/pii/S0034425721003084](https://www.sciencedirect.com/science/article/abs/pii/S0034425721003084)
- [https://cleantechnica.com/2019/05/10/seeing-energy-from-space-5-tools-using-remote-sensing-to-improve-life-on-earth/](https://cleantechnica.com/2019/05/10/seeing-energy-from-space-5-tools-using-remote-sensing-to-improve-life-on-earth/)
- [https://www.smart-energy.com/industry-sectors/data_analytics/satellite-data-to-support-the-renewables-transition/](https://www.smart-energy.com/industry-sectors/data_analytics/satellite-data-to-support-the-renewables-transition/)
- [https://allianceformalariaprevention.com/wp-content/uploads/2022/03/Geo-enabled-Digital-Microplanning-2.pdf](https://allianceformalariaprevention.com/wp-content/uploads/2022/03/Geo-enabled-Digital-Microplanning-2.pdf)

### Capture

- [https://www.earthdata.nasa.gov/learn/backgrounders/remote-sensing](https://www.earthdata.nasa.gov/learn/backgrounders/remote-sensing)
- [https://www.nrcan.gc.ca/maps-tools-and-publications/satellite-imagery-and-air-photos/tutorial-fundamentals-remote-sensing/satellites-and-sensors/spectral-resolution/9393](https://www.nrcan.gc.ca/maps-tools-and-publications/satellite-imagery-and-air-photos/tutorial-fundamentals-remote-sensing/satellites-and-sensors/spectral-resolution/9393)
- [https://www.esa.int/Enabling_Support/Space_Transportation/Types_of_orbits](https://www.esa.int/Enabling_Support/Space_Transportation/Types_of_orbits)
- [https://albedo.com/](https://albedo.com/)
- [https://crisp.nus.edu.sg/~research/tutorial/optical.htm#:~:text=Optical%20remote%20sensing%20makes%20use,absorb%20differently%20at%20different%20wavelengths](https://crisp.nus.edu.sg/~research/tutorial/optical.htm#:~:text=Optical%20remote%20sensing%20makes%20use,absorb%20differently%20at%20different%20wavelengths)
- [https://www.earthdata.nasa.gov/learn/backgrounders/what-is-sar](https://www.earthdata.nasa.gov/learn/backgrounders/what-is-sar)
- [https://eijournal.com/print/articles/discover-the-benefits-of-radar-imaging](https://eijournal.com/print/articles/discover-the-benefits-of-radar-imaging)
- [https://oceanservice.noaa.gov/facts/lidar.html](https://oceanservice.noaa.gov/facts/lidar.html)
- [https://up42.com/blog/tech/aerial-imagery-explained-top-sources-and-what-you-need-to-know](https://up42.com/blog/tech/aerial-imagery-explained-top-sources-and-what-you-need-to-know)
- [https://www.landpoint.net/aerial-photogrammetry/](https://www.landpoint.net/aerial-photogrammetry/)
- [https://dx.plos.org/10.1371/journal.pone.0200288](https://dx.plos.org/10.1371/journal.pone.0200288)
- [http://www.earthdata.nasa.gov/engage/open-data-services-and-software/data-information-policy/data-levels](http://www.earthdata.nasa.gov/engage/open-data-services-and-software/data-information-policy/data-levels)
- [https://www.esri.com/about/newsroom/insider/what-is-orthorectified-imagery/](https://www.esri.com/about/newsroom/insider/what-is-orthorectified-imagery/)
- [https://blog.maxar.com/earth-intelligence/2017/lets-clear-the-air-digitalglobe-atmospheric-compensation-acomp-part-2](https://blog.maxar.com/earth-intelligence/2017/lets-clear-the-air-digitalglobe-atmospheric-compensation-acomp-part-2)

### Analysis

- [https://eos.com/blog/historical-satellite-images/](https://eos.com/blog/historical-satellite-images/)
- [https://post.parliament.uk/research-briefings/post-pn-0628/#:~:text=Machine%20learning%20with%20remote%20sensing,insights%20from%20complex%20data%20sets](https://post.parliament.uk/research-briefings/post-pn-0628/#:~:text=Machine%20learning%20with%20remote%20sensing,insights%20from%20complex%20data%20sets)
- [https://mapasyst.extension.org/whats-the-difference-between-a-supervised-and-unsupervised-image-classification/](https://mapasyst.extension.org/whats-the-difference-between-a-supervised-and-unsupervised-image-classification/)
- [https://mapasyst.extension.org/whats-the-difference-between-a-supervised-and-unsupervised-image-classification/](https://mapasyst.extension.org/whats-the-difference-between-a-supervised-and-unsupervised-image-classification/)
- [https://colab.research.google.com/signup](https://colab.research.google.com/signup)
- [https://github.com/](https://github.com/)
- [https://www.anaconda.com/products/distribution](https://www.anaconda.com/products/distribution)
- [https://mlhub.earth/](https://mlhub.earth/)
- [https://www.eoportal.org/satellite-missions/worldview-legion#eop-quick-facts-section](https://www.eoportal.org/satellite-missions/worldview-legion#eop-quick-facts-section)
- [https://eos.com/blog/eos-agrisat-first-satellite-provided-by-dragonfly-aerospace/](https://eos.com/blog/eos-agrisat-first-satellite-provided-by-dragonfly-aerospace/)
- [https://www.nasaspaceflight.com/2022/07/cz-2c-siwei-gaojing-2/](https://www.nasaspaceflight.com/2022/07/cz-2c-siwei-gaojing-2/)

### Distribution

- [https://stacspec.org/en/about/](https://stacspec.org/en/about/)
- [https://www.maxar.com/products/satellite-access](https://www.maxar.com/products/satellite-access)
- [https://www.planet.com/products/analytics/#building-detection](https://www.planet.com/products/analytics/#building-detection)
- [https://skywatch.com/](https://skywatch.com/)

### Platforms for Accessing and Analyzing Satellite Data

- [https://www.sentinel-hub.com/](https://www.sentinel-hub.com/)
- [https://github.com/sentinel-hub/eo-learn](https://github.com/sentinel-hub/eo-learn)
- [https://earthengine.google.com/](https://earthengine.google.com/)
- [https://developers.google.com/earth-engine/datasets#:~:text=The%20Earth%20Engine%20data%20catalog,to%20raw%20Landsat%20thermal%20data](https://developers.google.com/earth-engine/datasets#:~:text=The%20Earth%20Engine%20data%20catalog,to%20raw%20Landsat%20thermal%20data)
- [https://earthexplorer.usgs.gov/](https://earthexplorer.usgs.gov/)
- [https://www.digitalearthafrica.org/](https://www.digitalearthafrica.org/)
- [https://data.humdata.org/](https://data.humdata.org/)
- [https://www.maxar.com/open-data](https://www.maxar.com/open-data)
- [https://data.grid3.org/](https://data.grid3.org/)
- [https://www.thisisplace.org/](https://www.thisisplace.org/)

### Further Investments

- [https://www.undp.org/](https://www.undp.org/)
- [https://www.earthdata.nasa.gov/esds/csda](https://www.earthdata.nasa.gov/esds/csda)
- [https://www.undp.org/pacific/press-releases/ ](https://www.undp.org/pacific/press-releases/ )
- [https://www.undp.org/tanzania/blog/ ](https://www.undp.org/tanzania/blog/ )
- [https://www.earthdata.nasa.gov/esds/csda](https://www.earthdata.nasa.gov/esds/csda)
- [https://ir.blacksky.com/news-events/press-releases](https://ir.blacksky.com/news-events/press-releases)
- [https://www.copernicus.eu/en](https://www.copernicus.eu/en)
- [https://disasterscharter.org/](https://disasterscharter.org/)
- [https://undp.medium.com](https://undp.medium.com)
- [https://www.planet.com/nicfi/](https://www.planet.com/nicfi/)

### Resource Library

- [https://www.fao.org/hih-geospatial-platform/en/](https://www.fao.org/hih-geospatial-platform/en/)
- [https://rampml.global/](https://rampml.global/)
- [https://revealprecision.com/use-cases/](https://revealprecision.com/use-cases/)
- [https://aedesproject.org/](https://aedesproject.org/)


text:
<?php
/**
 * Message translations.
 *
 * This file is automatically generated by 'yiic message' command.
 * It contains the localizable messages extracted from source code.
 * You may modify this file by translating the extracted messages.
 *
 * Each array element represents the translation (value) of a message (key).
 * If the value is empty, the message is considered as not translated.
 * Messages that no longer need translation will have their translations
 * enclosed between a pair of '@@' marks.
 *
 * Message string can be used with plural forms format. Check i18n section
 * of the guide for details.
 *
 * NOTE, this file must be saved in UTF-8 encoding.
 */
return array (
  '"YiiWheels" must work in conjunction with "YiiStrap".' => '',
  '"chartOptions.series" is expected to be an array.' => '',
  '"data" attribute cannot be blank' => '',
  '"uploadAction" attribute cannot be blank' => '',
  '"{attribute}" attribute cannot be empty.' => '',
  '"{attribute}" attribute must be defined' => '',
  '"{attribute}" cannot be empty.' => '',
  '"{operation}" is an unsupported class operation.' => '',
  '$pluginOptions["country"] cannot be blank.' => '',
  'Check' => '',
  'Column summary configuration must be an array containing a "type" element.' => '',
  'Display Chart' => '',
  'Display Grid' => '',
  'Invalid request' => '',
  'No files to upload.' => '',
  'No results found.' => '',
  'Not set' => '',
  'Please enable JavaScript to use file uploader.' => '',
  'The "label" of a type must be defined.' => '',
  'The column must be specified in the format of "Name:Type:Label", where "Type" and "Label" are optional.' => '',
  'The files are being uploaded, if you leave now the upload will be cancelled.' => '',
  'Uncheck' => '',
  'Unsupported "{attribute}" setting.' => '',
  'Unsupported column type. Supported column types are: "{types}"' => '',
  'You need to set the "series" attribute in order to render a chart' => '',
  '{file} has an invalid extension. Valid extension(s): {extensions}.' => '',
  '{file} is empty, please select files again without it.' => '',
  '{file} is too large, maximum file size is {sizeLimit}.' => '',
  '{file} is too small, minimum file size is {minSizeLimit}.' => '',
);

redpajama_set_name: RedPajamaGithub


text:
using System;
using System.Collections.Generic;
using System.Threading;
using AlgoSharp.Algs.PriorityQueue;

namespace AlgoSharp.Collision.Service
{
    public class CollisionSystem
    {
        private readonly List<Particule> _particules;
        private readonly double _drawFrequency;
        private readonly MinPriorityQueue<CollisionEvent> _pq;
        private double _time;

        public event EventHandler<DrawEventArgs> DrawEvent;

        public CollisionSystem(List<Particule> particules, double drawFrequency)
        {
            _particules = particules;
            _drawFrequency = drawFrequency;
            _pq = new MinPriorityQueue<CollisionEvent>();
            _time = 0;
        }

        public void Simulate(CancellationToken token)
        {
            // Predict collision for each a
            foreach (Particule particule in _particules) PredictCollision(particule);

            // First event to draw all particules
            _pq.Insert(new CollisionEvent(0));

            // Event loop
            while (!_pq.IsEmpty() && !token.IsCancellationRequested)
            {
                var collisionEvent = _pq.DelMin();
                if (!collisionEvent.IsValid()) continue;

                // Move all particules to the next event
                foreach (Particule p in _particules)
                    p.Move(collisionEvent.EventTime - _time);

                _time = collisionEvent.EventTime;

                if (collisionEvent.A != null && collisionEvent.B != null)
                    collisionEvent.A.BounceOff(collisionEvent.B);
                else if (collisionEvent.A != null)
                    collisionEvent.A.BounceOffVerticalWall();
                else if (collisionEvent.B != null)
                    collisionEvent.B.BounceOffHorizontalWall();
                else RaiseDrawEvent();

                PredictCollision(collisionEvent.A);
                PredictCollision(collisionEvent.B);
            }
        }

        private void RaiseDrawEvent()
        {
            var handler = DrawEvent;
            if (handler != null) handler(this, new DrawEventArgs(_particules));

            _pq.Insert(new CollisionEvent(_time + 1 / _drawFrequency));
        }

        private void PredictCollision(Particule particule)
        {
            if (particule == null) return;

            double collisionTime;

            // compute a collision time
            foreach (var p in _particules)
            {
                collisionTime = particule.TimeToHit(p);
                _pq.Insert(new CollisionEvent(_time + collisionTime, particule, p));
            }

            // compute wall collision time
            collisionTime = particule.TimeToHitVerticalWall();
            _pq.Insert(new CollisionEvent(_time + collisionTime, particule));
            collisionTime = particule.TimeToHitHorizontalWall();
            _pq.Insert(new CollisionEvent(_time + collisionTime, null, particule));
        }
    }

    public class DrawEventArgs : EventArgs
    {
        public List<Particule> Particules { get; private set; }

        public DrawEventArgs(List<Particule> particules)
        {
            Particules = particules;
        }
    }

    public class CollisionEvent : IComparable<CollisionEvent>
    {
        public double EventTime { get; private set; }
        public Particule A { get; private set; }
        public Particule B { get; private set; }
        private readonly int _countA;
        private readonly int _countB;

        public CollisionEvent(double eventTime, Particule a = null, Particule b = null)
        {
            EventTime = eventTime;
            A = a;
            B = b;
            _countA = A != null ? A.Count : -1;
            _countB = B != null ? B.Count : -1;
        }

        public int CompareTo(CollisionEvent other)
        {
            return EventTime.CompareTo(other.EventTime);
        }

        public bool IsValid()
        {
            if (A != null && A.Count != _countA) return false;
            if (B != null && B.Count != _countB) return false;
            return true;
        }
    }
}


text:
v8::Persistent<v8::Function> VcdHashedDictionary::constructor;

VcdHashedDictionary::VcdHashedDictionary(
    std::unique_ptr<open_vcdiff::HashedDictionary> hashed_dictionary)
    : hashed_dictionary_(std::move(hashed_dictionary)) {
}

VcdHashedDictionary::~VcdHashedDictionary() {
}

// static
void VcdHashedDictionary::Init(v8::Handle<v8::Object> exports) {
  v8::Isolate* isolate = exports->GetIsolate();

  v8::Local<v8::String> className = v8::String::NewFromUtf8(isolate, "HashedDictionary", v8::String::kInternalizedString);
  v8::Local<v8::FunctionTemplate> tpl = v8::FunctionTemplate::New(isolate, New);
  tpl->SetClassName(className);
  tpl->InstanceTemplate()->SetInternalFieldCount(1);

  exports->Set(className, tpl->GetFunction());
}

// static
void VcdHashedDictionary::New(const v8::FunctionCallbackInfo<v8::Value>& args) {
  assert(args.Length() == 1 && "new HashedDictionary(buffer)");
  assert(node::Buffer::HasInstance(args[0]) &&
         "should pass Buffer to constructor");

  v8::Isolate *isolate = args.GetIsolate();

  std::unique_ptr<open_vcdiff::HashedDictionary> dictionary(
      new open_vcdiff::HashedDictionary(node::Buffer::Data(args[0]),
                                        node::Buffer::Length(args[0])));
  if (!dictionary->Init()) {
    isolate->ThrowException(v8::String::NewFromUtf8(isolate,
        "Error initializing hashed dictionary"));
    return;
  }
  auto vcd_hashed_dict = new VcdHashedDictionary(std::move(dictionary));
  vcd_hashed_dict->Wrap(args.This());
}


text:
<!DOCTYPE html>

<meta charset="UTF-8">
<title>Twitter Manager</title>
<link rel="stylesheet" href="http://code.jquery.com/ui/1.10.3/themes/smoothness/jquery-ui.css" />

    <button onclick="onRefresh()">Refresh</button>
    <button onclick="onAdd()">Add</button>


text:
/*
 *	@name classes/item.js
 *  @author Árpád Kiss
 *	@require interface.js, item.js
 */

var MemoryGame = (function() {

	// private static
	var _created = false;
	var _clicks, _matches,
		_container, _d, _di, _b, _p, _lastElement,
		_userInteractions,
		_width, _height;
		_ticker = null;
	return function(container, options) {

		// constructor
		if (_created) throw new Error('MemoryGame: only one instance is allowed.');
		_created = true;

		if (Item === undefined) throw new Error('MemoryGame: Item class is missing.');

		if (options.tiles.items === undefined || options.tiles.items.length === 0) throw new Error('MemoryGame: tiles are not defined or has zero length.');
		if (document.getElementById(container) === undefined) throw new Error('MemoryGame: conatiner [memoryGame] not found.');

		if(options.ticker) _ticker = document.getElementById(options.ticker);

		_width = options.itemWidth || 120;
		_height = options.itemHeight || 120;

		_container = document.getElementById(container);
		_d = document.createElement('div');
		_d.style.minWidth = _width + 'px';
		_d.style.minHeight = _height + 'px';
		_d.setAttribute('class', 'item-holder');

		_di = document.createElement('div');
		_di.classList.add('item');
		_di.style.width = _width + 'px';
		_di.style.height = _height + 'px';
		_b = document.createElement('div');
		_b.classList.add('front');
		_b.style.width = _width + 'px';
		_b.style.height = _height + 'px';
		_di.appendChild(_b);

		_d.appendChild(_di);

		var _order = [];

		var _start, _items = [],
			_counter, _miliseconds = 0;
		var j = 0;
		for (var i = 0; i < options.tiles.items.length; i++) {
			_items[j] = new Item(i, 'img/' + options.tiles.items[i] + '.' + ((options.tiles.type) ? options.tiles.type : 'png'), _width, _height);
			j++;
			_items[j] = new Item(i, 'img/' + options.tiles.items[i] + '.' + ((options.tiles.type) ? options.tiles.type : 'png'), _width, _height);
			j++;
			_container.appendChild(_d.cloneNode(true));
			_container.appendChild(_d.cloneNode(true));
		}

		// private
		var _startTimer = function() {
			_start = new Date();
			if(_ticker) {
				if(_counter) clearInterval(_counter);
				_counter = setInterval(function() {
					_ticker.innerHTML = Number((new Date() - _start) / 1000).toFixed(2) + " ms";
				}, 10);
			}
			return "Timer started";
		};

		var _stopTimer = function() {
			_miliseconds = new Date() - _start;
			if(_ticker) clearInterval(_counter); _counter = null;
			return "Timer stoped: " + _miliseconds;
		};

		var _drawScene = function() {
			Interface.ensureImplements(_items[0], ItemInterface);
			for (var i = 0; i < options.tiles.items.length << 1; i++) {
				_order.push(_items[i].getID());
				_container.children[i].className = 'item-holder';
				_container.children[i].children[0].appendChild(_items[i].toString());
				if(!_container.children[i].addEventListener) {
					_container.children[i].detachEvent('onclick',_onItemClick);
					_container.children[i].attachEvent('onclick', _onItemClick);
				}
				else {
					_container.children[i].removeEventListener('click', _onItemClick);
					_container.children[i].addEventListener('click', _onItemClick);
				}
			}
		};

		var _getNodeDeep = function(node,className)
		{
			if(node.className == className) {
				return node;
			} else {
				return _getNodeDeep(node.parentNode,className);
			}
		};

		var _onItemClick = function() {
			var element = null;
			if(this.className && this.className.indexOf('item-holder') != -1) {
				element = this;
			} else {
				element = _getNodeDeep(window.event.srcElement,'item-holder');
			}

			if(_lastElement.length > 0 && element.children[0].children[1].getAttribute('data-instance') == _lastElement[_lastElement.length - 1].children[1].getAttribute('data-instance')) return;

			_clicks++;

			if (_clicks > 2) {
				_lastElement.pop().children[1].flop();
				_lastElement.pop().children[1].flop();
				_lastElement = [];
				_clicks = 1;

			}
			element.children[0].children[1].flip();
			element.children[0].event = arguments[0];

			if (_lastElement.length > 0 && element.children[0].children[1].getAttribute('data-id') == _lastElement[_lastElement.length - 1].children[1].getAttribute('data-id') && element.children[0].children[1].getAttribute('data-instance') != _lastElement[_lastElement.length - 1].children[1].getAttribute('data-instance')) {

				_matches++;

				_userInteractions.push({
					id: element.children[0].getAttribute('data-id'),
					items: [{
						x: _lastElement[_lastElement.length - 1].event.clientX,
						y: _lastElement[_lastElement.length - 1].event.clientY,
						time: _lastElement[_lastElement.length - 1].event.timeStamp
					}, {
						x: arguments[0].offsetX,
						y: arguments[0].offsetY,
						time: new Date().getTime()
					}]
				});

				if (_matches == options.tiles.items.length) {
					console.log(_stopTimer());
					// Custom event
					var gameOver = null;

					var detail = {
						message: "Congratulation!",
						userInteractions: _userInteractions,
						offset: {
							top: _container.offsetTop,
							left: _container.offsetLeft
						},
						container: {
							width: _container.offsetWidth,
							heigth: _container.offsetHeight
						},
						item: {
							size: {
								width: _width,
								height: _height
							}
						},
						order: _order,
						miliseconds: _miliseconds
					};

					if(window.CustomEvent) {
						gameOver = new CustomEvent(
							'gameOver', {
							detail: detail,
							bubbles: true,
							cancelable: false
						});
						_container.dispatchEvent(gameOver);
					} else {
						gameOver = document.createEventObject();
						gameOver.detail = detail;
						gameOver.customEvent = true;
						_container.fireEvent('onpropertychange',gameOver);
					}
				}
				if(!_lastElement[_lastElement.length - 1].parentNode.removeEventListener) {
					_lastElement[_lastElement.length - 1].parentNode.detachEvent('onclick',_onItemClick);
					element.detachEvent('onclick',_onItemClick);
				} else {
					_lastElement[_lastElement.length - 1].parentNode.removeEventListener('click', _onItemClick);
					element.removeEventListener('click', _onItemClick);
				}

				_clicks = 0;
				_lastElement = [];
			} else {
				_lastElement.push(element.children[0]);
			}
		};

		// public
		this.startGame = function() {
			_lastElement = [];
			_userInteractions = [];
			_matches = 0;
			_clicks = 0;
			_items.shuffle();
			_drawScene();
			console.log(_startTimer());
		};

		this.onGameOver = function(callback)
		{
			if(!_container.addEventListener) {
				_container.attachEvent('onpropertychange', function(){
					if(arguments[0].customEvent)
					{
						callback.call(this,arguments[0]);
					}
				});
			} else {
				_container.addEventListener('gameOver', callback);
			}
		};

		// getters
		this.getMiliseconds = function() {
			return _miliseconds;
		};

		this.getItems = function() {
			return _items;
		};

		this.getContainer = function() {
			return _container;
		};

		console.log("MemoryGame initialized.");
	};
})();

var shuffle = function(b) {
	var i = this.length,
		j, t;
	while (i) {
		j = Math.floor((i--) * Math.random());
		t = b && typeof this[i].shuffle !== 'undefined' ? this[i].shuffle() : this[i];
		this[i] = this[j];
		this[j] = t;
	}
	return this;
};
var defineProperty = (typeof Object.defineProperty == 'function');
if (defineProperty) {
	try {
		Object.defineProperty(Array.prototype, 'shuffle', {
			enumerable: false,
			configurable: false,
			writable: false,
			value: shuffle
		});
	} catch (e) {}
}
if (!Array.prototype.shuffle) Array.prototype.shuffle = shuffle;


text:
package com.barchart.common.transport;

public interface SocketChannel {
	String getChannelName();
}