text:
CMT Crossroads: Willie Nelson & Sheryl Crow: troubadours are travelers on the same winding road
Sony Pictures Studios, Culver City, Cal., May 21, 2001
CULVER CITY, CA - CMT's Crossroads made its first trek out west (at the corner of Washington and Overland, to be exact) as Sony Pictures Studios hosted a little musical interaction between Willie Nelson (country icon) and Sheryl Crow (emerging rock artist and hottie).
The program, set to debut Sunday, June 16 8 p.m., eastern/pacific on CMT, was nothing even close to a display of marked musical contrasts. This is because both of these artists are all about putting the song first, only one of them (Crow) just happens to rock out a little harder.
Nelson and Crow are the most relaxed musicians you'll ever want to see. Willie performs while standing almost statuesque, and never makes any fast moves - even though Crow's zipper-top kept incrementally sliding down before his very eyes.
Crow also sings with a languidly measured style, yet she couldn't always hide the excitement of being up on stage with one of her idols. Along the way, Nelson told a few corny jokes (which were also, by the way, the only clean jokes Crow had ever heard him tell). The two also answered audience questions during a brief intermission. Greg Martin, who came off fine with his scripted lines, hosted.
The songs they chose included a little of his, a little or hers and a few covers. Crow's high harmonizing next to Nelson's plain-spoken phrasing on The Everly Brothers' "Let It Be Me" worked wonders, but their flat take on Johnny and June Carter Cash's "Jackson" was a big mistake. June playfully growls like a lion at Johnny whenever she sings this with her "sweet talkin' man," but Crow managed only a slight purr.
For the most part, Nelson's quiet voice was overwhelmed whenever Crow revved up one of her rockers, such as "Everyday Is A Winding Road." But with his own gentler "Crazy," and "You Remain" - from his new "The Great Divide" - their voices were magical together.
There isn't anything like a great divide between what Willie Nelson and Sheryl Crow do, so this collaboration merely highlighted how these two troubadours are travelers on the same winding road.


