text:
(function (/**Window|{ process: Object, module: Object, modules: Object, define: Function, postMessage: Function }*/global) {
    "use strict";
    var provideModule = function (vow) {
        var process = global.process;
        var ALLOW_IMMEDIATE = "setImmediate" in global,
            ALLOW_NEXT_TICK = process && "nextTick" in process,
            MIN_STACK_CUT_THRESHOLD = 100,
            DEF_STACK_CUT_THRESHOLD = 1000;
        var undef,
            toArray = function (target, /**Number?*/offset, /***[]?*/startWith, /***[]?*/endWith) {
                var result = [];
                if (target.length) for (var i = offset || 0, len = target.length; i < len; ++i)
                    result.push(target[i]);
                return (startWith || []).concat(result).concat(endWith || []);
            },
            objectTOS = Object.prototype.toString,
            isArray = Array.isArray || function (obj) { return objectTOS.call(obj) === "[object Array]"; },
            /**
             * @param {*} it
             * @return {Boolean}
             */
            isString = function (it) {
                return (typeof it === "string" || it instanceof String);
            },
            /**
             * @param {*} it
             * @return {Boolean}
             */
            isFunction = function (it) {
                return typeof it === "function";
            },
            /**
             * @param {Object} scope
             * @param {Function|String} method
             * @return {Function}
             */
            hitchArgs = function (scope, method) {
                var pre = toArray(arguments, 2),
                    named = isString(method);
                return function () {
                    var args = toArray(arguments),
                        f = named ? scope[method] : method;
                    return f && f.apply(scope, pre.concat(args));
                };
            },
            /**
             * @param {Object} [scope]
             * @param {Function|String} method
             * @return {Function}
             */
            hitch = function (scope, method) {
                if (arguments.length > 2)
                    return hitchArgs.apply(null, arguments);
                if (!method) {
                    //noinspection JSValidateTypes
                    method = scope;
                    scope = null;
                }
                if (isString(method)) return function () {
                    return scope[method].apply(scope, arguments || []);
                };
                return !scope
                    ? method
                    : function () {
                    return method.apply(scope, arguments || []);
                };
            },
            getObjectKeys = ("keys" in Object) ? Object.keys : function (it) {
                if (it == null)
                    return [];
                var result = [], prop;
                for (prop in it) if (it.hasOwnProperty(prop))
                    result.push(prop);
                return result;
            },
            /**
             * @param {!(Object|[])} it
             * @param {!function(value: *, key: String|Number, index: Number, target: Object)} iterator
             * @param {Object} [thisObject]
             * @param {Boolean|Function} [sort]
             */
            enumerate = function (it, iterator, thisObject, sort) {
                if (it && iterator) {
                    var i, len;
                    if (isArray(it) && (len = it.length)) {
                        if (len > 1 && sort)
                            it = it.sort(isFunction(sort) ? sort : undef);
                        for (i = 0; i < len; ++i)
                            iterator.call(thisObject, it[i], i, i, it);
                    } else {
                        var /**String[]*/keys = getObjectKeys(it),
                            key;
                        if ((len = keys.length) > 1 && sort)
                            keys = keys.sort(isFunction(sort) ? sort : undef);
                        for (i = 0; i < len; ++i)
                            iterator.call(thisObject, it[key = keys[i]], key, i, it);
                    }
                }
            },
            /**
             * @param {String|Boolean} option
             * @return {{ after: Boolean, before: Boolean }}
             */
            parseNotifyOption = function (option) {
                var result = { after: true, before: false };
                if (!(option == null || option === true || option === "after")) {
                    if (option === false || option === "none") {
                        result.after = result.before = false;
                    } else if (option === "both") {
                        result.after = result.before = true;
                    } else if (option === "before") {
                        result.after = false;
                        result.before = true;
                    }
                }
                return result;
            },
            /**
             * @param {Number|Boolean} option
             * @return {Number}
             */
            parseStackLimitOption = function (option) {
                if (option == null) option = true;
                return option === true
                    ? DEF_STACK_CUT_THRESHOLD
                    : (!option ? false : ( option < MIN_STACK_CUT_THRESHOLD ? MIN_STACK_CUT_THRESHOLD : option ));
            },
            /**
             * @param {!Arguments} args
             * @param {Boolean} [rest=true]
             * @return {Function}
             */
            postponedArgsPrepare = function (args, rest) {
                var len = args.length,
                    func;
                if (len === 1) func = args[0];
                else if (len === 2) func = hitch(args[1], args[0]);
                else if (len > 2) {
                    if (rest || rest == null) func = hitch.apply(null, toArray(args, 2, [args[1], args[0]])); else
                        func = hitch.apply(null, [args[1], args[0]].concat(args[2]));
                }
                return func;
            },
            qwhen = function (target, resolve, reject, progress) {
                if (vow.isPromise(target)) target.then(resolve, reject, progress); else if (resolve) resolve(target);
            },
            laterQ = (function () {
                var list = [],
                    enq = function (func) {
                        return list.push(func) === 1;
                    },
                    invoke = function () {
                        var toInvoke = list, i = 0, len = list.length;
                        list = [];
                        while (i < len) toInvoke[i++]();
                    };
                if (ALLOW_IMMEDIATE) return function (fn) {
                    enq(fn) && setImmediate(invoke);
                };
                if (ALLOW_NEXT_TICK) return function (fn) {
                    enq(fn) && process.nextTick(invoke);
                };
                var MutationObserver = global["MutationObserver"] || global["WebKitMutationObserver"];
                if (MutationObserver) {
                    var num = 1, node = global.document.createTextNode("");
                    //noinspection JSCheckFunctionSignatures
                    new MutationObserver(invoke).observe(node, { characterData: true });
                    return function (fn) {
                        enq(fn) && (node.data = (num *= -1));
                    };
                }
                if (global.postMessage) {
                    var isPostMessageAsync = true;
                    if (global.attachEvent) {
                        var checkAsync = function () {
                            isPostMessageAsync = false;
                        };
                        global.attachEvent("onmessage", checkAsync);
                        //noinspection JSCheckFunctionSignatures
                        global.postMessage("__checkAsync", "*");
                        global.detachEvent("onmessage", checkAsync);
                    }
                    if (isPostMessageAsync) {
                        var msg = "__promise" + Math.random() + "_" + (new Date()),
                            onMessage = function (e) {
                                if (e.data === msg) {
                                    e.stopPropagation && e.stopPropagation();
                                    invoke();
                                }
                            };
                        global.addEventListener
                            ? global.addEventListener("message", onMessage, true)
                            : global.attachEvent("onmessage", onMessage);
                        return function (fn) {
                            //noinspection JSCheckFunctionSignatures
                            enq(fn) && global.postMessage(msg, "*");
                        };
                    }
                }
                var document = global.document;
                if ("onreadystatechange" in document.createElement("script")) {
                    var createScript = function () {
                        var script = document.createElement("script");
                        script.onreadystatechange = function () {
                            script.parentNode.removeChild(script);
                            script = script.onreadystatechange = null;
                            invoke();
                        };
                        (document.documentElement || document.body).appendChild(script);
                    };
                    return function (fn) {
                        enq(fn) && createScript();
                    };
                }
                return function (fn) {
                    enq(fn) && setTimeout(invoke, 0);
                };
            })(),
            afterQ = ALLOW_NEXT_TICK ? (function () {
                var list = [],
                    enq = function (func) {
                        return list.push(func) === 1;
                    },
                    invoke = function () {
                        var toInvoke = list, i = 0, len = list.length;
                        list = [];
                        while (i < len) toInvoke[i++]();
                    };
                return function (fn) {
                    enq(fn) && process.nextTick(invoke);
                };
            })() : laterQ;
        /**
         * @class AsyCtx
         * @param {!Deferred} control
         * @param {!Number} index
         * @param {!(String|Number)} [key]
         * @param {*} [prev]
         * @param {function(data: *?)} [onFulfill]
         * @constructor
         */
        var AsyCtx = function (control, index, key, prev, onFulfill) {
            this._control = control;
            this._onFulfill = onFulfill;
            this.index = index;
            this.key = key == null ? index : key;
            //noinspection JSUnusedGlobalSymbols
            this.prev = prev;
            this.promise = false;
        };
        AsyCtx.prototype.fulfilled = false;
        /**
         * @param {function(fulfill: function(data: *?), success: function(data: *?), fail: function(error: *?))} [handler]
         * @return AsyCtx
         */
        AsyCtx.prototype.defer = function (handler) {
            this._def = vow.defer();
            this.promise = this._def.promise();
            if (handler) try {
                handler(
                    hitch(this, this.fulfill),
                    hitch(this, this.success),
                    hitch(this, this.fail)
                );
            } catch (exception) {
                this.fail(exception);
            }
            return this;
        };
        /**
         * @param {*} [data]
         */
        AsyCtx.prototype.notify = function (data) {
            this._control.notify(data, true);
        };
        /**
         * @param {*} [data]
         */
        AsyCtx.prototype.fulfill = function (data) {
            this.fulfilled = true;
            if (this._onFulfill) this._onFulfill.call(this, data);
            this._control.resolve(data, true);
        };
        //noinspection JSUnusedGlobalSymbols
        /**
         * @param {!(*|Promise)} promiseOrData
         */
        AsyCtx.prototype.delegateFulfill = function (promiseOrData) {
            var self = this.defer();
            vow.when(
                promiseOrData,
                function (data) { self.fulfill(data); },
                function (error) { self.fail(error); }
            );
        };
        //noinspection JSUnusedGlobalSymbols
        /**
         * @param {!(Promise|*)} promiseOrData
         * @param {*} [result]
         */
        AsyCtx.prototype.fulfillAfter = function (promiseOrData, result) {
            var self = this.defer(),
                useResult = arguments.length === 2;
            vow.when(
                promiseOrData,
                function (data) { self.fulfill(useResult ? result : data); },
                function (error) { self.fail(error); }
            );
        };
        /**
         * @param {*} [data]
         */
        AsyCtx.prototype.success = function (data) {
            if (this._def) this._def.resolve(data, true); else
                this._control.reject(new Error("Iteration can't be successful until AsyCtx#defer() is not called"));
        };
        //noinspection JSUnusedGlobalSymbols
        /**
         * @param {!(Promise|*)} promiseOrData
         * @param {*} [result]
         */
        AsyCtx.prototype.successAfter = function (promiseOrData, result) {
            if (!this._def) this._control.reject(new Error("Iteration can't be successful until AsyCtx#defer() is not called"));
            else {
                var self = this,
                    useResult = arguments.length === 2;
                vow.when(
                    promiseOrData,
                    function (data) { self.success(useResult ? result : data); },
                    function (error) { self.fail(error); }
                );
            }
        };
        /**
         * @param {*} [error]
         */
        AsyCtx.prototype.fail = function (error) {
            this.fulfilled = true;
            this._control.reject(error, true);
            if (this._def) this._def.resolve();//yes. resolve
        };
        AsyCtx.prototype.release = function () {
            this._control = this._def = this.promise = false;
            //noinspection JSUnusedGlobalSymbols
            this.prev = this.index = this.key = null;
        };
        /**
         * @param {!function(item: *, q: AsyQ): *|Promise} processor
         * @param {Object} [options]
         * @param {Boolean} [options.reverse=false]
         * @param {Number} [options.processLimit=2]
         * @param {*[]} [options.elems]
         * @param {Boolean} [options.paused=false]
         * @param {Number|Boolean} [options.separate=false]
         * @constructor
         */
        var AsyQ = function (processor, options) {
            options = options || {};
            /**
             * @type {Number}
             * @private
             */
            this._processedCount = 0;
            /**
             * @type {Object.<String, Function[]>}
             * @private
             */
            this._events = {};
            /**
             * @type {Object.<Number, Promise>}
             * @private
             */
            this._processed = {};
            /**
             * @type {*[]}
             * @private
             */
            this._q = [];
            /**
             * @type {function(item: *, q: AsyQ): *|Promise}
             * @private
             */
            this._processor = processor;
            /**
             * @type {Boolean|Number}
             * @private
             */
            this._separateInterval = options.separate == null ? false : options.separate;
            /**
             * @type {Boolean}
             * @private
             */
            this._reverse = options.reverse == null ? false : options.reverse;
            /**
             * @type {Number}
             * @private
             */
            this._processLimit = options.processLimit == null ? 2 : options.processLimit;
            /**
             * @type {Boolean}
             * @private
             */
            this._paused = options.paused == null ? false : options.paused;
            if (options.elems) this._write(options.elems);
            if (!this._paused && this._q.length)
                this._do();
        };
        /**
         * @param {!String} event
         * @param {...*} [data]
         * @return {AsyQ}
         * @protected
         */
        AsyQ.prototype.emit = function (event, data) {
            var /**Function[]*/lList;
            if (event && (lList = this._events[event]) && lList.length) {
                var self = this,
                    args = toArray(arguments, 1);
                enumerate(lList, function (/**Function*/item) {
                    item.apply(self, args);
                });
            }
        };
        /**
         * @param {!String} event
         * @param {!Function} listener
         * @return {AsyQ}
         */
        AsyQ.prototype.on = function (event, listener) {
            if (event && listener) {
                if (!(event in this._events))
                    this._events[event] = [];
                this._events[event].push(listener);
            }
            return this;
        };
        //noinspection JSUnusedGlobalSymbols
        /**
         * @param {!String} event
         * @param {!Function} listener
         * @return {AsyQ}
         */
        AsyQ.prototype.un = function (event, listener) {
            var /**Function[]*/lList;
            if (event && listener && (lList = this._events[event]) && lList.length) {
                var idx = lList.indexOf(listener);
                if (idx >= 0) lList.splice(idx, 1);
            }
            return this;
        };
        /**
         * @param {*|*[]} data
         * @private
         */
        AsyQ.prototype._write = function (data) {
            if (isArray(data)) {
                enumerate(data, function (item) {
                    this._q.push(item);
                    this.emit("write", item);
                }, this);
            } else {
                this._q.push(data);
                this.emit("write", data);
            }
        };
        AsyQ.prototype._separate = function () {
            if (this._separateInterval === false) this._do();
            else if (this._separateInterval === true) asy.callAfter(this._do, this);
            else if (this._separateInterval === 0) asy.callLater(this._do, this);
            else setTimeout(hitch(this, "_do"), this._separateInterval);
        };
        AsyQ.prototype._nextTmpId = function () {
            if (this.__tmpId == null)
                this.__tmpId = 0;
            return this.__tmpId++;
        };
        AsyQ.prototype._do = function () {
            var limit = this._processLimit;
            if (!this._paused && this._processedCount < limit) {
                var self = this,
                    item,
                    /***|Promise*/val,
                    onData = function (id, data) {
                        self._processedCount--;
                        waits--;
                        delete self._processed[id];
                        self.emit("data", data);
                        checkComplete();
                    },
                    onError = function (error) {
                        try {
                            self.emit("error", error, item);
                        } finally {
                            self.empty();
                        }
                    },
                    checkComplete = function () {
                        if (!self._isDrain && self._q.length === 0 && self._processedCount === 0) {
                            self._isDrain = true;
                            self.emit("drain");
                        } else if (self._q.length)
                            self._separate();
                    },
                    waits = 0,
                    tmpId;
                try {
                    while (self._q.length && self._processedCount < limit) {
                        item = this._reverse ? this._q.shift() : this._q.pop();
                        val = self._processor(item, self);
                        if (!vow.isPromise(val)) self.emit("data", val); else {
                            self._processedCount++;
                            waits++;
                            self._processed[tmpId = this._nextTmpId()] = val;
                            val.then(hitch(null, onData, tmpId), onError);
                        }
                    }
                    if (!waits) checkComplete();
                } catch (exception) {
                    onError(exception);
                }
            }
        };
        //noinspection JSUnusedGlobalSymbols
        /**
         * @return {Boolean}
         */
        AsyQ.prototype.isEmpty = function () {
            return !this._q.length && !this._processedCount;
        };
        /**
         * @return {AsyQ}
         */
        AsyQ.prototype.empty = function () {
            if (this._q.length)
                this._q = [];
            if (this._processedCount) {
                //vow promise does't support cancel api =\
                //enumerate(this._processed, function (/**Promise*/promise) {
                //    promise.cancel();
                //});
                this._processedCount = 0;
                this._processed = {};
            }
            return this;
        };
        /**
         * @return {AsyQ}
         */
        AsyQ.prototype.resume = function () {
            if (this._paused && this._processedCount < this._processLimit) {
                this._paused = false;
                this.emit("resume");
                this._do();
            }
            return this;
        };
        /**
         * @return {AsyQ}
         */
        AsyQ.prototype.pause = function () {
            if (!this._paused)
                this.emit("pause");
            return this;
        };
        /**
         * @param {...*} data
         * @return {AsyQ}
         */
        AsyQ.prototype.write = function (data) {
            this._isDrain = false;
            this._write(toArray(arguments));
            if (!this._paused)
                this._do();
            return this;
        };
        var asy = {
            /**
             * Variation {@link asy.callAfter} with argument's array instead of rest-arguments
             * @param {Function} func
             * @param {Object} [thisObject]
             * @param {*[]} [args]
             */
            applyAfter: function (func, thisObject, args) {
                func && afterQ(postponedArgsPrepare(arguments, false));
            },
            /**
             * Cross-platform implementation nextTick
             * @see https://nodejs.org/docs/latest/api/process.html#process_process_nexttick_callback nextTick
             * @alias asy.nextTick
             * @param {Function} func
             * @param {Object} [thisObject]
             * @param {...*} [args]
             */
            callAfter:  function (func, thisObject, args) {
                func && afterQ(postponedArgsPrepare(arguments));
            },
            /**
             * Variation {@link asy.callLater} with argument's array instead of rest-arguments
             * @param {Function} func
             * @param {Object} [thisObject]
             * @param {*[]} [args]
             */
            applyLater: function (func, thisObject, args) {
                func && laterQ(postponedArgsPrepare(arguments, false));
            },
            /**
             * Cross-platform implementation setImmediate
             * @see https://developer.mozilla.org/docs/Web/API/Window/setImmediate setImmediate
             * @alias asy.immediately
             * @param {Function} func
             * @param {Object} [thisObject]
             * @param {...*} [args]
             */
            callLater:  function (func, thisObject, args) {
                func && laterQ(postponedArgsPrepare(arguments));
            },
            /**
             * Sequential processing promise-oriented arguments with transfer result
             * @param {...(*|function(prev:*, actx:AsyCtx):*|Promise)} targets The arguments are:
             *      primitive types,
             *      objects,
             *      promise (the transition is carried out only after his resolving),
             *      function (the transition is carried out only after completion function execution and processing its result)
             * @return Promise
             */
            seq:        function (targets) {
                var len = arguments.length;
                if (!len) return vow.resolve(); else
                    return asy.chain(toArray(arguments));
            },
            /**
             * Sequential processing promise-oriented items of target with transfer result
             * @param {Promise|Object|(*|function(prev:*, actx:AsyCtx): *|Promise)[]} target
             * @param {Object} [thisObject]
             * @param {Object} [options]
             * @param {Number|Boolean} [options.separate=false] Bypass separate interval
             * @param {Number|Boolean} [options.stackLimit=true] Limit of execution stack
             * @param {Boolean|(function(item1: String|*, item2: String|*): Number)} [options.sort=false]
             * @param {"after"|"before"|"both"|"none"|Boolean} [options.notify="after"]
             * @return Promise
             */
            chain:      function (target, thisObject, options) {
                var /***|Promise*/val,
                    prev, isFunc,
                    prevCatcher = function (val) { prev = val; },
                    promise = asy.eachSeries(target, function (item, actx) {
                        val = (isFunc = isFunction(item))
                            ? item.call(thisObject, prev, actx)
                            : item;
                        if (isFunc && promise.isResolved()) return null; else {
                            if (actx.promise) val = actx.promise;
                            if (!vow.isPromise(val)) prev = val; else
                                val.then(prevCatcher);
                            return val;
                        }
                    }, null, options);
                return promise;
            },
            /**
             * Iterate all elements of Target consistently, calling iterator for each.
             * @param {*[]|Object|Promise} target Target
             * @param {function(item: *, actx: AsyCtx): *|Promise} [iterator]
             * @param {Object} [thisObject] Function type item context and iterator context
             * @param {Object} [options]
             * @param {Number|Boolean} [options.separate=false] Bypass separate interval
             * @param {Number|Boolean} [options.stackLimit=true] Limit of execution stack
             * @param {Boolean|function(item1: String|*, item2: String|*): Number} [options.sort=false]
             * @param {"after"|"before"|"both"|"none"|Boolean} [options.notify="after"]
             * @return Promise
             */
            eachSeries: function (target, iterator, thisObject, options) {
                options = options || {};
                var def = vow.defer(),
                    promise = def.promise();
                vow.when(
                    target,
                    function (/**Object|[]*/target) {
                        var /**Boolean*/targetIsArray, /**String[]*/targetKeys, /**Number*/targetLen,
                            stackThreshold = parseStackLimitOption(options.stackLimit),
                            notify = parseNotifyOption(options.notify);
                        if (target) {
                            targetIsArray = isArray(target);
                            targetKeys = targetIsArray ? null : getObjectKeys(target);
                            targetLen = targetIsArray ? target.length : targetKeys.length;
                            if (options.sort && targetLen > 1) {
                                if (targetIsArray) target = target.sort(isFunction(options.sort) ? options.sort : undef); else
                                    targetKeys = targetKeys.sort(isFunction(options.sort) ? options.sort : undef);
                            }
                        }
                        if (!target || !targetLen) def.resolve(); else {
                            iterator = iterator || false;
                            var lightIterator = iterator && iterator.length < 2,
                                sep = options.separate || false,
                                prev, item, actx, key, val,
                                idx = 0, inTick = true, inTickCount = 0,
                                sepStep = function () {
                                    if (sep === true) asy.callAfter(step);
                                    else if (sep === 0) asy.callLater(step);
                                    else if (sep > 0) setTimeout(step, sep);
                                    else step();
                                },
                                onACtxFulfill = function (data) {
                                    def.notify({ index: this.index, key: this.key, data: data, kind: "after" });
                                },
                                step = function () {
                                    try {
                                        inTickCount++;
                                        item = targetIsArray ? target[key = idx] : target[(key = targetKeys[idx])];
                                        if (notify.before)
                                            def.notify({ index: idx, key: key, data: item, kind: "before" });
                                        if (iterator === false) val = item; else {
                                            if (lightIterator) val = iterator.call(thisObject, item); else {
                                                val = iterator.call(
                                                    thisObject, item,
                                                    actx = new AsyCtx(
                                                        def, idx, key, prev,
                                                        notify.after ? onACtxFulfill : undef
                                                    )
                                                );
                                                if (actx.promise) val = actx.promise;
                                            }
                                        }
                                        if (!promise.isResolved()) qwhen(
                                            val,
                                            function (val) {
                                                if (actx) {
                                                    actx.release();
                                                    if (actx.fulfilled)
                                                        return;
                                                    actx = null;
                                                }
                                                if (notify.after)
                                                    def.notify({ index: idx, key: key, data: val, kind: "after" });
                                                prev = val;
                                                idx++;
                                                if (idx === targetLen) def.resolve(prev); else {
                                                    if (!inTick) {
                                                        inTickCount = 0;
                                                        inTick = true;
                                                    }
                                                    if (!stackThreshold || (stackThreshold && (inTickCount < stackThreshold))) sepStep(); else
                                                        asy.callAfter(sepStep);//cut stack
                                                }
                                            },
                                            def.reject
                                        );
                                        inTick = false;
                                    } catch (exception) {
                                        def.reject(exception);
                                    }
                                };
                            step();
                        }
                    },
                    def.reject
                );
                return promise;
            },
            /**
             * Iterate all elements of Target consistently, organizing asynchronous iterator call to the pool the size of which is specified in poolSize argument.
             * @param {!Number} poolSize
             * @param {*[]|Object|Promise} target
             * @param {function(item: *, actx: AsyCtx): *|Promise} [iterator]
             * @param {Object} [thisObject]
             * @param {Object} [options]
             * @param {Number|Boolean} [options.separate=false]
             * @param {Boolean|function(item1: String|*, item2: String|*): Number} [options.sort=false]
             * @param {"after"|"before"|"both"|"none"|Boolean} [options.notify="after"]
             * @return Promise
             */
            eachPooled: function (poolSize, target, iterator, thisObject, options) {
                options = options || {};
                iterator = iterator || false;
                if (!poolSize || poolSize < 1) poolSize = 2;
                var def = vow.defer(),
                    promise = def.promise();
                vow.when(
                    target,
                    function (/**Object|*[]*/target) {
                        var isArr = isArray(target),
                            keys = isArr ? null : getObjectKeys(target),
                            key,
                            idx = -1,
                            /**Object|[]*/_target = isArr ? target : [],
                            isLightIterator = iterator && iterator.length < 2,
                            notify = parseNotifyOption(options.notify);
                        if (!isArr) enumerate(
                            target,
                            function (item) { this.push(item); },
                            _target, options.sort
                        );
                        else if (options.sort && target.length > 1)
                            _target = _target.sort(isFunction(options.sort) ? options.sort : undef);
                        var resolver = function (index, key, data) {
                                return promise.isResolved()
                                    ? null
                                    : { index: idx, key: key, data: data, kind: "after" };
                            },
                            onACtxFulfill = function (data) {
                                def.notify({ index: this.index, key: this.key, data: data, kind: "after" });
                            },
                            asyQ = new AsyQ(function (item) {
                                var /***|Promise*/val, actx;
                                idx++;
                                key = isArr ? idx : keys[idx];
                                if (notify.before)
                                    def.notify({ index: idx, key: key, data: item, kind: "before" });
                                if (iterator === false) val = item; else {
                                    if (isLightIterator) val = iterator.call(thisObject, item); else {
                                        actx = new AsyCtx(def, idx, key, undef, notify.after ? onACtxFulfill : undef);
                                        val = iterator.call(thisObject, item, actx);
                                        if (actx.promise) val = actx.promise;
                                    }
                                }
                                if (promise.isResolved()) {
                                    asyQ.empty();
                                    return null;
                                } else if (!vow.isPromise(val)) {
                                    return { index: idx, key: key, data: val, kind: "after" };
                                } else
                                    return val.then(hitch(val, resolver, idx, key));
                            }, {
                                processLimit: poolSize,
                                separate:     options.separate,
                                elems:        _target,
                                paused:       true,
                                reverse:      true
                            });
                        asyQ.on("error", function (error) { def.reject(error); });
                        asyQ.on("data", function (data) { if (data) def.notify(data); });
                        asyQ.on("drain", function () { def.resolve(); });
                        asyQ.resume();
                    },
                    def.reject
                );
                return promise;
            },
            /**
             * As well as Array#map return sequential mapped target elements by iterator
             * @see https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/Map Array.prototype.map()
             * @param {*[]|Object|Promise} target Target
             * @param {function(item: *, actx: { key: String|Number, index: Number, result: Object|*[]}): *|Promise} [iterator] Iterator
             * @param {Object} [thisObject] Iterator context
             * @param {Object} [options]
             * @param {Number|Boolean} [options.separate=false] Bypass separate interval
             * @param {Number|Boolean} [options.stackLimit=true] Limit of execution stack
             * @param {Boolean|(function(item1: String|*, item2: String|*): Number)} [options.sort=false]
             * @param {"after"|"before"|"both"|"none"|Boolean} [options.notify="after"]
             * @return Promise
             */
            mapSeries:  function (target, iterator, thisObject, options) {
                options = options || {};
                var def = vow.defer();
                vow.when(
                    target,
                    function (target) {
                        var isArr = isArray(target),
                            result = isArr ? new Array(target.length) : {};
                        iterator = iterator || false;
                        var isLightIterator = iterator && iterator.length < 2,
                            _iterator = function (item, actx) {
                                return iterator.call(thisObject, item, { key: actx.key, index: actx.index, result: result });
                            },
                            _lightIterator = function (item) { return iterator.call(thisObject, item); },
                            _iteratorStub = function (item) { return item; };
                        var promise = asy.eachSeries(
                            target,
                            iterator
                                ? (isLightIterator ? _lightIterator : _iterator)
                                : _iteratorStub,
                            null, options
                        );
                        promise.then(
                            function () { def.resolve(result); },
                            def.reject,
                            function (aprog) {
                                if (aprog.kind === "after")
                                    result[aprog.key] = aprog.data;
                                def.notify(aprog);
                            }
                        );
                    },
                    def.reject
                );
                return def.promise();
            },
            /**
             * "Pooled" version of {@link asy.mapSeries}
             * @param {!Number} poolSize
             * @param {*[]|Object|Promise} target
             * @param {function(item: *, actx: { key: String|Number, index: Number, result: Object|*[]} ): *|Promise} [iterator]
             * @param {Object} [thisObject]
             * @param {Object} [options]
             * @param {Number|Boolean} [options.separate=false]
             * @param {Boolean|function(item1: String|*, item2: String|*): Number} [options.sort=false]
             * @param {"after"|"before"|"both"|"none"|Boolean} [options.notify="after"]
             * @return Promise
             */
            mapPooled:  function (poolSize, target, iterator, thisObject, options) {
                options = options || {};
                var def = vow.defer();
                vow.when(
                    target,
                    function (target) {
                        var isArr = isArray(target),
                            result = isArr ? new Array(target.length) : {};
                        iterator = iterator || false;
                        var _iterator = function (item, actx) {
                                return iterator.call(
                                    thisObject, item,
                                    { key: actx.key, index: actx.index, result: result }
                                );
                            },
                            _iteratorStub = function (item) { return item; };
                        asy.eachPooled(
                            poolSize, target,
                            iterator ? _iterator : _iteratorStub,
                            null, options
                        ).then(
                            function () { def.resolve(result); },
                            def.reject,
                            function (aprog) {
                                if (aprog.kind === "after")
                                    result[aprog.key] = aprog.data;
                                def.notify(aprog);
                            }
                        );
                    },
                    def.reject
                );
                return def.promise();
            },
            /**
             * As well as Array#map return parallel mapped target elements by iterator
             * @see https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/Map Array.prototype.map()
             * @param {*[]|Object|Promise} target Target
             * @param {function(item: *, actx: { key: String|Number, index: Number, result: Object|*[] }): *|Promise} [iterator] Iterator
             * @param {Object} [thisObject] Iterator context
             * @param {Object} [options]
             * @param {Boolean|function(item1: String|*, item2: String|*): Number} [options.sort=false]
             * @param {"after"|"before"|"both"|"none"|Boolean} [options.notify="after"]
             * @return Promise
             */
            map:        function (target, iterator, thisObject, options) {
                options = options || {};
                iterator = iterator || false;
                var def = vow.defer();
                vow.when(
                    target,
                    function (/***[]|Object*/target) {
                        var isArr = isArray(target),
                            keys = isArr ? null : getObjectKeys(target),
                            len = isArr ? target.length : keys.length,
                            result = isArr ? new Array(len) : {},
                            waitCount = 0, enumDone = false,
                            onReject = function (error) {
                                if (!def.isResolved())
                                    def.reject(error);
                            },
                            notify = parseNotifyOption(options.notify);
                        enumerate(target, function (/***|Promise*/val, key, index) {
                            if (notify.before)
                                def.notify({ index: index, key: key, data: val, result: result, kind: "before" });
                            if (iterator !== false) val = iterator.call(
                                thisObject, val,
                                { key: key, index: index, result: result }
                            );
                            if (!vow.isPromise(val)) {
                                result[key] = val;
                                if (notify.after)
                                    def.notify({ key: key, index: index, data: val, result: result, kind: "after" });
                            } else {
                                waitCount++;
                                val.then(
                                    function (val) {
                                        result[key] = val;
                                        if (notify.after)
                                            def.notify({ key: key, index: index, data: val, result: result, kind: "after" });
                                        waitCount--;
                                        if (!waitCount && enumDone) def.resolve(result);
                                    },
                                    onReject
                                );
                            }
                        }, null, options.sort);
                        enumDone = true;
                        if (!waitCount) def.resolve(result);
                    },
                    def.reject
                );
                return def.promise();
            },
            /**
             * Array#reduce analog for asy
             * @see https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce Array.prototype.reduce()
             * @param {*[]|Object|Promise} target
             * @param {!function(prev: *, curr: *, actx: { key: String|Number, index: Number, target: *[]|Object })} reducer
             * @param {Object} [thisObject]
             * @param {Object} [options]
             * @param {*} [options.initialValue]
             * @param {Boolean|function(item1: String|*, item2: String|*): Number} [options.sort=false]
             * @return Promise
             */
            reduce:     function (target, reducer, thisObject, options) {
                options = options || {};
                var def = vow.defer();
                vow.when(
                    target,
                    function (/**Object|*[]*/target) {
                        var /**Boolean*/isArr = isArray(target),
                            /**[]*/keys = isArr ? null : getObjectKeys(target),
                            /**Number*/len = isArr ? target.length : keys.length,
                            /***|Promise*/val, idx = 0, key, stepVars,
                            resolver = function (val) {
                                if (len === idx) def.resolve(val); else
                                    step(val);
                            },
                            step = function (prev, first) {
                                if (len === idx) def.resolve(val); else {
                                    if (first === true && "initialValue" in options) {
                                        stepVars = [options.initialValue, prev];
                                        idx++;
                                        key = isArr ? idx : keys[idx];
                                    } else
                                        stepVars = [prev, target[key = isArr ? idx++ : keys[idx++]]];
                                    vow.all(stepVars).then(
                                        function (/**[]*/data) {
                                            try {
                                                val = reducer.call(thisObject, data[0], data[1], {
                                                    key:    isArr ? idx - 1 : keys[idx - 1],
                                                    index:  idx - 1,
                                                    target: target
                                                });
                                                if (!vow.isPromise(val)) step(val); else
                                                    val.then(resolver, def.reject);
                                            } catch (exception) {
                                                def.reject(exception);
                                            }
                                        },
                                        def.reject
                                    );
                                }
                            };
                        if (options.sort && len > 1) {
                            if (isArr) target = target.sort(isFunction(options.sort) ? options.sort : undef); else
                                keys = keys.sort(isFunction(options.sort) ? options.sort : undef);
                        }
                        step(target[key = isArr ? idx : keys[idx]], true);
                    },
                    def.reject
                );
                return def.promise();
            }
        };
        if (!ALLOW_NEXT_TICK) {
            asy.applyAfter = asy.applyLater;
            asy.callAfter = asy.callLater;
        }
        asy.immediately = asy.callLater;
        asy.nextTick = asy.callAfter;
        return asy;
        /**@name asy*/
    };
    var defineAsGlobal = true;
    if (typeof global.modules !== "undefined") {
        global.modules.define("vow-asy", ["vow"], function (provide, vow) {
            provide(provideModule(vow));
        });
        defineAsGlobal = false;
    }
    if (typeof global.define === "function") {
        global.define(["vow"], function (vow) {
            return provideModule(vow);
        });
        defineAsGlobal = false;
    }
    if (typeof module === "object" && typeof module.exports === "object") {
        module.exports = provideModule(require("vow"));
        defineAsGlobal = false;
    }
    if (defineAsGlobal) {
        global["asy"] = provideModule(global["vow"]);
    }
})(function () { return this; }());


