Lately, there has been an exponential increase in the number of people using mobile devices and thereby increasing the need for websites to target users on mobile devices. Converting the website into a Progressive Web App (PWA) is the easiest and most efficient thing to do. But what is a Progressive Web App? It is simply a mobile app delivered through the web. It looks and functions similar to a native app. The main advantage is that there is no app store process involved and the costs to build a progressive web app is significantly lesser.
Progressive Web App (PWA) is a set of mobile web application development techniques that combine features offered by most modern browsers with the benefits of mobile experience. Unlike native applications, progressive web apps are a hybrid of regular web pages (or websites) and a mobile application. In short, they provide the best of the web, plus the best of native apps.
Progressive web apps look and feel like mobile apps having interactive navigation and providing superior user experience.
Progressive Web Apps can work offline or in low quality internet connections making them reliable and more convenient than websites.
Progressive Web Apps caches and serves text, images and other content on the websites resulting in improved performance.
Progressive Web Apps are intsalled quickly and directly on the user's device in one click eliminating the necessity to download it.
Why your website should be a PWA?
A Progressive web app can help a website quickly reach a wider audience with relatively less effort. In the times where competition is increasing day-by-day, expanding your market reach faster than your competitors can prove to be a decisive advantage.
Progressive Web Apps work even when there is no or poor internet connectivity. This leads to a massive decrease in the combined data usage in a month. PWAs use only a fraction of the data when compared to Native apps.
Progressive Web Apps do not require different versions for various devices; a single progressive app meets the requirements of all endpoints on which it operates. Thus, the costs involved in building PWA is much lesser than building a native app.
Progressive Web Apps boosts the searchability and accessibility of any application. Progressive Web Apps load fast and this has a marked impact on search engine rankings as faster loading sites receive a ranking boost and are indexed quickly.
Progressive Web Apps have a specific functionality that allows them to update automatically, without notifying users and bothering them with permission requests. These apps update themselves every time when users visit them.
Progressive Web Apps are installable and live on the user's home screen from the moment the user adds it to his home screen. There is no need for having to through the app store process to get the app approved.
PWA plugin make re-engagement easy through features like push notifications. Users don't need to do every day check of their site for ordinary updates. Push notifications are sent to the user's gadgets tapping on which lands them to the fitting page with the refresh. Program Push Notifications can be surveyed on all gadgets independent of the program.
Progressive Web App loads instantly, irrespective of the kind of network connection. The technique involved is Runtime Caching with Service Worker, which reduces the time involved to load page and resources to a few milliseconds.
Note that PWA works for SSL certified websites only. That means your website should be running on HTTPS. This factor of PWA makes your content even more safe and secured. Thus, We can say that PWA serves via HTTPS to prevent snooping and ensure content has not been tampered.
Not only the app like look and feel improves the experience of users of a community but PWA also provides the app like functionality.Better UI, No scrolling glitches, better speed, Service worker caching, Server-side rendering etc are some integral parts of PWA which results in providing better user experience.
Progressive Web Apps work even when there is no or poor internet connectivity. Though the user will not able to load new content, they can view the pages which have been previously visited by them.
When users visit your website in the mobile browser, they'll be prompted to add the Progressive Web Apps to their home screens. PWAs are added to the home screens along with the app icon and name in just one click and launches with a splash screen and works like a native app.
Progressive Web Apps are highly responsive , i.e. they respond differently when viewed on devices of different sizes, be it a mobile, tablet, laptop or desktop. They automatically adjust their layout depending on the device.
Progressive Web Apps can be installed with just one tap. This frictionless installation lets users enjoy service instead of installing the bulky native app.
Experience this Awesome Plugin first hand!
What all the plugin offers?
You do not have to pay the app store fees or pass the app store approval process to get your own app published. Your app goes lives instantly.
The cost involved for progressive web apps is much less than what it takes to develop native apps.
Once the PWA has been added to the homescreen, it launches and works exactly like a native application.
Better user experience because of the instant and reliable loading irrespective of the network connectivity.
Increased user engagement on the store due to the lightning fast speed.
⇒ For having eye catching visuals of feeds present in your web app, install Advanced Activity Feeds plugin.
⇒ On the off chance that you need to be refreshed about each in and outs of your web application, install Browser Push Notifications Plugin.
⇒ Another remarkable perk is that you will get an alternate mini admin panel which you can use to set the design of your web application. Utilizing which you will have the capacity to set apart the designs of your web application and site.
As indicated by the general analysis, usage of progressive web apps provides you numerous benefits. These analysis comprises of many benefits like high user engagement, increase in mobile traffic and page views , enhanced loading speed and many more.
Display the Advanced Search box to allow search your site's content. This should be placed on the site header.
Displays the Create New Account Banner. This should be placed on the Landing Page.
Displays your Progressive Web App Header. This should be placed on the Site header. You can edit its contents in the Manage Header section of this plugin.
Shows the Startup Image that will appear while your website is being loaded. This widget should be placed on the Landing Page.
Shows a tip with an offline mode message when the network is not available.
Displays the selected Banner image. Images are uploaded from the File and Media Manager section in the Admin Panel.
Shows the page title. This widget will work for all pages except Member Home Page.
Displays the selected Navigation Menu. The content of different navigation menus can be edited from the Menu Editor Section of the Progressive Web App plugin.
Shows the site wide main menu. You can edit its contents in your Menu Editor.
Set the title: For your PWA set the title here.
Left / Right Column: Hide left / right column from pages which are not added in PWA Layout Editor.
Footer: Show / HIde footer in the PWA.
Theme: Choose to use the PWA theme or the default website theme in your PWA.
Site Title: A different website title for the PWA mode.
Auto Enable Mode: Auto enable mode for your website can also be via global settings.
PWA provides you the separate layout editor using which you can set the app like layout for your website.
The PWA Layout Editor lets your decide what content appears on specific pages or in your PWA header and footer. Click and drag the colored "blocks" to arrange the content you want on each page. Drag blocks to and from the "Available Blocks" area to add or remove them from your page. Use "HTML Blocks" if you want to drop in raw HTML or other content.
Can customize theme's colors from "Manifest Settings" section of the plugin in the admin panel.
Can set the application's background color from "Manifest Settings" section of the plugin in the admin panel.
Easy theme customization through a separate CSS file to easily modify the theme according to your requirements. A big advantage is that these theme customizations will not be lost after future theme upgrades.
In PWA, Users are getting 12 color schemes by default. In which 6 are light color schemes whereas 6 are dark color schemes. Users can use any default theme provided in the mini theme editor provided under PWA.
Not only the default theme, User can create a new color scheme in which users can modify the scheme in any way of their choice.
The web app manifest is a simple JSON file that tells the browser about your web application and how it should behave when 'installed' on the users mobile device or desktop.
App Name: The name of the application that is displayed to the user.
App Short Name: The name to be displayed when there is insufficient space to display the full name of the application.
App Description: A general description of what the application does.
Start Url: The URL that loads when a user launches the application from a device.
Theme Color: The default theme color for the application.
Background Color: The background color of the screen that is displayed between launching the application and loading it's contents.
Display: The default display mode for the web application.
Screen Orientation: The default screen orientation of the application.
App Icon: The icon of the application that will be displayed on the user's home screen.
The PWA Menu Editor lets you manage the various navigation menus that appear on your Progressive Web App. When you select the menu you wish to edit, a list of the menu items it contains will be shown. You can drag these items up and down to change their order.
This section allows you to manage your Header, Main Navigation Menu for users of all member levels.
Set logo for logged in and non-logged in users distinctively.
No, SocialEngineAddOns core plugin is required to run this plugin smoothly.
Does this plugin make every plugin work like an app?
This plugin will work in a way the core responsive functionality of the other plugins works. This plugin is compatible with every plugin as it uses the core responsive built of every plugin.
Is there any requirement to get my website as PWA?
Yes, your site must be running on HTTPS instead of HTTP then only you will be able to get the PWA of your website.
What is manifest file in PWA?
The web app manifest is a simple JSON file that tells the browser about your web application and how it should behave when 'installed' on the user's mobile device or desktop. Manifest files is created in a format like manifest.json. Having a manifest is required by Chrome to show the Add to Home Screen prompt.
Installation Simple installation that involves adding PWA to the device home screen in just one click. The installation involves different steps like visiting the app store, accepting permissions and signing in.
User Interface (UI) UI of PWA is the exact raplica of the responsive of your website. That implies it is completely dependent on the responsive work done for the plugin installed on your website. UI of native app doesn't hold any reliance. UI of every module present in the app can be planned and designed according to the user's desire.
Online / Offline Mode PWA will function offline. Though you will not able to load new content, you can access all the pages that have been previously visited. Not completely but some counted features can be used offline.
Access to Device's Features Limited access to the device's features. Full access to the device's features.
App Store Independent Any update made on the synced website will be reflected to the PWA automatically. No update will have to be done via any kind of App store. For all updates, user has to download the updates from the App store.
Costs Involved The time and costs involved are significantly lower than a Native App. A longer development process, involving higher costs.
Sharability Progressive Web Apps can be shared through a URL instead so they're easily found. Native apps need to be downloaded from App Store.
Storage, Data and Power Resource use in terms of power/battery, storage space and mobile data is much lower than a native app. Resource use in terms of power/battery, storage space and mobile data is higher.


text:
//******************************************************************************************************
//  SubscriptionInfo.cs - Gbtc
//
//  Copyright © 2010, Grid Protection Alliance.  All Rights Reserved.
//
//  Licensed to the Grid Protection Alliance (GPA) under one or more contributor license agreements. See
//  the NOTICE file distributed with this work for additional information regarding copyright ownership.
//  The GPA licenses this file to you under the Eclipse Public License -v 1.0 (the "License"); you may
//  not use this file except in compliance with the License. You may obtain a copy of the License at:
//
//      http://www.opensource.org/licenses/eclipse-1.0.php
//
//  Unless agreed to in writing, the subject software distributed under the License is distributed on an
//  "AS-IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. Refer to the
//  License for the specific language governing permissions and limitations.
//
//  Code Modification History:
//  ----------------------------------------------------------------------------------------------------
//  04/25/2012 - Stephen C. Wills
//       Generated original version of source code.
//
//******************************************************************************************************

using System;

namespace GSF.TimeSeries.Transport
{