text:
(function (window, undefined) {

    var TraceKit = {};
    var _oldTraceKit = window.TraceKit;

    // global reference to slice
    var _slice = [].slice;
    var UNKNOWN_FUNCTION = '?';

    /**
     * _has, a better form of hasOwnProperty
     * Example: _has(MainHostObject, property) === true/false
     *
     * @param {Object} host object to check property
     * @param {string} key to check
     */
    function _has(object, key) {
        return Object.prototype.hasOwnProperty.call(object, key);
    }

    function _isUndefined(what) {
        return typeof what === 'undefined';
    }

    /**
     * TraceKit.noConflict: Export TraceKit out to another variable
     * Example: var TK = TraceKit.noConflict()
     */
    TraceKit.noConflict = function noConflict() {
        window.TraceKit = _oldTraceKit;
        return TraceKit;
    };

    /**
     * TraceKit.wrap: Wrap any function in a TraceKit reporter
     * Example: func = TraceKit.wrap(func);
     *
     * @param {Function} func Function to be wrapped
     * @return {Function} The wrapped func
     */
    TraceKit.wrap = function traceKitWrapper(func) {
        function wrapped() {
            try {
                return func.apply(this, arguments);
            } catch (e) {
                TraceKit.report(e);
                throw e;
            }
        }
        return wrapped;
    };

    /**
     * TraceKit.report: cross-browser processing of unhandled exceptions
     *
     * Syntax:
     *   TraceKit.report.subscribe(function(stackInfo) { ... })
     *   TraceKit.report.unsubscribe(function(stackInfo) { ... })
     *   TraceKit.report(exception)
     *   try { ...code... } catch(ex) { TraceKit.report(ex); }
     *
     * Supports:
     *   - Firefox: full stack trace with line numbers, plus column number
     *              on top frame; column number is not guaranteed
     *   - Opera:   full stack trace with line and column numbers
     *   - Chrome:  full stack trace with line and column numbers
     *   - Safari:  line and column number for the top frame only; some frames
     *              may be missing, and column number is not guaranteed
     *   - IE:      line and column number for the top frame only; some frames
     *              may be missing, and column number is not guaranteed
     *
     * In theory, TraceKit should work on all of the following versions:
     *   - IE5.5+ (only 8.0 tested)
     *   - Firefox 0.9+ (only 3.5+ tested)
     *   - Opera 7+ (only 10.50 tested; versions 9 and earlier may require
     *     Exceptions Have Stacktrace to be enabled in opera:config)
     *   - Safari 3+ (only 4+ tested)
     *   - Chrome 1+ (only 5+ tested)
     *   - Konqueror 3.5+ (untested)
     *
     * Requires TraceKit.computeStackTrace.
     *
     * Tries to catch all unhandled exceptions and report them to the
     * subscribed handlers. Please note that TraceKit.report will rethrow the
     * exception. This is REQUIRED in order to get a useful stack trace in IE.
     * If the exception does not reach the top of the browser, you will only
     * get a stack trace from the point where TraceKit.report was called.
     *
     * Handlers receive a stackInfo object as described in the
     * TraceKit.computeStackTrace docs.
     */
    TraceKit.report = (function reportModuleWrapper() {
        var handlers = [],
            lastException = null,
            lastExceptionStack = null;

        /**
         * Add a crash handler.
         * @param {Function} handler
         */
        function subscribe(handler) {
            installGlobalHandler();
            handlers.push(handler);
        }

        /**
         * Remove a crash handler.
         * @param {Function} handler
         */
        function unsubscribe(handler) {
            for (var i = handlers.length - 1; i >= 0; --i) {
                if (handlers[i] === handler) {
                    handlers.splice(i, 1);
                }
            }
        }

        /**
         * Dispatch stack information to all handlers.
         * @param {Object.<string, *>} stack
         */
        function notifyHandlers(stack, windowError) {
            var exception = null;
            if (windowError && !TraceKit.collectWindowErrors) {
                return;
            }
            for (var i in handlers) {
                if (_has(handlers, i)) {
                    try {
                        handlers[i].apply(null, [stack].concat(_slice.call(arguments, 2)));
                    } catch (inner) {
                        exception = inner;
                    }
                }
            }

            if (exception) {
                throw exception;
            }
        }

        var _oldOnerrorHandler, _onErrorHandlerInstalled;

        /**
         * Ensures all global unhandled exceptions are recorded.
         * Supported by Gecko and IE.
         * @param {string} message Error message.
         * @param {string} url URL of script that generated the exception.
         * @param {(number|string)} lineNo The line number at which the error
         * occurred.
         */
        function traceKitWindowOnError(message, url, lineNo) {
            var stack = null;

            if (lastExceptionStack) {
                TraceKit.computeStackTrace.augmentStackTraceWithInitialElement(lastExceptionStack, url, lineNo, message);
                stack = lastExceptionStack;
                lastExceptionStack = null;
                lastException = null;
            } else {
                var location = {
                    'url': url,
                    'line': lineNo
                };
                location.func = TraceKit.computeStackTrace.guessFunctionName(location.url, location.line);
                location.context = TraceKit.computeStackTrace.gatherContext(location.url, location.line);
                stack = {
                    'mode': 'onerror',
                    'message': message,
                    'url': document.location.href,
                    'stack': [location],
                    'useragent': navigator.userAgent
                };
            }

            notifyHandlers(stack, 'from window.onerror');

            if (_oldOnerrorHandler) {
                return _oldOnerrorHandler.apply(this, arguments);
            }

            return false;
        }

        function installGlobalHandler() {
            if (_onErrorHandlerInstalled === true) {
                return;
            }
            _oldOnerrorHandler = window.onerror;
            window.onerror = traceKitWindowOnError;
            _onErrorHandlerInstalled = true;
        }

        /**
         * Reports an unhandled Error to TraceKit.
         * @param {Error} ex
         */
        function report(ex) {
            var args = _slice.call(arguments, 1);
            if (lastExceptionStack) {
                if (lastException === ex) {
                    return; // already caught by an inner catch block, ignore
                } else {
                    var s = lastExceptionStack;
                    lastExceptionStack = null;
                    lastException = null;
                    notifyHandlers.apply(null, [s, null].concat(args));
                }
            }

            var stack = TraceKit.computeStackTrace(ex);
            lastExceptionStack = stack;
            lastException = ex;

            // If the stack trace is incomplete, wait for 2 seconds for
            // slow slow IE to see if onerror occurs or not before reporting
            // this exception; otherwise, we will end up with an incomplete
            // stack trace
            window.setTimeout(function () {
                if (lastException === ex) {
                    lastExceptionStack = null;
                    lastException = null;
                    notifyHandlers.apply(null, [stack, null].concat(args));
                }
            }, (stack.incomplete ? 2000 : 0));

            throw ex; // re-throw to propagate to the top level (and cause window.onerror)
        }

        report.subscribe = subscribe;
        report.unsubscribe = unsubscribe;
        return report;
    }());

    /**
     * TraceKit.computeStackTrace: cross-browser stack traces in JavaScript
     *
     * Syntax:
     *   s = TraceKit.computeStackTrace.ofCaller([depth])
     *   s = TraceKit.computeStackTrace(exception) // consider using TraceKit.report instead (see below)
     * Returns:
     *   s.name              - exception name
     *   s.message           - exception message
     *   s.stack[i].url      - JavaScript or HTML file URL
     *   s.stack[i].func     - function name, or empty for anonymous functions (if guessing did not work)
     *   s.stack[i].args     - arguments passed to the function, if known
     *   s.stack[i].line     - line number, if known
     *   s.stack[i].column   - column number, if known
     *   s.stack[i].context  - an array of source code lines; the middle element corresponds to the correct line#
     *   s.mode              - 'stack', 'stacktrace', 'multiline', 'callers', 'onerror', or 'failed' -- method used to collect the stack trace
     *
     * Supports:
     *   - Firefox:  full stack trace with line numbers and unreliable column
     *               number on top frame
     *   - Opera 10: full stack trace with line and column numbers
     *   - Opera 9-: full stack trace with line numbers
     *   - Chrome:   full stack trace with line and column numbers
     *   - Safari:   line and column number for the topmost stacktrace element
     *               only
     *   - IE:       no line numbers whatsoever
     *
     * Tries to guess names of anonymous functions by looking for assignments
     * in the source code. In IE and Safari, we have to guess source file names
     * by searching for function bodies inside all page scripts. This will not
     * work for scripts that are loaded cross-domain.
     * Here be dragons: some function names may be guessed incorrectly, and
     * duplicate functions may be mismatched.
     *
     * TraceKit.computeStackTrace should only be used for tracing purposes.
     * Logging of unhandled exceptions should be done with TraceKit.report,
     * which builds on top of TraceKit.computeStackTrace and provides better
     * IE support by utilizing the window.onerror event to retrieve information
     * about the top of the stack.
     *
     * Note: In IE and Safari, no stack trace is recorded on the Error object,
     * so computeStackTrace instead walks its *own* chain of callers.
     * This means that:
     *  * in Safari, some methods may be missing from the stack trace;
     *  * in IE, the topmost function in the stack trace will always be the
     *    caller of computeStackTrace.
     *
     * This is okay for tracing (because you are likely to be calling
     * computeStackTrace from the function you want to be the topmost element
     * of the stack trace anyway), but not okay for logging unhandled
     * exceptions (because your catch block will likely be far away from the
     * inner function that actually caused the exception).
     *
     * Tracing example:
     *     function trace(message) {
     *         var stackInfo = TraceKit.computeStackTrace.ofCaller();
     *         var data = message + "\n";
     *         for(var i in stackInfo.stack) {
     *             var item = stackInfo.stack[i];
     *             data += (item.func || '[anonymous]') + "() in " + item.url + ":" + (item.line || '0') + "\n";
     *         }
     *         if (window.console)
     *             console.info(data);
     *         else
     *             alert(data);
     *     }
     */
    TraceKit.computeStackTrace = (function computeStackTraceWrapper() {
        var debug = false,
            sourceCache = {};

        /**
         * Attempts to retrieve source code via XMLHttpRequest, which is used
         * to look up anonymous function names.
         * @param {string} url URL of source code.
         * @return {string} Source contents.
         */
        function loadSource(url) {
            if (!TraceKit.remoteFetching) { //Only attempt request if remoteFetching is on.
                return '';
            }
            try {
                var getXHR = function () {
                    try {
                        return new window.XMLHttpRequest();
                    } catch (e) {
                        // explicitly bubble up the exception if not found
                        return new window.ActiveXObject('Microsoft.XMLHTTP');
                    }
                };

                var request = getXHR();
                request.open('GET', url, false);
                request.send('');
                return request.responseText;
            } catch (e) {
                return '';
            }
        }

        /**
         * Retrieves source code from the source code cache.
         * @param {string} url URL of source code.
         * @return {Array.<string>} Source contents.
         */
        function getSource(url) {
            if (!_has(sourceCache, url)) {
                // URL needs to be able to fetched within the acceptable domain.  Otherwise,
                // cross-domain errors will be triggered.
                var source = '';
                if (url.indexOf(document.domain) !== -1) {
                    source = loadSource(url);
                }
                sourceCache[url] = source ? source.split('\n') : [];
            }

            return sourceCache[url];
        }

        /**
         * Tries to use an externally loaded copy of source code to determine
         * the name of a function by looking at the name of the variable it was
         * assigned to, if any.
         * @param {string} url URL of source code.
         * @param {(string|number)} lineNo Line number in source code.
         * @return {string} The function name, if discoverable.
         */
        function guessFunctionName(url, lineNo) {
            var reFunctionArgNames = /function ([^(]*)\(([^)]*)\)/,
                reGuessFunction = /['"]?([0-9A-Za-z$_]+)['"]?\s*[:=]\s*(function|eval|new Function)/,
                line = '',
                maxLines = 10,
                source = getSource(url),
                m;

            if (!source.length) {
                return UNKNOWN_FUNCTION;
            }

            // Walk backwards from the first line in the function until we find the line which
            // matches the pattern above, which is the function definition
            for (var i = 0; i < maxLines; ++i) {
                line = source[lineNo - i] + line;

                if (!_isUndefined(line)) {
                    if ((m = reGuessFunction.exec(line))) {
                        return m[1];
                    } else if ((m = reFunctionArgNames.exec(line))) {
                        return m[1];
                    }
                }
            }

            return UNKNOWN_FUNCTION;
        }

        /**
         * Retrieves the surrounding lines from where an exception occurred.
         * @param {string} url URL of source code.
         * @param {(string|number)} line Line number in source code to centre
         * around for context.
         * @return {?Array.<string>} Lines of source code.
         */
        function gatherContext(url, line) {
            var source = getSource(url);

            if (!source.length) {
                return null;
            }

            var context = [],
                // linesBefore & linesAfter are inclusive with the offending line.
                // if linesOfContext is even, there will be one extra line
                //   *before* the offending line.
                linesBefore = Math.floor(TraceKit.linesOfContext / 2),
                // Add one extra line if linesOfContext is odd
                linesAfter = linesBefore + (TraceKit.linesOfContext % 2),
                start = Math.max(0, line - linesBefore - 1),
                end = Math.min(source.length, line + linesAfter - 1);

            line -= 1; // convert to 0-based index

            for (var i = start; i < end; ++i) {
                if (!_isUndefined(source[i])) {
                    context.push(source[i]);
                }
            }

            return context.length > 0 ? context : null;
        }

        /**
         * Escapes special characters, except for whitespace, in a string to be
         * used inside a regular expression as a string literal.
         * @param {string} text The string.
         * @return {string} The escaped string literal.
         */
        function escapeRegExp(text) {
            return text.replace(/[\-\[\]{}()*+?.,\\\^$|#]/g, '\\$&');
        }

        /**
         * Escapes special characters in a string to be used inside a regular
         * expression as a string literal. Also ensures that HTML entities will
         * be matched the same as their literal friends.
         * @param {string} body The string.
         * @return {string} The escaped string.
         */
        function escapeCodeAsRegExpForMatchingInsideHTML(body) {
            return escapeRegExp(body).replace('<', '(?:<|<)').replace('>', '(?:>|>)').replace('&', '(?:&|&)').replace('"', '(?:"|")').replace(/\s+/g, '\\s+');
        }

        /**
         * Determines where a code fragment occurs in the source code.
         * @param {RegExp} re The function definition.
         * @param {Array.<string>} urls A list of URLs to search.
         * @return {?Object.<string, (string|number)>} An object containing
         * the url, line, and column number of the defined function.
         */
        function findSourceInUrls(re, urls) {
            var source, m;
            for (var i = 0, j = urls.length; i < j; ++i) {
                // console.log('searching', urls[i]);
                if ((source = getSource(urls[i])).length) {
                    source = source.join('\n');
                    if ((m = re.exec(source))) {
                        // console.log('Found function in ' + urls[i]);

                        return {
                            'url': urls[i],
                            'line': source.substring(0, m.index).split('\n').length,
                            'column': m.index - source.lastIndexOf('\n', m.index) - 1
                        };
                    }
                }
            }

            // console.log('no match');

            return null;
        }

        /**
         * Determines at which column a code fragment occurs on a line of the
         * source code.
         * @param {string} fragment The code fragment.
         * @param {string} url The URL to search.
         * @param {(string|number)} line The line number to examine.
         * @return {?number} The column number.
         */
        function findSourceInLine(fragment, url, line) {
            var source = getSource(url),
                re = new RegExp('\\b' + escapeRegExp(fragment) + '\\b'),
                m;

            line -= 1;

            if (source && source.length > line && (m = re.exec(source[line]))) {
                return m.index;
            }

            return null;
        }

        /**
         * Determines where a function was defined within the source code.
         * @param {(Function|string)} func A function reference or serialized
         * function definition.
         * @return {?Object.<string, (string|number)>} An object containing
         * the url, line, and column number of the defined function.
         */
        function findSourceByFunctionBody(func) {
            var urls = [window.location.href],
                scripts = document.getElementsByTagName('script'),
                body,
                code = '' + func,
                codeRE = /^function(?:\s+([\w$]+))?\s*\(([\w\s,]*)\)\s*\{\s*(\S[\s\S]*\S)\s*\}\s*$/,
                eventRE = /^function on([\w$]+)\s*\(event\)\s*\{\s*(\S[\s\S]*\S)\s*\}\s*$/,
                re,
                parts,
                result;

            for (var i = 0; i < scripts.length; ++i) {
                var script = scripts[i];
                if (script.src) {
                    urls.push(script.src);
                }
            }

            if (!(parts = codeRE.exec(code))) {
                re = new RegExp(escapeRegExp(code).replace(/\s+/g, '\\s+'));
            }

                // not sure if this is really necessary, but I don't have a test
                // corpus large enough to confirm that and it was in the original.
            else {
                var name = parts[1] ? '\\s+' + parts[1] : '',
                    args = parts[2].split(',').join('\\s*,\\s*');

                body = escapeRegExp(parts[3]).replace(/;$/, ';?'); // semicolon is inserted if the function ends with a comment.replace(/\s+/g, '\\s+');
                re = new RegExp('function' + name + '\\s*\\(\\s*' + args + '\\s*\\)\\s*{\\s*' + body + '\\s*}');
            }

            // look for a normal function definition
            if ((result = findSourceInUrls(re, urls))) {
                return result;
            }

            // look for an old-school event handler function
            if ((parts = eventRE.exec(code))) {
                var event = parts[1];
                body = escapeCodeAsRegExpForMatchingInsideHTML(parts[2]);

                // look for a function defined in HTML as an onXXX handler
                re = new RegExp('on' + event + '=[\\\'"]\\s*' + body + '\\s*[\\\'"]', 'i');

                if ((result = findSourceInUrls(re, urls[0]))) {
                    return result;
                }

                // look for ???
                re = new RegExp(body);

                if ((result = findSourceInUrls(re, urls))) {
                    return result;
                }
            }

            return null;
        }

        // Contents of Exception in various browsers.
        //
        // SAFARI:
        // ex.message = Can't find variable: qq
        // ex.line = 59
        // ex.sourceId = 580238192
        // ex.sourceURL = http://...
        // ex.expressionBeginOffset = 96
        // ex.expressionCaretOffset = 98
        // ex.expressionEndOffset = 98
        // ex.name = ReferenceError
        //
        // FIREFOX:
        // ex.message = qq is not defined
        // ex.fileName = http://...
        // ex.lineNumber = 59
        // ex.stack = ...stack trace... (see the example below)
        // ex.name = ReferenceError
        //
        // CHROME:
        // ex.message = qq is not defined
        // ex.name = ReferenceError
        // ex.type = not_defined
        // ex.arguments = ['aa']
        // ex.stack = ...stack trace...
        //
        // INTERNET EXPLORER:
        // ex.message = ...
        // ex.name = ReferenceError
        //
        // OPERA:
        // ex.message = ...message... (see the example below)
        // ex.name = ReferenceError
        // ex.opera#sourceloc = 11  (pretty much useless, duplicates the info in ex.message)
        // ex.stacktrace = n/a; see 'opera:config#UserPrefs|Exceptions Have Stacktrace'

        /**
         * Computes stack trace information from the stack property.
         * Chrome and Gecko use this property.
         * @param {Error} ex
         * @return {?Object.<string, *>} Stack trace information.
         */
        function computeStackTraceFromStackProp(ex) {
            if (!ex.stack) {
                return null;
            }

            var chrome = /^\s*at (?:((?:\[object object\])?\S+(?: \[as \S+\])?) )?\(?((?:file|http|https):.*?):(\d+)(?::(\d+))?\)?\s*$/i,
                gecko = /^\s*(\S*)(?:\((.*?)\))?@((?:file|http|https).*?):(\d+)(?::(\d+))?\s*$/i,
                lines = ex.stack.split('\n'),
                stack = [],
                parts,
                element,
                reference = /^(.*) is undefined$/.exec(ex.message);

            for (var i = 0, j = lines.length; i < j; ++i) {
                if ((parts = gecko.exec(lines[i]))) {
                    element = {
                        'url': parts[3],
                        'func': parts[1] || UNKNOWN_FUNCTION,
                        'args': parts[2] ? parts[2].split(',') : '',
                        'line': +parts[4],
                        'column': parts[5] ? +parts[5] : null
                    };
                } else if ((parts = chrome.exec(lines[i]))) {
                    element = {
                        'url': parts[2],
                        'func': parts[1] || UNKNOWN_FUNCTION,
                        'line': +parts[3],
                        'column': parts[4] ? +parts[4] : null
                    };
                } else {
                    continue;
                }

                if (!element.func && element.line) {
                    element.func = guessFunctionName(element.url, element.line);
                }

                if (element.line) {
                    element.context = gatherContext(element.url, element.line);
                }

                stack.push(element);
            }

            if (stack[0] && stack[0].line && !stack[0].column && reference) {
                stack[0].column = findSourceInLine(reference[1], stack[0].url, stack[0].line);
            }

            if (!stack.length) {
                return null;
            }

            return {
                'mode': 'stack',
                'name': ex.name,
                'message': ex.message,
                'url': document.location.href,
                'stack': stack,
                'useragent': navigator.userAgent
            };
        }

        /**
         * Computes stack trace information from the stacktrace property.
         * Opera 10 uses this property.
         * @param {Error} ex
         * @return {?Object.<string, *>} Stack trace information.
         */
        function computeStackTraceFromStacktraceProp(ex) {
            // Access and store the stacktrace property before doing ANYTHING
            // else to it because Opera is not very good at providing it
            // reliably in other circumstances.
            var stacktrace = ex.stacktrace;

            var testRE = / line (\d+), column (\d+) in (?:<anonymous function: ([^>]+)>|([^\)]+))\((.*)\) in (.*):\s*$/i,
                lines = stacktrace.split('\n'),
                stack = [],
                parts;

            for (var i = 0, j = lines.length; i < j; i += 2) {
                if ((parts = testRE.exec(lines[i]))) {
                    var element = {
                        'line': +parts[1],
                        'column': +parts[2],
                        'func': parts[3] || parts[4],
                        'args': parts[5] ? parts[5].split(',') : [],
                        'url': parts[6]
                    };

                    if (!element.func && element.line) {
                        element.func = guessFunctionName(element.url, element.line);
                    }
                    if (element.line) {
                        try {
                            element.context = gatherContext(element.url, element.line);
                        } catch (exc) { }
                    }

                    if (!element.context) {
                        element.context = [lines[i + 1]];
                    }

                    stack.push(element);
                }
            }

            if (!stack.length) {
                return null;
            }

            return {
                'mode': 'stacktrace',
                'name': ex.name,
                'message': ex.message,
                'url': document.location.href,
                'stack': stack,
                'useragent': navigator.userAgent
            };
        }

        /**
         * NOT TESTED.
         * Computes stack trace information from an error message that includes
         * the stack trace.
         * Opera 9 and earlier use this method if the option to show stack
         * traces is turned on in opera:config.
         * @param {Error} ex
         * @return {?Object.<string, *>} Stack information.
         */
        function computeStackTraceFromOperaMultiLineMessage(ex) {
            // Opera includes a stack trace into the exception message. An example is:
            //
            // Statement on line 3: Undefined variable: undefinedFunc
            // Backtrace:
            //   Line 3 of linked script file://localhost/Users/andreyvit/Projects/TraceKit/javascript-client/sample.js: In function zzz
            //         undefinedFunc(a);
            //   Line 7 of inline#1 script in file://localhost/Users/andreyvit/Projects/TraceKit/javascript-client/sample.html: In function yyy
            //           zzz(x, y, z);
            //   Line 3 of inline#1 script in file://localhost/Users/andreyvit/Projects/TraceKit/javascript-client/sample.html: In function xxx
            //           yyy(a, a, a);
            //   Line 1 of function script
            //     try { xxx('hi'); return false; } catch(ex) { TraceKit.report(ex); }
            //   ...

            var lines = ex.message.split('\n');
            if (lines.length < 4) {
                return null;
            }

            var lineRE1 = /^\s*Line (\d+) of linked script ((?:file|http|https)\S+)(?:: in function (\S+))?\s*$/i,
                lineRE2 = /^\s*Line (\d+) of inline#(\d+) script in ((?:file|http|https)\S+)(?:: in function (\S+))?\s*$/i,
                lineRE3 = /^\s*Line (\d+) of function script\s*$/i,
                stack = [],
                scripts = document.getElementsByTagName('script'),
                inlineScriptBlocks = [],
                parts,
                i,
                len,
                source;

            for (i in scripts) {
                if (_has(scripts, i) && !scripts[i].src) {
                    inlineScriptBlocks.push(scripts[i]);
                }
            }

            for (i = 2, len = lines.length; i < len; i += 2) {
                var item = null;
                if ((parts = lineRE1.exec(lines[i]))) {
                    item = {
                        'url': parts[2],
                        'func': parts[3],
                        'line': +parts[1]
                    };
                } else if ((parts = lineRE2.exec(lines[i]))) {
                    item = {
                        'url': parts[3],
                        'func': parts[4]
                    };
                    var relativeLine = (+parts[1]); // relative to the start of the <SCRIPT> block
                    var script = inlineScriptBlocks[parts[2] - 1];
                    if (script) {
                        source = getSource(item.url);
                        if (source) {
                            source = source.join('\n');
                            var pos = source.indexOf(script.innerText);
                            if (pos >= 0) {
                                item.line = relativeLine + source.substring(0, pos).split('\n').length;
                            }
                        }
                    }
                } else if ((parts = lineRE3.exec(lines[i]))) {
                    var url = window.location.href.replace(/#.*$/, ''),
                        line = parts[1];
                    var re = new RegExp(escapeCodeAsRegExpForMatchingInsideHTML(lines[i + 1]));
                    source = findSourceInUrls(re, [url]);
                    item = {
                        'url': url,
                        'line': source ? source.line : line,
                        'func': ''
                    };
                }

                if (item) {
                    if (!item.func) {
                        item.func = guessFunctionName(item.url, item.line);
                    }
                    var context = gatherContext(item.url, item.line);
                    var midline = (context ? context[Math.floor(context.length / 2)] : null);
                    if (context && midline.replace(/^\s*/, '') === lines[i + 1].replace(/^\s*/, '')) {
                        item.context = context;
                    } else {
                        // if (context) alert("Context mismatch. Correct midline:\n" + lines[i+1] + "\n\nMidline:\n" + midline + "\n\nContext:\n" + context.join("\n") + "\n\nURL:\n" + item.url);
                        item.context = [lines[i + 1]];
                    }
                    stack.push(item);
                }
            }
            if (!stack.length) {
                return null; // could not parse multiline exception message as Opera stack trace
            }

            return {
                'mode': 'multiline',
                'name': ex.name,
                'message': lines[0],
                'url': document.location.href,
                'stack': stack,
                'useragent': navigator.userAgent
            };
        }

        /**
         * Adds information about the first frame to incomplete stack traces.
         * Safari and IE require this to get complete data on the first frame.
         * @param {Object.<string, *>} stackInfo Stack trace information from
         * one of the compute* methods.
         * @param {string} url The URL of the script that caused an error.
         * @param {(number|string)} lineNo The line number of the script that
         * caused an error.
         * @param {string=} message The error generated by the browser, which
         * hopefully contains the name of the object that caused the error.
         * @return {boolean} Whether or not the stack information was
         * augmented.
         */
        function augmentStackTraceWithInitialElement(stackInfo, url, lineNo, message) {
            var initial = {
                'url': url,
                'line': lineNo
            };

            if (initial.url && initial.line) {
                stackInfo.incomplete = false;

                if (!initial.func) {
                    initial.func = guessFunctionName(initial.url, initial.line);
                }

                if (!initial.context) {
                    initial.context = gatherContext(initial.url, initial.line);
                }

                var reference = / '([^']+)' /.exec(message);
                if (reference) {
                    initial.column = findSourceInLine(reference[1], initial.url, initial.line);
                }

                if (stackInfo.stack.length > 0) {
                    if (stackInfo.stack[0].url === initial.url) {
                        if (stackInfo.stack[0].line === initial.line) {
                            return false; // already in stack trace
                        } else if (!stackInfo.stack[0].line && stackInfo.stack[0].func === initial.func) {
                            stackInfo.stack[0].line = initial.line;
                            stackInfo.stack[0].context = initial.context;
                            return false;
                        }
                    }
                }

                stackInfo.stack.unshift(initial);
                stackInfo.partial = true;
                return true;
            } else {
                stackInfo.incomplete = true;
            }

            return false;
        }

        /**
         * Computes stack trace information by walking the arguments.caller
         * chain at the time the exception occurred. This will cause earlier
         * frames to be missed but is the only way to get any stack trace in
         * Safari and IE. The top frame is restored by
         * {@link augmentStackTraceWithInitialElement}.
         * @param {Error} ex
         * @return {?Object.<string, *>} Stack trace information.
         */
        function computeStackTraceByWalkingCallerChain(ex, depth) {
            var functionName = /function\s+([_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*)?\s*\(/i,
                stack = [],
                funcs = {},
                recursion = false,
                parts,
                item,
                source;

            for (var curr = computeStackTraceByWalkingCallerChain.caller; curr && !recursion; curr = curr.caller) {
                if (curr === computeStackTrace || curr === TraceKit.report) {
                    // console.log('skipping internal function');
                    continue;
                }

                item = {
                    'url': null,
                    'func': UNKNOWN_FUNCTION,
                    'line': null,
                    'column': null
                };

                if (curr.name) {
                    item.func = curr.name;
                } else if ((parts = functionName.exec(curr.toString()))) {
                    item.func = parts[1];
                }

                if ((source = findSourceByFunctionBody(curr))) {
                    item.url = source.url;
                    item.line = source.line;

                    if (item.func === UNKNOWN_FUNCTION) {
                        item.func = guessFunctionName(item.url, item.line);
                    }

                    var reference = / '([^']+)' /.exec(ex.message || ex.description);
                    if (reference) {
                        item.column = findSourceInLine(reference[1], source.url, source.line);
                    }
                }

                if (funcs['' + curr]) {
                    recursion = true;
                } else {
                    funcs['' + curr] = true;
                }

                stack.push(item);
            }

            if (depth) {
                // console.log('depth is ' + depth);
                // console.log('stack is ' + stack.length);
                stack.splice(0, depth);
            }

            var result = {
                'mode': 'callers',
                'name': ex.name,
                'message': ex.message,
                'url': document.location.href,
                'stack': stack,
                'useragent': navigator.userAgent
            };
            augmentStackTraceWithInitialElement(result, ex.sourceURL || ex.fileName, ex.line || ex.lineNumber, ex.message || ex.description);
            return result;
        }

        /**
         * Computes a stack trace for an exception.
         * @param {Error} ex
         * @param {(string|number)=} depth
         */
        function computeStackTrace(ex, depth) {
            var stack = null;
            depth = (depth == null ? 0 : +depth);

            try {
                // This must be tried first because Opera 10 *destroys*
                // its stacktrace property if you try to access the stack
                // property first!!
                stack = computeStackTraceFromStacktraceProp(ex);
                if (stack) {
                    return stack;
                }
            } catch (e) {
                if (debug) {
                    throw e;
                }
            }

            try {
                stack = computeStackTraceFromStackProp(ex);
                if (stack) {
                    return stack;
                }
            } catch (e) {
                if (debug) {
                    throw e;
                }
            }

            try {
                stack = computeStackTraceFromOperaMultiLineMessage(ex);
                if (stack) {
                    return stack;
                }
            } catch (e) {
                if (debug) {
                    throw e;
                }
            }

            try {
                stack = computeStackTraceByWalkingCallerChain(ex, depth + 1);
                if (stack) {
                    return stack;
                }
            } catch (e) {
                if (debug) {
                    throw e;
                }
            }

            return {
                'mode': 'failed'
            };
        }

        /**
         * Logs a stacktrace starting from the previous call and working down.
         * @param {(number|string)=} depth How many frames deep to trace.
         * @return {Object.<string, *>} Stack trace information.
         */
        function computeStackTraceOfCaller(depth) {
            depth = (depth == null ? 0 : +depth) + 1; // "+ 1" because "ofCaller" should drop one frame
            try {
                throw new Error();
            } catch (ex) {
                return computeStackTrace(ex, depth + 1);
            }
        }

        computeStackTrace.augmentStackTraceWithInitialElement = augmentStackTraceWithInitialElement;
        computeStackTrace.guessFunctionName = guessFunctionName;
        computeStackTrace.gatherContext = gatherContext;
        computeStackTrace.ofCaller = computeStackTraceOfCaller;

        return computeStackTrace;
    }());

    /**
     * Extends support for global error handling for asynchronous browser
     * functions. Adopted from Closure Library's errorhandler.js
     */
    (function extendToAsynchronousCallbacks() {
        var _helper = function _helper(fnName) {
            var originalFn = window[fnName];
            window[fnName] = function traceKitAsyncExtension() {
                // Make a copy of the arguments
                var args = _slice.call(arguments);
                var originalCallback = args[0];
                if (typeof (originalCallback) === 'function') {
                    args[0] = TraceKit.wrap(originalCallback);
                }
                // IE < 9 doesn't support .call/.apply on setInterval/setTimeout, but it
                // also only supports 2 argument and doesn't care what "this" is, so we
                // can just call the original function directly.
                if (originalFn.apply) {
                    return originalFn.apply(this, args);
                } else {
                    return originalFn(args[0], args[1]);
                }
            };
        };

        _helper('setTimeout');
        _helper('setInterval');
    }());

    //Default options:
    if (!TraceKit.remoteFetching) {
        TraceKit.remoteFetching = true;
    }
    if (!TraceKit.collectWindowErrors) {
        TraceKit.collectWindowErrors = true;
    }
    if (!TraceKit.linesOfContext || TraceKit.linesOfContext < 1) {
        // 5 lines before, the offending line, 5 lines after
        TraceKit.linesOfContext = 11;
    }

    // Export to global object
    window.TraceKit = TraceKit;

}(window));
(function (window) {

    //pull in any existing definitions of the client before replacing
    var _slipspace = window.Slipspace;

    //Slipspace client definition
    var self = {
        _eventsPerPage: 100,
        _customData: {},
        _environmentData: {},
        _traceKit: window.TraceKit,

        scriptTag: getCurrentlyExecutingScript(),

        settings: {
            endpoint: "https://data.slipspace.co/v1/events",
            ignoredFields: ["password", "secret", "cc", "creditcard"],
            eventsPerPage: 10,
            level: 2,
            notifierVersion: "1.0.0",
            notifierName: "slipspace.js",
            environment: "production"
        }
    };

    self.isDebug = function () {
        return self.setting("debug", false);
    };

    //Ability to restore the existing definition for no-conflict support
    self.noConflict = function () {
        var slipspace = window.Slipspace;
        window.Slipspace = _slipspace;
        return slipspace;
    };

    //Initialise the settings for the app
    self.init = function (settings) {
        self.settings = merge(self.settings, settings); //Explicit init settings
        self._eventsPerPage = self.setting("eventsPerPage");
        return self;
    };

    //Pull in any script-tag settings as defaults
    self.settings = merge(self.settings, getDataAttributes(self.scriptTag));

    //Set the user
    self.setUser = function (uuid, email, name) {
        self.settings = merge(self.settings, {
            uuid: uuid,
            email: email,
            name: name
        });
        return self;
    };

    //Get the user from the setting information
    self.getUser = function () {
        if (self.setting("uuid")) {
            return {
                uuid: self.setting("uuid"),
                email: self.setting("email"),
                name: self.setting("name")
            };
        }
    };

    //Set the correlationId for the error
    self.setCorrelationId = function(correlationId){
        self.settings = merge(self.settings, {
            correlationId: correlationId
        });
        return self;
    }

    //Set the version of the application
    self.setVersion = function (version) {
        self.settings = merge(self.settings, { version: version });
        return self;
    };

    //Add additional custom data
    self.addCustomData = function (customData) {
        self._customData = merge(self._customData, customData);
        return self;
    };

    //Add additional environment data
    self.addEnvironmentData = function (environmentData) {
        self._environmentData = merge(self._environmentData, environmentData);
        return self;
    };

    //Get the value of a setting
    self.setting = function (key, defaultValue) {
        var value = self.settings[key];
        if (value === "false") {
            value = false; //Fix type
        }

        if(value == undefined){
            return defaultValue;
        }

        return value
    };

    //Logic to construct the payload to send to slipspace
    self.recordException = function (traceToProcess, customData) {

        self._eventsPerPage -= 1;
        if (self._eventsPerPage <= 0) return;

        var trace = Array();

        if (traceToProcess.stack && traceToProcess.stack.length) {
            for (i = 0; i < traceToProcess.stack.length; i++) {
                var frame = traceToProcess.stack[i];
                trace.push({
                    lineNumber: frame.line,
                    methodName: frame.func || "[anonymousFunc]",
                    className: "line: " + frame.line + ", col:" + frame.column,
                    fileName: frame.url,
                });
            }
        }

        var screen = window.screen || { width: getViewPort().width, height: getViewPort().height };

        var payload = {
            environment: self.setting("environment"),
            occurredOn: new Date(),
            language: "JavaScript",
            userData: self.getUser(),
            version: self.setting("version"),
            correlationId: self.setting("correlationId"),
            customData: customData,
            platform: navigator.platform,
            level: self.setting("level"),
            environmentData: merge({
                utcOffset: new Date().getTimezoneOffset() / -60.0,
                userLanguage: navigator.userLanguage,
                documentMode: document.documentMode,
                browserWidth: getViewPort().width,
                browserHeight: getViewPort().height,
                screenWidth: screen.width,
                screenHeight: screen.height,
                browser: navigator.appCodeName,
                browserName: navigator.appName,
                browserVersion: navigator.appVersion,
                cookiesEnabled: window.navigator.cookieEnabled
            }, self._environmentData),

            exceptionData: {
                className: traceToProcess.Name || traceToProcess.message || "Script",
                message: traceToProcess.Name || traceToProcess.message || "Script",
                trace: trace,
            },

            requestData: {
                url: document.location.href,
                queryString: parseQueryString(),
                host: document.domain,
                headers: {
                    userAgent: navigator.userAgent,
                    referer: document.referrer,
                    host: document.domain
                }
            },

            notifier: {
                name: self.setting("notifierName"),
                version: self.setting("notifierVersion"),
            }
        };

        if (self.isDebug())
            console.log(JSON.stringify(payload));

        self.sendToSlipspace(payload);
    };

    //Send an exception to Slipspace
    self.send = function(ex, customData){
        var traceToProcess = self._traceKit.computeStackTrace(ex);

        if (typeof customData === 'function')
            customData = customData();

        self.recordException(traceToProcess, customData);
    };

    //Send the payload up to Slipspace
    //We'll just send it up as an image request for now, super compatible
    self.sendToSlipspace = function (payload) {
        var img = new Image();
        img.src = self.setting("endpoint") + "?json=" + encodeURIComponent(JSON.stringify(payload)) + "&apikey=" + self.setting("apikey") + "&cache=" + new Date().getTime();
    };

    //Register with tracekit
    self.attach = function () {
        self._traceKit.report.subscribe(self.recordException);
    }

    self.detach = function () {
        self._traceKit.report.unsubscribe(self.recordException);
    },

    //Set the global Slipspace var and attach
    window.Slipspace = self;
    self.attach();

    //Helper functions used in creating out Slipspace client
    function getCurrentlyExecutingScript() {
        var scripts = document.getElementsByTagName("script");
        return scripts[scripts.length - 1];
    }

    function getDataAttributes(node) {
        var dataAttrs = {};
        var dataRegex = /^data\-([\w\-]+)$/;
        var attrs = node.attributes;
        for (var i = 0; i < attrs.length; i++) {
            var attr = attrs[i];
            if (dataRegex.test(attr.nodeName)) {
                var key = attr.nodeName.match(dataRegex)[1];
                dataAttrs[key] = attr.value || attr.nodeValue;
            }
        }

        return dataAttrs;
    }

    function merge(obj, objOther) {
        var objectFinal = {};

        for (prop in obj) {
            objectFinal[prop] = obj[prop];
        }

        for (prop in objOther) {
            objectFinal[prop] = objOther[prop];
        }

        return objectFinal;
    }

    function getViewPort() {
        var e = document.documentElement,
        g = document.getElementsByTagName('body')[0],
        x = window.innerWidth || e.clientWidth || g.clientWidth,
        y = window.innerHeight || e.clientHeight || g.clientHeight;
        return { width: x, height: y };
    }

    function getStacktrace(exception) {
        return exception.stack || exception.backtrace || exception.stacktrace;
    }

    function generateStacktrace() {
        return exception.stack || exception.backtrace || exception.stacktrace;
    }

    function parseQueryString(){
        var qs = {};
        var qsRaw = window.location.search.substr(1).split('&');

        if(qsRaw == "") return qs;
        for(var i=0; i< qsRaw.length; i++){
            var qsParamPair = qsRaw[i].split('=');
            if(qsParamPair.length != 2) continue;
            qs[qsParamPair[0]] = decodeURIComponent(qsParamPair[1].replace("+"," "));
        }

        return qs;
    }

})(window);

redpajama_set_name: RedPajamaGithub


AirPop is pioneering the innovation of air wearables for personal and public health.
We are passionate about building a new brand of connected experiences that merge environment, wellness and lifestyle. Inspired by better, smarter, more insightful breathing, AirPop aims to empower the more than 4B+ people living in pervasive ambient air pollution using its revolutionary smart mask system. AirPop is based in San Francisco and Shanghai.


text:
Vol. 33, Issue No. 1-2, 10 Jan, 1998
Biren Roy
Bankim Mukherjee
also cause long lasting environmental degradation in the neighbourhood. Northern Kerala is an acutely power- starved area where voltage drop as well as frequent power cuts are the order of the day. People are prepared to sacrifice anything for the sake of a steady supply of electricity. Feeling the pulse of the people, SKPL has come forward with a statement that they will generate 100 MW of power captively, out of which 80 MW will be utilised by the factory and 20 MW will be fed into the grid. In a state where unemployment has reached explosive proportions, any opportunity to mitigate it will be accepted wholeheartedly. Knowing this well, grossly exaggerated estimates of employment potential of the proposed plant are being flaunted by Vinod Thaparia, the director of the company. The public relations exercise he has undertaken is unique for its attempt to foreclose any anticipated opposition, by certain simplistic statements. For example, he has gone on record (see Chemical Weekly, February 11, 1997) saying that the petrochemical factory is a 'non-toxic' and 'zero-pollution' venture. Imagine the nerve of portraying an industry which is among the most hazardous 20 industries as such a harmless venture, "to allay the fears of the public", even before the deal has been finalised. Much more by way of statements such as these can be expected from companies of this type with huge allocation of funds for public relation and propaganda Now that an MoU has been signed and a 'green signal' has been received from the central government by way of a letter of intent, it calls for immediate public attention. One has to weigh the advantages on the economic and employment sectors against probable destruction of the environment through pollution and excessive water consumption. Pollution, of course, can be prevented to a limited extent; but only at the cost of profits, as funds will have to be diverted to state-of-the-art technologies to fight pollution. Can we reasonably expect a private company with a considerable equity participation by foreign firms to invest heavily on pollution control and monitoring, in a country where the rules are rather for the statute books than for implementation? TNCs coming to India with hazardous processes do not have a track record of conforming to stringent environmental standards in their host countries (the case of Bhopal is too vivid to forget).
Read more about Bankim Mukherjee

redpajama_set_name: RedPajamaCommonCrawl


text:
      <portlet-icon></portlet-icon>
{{ ::portlet.title }}

    {{:: portlet.description | truncate:160}}


Ohios Govenor Ted Strickland's economic stimulus package includes $50 million to encourage the development of bioproducts, such as plastic resins from corn, in a bid to link two of Ohio's most important industries. Ohio is at a crossroads when it comes to future plant-based materials and energy sources, Strickland said in a speech at the Ohio Polymer Summit, held June 3 in Columbus.
"This is truly a transformative time in Ohio's economic history. Two of our great industries, agriculture and polymers, have proven themselves in Ohio in the past, using separate tracks," Strickland said. "But these sectors are now, thankfully, coming together." The need is more urgent because of high energy costs and concerns about climate change, he said.
Agriculture and food products make up Ohio's largest industrial sector – a $93 billion annual business. Polymers generate $49 billion in annual sales. Wayne Earley, president of PolymerOhio Inc., said Ohio is a national leader for plastic materials makers, compounders and leading-edge research universities. "We can commercialize those biomaterials faster than anybody else," he said.
According to Westerville, Ohio-based PolymerOhio, 140,000 Ohioans are employed at the state's 2,800 polymer-related facilities. PolymerOhio organized the Ohio Polymer Summit, which drew 220 people. The governor's address came at a lunch attended by polymer activists and also people who attended the annual meeting of a group called the National Agricultural Biotechnology Council.
Strickland acknowledged that $50 million for bioproducts is only a small fraction of his $1.57 billion plan to help Ohio's struggling economy. But he called it a "major step forward" in recognizing the importance of that emerging industry. In his speech, Strickland also outlined several recommendations of the Ohio Agriculture to Chemicals, Polymers and Advanced Materials Task Force. The full report will be released in mid-June.
One of the proposals is to set up an Agbioproducts Technology Center to link efforts of the Ohio Department of Development and Ohio Department of Agriculture. A likely home would be at the Ohio Bioproducts Innovation Center, based at Ohio State University. Another recommendation is to set up a refinery so companies could produce large samples of new materials for pilot and pre-production runs of new biomaterials.
"We believe Ohio leads the nation, and perhaps the world, in terms of the research and development, expertise and creativity that exists in the polymer industry," Strickland said.


text:
Jarred's 2019 "Film-Bum" Oscar Predictions
By Jarred Gregory-Grimeson February 23, 2019
This year's Oscars are sure to be one of the most interesting in recent memory. The Academy forgoing without a host, a number of films nominated in some categories that many find to be both offensive and wrong, and seemingly nobody content with any nomination and all the non-nominations. So, it actually will be like any year at the Oscars.
From this lame duck of a cinephile and film lover, I have my own biases and judgments on what should and shouldn't have been nominated, and when it will come to the night itself, thoughts on what should have won and shouldn't have won, but don't worry, you won't have to wait until February 24th to get a pulse on my thoughts and reactions.
These choices below are a mix of predictions, personal choices and favorites, and just wild guesses. When it comes to the bottom line, all of these films are works of art, meant to exhibit ideas and provoke feelings and emotions. There is no complete consensus or right answer. All this boils down to is personal preference and subjectivity (save Spider-Man…). So without further ado, here is my Film-Bum Oscar predictions and guesses…
MAKEUP AND HAIRSTYLING
A charging and ravish story that is as many parts magical realism as it is a political/contemporary critique. Aside from an intense and unexpected story that unravels in ways you never expect, keeping your breath within its cinematic grasp until the very last frame. Border is by no means perfect or even exquisite filmmaking, but where it lacks in sense and barrages in audacity, it excels in its makeup and design. You should probably just see this one just to get what I am talking about…
The third area where a film is 'written', editing is so crucial in not only telling a compelling or beautiful story but a story that makes sense to the eyes and mind. Not many other films manage to be a cinematic grappling hook to the brain like The Favourite manages to be. Lavish and holding the elements of the film in his very talented holds Lanthimos handles stories with such a brisk dominance. The fact his past three films have been so exceptional, it is a head scratcher he is not brought up more as one of the worlds best-working directors more.
Not everyone's favorite movies, let alone Spielberg films, Ready Player One is a bit of a conundrum. It is very much clickbait and of its time, but having known that and having known Spielberg's career and past films this could be looked at as one of his most brilliant and relevant works. I could fall down the rabbit hole of his this film is as much of a money grabber as it is a self-reflection on an artist's own career, but we're here to talk about the visual effects, and some of the most beautiful and incredible cinematic moments happen within Ready Player One.
Beale Street's soundtrack is hands down one of the best pieces of art to come out of 2018. Alone, Nicholas Britell's soundtrack is an elegant and empathetic work. It transcends the limits of music and creates emotions and feelings in its listener. Pairing that with the beauty and grace that Barry Jenkins shoots love and you have near perfection.
LIVE ACTION SHORT FILM
"Detainment"
One of the most well crafted all around shorts from the lot, Detainment is the gripping true story of… well, maybe just dig it up and find out yourself. You won't be disappointed.
ANIMATED SHORT FILM
This year's selection of animated shorts is challenging to sift through. There are a number of shorts here that actually pair really well and work around similar issues and themes in their own unique ways. Maybe it's the simplicity and crispness that the film is made with, or maybe it is my bay Area bias, but One Small Step just eeks out past Bao for me for Best Animated Short this year.
I am quite disappointed in myself for not going out to see First Man more than once on as big of a screen (and speakers) as I could. Its opening sequence is shocking and exhilarating. If you were looking for as different of a first ten minutes in a film, pair the opening of La La Land and First Man and let's talk about a skilled and diverse filmmaker who is not afraid to change things up and have it work any way he pleases.
If The Favourite didn't win costumes this year, it would be like if Phantom Thread didn't win best costumes last year. It just doesn't happen.
One of my first gutsy personal picks, I am going with something I feel deserves the win, and hopes will win over what I think actually will win this year. Cold War's framing and entire run time is a slow-burning pleasure to the senses, from its gorgeous depiction of Europe during the Cold War, to its intimate, yet distanced closeness to its two star-crossed-lovers, Cold War is one of the coldest love stories to come out in recent memory and it rocks.
Again, The Favourite excels in nearly every category its nominated it, it will be a real head scratcher if it doesn't walk away from most of these categories with a little gold man.
Spike Lee, "BlacKkKlansman"
Pawel Pawlikowski, "Cold War"
Yorgos Lanthimos, "The Favourite"
Adam McKay, "Vice"
This is a really tough category, and although I think a pair of directors above could easily win, Cuaron's overall masterpiece is beyond me. It's so intensely personal, yet so refined. he has his fingers all over this film and it really shows. By far one of his best works since Children of Men.
ACTRESS IN A LEADING ROLE
Lady Gaga, "A Star Is Born"
Glenn Close, "The Wife"
Olivia Colman, "The Favourite"
Melissa McCarthy, "Can You Ever Forgive Me?"
Another pick I am making from the gut rather than the brain, although I will say, I think this category is much closer than some think. I think Gaga's performance here is masterful and unparalleled. She deserves the Oscar as much as some of the other women here, but I am going with my gut and my gut is Gaga.
ACTOR IN A LEADING ROLE
Bradley Cooper, "A Star Is Born"
Willem Dafoe, "At Eternity's Gate"
Viggo Mortensen, "Green Book"
See the Golden Globes the past few years and this pick feels like a no brainer.
ACTRESS IN A SUPPORTING ROLE
Regina King, "If Beale Street Could Talk"
Marina de Tavira, "Roma"
Emma Stone, "The Favourite"
Rachel Weisz, "The Favourite"
There are a few actors in Beale Street I am very upset didn't get noms. In fact, I am quite upset Beale Street didn't get more noms, but c'est la vie. Regina King gives an unforgettable performance as she dominates the screen anytime she is there. She portrays Black motherhood with such beauty and grace. It's something to be seen.
ACTOR IN A SUPPORTING ROLE
Mahershala Ali, "Green Book"
Adam Driver, "BlackKKlansman"
Sam Elliott, "A Star Is Born"
Richard E. Grant, "Can You Ever Forgive Me"
Sam Rockwell, "Vice"
I am not a fan of Green Book, and really its only saving grace is Mahershala's performance and, well, that's about it. It is just that good, and he will get an Oscar for it.
A category I don't agree with all that much, but out of the bunch First Reformed is one of the most compelling and outright gritty stories this year.
If Beale Street doesn't win, there will be riots. Full on riots, I tell you.
ANIMATED FEATURE FILM
The easiest pick this year, probably.
"Shallow" – "A Star Is Born
"All The Stars" – "Black Panther"
"I'll Fight" – "RBG"
"The Place Where Lost Things Go" – "Mary Poppins Returns"
"When A Cowboy Trades His Spurs For Wings" – "The Ballad of Buster Scruggs"
A tough category, but Gaga takes it again here.
DOCUMENTARY (SHORT)
"Period. End of Sentence."
"A Night at the Garden"
The most uplifting and brightest of the docs this year, it is a really tough category and I feel each doc excels in its own right. There is hard spaces to compare these masterful docs, but Period. End of Sentence seems to me to just be one of the best. It's tough, but just barely.
"Hale County This Morning, This Evening"
Minding the Gap is one of the most important works about/on/of masculinity in the modern age, and I don't see how it doesn't win here.
I am going with the film I am pretty sure won't win, but I will pick it here, and in every Oscar ballot I submit because it is pure treason and treachery to not pick this film for me. One of the best movies I have seen this decade.
I think this award can go three or four different ways. I think that overall Roma is the best film. It packs the most punch emotionally and resonated with audiences throughout. This may be the toughest category to pick, but I feel (and hope) that Roma is the film to eek the award of the night.
Jarred Gregory-Grimes
Film student and casual Earth wanderer. I find beauty in the things NOT said. Twitter: JarredGregoryG1 Instagram: jrod_writes letterboxd: jrodxc19 Email: jrodgrimes@gmail.com
Aaron Linskey
Joshua Sorensen
Katie Duggan
SpotlightsTelevision
Toni Stanger
Previous 'Black Panther' and 'Spider-verse' are Brilliant Beyond Their Blackness
Next 'Gaea Girls' Review


On a nippy Sunday afternoon, as a delicious roast dinner from The Hastings Arms sat snugly under our belts, it was with delight we spotted a Facebook post about this matinee gig.
It came from local friend to the music scene, Andy Gunton – and reminded us why we set up this site…Hastings has so much going on, but it's easy to miss it!
When we got to the Jenny Lind it was just Toby, his steel guitar and a small amp – that was all that was needed. The full King Size Slim band is always a treat, but it's the mark of a great songsmith that they can stand on their own two feet and perform just as powerfully solo.
The front bar of the Jenny Lind is just about perfect for these intimate shows. And the rear bar gives people who want to chat somewhere to do it without disturbing the enjoyment of lovers of great music.
Toby plays heavyweight rootsy blues with a unique style that borders on manic but draws in the listener to his warped world.
He's Hastings through and through – don't miss him if you get a chance…and why not buy his music too?


Col's charter service provides the opportunity to experience unique private charters or memorable touring experiences in and around South East Queensland. Our services are professional, courteous and cost effective and can be designed to meet your needs.
A people mover with room to move. The Hyundai has massive amounts of flexibility with its seating configuration and yet doesn't sacrifice any of its rear cargo room. Rear air conditioning vents help keep everyone in comfort all year round. Economical 4 cylinder petrol motor with automatic transmission makes for easy driving.
With the efficiency of the 3.0 litre Turbo diesel engine and 5 speed transmission these vehicles have all the luxuries you expect from Toyota. Air conditioning throughout the bus allows you to sit back and enjoy the ride.
This deluxe model bus has cloth high back seats, Lap/Sash belts and is best suited to schools, community groups, clubs and sporting organisations. The 3.9 litre turbo diesel engine with 6 speed manual transmission provides the perfect ride.


An improved synchronizer for recovering the clock signal in split phase encoded data. The synchronizer includes a phase locked loop (PLL) which locks in phase with the encoded data at twice the data clock frequency. The output from the PLL is divided by two in a flip flop which is triggerable to produce an output at either 0° or 180° relative phase. The encoded data is detected in synchronism with the output of the flip flop and the resultant is integrated over each cycle of the flip flop signal. Comparator circuitry produces an error signal if the integrated value is within predetermined limits. A counter receives the error signals and, in response to a significant number thereof, activates the flip flop to produce its alternate phase output. In this manner, the flip flop output recovers the clock signal in proper phase.
The synchronizer may be used in combination with additionally disclosed circuitry for use as a full demodulator.
The present invention pertains to the signal communication art and, in particular, to a means for synchronizing with, and demodulating split phase encoded data.
Split phase data encoding schemes are well known in the communication art. Raw digital data, i.e. a data bit stream containing a sequence of logic "ones" and "zeros", often contains low frequency signal components since the data is not constrained to be concentric about its central axis, i.e. the total number of ones does not have to equal the total number of zeros. Thus, transmission and reception apparatus, in order to handle raw data, requires the use of complicated and expensive circuitry having a bandwidth suitable for maintaining low frequency components. Moreover, raw digital data may contain long strings of "ones" or "zeros". A data clock regenerated from the bit stream may drift significantly during this period.
The split phase, or Manchester code was developed to avoid these problems. In such encoding systems, logic levels are represented by transitions in the encoded data. That is, a logic level "1" might be represented by a positive data transition, whereas the logic level "0" would be represented by a negative transition. In operation, the split phase encoded data bit stream is very symmetric about its axis whereby there are few, if any, low frequency components to be carried by the transmission system. The split phase code also insures that there is a signal transition in each bit time period regardless of the particular bit pattern being transmitted.
A problem with split phase encoding schemes is that proper decoding requires the resolution of a phase ambiguity. The encoding process operates by sensing the status of the informaion bit stream at a given clock frequency interval and generating the corresponding positive and negative encoded data stream transition. At the decoder, while it is a simple matter to recover the clock frequency, it is difficult to determine whether the recovered signal is synchronous to the transmitted clock frequency, or a 180° phase angle with respect thereto. Phase sense is critical since a necesssary condition for proper decoding is that the recovered clock signal be synchronized to the clock signal used in encoding. Thus, there has been a need for effective synchronizing circuitry to resolve the decoder phase ambiguity of split phase encoded data.
Of the several approaches for resolving the phase ambiguity in the decoder of split phase encoded data known in the art, all of them require elaborate and costly implementation, resulting in a prohibitive cost. Moreover, due to the large number of components required to implement the known synchronizer circuits, system reliability and accuracy has been a problem.
It is an object of this invention, therefore, to provide an improved synchronizer for use in resolving the phase ambiguity of split phase encoded data.
It is a particular object of the invention to provide the above described synchronizer which may be implemented in an inexpensive, reliable form.
Briefly, according to the invention, the synchronizer receives encoded data of the split phase, clock synchronous encoded type and recovers the clock signal, in proper phase, therefrom. The synchronizer comprises a reference signal generator which is selectable to produce either a first or a second reference signal. Each reference signal has the same frequency as the clock frequency with the two signals maintaining a relative phase angle of 180° with respect to each other. A synchronous detector is employed to synchronously detect the received encoded data and the particular selected reference signal. An integrator produces an integral signal which has a value representative of the integral of the output of the synchronous detector over each cycle of the selected reference signal. A comparator produces an output error signal in response to the integral signal having a value within predetermined minimum and maximum values. A control logic circuit processes the error signal and selects the alternate output from the reference signal means in response to the error signals being in a predetermined condition. Thus, the selected reference signal is synchronized to the encoding clock signal.
The synchronizer may be used as part of a full demodulator for split phase encoded data wherein the combination also includes a sample pulse generator which produces sample pulses at predetermined points in each cycle of the selected reference signal and a decoded data output circuit which produces the fully demodulated information data by generating an output signal having either a first or second logic level responsive to the status of the integral signal occurring synchronous to the generation of each sample pulse.
FIG. 2 is a sequence of signal waveforms illustrating operation of the circuit of FIG. 1.
FIG. 1 illustrates, in schematic diagrammatic form, a split phase encoded synchronizer, indicated generally at 10, in combination with demodulation circuitry 12. Operation of the circuit in FIG. 1 is more easily understood with reference to FIG. 2 which is a sequence of waveforms labeled A-P illustrating representative signal waveforms at indicated portions of the FIG. 1 circuit. The synchronizer 10 accepts at its input 14 the split phase, or Manchester encoded data, which, in the present example, is assumed to have originated at the transmission location (not shown). The split phase encoding process is understood with reference to FIGS. 2A and 2B. FIG. 2A illustrates representative raw data which is of the logic sequence 0-1-0-1-0-1-1-1-0-0-1. FIG. 2B is the translated split phase encoded form of FIG. 2A in which each raw data bit time period is split into two halves which, taken together, define a bit of split phase information. In FIG. 2B a raw data "one" is represented by a "one" in the first half of the corresponding bit time period and by a "zero" in the other half of the same bit time period. Conversely, a raw data "zero" is represented by a "one" and "zero" whose order is reversed from that used to represent a raw data "one". The encoding of the split phase waveform in FIG. 2B occurs at an established clock rate.
Referring again to FIG. 1, the encoded data at the synchronizer input 14 is processed by a limiting amplifier 16 and routed to the inputs 20, 22 of a pair of differentiaters 24, 26, respectively. The first differentiator 24 produces an output pulse corresponding to each positive transition of signals at its input 20. The second differentiator produces output pulses corresponding to the occurrence of a negative transition at its input 22. The transistion pulses from the differentiators 24, 26 are applied to two inputs of an OR gate 30 which, acting in the known manner, produces an output signal which is a sequence of pulses occurring at each transistion of the input coded data. Since the encoded data is synchronous to the fixed frequency clock, the input pulse are, therefore, clock sync pulses, as illustrated in FIG. 2C.
The clock sync pulses are fed to an active bandpass filter 32. The bandpass filter 32 is tuned to twice the known clock frequency of the encoder and, thus, passes those frequency components of the clock sync pulses at or near the second harmonic of the clock frequency.
The output from the bandpass filter 32 is processed by a limiting amplifier 36 and applied to a phase locked loop circuit, illustrated as a block 40. The phase locked loop is of conventional design having a narrow bandwidth at the second harmonic of the clock frequency to provide significant noise immunity. The output 42 of the phase locked loop 40 is a signal in phase quadrature lock, and at the same frequency as the signal at the phase locked loop input, i.e. the second harmonic of the encoding clock frequency. FIG. D illustrates the output from the phase locked loop 40.
The output 42 from the phase locked loop 40 is applied to the input 52 of a divide by two bistable or flip flop circuit 50. The flip flop 50 has a Q output 54 and a Q output 56. The outputs 54, 56 contain signals which are one-half of twice the clock frequency, and thus are at the clock frequency, whereas the relative phase relationship between the two outputs 54, 56 is 180°. The bistable 50 is also provided with a reset input 58 which, when activated, effectively switches the output phase of the two flip flop outputs 54, 56. Thus, the reset input 58 allows a means to change the phase of the output or reference signal from the bistable 50. FIGS. 2E and 2K illustrate examples of the two reference signals which are seen to be at the clock frequency and 180° out of phase with each other.
The Q output 54 of the divide by two flip flop 50 is connected to the control input 62 of a synchronous detector 60. The synchronous detector has a second input 64 to which is applied the output from the limiter 16. The synchronous detector 60, which may be implemented using a standard exclusive OR gate, produces an output 0 level in response to the signals at its input 62, 64 synchronously assuming the same logic state, whereas otherwise the synchronous detector 60 produces an output logic 1 level. Thus, depending upon whether the particular reference signal 2E or 2K has been selected, the synchronous detector 60 produces the output shown as either waveform 2F or 2L.
The output from the synchronous detector 60 is applied to an integrate and dump circuit 70. The integrate and dump circuit 70 is comprised of a standard analog type integrator which, upon receiving a dump signal at the dump input 72 is resettable to a reference level, such as 0 volts. In this particular application the dump input 72 is provided by coupling the Q output 56 of the bistable 50 through a positive differentiator 80. In so doing, the integrate and dump circuit 70 produces an integral signal whose magnitude assumes a value which is representative of the integral of the synchronous detector output over the interval of one cycle of the selected reference signal. Thus, depending upon whether the reference signal of waveform 2E or 2K is chosen the output from the integrate and dump circuit 70 will be either that shown in FIG. 2G or 2M.
The output from the integrate and dump circuit 70 is applied to the first inputs 92, 102 of a pair of comparators 90, 100, respectively. The comparators have second inputs 99, 104 and output terminals 96, 106. Applied to the second input 99 of comparator 90 is a predetermined fixed DC reference, reference Y. Applied to the second input 104 of the second comparator 100 is a second predetermined reference source, reference Z. References Y, Z define upper and lower predetermined limits for the integrated waveform, as is illustrated in FIGS. 2G and 2M. The first comparator 90 produces an output pulse at its output 96 in response to the integral signal exceeding the upper limit, whereas the second comparator 100 produces an output pulse at its output terminal 106 in response to the integral signal exceeding the minimum level reference Z.
The outputs 96, 106 from the comparators 90, 100 feed to a control logic circuit 110. The control logic circuit 110 has a trigger input terminal 112 which, when activated via an input pulse, causes the control logic to determine whether or not the output from the comparators 90, 100 sense that the integral signal is within or exceeding the predetermined upper and lower limits. If, at the time of a trigger pulse at input 112, the integral signal is between its upper and lower levels, defined by reference levels Y and Z, a pulse is generated at the control logic first output 114. If, however, it is sensed that the integral signal, at the time of a trigger pulse at input 112, exceeds the predetermined minimum and maximum values defined by reference levels Y and Z, a pulse is produced at a second control logic output 116.
A series of sample pulses, shown in FIGS. 2H or 2N, depending on the particular reference signal that has been selected, are applied to the trigger input 112 of the control logic 110. The generation of the sample pulses is more fully discussed herein below, however, it is sufficient to say that a sample pulse is generated corresponding to the occurrence of a particular point in each cycle of the selected reference signal, namely, just prior to the conclusion of each selected reference signal cycle.
While a detailed schematic diagram of the control logic 110 is not provided, it would be apparent to anyone of ordinary skill in the art, given the above described inputs and desired outputs, as to numerous operative configurations.
The first output 114 from the control logic circuit 110 is applied to the clock input 122 of a conventional counter 120. The counter 120 has a reset input 124, to which is applied the second output 116 from the control logic 110. As it will be more clearly shown herein below, a pulse on control logic 114 corresponds to the wrong reference phase being chosen, whereas a pulse on the second control logic output 116 corresponds to the condition of the proper reference signal phase being chosen. Thus, the counter 120 sequentially counts out the number of error signals received at its clock input 122, and resets to 0 in response to the occurrence of a signal at its reset input 124. In the preferred embodiment of the invention, the counter 120 produces a pulse on its output line 126 in response to having counted eight successive signals appearing at its clock input 122. Thus, for each of eight or more successive error signals produced at the control logic output 114 the counter 120 produces a pulse on its output line 126, as illustrated in FIG. 2P. In the absence of produced error pulses, the output line 126 waveform is as shown in FIG. 2J.
The output line 126 of counter 120 feeds to the first input 132 of a conventional AND gate 130, which has a second input 134 and an output 136. Applied to the second input 134 of AND gate 130 are the sample pulses, as shown in FIGS. 2H and 2N. A pulse is produced at the AND gate output 136 in response the synchronous occurrence of a pulse at both AND gate inputs 132, 134, respectively. Thus, upon receiving an output pulse from the counter 120 and a synchronous sample pulse, the AND gate 130 produces an output pulse on line 136 which, in turn, is fed to the reset input 58 of the bistable 50. As mentioned hereinabove, a pulse at the reset input 58 causes the reference phase appearing at the divide by two bistable outputs 54, 56 to change 180° in phase.
Then, when eight successive error pulses have been counted by counter 120, the system reacts by selecting the alternate reference signal which is assumed to be the properly phased clock signal. By waiting until eight error signals are counted, the system does not falsely react to spurious noise signals.
The synchronizer 10 may be used in combination with the further demodulator circuitry 12 whereby the split phase encoded data may be decoded back to the original raw data. The circuitry 12 includes the means for generating the previously described sample pulses. The sample pulse circuitry includes a negative differentiator 150 which receives the output from the phase lock loop 42 at its input terminal 152 and produces at its output 154 a signal having pulses appearing at the occurrence of negative transitions of the signal at its input 152. The negative transition pulses appearing at the differentiator output 154 are applied to the first input 162 of an AND gate 160. AND gate 160 has a second input 164 to which is applied the Q output 56 of the bistable 58. In response to simultaneous positive levels received at its inputs 162, 164 the AND gate 160 produces a positive output pulse at its output terminal 166. The pulse at AND gate output 166 is time delayed through a delay circuit 170, thus providing the sample pulse. The exact time delay provided by the circuit 170 is sufficient such that the sample pulse is generated at a position of the selected reference signal which occurs just prior to a complete cycle thereof. By using the delay circuitry 170, the sample pulse can be generated immediately prior to a complete selected reference signal cycle such that, through the operation of the control logic circuit 110, the system senses the magnitude of the integral signal just prior to the integrate and dump circuit 70 being reset via the dump input 72.
The sample pulses are also fed to the first input 182 of a data sample circuit 180. The data sample circuit 180 has a second input 184, to which is coupled the output from a comparator 190. Comparator 190 has a first input 192 which receives the integral signal from the integrate and dump circuit 70 and a second input 194 to which is applied a reference DC signal, reference X. Referring to FIGS. 2G and 2M, the reference level X is selected to be the symmetric midpoint, or axis of the integral signal. Thus, the output from the comparator 190 assumes a high or low value dependent upon whether the integral signal is above, or below its axis, respectively. The data sample circuit 180 responds to receiving a sample pulse at its input 182 by transferring the signal at its second input 184 to an output terminal 186. Depending upon the particular reference signal selected, the output waveform will either be that shown in FIG. 2I or 20. Thus, the data sample circuit 180 operates as a D type flip flop, receiving the sample pulses on its clock input, and the output from comparator 190 at its D output, with the data sample output terminal 186 being the Q output from the flip flop.
Comparing FIGS. 2A, 2I and 20, it is seen that for the condition of the integral signal being within the upper and lower limits ref Y and ref Z at the occurrence of a sample pulse that the decoding is improper and the phase change clock pulses, FIG. 2P are generated thereby causing the alternate reference signal i.e. FIG. 2E to be selected, at which point proper decoding occurs and no further error pulses are generated.
In summary, then, an improved synchronizer for split phase modulated data has been described. The synchronizer requires a minimum of inexpensive, but reliable parts for implementation whereby it is easy to manufacture and inexpensive to realize. A full split phase encoded demodulator may be fabricated by combining the improved synchronizer with a small number of additional components.
While a preferred embodiment of the invention has been described in detail, it should be understood that many modifications and variations thereto are possible, all of which fall within the true spirit and scope of the invention.
whereby the selected reference signal is synchronized to the clock signal.
a bistable circuit operative to divide the oscillator output signal by two, the bistable including means adapted to respond to a received trigger signal to produce its divided output either at 0° or 180° relative phase.
3. The synchronizer of claim 1 wherein the synchronous detecting means is comprised of an exclusive OR gate.
counter means for processing both the comparator produced error signals and said generated correct signals and activating the reference signal means to select the alternate reference signal in response to a predetermined relationship therebetween.
whereby the produced output of the divider means tends to be the regenerated and properly phased clock signal.
6. The synchronizer of claim 5 wherein the oscillator means comprises a phase locked loop.
a phase locked loop for producing an oscillator output signal which is in phase quadrature with the bandpass filter passed signal.
8. The synchronizer of claim 5 wherein the logic state means is comprised of an exclusive OR gate.
counter means for processing both the comparator produced error signals and said generated correct signals and activating the selecting means to select the alternate first or second signal in response to a predetermined relationship therebetween.
data sample means for producing a recovered data signal having predetermined first or second levels responsive to the status of the integrator produced logic level at the time of each produced sample pulse.
decoded data output means for producing an output signal having either a first or a second logic level responsive to the status of the integral signal synchronous to the occurrence of each sample pulse.
13. The demodulator of claim 11 wherein the synchronous detecting means is comprised of an exclusive OR gate.
15. The demodulator of claim 11 wherein the decoded output data means comprises a D type flip flop with the integral signal coupled to its D input and the sample pulses coupled to its clock input whereby its Q output produces the decoded data.


text:
Privacywebmaster@inovix.net2021-07-20T12:06:01+01:00
Holymoorside & Walton Parish Council Privacy Policy
The deployment of effective, relevant information security and data protection controls is fundamental to Holymoorside & Walton Parish Council, who is committed to securing and protecting the personal data in its custody.
The General Data Protection Regulation (GDPR) came into force on the 25th May 2018, at which point it superseded the Data Protection Act 1998 (DPA).
Please use this link to fully access Holymoorside & Walton Parish Council's Data Protection Privacy Policy:
Information Gathered from Visitors to our Website
In common with other websites, log files are stored on the web server saving details such as the visitor's IP address, browser type, referring page and time of visit.
Cookies may be used to remember visitor preferences when interacting with the website.
Where registration is required, the visitor's email and a username will be stored on the server.
How the Information is used
The information is used to enhance the visitor's experience when using the website to display personalised content and possibly advertising.
E-mail addresses will not be sold, rented or leased to 3rd parties.
Visitor Options
If you have subscribed to one of our services, you may unsubscribe by following the instructions which are included in any e-mail that you receive.
You may be able to block cookies via your browser settings but this may prevent you from access to certain features of the website.
Cookies are small digital signature files that are stored by your web browser that allow your preferences to be recorded when visiting the website. Also they may be used to track your return visits to the website.
3rd party advertising companies may also use cookies for tracking purposes.
Google, as a third party vendor, uses cookies to serve ads.
Google's use of the DART cookie enables it to serve ads to visitors based on their visit to sites they visit on the Internet.
Website visitors may opt out of the use of the DART cookie by visiting the Google ad and content network privacy policy.


text:
Que peut-on enseigner en EPS ? Et donc, quels contenus viser pour les élèves ? Ces deux questions sont au centre des préoccupations éducatives et constituent l'origine et la constitution de la matière de l'enseignement au-delà d'une discipline, comme le note Pierre Arnaud : « Une discipline d'enseignement ne devient matière d'enseignement que si ses contenus (objet de la connaissance) sont structurés et hiérarchisés en fonction du niveau des élèves. Il s'agit de définir des niveaux d'acquisition en tenant compte de certains types d'exigences quant au savoir à acquérir ou aux aptitudes sollicitées. »

Définition

Définition de Contenus d'enseignement :"Les contenus d'enseignements sont les éléments, les connaissances ou techniques que l'élève doit apprendre, s'approprier, intégrer et utiliser pour avoir la compétence visée". La notion de contenus d'enseignement se considère sur le versant de l'apprenant, par l'ensemble des savoir et des savoir-faire à acquérir.  C'est ce que l'élève va devoir s'approprier pour que l'objectif soit atteint.

Les contenus d'enseignement concernent à la fois ce qu'on enseigne (programme) et ce que les élèves apprennent (savoirs pour les élèves). La notion de « contenu de formation » a été avancée par Alain Hébrard pour décrire le contenu de la formulation pour l'élève des contenus d'enseignement tels que décrits dans le langage du professeur ou des institutions.

Perspective didactique constructiviste

On peut s'écarter d'une perspective de contenus technico-centrés, en formulant des contenus d'enseignement en termes de visées de transformation de l'activité de l'élève confronté aux pratiques concrètes de la spécialité sportive abordée. Ils constitueraient alors « le système des éléments qu'un élève doit s'approprier pour comprendre et réussir les actions »  ou encore  « les conditions que l'élève doit intégrer pour transformer ses actions » . « Ils prennent donc en compte les actions et les résultats à obtenir dans les tâches d'apprentissage, mais aussi les moyens et les procédures permettant d'arriver à ces résultats » .

Notes et références

Annexes

Bibliographie
 Pierre Arnaud, Les savoirs du corps, Presses Universitaires de Lyon, Lyon, 1983
 Jean Paul Dugal, Dicodidac, CRDP Limoges, 1992
 Alain Hébrard, L'éducation physique et sportive, éducation physique et sportive, réalité et perspectives, Revues STAPS/EPS, Paris, 1986
 Jackie Marsenach, Les pratiques des enseignants dans les collèges, Revue française de pédagogie, n°89, 1989
 Jackie Marsenach (et all.), Quel enseignement ? , INRP, 1991
 Rapport de jury CAPEPS externe, 2001

Liens externes
Pepsteam.com : forum EPS - nombreux documents pédagogiques

Éducation physique et sportive

redpajama_set_name: RedPajamaWikipedia


text:
#FROMTHEFRONT#SYRIA 26.02.2020 - 26 views
Syrian Army Loses More Positions Around Saraqib Following New Turkish-led Attack (Photos, Map) 1.8 out of 5 based on 20 ratings. 20 user reviews.
Syrian Army Loses More Positions Around Saraqib Following New Turkish-led Attack (Photos, Map)
On February 26 afternoon, al-Qaeda-affiliated Hay'at Tahrir al-Sham (HTS) and the National Front for Liberation (NFL) launched a new attack on Syrian Arab Army (SAA) positions around Saraqib city with direct Turkish support.
Within a few hours, Turkish-backed militants imposed control of the towns of Salihiya and Afis to the north of Saraqib. SAA troops were pushed back to the vicinity of the city.
Militants reportedly captured three battle tanks, including a Russian-supplied T-90, in the course of the attack. Other military vehicles were destroyed.
Click to see full-size map. Source: (@Suriyakmaps) on Twitter.
A few day ago, a similar attack backed, and possibly planned, by Turkey allowed HTS and the NFL to capture the town of al-Nayrab, northwest of Saraqib. The SAA withdrew from the town, leaving behind loads of weapons.
SAA troops around Saraqib city appear to be facing some serious issues, including a poor coordination and a weak decision making among field commanders. The morale of Syrian service members there also appear to be low, for no clear reason.
Turkish-backed militants will likely develop their offensive around Saraqib, taking advantage of absence of the SAA's elite units. These units, including the 25th Special Forces Division and the 4th Division, are now advancing in southern Idlib, dozens of kilometers away from the city.
Click to see full-size image
Syrian Army Advances Deeper Into Southern Idlib, Secures Two Towns
Apple Sued For Not Removing Telegram From App Store
Taliban Attack Baghlan Provincial Capital Killing At Least 10 Security Personnel
Sergey Lavrov Annual Press Conference: Nuclear Weapons, Relations With United States And Other Questions
UAE Forces Evacuate Base In Southern Yemen Amid Houthis' Advances On Frontline (Map Update)