Join our Google Hangout with guest of honor, Jenny Sanders, on Monday, April 1st from 6:00- 6:30 PM CST. If you're interested in stationary and calligraphy, this Hangout is for you!
Hangouts are limited to eight participants, a moderator, and Jenny. There will be no boring presentation. Instead, participants have the opportunity to "Hangout" with Jenny and ask any questions. The session will not be live-streamed or recorded and is exclusive to members.
To learn more about Jenny, please click here.


text:
Q: How to write a script that will calculate an interest rate I am building a form using the WP plugin called Calculated Fields Form.
The first question is for people to enter the amount they want to invest (fieldname2)
The second question is for people to select the number of months (fieldname3)
Based on the amount and the length, a different interest rate should be displayed.
I am supposed to enter the equation myself so I wrote the following script to try but it doesn't work.
(function()`{`
if (50<=fieldname2<=99 && fieldname3=3) return fieldname2*4/100;
if (50<=fieldname2<=99 && fieldname3=6) return fieldname2*6/100;
if (50<=fieldname2<=99 && fieldname3=12) return fieldname2*8/100;
`}`)();

A: It's a little unclear what you are trying to achieve here but the issues with your code are as follows:
(function()`{`
// --------^^^ unexpected template string
if (50<=fieldname2<=99 && fieldname3=3) return fieldname2*4/100;
// ------^^^ this is not valid  ----^^^ should be === not =
if (50<=fieldname2<=99 && fieldname3=6) return fieldname2*6/100;
if (50<=fieldname2<=99 && fieldname3=12) return fieldname2*8/100;
`}`)();
// immediately invoked function - but why?
// what happens if "50<=fieldname2<=99" is not satisfied?