    /// <summary>
    /// Configuration object for data subscriptions.
    /// </summary>
    public abstract class SubscriptionInfo
    {
        #region [ Members ]

        // Fields
        private string m_filterExpression;

        private bool m_useCompactMeasurementFormat;
        private bool m_useMillisecondResolution;

        private bool m_udpDataChannel;
        private int m_dataChannelLocalPort;

        private double m_lagTime;
        private double m_leadTime;
        private bool m_useLocalClockAsRealTime;

        private string m_startTime;
        private string m_stopTime;
        private string m_constraintParameters;
        private int m_processingInterval;

        private string m_waitHandleNames;
        private int m_waitHandleTimeout;

        private string m_extraConnectionStringParameters;

        #endregion

        #region [ Constructors ]

        /// <summary>
        /// Creates a new instance of the <see cref="SubscriptionInfo"/> class.
        /// </summary>
        public SubscriptionInfo()
        {
            m_useCompactMeasurementFormat = true;
            m_dataChannelLocalPort = 9500;
            m_lagTime = 10.0;
            m_leadTime = 5.0;
            m_processingInterval = -1;
        }

        #endregion

        #region [ Properties ]

        /// <summary>
        /// Gets or sets the filter expression used to define which
        /// measurements are being requested by the subscriber.
        /// </summary>
        public virtual string FilterExpression
        {
            get
            {
                return m_filterExpression;
            }
            set
            {
                m_filterExpression = value;
            }
        }

        /// <summary>
        /// Gets or sets the flag that determines whether to use the
        /// compact measurement format or the full measurement format
        /// for transmitting measurements to the subscriber.
        /// </summary>
        public virtual bool UseCompactMeasurementFormat
        {
            get
            {
                return m_useCompactMeasurementFormat;
            }
            set
            {
                m_useCompactMeasurementFormat = value;
            }
        }

        /// <summary>
        /// Gets or sets the flag that determines whether the subscriber
        /// is requesting its data over a separate UDP data channel.
        /// </summary>
        public virtual bool UdpDataChannel
        {
            get
            {
                return m_udpDataChannel;
            }
            set
            {
                m_udpDataChannel = value;
            }
        }

        /// <summary>
        /// Gets or sets the port number that the UDP data channel binds to.
        /// This value is only used when the subscriber requests a separate
        /// UDP data channel.
        /// </summary>
        public virtual int DataChannelLocalPort
        {
            get
            {
                return m_dataChannelLocalPort;
            }
            set
            {
                m_dataChannelLocalPort = value;
            }
        }

        /// <summary>
        /// Gets or sets the allowed past time deviation
        /// tolerance in seconds (can be subsecond).
        /// </summary>
        public virtual double LagTime
        {
            get
            {
                return m_lagTime;
            }
            set
            {
                m_lagTime = value;
            }
        }

        /// <summary>
        /// Gets or sets the allowed future time deviation
        /// tolerance, in seconds (can be subsecond).
        /// </summary>
        public virtual double LeadTime
        {
            get
            {
                return m_leadTime;
            }
            set
            {
                m_leadTime = value;
            }
        }

        /// <summary>
        /// Gets or sets the flag that determines whether the server's
        /// local clock is used as real-time. If false, the timestamps
        /// of the measurements will be used as real-time.
        /// </summary>
        public virtual bool UseLocalClockAsRealTime
        {
            get
            {
                return m_useLocalClockAsRealTime;
            }
            set
            {
                m_useLocalClockAsRealTime = value;
            }
        }

        /// <summary>
        /// Gets or sets the flag that determines whether measurement timestamps use
        /// millisecond resolution. If false, they will use <see cref="Ticks"/> resolution.
        /// </summary>
        /// <remarks>
        /// This flag determines the size of the timestamps transmitted as part of
        /// the compact measurement format when the server is using base time offsets.
        /// </remarks>
        public virtual bool UseMillisecondResolution
        {
            get
            {
                return m_useMillisecondResolution;
            }
            set
            {
                m_useMillisecondResolution = value;
            }
        }

        /// <summary>
        /// Gets or sets the start time of the requested
        /// temporal session for streaming historic data.
        /// </summary>
        /// <remarks>
        /// <para>
        /// When the <see cref="StartTime"/> or <see cref="StopTime"/> temporal processing contraints are defined (i.e., not <c>null</c>), this
        /// specifies the start and stop time over which the subscriber session will process data. Passing in <c>null</c> for the <see cref="StartTime"/>
        /// and <see cref="StopTime"/> specifies the the subscriber session will process data in standard, i.e., real-time, operation.
        /// </para>
        ///
        /// <para>
        /// Both the <see cref="StartTime"/> and <see cref="StopTime"/> parameters can be specified in one of the
        /// following formats:
        /// <list type="table">
        ///     <listheader>
        ///         <term>Time Format</term>
        ///         <description>Format Description</description>
        ///     </listheader>
        ///     <item>
        ///         <term>12-30-2000 23:59:59.033</term>
        ///         <description>Absolute date and time.</description>
        ///     </item>
        ///     <item>
        ///         <term>*</term>
        ///         <description>Evaluates to <see cref="DateTime.UtcNow"/>.</description>
        ///     </item>
        ///     <item>
        ///         <term>*-20s</term>
        ///         <description>Evaluates to 20 seconds before <see cref="DateTime.UtcNow"/>.</description>
        ///     </item>
        ///     <item>
        ///         <term>*-10m</term>
        ///         <description>Evaluates to 10 minutes before <see cref="DateTime.UtcNow"/>.</description>
        ///     </item>
        ///     <item>
        ///         <term>*-1h</term>
        ///         <description>Evaluates to 1 hour before <see cref="DateTime.UtcNow"/>.</description>
        ///     </item>
        ///     <item>
        ///         <term>*-1d</term>
        ///         <description>Evaluates to 1 day before <see cref="DateTime.UtcNow"/>.</description>
        ///     </item>
        /// </list>
        /// </para>
        /// </remarks>
        public virtual string StartTime
        {
            get
            {
                return m_startTime;
            }
            set
            {
                m_startTime = value;
            }
        }

        /// <summary>
        /// Gets or sets the stop time of the requested
        /// temporal session for streaming historic data.
        /// </summary>
        /// <remarks>
        /// <para>
        /// When the <see cref="StartTime"/> or <see cref="StopTime"/> temporal processing contraints are defined (i.e., not <c>null</c>), this
        /// specifies the start and stop time over which the subscriber session will process data. Passing in <c>null</c> for the <see cref="StartTime"/>
        /// and <see cref="StopTime"/> specifies the the subscriber session will process data in standard, i.e., real-time, operation.
        /// </para>
        ///
        /// <para>
        /// Both the <see cref="StartTime"/> and <see cref="StopTime"/> parameters can be specified in one of the
        /// following formats:
        /// <list type="table">
        ///     <listheader>
        ///         <term>Time Format</term>
        ///         <description>Format Description</description>
        ///     </listheader>
        ///     <item>
        ///         <term>12-30-2000 23:59:59.033</term>
        ///         <description>Absolute date and time.</description>
        ///     </item>
        ///     <item>
        ///         <term>*</term>
        ///         <description>Evaluates to <see cref="DateTime.UtcNow"/>.</description>
        ///     </item>
        ///     <item>
        ///         <term>*-20s</term>
        ///         <description>Evaluates to 20 seconds before <see cref="DateTime.UtcNow"/>.</description>
        ///     </item>
        ///     <item>
        ///         <term>*-10m</term>
        ///         <description>Evaluates to 10 minutes before <see cref="DateTime.UtcNow"/>.</description>
        ///     </item>
        ///     <item>
        ///         <term>*-1h</term>
        ///         <description>Evaluates to 1 hour before <see cref="DateTime.UtcNow"/>.</description>
        ///     </item>
        ///     <item>
        ///         <term>*-1d</term>
        ///         <description>Evaluates to 1 day before <see cref="DateTime.UtcNow"/>.</description>
        ///     </item>
        /// </list>
        /// </para>
        /// </remarks>
        public virtual string StopTime
        {
            get
            {
                return m_stopTime;
            }
            set
            {
                m_stopTime = value;
            }
        }

        /// <summary>
        /// Gets or sets the aditional constraint parameters
        /// supplied to temporal adapters in a temporal session.
        /// </summary>
        public virtual string ConstraintParameters
        {
            get
            {
                return m_constraintParameters;
            }
            set
            {
                m_constraintParameters = value;
            }
        }

        /// <summary>
        /// Gets or sets the processing interval requested by the subscriber.
        /// A value of <c>-1</c> indicates the default processing interval.
        /// A value of <c>0</c> indicates data will be processed as fast as
        /// possible.
        /// </summary>
        /// <remarks>
        /// With the exception of the values of -1 and 0, the <see cref="ProcessingInterval"/> value specifies the desired historical playback data
        /// processing interval in milliseconds. This is basically a delay, or timer interval, overwhich to process data. Setting this value to -1 means
        /// to use the default processing interval while setting the value to 0 means to process data as fast as possible.
        /// </remarks>
        public virtual int ProcessingInterval
        {
            get
            {
                return m_processingInterval;
            }
            set
            {
                m_processingInterval = value;
            }
        }

        /// <summary>
        /// Gets or sets the wait handle names used to deterministically
        /// wait for data to become available on the server side.
        /// </summary>
        public virtual string WaitHandleNames
        {
            get
            {
                return m_waitHandleNames;
            }
            set
            {
                m_waitHandleNames = value;
            }
        }

        /// <summary>
        /// Gets or sets the amount of time to wait on the wait handles
        /// identified by the <see cref="WaitHandleNames"/> before the
        /// operation times out.
        /// </summary>
        public virtual int WaitHandleTimeout
        {
            get
            {
                return m_waitHandleTimeout;
            }
            set
            {
                m_waitHandleTimeout = value;
            }
        }

        /// <summary>
        /// Gets or sets the additional connection string parameters to
        /// be applied to the connection string sent to the publisher
        /// during subscription.
        /// </summary>
        public virtual string ExtraConnectionStringParameters
        {
            get
            {
                return m_extraConnectionStringParameters;
            }
            set
            {
                m_extraConnectionStringParameters = value;
            }
        }

        #endregion

        #region [ Methods ]

