Greetings,
You can now test Chorale!
In case you forgot: You requested early access to Chorale, a music app for listeners and creators.
With that out of the way, here’s the juicy stuff:
|
The desktop web app can be accessed from web.choraleapp.com on the latest version of Chrome, Firefox, or Safari. The app may not work with other browsers such as Microsoft Edge and is guaranteed to break in amazing ways on all versions of Internet Explorer. Because Internet Explorer is awful.
A dedicated Windows, macOS, or Linux version of the Chorale desktop app is not currently available, but that’s on our radar for sure. We will most likely start with Linux to make you feel bad, then move on to Windows. A macOS desktop app will not be available until a developer that has a some-thousand dollar machine can help us compile the app, though.
Mobile apps are currently still in development.
Make sure you have joined our Discord! Stay active on the guild if you want in-progress updates or want to contribute to the development of the project. Join with this link: discord.io/choraleapp
And one last thing: Be vocal about the app! Please, do not hesitate to ask us any questions, do not hesitate to ask for new features, or anything of the like. Visit www.choraleapp.com to talk to us!
Thank you for being a part of the Chorale Tester Program! Have a nice day!


EMPTY_FORMAT_MAPPER_NG
Documentation du Custom Transformer FME
Description:
Custom transformer used to fill the resources{}.format when the format is missing or empty. The custom is using the corresponding resources{}.url to extract the format.
In a first step, the custom transformer will analyse the URL:
- if the url contains the substring "service=wms" the format is WMS
- if the url contains the substring "mapserver" or "featureserver" the format is ESRI REST
- if the url ends with a file format extension (ex.: .shp) it takes the extension as the file format; except if the extension is .zip where it tries to find the original file format before being zipped (like CSV for the following url: blablabla.csv.zip)
In a second step, the custom transformer will validate that the format extracted with the preceding rules is a valid format by checking if the format is present in the table Format.csv.
In a third step, if the format is still unknown (format="other"), the custom transformer extract the MIME-content of header of the URL. The MIME-content is than used to extract the format from the CSV file Mime_type.csv
Parameters
- CSV_FORMAT: Name of the CSV table containing the list of valid fromat for the resources.
- CSV_MIME_TYPE: Name of the CSV table containing the MIME-type and the corresponding format.
- IN_CSV_LOOKUP_TABLES_DIR: Name of the directoty containing the lookup tables.
- P-T_ABBR: Two letter abbreviation of the province (ex: ON for Ontario)
- URL_VALIDATION: Flag used to extract the header of the URL, can take two values: Yes: Extract the header in order to get the MIME-type; No: Do not extract the header.
Input Ports
- DATA_INPUT: The input features to process
OUTPUT Ports
- DATA_OUTPUT: The processed output features
- UNKNOWN_MIME_TYPE: The features with a MIME-TYPE not present in the MIME-type CSV file.
Documentation du code EMPTY_FORMAT_MAPPER_NG.py
- class EMPTY_FORMAT_MAPPER_NG.FeatureProcessor[source]
Bases:
object
- __init__()[source]
Contructor of the class.
Create the necessary list and dictionary
- Parameters
None –
- Return type
None
- close()[source]
Method call once all the feature are read.
The method processes each FME feature to determine the format.
- Parameters
None –
- Return type
None
- input(feature)[source]
Method called for each FME feature.
The method places each feature in the corresponding data structure depending on the order attribute
- Parameters
feature (FME_Feature) – Feature to process
- Return type
None
- process_feature(feature)[source]
This method add a format to ressources with empty format.
This method is analysing the content of the url to determine the format. It searches for substring (ex.: service=wms) or extensions (ex.: .shp).
If the format is still unknown, it extracts the format from the MIME-type of the HTTP URL call.
- Parameters
feature (FME feature) – FME feature to process
- Return type
None


For my final piece for the Local Music and Local Politics series, I discussed the history of New York City’s infamous “cabaret law.” The law banned dancing in venues that did not possess a “cabaret license,” which was infamously hard to get and maintain. The law was passed during the Prohibition era to crack down on speakeasies, but stayed on the books for 91 years, until it was repealed in 2017. This originally aired on March 9, 2018.
Further reading:
Everything You Need to Know About New York's No-Dancing Law, Vice
After 91 Years, New York Will Let Its People Boogie, New York Times
With Its 'No Dancing' Law Verging On Repeal, New York Legitimizes Its Nightlife, NPR
Ninety Years and Counting for New York City’s Outdated Cabaret Law, Metro
Cabaret Law Repeal Lets New York City Dance - As Long As You're Zoned for It, City and State NY
Role Call on the Repeal, New York City Council


The story of Svalegaarden in Hasseris
In 1952, the beautiful grocery farm was
rebuilt on the
corner of Thorsens Allé and Svalegårdsvej, and the farm
was also renamed Svalegaarden. The idyllic farm always
stands at the same address, and has set the stage for
many events and experiences over the years.
In June 2016, Svalegaarden got new tenants with a new
spirit and bright hopes for the future
- Mette and Stefan from the former
Restaurant Mest.
Mette and Stefan come with new strength and fresh eyes
on the beautiful renovated grocery farm, which has so
far functioned as a company business.
Mette and Stefan have a vision to take
the best from Restaurant Mest and continue it in the
farm's beautiful setting in the heart of Aalborg.
The thoughts behind Svalegaarden Mest are gastronomy
meets rural idyll, where the focus is on creating
memorable experiences.


The GpioEnum enum defines the available GPIOs on the Beaglebone Black. The source code below lists all possible GPIO values. There are gaps in this list because some GPIO's, although theoretically present, are not exposed on the P8 and P9 headers as pins and hence cannot be used.
The GPIOs are not exposed on the P8 or P9 header in any particularly logical order. You must refer to the Beaglebone Black P8 or P9 header pinouts in order to determine on which header and pin the GPIO appears.
The source code below lists all possible GPIO values. You CAN NOT assume that, by default, any particular GPIO is available for use on your Beaglebone Black and that it is configured correctly as an input or output. Any one GPIO can be used for over half a dozen different peripherals (UART, SPI bus, PWM, A/D etc). In particular, the HDMI display and the EMMC memory use large swathes of the available GPIO range. Simply just picking a GPIO at random and using it could cause a great deal of trouble and possibly physical damage to your Beaglebone Black.
Before using any BBBCSIO Port class on a GPIO you will need to ensure that the GPIO is actually configured in the PinMux as a GPIO and also that it is also set appropriately as an input or output. There is no code you can call in the BBBCSIO library which does this. You MUST configure the GPIO externally prior to running your executable - usually this is done by editing the device tree.
public enum GpioEnum { GPIO_NONE, GPIO_2, GPIO_3, GPIO_4, GPIO_5, GPIO_7, GPIO_8, GPIO_9, GPIO_10, GPIO_11, GPIO_12, GPIO_13, GPIO_14, GPIO_15, GPIO_20, GPIO_22, GPIO_23, GPIO_26, GPIO_27, GPIO_30, GPIO_31, GPIO_32, GPIO_33, GPIO_34, GPIO_35, GPIO_36, GPIO_37, GPIO_38, GPIO_39, GPIO_44, GPIO_45, GPIO_46, GPIO_47, GPIO_48, GPIO_49, GPIO_50, GPIO_51, GPIO_60, GPIO_61, GPIO_62, GPIO_63, GPIO_65, GPIO_66, GPIO_67, GPIO_68, GPIO_69, GPIO_70, GPIO_71, GPIO_72, GPIO_73, GPIO_74, GPIO_75, GPIO_76, GPIO_77, GPIO_78, GPIO_79, GPIO_80, GPIO_81, GPIO_86, GPIO_87, GPIO_88, GPIO_89, GPIO_110, GPIO_111, GPIO_112, GPIO_113, GPIO_115, GPIO_117 }


COTTON MARY A film review by Steve Rhodes Copyright 2000 Steve Rhodes RATING (0 TO ****): **
Set along the Malabar Coast in India in 1954, COTTON MARY is by Merchant-Ivory Productions, a group so famous for costume dramas that they probably hold several patents on the genre. COTTON MARY does a marvelous job of displaying the sights and sounds of the era but a miserable job of doing much more.
At the center of the drama is a chatty, vain and strange woman called Cotton Mary. Mary is played by Madhur Jaffrey as a woman so unlikable that she becomes an obnoxious, cliché of a villain. Wearing her prejudice on her sleeve, Mary hates Indians because she thinks she is better than them since she is Anglo-Indian. "These Indian nurses don't know anything," nurse Mary informs Lily Macintosh (Greta Scacchi), who is having trouble producing any milk for her newborn baby. "I'm half-English!" Mary reassures Lily. Mary is also a thief and a liar, among her other despicable traits.
A sickly and depressed woman, Lily is so out of touch with reality that the story would have us believe that she doesn't even know how her own baby is being fed. The baby's nourishment comes from the breasts of Mary's sister. In an attempt to get her own milk production going, Lily keeps going to her doctor, who tells her that it's all in her mind,.
Lily's husband, John (James Wilby), works as a reporter for the BBC World Service. When his body makes its infrequent appearances at home, his mind remains firmly elsewhere. Even at work, he is just as out to lunch as his wife. When interviewing some poor workers, he tells them he is just like them since his father was a union man. Living a life of luxury with servants, a big house and a private club, he is, of course, nothing at all like them.
After sketching out his characters, writer Alexandra Viets, who based the script on her play, never gets around to filling them in. Director Ismail Merchant stages some lovely scenes of evening festivals but is never able to make up for the lack of a compelling script.
This is the second film in less than a month about the stilted views of Ango-Somethings -- the other was THE LAST SEPTEMBER about the Anglo-Irish. One wonders if this is another one of those cinematic trends that studios seem to love. Are we shortly going to have stories about the Anglo-Africans, the Anglo-Jamaicans, and who knows who else? If we do, let's hope the next one in the series finally finds a script worthy of the subject.
COTTON MARY runs a long 2:03. It is rated R for a scene of sexuality and would be acceptable for teenagers.
Email<EMAIL_ADDRESS>Web: http://www.InternetReviews.com
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


HTML, CSS and DOM - Udacity Tutorial Part Two: My Thoughts
What is grid based design?
Grid based design uses rows and columns to from the structure of a webpage. The most common layout seems to be 12 x 12 as most web devs use 3, 4 and 5 column layouts. 12 x 12 supports all these.
Whats all the hype about responsive webpages?
Responsive design is important because we live in an age where people are accessing the web from any number of different devices. The use of smartphones to browse the internet is increasing at a massive rate. Personally I think that responsive design is especially important from an accessibility perspective. Many people cannot afford to own laptops or desktops, so they use their phones for all digital needs. Certainly this is the case where I grew up. By ignoring principles of responsive design we could be unwittingly perpetuating some quite destructive social tendencies.
Semantic structure
Interesting to note the difference in opinion on the h1 - h6 elements. Some seem to say it comes down to specificity of the content, while others seem to use it as a way to style their headings. It seems irrelevent to use it for styling if we're going to be using CSS to style anyway.
Any other points you found interesting and want to reflect on
Pretty keen to explore the overflow element as well as play more with @media. I have a feeling the latter might take me a while to get used to.