A bit of advice - write the function first as a testable entity to see if it is even getting the result you want. Use expressive arguments so you can reason about what you are doing. Consider cases that are not covered by your function (see comments below). In those cases, you will return undefined which I doubt is desirable.
function calculateInterest (amount, months) {
  if (50 <= amount && amount <= 99) {
    if (months === 3) return amount*4/100;
    if (months === 6) return amount*6/100;
    if (months === 12) return amount*8/100;
    // what should we return if months does not satisfy one of the above?
  }
  // what should we return if amount does not satisfy the above?
}

Assuming fieldname2 and fieldname3 are variables that exist in your code, you can now call the function calculateInterest(fieldname2, fieldname3)

redpajama_set_name: RedPajamaStackExchange


You can use either Ax 647 or  APC in a single tube and read it in FL4.
PE-Cy5 (FL3) and APC (FL4) can be used simulataneously in FACSCalibur.
Experiment needs to be carefully designed to minimise compensation.
Pls refere to Purdue email archives for previous discussion on this.
to measure FL1, FL2, FL3 and FL4.


Hospital care has long been associated with development of nosocomial infection. Recently, these infections have been identified as a significant public health problem. Changes in health care delivery over time, including the increased use of invasive procedures or immunosuppressive therapy in hospitalized patients and, conversely, out of hospital treatment of less seriously ill patients has likely changed the frequency and pattern of nosocomial infections. However, it has been difficult to document trends in the occurrence of all nosocomial infections, given the difficulty of capturing such data and the limited immediate benefit of doing so. Noso- comial infections associated with blood stream infection account for less than 10% of the total, but may result in greater attributable mortality, prolonged length of hospitalization and a higher cost of care than other infections. Furthermore, such infections are much easier to detect in a prospective surveillance system. Changes in the occurrence of noso- comial blood stream infections may, therefore, provide easily obtainable data which can be used as a surrogate for changes in all nosocomial infections.
Since August 1986, blood culture reports have been pro- spectively monitored at University of Alberta Hospital to determine the occurrence of nosocomial bloodstream infection. Studies of organ system infections resulting in bloodstream infection and specific microorganisms causing those infections have been reported. The present study examines all sources, microbiological etiology and long term trends in the frequency of nosocomial bloodstream infection from August 1, 1986 to December 31, 1996.