        /// <summary>
        /// Creates a shallow copy of this
        /// <see cref="SubscriptionInfo"/> object.
        /// </summary>
        /// <returns>The copy of this object.</returns>
        public virtual SubscriptionInfo Copy()
        {
            return (SubscriptionInfo)MemberwiseClone();
        }

        #endregion
    }

    /// <summary>
    /// Configuration object for synchronized data subscriptions.
    /// </summary>
    public sealed class SynchronizedSubscriptionInfo : SubscriptionInfo
    {
        #region [ Members ]

        // Fields
        private bool m_remotelySynchronized;

        private int m_framesPerSecond;
        private DownsamplingMethod m_downsamplingMethod;
        private bool m_allowPreemptivePublishing;

        private bool m_allowSortsByArrival;
        private bool m_ignoreBadTimestamps;
        private long m_timeResolution;

        #endregion

        #region [ Constructors ]

        /// <summary>
        /// Creates a new instance of the <see cref="SynchronizedSubscriptionInfo"/> class.
        /// </summary>
        /// <param name="remotelySynchronized">Flag that determines whether the subscription defined by this object is remotely synchronized or locally synchronized.</param>
        /// <param name="framesPerSecond">Frame rate of the subscription in frames per second.</param>
        public SynchronizedSubscriptionInfo(bool remotelySynchronized, int framesPerSecond)
        {
            m_remotelySynchronized = remotelySynchronized;

            m_framesPerSecond = framesPerSecond;
            m_downsamplingMethod = DownsamplingMethod.LastReceived;
            m_allowPreemptivePublishing = true;

            m_allowSortsByArrival = true;
            m_timeResolution = Ticks.PerMillisecond;
        }

        #endregion

        #region [ Properties ]

        /// <summary>
        /// Gets or sets the flag that determines whether this subscription
        /// is remotely synchronized or locally synchronized.
        /// </summary>
        public bool RemotelySynchronized
        {
            get
            {
                return m_remotelySynchronized;
            }
            set
            {
                m_remotelySynchronized = value;
            }
        }

        /// <summary>
        /// Gets or sets the frame rate of the subscription in frames per second.
        /// </summary>
        public int FramesPerSecond
        {
            get
            {
                return m_framesPerSecond;
            }
            set
            {
                m_framesPerSecond = value;
            }
        }

        /// <summary>
        /// Gets or sets the downsampling method used when the frame rate of
        /// the subscription is lower than the frame rate of the measurement's
        /// source.
        /// </summary>
        public DownsamplingMethod DownsamplingMethod
        {
            get
            {
                return m_downsamplingMethod;
            }
            set
            {
                m_downsamplingMethod = value;
            }
        }

        /// <summary>
        /// Gets or sets the flag that determines whether frames should be published
        /// as soon as the data is available. If false, frames will be published
        /// when their timestamp expires <c>(realTime > timestamp + lagTime)</c>.
        /// </summary>
        public bool AllowPreemptivePublishing
        {
            get
            {
                return m_allowPreemptivePublishing;
            }
            set
            {
                m_allowPreemptivePublishing = value;
            }
        }

        /// <summary>
        /// Gets or sets the flag that determines whether to allow measurement
        /// sorting based on the measurement's time of arrival, if its timestamp
        /// is unreasonable.
        /// </summary>
        public bool AllowSortsByArrival
        {
            get
            {
                return m_allowSortsByArrival;
            }
            set
            {
                m_allowSortsByArrival = value;
            }
        }

        /// <summary>
        /// Gets or sets the flag that determines whether to
        /// ignore bad timestamps when sorting measurements.
        /// </summary>
        public bool IgnoreBadTimestamps
        {
            get
            {
                return m_ignoreBadTimestamps;
            }
            set
            {
                m_ignoreBadTimestamps = value;
            }
        }

        /// <summary>
        /// Gets or sets the maximum time resolution, in ticks, to use when sorting measurements by timestamps into their proper destination frame.
        /// </summary>
        /// <remarks>
        /// <list type="table">
        ///     <listheader>
        ///         <term>Desired maximum resolution</term>
        ///         <description>Value to assign</description>
        ///     </listheader>
        ///     <item>
        ///         <term>Seconds</term>
        ///         <description><see cref="Ticks"/>.<see cref="Ticks.PerSecond"/></description>
        ///     </item>
        ///     <item>
        ///         <term>Milliseconds</term>
        ///         <description><see cref="Ticks"/>.<see cref="Ticks.PerMillisecond"/></description>
        ///     </item>
        ///     <item>
        ///         <term>Microseconds</term>
        ///         <description><see cref="Ticks"/>.<see cref="Ticks.PerMicrosecond"/></description>
        ///     </item>
        ///     <item>
        ///         <term>100-Nanoseconds</term>
        ///         <description>0</description>
        ///     </item>
        /// </list>
        /// Assigning values less than zero will be set to zero since minimum possible concentrator resolution is one tick (100-nanoseconds). Assigning
        /// values values greater than <see cref="Ticks"/>.<see cref="Ticks.PerSecond"/> will be set to <see cref="Ticks"/>.<see cref="Ticks.PerSecond"/>
        /// since maximum possible concentrator resolution is one second (i.e., 1 frame per second).
        /// </remarks>
        public long TimeResolution
        {
            get
            {
                return m_timeResolution;
            }
            set
            {
                m_timeResolution = value;
            }
        }

        #endregion
    }

    /// <summary>
    /// Configuration object for unsynchronized data subscriptions.
    /// </summary>
    public sealed class UnsynchronizedSubscriptionInfo : SubscriptionInfo
    {
        #region [ Members ]

        // Fields
        private bool m_throttled;
        private double m_publishInterval;
        private bool m_includeTime;

        #endregion

        #region [ Constructors ]

        /// <summary>
        /// Creates a new instance of the <see cref="UnsynchronizedSubscriptionInfo"/> class.
        /// </summary>
        /// <param name="throttled">The flag that determines whether to request that the subscription be throttled.</param>
        public UnsynchronizedSubscriptionInfo(bool throttled)
        {
            m_throttled = throttled;
            m_publishInterval = -1;
            m_includeTime = true;
        }

        #endregion

        #region [ Properties ]

        /// <summary>
        /// Gets or sets the flag that determines whether
        /// to request that the subscription be throttled.
        /// </summary>
        public bool Throttled
        {
            get
            {
                return m_throttled;
            }
            set
            {
                m_throttled = value;
            }
        }

        /// <summary>
        /// Gets or sets the interval at which data should be
        /// published when using a throttled subscription.
        /// </summary>
        public double PublishInterval
        {
            get
            {
                return m_publishInterval;
            }
            set
            {
                m_publishInterval = value;
            }
        }

        /// <summary>
        /// Gets or sets the flag that determines whether timestamps are
        /// included in the data sent from the publisher. This value is
        /// ignored if the data is remotely synchronized.
        /// </summary>
        public bool IncludeTime
        {
            get
            {
                return m_includeTime;
            }
            set
            {
                m_includeTime = value;
            }
        }

        #endregion
    }
}

redpajama_set_name: RedPajamaGithub


text:
Leadership Principles
Investor Centre Frequently Asked Questions Financial | Frequently Asked Questions
Financial | Frequently Asked Questions
1. Where you acquire PDPs from the "big four" banks do you need to repay the full face value of the debt?
The majority of customer accounts acquired are under forward flow agreements, where Pioneer agrees to purchase and the vendor agrees to sell a proportion of its portfolio, meeting agreed characteristics for an agreed term (typically of 12-24 months). Pricing is typically reported as a percentage of the face value of the debt or "cents in the dollar".
Pioneer's objective is to invest in debt portfolios and then recover an amount on the accounts that make up those portfolios that exceeds the purchase cost by an amount that is large enough to pay all of Pioneer's operating expenses and generate a profit and adequate return on capital. This will achieve, across the portfolio, an overall return which is evaluated and managed in terms of a return multiple to the acquisition investment.
Pioneer's contractual obligation in accepting the offer of the customer contracts from the vendor is to service the forward flow arrangement for the agreed term at the agreed price as referenced above.
2. Who are the Company's auditors?
PricewaterhouseCoopers are the Company's auditors.
In accordance with the Corporations Act 2001 (Cth), an audit engagement partner must be rotated after 5 successive financial years. The Company was admitted to the Official List of the ASX Limited on 1 May 2014 and as such rotation of the current audit partner will be required in 2019.
We're available 6am - 5pm WST;
Click here to download our Privacy & Credit Information Policy Statement © 2019 Pioneer Credit - Site design by egg design group built by PPR

redpajama_set_name: RedPajamaCommonCrawl


text:
Q: How to update state in specific rows in a table ReactJS I have icons in a table setup so that when an icon is clicked, a different icon is rendered. Now this works fine but I want to re-render a different icon for that specific row in the row that I clicked as opposed to re-rendering a different icon in every row. No idea as to how I would go about doing this. Here is my code:
import React from 'react';
import StarBorder from '@material-ui/icons/StarBorder';
import Star from '@material-ui/icons/Star';
import axios from 'axios';

class Test extends React.Component {
    constructor(props) {
        super(props);
        this.state = {
            starIcon: true,
            data: [],
        }
    }

    componentDidMount() {

        axios.get('https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&order=market_cap_desc&per_page=100&page=1&sparkline=true')
            .then(res => {
                const data = res.data;
                this.setState({  data: data})
            })
    }

    handleClick = () => {
        this.setState(prevState => ({
          starIcon: !prevState.starIcon
        }));
      }

    render() {
        return (

                    Rank
                    Name
                    Price

                {this.state.data.map((n) => {
                    return (

                          this.handleClick()}> {this.state.starIcon ? <StarBorder/> : <Star /> }
                        {n.name}
                        {n.current_price}

                    );
                    })}

        );
    }
}

export default Test;

A: The way I see it, you need to either duplicate your starIcon boolean in an array that has the same length as your data array, or integrate your boolean in your data array. Here's a proposition for the second option :
import React from 'react';
import StarBorder from '@material-ui/icons/StarBorder';
import Star from '@material-ui/icons/Star';
import axios from 'axios';

class Test extends React.Component {
    constructor(props) {
        super(props);
        this.state = {
            data: [],
        }
    }

    componentDidMount() {

        axios.get('https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&order=market_cap_desc&per_page=100&page=1&sparkline=true')
            .then(res => {
                const data = res.data;
                this.setState({  data: data.map(x => ({...x, starIcon: true}) ) })
            })
    }