System Architect Symbol details for "Activity Type Offered"
AAT/essential type (Generalization Node)
- Base Class:
"Agent's Activity Type"
- Definitions Used:
-
Agent's Activity Type (Class)
Activity Type Offered (Class)
- Description:
-
An "Activity Type" that an "Agent" makes a general offer to perform.
- Comment:
There is no need for any authorisation for this type of offer - it can be offered by a "Free Agent".
Example would be setting up a business to supply goods that are not regulated by legislation (i.e.
a pharmacists shop would not be covered by this type.)
Agent's Activity Type (Class)
- Description:
A means of establishing that an "Agent" may perform, offer to perform or authorise others to perform
certain "Activity Types".
- Comment:
For examples see subtypes.
Authorised Agent Activity (Class)
- Description:
"Activity Type for Agent" that is subject to some type of authorisation or external control.
- Comment:
Such control can be interdictions, permissions and exceptions (including "Activity State Types") to
one or many Activity Types.


Uma Bangalore
Work
About
Github
LinkedIn
Twitter
Repos from my Code Fellows class
Coding Projects Go Here
Welcome to my Blog
Some of my interests:
Coding
Sharing what I've learned
Hanging out with my family


Event Processing Platform
Automate your Apps
We automate your various apps so you don't have to do it
Login
Email address
Password
Login
Sign in with Google
Register yourself here
Invalid Login
×
Invalid username or password


dvgrd
Asraya is a registered voluntary organization (Reg. No. T 1684/99) founded in 1996. It all started when Mrs. Santha Jose happened to accompany one of her relatives, a cancer patient, to the Regional Cancer Centre in Trivandrum for treatment. The plight of hundreds of cancer patients struggling with the same disease moved her so much that she firmly resolved to make a difference in their lives. This idea was shared with a group of like-minded ladies and they met the Director of RCC, Dr. M. Krishnan Nair, Dr. Paul Sebastian, HOD of Head and Neck, and the Chief Nursing Superintendent, Sister Vijaya with this vision in mind.