text:
WPL Teenspace
Teens' Top Ten
Rebecca Caudill
Quarantine Stories
Books to Inspire Action
Posted by Lisa on July 23, 2020 0 Comments
YALSA's Teens' Top Ten Winners – 2020
Indigenous Authors
2020 Book Awards
Check out these reads (fiction and nonfiction) about activism and justice.
Black Lives Matter by Sue Bradford Edwards and Duchess Harris
Black Lives Matter covers the shootings that touched off passionate protests, the work of activists to bring about a more just legal system, and the tensions in US society that these events have brought to light.
Twelve Days in May by Larry Brimner
For twelve history-making days in May 1961, thirteen black and white civil rights activists, also known as the Freedom Riders, traveled by bus into the South to draw attention to the unconstitutional segregation still taking place. Despite their peaceful protests, the Freedom Riders were met with increasing violence the further south they traveled.
Because I was a Girl edited by Melissa de la Cruz
Brief writings from an array of girls and women who are trailblazers in their fields, discussing the barriers they've faced, the battles they've fought, and the dreams they've brought to life. The entries are arranged by decade, from Dolores Huerta learning how organizations contribute to the community in the 1920s, to Mattie Johnston explaining that no one every told her she couldn't do anything "because I was a girl" in the 2000s.
Here We Are: Feminism for the Real World edited by Kelly Jensen
A scrapbook-style teen guide to understanding what it really means to be a feminist packed with contributions from a diverse range of voices, including celebrities and public figures, and featuring more than forty-four pieces, including an eight-page insert of full-color illustrations.
Nevertheless, We Persisted forward by Amy Klobuchar
A powerful collection of essays from actors, activists, athletes, politicians, musicians, writers, and teens, each writing about a time in their youth when they were held back because of their race, gender, or sexual identity– but persisted.
March (Books One, Two, and Three) by John Lewis
This graphic novel is a first-hand account of Congressman John Lewis' lifelong struggle for civil and human rights, meditating in the modern age on the distance traveled since the days of Jim Crow and segregation.
Turning 15 on the Road to Freedom by Lynda Blackmon Lowery
A 50th-anniversary tribute shares the story of the youngest person to complete the momentous Selma to Montgomery March.
Glimmer of Hope by March for Our Lives
Glimmer of Hope tells the story of how a group of teenagers raced to channel their rage and sorrow into action, and went on to create one of the largest youth-led movements in global history.
We Say #NeverAgain reporting by the Parkland Student Journalists
This collection of essays looks at the shooting at Marjory Stoneman Douglas High School in Parkland and the fight for gun control– as told by the student reporters for the school's newspaper and TV station.
Queer, There, and Everywhere by Sarah Prager
Queer author and activist Sarah Prager delves deep into the lives of 23 people who fought, created, and loved on their own terms.
My Body, My Choice by Robin Stevenson
This book examines the ongoing fight for abortion rights and reproductive justice.
How Dare the Sun Rise by Sandra Uwiringiyimana
Sandra Uwiringiyimana was just ten years old when she found herself with a gun pointed at her head. The rebels were killing people who weren't from the same community, the same tribe. In other words, they were killing people simply for looking different. Remarkably, Sandra escaped into the night. In this memoir, Sandra tells the story of her survival, of finding her place in a new country, and of her hope for the future.
Yes No Maybe So by Becky Albertalli and Aisha Saeed
Jamie Goldberg, who chokes when speaking to strangers, and Maya Rehrman, who is having the worst Ramadan ever, are paired to knock on doors and ask for votes for the local state senate candidate.
Internment by Samira Ahmed
A terrifying, futuristic United States where Muslim-Americans are forced into internment camps, and seventeen-year-old Layla Amin must lead a revolution against complicit silence.
The Epic Fail of Arturo Zamora by Pablo Cartaya
Save the restaurant. Save the town. Get the girl. Make Abuela proud. Can thirteen-year-old Arturo Zamora do it all or is he in for a BIG, EPIC FAIL?
Amina's Voice by Hena Khan
A Pakistani-American Muslim girl struggles to stay true to her family's vibrant culture while simultaneously blending in at school after tragedy strikes her community.
Moxie by Jennifer Mathieu
In a small Texas town where high school football reigns supreme, Viv, sixteen, starts a feminist revolution using anonymously-written zines.
The Nowhere Girls by Amy Reed
Three misfit girls come together to avenge the rape of a girl none of them knew and in the process start a movement that transforms the lives of everyone around them.
All American Boys by Jason Reynolds and Brendan Kiely
When sixteen-year-old Rashad is mistakenly accused of stealing, classmate Quinn witnesses his brutal beating at the hands of a police officer who happens to be the older brother of his best friend. Told through Rashad and Quinn's alternating viewpoints.
Dear Martin by Nic Stone
Writing letters to the late Dr. Martin Luther King Jr., seventeen-year-old college-bound Justyce McAllister struggles to face the reality of race relations today and how they are shaping him.
This Time Will Be Different by Misa Sugiura
Katsuyamas never quit — but seventeen-year-old CJ doesn't even know where to start. But when it comes to arranging the perfect bouquet, CJ discovers a knack she never knew she had. Then her mom decides to sell the shop — to the family who swindled CJ's grandparents when thousands of Japanese Americans were sent to internment camps during WWII. Soon a rift threatens to splinter CJ's family, friends, and their entire Northern California community; and for the first time, CJ has found something she wants to fight for.
After witnessing her friend's death at the hands of a police officer, Starr Carter's life is complicated when the police and a local drug lord try to intimidate her in an effort to learn what happened the night Kahlil died.
Watch Us Rise by Renee Watson
Jasmine and Chelsea are best friends on a mission–they're sick of the way women are treated even at their progressive NYC high school, so they decide to start a Women's Rights Club. They post their work online–and soon they go viral. But the club is also targeted by trolls. When things escalate in real life, the principal shuts the club down. Not willing to be silenced, Jasmine and Chelsea will risk everything for their voices–and those of other young women–to be heard.
White Rose by Kip Wilson
Disillusioned by the propaganda of Nazi Germany, Sophie Scholl, her brother, and his fellow soldiers formed the White Rose. A non-violent resistance group, they write and distribute anonymous letters criticizing the Nazi regime and calling for action from their fellow German citizens. When Sophie and her brother are arrested for treason and interrogated for information about their collaborators, they know that speaking out against Hitler's regime is punishable by death. Is it too late to try to save their lives?
*Book summaries from our catalog.
Find us on Goodreads!
Aiden Thomas
Girl, Serpent, Thorn
Melissa Bashardoust
The Extraordinaries (The Extraordinaries, #1)
T.J. Klune
Awards, Lists, and More
Lincoln Award: Illinois Teen Readers' Choice | 2021 Nominees
Lincoln Award: Illinois Teen Readers' Choice Winners
Rebecca Caudill | 2020 Nominees
Rebecca Caudill Award Winners
2020 Teens' Top Ten Nominees
Michael L Printz Award
Coretta Scott King Award: Young Adult Winners & Honors Past and Present
© 2021 WPL Teenspace

redpajama_set_name: RedPajamaCommonCrawl


The Java Servlet specification is the common denominator for most server-side Java Web technologies, including JavaServer Pages (JSP), JavaServer Faces (JSF), numerous Web frameworks, SOAP and RESTful Web services APIs, and newsfeeds. The servlets running underneath these technologies make them portable across all Java Web servers (servlet containers). Any proposed changes to this widely accepted API for handling HTTP communications will potentially affect all affiliated server-side Web technologies.
Asynchronous support is Servlet 3.0's most significant enhancement, intended to make the server-side processing of Ajax applications much more efficient. In this article I'll focus on asynchronous support in Servlet 3.0, starting by explaining the connection and thread-consumption issues that underlie the need for asynchronous support. I'll then explain how real-world applications today utilize asynchronous processing in server push implementations like Comet, or reverse Ajax. Finally, I'll touch on Servlet 3.0's other enhancements such as pluggability and ease of configuration, leaving you with a good impression of Servlet 3.0 and its impact on Java Web development.
Web 2.0 technologies drastically change the traffic profile between Web clients (such as browsers) and Web servers. Asynchronous support introduced in Servlet 3.0 is designed to respond to this new challenge. In order to understand the importance of asynchronous processing, let's first consider the evolution of HTTP communications.
Figuring out how to make Web servers more scalable is an ongoing challenge for vendors. Thread per HTTP connection, which is based on HTTP 1.1's persistent connections, is a common solution vendors have adopted. Under this strategy, each HTTP connection between client and server is associated with one thread on the server side. Threads are allocated from a server-managed thread pool. Once a connection is closed, the dedicated thread is recycled back to the pool and is ready to serve other tasks. Depending on the hardware configuration, this approach can scale to a high number of concurrent connections. Experiments with high-profile Web servers have yielded numerical results revealing that memory consumption increases almost in direct proportion with the number of HTTP connections. The reason is that threads are relatively expensive in terms of memory use. Servers configured with a fixed number of threads can suffer the thread starvation problem, whereby requests from new clients are rejected once all the threads in the pool are taken.
On the other hand, for many Web sites, users request pages from the server only sporadically. This is known as a page-by-page model. The connection threads are idling most of the time, which is a waste of resources.
Thanks to the non-blocking I/O capability introduced in Java 4's New I/O APIs for the Java Platform (NIO) package, a persistent HTTP connection doesn't require that a thread be constantly attached to it. Threads can be allocated to connections only when requests are being processed. When a connection is idle between requests, the thread can be recycled, and the connection is placed in a centralized NIO select set to detect new requests without consuming a separate thread. This model, called thread per request, potentially allows Web servers to handle a growing number of user connections with a fixed number of threads. With the same hardware configuration, Web servers running in this mode scale much better than in the thread-per-connection mode. Today, popular Web servers -- including Tomcat, Jetty, GlassFish (Grizzly), WebLogic, and WebSphere -- all use thread per request through Java NIO. For application developers, the good news is that Web servers implement non-blocking I/O in a hidden manner, with no exposure whatsoever to applications through servlet APIs.
To offer a richer user experience with more-responsive interfaces, more and more Web applications use Ajax. Users of Ajax applications interact with the Web server much more frequently than in the page-by-page model. Unlike ordinary user requests, Ajax requests can be sent frequently by one client to the server. In addition, both the client and scripts running on the client side can poll the Web server regularly for updates. More simultaneous requests cause more threads to be consumed, which cancels out the benefit of the thread-per-request approach to a high degree.
Some slow-running back-end routines worsen the situation. For example, a request could be blocked by a depleted JDBC connection pool, or a low-throughput Web service endpoint. Until the resource becomes available, the thread could be stuck with the pending request for a long time. It would be better to place the request in a centralized queue waiting for available resources and recycle that thread. This effectively throttles the number of request threads to match the capacity of the slow-running back-end routines. It also suggests that at a certain point during request processing (when the request is stored in the queue), no threads are consumed for the request at all. Asynchronous support in Servlet 3.0 is designed to achieve this scenario through a universal and portable approach, whether Ajax is used or not. Listing 1 shows you how it works.
When the asyncSupported attribute is set to true, the response object is not committed on method exit. Calling startAsync() returns an AsyncContext object that caches the request/response object pair. The AsyncContext object is then stored in an application-scoped queue. Without any delay, the doGet() method returns, and the original request thread is recycled. In the ServletContextListener object, separate threads initiated during application launch monitor the queue and resume request processing whenever the resources become available. After a request is processed, you have the option of calling ServletResponse.getWriter().print(...), and then complete() to commit the response, or calling forward() to direct the flow to a JSP page to be displayed as the result. Note that JSP pages are servlets with an asyncSupported attribute that defaults to false.
In addition, the AsyncEvent and AsynListener classes in Servlet 3.0 give developers elaborate control of asynchronous lifecycle events. You can register an AsynListener through the ServletRequest.addAsyncListener() method. After the startAsync() method is called on the request, an AsyncEvent is sent to the registered AsyncListener as soon as the asynchronous operation has completed or timed out. The AsyncEvent also contains the same request and response objects as in the AsyncContext object.
A more interesting and vital use case for the Servlet 3.0 asynchronous feature is server push. GTalk, a widget that lets GMail users chat online, is an example of server push. GTalk doesn't poll the server frequently to check if a new message is available to display. Instead it waits for the server to push back new messages. This approach has two obvious advantages: low-lag communication without requests being sent, and no waste of server resources and network bandwidth.
Ajax allows a user to interact with a page even if other requests from the same user are being processed at the same time. A common use case is to have a browser regularly poll the server for updates of state changes without interrupting the user. However, high polling frequencies waste server resources and network bandwidth. If the server could actively push data to browsers -- in other words, deliver asynchronous messages to clients on events (state changes) -- Ajax applications would perform better and save precious server and network resources.
Long polling, also known as asynchronous polling, is a hybrid of pure server push and client pull. It is based on the Bayeux protocol, which uses a topic-based publish-subscribe scheme. As in streaming, a client subscribes to a connection channel on the server by sending a request. The server holds the request and waits for an event to happen. Once the event occurs (or after a predefined timeout), a complete response message is sent to the client. Upon receiving the response, the client immediately sends a new request. The server, then, almost always has an outstanding request that it can use to deliver data in response to a server-side event. Long polling is relatively easier to implement on the browser side than streaming.
Passive piggyback: When the server has an update to send, it waits for the next time the browser makes a request and then sends its update along with the response that the browser was expecting.
Ajax improves single-user responsiveness. Server-push technologies like Comet improve application responsiveness for collaborative, multi-user applications without the overhead of regular polling.
The client aspect of the server push techniques -- such as hidden iframes, XMLHttpRequest streaming, and some Dojo and jQuery libraries that facilitate asynchronous communication -- are outside this article's scope. Instead, our interest is on the server side, specifically how the Servlet 3.0 specification helps implement interactive applications with server push.


text:
Beatle in a Ballpark
Paul McCartney selects offbeat Fort Worth-area venue for his spring tour
Dec 4, 2018 | 12:56 pm
Paul McCartney will play at Globe Life Park in Arlington on June 14, 2019.
Photo by Chad Wadsworth
Paul McCartney will make one very special stop in Texas on a spring 2019 tour to promote his newest album.
Called The Freshen Up Tour, it's an extremely limited-run engagement with only 10 stops — including a June 14, 2019 date at Globe Life Park in Arlington.
To clarify, the concert will be at Globe Life Park, where Texas Rangers games currently take place — not Globe Life Field, the new ballpark being built across the parking lot, expected to open in spring of 2020.
While Globe Life Park has hosted smaller, post-game events, this is the first major concert to take place at the ballpark.
Sean Decker, Texas Rangers SVP of Operations and Events, says in a release that they're ecstatic to host "Sir Paul."
"This will be a historic event that fans will remember for years to come as the venue approaches its final season as a Major League Baseball park," Decker says.
The tour follows the release of McCartney's new album, Egypt Station, released on September 7. Fans can expect a nearly three-hour-long show featuring dozens of songs from McCartney's solo career, time with Wings, and the Beatles catalog.
This is the only confirmed stop in Texas.
The former Beatle last played in the Dallas-Fort Worth area in 2014 at American Airlines Center. Previously, he played at AT&T Stadium in 2009. He appears to be on a once-every-five-years timeline.
Tickets go on sale to the general public on Thursday, December 13 at 10 am. American Express Card Members can purchase tickets before the general public, December 10-12.
The full tour is here:
May 23 - New Orleans, LA - Smoothie King Arena
May 27 - Raleigh, NC - PNC Arena
May 30 - Greenville, SC - Bon Secours Wellness Arena
June 1 - Lexington, KY - Rupp Arena
June 3 - Fort Wayne, IN - Allen County War Memorial Coliseum
June 6 - Madison, WI - Kohl Center
June 8 - Green Bay WI - Lambeau Field
June 11 - Moline, IL - TaxSlayer Center
June 14 - Arlington TX - Globe Life Park
June 26 - Phoenix, AZ - Talking Stick Resort Arena
The Freshen Up tour began in September. The Arlington date is the newest addition to the spring leg, along with Lambeau Field in Wisconsin, home to the Green Bay Packers football team.
celebritiesconcertssports


text:
Dates and Organizers of World Champs Africa qualifying final phase confirmed
By: Editors
Cameroon, who were a huge hit in the 2010 edition, will play their Africa third round FIVB Volleyball Men's World Championship Poland 2014 qualifier in front of their own fans
Cairo, Egypt, January 6, 2014 - The African Volleyball Confederation has confirmed the dates and organizers for the third and final phase of the African qualification tournaments for the 2014 FIVB Volleyball World Championships, which are due to be held in Poland and Italy in September and October later this year.
Fifteen teams will be participating in the men's qualifiers and will be divided into three pools of five. The winner of each pool will secure a ticket to the finals in Poland, which will take place from September 3 to 18.
Cameroon will organize the first men's group (Pool T) from February 12 to 18, 2014 which will include the participation of Algeria, Nigeria, Rwanda and Gabon besides the organizer.
The second group (Pool U) will be held in Kenya, joined by Botswana, Zambia, Cape Verde and Egypt to play the tournament in Nairobi from February 5-11, 2014.
Tunisia will host the third group (Pool V) where they will battle it out against the Seychelles, Congo Brazzaville, Senegal and Niger for a ticket to the finals.
The women's third round qualifiers feature 14 teams and are divided into two pools where the winner of both will clinch a ticket to the finals in Italy, which will be held from September 23 to October 12.
Algeria will be hosting the first group (Pool T) from February 23 to March 2, 2014 where the hosts along with Botswana, Ghana, Cameroon, RD Congo, Nigeria and Egypt will contest a ticket to the finals.
Kenya will organize the second women's group (Pool U) from February 16 to 23, 2014 with the Seychelles, Uganda, Tunisia, Senegal, Mozambique and Cape Verde all participating.


HomeBlog How Flowmon can help you grow your career?
How Flowmon can help you grow your career?
Three weeks ago I was giving a presentation to a customer and you wouldn't believe what question I have received. "So how the deployment of Flowmon can help me and my colleague to grow in career?" Wow!
I was confused, as this is not a regular question one is receiving during the introduction meeting. Usually I receive questions like: "What type of info can Flowmon deliver?" "How alerting is done in Flowmon?" "How the detection methods work in Flowmon Anomaly Detection System?". But the aforementioned one was really different and honestly, a bit unexpected.
As I'm a calm guy, I didn't react immediately to avoid saying something unreasonable or completely irrelevant. The question laid down in my head and I started to see a sense why it was asked. Of course he wants to know that. He is going to present benefits of Flowmon to his boss and obviously he wants to be the best in his eyes. He wants to show him his professionality. Maybe also a personal bonus is included. Actually, it was a very relevant question!
With monitoring and visibility, you know exactly what is going on in your network. Thanks to that all the admins are aware of everything and they can very easily find whatever they are looking for. So if there is any issue, you can discover and solve it within few hours. It means you are much more effective and can spent your precious time on another (maybe more important) tasks. In the end of the day it is about saving money as well.
As you are monitoring the traffic in the network, you can very easily find out security breaches. And I think every organization is going to be grateful to detect ransomware Locky (encrypting shared files and blackmailing afterwards), or massive upload of internal data to external shared storage services (especially if the employee is on leave notice), or even compromised DNS servers (stealing login credentials and much more). All of them and much more might be detected via traffic analysis and in the end of the day save a lot of resources to the organization.
Do you know if users are using only allowed services and applications? I'm sure no one wants his employees to run a torrent in their network and I will bet it is against company policies in 99 % organizations. In the end it might compromise the whole reputation and nobody wants that (not even mentioning high chance of infection). Do you know what your employees are doing when you are not watching?
Some questions can always surprise me like this one with Flowmon and career growth. Flowmon is not a tool for a career growth, it must be clear. It's a network monitoring and analysis solution. Even though, it helps network professionals to develop their skills and also to grow career at the end of the day. How? By knowing advanced network monitoring, the one will achieve knowledge, which will shift his skills on the next level. In the end the person is able to manage the IT environment as a professional and with that receive appreciation from management as well.


Ermite : Cheese, Canada, Canadian Cheese, Springbank Cheese Co.
Blue Ermite cheese is sharp and crumbly Canadian blue cheese. Excellent for cooking, and salads. A Canadian alternative to Danish Blue, comes wrapped in foil.


I am very pleased with the education that I received at UCM; all around, it was a very good online experience. However, I did have a very bad experience with one of the instructors who is also over the Family Nurse Practitioner Program. I do NOT recommend taking her as an instructor, I would rate her at 1 out of 5. She grades hard and does not explain the assignments so you end up getting a low score. Stand clear from her. The other instructors were amazing and made you feel like they genuinely wanted you to succeed; this lady seemed like she wanted you to fail.
Central Missouri offered an excellent amount of support academically and personally while I persuaded my educational goal. The Counselors were very attentive with answering question and direction me on my path to success. This has not only been an dream come true, but an adventure to what dreams are made of and for this I will be forever grateful for the quality of Education received at UCM.


The prime minister leads in polls and is favoured to succeed the outgoing president.
But analysts say he may struggle to win the more than the 50 per cent needed to avoid a second round.
Kocharian chose him as his successor after Sarkisian's Republican Party of Armenia swept parliamentary elections in May last year.
Both men are credited with ensuring relative stability.
Speaking to tens of thousands of supporters at a rally on Sunday, Sarkisian, 53, said his government was the only one voters could trust to maintain economic growth.
"I know there are many problems in our country - poverty, unemployment, corruption. We are the only political force that knows how to resolve these problems," he said.
Sarkisian's two main rivals - Levon Ter-Petrosian, former president, and Artur Baghdasarian, a former parliamentary speaker - boosted the prime minister's chances by failing to unite ahead of the vote.
Opponents accuse the Sarkisian camp of making unfair use of state resources to promote his candidacy, a charge the prime minister has denied.
Opposition candidates say they will call supporters to protest if they believe the vote is unfair, raising fears of post-election unrest.
Analysts predict Sarkisian will follow in Kocharian's footsteps if elected - pursuing close ties with Moscow and maintaining a hawkish stance with neighbouring Azerbaijan and Turkey.
The two countries have cut diplomatic ties and sealed their borders with Armenia over its support for Armenian separatists in Azerbaijan's rebel Nagorny-Karabakh region.
Ankara has also been angered by efforts by the Armenian capital, Yerevan, to have mass killings of Armenians by the Ottoman Empire in the first world war internationally recognised as genocide.
Pre-election polls showed Sarkisian hovering at about 50 per cent support, with Ter-Petrosian and Baghdasarian trailing with between 10 and 15 per cent.
Opposition candidates have questioned the polling companies' independence.
About 600 foreign observers are to monitor the vote and analysts say the government is keen to win international legitimacy for the result.
The Organisation for Security and Cooperation in Europe (OSCE) is to issue a report on the election on Wednesday.
Parliamentary elections last May were the first to be declared largely in accordance with international standards.


text:
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

#include "error_codes.h"
#include "host_startup_info.h"
#include "pal.h"
#include "trace.h"
#include "utils.h"

host_startup_info_t::host_startup_info_t(
    const pal::char_t* host_path_value,
    const pal::char_t* dotnet_root_value,
    const pal::char_t* app_path_value)
    : host_path(host_path_value)
    , dotnet_root(dotnet_root_value)
    , app_path(app_path_value) {}

// Determine if string is a valid path, and if so then fix up by using realpath()
bool get_path_from_argv(pal::string_t *path)
{
    // Assume all paths will have at least one separator. We want to detect path vs. file before calling realpath
    // because realpath will expand a filename into a full path containing the current directory which may be
    // the wrong location when filename ends up being found in %PATH% and not the current directory.
    if (path->find(DIR_SEPARATOR) != pal::string_t::npos)
    {
        return pal::realpath(path);
    }

    return false;
}

int host_startup_info_t::parse(
    int argc,
    const pal::char_t* argv[])
{
    // Get host_path
    get_host_path(argc, argv, &host_path);

    // Get dotnet_root
    dotnet_root.assign(get_directory(host_path));

    // Get app_path
    app_path.assign(dotnet_root);
    pal::string_t app_name = get_filename(strip_executable_ext(host_path));
    append_path(&app_path, app_name.c_str());
    app_path.append(_X(".dll"));

    trace::info(_X("Host path: [%s]"), host_path.c_str());
    trace::info(_X("Dotnet path: [%s]"), dotnet_root.c_str());
    trace::info(_X("App path: [%s]"), app_path.c_str());
    return 0;
}

bool host_startup_info_t::is_valid(host_mode_t mode) const
{
    if (mode == host_mode_t::libhost)
    {
        // libhost allows empty app path
        return !host_path.empty() && !dotnet_root.empty();
    }

    return !host_path.empty()
        && !dotnet_root.empty()
        && !app_path.empty();
}

const pal::string_t host_startup_info_t::get_app_name() const
{
    return get_filename(strip_file_ext(app_path));
}

/*static*/ int host_startup_info_t::get_host_path(int argc, const pal::char_t* argv[], pal::string_t* host_path)
{
    // Attempt to get host_path from argv[0] as to allow for hosts located elsewhere
    if (argc >= 1)
    {
        host_path->assign(argv[0]);
        if (!host_path->empty())
        {
            trace::info(_X("Attempting to use argv[0] as path [%s]"), host_path->c_str());
            if (!get_path_from_argv(host_path))
            {
                trace::warning(_X("Failed to resolve argv[0] as path [%s]. Using location of current executable instead."), host_path->c_str());
                host_path->clear();
            }
        }
    }

    // If argv[0] did not work, get the executable name
    if (host_path->empty() && (!pal::get_own_executable_path(host_path) || !pal::realpath(host_path)))
    {
        trace::error(_X("Failed to resolve full path of the current executable [%s]"), host_path->c_str());
        return StatusCode::LibHostCurExeFindFailure;
    }

    return 0;
}

redpajama_set_name: RedPajamaGithub


Best in Sight in Freeport provides treatment, consultation and referrals for these common vision correction surgeries and procedures.
Vision correction is a general term used to describe a variety of techniques for correcting less-than-perfect vision. For your convenience, we have included a brief description of some of the most common vision correction procedures offered through Best in Sight in Freeport. For more specific information about lenses and frames or contacts, please visit their respective pages.
Best in Sight has the experience and equipment necessary to provide treatment, consultation and referrals for the vision correction procedures and surgeries detailed above at our office in Freeport.


text:
Cynthia Leitich Smith, nacida en Kansas City en 1967, es una escritora estadounidense, autora de libros de ficción para niños y jóvenes.

Es una amerindia, de la tribu de los Creek, y escribe ficción para los niños centrados en las vidas de los indios americanos de hoy en día. Estos libros se enseñan extensamente por parte de los profesores de escuela elemental, media, secundaria, y aulas de clase de la Universidad. Además, Smith escribe libros imaginarios, libros divertidos de dibujos y álbumes ilustrados, así como de fantasía gótica, para edades desde 14 años en adelante.

Obra publicada
 2000: Jingle Dancer.
 2001: Rain is Not My Indian Name.
 2002: Indian Shoes.
 2006: Santa Knows.
 2007: Tantalize.
 2009: Eternal.

Relatos cortos
 2003: The Gentleman Cowboy, en Period Pieces: Stories for Girls.
 2003: The Naked Truth en In My Grandmother's House: Award-Winning Authors tell Stories about their Grandmothers.
 2005: A Real-Live Blonde Cherokee and His Equally Annoyed Soul Mate, en Moccasin Thunder.
 2005: Riding With Rosa en Cicada'' (revista literaria)-

Enlaces externos
 Cynthia Leitich Smith Web oficial
 Tantalize Blog en español
 Cynsations  Blog de la autora
 Cynthia´s myspace Blog myspace de la autora

Escritoras de Estados Unidos
Escritores en inglés del siglo XXI
Escritores de Estados Unidos del siglo XXI
Nacidos en Kansas City (Misuri)
Alumnado de la Universidad de Míchigan

redpajama_set_name: RedPajamaWikipedia


Take I-70 East to US Hwy 68 North. Continue on US Hwy 68 to the State Route 41 exit. Take that exit and turn Right off of it. Follow State Route 41 to West McCreight Avenue. Turn Right onto West McCreight Avenue. Continue past the Speedway gas station. McCreight Avenue will turn into Mitchell Blvd. Go approximately 1/2 mile past Lagonda Elementary School. The field is located behind the skate park on the right hand side.


text:
Economic empowerment (-) (48)
Sexual harassment (-) (2)
Institutional mechanisms (-) (1)
Assessment of the Social Protection System in Armenia
Date: Monday, 8 November 2021
The assessment identifies the areas for further strengthening, with particular attention to gender equality and reiterates the importance of national social protection floors to protect people in case of different risks across the lifecycle and covariate shocks.
Workplace Sexual Harassment in the Civil Service in Georgia
The Study on Workplace Sexual Harassment in the Civil Service in Georgia is a joint initiative of UN Women and the Civil Service Bureau of Georgia. The study aimed at generating evidence to inform policies on preventing and responding to workplace sexual harassment in Georgia's civil service.
Gender Impact Assessment of the State Programme Plant the Future
Date: Monday, 23 August 2021
The Gender Impact Assessment (GIA) of the programme Plant the Future was conducted by the ISET Policy Institute (ISET-PI) as part of its collaboration with UN Women within the scope of the project "Regulatory Impact Assessment and Gender Impact Assessment for Women's Economic Empowerment in Georgia".
Gender Impact Assessment Methodology
The gender impact assessment (GIA) is an equality tool that helps assess the gendered impact of different policies, programmes and services. It provides technical knowledge to enhance public sector organizations, think tanks and international development organizations to create gender-responsive and equitable programmes.
Regulatory Impact Assessment of ILO C183 - Maternity Protection Convention
Date: Friday, 28 May 2021
The ISET Policy Institute (ISET-PI) - in collaboration with UN Women has implemented a Regulatory Impact Assessment (RIA) to study the prospects and organize a policy dialogue towards the possible ratification of the Maternity Protection Convention, 2000 (No. 183).
Regulatory Impact Assessment of ILO C189 - Domestic Workers Convention
Date: Monday, 24 May 2021
The ISET Policy Institute (ISET-PI) – in collaboration with UN Women in the scope of the project "Women's Economic Empowerment in the South Caucasus" (WEESC), funded by the Swiss Agency for Development and Cooperation (SDC) and the Austrian Development Cooperation (ADC) – has implemented a Regulatory Impact Assessment (RIA) to study the prospects and organize a policy dialogue towards the possible ratification of Convention No. 189.
The ISET Policy Institute (ISET-PI) - in collaboration with UN Women in the scope of the project "Women's Economic Empowerment in the South Caucasus" (WEESC), funded by the Swiss Agency for Development and Cooperation (SDC) and the Austrian Development Cooperation (ADC) – has implemented a Regulatory Impact Assessment (RIA) to study the prospects and organize a policy dialogue towards the possible ratification of Convention No. 189.
Women's Empowerment Principles in Georgia
Date: Tuesday, 23 February 2021
The publication combines the stories of success and inspiration of WEPs signatory companies in Georgia that demonstrated exemplary practices of empowering women, brought change to corporate culture, achieved inclusive growth and considered equality as both the right thing to do and good for business.
Assessment of the Social Protection System in Georgia
Date: Friday, 25 December 2020
The assessment of a social protection system in the Republic of Georgia carried out at the outset of the COVID-19 global pandemic reiterates the importance of national social protection floors to protect people in case of different risk across the lifecycle and covariate shocks.
Institutional Mechanisms for the Advancement of Women in Georgia
This issue brief describes four different branches of institutional mechanisms for the advancement of Women in Georgia, highlighting their functions and roles in ensuring gender equality and women's empowerment in Georgia.
Assessment of COVID-19's Impact on Women Employed as Domestic Workers in Georgia
Assessment of COVID-19's Impact on Women Employed as Domestic Workers in Georgia presents in-depth qualitative study findings on the impact of the pandemic on the lives of women domestic workers, highlights their challenges and needs and provides evidence-based recommendations to policymakers and practitioners.


Send personalized bulk emails to distribution lists, candidates, employees, clients, suppliers and other partners.
Our mass mailing tools are greatly optimized to send huge volumes of emails with out effecting delivery rates.
Email to candidates from Resume board search results such as Dice, Monster, Career Builder etc.


Dr. Luci (adjunct lecturer) has enjoyed teaching at Roanoke College for the past few years in addition to her "day job" as a clinical geropsychologist at the Salem VA Medical Center. She received a B.A. in cultural anthropology from Mary Washington College in 1999, a M.Ed. in curriculum and instruction from Virginia Tech in 2003, and a Psy.D. in clinical and school psychology in 2010 from James Madison University. Dr. Luci's teaching and research interests include aging, resilience, best practices in dementia care, and third-wave psychotherapies for caregivers and older adults.


text:
Home / News / Car Tech
BMW rolls out i8 Spyder concept at 2016 CES packed with technology
If you're looking to make a big splash at the Consumer Electronics Show, taking a page out of BMW's book and rolling out an exotic sports car wearing bright orange paint on its exterior and featuring some mind-boggling tech in the cabin wouldn't be a bad idea. The German automaker with its latest concept, officially the BMW i Future Interaction, certainly turned a lot of heads at CES during a presentation earlier today, and just looking at these shots makes it easy to see why.
As its name suggests, the concept is meant to preview new methods of interacting with a car BMW is currently cooking up for its next-generation fleet. However, it's also a preview of a new convertible version of the i8 plug-in hybrid sports car that's likely in the works. It's actually the second i8 convertible concept, hinting that a production version may be coming in the not too distant future. In fact, during the CES presentation, BMW product chief Klaus Fröhlich said he believed BMW should "build it as soon as possible."
But what about the technology? BMW says the concept provides a preview of the networked car of the future and the user interface it could feature. The main element is a gesture control system called AirTouch that was announced a week ago. AirTouch is an evolution of the gesture control system that debuted in the 2016 BMW 7-Series and enables control of entertainment, navigation and communication functions using gestures made with a flat hand. The version in the 7-Series reads finger movements only.
By making set hand movements over the center console, where special sensors can read the movements and translate these to commands, the driver can control a number of the vehicle functions. Information is relayed back through a head-up display, the main instrument cluster and a massive 21-inch panorama display located in front of the passenger.
BMW i Future Interaction concept - 2016 Consumer Electronics Show
BMW hasn't confirmed AirTouch for production but says that such systems will make more sense as vehicles start to have more autonomous capability. In fact, the BMW i Future Interaction also has a version of BMW's planned autonomous driving system. BMW hasn't provided many details on this area but says its future cars will have three modes to choose from: Pure Drive (driving yourself), Assist (assistance systems intervene actively) and Auto Mode (highly automated operation).
Also on another i8-based concept is a new feature called Mirrorless. This does away with the standard rear-view and side mirrors, replacing them instead by three cameras that project an image on the various displays. BMW says the cameras cover larger viewing angles and eliminates blind spots. Furthermore, the system evaluates the images and provides a situative response to imminent hazards, for example with yellow warning icons.
This year at CES, the BMW Motorrad motorcycle division also had a presence. The two main attractions at the BMW Motorrad stand were a laser headlight and a helmet with a head-up display.
To see what else is happening at CES, head to our dedicated hub.
High-Res Gallery: BMW i Future Interaction concept - 2016 Consumer Electronics Show
BMW i8 News BMW News Car Tech Concept Cars Consumer Electronics Show Convertibles
Toyota At CES: More Smartphones, More Telematics, More Robots
Ford's Sync 3: The good, the bad and the ugly
Talk To Your Volvo With Microsoft Band 2 Smartwatch
Faraday Future reveals 1,000-hp FFZERO1 concept and VPA platform
2022 BMW X4 spy shots: Mid-cycle refresh on the way Spy Shots January 14, 2021
Sony Vision-S electric car begins testing on public roads in Europe Concept Cars January 13, 2021
2021 Porsche 718 Boxster 25 model celebrates a quarter century of... Sports Cars January 12, 2021