    handleClick = (i) => {
        this.setState(prevState => ({
          data: prevState.data.map((x, key) => (key === i ? {...x, starIcon: !x. starIcon} : x) )
        }));
      }

    render() {
        return (

                    Rank
                    Name
                    Price

                {this.state.data.map((n, i) => {
                    return (

                          this.handleClick(i)}> {n.starIcon ? <StarBorder/> : <Star /> }
                        {n.name}
                        {n.current_price}

                    );
                    })}

        );
    }
}

export default Test;

Hope it helps

redpajama_set_name: RedPajamaStackExchange


Enjoy delicious dining in relaxing surroundings. The menu at Molly's Bistro is tailored to showcase the very best ingredients with a passion for promoting local food and drink. The wine list has been carefully selected to offer the best flavour, body and choice.
With a fully stocked bar that features a selection of single malts, spirits and local beers. Molly's Bistro provides a lovely and relaxing environment for lunch and evening meals. The menu and opening times can be found here.
Nothing beats a good afternoon tea and a catch up with friends or family. Delicious hand cut sandwiches, fresh scones, homemade cakes, chocolate dipped strawberries tea/coffee & optional prosecco – heaven!
Malones Irish Pub, is the Douglas Hotels very own lively corner of Ireland, showing live sports and live music 7 nights a week.
The Aberdeen Douglas Hotel has been welcoming guests since 1848 and in recent years has re-established itself as one of Aberdeen's Premier Hotels.
The Aberdeen Douglas Hotel is located in the heart of the city centre. They are an independently owned business with friendly, efficient and unobtrusive service at its heart. Their experienced staff will do everything to make your stay in the Granite City a truly enjoyable experience.
Conferencing and event facilities available for for 2 – 400 people.
Our standard double rooms have crisp white linen along with tea and coffee making facilities.
Our standard twin rooms have crisp white linen along with tea and coffee making facilities.
Our Executive double rooms have crisp white linen along with tea and coffee making facilities.


text:
Luisa Eugenia Navas Bustamante (Chillán, 1920 - 2020) fue una farmacéutica y botánica chilena.

Biografía
El  consiguió su título de químico-farmacéutica, en ese mismo año es Ayudante de la Cátedra de Botánica en la Escuela de Química y Farmacia de la Universidad de Chile. En 1958 asciende a "Profesor extraordinario", y ayudante de Hugo Gunckel en el Instituto Pedagógico, Sección de Plantas y finalmente catedrática de Criptogamia de la Facultad de Ciencias Químicas y Farmacéuticas en 1985.

Tempranamente, cuando se dedica al estudio de las algas marinas, concurría con su padre a la Estación marina de Biología en Montemar. Con la autorización del decano de Farmacia, ella concurría dos veces por semana al Museo Nacional de Historia Natural. Por encargo de Humberto Fuenzalida, reorganiza la Sección Botánica de Criptogamia. Con una beca de la Unesco estudia Ecología Vegetal en México, en la Escuela Politécnica con los especialistas de Montpellier y del San Luis de Potosí. Y concurre más adelante al jardín botánico de la Universidad Central de Caracas.

Publicaciones
 1966. Monografía sobre las parietarias de Chile. 9 pp.
 1971. "Distribución Geográfica de las Mirtáceas Chilenas". Boletín del Museo Nacional de Historia Natural. Chile. 29: 223-247. en línea

 1976. Flora de la cuenca de Santiago de Chile. Vol. 2. Editor Andrés Bello, 559 pp. en línea

 1969. El género Dioscorea en Chile. Con Gevina Erba V. Ed. Universidad Cátolica, 20 pp.

Algunos taxones de L.E.Navas
 Gavilea longibracteata (Lindl.)Sparre ex L E Navas,

Glandularia lipozygioides (Walp.)L.E.Navas
 Myrceugenia colchaguensis
 Parietaria fernandeziana (es P.debilis)

Referencias

Enlaces externos

Alumnado de la Universidad de Chile
Farmacéuticos de Chile
Botánicas de Chile
Escritores en español del siglo XX
Profesores de la Universidad de Chile
Nacidos en Chillán
Centenarios de Chile

redpajama_set_name: RedPajamaWikipedia


text:
using namespace IECore;

RunTimeTyped::Mutex RunTimeTyped::g_baseTypeIdsMutex;
RunTimeTyped::Mutex RunTimeTyped::g_derivedTypeIdsMutex;

RunTimeTyped::RunTimeTyped()
{
}

RunTimeTyped::~RunTimeTyped()
{
}

TypeId RunTimeTyped::typeId() const
{
	return staticTypeId();
}

const char *RunTimeTyped::typeName() const
{
	return staticTypeName();
}

TypeId RunTimeTyped::staticTypeId()
{
	return RunTimeTypedTypeId;
}

const char *RunTimeTyped::staticTypeName()
{
	return "RunTimeTyped";
}

TypeId RunTimeTyped::baseTypeId()
{
	return InvalidTypeId;
}

const char *RunTimeTyped::baseTypeName()
{
	return "InvalidType";
}

bool RunTimeTyped::isInstanceOf( TypeId typeId ) const
{
	return typeId==staticTypeId();
}

bool RunTimeTyped::isInstanceOf( const char *typeName ) const
{
	assert( typeName );
	return !strcmp( typeName, staticTypeName() );
}

bool RunTimeTyped::inheritsFrom( TypeId typeId )
{
	return false;
}

bool RunTimeTyped::inheritsFrom( const char *typeName )
{
	assert( typeName );
	return false;
}

bool RunTimeTyped::inheritsFrom( TypeId type, TypeId baseType )
{
	const std::vector<TypeId> &baseTypes = baseTypeIds( type );
	return find( baseTypes.begin(), baseTypes.end(), baseType ) != baseTypes.end();
}

bool RunTimeTyped::inheritsFrom( const char *typeName, const char *baseTypeName )
{
	return inheritsFrom( typeIdFromTypeName( typeName ), typeIdFromTypeName( baseTypeName ) );
}

void RunTimeTyped::registerType( TypeId derivedTypeId, const char *derivedTypeName, TypeId baseTypeId )
{
	assert( derivedTypeName );

	{
		BaseTypeRegistryMap &baseRegistry = baseTypeRegistry();
		BaseTypeRegistryMap::iterator lb = baseRegistry.lower_bound( derivedTypeId );
		if ( lb != baseRegistry.end() && derivedTypeId == lb->first )
		{
			if ( baseTypeId != lb->second )
			{
				msg( Msg::Warning, "RunTimeTyped", boost::format( "Duplicate registration of base type id for '%s' - %d and %d") % derivedTypeName % lb->second % baseTypeId  );
			}
		}
		else
		{
			/// Use the lower-bound as a hint for the position, yielding constant insert time
			baseRegistry.insert( lb, BaseTypeRegistryMap::value_type( derivedTypeId, baseTypeId ) );
		}
	}

	/// Inserted derived type id into set of base classes derived type ids
	DerivedTypesRegistryMap &derivedRegistry = derivedTypesRegistry();
	derivedRegistry[ baseTypeId ].insert( derivedTypeId );

	/// Put in id->name map
	{
		TypeIdsToTypeNamesMap &idsToNames = typeIdsToTypeNames();
		TypeIdsToTypeNamesMap::iterator lb = idsToNames.lower_bound( derivedTypeId );
		if ( lb != idsToNames.end() && derivedTypeId == lb->first )
		{
			if ( std::string( derivedTypeName ) != lb->second )
			{
				msg( Msg::Warning, "RunTimeTyped", boost::format( "Duplicate registration of type name for type id %d - '%s' and '%s'" ) % derivedTypeId % lb->second % derivedTypeName );
			}
		}
		else
		{
			/// Use the lower-bound as a hint for the position, yielding constant insert time
			idsToNames.insert( lb, TypeIdsToTypeNamesMap::value_type( derivedTypeId, derivedTypeName ) );
			assert( !strcmp( typeNameFromTypeId( derivedTypeId ), derivedTypeName ) );
		}
	}

	/// Put in name->id map
	{
		TypeNamesToTypeIdsMap &namesToIds = typeNamesToTypeIds();
		TypeNamesToTypeIdsMap::iterator lb = namesToIds.lower_bound( derivedTypeName );
		if ( lb != namesToIds.end() && derivedTypeName == lb->first )
		{
			if ( derivedTypeId != lb->second )
			{
				msg( Msg::Warning, "RunTimeTyped", boost::format( "Duplicate registration of type id for type name '%s' - %d and %d") % derivedTypeName % lb->second % derivedTypeId );
			}
		}
		else
		{
			/// Use the lower-bound as a hint for the position, yielding constant insert time
			namesToIds.insert( lb, TypeNamesToTypeIdsMap::value_type( derivedTypeName, derivedTypeId ) );
			assert( typeIdFromTypeName( derivedTypeName ) == derivedTypeId );
		}
	}
}

RunTimeTyped::BaseTypeRegistryMap &RunTimeTyped::baseTypeRegistry()
{
	static BaseTypeRegistryMap *registry = new BaseTypeRegistryMap();

	assert( registry );
	return *registry;
}

RunTimeTyped::DerivedTypesRegistryMap &RunTimeTyped::derivedTypesRegistry()
{
	static DerivedTypesRegistryMap *registry = new DerivedTypesRegistryMap();

	assert( registry );
	return *registry;
}

TypeId RunTimeTyped::baseTypeId( TypeId typeId )
{
	BaseTypeRegistryMap &baseRegistry = baseTypeRegistry();
	BaseTypeRegistryMap::const_iterator it = baseRegistry.find( typeId );

	if ( it == baseRegistry.end() )
	{
		return InvalidTypeId;
	}
	else
	{
		return it->second;
	}
}

const std::vector<TypeId> &RunTimeTyped::baseTypeIds( TypeId typeId )
{
	Mutex::scoped_lock lock( g_baseTypeIdsMutex, false ); // read-only lock
	BaseTypesRegistryMap &baseTypes = completeBaseTypesRegistry();

	BaseTypesRegistryMap::iterator it = baseTypes.find( typeId );
	if ( it != baseTypes.end() )
	{
		return it->second;
	}

	lock.upgrade_to_writer();

	baseTypes.insert( BaseTypesRegistryMap::value_type( typeId, std::vector<TypeId>() ) );
	it = baseTypes.find( typeId );
	assert( it != baseTypes.end() );

	TypeId baseType = baseTypeId( typeId );
	while ( baseType != InvalidTypeId )
	{
		it->second.push_back( baseType );
		baseType = baseTypeId( baseType );
	}

	return it->second;
}