At the time of this writing, Spring 3.0 isn’t out yet, but that doesn’t mean we can’t start goofing around with the nightly snapshots. I’ve been doing just that, and in this article I’ll show you how to publish an RSS feed using the new AbstractRssFeedView
class from Spring 3.0.
Those familiar with Spring Modules might recognize our view class. It began life as AbstractRssView
in the Spring Modules project. But as of Spring 3.0, it’s now a first-class member of the framework (though it’s been renamed to AbstractRssFeedView
), along with the AbstractAtomFeedView
class for Atom feeds, and the AbstractFeedView
, which serves as a base class for both. The new classes, like the old one, are based on Sun’s ROME API.
You’ll need to know Spring Web MVC to get the most out of this article. In particular, you’ll need to understand the relationship between controllers and views, which in a nutshell is this: when a controller is done processing a request, it returns a logical view name that a view resolver subsequently maps to a view.
Without further ado, let’s look at some code.
The controller
Let’s start with the controller, since processing starts there, and since that’s probably more familiar to more readers than implementing views. Here’s a pretty basic controller for a news feed.
package rssdemo.web; import javax.servlet.http.HttpServletResponse; import org.springframework.beans.factory.annotation.Required; import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.web.bind.annotation.RequestMapping; import rssdemo.model.NewsItem; import rssdemo.service.NewsService; @Controller public final class NewsController { private NewsService newsService; private String rssNewsFeedView; @Required public void setNewsService(NewsService newsService) { this.newsService = newsService; } @Required public void setRssNewsFeedView(String rssNewsFeedView) { this.rssNewsFeedView = rssNewsFeedView; } @RequestMapping("/news.rss") public String rss(HttpServletResponse res, Model model) { List<NewsItem> newsItems = newsService.getAllNewsItems(); model.addAttribute(newsItems); // 1 return rssNewsFeedView; // 2 } }
As you can see, this controller really is as simple as I said it would be. Our rss()
method grabs a list of NewsItem
s from the NewsService
1 and places it on the Model
under a conventionally-generated key, which in this case would be newsItemList
. Then we simply return an injected logical view name 2, which we’re going to map to an actual view shortly. (We inject the view name to maintain the separation between the controller and the view.)
Now let’s check out the star of the show, which would be our view.
The view, via Spring 3.0’s new AbstractRssFeedView
Now we come to the meat of the subject. Here we’re going to implement a Spring Web MVC view by extending Spring 3.0’s new AbstractRssFeedView
class and by using ROME to model our news feed. Once we have the view in place, we’ll be ready to configure the mapping from the logical view name we set in the controller to the view.
The next listing what’s involved in implementing a view for an RSS feed. If you’re doing an Atom feed, the approach is entirely analogous, but you would just need to extend AbstractAtomFeedView
instead of AbstractRssFeedView
.
package rssdemo.web; import java.util.*; import javax.servlet.http.*; import org.springframework.beans.factory.annotation.Required; import org.springframework.web.servlet.view.feed.AbstractRssFeedView; import com.sun.syndication.feed.rss.Channel; import com.sun.syndication.feed.rss.Description; import com.sun.syndication.feed.rss.Item; import rssdemo.model.NewsItem; public final class RssNewsFeedView extends AbstractRssFeedView { // 1 private String feedTitle; // 2 private String feedDesc; private String feedLink; @Required public void setFeedTitle(String feedTitle) { this.feedTitle = feedTitle; } @Required public void setFeedDescription(String feedDesc) { this.feedDesc = feedDesc; } @Required public void setFeedLink(String feedLink) { this.feedLink = feedLink; } @Override protected void buildFeedMetadata( Map model, Channel feed, HttpServletRequest request) { // 3 feed.setTitle(feedTitle); feed.setDescription(feedDesc); feed.setLink(feedLink); } @Override protected List<Item> buildFeedItems( Map model, HttpServletRequest request, HttpServletResponse response) throws Exception { // 4 @SuppressWarnings("unchecked") List<NewsItem> newsItems = (List<NewsItem>) model.get("newsItemList"); // 5 List<Item> feedItems = new ArrayList<Item>(); for (NewsItem newsItem : newsItems) { // 6 Item feedItem = new Item(); feedItem.setTitle(newsItem.getTitle()); feedItem.setAuthor(newsItem.getAuthor()); feedItem.setPubDate(newsItem.getDatePublished()); Description desc = new Description(); desc.setType("text/html"); desc.setValue(newsItem.getDescription()); feedItem.setDescription(desc); feedItem.setLink(newsItem.getLink()); feedItems.add(feedItem); } return feedItems; } }
So what’s going on here? Well, we begin by extending the AbstractRssFeedView
class 1. Then we include some injected fields for feed metadata 2. We use these in the optional buildFeedMetadata()
method 3. I say “optional” because the AbstractRssFeedView
provides a dummy implementation (actually, its superclass AbstractFeedView
provides it).
The method we’re required to implement is buildFeedItems()
4. Here’s where we map our list of domain objects (here, a list of NewsItem
objects that are just something we cooked up ourselves) to the ROME API, which provides a structure for modeling feeds. We begin by grabbing the NewsItem
list off the model (recall from listing 1 that we placed the list on the model in the controller) 5. Then we iterate over the NewsItem
list, mapping each one to a ROME Item
6.
That should be pretty straightforward-looking. And we’re almost done. There’s just one part that remains, and that’s establishing the mapping between the logical view name we return from the controller and the RssNewsFeedView
that we just created. We do that in the application context.
Configure the view resolver for your RSS feed
The last thing we need to take care of is configuring up the right view resolver in our application context. We can’t use the standard InternalResourceViewResolver
here because we’re not mapping to a URL; instead we want to map to a view (namely, the RssNewsFeedView
that we just created) and we want that view to handle generating the output directly.
The simplest approach here is to use something called the BeanNameViewResolver
. The idea with this type of resolver is quite simple. Whenever a controller returns a logical view name, the BeanNameViewResolver
will attempt to find a bean on the application context with the same name (or ID). If there’s a match, then it interprets that bean as the mapped view. Otherwise, the other resolvers are given their shot at matching the view name.
To add a BeanNameViewResolver
, all we need to add is this:
<bean class="org.springframework.web.servlet.view.BeanNameViewResolver"/>
We also need to inject the view name into our controller, as we saw in listing 1. Here’s how we can do that:
<bean class="rssdemo.web.NewsController" p:newsService-ref="newsService" p:rssNewsFeedView="rssNewsFeedView"/>
We just chose the name rssNewsFeedView
more or less arbitrarily; we could have chosen anything. It’s good to choose something accurate and descriptive just to keep things clear and the minimize the chance of a mapping conflict, since the name you choose is going to be a bean name. Speaking of which, we’ll need to put our view on the app context too:
<bean id="rssNewsFeedView" class="rssdemo.web.RssNewsFeedView" p:feedTitle="Ye Olde Cigar Shoppe" p:feedDescription="Latest and greatest news about cigars" p:feedLink="http://yeoldecigarshoppe.com/"/>
And there you have it! When the DispatcherServlet
gets a request for the RSS feed, it will run the controller method and then grab the resulting view name, which we’ve configured to be rssNewsFeedView
. Then the BeanNameViewResolver
will find the corresponding view bean on the app context—in this case our RssNewsFeedView
—and the view bean will finish up the request as required. All in all a nice, clean way of handling feed publication.
Post migrated from my Wheeler Software site.


Create New Training
name
View Training Close
List of Training Types
List of Trainings
Name
Date Limit
Date Training
Place
Place
name
13/01/2015
15/01/2015
countPlaces
maxPlaces
×
Confirmation
Message
×
Confirmation
Message


Global NL Database
Console
Add New Location
Add New Student
Add New Job
View Job Map
User
Logout
Add New Student to Database
Name
School
Degree
Graduation Year
Add Student
Back
© 2017 Global NL


Create a new event. You can edit the details, such as what event, when, and the description, when you create one.
You can filter events by type, so you only see the events that match the filter. This is useful if you only want to see events for a particular subject, or social events, or any other filter you make.
{% if eventlist == [] %}
No events found. Go create some events or use a different filter.


within 10 mile 25 miles 50 miles 100 miles
Please enable JavaScript to view the map.
BAPL Dealers and Territories


Dear {% for r in recipients %} {% block r %} {{ escape(r.first_name) }} {{ escape(r.last_name) }}, {% end %} {% end %}
You are receiving this request because a user has requested a new authority.
This email is only for admins, if you have any questions, kindly contact<EMAIL_ADDRESS>{% include ../button.html %}Yours sincerely,
The OneLab team


{% extends "layout.html" %} {% block body %}
We looked everywhere but we couldn't find it!
click here return


This section includes samples for:
Activity
- Hello World
- Demonstrates a basic screen activity.
- Code:
- HelloWorld.java
- Layout:
-
hello_world.xml
- Save & Restore State
- Demonstrates how an activity should save state when it is paused.
- Persistent State
- Demonstrates how you can save and restore preferences, which are stored
even after the user closes the application.
- Receive Result
- Demonstrates how an activity screen can return a result to the
activity that opened it.
- Forwarding
- Demonstrates opening a new activity and removing the current activity
from the history stack, so that when the user later presses BACK they will
not see the intermediate activity.
- Redirection
- Demonstrates how to save data to preferences and use it to determine
which activity to open next.
- Translucent
- Demonstrates how to make an activity with a transparent background.
- TranslucentBlur
- Demonstrates how to make an activity with a transparent background with
a special effect (blur).
- Dialog Activity
- An Activity that sets its theme to android:style/Theme.Dialog so that
it looks like a Dialog.
- Custom Title
- An Activity that places a custom UI in its title.
- Animation
- Demonstrates how to use custom animations when moving between activities.
- Activity Recreate
- Demonstrates how an Activity can cause itself to be recreated.
- Screen Orientation
- Demonstrates the different screen orientations an Activity can request.
- Soft Input Modes
- Demonstrates how different soft input modes set in an Activity's
window impacts how it adjusts to accommodate an IME.
- Intent Activity Flags
- Demonstrates various uses of Intent flags to modify an application
task's activity stack in common ways.
- Reorder on Launch
- Demonstrates how the activities in a task can be reordered. UI flow
goes through the activities ReorderOnLaunch,
ReorderTwo, ReorderThree,
and ReorderFour.
- Wallpaper Activity
- An Activity that uses android:style/Theme.Wallpaper to be displayed
on top of the system wallpaper.
Fragment
- Fragment Alert Dialog
- Demonstrates how to use a DialogFragment to show and manage an
AlertDialog.
- Fragment Arguments
- Demonstrates how a fragment can be initialized with arguments,
supplying them either as an argument Bundle at runtime or XML attributes
in a <fragment> tag.
- Fragment Context Menu
- Demonstrates how to display and respond to a context menu that is
display from a fragment's view hierarchy.
- Fragment Custom Animation
- Demonstrates the use of a custom animation for pushing and popping fragments
on the back stack.
- Fragment Dialog
- Demonstrates use of DialogFragment to show various types of dialogs.
- Fragment Dialog or Activity
- Demonstrates how the same Fragment implementation can be used to provide the UI
for either an Activity or Dialog.
- Fragment Hide Show
- Demonstrates hiding and showing fragments.
- Fragment Layout
- Demonstrates use of the <fragment> tag to embed a Fragment in
an Activity's content view layout, and making the layout change based on
configuration to achieve different UI flows.
- Fragment List Array
- Demonstrates use of ListFragment to show the contents of a simple ArrayAdapter.
- Fragment Menu
- Demonstrates populating custom menu items from a Fragment.
- Fragment Receive Result
- Demonstrates starting a new Activity from a Fragment, and receiving
a result back from it.
- Fragment Retain Instance
- Demonstrates a Fragment can be used to easily retain active state across
an Activity's configuration change.
- Fragment Stack
- Demonstrates creating a stack of Fragment instances similar to the
traditional stack of activities.
- Fragment Tabs
- Demonstrates implementing ActionBar tabs by switching between
Fragments.
Action Bar
- Action Bar Mechanics
- Demonstrates the basics of the Action Bar and how it interoperates with the standard options
menu. This demo is for informative purposes only; see Usage for an example of using the
Action Bar in a more idiomatic manner.
- Action Bar Tabs
- Demonstrates the use of Action Bar tabs and how they interact with other action bar
features. Also see the Fragment Tabs for a more
complete example of how to switch between fragments.
- Action Bar Usage
- Demonstrates simple usage of the Action Bar, including a SearchView as an action item. The
default Honeycomb theme includes the Action Bar by default and a menu resource is used to populate
the menu data itself. If you'd like to see how these things work under the hood, see
Mechanics.
- Settings Action Provider
- Shows how to implement an ActionProvider for launching the system settings that supplies a
menu item with a specialized action view and handles standard menu item clicks in one place.
- Share Action Provider
- Shows how to use a ShareActionProvider to embed sharing functionality in your application
via the streamlined sharing UI added in ICS.
- Display Options
- Shows how various Action Bar display option flags can be combined and their effects.
LoaderManager
- Loader Cursor
- Demonstrates use of LoaderManager to perform a query for a Cursor that
populates a ListFragment.
- Loader Custom
- Demonstrates implementation and use of a custom Loader class. The
custom class here "loads" the currently installed applications.
- Loader Throttle
- Complete end-to-end demonstration of a simple content provider that
populates data in a list through a cursor loader. The UI allows the list
to be populated with a series of items, showing how AsyncTaskLoader's
throttling facility can be used to control how much a Loader is refreshed
in this case.
Service
- Local Service
- Demonstrate the implementation of a service that runs in the same
process as its client(s). Shows how those clients can either start/stop it
with Context.startService and Context.stopService, or bind and call it with
Context.bindService and Context.unindService.
This also shows how you can simplify working
with a service when you know it will only run in your own process. The client
code for interacting with the service is in
Local Service Activities.
- Messenger Service
- Demonstrates binding to a Service whose interface is implemented with
the Messenger class. This is often an easier way to do remote communication
with a Service than using a raw AIDL interface. The client
code for interacting with the service is in
Messenger Service Activities.
- Remote Service Controller and
Remove Service Binding
- Demonstrates starting a service in a separate process, by assigning
android:process=":remote"
to the service in the
AndroidManifest.xml file. Shows how those clients can either start/stop it
with Context.startService and Context.stopService, or bind and call it with
Context.bindService and Context.unindService.
Binding is similar to the local service sample,
but illustrates the additional work (defining aidl
interfaces) needed to interact with a service in another process. Also
shows how a service can publish multiple interfaces and implement
callbacks to its clients.
- Service Start Arguments
- Demonstrates how you can use a Service as a job queue, where you
submit jobs to it with Context.startService instead of binding to the service. Such a service
automatically stops itself once all jobs have been processed. This can be
a very convenient way to interact with a service when you do not need
a result back from it.
- Foreground Service
- Shows how you
can write a Service that runs in the foreground and works on both pre-2.0
and post-2.0 versions of the platform. This example will selectively use
the new foreground APIs that were introduced in Android 2.0 if they are
available.
Alarm
- Alarm Controller
- Demonstrates two ways you can schedule alarms: a one-shot alarm that
will happen once at a given time, and a repeating alarm that will happen
first at a given time and then continually trigger at regular intervals
after that.
- Code:
- AlarmController.java
- OneShotAlarm.java
- RepeatingAlarm.java
- Layout:
-
alarm_controller.xml
- Alarm Service
- Demonstrates how you can schedule an alarm that causes a service to
be started. This is useful when you want to schedule alarms that initiate
long-running operations, such as retrieving recent e-mails.
- Code:
- AlarmService.java
- AlarmService_Service.java
- Layout:
-
alarm_service.xml
Notification
- NotifyWithText
- Demonstrates popup notifications of varying length.
- IncomingMessage
- Demonstrates sending persistent and transient notifications, with a View object in the notification. It also demonstrated inflating a View object from an XML layout resource.
- Status Bar Notifications
- Demonstrates a variety of different notifications that can be posted in
the status bar, and a standard way for handling them.
Search
- SearchInvoke
- Demonstrates various ways in which activities can launch the Search UI.
- SearchQueryResults
- Demonstrates an activity that receives Search intents and handles them.
- SearchSuggestionSampleProvider
- Demonstrates how to configure and use the built-in "recent queries" suggestion provider.
Misc
- Alert Dialog Samples
- Demonstrates various styles of alert dialogs.
- Device Admin Sample
- Demonstration of the implementation of a simple device administrator
and its use of the DevicePolicyManager.


Get latest results
Hide overall results
Alameda County © 2016 - All Rights Reserved
This application uses the following software and licenses:
Retry loading
Registration and Turnout
Precincts Reported:
Percentage


After my Btree bloat estimation query,
I found some time to work on a new query for tables. The goal here is still to
have a better bloat estimation using dedicated queries for each kind of objects.
Compare to the well known
bloat query, this query pay attention to:
I created the file sql/bloat_tables.sql with the 9.0 and more query version.
I edited the query to add the bloat reported by pgstattuple (free_percent +
dead_tuple_percent) to compare both results and added the following filter:
Here is the result on a fresh pagila database:
Well, not too bad. Let’s consider the largest table, clone it and create some
bloat:
Again, the bloat reported here is pretty close to the reality!
Some more tests:
Good, good, good. What next?
The alignment deviation
You might have noticed I did not mentioned this table with a large deviation
between the statistical bloat and the real one, called rental:
This particular situation is exactly why I loved writing these bloat queries
(including the btree one), confronting the statistics and the reality and
finding a logical answer or a fix.
Statistical and real bloat are actually both right here. The statistical one is
just measuring here the bloat AND something else we usually don’t pay attention
to. I’ll call it the alignment overhead.
Depending on the fields types, PostgreSQL adds some padding before the values
to align them inside the row in regards to the CPU word size. This help
ensuring a value fits in only one CPU register when possible. Alignment padding
are given in this pg_type
page from PostgreSQL document, see field typalign.
So let’s demonstrate how it influence the bloat here. Back to the rental table,
here is its definition:
All the fields here are fixed-size types, so it is quite easy to compute the
row size:
rental_id and inventory_id are 4-bytes integers, possible alignment is
every 4 bytes from the begining of the row
customer_id and staff_id are 2-bytes integers, possible alignment is
every 2 bytes from the begining of the row
rental_date, return_date and last_update are 8-bytes timestamps,
possible alignment is every 8 bytes from the begining of the row
The minimum row size would be 2*4 + 2*2 + 3*8, 36 bytes. Considering the
alignment optimization and the order of the fields, we now have (ascii art is
easier to explain):
That makes 12 bytes of padding and a total row size of 48 bytes instead of 36.
Here are the 10%! Let’s double check this by the experience:
Removing the “remove tables with real bloat < 1 block” filter from my demo
query, we have now:
Great!
Sadly, I couldn’t find a good way to measure this in the queries so far, so I
will live with that. By the way, this alignment overhead might be a nice
subject for a script measuring it per tables.
Known issues
The same than for the Btree statistical bloat query: I’m pretty sure the query
will have a pretty bad estimation with array types. I’ll investigate about that
later.
Comments Leave a comment by email or Disqus
Note: I only publish your name/pseudo, mail subject and content. I will NOT publish your email address.
Hi,
The article is really helpful.
The example that you have explained is of fixed size data type.
How we can order the columns of variable length types like varchar,char,text,numeric, bytes etc?


Time Remaining:
100
Test Of Pets
This is the most accurate test of pets in the business. Do not doubt. Very good.
Start!
TEST
TEST
TEST
TEST
The Quiz is over! Here is your score:


QLC+ supports the ArtNet protocol through an input/output plugin
that receives and transmits packets on the network.
No extra requirements are needed, since QLC+ has a native implementation of the ArtNet protocol
that works on Linux, Windows and OSX systems.
The ArtNet plugin can send and receive packets from multiple network cards, virtual addresses
and multiple universes per network card.
When transmitting multiple universes on the same interface, the packets will be sent with an ArtNet
Universe ID equal to the QLC+ universe number minus 1.
For example:
QLC+ Universe 1 --> ArtNet Universe 0
QLC+ Universe 2 --> ArtNet Universe 1
...
QLC+ Universe 8 --> ArtNet Universe 7
This choice is due to some facts:
1- The first valid ArtNet universe is 0 and not 1
2- The first universe accepted by commercial ArtNet-DMX devices like eDMX and ODE is 0, so
to have QLC+ to work out of the box, the first ArtNet universe must be 0.
The ArtNet plugin doesn't really have a configuration panel. When clicking on the configuration button, a panel will be shown, displaying the ArtNet nodes discovered, grouped by network interface.
If you own one of these devices, they both have configuration tools that might come handy
when working with QLC+. With them you can set several parameters to match the best
configuration to input/output data from/to QLC+.
For example if you want QLC+ universe 3 to output data on the first port of a eDMX,
you need to use the tool below to change the device universe address to 2.
Here the links to download the tools:
DMXKing eDMX Configuration tool
ENTTEC Node Management Utility
QLC+ has been tested with the following ArtNet softwares/devices:


Emma Fordham
Home
|
About
|
Artwork
|
Events
|
Contact
|
Hong Kong based Artist and Teacher of Art
© All work is copyright the artist, no reproduction without permission.
An
Eye Gallery
site


Gabriel Lien Goh, 22, appeared via video-link in the State Courts to receive the new charge of killing his 90-year-old grandmother.
He is accused of murdering Madam See Keng Keng at about 7.24pm at a seventh-floor unit at Block 7A Commonwealth Avenue on Oct 27.
He was charged last month with murdering 56-year-old Lee Soh Mui, his mother. According to charge sheets, he committed this act at about the same time as the murder of his grandmother, but it allegedly occurred at another unit on the same floor at the block that day.
Goh said: "I want to apologise to the relatives of my mum and grandma. I want to clarify. What happened was an accident. I had no control over my actions and I never intended for those things to happen."
District Judge Terence Tay stopped him and told him that he may want to reserve the details for later, in case he got a lawyer on board.
The prosecutor said the Institute of Mental Health had requested an extension in remand.
The judge ordered Goh to be further remanded at Changi Prison's Complex Medical Centre and to return to court on Nov 25.
Goh was arrested on the night of Oct 27 after the two women were found dead at the block in Commonwealth.
Paramedics pronounced both women dead at the scene.
It was the second reported murder case that day, with a 63-year-old man found dead in Ang Mo Kio that morning. A 54-year-old woman was arrested in that case, and was charged with murdering the man.
If found guilty of murder, Goh could be sentenced to death.


Recent analysis and introspection regarding Software Carpentry's Python lesson has led us to conclude that the lesson would benefit from a complete rewrite. The subcommittee on lesson development met twice to plan much about the new lessons (yes, that's plural). This post will describe our plans for the new lessons.
We're going to write two new Python lessons, one intended for students who are completely new to programming (the "novice" lesson), and another for students with some programming experience in any language (the "intermediate" lesson). Data Carpentry also targets new programmers so we'll be developing the new novice lesson in collaboration with DC, and both DC and SWC will use the lesson. We decided to use Gapminder data for both the novice and intermediate lessons in order to have a consistent experience and approachable, meaningful data (and because some lessons are already using it).
The overarching goal of the novice lesson is to convince students to adopt programming in their everyday work flow. To do that we want to both teach practical data tools and demonstrate the power of writing code (instead of using Excel). Our lesson will include using Pandas to work with data and using Python's control flow features to really make the computer work.
Greg Wilson will be leading the development of the new novice lesson. He'll be looking for help writing, editing, and reviewing the lesson, so keep an eye out for future announcements about that.
The goal of the intermediate lesson is to get students thinking about programming itself: What are effective ways for organizing code? What does it mean to refactor and abstract code? Along the way we'll teach much of the same Python syntax and data tooling from the novice lesson, but we want students to leave applying a more critical mind to the structure of their code and having a vocabulary for talking about code.
Daisie Huang will be leading the development of the intermediate Python lesson and has already started a discussion in the new python-intermediate repo. Your input would be welcome there (look at the issues).
In our discussion of the Python lessons we identified some additional topics that we think students could benefit from. These won't fit into either the novice or intermediate novice lessons, but maybe a third lesson could pick up some of these:


This is Words and Buttons Online — a collection of interactive #tutorials, #demos, and #quizzes about #mathematics, #algorithms and #programming.
This is a crossover episode between polynomial interpolation and projective transformations. With projective transformations, you can turn any quadrilateral on a plane into any other quadrilateral with a single matrix multiplication! Yey! However, even in 3D, you can't do the same to hexahedron. Well, not every hexahedron to be precise.
You see, projective transformations not only translate a straight line into a straight line in 2D; in 3D, they translate a plane into a plane as well. And since not every hexahedron has its sides made of perfectly straight planes, there is only a subset of them that are perfectly projectable.
You need tri-linear transformation to transform all the possible hexahedrons into each other. Or tri-quadratic if you want curvy hexahedrons. Or tri-cubic. Tri-polynomial. On 2D, of course, the corresponding transformations will be bi-polynomial, and in other dimensions, well, let's just omit the prefix and call them polynomial.
With polynomial transformations, you get to pick features that you want to preserve while transforming. You can preserve the straightness of lines, or you can guarantee that a parabola will translate into another parabola, or a curvy surface into another surface equally or less curvy than the original. You have options.
In 2013, I wrote the Unpager. It's a tool for unbending the pages from the pictures taken by a phone or a pocket camera. The idea was, if you lack a proper scanner, you can simply take a few pictures of the pages you want. They will, of course, appear all skewed and curvy but that's ok. That's where the Unpages comes in. You unpage the pages, and they look just like if they were scanned.
The points are moveable ↑
I wrote the thing by making a polynomial transformation do what I want: bend pages. This page shows that as soon as you know what you want mathematically, you can probably achieve it with a polynomial transformation, too.
A standard cube is an n-dimensional generalization of the [0..1] range. On a plane, it's an axis-aligned square that has four corners in (0, 0), (1, 0), (1, 1), and (0, 0).
It doesn't bring much mathematical sense into the whole business of transformations, you can still transform from an arbitrary entity to another arbitrary entity, but since the standard cube all consists of ones and zeroes, transforming in and out of this cube requires much simpler equations.
On this page, all the transformations are translating line segments from a standard square to a particular figure on a plane, and they are all ruled by sets of points. This is only a convention, you can still transform any shapes you want.
Ok, so you want to translate a thing by moving 4 points around. Wherever these points go, the neighbors shall follow. This implies that for every transformative equation you'd have to have at least 4 coefficients, too. For the polynomial transformation, this means a 4x4 system of linear equations.
4 points, 4 equations, 4 coefficients, it all comes together nicely.
The idea of bilinear transformation, or bi-anything, or even whatever-anything for that matter, is: you can decompose an n-dimensional translation into n 1-dimensional ones.
For the bilinear transformation, it works the most transparent. Let's say we have a function that linearly interpolates from one value to another as the parameter travels from 0 to 1. Here it is:
// linear interpolation by the two values in 0 and 1
function lerp(y1, y2, x) {
return y1 * (1. - x) + y2 * x;
}
|
Just to reiterate, this is a linear interpolating function. You give it two values and a parameter. When the parameter is 0, it returns the first value, when the parameter is 1, — the second one. When it's something in between, it returns something in between but in such a way that all these inbetweeners form a straight line.
Now you can use two of these to compose a bilinear interpolation. It will also give you back the values you supply it with in the points (0, 0), (1, 0), (1, 1), and (1, 1); and it will also give you the values between these poitns so they will form straight lines along the parametric axes.
function l_transform(points, x, y) { const x1 = lerp(points[0][0], points[1][0], x); const x2 = lerp(points[2][0], points[3][0], x); const x_transformed = lerp(x1, x2, y); const y1 = lerp(points[0][1], points[1][1], x); const y2 = lerp(points[2][1], points[3][1], x); const y_transformed = lerp(y1, y2, y); return [x_transformed, y_transformed]; } |
All and all, what it does looks exactly like on the plot below. This is a live plot, the guiding points are draggable.
If mapping a straight quadrilateral to another quadrilateral isn't enough for you, if you need curves, you should go biquadratic.
The main idea remains, we just need another interpolator.
// quadratic interpolation by the three values in 0, 0.5, and 1
function qerp(y1, y2, y3, x) {
const a = 2.0*y1 - 4.0*y2 + 2.0*y3;
const b = -3.0*y1 + 4.0*y2 - y3;
const c = y1;
return a*x*x + b*x + c;
}
|
This is a quadratic interpolation. You give it points in 0, 0.5, and 1, and it computes all the other points so they form a parabola passing through these three points.
And the biquadratic transofrmation looks almost the same as the bilinear one except for the few extra lines and a few extra arguments.
function q_transform(points, x, y) { const x1 = qerp(points[0][0], points[1][0], points[2][0], x); const x2 = qerp(points[3][0], points[4][0], points[5][0], x); const x3 = qerp(points[6][0], points[7][0], points[8][0], x); const x_transformed = qerp(x1, x2, x3, y); const y1 = qerp(points[0][1], points[1][1], points[2][1], x); const y2 = qerp(points[3][1], points[4][1], points[5][1], x); const y3 = qerp(points[6][1], points[7][1], points[8][1], x); const y_transformed = qerp(y1, y2, y3, y); return [x_transformed, y_transformed]; } |
And it behaves like this:
And, of course, a 2D polynomial transformation doesn't have to be just bi-something. For instance, it can be linear along one axis and cubic along the other. That's how I modeled pages in the Unpager.
The cubic-linear transformation code looks like this:
// cubic interpolation by the four values in 0, 1/3, 2/3 and 1
function cerp(y1, y2, y3, y4, x) {
const a = -9*y1/2 + 27*y2/2 - 27*y3/2 + 9*y4/2;
const b = 9*y1 - 45*y2/2 + 18*y3 - 9*y4/2;
const c = -11*y1/2 + 9*y2 - 9*y3/2 + y4;
const d = y1;
return a*x*x*x + b*x*x + c*x + d;
}
function cl_transform(points, x, y) {
const x1 = lerp(points[0][0], points[1][0], x);
const x2 = lerp(points[2][0], points[3][0], x);
const x3 = lerp(points[4][0], points[5][0], x);
const x4 = lerp(points[6][0], points[7][0], x);
const x_transformed = cerp(x1, x2, x3, x4, y);
const y1 = lerp(points[0][1], points[1][1], x);
const y2 = lerp(points[2][1], points[3][1], x);
const y3 = lerp(points[4][1], points[5][1], x);
const y4 = lerp(points[6][1], points[7][1], x);
const y_transformed = cerp(y1, y2, y3, y4, y);
return [x_transformed, y_transformed];
}
|
And the transformation itself — like this:
The formulas for the interpolants are well known. You can google them up or you can just deduce them with pen and paper.
SymPy is a Python library for symbolic computations. It does your math for you. E. g. the cubic interpolant formula can be deduced automatically by stating that you want your interpolation function through the points you want. Once you get the problem expressed, you run the solver and it does the rest.
For instance, that's how you get the formula for the cubic interpolant.
from sympy import * y1, y2, y3, y4, a, b, c, d = symbols('y1 y2 y3 y4 a b c d') print(solve([ d - y1, a * 1/27 + b * 1/9 + c * 1/ 3 + d - y2, a * 8/27 + b * 4/9 + c * 2/ 3 + d - y3, a + b + c + d - y4, ], (a, b, c, d))) |
Yes, it's that simple. Of course, you can tailor this code to produce a polynomial interpolant you want.
And you can combine interpolants to make the transformation you want.
And you can make it work in 2D, 3D, or kD by adding more interpolants one on top of another.
Have fun!
| Index #mathematics #demos | ← there's more. |
+
So You Think You Know C (free book) + Geometry for Programmers (paid book) + Github & RSS |


By
Robin Johnson(1)
Research and Development spending in New Zealand is a mixture of private and public investment undertaken to improve productive activity and efficiency. Investment is split fairly equally between private business, government organisations and the universities. It is a long term investment with some uncertainty about outcomes being achieved. It is predominantly a public good investment as most government organisations and universities are providers of R & D but not users of it and hence there is a discontinuity in the connection between investment and results. Furthurmore, the supply of Research and Development has properties of a free good which lead to users looking for new applications on a wider and wider front (spillovers). For these reasons Research and Development is generally regarded as a "good thing" rather than a "solid investment vehicle". Cost-benefit studies have shown, both in New Zealand and overseas, some projects with rates of return well in excess of the opportunity cost of capital, yet at the aggregate level there is a paucity of cost-benefit studies confirming such rates of return on a broader industry basis. This paper discusses some results from aggregate studies of the economic impact of Research and Development investment in NZ and suggests reasons why the links between aggregate supply of R & D and user demand are very weak.
Key Words: Investment, Research and Development Expenditure, Social Benefits.
By structural analysis, it is meant the institutional organisation of an industry may have some bearing on the impact of that industry on other industries. Institutional economics lays considerable stress on the relation between performance and structure. In the case of the science industry in New Zealand the institutions originally developed in a government-sponsored framework that some writers believe 'crowded out' private investment. Two large departments, the Department of Agriculture and the Department Scientific and Industrial Research, were created in a framework where it was thought individual producers could not afford to pay for research in their own interests. Even so, in the post-war years the DSIR was responsible for setting up a number of industrial research associations (DRI, WRO, MIRC) with joint funding from Government and industry. By reason of specialisation and skills, the universities were a separate institutional entity in the science industry, which largely drew on Government funding for this activity which was considered as a desirable adjunct of training in science on which they had a monopoly.
These relationships were changed by the reforms in the science establishment in the early 1990s which removed science from DSIR and MAF and created a series of subject research institutes (AgResearch etc) with private company charters. At the same time the Ministry of Research, Science and Technology (MoRST) was established as the policy body responsible for science and the Foundation of Research Science and Technology (FRST) was established as the funding body for government funds with a mandate to organise science funding on a competitive bidding process (Johnson 2000).
Another aspect of these reforms was an endeavour to find out how much exactly was spent on both private and public Research and Development. This task was entrusted to MoRST and started in the 1989 expenditure year. The survey was taken over by Statistics New Zealand in 2002. It is this survey which informs most of the comments and analysis presented in this paper.
Organisations which carry out Research and Development are called 'research providers' and the organisations which finance research are called 'research funders'. Private sector providers are called business (BERD), government (GERD) and universities (HERD for higher education) and are both providers and funders as are business. 'Providers' is the basis of all analytical tables used in this paper. The old research associations (DRI, WRO etc) are considered to be private providers of Research and Development. MoRST spent considerable effort in identifying output class areas which were categories based on the purposes of Research and Development used for public science funding ( MoRST Survey 1997, p. 27). Up to 2000, MoRST asked in the questionaires what output or outputs each firm/department/organisation was providing science services to? (I assume there was space for a multiple answer). In research utilising the MoRST output area data, we reclassify these outcome categories to fit ANZSIC (industry classification). Statistics New Zealand classifies BERD by ANZSIC categories and GERD by the appropriate ANZSIC categories This means that the meaning and intent of science output class areas has been put aside.
In addition to the MoRST Surveys (1989-2004), earlier statistics of Research and Development spending were collected by The National Research Advisory Council (NRAC) and Government Departments. These figures were assessed under various subject areas which approximated roughly to the output areas used by MoRST. In this way spending statistics by the private sector, universities and Government were extended back to 1961-62 for the following industry sectors:
The economic impact of Research and Development needs to be analysed in some benefit-cost framework. Earlier studies have included a study by Scobie and Eveleens of the agriculture sector where fairly clear records of research and extension expenditure had been kept (Scobie & Eveleens 1986). This study related Research and Development expenditure to a total productivity ratio (gross return/total input) for the sector drawn from the work of B.P. Philpott (1969). The Scobie and Eveleens study of agricultural productivity from 1926 to 1984 used a model in which the observed level of total productivity in agriculture in each year was dependent on:
The results showed that, on average, research results are slowly incorporated [in the case of livestock farming] into practice and their impact on productivity increased reaching a peak after 11 years and finally tailing off after a total of 23 years. In terms of research expenditure alone [i.e. holding other variables constant], $1m of research expenditure generated total benefits of $8.5m over the following 23 years, giving an internal rate of return of 30 per cent.
In agricultural circles, the total productivity ratio seems the obvious way to study production changes resulting from adoption of scientific procedures. On a wider industry basis, net output or value added is the statistical measure of production recorded. A productivity ratio like total factor productivity might then be employed (net output/weighted capital and labour inputs) for testing Research and Development impacts. If the underlying function adopted is Cobb Douglas then it may be relevant to make net output the dependent variable in the Research and Development analysis. Some of these variants are discussed later in the paper.
It has to be said that these are aggregate industry studies dependent on national collections of statistics. Project level data or even programme level data (within an organisation) may be a more precise approach to cost benefit studies.
The question remains as to where an industry obtains its R & D knowledge. A stock of knowledge is built up in continuing investment by public and private agencies both in NZ and overseas. It could be that all knowledge is available to everybody and one just has to plug into it. Some industries may generate their own. Or is part of the stock of knowledge specific to particular users or industries or locked up by legal means such as patents?. The MoRST system of science output area classes suggests that science users can be categorised in a useful way and Research and Development can be something specific to a group of users. This kind of hypothesis can be tested by relating productivity gains in an industry to specific sets of Research and Development knowledge (organised around science output area classes) or the general body of R & D knowledge. If one industry draws from another industry this is a form of economic spillover. It is thus quite important to examine where a group finds its relevant Research and Development knowledge and to look for links between groups.
Table 1 shows Research and Development expenditure from a provider point of view since 1990. National expenditure on Research and Development has risen from $725m in 1990-91 to $1467m in 2003-04. As can be seen, the amount has grown in line with the growth of national GDP. As far as the main providers are concerned, government has slowly withdrawn from research provision while the private sector and the universities have increased their share.
| Table 1: Research Expenditure by Major Providers % | |||||||||
|---|---|---|---|---|---|---|---|---|---|
| 1990 -91 |
1991 -92 |
1992 -93 |
1993 -94 |
1995 -96 |
1997 -98 |
1999 -00 |
2001 -02 |
2003 -04 |
|
| Business | 28.3 | 26.8 | 27.1 | 30.1 | 27.0 | 28.2 | 29.7 | 32.1 | 35.6 |
| Universities | 27.8 | 28.6 | 30.8 | 28.3 | 30.7 | 36.4 | 34.2 | 33.3 | 31.0 |
| Government | 43.9 | 44.6 | 42.1 | 41.6 | 42.2 | 35.3 | 36.0 | 34.6 | 33.4 |
| Total $m | 724.6 | 714.5 | 755.3 | 824.8 | 889.3 | 1107.4 | 1091.3 | 1308.3* | 1467.9* |
| % GDP | 0.99 | 0.98 | 1.00 | 1.03 | 0.98 | 1.10 | 1.01 | 1.06 | 1.07 |
| * sample total adjusted to 2000 survey basis. | |||||||||
| Sources: MoRST 1999 Survey and Statistcs New Zealand Updates. |
Table 2 shows where the funds for Research and Development originate. Most university funds come from Government but not all of it (see Table 3). This table is presented to demonstrate the rising share of the private sector.
| Table 2: Funding of Providers of Science (%) | |||||||||
|---|---|---|---|---|---|---|---|---|---|
| 1990-91 | 1991-92 | 1992-93 | 1993-94 | 1995-96 | 1997-98 | 1999-00 | 2001-02 | 2003-04 | |
| Business | 29.3 | 27.4 | 29.7 | 33.8 | 33.7 | 30.5 | 33.9 | 33.4 | 36.7* |
| Government | 60.3 | 61.8 | 59.0 | 54.8 | 52.3 | 52.3 | 50.9 | 49.3 | 56.5* |
| Other | 10.4 | 10.8 | 11.3 | 11.4 | 14.0 | 17.2 | 15.1 | 17.3 | 6.8* |
| Total $m | 724.6 | 714.5 | 755.3 | 824.8 | 889.3 | 1107.4 | 1105.7 | 1329.9 | 1601.2* |
| * In 2000, 2002 and 2004 funding is not equalised with spending. In 2002 the matched sample is utilised. In 2004, the new sample is the only information available. | |||||||||
| Sources: MoRST 1999 and Statistics New Zealand. |
Table 3 shows University sources of funds for some recent years. These do not show in Table 2. Government block grants predominate but the contractual system (FRST) is of growing importance and internally generated funds have remained at a constant proportion. There are not large linkages with business. In our econometric analysis, all University provider spending is treated as part of the Government sector.
| Table 3: Source of Funds for University Research and Development (%) | ||||||
|---|---|---|---|---|---|---|
| 1993-94 | 1995-96 | 1997-98 | 1999-00 | 2001-02 | 2003-04 | |
| General University funds | 46 | 35 | 36 | 28 | 23 | - |
| Research contracts (Govt) | 16 | 20 | 25 | 31 | 37 | - |
| Other funds (incl. student fees) | 23 | 27 | 29 | 26 | 26 | - |
| Business | 5 | 9 | 5 | 6 | 5 | - |
| Overseas | 3 | 5 | 3 | 5 | 3 | - |
| Others | 6 | 4 | 3 | 4 | 5 | - |
| Total $m | 233.5 | 273.5 | 403.5 | 374.1 | 435.8* | 454.8* |
| * on the new sample basis. | ||||||
| Source: Morst 1999 and Statistics New Zealand. |
Table 4 shows how the business sector funds its spending. This demonstrates, I think, the independence of the business Research and Development sector from the public sector, remembering the business sector includes the former research associations (WRO etc).
| Table 4: Sources of Funding for Private Sector (%) | |||||||||
|---|---|---|---|---|---|---|---|---|---|
| 1990-91 | 1991-92 | 1992-93 | 1993-94 | 1995-96 | 1997-98 | 1999-00 | 2001-02 | 2003-04 | |
| Business | 88.9 | 87.8 | 88.6 | 89.4 | 86.4 | 79.3 | 83.8 | 76.4 | 77.3 |
| Government* | 6.2 | 7.3 | 8.1 | 7.1 | 7.0 | 9.3 | 9.7 | 9.2 | 9.6 |
| Other# | 4.9 | 4.9 | 2.3 | 3.5 | 6.6 | 11.4 | 6.5 | 14.4 | 13.2 |
| Total $m | 204.4 | 191.7 | 204.8 | 247.9 | 240.3 | 312.5 | 326.2 | 423.5 | 648.1** |
| * includes higher education | |||||||||
| # includes private non-profit funds and overseas funds. | |||||||||
| ** based on 2004 sample | |||||||||
| Sources: MoRST 1999 and Statistics New Zealand. |
Figure 1 shows the division of the Research and Development spending between the 3 main sectors in real terms since 1961. From 1989 the data is based on the MoRST surveys. For the intermediate years in which MoRST did not carry out a survey, the expenditure has been extrapolated in proportion to changes in nominal GDP. Prior to 1989, the NRAC data for Government expenditure is used. For Universities a fixed proportion of the Government Block Grant is used. For Business the proportion of business expenditure to nominal GDP in 1989 is carried back to 1961-62.
Real expenditure by Government was rising rapidly up to the early 1980s but has since plateaued with quite a reduction in real terms in the 1980s. The trend in University expenditure up to the late 1980s reflects the Block Grant allocation and is only a guide to actual Research and Development expenditure by the Universities. In the private sector the trend reflects GDP growth and is only an approximation to what private enterprise might have spent on Research and Development.
The impact of Research and Development investment will be felt in the longer run in production levels and efficiency. One approach is to observe production changes as reflected in real national product and seek explanatory changes in capital employed, labour employed and previous Research and Development investment.
The two approaches are related. Both can be derived from a production function of the form:
(1) Y = A Ka Lb,
where
Y is output:
A is productivity;
K is the stock of physical capital; and
L is labour.
If productivity can be explained by the stock of knowledge capital and other factors, then equation (1) can be rewritten as:
(2) Y = Ka Lb Rg Zs,
where R is the stock of knowledge capital; and
Z is other factors affecting measured productivity.
In the production function approach, a log linear version of equation (2) is estimated directly:
(3) ln Y = a ln K + b ln L + g ln R + s ln Z,
with no further restrictions placed upon the parameters. The estimate of g would provide a direct estimate of the percentage increase in output obtainable from a one per cent increase in knowledge stocks, holding all other factors constant.
In the two-step productivity approach, equation (3) would be rewritten as :
(4) ln Y - a ln K - b ln L = g ln R + s ln Z
Under the additional assumptions that a + b = 1 and that a and b equal capital and labour income shares, the left-hand side of (4) equals multi-factor productivity (in level, not growth form), as conventionally measured in a growth accounting framework. Observations on multi-factor productivity can then be regressed on the variables shown on the RHS.
In either case, estimates of the parameter g can be converted from an elasticity to an overall rate of return dY/dR as given by:
(5) dY/dR = g (Y/R).(2)
The capital variable K is derived from capital expenditure data by the perpetual inventory method:
(6) Kt = (1 - f) Kt-1 + Et-1
where
Kt = the stock of conventional capital at the beginning of period t in constant prices;
Kt-1 = the stock of capital at the beginning of period t-1;
Et-1 = capital expenditure during period t-1 in constant prices; and
f = the depreciation or obsolescence rate of capital.
In this study, Philpott's data on capital employed in different sectors is utilised. Philpott does not use diminishing balance depreciation rates but substitutes a formula taking in the average life of assets (Philpott 1994). These estimates of the capital employed are about 50 per cent greater than those determined by book depreciation methods (Philpott 1995).
The perpetual inventory method is also applied to the Research and Development variables. The expenditures shown in Figure 1 are transformed as in equation (6). Knowledge is regarded as a stock of available technologies which can be added to and subtracted from. The reduction process can be treated as the depreciation factor. The initial stock of knowledge has to be established from the available data by a formula of the kind:
(7) So = Eo / (e + f),
where
So = the stock of Research and Development capital at the beginning of the first year for which expenditure data is available;
Eo = the annual expenditure on R & D (in constant prices) during the first year;
e = the average annual logarithmic growth of Research and Development expenditures for the nearest relevant years; and
f the depreciation or obsolescence rate of knowledge.
The assumption is that if the stock had been growing before the first year at a certain rate, then the estimate of the total starting stock will be that much higher than it would have been if expenditure were capitalised by the rate of depreciation alone. In the estimates used in this paper e was estimated for the first ten years after 1962, and f was set at 5 per cent per year. Thus the starting stock for the market sector is:
(8) So = $86.3m / (0.1 + 0.05)
= $575.3m (in $1982-83)
The choice of a rate of depreciation of a knowledge stock is a difficult question. It seems clear that new inventions and ways of doing things replace older inventions and ways. The stock is thus a moving entity - constantly wasted and constantly replenished. Evidence is lacking on what is the appropriate course of action. Scobie and Eveleens (1986) note that "average research results are slowly incorporated into practice and their impact on productivity increases [in agriculture] reaching a peak after 11 years, and finally tailing off after a total of 23 years". This suggest a "life" of research of about 20 years with the maximum effect in the mid years of that period. Thus a rate of 5-10 per cent might be quite appropriate for a country like New Zealand - the results presented here are calculated at 5 per cent.
The second approach is to isolate the productivity change as a residual after capital and labour returns have been allowed for. This is the total factor productivity index (TFP) which is defined as the net output of an industry divided by the weighted sum of the labour and capital inputs used. In national accounting terms the ratio is:
(9) TFPi = Yi / aiLi + biKi
where ai and bi are the average factor shares of income in nominal terms for the ith industry. For example, in the market sector as a whole the share of L is 0.60 and K is 0.40.
The TFP index can be regarded (by re-arrangement of (9) above) as the weighted mean of the labour and capital productivity indices:
(10) TFPi = ai(Yi / Li) + bi(Yi / K i).
The actual data and factor shares from the Philpott data set are available in the form:
Y it. Real GDP by SNA industry group ($m in 1982-83 prices).
L it. Employment in SNA industry groups (`000 full time equivalents).
K it. Real gross capital stock by SNA industry group ($m in 1982-83 prices).
ai and b i. Average factor shares in nominal $.
The ratios in equation (10) are shown in Figure 2 for the national market economy with base year weights (n.b. excluding owner-occupied dwellings and government services).
Figure 2: Components of National Productivity
We first test the Cobb-Douglas hypothesis (Equations (2) and (3)) in a step-wise manner for the market economy and for the agriculture sector(Tables 5 and 6). The variables are:
Sectoral Real GDP as a function of:
Labour in full time equivalents (Philpott)
Real Capital Gross Stocks (Philpott)
Real Stocks of Private Research and Development depreciated at 5%
Real Stocks of Public Research and Development depreciated at 5%
Real Stocks of Australian Research and Development (reflecting a source of
external spillovers)
Real Expenditure on Education in NZ (reflecting upgrading of
skills)
In Table 5, hypothesis a. has good properties for expected values for Labour and Capital approximating to their factor shares. In hypothesis b. private Research and Development is highly positive but public R & D highly negative. In hypothesis c. both external factors are not significant. In Table 6 the Cobb-Douglas fit is very poor; there is again a high return to private Research and Development and a negative return to public Research and Development; no influence from Australian R & D; but a suggestion of an influence from skill levels in the economy.
Table 7 shows the regression results derived from equation (4). The dependent variable is now total factor productivity as defined in equation (9). Constant factor shares (averages) were used as weights for capital and labour inputs. We also show the RORs for these results as derived by the formula in equation (5). For MK the size of the Research and Development coefficient is smaller but of the same sign. For AGR the Research and Development coefficients are barely changed from Table 6. Australian Research and Development comes through as significant for MK and AGR and EDU cames through in AGR again. The ROR for PVTResearch and Development is quite high in both equations but the ROR for PUBResearch and Development is low and negative.
| Table 5: Full Cobb-Douglas Results for Market Economy | ||||||
|---|---|---|---|---|---|---|
| Variable Option |
Labour | Capital | PVTResearch and Development | PUBResearch and Development | AUST | EDU |
| a. | 0.54 (5.2) | 0.56 (18.9) | ||||
| b. | 1.06 (12.5) | 0.58 (4.1) | 0.70 (4.5) | -0.78 (-7.1) | ||
| c. | 0.95 (9.3) | 0.37 (1.7) | 0.57 (3.5) | -0.59 (-3.6) | 0.07 (1.2) | 0.03 (0.5) |
| (t test in brackets) |
| Table 6: Full Cobb-Douglas Results for Agriculture | ||||||
|---|---|---|---|---|---|---|
| Variable Option |
Labour | Capital | PVTResearch and Development | PUBResearch and Development | AUST | EDU |
| a. | -2.56 (-6.1) | 2.42 (8.7) | ||||
| b. | 0.66 (1.3) | 1.63 (2.2) | 2.24 (6.3) | -2.01 (-5.7) | ||
| c. | 1.08 (2.5) | 2.15 (1.6) | 2.56 (3.9) | -2.57 (-5.6) | -0.1 (1.0) | 0.5 (2.8) |
| (t test in brackets) |
| Table 7: Factor Productivity Results for Market Sector&Agriculture | ||||
|---|---|---|---|---|
| Private Research and Development | Public Research and Development | AUST | EDU | |
| Option | ||||
| a.MK | 0.39 (3.1) | -0.38 (-3.3) | 0.13 (3.7) | 0.02(0.4) |
| b.AGR | 2.91 (6.7) | -2.51 (-6.7) | -0.46 (-2.7) | 0.60 (3.7) |
| c.ROR MK* | $11.9 | -$4.8 | ||
| d. ROR AGR* | $68.7 | -$6.7 | ||
| * ROR=Rate of Return; $return per $ of depreciated Research and Development stock; i.e. accumulated investment in R & D. |
All of these results utilise stocks of Research and Development knowledge as an independent variable. As already indicated, the stock of knowledge concept is rather hypothetical and its rate of wastage or depreciation equally so. Table 8 shows the sensitivity of the results in Table 7 to changes in the wastage rate. (There is a small change in the specification that changes the earlier result slightly). It appears that manipulation of the wastage rate is compensatory; the elasticity decreases as the wastage rate increases and the rate of return rises slightly in each case.
| Table 8 Sensitivity of Elasticity to the Wastage Rate for Research and Development Stocks | ||||
|---|---|---|---|---|
| (Same formulation as Table 7) | ||||
| Rate | PVTMK | PUBMK | PVTAGR | PUBAGR |
| 5% | 0.34 | -0.35 | 2.59 | -2.32 |
| 10 | 0.30 | -0.29 | 2.28 | -1.98 |
| 20 | 0.20 | -0.20 | 1.61 | -1.46 |
| 30 | 0.15 | -0.17 | 1.28 | -1.24 |
| 40 | 0.12 | -0.15 | 1.08 | -1.11 |
| 50 | 0.11 | -0.14 | 0.95 | -1.03 |
| Annual | 0.07 | -0.07 | 0.69 | -0.65 |
MoRST has been extremely concerned about the negative relationship between public Research and Development stocks and the two productivity measures employed. In terms of the industry breakdown employed in the larger study, private Research and Development stocks are positively related to changes in TFP in 7 cases out of 10; public R & D is positively related to changes in TFP in 4 cases out of 10; external Research and Development is positively related to changes in TFP in 7 cases out of 10; and education expenditure is positively related to changes in TFP in 4 cases out of 10. In the market economy as a whole there is a positive result for private Research and Development stocks and a negative result for public Research and Development stocks.
As Scobie and Eveleens have shown, there is a relationship between Research and Development annual expenditure over the long term and productivity in AGR. Table 9 shows the relationship in this set of data for the market economy and agriculture sectors using TFP as the dependent variable. Since the individual elasticities are additive the overall productivity effect of Research and Development investment can be assessed by this method. In both the market economy and agriculture there is now an overall positive relation between public Research and Development and productivity. There is clearly a negative relationship between the 4th and the 9th year in public investment in both sectors which seems to be common to most industries. Private investment in Research and Development in AGR is positive through the system reflecting the high elasticity and rate of return obtained earlier.
| Table 9: Polynomial Distributed Lag Effect | ||||
|---|---|---|---|---|
| Lag | PVTMK | PUBMK | PVTAGR | PUBAGR |
| -1 | -0.001 | 0.130 | 0.147 | 0.459 |
| -2 | -0.026 | 0.045 | 0.114 | 0.207 |
| -3 | -0.040 | -0.014 | 0.088 | 0.029 |
| -4 | -0.044 | -0.051 | 0.070 | -0.085 |
| -5 | -0.040 | -0.068 | 0.058 | -0.145 |
| -6 | -0.030 | -0.070 | 0.052 | -0.160 |
| -7 | -0.016 | -0.059 | 0.049 | -0.140 |
| -8 | 0.001 | -0.040 | 0.049 | -0.094 |
| -9 | 0.018 | -0.016 | 0.050 | -0.034 |
| -10 | 0.035 | 0.010 | 0.052 | 0.032 |
| -11 | 0.048 | 0.034 | 0.053 | 0.094 |
| -12 | 0.056 | 0.052 | 0.051 | 0.143 |
| -13 | 0.057 | 0.061 | 0.046 | 0.167 |
| -14 | 0.049 | 0.058 | 0.037 | 0.158 |
| -15 | 0.031 | 0.039 | 0.022 | 0.105 |
| Sums | 0.096 | 0.112 | 0.940 | 0.736 |
| Turning points | 4, 13 | 6, 13 | 6, 12 | 6, 13 |
The assumption that Research and Development can be conveniently divided into private and public providers can be challenged although the insight it reveals is useful as the results so far show. Table 10 recalculates some of the main results for AGR with a variable amalgamating the components of Research and Development. By itself ALLR & D is strongly and positively related to changes in TFP. However its strength of asociation is lost when regressed with AUST and EDU in the same equation. Curiously the strongest relationship is that with Australian stocks of Research and Development. This is inconsistent with the result in Table 6.
| Table 10: Amalgamation of Private and Public R & D for Agriculture | |||
|---|---|---|---|
| Option | ALL Research and Development | AUST | EDU |
| a. | 0.39 (10.4) | ||
| b. | 0.25 (0.4) | 0.62 (7.2) | |
| c. | 0.06 (0.5) | 0.72 (2.8) | |
| d. | -0.02 (-0.2) | 0.61 (5.9) | 0.06 (0.3) |
We next examine the source of Research and Development knowledge employed in an industry. We use the agricultural sector as an example. There are two hypotheses to examine. We can ask whether the source of R & D knowledge is outside the immediate industry environs - in this case such an effect could be called a spillover from one industry to another. Secondly we can ask whether the additional source of R & D complements the Research and Development already held or is a substitute for it. We create two new variables; PVTOTHER and PUBOTHER; being the stock of Research and Development not designated as belonging to the AGR science output area as defined by MoRST. We then create another variable 'MULT' which is the geometric sum of the two stocks of Research and Development. A positive sign indicates complementarity and a negative sign indicates substitution between own stocks and other stocks. In Table 11, PVTOTHER is not quite significant at the 5% level and is certainly of the right sign. PUBOTHER does not feature strongly. In the case of MULT the coefficients are negative (indicating substitution at work) but only that for PUBResearch and Development is significant at the 5% level. Since PUBResearch and Development by itself has a negative elasticity the MULT result amounts to reinforcing the negative effect on TFP.
| Table 11: Spillovers in the Agriculture Sector | |||||
|---|---|---|---|---|---|
| Option | PVTResearch and Development | PUBResearch and Development | PVTOTHER | PUBOTHER | MULT* |
| a. | 1.24 (2.7) | -1.95 (-7.0) | 1.14 (1.7) | ||
| b. | 1.91 (8.5) | -1.91 (-2.9) | 0.41 (0.5) | ||
| c. | 2.28 (3.0) | -2.26 (-7.2) | 1.05 (1.8) | -0.07 (-1.3) | |
| d. | 2.91 (6.9) | -0.09 (-0.1) | -1.01 (-1.3) | -0.13 (-2.3) | |
| * MULT is a variable representing the multiplicand of PVTResearch and Development and PVTOTHER. See text. Likewise for PUBResearch and Development and PUBOTHER. |
A more sophisticated approach to the structure of returns in the science system, using the same set of data, is to treat the sectoral data as a cross-section panel (Johnson, Razzak & Stillman, 2005). This gives a 9x37 set of observations. The function was assumed Cobb Douglas and the data normalised by dividing throughout by the labour variable. Hence the results can be interpreted as factors which affect labour productivity across sectors in the economy. This variable enters the estimating equation on the RHS as output per person lagged by one year and is statistically significant. The response to capital per employee is variable and not significant in every specification explored. The results tend to support a constant returns to scale hypothesis. Across industries, the elasticity of private Research and Development stocks is positive in all regressions tried, but the own effect of public R & D stocks is negative and barely significant. Spillovers were tested by including each industry Research and Development stock as an independent variable. This measures the effect of a given industry stock on all other industries. For private Research and Development there were measurable spillovers from building, forestry and services and for public R & D smaller spillovers from the agriculture and transport industries.
These results confirm the simpler statistical models where private Research and Development has a small positive impact on own-industry output after controlling for capital and labout inputs, and some evidence that this Research and Development spills over from certain industries to the overall economy. Publicly provided Research and Development does not appear to have a positive impact on either own-industry output or the overall economy. These results are consistent with economic theory in the sense that private Research and Development investments should be more efficient as private firms will not undertake such investments unless they expect a positive return. On the other hand, publicly provided R & D often has goals beyond profit maxmisation. (op cit, p.11).
Table 12 shows the results of cost-benefit studies on a project basis undertaken by FRST. While these may be possibly 'successful' projects, they have longer track records that permit evaluation. The results are generally very favourable. It is not clear to me whether the methodology is always the same in each case study. There is a need to be clear about private returns and social returns to investment and whether national income conventions are being observed. We should look forward to more of these evaluations.
The results obtained by myself and Johnson et al are drawn from a single set of data. Some of the Research and Development data is drawn from surveys in the period from 1989 to 2000, while some of the Research and Development data is extrapolated from less reliable sources for the earlier period. National income, labour employment, and capital stock are drawn from the data base set up by B. P. Philpott which is consistent for the whole period of study. The allocation of R & D expenditure to a particular industry relies on the MoRST system of 'science output areas' where providers try to identify the probable users of that research. Before 1989, public expenditure on Research and Development was gleaned from Government and NRAC records and the industry allocation depended on the department carrying it out. For private expenditure on Research and Development the allocation was roughly in line with that found in 1989.
For these reasons, the association between Research and Development expenditure and particular industries is weak in the data. The set for the market economy is stronger in this sense because these allocation errors are avoided. The difference between the results for PVR & D and PUResearch and Development in both studies appears to be partly due to these measurement errors and partly due to a conceptual difference associated with the aim of scientific research. The latter is perhaps best encapsulated in the notion of short-term versus long-term investment strategies. The state, perhaps, has set scientific objectives, in the past, that aimed at the national good in a longer term framework. The results of such research permeate into society rather slowly and unevenly. It may be virtually unmeasurable! On the other hand, we would expect private enterprise to invest in areas where there was a forseeable gain for them. (This is pure hypothesis of course, given the measurement errors in 'science output areas').
The analysis does demonstrate, I think, that it is the general
pool of knowledge which is important in the economic utilisation of
scientific research rather than any special designated research.
Maybe we should stop looking for spillovers (between industries
say) and accept that knowledge is a general resource available to
anyone apart from where particular patents or ownership
restrictions apply. It might be important to bear in mind Griliches
(1979) definition where he says The level of productivity
achieved by one firm or industry depends not only on its own
research efforts but also on the level of the pool of general
knowledge accessible to it
.
1. Griliches, Z.(1979), Issues in Assessing the Contribution of Research and Development to Productivity Growth, Bell Journal of Economics 10, 92-116.
2. Johnson, RWM (1999), The Rate of Return on NZ Research and Development, NZ Assocation of Economists, Rotorua.
3. Johnson, RWM and Forbes RN (2000), Recent Productivity Trends in New Zealand Primary Sectors, MAFPolicy Technical Paper No 2000/20. Wellington.
4. Johnson, Robin (2000), Crowding Out and Resulting Trends in Research Fund Allocation in New Zealand 1991-2000, NZ Economic Papers 34(1), pp 129-147.
5. Johnson Robin, W A Razzak & Steven Stillman (2005), 'Has NZ benefited from its investment in research and development?', unpublished ms., Department of Labour.
6. MoRST (1999), New Zealand Research and Development Statistics 1997/98, Publication No 17, Wellington.
7. Philpott, B P and Hussey DD (1969), Productivity and Income of New Zealand Agriculture 1921-67, Agricultural Economics Research Unit Research Report No 59, Lincoln University.
8. Philpott B.P. (1994), Data base of Nominal and Real Output, Labour, and Capital Employed by SNA Industry group 1960-1990, RPEP Paper 265, Victoria University.
9. Philpott B.P. (1995), Real Net Capital Stock by SNA Production Groups New Zealand 1950-1991, RPEP Paper 270.
10. Scobie, G and Eveleens W (1986), Agricultural Research: What's it Worth?, Research Paper no 1/86, Economics Division, MAF, Hamilton.
(1) Consultant, Wellington
(2) This is not equivalent to the internal rate of return. The IRR would need to be estimated from the long term responses in productivity.


Index
All Classes|All Packages
G
- GAS - com.weapons.Pedal
-
GAS
- getDirection() - Method in class com.weapons.FireBulletWeapon
-
get direction
- getDirection() - Method in class com.weapons.FireSonicWaveWeapon
-
get Direction
- getDirection() - Method in class com.weapons.InTheAirChimneyBlastWeapon
-
get Direction
- getDirection() - Method in class com.weapons.RearDefenseMineWeapon
-
get Direction
- getDirection() - Method in class com.weapons.Vehicle
-
getDirection
- getDirection() - Method in interface com.weapons.WeaponInterface
- getFireBulletList() - Method in class com.weapons.Vehicle
-
getFireBulletList
- getFireSonicWaveList() - Method in class com.weapons.Vehicle
-
getFireSonicWaveList
- getHealth() - Method in class com.weapons.Vehicle
-
get Health
- getHealthReduced() - Method in class com.weapons.FireBulletWeapon
-
get health value
- getHealthReduced() - Method in class com.weapons.FireSonicWaveWeapon
-
getHealthReduced
- getHealthReduced() - Method in class com.weapons.InTheAirChimneyBlastWeapon
-
getHealthReduced
- getHealthReduced() - Method in class com.weapons.RearDefenseMineWeapon
-
get HealthReduced
- getHealthReduced() - Method in interface com.weapons.WeaponInterface
- getInTheAirChimneyBlastList() - Method in class com.weapons.Vehicle
-
get InTheAirChimneyBlastList
- getName() - Method in class com.weapons.Vehicle
-
ge tName
- getName() - Method in class com.weapons.Weapon
-
getName
- getPedal() - Method in class com.weapons.Vehicle
-
get pedal
- getPosition() - Method in class com.weapons.FireBulletWeapon
-
get position
- getPosition() - Method in class com.weapons.FireSonicWaveWeapon
-
get Position
- getPosition() - Method in class com.weapons.InTheAirChimneyBlastWeapon
-
get Position
- getPosition() - Method in class com.weapons.RearDefenseMineWeapon
-
get Position
- getPosition() - Method in class com.weapons.Vehicle
-
get position
- getPosition() - Method in interface com.weapons.WeaponInterface
- getRearDefenseMine() - Method in class com.weapons.Vehicle
-
getRearDefenseMine
- getSize() - Method in class com.weapons.FireBulletWeapon
-
get size
- getSize() - Method in class com.weapons.FireSonicWaveWeapon
-
get Size
- getSize() - Method in class com.weapons.RearDefenseMineWeapon
-
get Size
- getSpeed() - Method in class com.weapons.FireBulletWeapon
-
get speed
- getSpeed() - Method in class com.weapons.FireSonicWaveWeapon
-
get Speed
- getSpeed() - Method in class com.weapons.InTheAirChimneyBlastWeapon
-
get Speed
- getSpeed() - Method in class com.weapons.RearDefenseMineWeapon
-
get Speed
- getSpeed() - Method in class com.weapons.Vehicle
-
get Speed
- getSpeed() - Method in interface com.weapons.WeaponInterface
- getSteeringWheel() - Method in class com.weapons.FireBulletWeapon
-
get x y
- getSteeringWheel() - Method in class com.weapons.FireSonicWaveWeapon
-
get SteeringWheel
- getSteeringWheel() - Method in class com.weapons.InTheAirChimneyBlastWeapon
-
get SteeringWheel
- getSteeringWheel() - Method in class com.weapons.RearDefenseMineWeapon
-
getSteeringWheel
- getSteeringWheel() - Method in class com.weapons.Vehicle
-
get SteeringWheel
- getSteeringWheel() - Method in interface com.weapons.WeaponInterface
- getType() - Method in class com.weapons.Vehicle
-
get Type
- getVehicle() - Method in class com.weapons.Weapon
-
getVehicle
- getX() - Method in class com.weapons.Position
-
get x position
- getX() - Method in class com.weapons.Size
-
get x position
- getY() - Method in class com.weapons.Position
-
get y position
- getY() - Method in class com.weapons.Size
-
get y position
- getZ() - Method in class com.weapons.Position
-
get z position
- getZ() - Method in class com.weapons.Size
-
get z position
All Classes|All Packages


Gas line ruptures under residential street in Granada Hills, prompting evacuations
by ABC7.com staffGRANADA HILLS, LOS ANGELES (KABC) -- A high-pressure, underground gas line in Granada Hills ruptured after being struck Wednesday afternoon, prompting the evacuation of six nearby homes, officials said.
The incident happened after 2 p.m. in the 17000 block of West Westbury Drive, according to the Los Angeles Fire Department.
Firefighters responded to the scene while gas company crews worked to repair the leak, the LAFD said.
No structural damage or injuries were reported.
Only one of the six houses required actual evacuation, as no one was home at the other residences at the time, officials said.


{% extends 'polls/base.html' %} {% block content %}
Twitter authorization presents minimal privacy concerns. As there's nothing much to hide on twitter, you have little or nothing to worry with regards access to your data. If you do not already have a twitter account, you can create one here.
Pollit Nigeria conducts online opinion polls on relevant and critical national issues. Our goal is to ensure the voice of regular Nigerians gets heard. Our polls application allows you to both filter votes by respondents characteristics and also view the demography of respondents for every poll. The future of polling is online, and our methodology represents the best approach yet.


One of the most charming actors of B-town – Aditya Roy Kapur – celebrates his 34th birthday today, though he looks no less than a 25-year-old.


Home
About
Events
Gallery
FAQ
Contact
Our Location
Send us a Quick Email
Send Message
Our Headquarters
Address:
2626 SW Corbett Ave, Suite 100
Portland, OR 97201
Phone:
503-444-8836
Email:
<EMAIL_ADDRESS>Gallery
Showcase of Our Beautiful Gallery in Various Columns
Home
Shortcodes
Gallery
2 Columns
3 Columns
4 Columns
5 Columns
6 Columns
<


Welcome to behind the scenes! We are the experts behind this amazing Design Your Life app!  Not just some days or some times, we want to live happy everyday and will not let anything stop us from encouraging others to do the same!
Katie McKnight
Meet Katie McKnight, she is our head of operations! She created the vision and made the plans for us to execute.
She specializes is practically everything when it comes to programming, she is also has a very creative way of thinking to match her insane amount of tenacity to make her visions come to life!
Skyler Slatosch
Meet Skyler Slatosch, the weaker link of the UI group. He may be less talented in all areas than the rest of the team but his effort speaks volumes!
While he gets distracted by fortnite streams when he should be working, others on the team always makes ton of progress regardless! He is mainly here because we felt bad saying no.
Jason Yoo
Meet Jason Yoo, he specializes in our Front-end unit 3 group! His contributions to what we have built do not go unnoticed!
The countless nights he has put in to make Design Your Life what it is, is beyond words, Jason's work ethic is outstanding as is his character!
Joe Denson
Meet Joe Denson, he is with our UI group! His out of the box thinking is what makes him shine!
He joined our team to conquor and help better lives, he has done just so if you ask us!
Daniel Wallen
Meet Daniel Wallen, he is on the Front-End unit 2 team! He specializes in many things, a very kind person with the skills and drive for the cherry on top!
He makes websites for animal shelters on his spare time, a task that we here at Design Your Life can also appreaciate!
Adrian Cobon
Meet Adrian Cobon, he along the side of Daniel is with our Front-End unit 2 team! A killer combo when it comes to a front end team.
Skills, talent or whatever you may call it; Adrian has it!
Tara Gamache
Meet Tara Gamache, she is a warrior! She is with the UI group, and makes her statement by dominating the programming industry!
Tara is a bright woman, who has just of a bright future! She is our piece to our puzzle that we could not be complete without!
Blake Goms
Meet Blake Goms, the lone wolf in our back-end! Some say he is the smartest person we got! I'd have to agree, don't you?
Blake not only does the back-end for Design Your Life but he is the glue that keeps us together with his ambitious attitude to reach amazing heights! All the while pushing us to do the same.
Richard Lawson
Meet Richard Lawson, he is with our Front-End unit 3 team! Richard has the ability to solve problems like a mad man!
Not only can he solve problems effortlessly, he can also see what it takes to get to the finish line seemingly before anyone else!