const std::set<TypeId> &RunTimeTyped::derivedTypeIds( TypeId typeId )
{
	Mutex::scoped_lock lock( g_derivedTypeIdsMutex, false ); // read-only lock
	DerivedTypesRegistryMap &derivedTypes = completeDerivedTypesRegistry();
	DerivedTypesRegistryMap::iterator it = derivedTypes.find( typeId );

	if ( it == derivedTypes.end() )
	{
		lock.upgrade_to_writer();
		derivedTypes.insert( DerivedTypesRegistryMap::value_type( typeId, std::set<TypeId>() ) );
		it = derivedTypes.find( typeId );
		assert( it != derivedTypes.end() );

		// Walk over the hierarchy of derived types
		derivedTypeIdsWalk( typeId, it->second );
	}

	return it->second;
}

void RunTimeTyped::derivedTypeIdsWalk( TypeId typeId, std::set<TypeId> &typeIds )
{
	DerivedTypesRegistryMap &derivedRegistry = derivedTypesRegistry();
	DerivedTypesRegistryMap::const_iterator it = derivedRegistry.find( typeId );
	if ( it == derivedRegistry.end() )
	{
		/// Termination condition: No derived types
		return;
	}

	for ( std::set<TypeId>::const_iterator typesIt = it->second.begin(); typesIt != it->second.end(); ++ typesIt )
	{
		typeIds.insert( *typesIt );

		// Recurse down into derived types
		derivedTypeIdsWalk( *typesIt, typeIds );
	}
}

RunTimeTyped::BaseTypesRegistryMap &RunTimeTyped::completeBaseTypesRegistry()
{
	static BaseTypesRegistryMap *baseTypes = new BaseTypesRegistryMap();
	assert( baseTypes );
	return *baseTypes;
}

RunTimeTyped::DerivedTypesRegistryMap &RunTimeTyped::completeDerivedTypesRegistry()
{
	static DerivedTypesRegistryMap *derivedTypes = new DerivedTypesRegistryMap();
	assert( derivedTypes );
	return *derivedTypes;
}

TypeId RunTimeTyped::typeIdFromTypeName( const char *typeName )
{
	assert( typeName );

	TypeNamesToTypeIdsMap &namesToIds = typeNamesToTypeIds();
	const std::string key( typeName );
	TypeNamesToTypeIdsMap::const_iterator it = namesToIds.find( key );
	if( it == namesToIds.end() )
	{
		return InvalidTypeId;
	}
	return it->second;
}

const char *RunTimeTyped::typeNameFromTypeId( TypeId typeId )
{
	TypeIdsToTypeNamesMap &idsToNames = typeIdsToTypeNames();
	TypeIdsToTypeNamesMap::const_iterator it = idsToNames.find( typeId );
	if( it == idsToNames.end() )
	{
		return "";
	}
	return it->second.c_str();
}

RunTimeTyped::TypeIdsToTypeNamesMap &RunTimeTyped::typeIdsToTypeNames()
{
	static TypeIdsToTypeNamesMap *m = new TypeIdsToTypeNamesMap();
	assert( m );
	if( !m->size() )
	{
		(*m)[staticTypeId()] = staticTypeName();
	}
	return *m;
}

RunTimeTyped::TypeNamesToTypeIdsMap &RunTimeTyped::typeNamesToTypeIds()
{
	static TypeNamesToTypeIdsMap *m = new TypeNamesToTypeIdsMap();
	assert( m );
	if( !m->size() )
	{
		(*m)[staticTypeName()] = staticTypeId();
	}
	return *m;
}


I did something weird July 11th.
I'm so not a 'line' person as in with the exception of waiting my turn to ride a Sea-Doo or a killer ride at Disneyland, nothing to me, is worth standing in an idle line of people.
But concert tickets, the newest toy or after Thanksgiving Day sales – no way.
So under the guise of 'having to do chores', I was able to get my mom to agree to come babysit while I covertly hit the AT&T store in hope of getting my own iphone.
I have a crappy Sprint phone that only makes calls and not impressively at that. Plus, I detest Sprint after 10 years of being a loyal customer.
I've recently determined that it's crucial that I have internet access, music, texting (which, for the record I've never done) and a crap load of other techie features in one device.
So, I snuck down to an AT&T store last Friday around 10:00am. and saw a line outside of about 5 people.
I parked and proudly walked up thinking these idiots who stand in lines for hours or who get there at midnight are complete morons.
I left 15 minutes later with no phone. They sold out before I was even awake.
So, I pretty much will have to wait until the one I ordered arrived. That's what I get for thinking I could beat the system.


text:
1.501-207-1271
tourbelizeautorentallimited@yahoo.com
Belize Airports
Belize Weather Overview
Flights to Belize
Frequently Asked Questions (FAQ) About Belize
Getting to Belize
Belize City is by far the largest urban area in Belize with a population of around 58,000 people. Located on the Caribbean coast, the city was originally known as "Belize Town" but later changed its name to Belize City as the population grew. Belize City was the capital of the country for more than a century, but after a severe storm hit in 1961, the government decided to move the capital further inland to Belmopan.
All international flights arrive at the Philip Goldson International Airport (BZE) which is in Ladyville, approximately nine miles north of Belize City. Most cruise ships make port in Belize City, making Belize City the first place in Belize that most foreign visitors see.
Originally a small Maya city named Holzuz, Belize Town was founded in 1638 by the earliest English colonizers who used the port to export valuable hardwoods.
The area of Belize City has many buildings from the colonial era that are now popular tourist attractions. These include:
St. John's Cathedral – Still a working Anglican church, this is one of the oldest buildings in the country. It's main claim to fame is that it is the only Anglican cathedral outside of England where kings were crowned.
The Belize Museum – Formerly a prison during colonial times, the museum now has exhibitions on the people and history of Belize.
Baron Bliss Lighthouse – Built to the exact specifications of Baron Bliss, the eccentric benefactor of the country. Although he never set food on land in Belize, he fell in love with the people while aboard his yacht anchored offshore and donated millions of dollars to the country in his will.
Baron Bliss gravesite.
Other attractions inside the city limits include:
Travellers Distillery – Maker of the famous "One Barrel Rum."
Belikin Brewery – Maker of the country's most popular beers.
Nearby attractions include:
The Belize Zoo – A rescue center for orphaned and injured animals, the Belize Zoo has more than 100 indigenous species and is the only handicap-accessible facility of its kind in the country.
Old Belize – A kind of "theme park" representing the entire country, Old Belize has the Cucumber ("Kukumba") Beach marina, water slides, and historical exhibitions.
Tour Belize Auto Rental has two convenient locations in Belize, one in downtown Belize City and one at the international airport. Tour Belize Auto Rental has a fleet of modern vehicles perfect for exploring the historical attractions of Belize City as well as other popular destinations like San Ignacio, Dangriga, and Placencia.
715 Gibnut Street Belize City, Belize (Main Branch)
Philip S.W. Goldson International Airport ( airport branch)
Copyright © 2017 Tour Belize Auto Rental


LIVING STONES OF THE MAYA - Are you a Living Stone?
Many years ago, while in Tikal, I was awoken before dawn. I had an intense calling to go into the jungles of Tikal before sunrise. As I walked into the jungle, misty clouds clung to the trees. The first predawn light filtered through the jungle canopy giving a surreal feeling. I could hear the first bird awakening and calling in the day. It was wonderful to be in the site free from the tourist buzz. I thought I was going to the main plaza of Tikal, but instead I was drawn toward another path leading me toward the north.
I kept following my heart until I came to a standing stone. I could feel it call me. I sat behind it and placed my back against its back. As I did this, I was filled with grief, and yet, a deep remembrance entered my heart. The rest of the history of the Living Stones came back to me.
But before I get ahead of myself, maybe I should start at the beginning . . .
The Ancient ones (a.k.a. The Star Elders), over eons of time, have worked to find ways to anchor a highly rarified form of universal, spiritual light on the Earth. This light ignites the evolution of all life. They wanted to anchor this light to keep the Earth from going into total darkness during various predictable "dark" cycles. The dark cycles are necessary for evolutionary advancement and act like a womb to birth new and more advanced cycles of time on the Earth. Without this light, we would have ended up like the Moon or Mars.
While in these dark cycles, Earth is in a state that we might see similar to a planetary comma. During these "dark" cycles, it is not possible to let this type of rarified light out into the planet, since it would accelerate the darkness, as darkness is the dominant force during these times. So this light was anchored so it would not be totally lost; it was locked away for safe keeping until the planet woke up from its catatonic state. This anchoring created little threads of light that keep the planet tied to the universal source of all that is. After this was done, all they could do was wait for the "dark" cycle to end before releasing this light once again into the world.
The ancient ones anchored this rarified light in many ways over eons of time. Long before any recorded history, Star Beings anchored this rarified light in stones that are part of a universal living library. We know these stones today as the "Stones of Ica". You can still listen to them in a little museum just south of Lima, in Peru. Later on, Andean Masters had the ability to hold this rarified light in living mummies. They still speak to you if you have the ears to hear them. They are scattered all over the Andes.
The Egyptians locked this light in ones that had obtained a certain level of advancement. They locked them body and soul in magnetically sealed pyramids and tombs to hold the light there.
The most tangible and easiest way to experience this rarified light is in the Maya lands. Over the last 20 years, I have had the blessings to spend time in all the major Maya sites and many smaller sites. I feel that Palenque and its surrounding area, Tikal and its area, Copan and Quirigua, and the mystical valley between these two, to be the most vocal of the Maya areas. Many of the Living Stone Stela (carved standing stones) speak about different things for different reasons. They can hold maps of consciousness, maps of the universe, spiritual knowledge, sacred geometry, advanced technology (like time travel and immortality), and some keep doorways open for us to use to travel. This is just the tip of the pyramid by the way. There is much more for us to uncover.
Why this is important to you now . . .
So getting back to that morning in the jungles of Tikal . . . some of the history that was shared with me, I can pass onto you now. I have been holding onto this information for 9 years. Because of the events that transpired during our last trip to Tikal, I now I feel that I can share the rest of the story.
As I sat in the mist with my back to this living stela, I began to have a conversation with an old friend in the stone. I could feel his pain, joy and wisdom. It felt like what he told me happened yesterday, but it didn't. It happened a long time ago. He began to tell me things that I had forgotten, and maybe things that you forgot as well.
The Living Stone said . . . "There came a time in Tikal's ancient past that one of these planetary dark cycles was expected very soon. It was time to hide away the light and the ancient knowledge for a future time . . . that which you are entering now. We knew that it was going to get really messy, and we didn't want the light to be misused to accelerate the dark cycle. Europe was already in the dark ages. We (Star Elders) had held this cycle at bay for a time, but it was spreading across the ocean like a virus, and it was too close for our comfort. We were going to have to leave, because we too hold this rarified light that can not be present in a living form during a dark cycle."
I was shown the intense focus, effort and deep spiritual practice it took to anchor their souls in a stone while retaining all the knowledge, wisdom and light that they carried.
The Living Stone said . . . "Once you were ready, your soul was anchored into the stone by means of a ceremony of sorts.*** While focusing upon the stone that you had prepared for yourself with great care, you were swiftly, but cautiously released from your physical body, while you projected your consciousness into the stone. If you failed, there was no turning back, because your body was gone. If this happened, you had to reincarnate. This is a great loss, because when you reincarnate, you lose much of the wisdom and basically have to start over. Hundreds and hundreds of these brave advanced souls were lost in this way. They were my friends. . . and this still makes me sad. But the victory was that many did indeed anchor their souls in the stone for a future time."
I asked the Living Stone, "How did it feel when you entered the stone?" As he shared the story, I got a chill to the bone that had a huge d�j� vu vibe to it. This sounded familiar, and I bet it will give many of you out there the same feeling.
The Living Stone said . . . "When you enter the stone, you still feel alive, as if you were still in your body. This is why it is so important when you pass away that you leave your body and go through layers of cleansing and clearing, so you forget what is was like to breathe and move in physical form. Also, so you forget your wounds and most everything, so you can start fresh and clean in the next life."
He went on . . . "But when you anchor yourself in a stone, you can not breathe and can not move. I felt like I was drowning, but I could not die. You know what I mean . . . that split second of utter terror just before you reach the surface of the water to breathe. I couldn't move either, causing me the feeling of pain because I was getting stiff. You stay in that terror and pain for years! We volunteered to do this. It was our choice out of service and love. We wanted to do this. We knew what we were signing up for . . . BUT I don't think we had any idea how horrifying it would feel at first. It was hard to adjust to."
The Stone continued . . . "Years later, when we became accustomed to being 'alive' in a stone, we could relax and enjoy the view from the angle that we entered the stone. First thing that I noticed was that time is different in a stone. The grass grew right before my eyes. The sun would come up and go down in what feels like an hour for you. By this point, the site had been abandoned for some time. But once in awhile, someone would go by and look at me. I would try to speak to them but they could not hear me."
The time difference made great sense to me. I know that the longer I sit in a site, the more I can hear. This is why we are called to sit atop a pyramid and just be there.
The Stone heard me thinking . . . "RIGHT YOU ARE! If you move through a sacred site too fast, you are just a flash to us. You have to stay in at least an hour or more in one spot for a stone to see you at all. It takes time to make a connection, so we can converse."
The Stone shared . . . "Everyone became quite lonely. In the loneliness, we had time to watch and map the stars, and watch the cycles for the time that we could live outside the stone. If the stone you were in fell down, face first, it was a real disappointment, as we could not watch the stars and life on Earth any more. It was just dark. Archeologists have now set some of these stones back upright again. What a blessing! But some of us were placed facing the wrong direction. There was a great importance to the direction that we faced."
I asked "If your body was gone, how could you come out to live again? What would your physical bodies look like?" I quickly learned that a very small part of each soul was sent out to reincarnate during this anchoring ceremony. This small part of yourself would reincarnate over and over and have no memory of the light that was anchored in the stone. This insured that you would have yourself, a body, to come back into. This way the light in the stone would be safe until it was time to come out.
I asked the Living Stone "How would this small part know how to find you again?"
The Stone shared . . . "All these little parts of ourselves were set up on a cosmic time clock, and when the alarm sounded, we would feel an intense urge to search for something that was lost. In this searching, once the body gets close enough to the light in the stone, the body will have a download . . . a great spiritual awakening. This is a life changing moment."
Then I asked a question that is so important to us now . . .
"If you were a living stone, or had a connection with a living stone, how will it feel when we get a download from a stone?"
"Aside from the blissful spiritual awakening and feeling like you have purpose once again (this topic to be discussed later in an entire book; not an article), many strange and sometimes un-diagnosable health issues seem to arise. Because you are stuck in a stone, alive for hundreds, maybe thousands, of years, it causes a memory of being in that stone that sometimes is a part of the download you receive. The Star Elders had not anticipated these issues. Much of the training went into getting into the stone, and most didn't pay much attention about getting out again."
Are you a returning Living Stone?
"	Feel weird stiffness, aches and pains in the body for no reason that massage and other treatments seem to fail at helping?
"	Breath shallow or have trouble with asthma and sudden allergies?
"	Have frightful dreams of being alive, but everyone around you thinks that you are dead?
"	Have claustrophobia and dislike closed in spaces?
"	Have issues about being heard by others or find that you are too loud?
"	Have a sudden need to completely shift your life?
"	Have strange events in which time lines feel different?
"	Have trouble finding home or maintaining deep relationships?
"	Have a strange attraction to stones or live in a place with a lot of rock?
If this feels like you, and you feel you might be one of these beings who have begun the download process, just knowing this story can help you overcome the issues of re-entry quickly.
A simple re-entry process . . .
Call in Archangel Michael. Ask him to assist you in filtering the effects of the download. Ask that the memory of being alive in the stone is filtered out. Ask that everything you brought with you and placed into the stone, and all the things you learned while in the stone, can be brought forth into current memory in your physical body. This filter looks like a house screen that you keeps bugs out of your house. But this screen is like being inside a beach ball of screen. Ask that this screen be put in place around you through . . . All time, space and dimension . . . Past, present and future . . . Body, mind and spirit . . . 7 day a week, 24 hours a day, 365 day a year.
Every time you go to a place where your symptoms seem to get worse, tighten up the screen, so it filters out more. Sometimes re-entered ones can feel the effect of a sacred site quite physically, and this can be uncomfortable.
Empaths feel what the INCA MASTERS call Kausay Pacha (cowz-eye pah-chah) a world of living energy. Sensitive ones are known as QAWAQ (cow-wak) or seers of living energy. Empaths feel Taripaypacha (tah-ree-pie-pah-cha) with means we encounter the entire universe. It is also a word that refers to a new golden era. It is known as the age of meeting ourselves again, and heralds coming together again of the people, and the recreation of a new and better world. Are YOU are a part of this emerging world?


text:
The Economic Effects of Hydrofracturing on Local Economies
May 06, 2013 | Reports
In 2013, New York's state government will decide whether to permit extraction of natural gas by hydraulic fracturing or, instead, turn its current moratorium into a permanent ban on this technology. In weighing their choice, New York officials have an abundance of useful data from neighboring Pennsylvania. There, nearly 5,000 wells have been hydrofractured since 2002. If New York lifts its moratorium, companies will be drilling the same type of wells to exploit the same subterranean source of gas—the Marcellus Shale. Pennsylvania's experience is a good guide to what would happen in New York. In this paper, we analyze the effect of hydrofracturing—at modest, moderate, and high levels—on jobs and income growth in Pennsylvania counties. We then use these data to project the benefits that New York counties stand to gain if the state again permits hydrofracturing.
We find that:
Pennsylvania counties with hydrofractured gas wells have performed better across economic indicators than those that have no wells.
The more wells a county contains, the better it performed.
Between 2007 and 2011, per-capita income rose by 19 percent in Pennsylvania counties with more than 200 wells, by 14 percent in counties with between 20 and 200 wells, and by 12 percent in counties with fewer than 20 wells.
In counties without any hydrofractured wells, income went up by only 8 percent.
Counties with the lowest per-capita incomes experienced the most rapid growth.
Counties with more than 200 wells added jobs at a 7 percent annual rate over the same time period.
Where there was no drilling, or only a few wells, the number of county jobs shrank by 3 percent.
Using the Pennsylvania data to project hydrofracking's effect on New York counties, we find that the income of residents in the 28 New York counties above the Marcellus Shale has the potential to expand by 15 percent or more over the next four years—if the state's moratorium is lifted.
Our data also suggest that had New York allowed its counties to fully exploit the Marcellus Shale, those counties would have seen income-growth rates of up to 15 percent for a given four-year period, or as much as 6 percent more than they are experiencing.
Large parts of Pennsylvania and western New York are located above the Marcellus Shale, a vast subterranean expanse of rock that is estimated to contain up to 489 trillion cubic1 feet of natural gas. Pennsylvania has allowed companies to extract natural gas with the technique known as hydraulic fracturing, hydrofracturing, or, as its vociferous opponents like to call it, "fracking." Usually, this method is combined with horizontal drilling (in which the drill turns off the vertical to extend horizontally through the rock formation, allowing more of it to be tapped). Today, many Pennsylvania counties are bustling with this "unconventional drilling."
In neighboring New York, all is quiet. Although New York once al- lowed hydraulic fracturing and horizontal drilling,2 the state placed a moratorium on the technique in 2010. This year, the state government will either end that moratorium or make it permanent. While New York ponders, drilling companies hold their pre-2010 leases on land, uncertain whether they will ever be able to use the resources beneath.
Any reasonable decision about hydrofracturing will weigh its costs against benefits. One of these benefits is economic growth in the areas where modern drilling techniques are used. A broad analysis of hydraulic fracturing by the Yale Graduates in Energy Study Group compared the cost of repairing potential environmental damage with a projection of likely benefit to consumers as well as producers.3 The study concluded that benefits exceeded costs by a factor of up to 400.
This paper aims to inform the New York debate by assessing the economic benefits of hydrofracturing on counties in neighboring Pennsylvania. We find that:
Those counties in Pennsylvania that contain hydrofractured gas wells have performed better across economic indicators than those that do not.
Economic performance correlates with a county's number of such wells and therefore is best among the counties most prolific in hydrofracturing.
Pennsylvania's counties are narrowing the economic growth-rate gap that existed between them and New York's counties, and this is most pronounced in counties where many hydrofractured wells have been drilled.
Income of residents in the 28 New York counties above the Marcellus Shale has the potential to expand by 15 percent or more over the next four years if the state's moratorium is lifted.
Between 2007 and 2011, per-capita income rose by 19 percent in Pennsylvania counties with more than 200 wells, by 14 percent in counties with between 20 and 200 wells, and by 12 percent in counties with fewer than 20 wells. In counties without any hydrofracking wells, income went up by only 8 percent. It is important to note, too, that counties with the lowest per-capita incomes experienced the most rapid growth. Moreover, counties with more than 200 wells added jobs at a 7 percent annual rate over the same time period. Where there was no drilling, or only a few wells, the number of county jobs shrank by 3 percent.
Similar benefits could also be realized by residents of New York State, and they would not have long to wait: shale gas drilling start-up expenditures make the first hydraulically fractured wells especially lucrative for a local economy. We calculate that a New York county that permits the drilling of a mere 20 wells could, in a four-year period, see per-capita income rise 3 percent more than it would have if no wells had been drilled. If all New York counties above the Marcellus Shale were to pursue this course, our estimate is that they would collectively have $4.2 billion more in income just in the last year of that four-year period. On the other hand, drilling 400 wells in a county, which some Pennsylvania counties have done in a similar time frame, could raise incomes by over 6 percent, with commensurate increases in statewide gains. Tax revenues would increase with incomes.
BACKGROUND AND METHOD
University of Wyoming professor Timothy Considine and Penn State professor Robert Watson have completed multiple studies specifically concerning the economic effects of the Marcellus Shale. They estimate that, in 2009, more than 44,000 Pennsylvania jobs were created because of the local shale gas drilling industry, through direct employment and the indirect and induced effects of the industry's equipment purchases and land royalties. Their input- output models also show that $3.87 billion in total value was added to the Pennsylvania economy because of the Marcellus drillers' activities.4
Modeling the New York economy in a similar fashion, Considine and Watson project that a reopening of that state's shale formation to hydrofracturing could result in $11.4 billion in economic output and create 15,000 to 18,000 jobs in southwestern counties (Allegany, Steuben, Chemung, Tioga, and Broome) alone.5
The New York State Department of Environmental Conservation (NYSDEC) commissioned a study of potential hydrofracturing-spurred growth in the state in 2009, finally addressing the full results in a 2011 release. The authors estimated that with an average projection for growth, hydraulic fracturing would directly create nearly 25,000 jobs in well construction and operation, as well as 29,000 jobs in indirectly influenced industries such as transportation.6 These 54,000 jobs would, in 2010, have represented approximately 0.7 percent of the labor force. This is a significant number at any time; but in 2010, it would have been especially high, with New York's unemployment rate then exceeding 8 percent.
Our inquiry focuses on job and income growth—the direct benefits from expanded drilling operations. Thanks to the contrasting policies of Pennsylvania and New York, there is no need for hypothetical projections to examine what exploration of the Marcellus Shale might do for New York's economy. Moreover, counties within Pennsylvania differ widely in the extent of their exploitation of natural gas resources. These circumstances provide a rich vein of comparative information with which to estimate the potential benefits of hydrofracturing in New York.
Using data from the Pennsylvania Department of Environmental Protection, the Bureau of Labor Statistics, and the Bureau of Economic Analysis, we have found a correlation between the presence and scale of hydraulic fracturing operations in a particular county, on the one hand, and improvement in economic indicators, on the other.
First, we compare average measures of economic growth among counties that are at different levels of Marcellus Shale development. This allows us to estimate whether the existence of shale energy reserves, along with the use of hydraulic fracturing to access those reserves, has offered an economic benefit to residents of individual counties.
Second, we perform a regression analysis, which suggests what specific economic effects might be predicted for Marcellus Shale counties in New York if the drilling moratorium ended. These analyses make clear the economic benefits of hydraulic fracturing.
Economic effects are just one part of a decision on the societal usefulness of hydraulic fracturing. But well-paying jobs and more tax revenue are important to consider in such an evaluation. Therefore, measuring the effects of hydrofracturing on local economies is an important step toward a fair and useful assessment of this approach to energy extraction.
The number of horizontal, hydraulically fractured wells drilled in each of the 67 Pennsylvania counties from 2002 to 2011 is available in tables at the Pennsylvania Department of Environmental Protection website.7 The "unconventional" category encompasses the relevant sets of hydrofractured wells. Numbers of such wells were low until 2007, when unconventional well-drilling began in earnest in Pennsylvania. (See Table 1 for annual and total unconventional-well counts for 2002–11.)
Based on the total number of unconventional wells drilled between 2002 and 2011, we divided counties into four groups: those counties that did no drilling of this type at all (30 counties); those that participated marginally in unconventional drilling, with fewer than 20 wells (15); those that drilled between 20 and 200 wells (16); and those that drilled more than 200 (6). All six counties in the last category contained at least 409 unconventionally drilled wells by 2011.
Map 1 displays these distinctions in a color-coded visual format.
Data were collected and analyzed for a variety of county-by-county metrics, including income and jobs totals, population levels, per-capita income levels, and unemployment rates, all on an annual basis.8 County- level economic data are available only through 2011, so that is the last year considered in this study. All periodic economic assessments were made for 2007–11, during which time significant amounts of well-drilling were done in Pennsylvania counties.
We measure changes in economic growth in 2007–11 through the use of three variables: the total number of jobs; the rate of unemployment; and per-capita personal income in each county. Per-capita income values are not adjusted for inflation, but comparisons of percentage change across counties and states will not be influenced by changes in this common variable.
In the analysis, we had to determine how much, if any, of each county sits on the Marcellus Shale. Most of the state's counties are either on the Marcellus entirely or not on it at all. In the few cases in which county borders encompassed some land on the Marcellus Shale and some not, we made a visual judgment about its status. We then designated a county as having access to the Marcellus Shale if one-third or more of its land sits on the formation. These assignments were made based on maps provided by the Pennsylvania Department of Environmental Protection.9 For our comparative analysis of New York counties, we used a similar map provided by the New York State Department of Environmental Conservation.10
RESULTS BY COUNTY GROUP
As we have mentioned, in order to assess potential effects of natural gas drilling on economic performance in New York counties, it is useful to examine various experiences in Pennsylvania. To that end, economic indicator averages were calculated for our four groupings, based on the amount of drilling, of Pennsylvania counties. Between 2007 and 2011, per- capita personal income levels rose about 8 percent in those counties with no unconventional wells drilled; and 12 percent where fewer than 20 wells were drilled. In contrast, income levels rose 14 percent in counties with more than 20, but fewer than 200, wells; and 19 percent in the counties with the most hydrofracturing wells.
Some counties drilled no wells because they have no known resources. However, the effect—more wells correlating with more prosperity—holds when we examine only counties that have access to the Marcellus Shale. For those counties, the ones in which no wells were drilled saw 9 percent per-capita income growth. That is not much different from the overall average for the no-wells group and far below the average for counties with many wells.
Among counties with no wells, the one that experienced the most growth was Philadelphia County, at over 15 percent. This is unsurprising; a heavily populated urban county should be an outlier in the generally more rural and more sparsely populated state of Pennsylvania. Philadelphia's economic performance is likely the least relevant when we seek to compare those counties that could benefit from oil and gas drilling. Of the remaining 29 Pennsylvania counties without unconventional wells, only two—Union and Northumberland—exceeded 14 percent income growth, the average rate experienced by counties in the 20–200 well group.
Meanwhile, employment growth in Pennsylvania counties, measured as the percentage change in jobs from 2007 to 2011, tells a somewhat similar story, though the effect becomes pronounced only in the more prolific unconventional-well-drilling counties. Where there was no such drilling, the number of jobs shrank in each county by an average of 3.27 percent. Counties with fewer than 20 unconventional wells improved only marginally on this number, losing 3.23 percent of jobs on average.
However, those counties with between 20 and 200 wells lost, on average, less than 1 percent of their jobs. Finally, the most striking value is the growth of employment in the heavy-drilling group. These counties added jobs at an average rate of 7.67 percent. None of the six counties with more than 200 unconventional wells failed to add jobs in 2007–11, despite the economic turmoil that gripped the rest of the state—and the nation—during this period.
In fact, each of these six counties had a higher rate of job creation than any of the other 61 Pennsylvania counties save two: Butler, in which 105 unconventional wells were drilled; and Montour, which had a 12 percent increase in job creation (though it has no wells).11
Unemployment rates display the same trend. They increased, on average, by only 2.2 percentage points in the heavy-drilling counties but by 3.7 points in counties with no unconventional drilling. The shale-land counties with no wells fared worst, averaging an increase in their unemployment rate of over 3.8 percentage points.
EXTRAPOLATING RESULTS TO NEW YORK STATE
Pennsylvania counties where hydraulic fracturing takes place have performed better economically on average than those with little or no such drilling. If New York State lifts its moratorium, the same drivers of growth will be in place, and their effect can be estimated.
We analyzed regressions of an economic indicator on variables associated with hydraulic fracturing. This allowed us to specify the influence of drilling on growth. Our per-capita income-growth variable was regressed on natural logarithms of the values of possible causal factors, including the number of hydraulic fracturing wells drilled. To be sure that the calculated effects of drilling do not encompass the actual influence of other variables, income growth was also regressed on the natural logarithms of population and base-year (2007) income in each Pennsylvania county, as well as the square of base-year income. Population levels were found to have a negligible effect, independent of other tested variables. However, 2007 income showed a negative correlation with growth rates. This negative correlation diminished somewhat at higher base-year income levels.
In the 2007–11 period, those Pennsylvania counties with the lowest per-capita incomes experienced the most rapid growth. This will bear some connection with the correlation between growth and hydraulic fracturing levels, which were somewhat higher in poorer areas. This connection is not enough to suggest that natural gas drilling by itself was the prominent factor in economic performance in these burgeoning areas. It merely shows that, for the relevant period, county incomes converged.
Details of the statistical analysis are provided in the Appendix. The results of the analysis indicate that the increase in income growth provided by the drilling of one well is proportional to the percent increase in the number of wells represented by the one new well, at a rate of 0.01006. For the sake of discussion, we can approximate this with 0.01.
For instance, if a county has five hydrofractured wells, the drilling of one more such well represents a 20 percent increase in the total. Twenty times 0.01 yields 0.2, so the model predicts that this county will experience 0.2 percent greater income growth over a four-year period. In a county starting with 40 wells, one new well would represent a 2.5 percent increase, and 2.5 times 0.01 is 0.025. A county with 40 wells can therefore expect to see a 0.025 percent increase in four-year per-capita income growth in conjunction with one new well, based on our model.
While these rate increases appear small on a per-well basis, they are cumulatively very important. For a given county with a given base income level, we project that permitting 50 hydraulically fractured wells throughout a four-year period will cause incomes to grow 3.95 percent more in that period than they would have with no wells. At 400 wells—a number that was exceeded by the six most active hydrofracturing counties in Pennsylvania from 2007 to 2011—the expected income growth is over 6 percent.
These increases represent an average of thousands of dollars more in the pocket of each earner within the county's economy, and up to $8.3 billion in personal income for the Pennsylvania counties above the Marcellus Shale.
As one would expect, the model predicts a diminishing per-well effect. In order to drill initial unconventional wells, the natural gas industry would need to inject more resources into the local economy by leasing land, purchasing equipment, hiring workers, and making other start-up outlays. Later wells will not require such a level of investment. However, in a logarithmic model such as that presented, the influence of a particular variable never diminishes to zero. Even adding one well to 400 will have some positive effect on income.
In addition, the expansion of hydraulic fracturing in Pennsylvania was only a few years old as of 2011, where the data for this study end. It is reasonable to hypothesize that once most of the start-up benefits have been reaped, a linear relationship between drilling and growth will emerge, and per-well benefits will persist rather than decline.
Importantly, our model, though quite simple in projecting income growth based solely on current income levels and the number of hydraulically fractured wells to be drilled, nonetheless accounts for half of the total variation in growth rates among counties. There is little to suggest a relevant inherent difference between the economy in Pennsylvania and economies in other states that face hydrofracturing decisions. Therefore, it is not unreasonable to think that the results of our regressions indicate the benefits that would accrue to areas outside Pennsylvania, should they allow the process to be used to recover natural gas. With this in mind, we examine the potential economic benefits to New York State of lifting the hydrofracturing moratorium.
POTENTIAL EFFECTS OF HYDROFRACTURING ON NEW YORK STATE
Twenty-eight counties in New York lie above the Marcellus Shale. These range from Onondaga in the north to Sullivan in the south, and from Greene in the east to Chautauqua in the west. Our model can estimate their added income-growth potential due to the presence of shale gas.
Table 2 shows the projected effects on various counties for different levels of hydrofracturing. The latest income data are for 2011. If hydrofracturing had been permitted in New York just as it was in Pennsylvania, we would expect to see significant effects by 2015 in New York. In the 50 Pennsylvania counties lying above the Marcellus, an average of 52.3 wells per county were hydraulically fractured from 2007 to 2011, so this figure provides a guide to what could have happened in New York.
Consider the example of Chemung County, which in 2011 had a per-capita income of under $36,000, about average for the New York Marcellus counties. Under the hydrofracturing moratorium, our model projects that Chemung will see a per-capita income of over $38,000 in 2015, a 7 percent increase. Total annual income would have increased by $231 million.
However, if hydrofracturing were permitted in Chemung, natural gas extraction start-up and the drilling of just 20 unconventional wells through the period would have brought per-capita income up to an estimated $39,207, an increase of over 10 percent. Well-drilling at the average Pennsylvania rate of 52.3 wells in 2011–15 would bring another full percent of income growth, to $39,540.
This average level of hydraulic fracturing would represent, for Chemung as well as for the other New York counties, an increase in income-growth rates of 4 percentage points. The county would have seen an increase in annual income of $357 million, or $126 million more than the case of no hydrofracturing.
The five most prolific counties in Pennsylvania had more than 400 natural gas wells hydraulically fractured in a similar period. At that high rate of production, Chemung would be expected to see average income easily surpass the $40,000 mark by 2015.
Table 2 also displays the effect that certain per-county levels of unconventional drilling could have on total personal income per year in the counties concerned. Income is projected to grow by $4.2 billion more if counties have an average of 20 wells. This figure increases to $5.5 billion at the average level of well-drilling found in Pennsylvania: 52 wells per county. At 400 wells per county, New York would gain another $8.3 billion in revenue by lifting the moratorium. These personal income gains would increase tax revenues and do not take into account potential residual activity and benefits for nearby counties that do not sit on the Marcellus Shale.
Of course, each county will choose its own quantity of wells. But even at levels of development far below the maximum, our analysis estimates that billions of dollars could accrue to local economies if hydrofracturing is permitted in New York State.
We have shown that Pennsylvania counties with hydraulic fracturing had higher economic growth rates than those without. The results also reveal that a greater number of wells correlated with a higher rate of economic growth. These results could equally well be applied to counties in New York and other states, from California to West Virginia, that have the potential to drill for oil and natural gas. They suggest that over the past decade, had New York State counties on the Marcellus Shale been allowed to use these resources, economic growth would have been substantially higher—at up to 15 percent for a given four-year period, or 6 percent greater than would otherwise be expected. This corresponds to a potential $8 billion in extra income in upstate New York.
The various benefits discussed here are within relatively easy reach for the state of New York. Figures 1–6 show the proportion of electrical power generated from various energy sources by Pennsylvania and New York in 2000, 2006, and 2010. Much can be gleaned from these figures.
New York already generates a fair amount of its power using natural gas. This means that it has the infrastructure available to take advantage of this resource once obtained. But it also means that New York's power must either be limited by its moratorium on its own Marcellus resources or dependent on imports from other areas for expansion. New natural gas production spurred by hydraulic fracturing would constitute an in-state energy supply, attracting more manufacturing back to the state.
As we have noted, decisions about the societal value of hydraulic fracturing must reckon with many considerations. But in balancing the costs and risks against the benefits, it is important to be precise about those benefits. Counting, as the physicist Lewis Fry Richardson used to say, is an antiseptic against prejudice. By our count, there are immediate and concrete benefits in hydrofracturing wells: more money in the pockets of the people, more tax revenue for the state. These data deserve close attention and consideration as New York State confronts its decision.
In the analysis of Pennsylvania counties, a dummy variable was established for whether each county sits on the Marcellus Shale. This variable serves to allow consideration of those counties to which the questions of hydraulic fracturing are most immediately pertinent. Counties that sit atop the shale were assigned a 1 for this variable, while those that do not were assigned a 0. In the few cases in which only parts of a county sat on the Marcellus Shale, a visual judgment was made as to the dummy-variable designation. If approximately one-third or more of a county's land sits on the Marcellus Shale, it was categorized as having access to the shale and assigned a 1. Dummy-variable assignments were made based on maps provided by the Pennsylvania Department of Environmental Protection.12 A similar map for the Empire State is provided by the New York State Department of Environmental Conservation.13 In the final regression analysis of Pennsylvania counties, this equation is specified:
y = .01006(In(wells + 1)) – 3.99905(ln(y07)) + .18474(ln(y07))2 + 22.69351
"y" is the ratio of per-capita income in 2011 to that in 2007. "In(wells+1)" represents the natural log of one more than the number of hydrofractured wells drilled in the given county through 2011. 1 is added to the number of wells to permit logarithmic calculations for counties with zero such wells. "In(y07)" represents the natural lg of per-capita income in 2007, the base year for this exercise. All coefficients are statistically significant (see Table A-1 below for t-test values).
This model projects an increased per-capita income growth, over a four-year period, of at least 3 percent for a county permitting 20 unconventional wells and over 5 percentage points for a county permitting 200 such wells, given current income levels. For example, the lowest-earning New York county, Allegany, shows an increase of 3.0 percentage points with 20 wells and 5.3 percent with 200 wells. The highest-earning county with the shale land, Albany, would gain 3.1 percent with 20 wells and 5.4 with 200.
Thus, while the coefficient for wells appears small, it is both statistically significant and qualitatively meaningful. Natural logarithms of per-capita income levels, which are all of the same order of magnitude, are similar, and variation in well-drilling is estimated to have an important effect.
As we have noted, this model explains approximately half of the variation in income growth since 2002 among the Pennsylvania counties sampled, as evidenced by the adjusted R-squared value appearing below in Table A-1. So while there is a fair amount of variation in income-growth projections in this model, a good deal of that variation is captured by counts of hydrofractured wells.
Refer to PDF for Endnotes
Pennsylvania counties with hydraulic fracturing had higher economic growth rates than those without
Download as PDF Back to top


front and back sockets for phone chargers.
AIR CONDITIONING. POWER STEERING. ELECTRIC WINDOWS. ELECTRIC MIRRORS. 2AIRBAGS. CENTRAL LOCKING. PROJECTORS. ALLOY WHEELS.
Air Conditioning [Climate control]. Alloy wheels. Gear change paddles. Electric windows and door mirrors. Power steering. Cruise control. Radio CD. ABS. Traction.
Phone Dora Tel 99449609 - Ymorphites@gmail.com.


Start with clean nails. We went for short rounded nails since it's pretty trendy lately and it's convenient.
Brush on a coat (or two, if you prefer) of the neutral base colour. We chose this colour as it reminded us of mocha ice cream.
Paint on "drips" by starting with two or three stripes (shown on the fourth finger), then fill in the gaps (shown on the first finger). We chose pink polish since it looks like strawberry sauce!
Continue doing so for all your fingers except the middle (or an accent finger of your choice).
Paint on "drips" in mint nail polish.
Follow up with a top coat to seal in your work, clean up any messes, and you're good to go!
With this easy tutorial, you too can wear ice cream on your nails!
For many parts of the world, it's almost time for autumn. Meanwhile in sunny Singapore, we're still enjoying permanent summer, so why not make the most out of the weather and go for some refreshing ice cream… on your nails?
If you're up for it, you can always paint on little sprinkles on the tips of your nails to add to the ice cream theme. For people who are more into the macabre side of things (or just getting ready for Halloween, you know), you can always switch out the bright nail polishes for a dark red to simulate dripping blood.
Do take due care to let each layer of your polish dry before moving on, or you'll risk smearing the colours together! Have fun with the manicure and don't forget to show us your nails by using the hashtag #ManicureFriday on Instagram!