Willets Point is an industrial neighborhood near Citi Field in Queens that is currently going under redevelopment. The neighborhood was previously home to hundreds of auto shops, many of which have recently relocated from the neighborhood after being bought out to make room for the redevelopment project. The redevelopment plan called for new retail and residential areas, which includes 1,925 affordable housing units. However, the city changed plans— affordable housing will no longer be guaranteed, and instead, land developers want to build a shopping center. This is a big problem because many residents have been promised affordable housing for a long time.
And so, our team aims to bring affordable housing to Willets Point to create a better neighborhood for all.
A major strength of Willets Point is its accessibility to other neighborhoods such as Flushing and Corona, since it is surrounded by the Whitestone Expressway, Northern Boulevard, and Van Wyck Expressway. This means that it has the potential to be a commercial hub in addition to providing housing. We looked at various sets of data and created our own maps to determine what Willets Point has access to and what could be worked on. In the maps below, Willets Point is colored in blue.
How do we want to incorporate affordable housing into Willets Point? Currently, the area is under cleaning before any building can begin. When clean up is done, Willets Points needs to be rezoned from its current zoning, commercial district C4-4, to allow for more housing to be built. We want to layout Willets Point with a main residential area as well as a commercial buffer area. Click on the map to explore each part of our plan.
We decided to follow the layout of many other 7 train stations and have the commercial area be closest to the subway stop. This will allow for the stores in Willets Point to be more accessible to outsiders, making the area more convenient. This side is closest to the Citi Field and Flushing Meadows Corona Park, and works as a commercial buffer area between the residential area and the busier surroundings. The area is shown in green in the map.
We want to rezone Willets Point to higher density zoning so that affordable housing can be more easily built. We would like to implement the 80/20 government program and have 40% of the future housing units designated for affordable housing. The inner corner of the triangle (in dark blue) will be R7D zoning, which will have 10-story apartments. The northeastern part of Willets Point (in light blue) will be R6 medium density housing, with 6-7- story apartments. We chose these zonings because they had the cheaper rents in Flushing.
Along Northern Blvd and Roosevelt Avenue across Flushing Creek, we hope to build pedestrian walkways to help better connect Willets Point with Downtown Flushing (the black lines on the map). We also want to build a new elementary school (shown by the marker), so that younger children who cannot commute far alone can have access to education close to home.
A list of resources we used for our project.
311 Complaints
List of Libraries
List of Public Schools
Location Affordability Index v 2.0
80/20 Housing Program
Supermarkets from Yelp
Rent Prices from Zillow
Start Bootstrap
Leaflet.Sleep.js
Census Tracts GEOjson
Python3 (folium, pygeocoder, scipy)
WILLETS "ON-POINT" HOUSING PROJECT by Ahalya Sanjiv, Jane Chen, Jamie Fung, Vincent Yu & James Wong
View Project on GitHub


Practicing HTML & CSS at Home
Just Messing Around With Different Compenents
Daily Schedule Mon-Friday:
- 6am- Prepare Breakfast
- 6:30-Training
- 9:20- Start walking
- Amagi Academy 10am-6pm
- 6:30pm- Training
- 8pm- Prepare Dinner
- 9pm-Bed
Monthly Reminders:
- Pay Electrcity, Water, Wifi
- Pay Monthyl Rent
- Make sure ive done grocerys
- Clean Apartment


AR(1) GNU Development Tools AR(1) NAME ar - create, modify, and extract from archives SYNOPSIS ar [--plugin name] [-X32_64] [-]p[mod [relpos] [count]] archive [member...] DESCRIPTION The GNU ar program creates, modifies, and extracts from archives. An archive is a single file holding a collection of other files in a structure that makes it possible to retrieve the original individual files (called members of the archive). The original files' contents, mode (permissions), timestamp, owner, and group are preserved in the archive, and can be restored on extraction. GNU ar can maintain archives whose members have names of any length; however, depending on how ar is configured on your system, a limit on member-name length may be imposed for compatibility with archive formats maintained with other tools. If it exists, the limit is often 15 characters (typical of formats related to a.out) or 16 characters (typical of formats related to coff). ar is considered a binary utility because archives of this sort are most often used as libraries holding commonly needed subroutines. ar creates an index to the symbols defined in relocatable object modules in the archive when you specify the modifier s. Once created, this index is updated in the archive whenever ar makes a change to its contents (save for the q update operation). An archive with such an index speeds up linking to the library, and allows routines in the library to call each other without regard to their placement in the archive. You may use nm -s or nm --print-armap to list this index table. If an archive lacks the table, another form of ar called ranlib can be used to add just the table. GNU ar can optionally create a thin archive, which contains a symbol index and references to the original copies of the member files of the archives. Such an archive is useful for building libraries for use within a local build, where the relocatable objects are expected to remain available, and copying the contents of each object would only waste time and space. Thin archives are also flattened, so that adding one or more archives to a thin archive will add the elements of the nested archive individually. The paths to the elements of the archive are stored relative to the archive itself. GNU ar is designed to be compatible with two different facilities. You can control its activity using command-line options, like the different varieties of ar on Unix systems; or, if you specify the single command- line option -M, you can control it with a script supplied via standard input, like the MRI "librarian" program. OPTIONS GNU ar allows you to mix the operation code p and modifier flags mod in any order, within the first command-line argument. If you wish, you may begin the first command-line argument with a dash. The p keyletter specifies what operation to execute; it may be any of the following, but you must specify only one of them: d Delete modules from the archive. Specify the names of modules to be deleted as member...; the archive is untouched if you specify no files to delete. If you specify the v modifier, ar lists each module as it is deleted. m Use this operation to move members in an archive. The ordering of members in an archive can make a difference in how programs are linked using the library, if a symbol is defined in more than one member. If no modifiers are used with "m", any members you name in the member arguments are moved to the end of the archive; you can use the a, b, or i modifiers to move them to a specified place instead. p Print the specified members of the archive, to the standard output file. If the v modifier is specified, show the member name before copying its contents to standard output. If you specify no member arguments, all the files in the archive are printed. q Quick append; Historically, add the files member... to the end of archive, without checking for replacement. The modifiers a, b, and i do not affect this operation; new members are always placed at the end of the archive. The modifier v makes ar list each file as it is appended. Since the point of this operation is speed, the archive's symbol table index is not updated, even if it already existed; you can use ar s or ranlib explicitly to update the symbol table index. However, too many different systems assume quick append rebuilds the index, so GNU ar implements q as a synonym for r. r Insert the files member... into archive (with replacement). This operation differs from q in that any previously existing members are deleted if their names match those being added. If one of the files named in member... does not exist, ar displays an error message, and leaves undisturbed any existing members of the archive matching that name. By default, new members are added at the end of the file; but you may use one of the modifiers a, b, or i to request placement relative to some existing member. The modifier v used with this operation elicits a line of output for each file inserted, along with one of the letters a or r to indicate whether the file was appended (no old member deleted) or replaced. t Display a table listing the contents of archive, or those of the files listed in member... that are present in the archive. Normally only the member name is shown; if you also want to see the modes (permissions), timestamp, owner, group, and size, you can request that by also specifying the v modifier. If you do not specify a member, all files in the archive are listed. If there is more than one file with the same name (say, fie) in an archive (say b.a), ar t b.a fie lists only the first instance; to see them all, you must ask for a complete listing---in our example, ar t b.a. x Extract members (named member) from the archive. You can use the v modifier with this operation, to request that ar list each name as it extracts it. If you do not specify a member, all files in the archive are extracted. Files cannot be extracted from a thin archive. A number of modifiers (mod) may immediately follow the p keyletter, to specify variations on an operation's behavior: a Add new files after an existing member of the archive. If you use the modifier a, the name of an existing archive member must be present as the relpos argument, before the archive specification. b Add new files before an existing member of the archive. If you use the modifier b, the name of an existing archive member must be present as the relpos argument, before the archive specification. (same as i). c Create the archive. The specified archive is always created if it did not exist, when you request an update. But a warning is issued unless you specify in advance that you expect to create it, by using this modifier. D Operate in deterministic mode. When adding files and the archive index use zero for UIDs, GIDs, timestamps, and use consistent file modes for all files. When this option is used, if ar is used with identical options and identical input files, multiple runs will create identical output files regardless of the input files' owners, groups, file modes, or modification times. f Truncate names in the archive. GNU ar will normally permit file names of any length. This will cause it to create archives which are not compatible with the native ar program on some systems. If this is a concern, the f modifier may be used to truncate file names when putting them in the archive. i Insert new files before an existing member of the archive. If you use the modifier i, the name of an existing archive member must be present as the relpos argument, before the archive specification. (same as b). l This modifier is accepted but not used. N Uses the count parameter. This is used if there are multiple entries in the archive with the same name. Extract or delete instance count of the given name from the archive. o Preserve the original dates of members when extracting them. If you do not specify this modifier, files extracted from the archive are stamped with the time of extraction. P Use the full path name when matching names in the archive. GNU ar can not create an archive with a full path name (such archives are not POSIX complaint), but other archive creators can. This option will cause GNU ar to match file names using a complete path name, which can be convenient when extracting a single file from an archive created by another tool. s Write an object-file index into the archive, or update an existing one, even if no other change is made to the archive. You may use this modifier flag either with any operation, or alone. Running ar s on an archive is equivalent to running ranlib on it. S Do not generate an archive symbol table. This can speed up building a large library in several steps. The resulting archive can not be used with the linker. In order to build a symbol table, you must omit the S modifier on the last execution of ar, or you must run ranlib on the archive. T Make the specified archive a thin archive. If it already exists and is a regular archive, the existing members must be present in the same directory as archive. u Normally, ar r... inserts all files listed into the archive. If you would like to insert only those of the files you list that are newer than existing members of the same names, use this modifier. The u modifier is allowed only for the operation r (replace). In particular, the combination qu is not allowed, since checking the timestamps would lose any speed advantage from the operation q. v This modifier requests the verbose version of an operation. Many operations display additional information, such as filenames processed, when the modifier v is appended. V This modifier shows the version number of ar. ar ignores an initial option spelt -X32_64, for compatibility with AIX. The behaviour produced by this option is the default for GNU ar. ar does not support any of the other -X options; in particular, it does not support -X32 which is the default for AIX ar. The optional command line switch --plugin name causes ar to load the plugin called name which adds support for more file formats. This option is only available if the toolchain has been built with plugin support enabled. @file Read command-line options from file. The options read are inserted in place of the original @file option. If file does not exist, or cannot be read, then the option will be treated literally, and not removed. Options in file are separated by whitespace. A whitespace character may be included in an option by surrounding the entire option in either single or double quotes. Any character (including a backslash) may be included by prefixing the character to be included with a backslash. The file may itself contain additional @file options; any such options will be processed recursively. SEE ALSO nm(1), ranlib(1), and the Info entries for binutils. COPYRIGHT Copyright (c) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License". binutils-2.20 2009-10-16 AR(1)


 MARK
THE HOLY GOSPEL OF JESUS CHRIST ACCORDING TO ST. MARK
Book 49 Luke
THE HOLY GOSPEL OF JESUS CHRIST ACCORDING TO ST. LUKE
THE HOLY GOSPEL OF JESUS CHRIST ACCORDING TO ST. LUKE
Book 50 John
THE HOLY GOSPEL OF JESUS CHRIST ACCORDING TO ST. JOHN
THE HOLY GOSPEL OF JESUS CHRIST ACCORDING TO ST. JOHN
Book 51 Acts
THE ACTS OF THE APOSTLES
THE ACTS OF THE APOSTLES
Book 52 Romans
THE EPISTLE OF ST. PAUL THE APOSTLE TO THE ROMANS
THE EPISTLE OF ST. PAUL THE APOSTLE TO THE ROMANS
Book 53 1 Corinthians
THE FIRST EPISTLE OF ST. PAUL TO THE CORINTHIANS
THE FIRST EPISTLE OF ST. PAUL TO THE CORINTHIANS
Book 54 2 Corinthians
THE SECOND EPISTLE OF ST. PAUL TO THE CORINTHIANS
THE SECOND EPISTLE OF ST. PAUL TO THE CORINTHIANS
Book 55 Galatians
THE EPISTLE OF ST. PAUL TO THE GALATIANS
THE EPISTLE OF ST. PAUL TO THE GALATIANS
Book 56 Ephesians
THE EPISTLE OF ST. PAUL TO THE EPHESIANS
THE EPISTLE OF ST. PAUL TO THE EPHESIANS
Book 57 Philippians
THE EPISTLE OF ST. PAUL TO THE PHILIPPIANS
THE EPISTLE OF ST. PAUL TO THE PHILIPPIANS
Book 58 Colossians
THE EPISTLE OF ST. PAUL TO THE COLOSSIANS
THE EPISTLE OF ST. PAUL TO THE COLOSSIANS
Book 59 1 Thessalonians
THE FIRST EPISTLE OF ST. PAUL TO THE THESSALONIANS
THE FIRST EPISTLE OF ST. PAUL TO THE THESSALONIANS
Book 60 2 Thessalonians
THE SECOND EPISTLE OF ST. PAUL TO THE THESSALONIANS
THE SECOND EPISTLE OF ST. PAUL TO THE THESSALONIANS
Book 61 1 Timothy
THE FIRST EPISTLE OF ST. PAUL TO TIMOTHY
THE FIRST EPISTLE OF ST. PAUL TO TIMOTHY
Book 62 2 Timothy
THE SECOND EPISTLE OF ST. PAUL TO TIMOTHY
THE SECOND EPISTLE OF ST. PAUL TO TIMOTHY
Book 63 Titus
THE EPISTLE OF ST. PAUL TO TITUS
THE EPISTLE OF ST. PAUL TO TITUS
Book 64 Philemon
THE EPISTLE OF ST. PAUL TO PHILEMON
THE EPISTLE OF ST. PAUL TO PHILEMON
Book 65 Hebrews
THE EPISTLE OF ST. PAUL TO THE HEBREWS
THE EPISTLE OF ST. PAUL TO THE HEBREWS
Book 66 James
THE CATHOLIC EPISTLE OF ST. JAMES THE APOSTLE
THE CATHOLIC EPISTLE OF ST. JAMES THE APOSTLE
Book 67 1 Peter
THE FIRST EPISTLE OF ST. PETER THE APOSTLE
THE FIRST EPISTLE OF ST. PETER THE APOSTLE
Book 68 2 Peter
THE SECOND EPISTLE OF ST. PETER THE APOSTLE
THE SECOND EPISTLE OF ST. PETER THE APOSTLE
Book 69 1 John
THE FIRST EPISTLE OF ST. JOHN THE APOSTLE
THE FIRST EPISTLE OF ST. JOHN THE APOSTLE
Book 70 2 John
THE SECOND EPISTLE OF ST. JOHN THE APOSTLE
THE SECOND EPISTLE OF ST. JOHN THE APOSTLE
Book 71 3 John
THE THIRD EPISTLE OF ST. JOHN THE APOSTLE
THE THIRD EPISTLE OF ST. JOHN THE APOSTLE
Book 72 Jude
THE CATHOLIC EPISTLE OF ST. JUDE
THE CATHOLIC EPISTLE OF ST. JUDE
Book 73 Apocalypse
THE APOCALYPSE OF ST. JOHN THE APOSTLE
THE APOCALYPSE OF ST. JOHN THE APOSTLE
next page


Store files securely
Expire files automatically
Own your information
Governments around the world have repeatedly shown a callous
disregard for individual privacy. Warrantless searches of personal
information abound. Haven gives back the power of high-grade
secrecy to the masses.
Your files are safe with us.
Haven works by ensuring that your files never pass over any network connection. Before any communication occurs between your computer and our servers, Haven encrypts your files using the proven Blowfish cipher. Even if someone were to listen to every last packet of information exchanged, they would be no closer to having your data.


What do you want to do?


| Class | Description |
|---|---|
| AgentInfo | |
| AgentInfos |
Ontology contains
List ,
list of informations about PikaterAgents |
| ExternalAgentNames | |
| GetAgentInfo |
Request for a
AgentInfo object of the given agent specified
by the GetAgentInfo.agentClassName field. |
| GetAgentInfos |
Request for
AgentInfo objects for all computation
related agents approved to be used - all internal agents
and approved user agents. |
| GetAgentInfoVisibleForUser | |
| GetAllAgentInfos |
Request for
AgentInfo objects of all system and user agents,
whether approved or not. |
| GetExternalAgentNames |
Request for class names of all user agents.
|
| GetOptions | |
| GetYourAgentInfo | |
| SaveAgentInfo | |
| Slot |


Back
Show and hide filters
Filters when open
The filter styles here are shown to indicate that there are a number of ways you could filter the content.
Hide filters
Selecting the ‘Hide filters’ toggle closes the filter section and moves the content to the left.


I started to develop a long time ago when web systems was made with tables. And since then have not stopped.
Soon after i started programming using C and PHP, so began my passion for algorithms. After completing my Bachelor of Science in Computer Science, at the best university in my city, with more accurate mathematical thoughts, i learned Java and NodeJs.
Planning a project from start to finish is a pleasure, seeking to deliver to the user a product that helps him with quick answers and that he does not need to think much about what he should do (UX/UI).


settings
Settings/Sign Out
add_alert
Notification Icon
ORG NAME(org image above)
<EMAIL_ADDRESS>dashboard
Dashboard
today
Calendar of special deadlines
menu
Nature of the Activity
Select Nature of Activity
Academic
Special Interest
Departmental Initiative
Fundraising
Community Engagement
Organizational Development
Issue Advocacy
Lasallian Formation/Spiritual Growth
Outreach
Type of Activity
Select Type of Activity
Acquaintance Party (On-Campus)
Concerts
Contests
Food Fest
Fund-Raising Activity (Nature Dependent)
Meidcal/Dental Mission
Novelty Item Selling
OCCS-Sponsored Seminar
Outreach
Participation in Contest/Seminars/Variety Shows
Party
Press Conference
Radio/Press/TV coverage of an Event
Raffles
Recollection/Retreat (Off-Campus)
Scholarship Grant
Solicitations
Sport's Fest/Tournament (Off-Campus)
Teambuilding (Off-Campus)
Ticket Selling
TV Interview
TV/Radio Guesting
Generic Off-Campus Activity (Nature Dependent)
Generic Tie-Up Activity (Nature Dependent)
Post-Activity Requirements
Pre-Activity Requirements
General Attendance Log-Sheet
List of Expenses
List of Pictures
Activity Report
Downloadable Form(s)
Click to Download!
Upcoming Deadlines
10/27/2016 | Event Name
.


 It is designed to make it simple to take data in, turn it into work to be done by people, and generate results that can be used to feed statistical analysis. Clickwork is free and open source software released by Nokia under the MIT/X11 License.
Clickwork helps you:
Clickwork is especially well suited to building groundtruth data sets for training and evaluation of supervised machine learning systems.
For example, when building a search engine, one might want to have humans manual "rate" different possible responses to large numbers of queries (10^3 to 10^6). Clickwork allows you to define such a job, assign it to many clickworkers (10^2 to 10^5), and save their inputs.


Chromium Example User Interface
(Web UI wrapped in a native macOS Application)
Demonstrates HTML/Javascript control & interaction with the App
Some things you can do from this UI, for example:
Control resources that the app-side has exclusive access to, like the file system...
Or simply Log Out


About this project
What is a food desert?
A food desert is defined as a geographical area that lacks grocery stores with a 1 mile radius in an urban setting and 10 mile radius in an urban desert.
What is being done to tackle food deserts?
- Food policy council to better food distribution
- Getting convenience stores to sell healthier foods
- Farmer’s markets
- Subsidized supermarkets
Resources
- DataLA: Information, Insights, and Analysis from the City of Angels
- Food Deserts, Food Empowerment Project
- Community Health Councils
- UCLA Center for Health Policy Research
- City Government, City of Los Angeles
- Department of Public Health, Los Angeles County
- Day-to-day steps, Los Angeles Food Policy Council
- Finding Nutrition in the Food Deserts of California (Pacific Standard)
- Food Access Research Atlas, USDA
- PolicyLink
- America’s Food Deserts Need Community Solutions, Not Big Box Stores (Civil Eats)
- Food Deserts, Societal Impacts, and Potential Solutions (PDF)
- The Grocery Gap, Who Has Access to Health Food and Why It Matters (PolicyLink)
- The Food Trust
- Studies Question the Pairing of Food Deserts and Obesity (The New York Times)
About this website
This website was put together during the Civic Hack Nights at Hack for LA, a part of Code for America.
If you have a question or want to help, please send a message to fooddesertsla@gmail.com


---
layout: post
title: The Powers of Certification
date: '2007-09-21T15:14:00.000-05:00'
author: Don Seiler
tags:
- oca
- oracle
- dilbert
modified_time: '2010-11-19T22:48:46.090-06:00'
thumbnail: http://1.bp.blogspot.com/_BsyNTxK8QhM/RvQmjtvcEvI/AAAAAAAAABs/0aLYLEXY4cY/s72-c/DilbertCertification.jpg
blogger_id: tag:blogger.com,1999:blog-7032512792942232766.post-1821917916004386712
blogger_orig_url: http://www.seiler.us/2007/09/powers-of-certification.html
---
On the heels of my recent OCAfication, I came across "The power of Oracle certification" which mentions this Dilbert comic that I hadn't seen and made me chuckle. Enjoy.


Anyone can use the following link to get access to the data from this dataset from our API in JSON format.
Alternatively, anyone can use the following link to download the entire dataset in CSV format.


Post Query Functions¶
In this section, we will cover the following functions in-depth listed below:
uadmin.APIPostQueryAdd¶
APIPostQueryAdd controls the data API’s post query for add commands. By default, APIPostQueryAdd returns false.
Type:
bool
uadmin.APIPostQueryAdder¶
APIPostQueryAdder is an interface for models to run after processing add function in dAPI and before returning the results. Returning false stops the rest of the process from happening.
Type:
interface
uadmin.APIPostQueryDelete¶
APIPostQueryDelete controls the data API’s post query for delete commands. By default, APIPostQueryDelete returns false.
Type:
bool
uadmin.APIPostQueryDeleter¶
APIPostQueryDeleter is an interface for models to run after processing delete function in dAPI and before returning the results. Returning false stops the rest of the process from happening.
Type:
interface
uadmin.APIPostQueryEdit¶
APIPostQueryEdit controls the data API’s post query for edit commands. By default, APIPostQueryEdit returns false.
Type:
bool
uadmin.APIPostQueryEditor¶
APIPostQueryEditor is an interface for models to run after processing edit function in dAPI and before returning the results. Returning false stops the rest of the process from happening.
Type:
interface
uadmin.APIPostQueryRead¶
APIPostQueryRead controls the data API’s post query for read commands. By default, APIPostQueryRead returns false.
Type:
bool
uadmin.APIPostQueryReader¶
APIPostQueryReader is an interface for models to run after processing read function in dAPI and before returning the results. Returning false stops the rest of the process from happening.
Type:
interface
uadmin.APIPostQuerySchema¶
APIPostQuerySchema controls the data API’s post query for schema commands. By default, APIPostQuerySchema returns false.
Type:
bool
uadmin.APIPostQuerySchemer¶
APIPostQuerySchemer is an interface for models to run after processing schema function in dAPI and before returning the results. Returning false stops the rest of the process from happening.
Type:
interface


{% extends 'base.html' %} {% block title %}Forgot Password - imageX{% endblock %} {% block content %}
Enter the email address you have registered with imageX below, and we'll email instructions for setting a new one.


'br}
'br}
{\
diagnostics, splain - produce verbose warning diagnostics
Using the f(CW*(C`diagnostics*(C' pragma:
use diagnostics; use diagnostics -verbose;
enable diagnostics; disable diagnostics;
Using the f(CW*(C`splain*(C' standalone filter program:
perl program 2>diag.out splain [-v] [-p] diag.out
Using diagnostics to get stack traces from a misbehaving script:
perl -Mdiagnostics=-traceonly my_script.pl
This module extends the terse diagnostics normally emitted by both the perl compiler and the perl interpreter (from running perl with a -w switch or f(CW*(C`use warnings*(C'), augmenting them with the more explicative and endearing descriptions found in perldiag. Like the other pragmata, it affects the compilation phase of your program rather than merely the execution phase.
To use in your program as a pragma, merely invoke
use diagnostics;
at the start (or near the start) of your program. (Note that this does enable perl's -w flag.) Your whole compilation will then be subject(ed :-) to the enhanced diagnostics. These still go out s-1STDERRs0.
Due to the interaction between runtime and compiletime issues, and because it's probably not a very good idea anyway, you may not use f(CW*(C`no diagnostics*(C' to turn them off at compiletime. However, you may control their behaviour at runtime using the disable() and enable() methods to turn them off and on respectively.
The -verbose flag first prints out the perldiag introduction before any other diagnostics. The f(CW$diagnostics::PRETTY variable can generate nicer escape sequences for pagers.
Warnings dispatched from perl itself (or more accurately, those that match descriptions found in perldiag) are only displayed once (no duplicate descriptions). User code generated warnings a la warn() are unaffected, allowing duplicate user messages to be displayed.
This module also adds a stack trace to the error message when perl dies. This is useful for pinpointing what caused the death. The -traceonly (or just -t) flag turns off the explanations of warning messages leaving just the stack traces.  By supplying the -warntrace (or just -w) flag, any warnings emitted will also come with a stack trace.
While apparently a whole nuther program, splain is actually nothing more than a link to the (executable) diagnostics.pm module, as well as a link to the diagnostics.pod documentation. The -v flag is like the f(CW*(C`use diagnostics -verbose*(C' directive. The -p flag is like the f(CW$diagnostics::PRETTY variable. Since you're post-processing with splain, there's no sense in being able to enable() or disable() processing.
Output from splain is directed to s-1STDOUTs0, unlike the pragma.
The following file is certain to trigger a few errors at both runtime and compiletime:
use diagnostics; print NOWHERE "nothingen"; print STDERR "enetThis message should be unadorned.en"; warn "etThis is a user warning"; print "enDIAGNOSTIC TESTER: Please enter a <CR> here: "; my $a, $b = scalar <STDIN>; print "en"; print $x/$y;
If you prefer to run your program first and look at its problem afterwards, do this:
perl -w test.pl 2>test.out ./splain < test.out
Note that this is not in general possible in shells of more dubious heritage, as the theoretical
(perl -w test.pl >/dev/tty) >& test.out ./splain < test.out
Because you just moved the existing stdout to somewhere else.
If you don't want to modify your source code, but still have on-the-fly warnings, do this:
exec 3>&1; perl -w test.pl 2>&1 1>&3 3>&- | splain 1>&2 3>&-
Nifty, eh?
If you want to control warnings on the fly, do something like this. Make sure you do the f(CW*(C`use*(C' first, or you won't be able to get at the enable() or disable() methods.
use diagnostics; # checks entire compilation phase print "entime for 1st bogus diags: SQUAWKINGSen"; print BOGUS1 *(Aqnada*(Aq; print "done with 1st bogusen";
disable diagnostics; # only turns off runtime warnings print "entime for 2nd bogus: (squelched)en"; print BOGUS2 *(Aqnada*(Aq; print "done with 2nd bogusen";
enable diagnostics; # turns back on runtime warnings print "entime for 3rd bogus: SQUAWKINGSen"; print BOGUS3 *(Aqnada*(Aq; print "done with 3rd bogusen";
disable diagnostics; print "entime for 4th bogus: (squelched)en"; print BOGUS4 *(Aqnada*(Aq; print "done with 4th bogusen";
Diagnostic messages derive from the perldiag.pod file when available at runtime. Otherwise, they may be embedded in the file itself when the splain package is built. See the Makefile for details.
If an extant f(CW$SIG{_|_WARN_|_} handler is discovered, it will continue to be honored, but only after the diagnostics::splainthis() function (the module's f(CW$SIG{_|_WARN_|_} interceptor) has had its way with your warnings.
There is a f(CW$diagnostics::DEBUG variable you may set if you're desperately curious what sorts of things are being intercepted.
BEGIN { $diagnostics::DEBUG = 1 }
Not being able to say *(L"no diagnostics*(R" is annoying, but may not be insurmountable.
The f(CW*(C`-pretty*(C' directive is called too late to affect matters.
BEGIN { $diagnostics::PRETTY = 1 }
I could start up faster by delaying compilation until it should be needed, but this gets a *(L"panic: top_level*(R" when using the pragma form in Perl 5.001e.
While it's true that this documentation is somewhat subserious, if you use a program named splain, you should expect a bit of whimsy.
Tom Christiansen<EMAIL_ADDRESS>25 June 1995.


Issue: DEFSTRUCT-COPIERReferences: DEFSTRUCT
Related issues:
Category: CLARIFICATION, CHANGE
Edit history: V1, 10 May 90, Sandra Loosemore
V2, 13 May 90, Sandra Loosemore (update discussion)
V3, 29 May 90, Sandra Loosemore (more comments)
Problem description:
The description of the :COPIER option to DEFSTRUCT in CLtL
states:
The automatically defined copier function simply makes a new
structure and transfers all components verbatim from the argument
into the newly created structure.
This description doesn't make it clear whether the type of the
newly created structure is copied from the argument, or is
determined by the copier function. This can make a difference
in the case where a copier function defined for one structure
type is passed an argument that belongs to a subtype of the
original type. Does the result have the "name" of the subtype
and any additional slots present in the subtype but not the
parent type, or does it have the same "name" as the parent
type and only the slots inherited from that type?
There are four proposals: ARGUMENT-TYPE, COPIER-TYPE,
UNSPECIFIED, and REMOVE.
Proposal (DEFSTRUCT-COPIER:ARGUMENT-TYPE):
Clarify that the type of the result returned by copier functions
created by DEFSTRUCT is always exactly the same type as the
argument to the copier. That is, if the argument is of a
subtype of the structure type for which the copier was defined,
then the result will also be of that subtype and include all
the slots of the subtype.
Rationale for proposal ARGUMENT-TYPE:
Some people expect this behavior.
Proposal (DEFSTRUCT-COPIER:COPIER-TYPE):
Clarify that the type of the result returned by copier functions
created by DEFSTRUCT is always exactly the structure type for
which the copier was defined. That is, if the argument is of a
subtype of the structure type for which the copier was defined,
the result will be of the supertype only and include only those
slots that are present in the supertype.
Rationale for proposal COPIER-TYPE:
Some people expect this behavior.
Proposal (DEFSTRUCT-COPIER:UNSPECIFIED):
Clarify that it is unspecified whether the type of the result
returned by copier functions created by DEFSTRUCT is the type
of the argument to the copier, or the structure type for which the
copier function was defined. (In other words, the behavior of
copier functions is well-defined only when they are passed
arguments of the exact same type for which the copier was
defined.)
Rationale for proposal UNSPECIFIED:
Some people don't know what behavior to expect.
Proposal (DEFSTRUCT-COPIER:REMOVE):
Remove the :COPIER option to DEFSTRUCT.
Rationale for proposal REMOVE:
The feature is so poorly specified it's already useless.
Examples:
(defstruct foo a b)
(defstruct (bar (:include foo)) c d)
(setq result (copy-foo (make-bar)))
Under proposal ARGUMENT-TYPE,
(type-of result) => BAR
Under proposal COPIER-TYPE,
(type-of result) => FOO
Under proposal UNSPECIFIED,
(type-of result) => either FOO or BAR
Under proposal REMOVE, users would have to define their own
copier functions to have whatever behavior they wanted.
Current Practice:
Some Lisps now implement proposal ARGUMENT-TYPE and others implement
proposal COPIER-TYPE. Some Lisps also provide a COPY-STRUCTURE
function that can be used to make an exact duplicate of any
structure object.
Cost to Implementors:
Small.
Cost to Users:
Code that relies on any particular behavior is probably not now
portable anyway. It doesn't seem like copiers are used very
much.
Cost of non-adoption:
This part of the language specification remains vague.
Performance impact:
Proposal REMOVE would save space since there would be no
normally useless copier functions generated by DEFSTRUCT.
It may be that copier functions defined by hand would be
considerably less efficient than a copier provided by the
implementation (which might make use of knowledge about the
internal layout of structures to do a block memory copy or the
like).
Benefits:
This part of the language specification becomes more precise.
Esthetics:
Leaving the behavior explicitly vague seems unnecessarily ugly.
Discussion:
Loosemore's ranking of the proposals from most to least
acceptable is: ARGUMENT-TYPE, REMOVE, COPIER-TYPE,
UNSPECIFIED.
BarMar has said he thinks the behavior should be left
unspecified.
Moon has said he favors flushing the :copier feature. Barrett
also prefers flushing :copier.
Perhaps we should consider adding COPY-STRUCTURE to the
standard?
-------


A PortletResourceURLFactory can be used to generate an url for direct rendering of a Portlet, comparable (but more limited)
to what Portlet 2.0 (likely) is going to provide when it introduces ResourceURLs.
Proxy for a Servlet HttpSession to attach to a PortletSession, providing only access to PORTLET_SCOPE session attributes
and hiding the APPLICATION_SCOPE attributes from the Servlet.


Public Member Functions | |
| ApiInvoker | getInvoker () |
| void | setBasePath (string basePath) |
| String | getBasePath () |
| List< Datasource > | listDatasources (string token) |
| Lists all data sources More... | |
| string | listDatasourcesAsString (string token) |
| Lists all data sources More... | |
| List< Datasource > | listCategoryDatasources (string category, string token) |
| Lists all data sources in a specific category More... | |
| string | listCategoryDatasourcesAsString (string category, string token) |
| Lists all data sources in a specific category More... | |
| Success | createDatasource (string category, string name, string token, bool _default, string body) |
| Creates a new data source More... | |
| string | createDatasourceAsString (string category, string name, string token, bool _default, string body) |
| Creates a new data source More... | |
| object | getDatasource (string category, string datasource, string token) |
| Retrieves a data source credentials More... | |
| string | getDatasourceAsString (string category, string datasource, string token) |
| Retrieves a data source credentials More... | |
| Success | updateDatasource (string category, string datasource, string token, string name, bool _default, string body) |
| Updates a data source More... | |
| string | updateDatasourceAsString (string category, string datasource, string token, string name, bool _default, string body) |
| Updates a data source More... | |
| Success | removeDatasource (string category, string datasource, string token) |
| Removes a data source More... | |
| string | removeDatasourceAsString (string category, string datasource, string token) |
| Removes a data source More... | |
| List< Collection > | getDatasourceContents (string category, string datasource, string token) |
| List available collections More... | |
| string | getDatasourceContentsAsString (string category, string datasource, string token) |
| List available collections More... | |
| Success | createCollection (string category, string datasource, string name, string token) |
| Creates collection More... | |
| string | createCollectionAsString (string category, string datasource, string name, string token) |
| Creates collection More... | |
| Collection | getCollectionMetadata (string category, string datasource, string collection, string token) |
| Retrieves metadata about a collection More... | |
| string | getCollectionMetadataAsString (string category, string datasource, string collection, string token) |
| Retrieves metadata about a collection More... | |
| Success | removeCollection (string category, string datasource, string collection, string token) |
| Removes a collection More... | |
| string | removeCollectionAsString (string category, string datasource, string collection, string token) |
| Removes a collection More... | |
| CollectionList28IO | listCollection (string category, string datasource, string collection, string token, int offset, int limit, bool expand) |
| Lists collection items More... | |
| string | listCollectionAsString (string category, string datasource, string collection, string token, int offset, int limit, bool expand) |
| Lists collection items More... | |
| Success | insertInCollection (string category, string datasource, string collection, string token, string body) |
| Inserts an item into a collection More... | |
| string | insertInCollectionAsString (string category, string datasource, string collection, string token, string body) |
| Inserts an item into a collection More... | |
| Success | truncateCollection (string category, string datasource, string collection, string token) |
| Truncates a collection More... | |
| string | truncateCollectionAsString (string category, string datasource, string collection, string token) |
| Truncates a collection More... | |
| object | getItem (string category, string datasource, string collection, string identifier, string token) |
| Retrieves a collection item More... | |
| string | getItemAsString (string category, string datasource, string collection, string identifier, string token) |
| Retrieves a collection item More... | |
| Success | updateItem (string category, string datasource, string collection, string identifier, string token, string body) |
| Updates a collection item More... | |
| string | updateItemAsString (string category, string datasource, string collection, string identifier, string token, string body) |
| Updates a collection item More... | |
| Success | removeItem (string category, string datasource, string collection, string identifier, string token) |
| Removes an item from a collection More... | |
| string | removeItemAsString (string category, string datasource, string collection, string identifier, string token) |
| Removes an item from a collection More... | |
|
inline |
Creates collection
This method creates a new collection within a data source.
Currently, this method is only available for MongoDB data sources.
| category | The data source category. |
| datasource | The data source name. |
| name | The name of the new collection. |
| token | A project token. |
|
inline |
Creates collection
This method creates a new collection within a data source.
Currently, this method is only available for MongoDB data sources.
| category | The data source category. |
| datasource | The data source name. |
| name | The name of the new collection. |
| token | A project token. |
|
inline |
Creates a new data source
This method creates a new data source. According to the specified data source category, the connection to the data source will be tested within this method. If the test does not pass the credentials will not be stored and the reponse status code will be set to 422.
Currently, the default MongoDB data source cannot be created using this method.
| category | The data source category. |
| name | The name of the data source. The data source name can contain any alphabetic letter, numbers, dots, or dashes, and must start with an alphabetic letter. |
| token | A project token. |
| _default | Whether the new data source will be the default one for its category. The default value is false. |
| body | The data sources credentials as JSON. |
|
inline |
Creates a new data source
This method creates a new data source. According to the specified data source category, the connection to the data source will be tested within this method. If the test does not pass the credentials will not be stored and the reponse status code will be set to 422.
Currently, the default MongoDB data source cannot be created using this method.
| category | The data source category. |
| name | The name of the data source. The data source name can contain any alphabetic letter, numbers, dots, or dashes, and must start with an alphabetic letter. |
| token | A project token. |
| _default | Whether the new data source will be the default one for its category. The default value is false. |
| body | The data sources credentials as JSON. |
|
inline |
Retrieves metadata about a collection
This method retrieves the metadata of a collection.
Currently, this method is only available for MongoDB data sources.
| category | The data source category. |
| datasource | The data source name. |
| collection | The collection name. |
| token | A project token. |
|
inline |
Retrieves metadata about a collection
This method retrieves the metadata of a collection.
Currently, this method is only available for MongoDB data sources.
| category | The data source category. |
| datasource | The data source name. |
| collection | The collection name. |
| token | A project token. |
|
inline |
Retrieves a data source credentials
This method retrieves credentials from data source.
Currently, the default MongoDB credentials cannot be retrieved using this method.
| category | The data source category. |
| datasource | The data source name. |
| token | A project token. |
|
inline |
Retrieves a data source credentials
This method retrieves credentials from data source.
Currently, the default MongoDB credentials cannot be retrieved using this method.
| category | The data source category. |
| datasource | The data source name. |
| token | A project token. |
|
inline |
List available collections
This method retrieves the list of available collections from a data source.
Currently, this method is only available for MongoDB data sources.
| category | The data source category. |
| datasource | The data source name. |
| token | A project token. |
|
inline |
List available collections
This method retrieves the list of available collections from a data source.
Currently, this method is only available for MongoDB data sources.
| category | The data source category. |
| datasource | The data source name. |
| token | A project token. |
|
inline |
Retrieves a collection item
This method retrieves a collection item.
Currently, this method is only available for MongoDB data sources.
| category | The data source category. |
| datasource | The data source name. |
| collection | The collection name. |
| identifier | The item identifier. |
| token | A project token. |
|
inline |
Retrieves a collection item
This method retrieves a collection item.
Currently, this method is only available for MongoDB data sources.
| category | The data source category. |
| datasource | The data source name. |
| collection | The collection name. |
| identifier | The item identifier. |
| token | A project token. |
|
inline |
Inserts an item into a collection
This method inserts an item into a data source collection.
Currently, this method is only available for MongoDB data sources.
| category | The data source category. |
| datasource | The data source name. |
| collection | The collection name. |
| token | A project token. |
| body | The item to insert. |
|
inline |
Inserts an item into a collection
This method inserts an item into a data source collection.
Currently, this method is only available for MongoDB data sources.
| category | The data source category. |
| datasource | The data source name. |
| collection | The collection name. |
| token | A project token. |
| body | The item to insert. |
|
inline |
Lists all data sources in a specific category
This method retrieves the list of data sources from a specific category configured for the project. If no data source is present in the specified category an empty array is returned.
| category | The data source category. |
| token | A project token. |
|
inline |
Lists all data sources in a specific category
This method retrieves the list of data sources from a specific category configured for the project. If no data source is present in the specified category an empty array is returned.
| category | The data source category. |
| token | A project token. |
|
inline |
Lists collection items
This method retrieves a list of items a the collection.
Currently, this method is only available for MongoDB data sources.
| category | The data source category. |
| datasource | The data source name. |
| collection | The collection name. |
| token | A project token. |
| offset | The index of the first item from which to start listing the collection items. Default is 1. |
| limit | The number of collection items to list. Default is 10. |
| expand | Whether to include the serialized item in the listing. The default value is false. |
|
inline |
Lists collection items
This method retrieves a list of items a the collection.
Currently, this method is only available for MongoDB data sources.
| category | The data source category. |
| datasource | The data source name. |
| collection | The collection name. |
| token | A project token. |
| offset | The index of the first item from which to start listing the collection items. Default is 1. |
| limit | The number of collection items to list. Default is 10. |
| expand | Whether to include the serialized item in the listing. The default value is false. |
|
inline |
Lists all data sources
This method retrieves the data sources that are configured for a project.
| token | A project token. |
|
inline |
Lists all data sources
This method retrieves the data sources that are configured for a project.
| token | A project token. |
|
inline |
Removes a collection
This method removes a collection from a data source.
Currently, this method is only available for MongoDB data sources.
| category | The data source category. |
| datasource | The data source name. |
| collection | The collection name. |
| token | A project token. |
|
inline |
Removes a collection
This method removes a collection from a data source.
Currently, this method is only available for MongoDB data sources.
| category | The data source category. |
| datasource | The data source name. |
| collection | The collection name. |
| token | A project token. |
|
inline |
Removes a data source
This method removes a data source.
Currently, the default MongoDB data source cannot be deleted through this method.
| category | The data source category. |
| datasource | The data source name. |
| token | A project token. |
|
inline |
Removes a data source
This method removes a data source.
Currently, the default MongoDB data source cannot be deleted through this method.
| category | The data source category. |
| datasource | The data source name. |
| token | A project token. |
|
inline |
Removes an item from a collection
This method removes an item from a collection
Currently, this method is only available for MongoDB data sources.
| category | The data source category. |
| datasource | The data source name. |
| collection | The collection name. |
| identifier | The item identifier. |
| token | A project token. |
|
inline |
Removes an item from a collection
This method removes an item from a collection
Currently, this method is only available for MongoDB data sources.
| category | The data source category. |
| datasource | The data source name. |
| collection | The collection name. |
| identifier | The item identifier. |
| token | A project token. |
|
inline |
Truncates a collection
This method truncates a collection.
Currently, this method is only available for MongoDB data sources.
| category | The data source category. |
| datasource | The data source name. |
| collection | The collection name. |
| token | A project token. |
|
inline |
Truncates a collection
This method truncates a collection.
Currently, this method is only available for MongoDB data sources.
| category | The data source category. |
| datasource | The data source name. |
| collection | The collection name. |
| token | A project token. |
|
inline |
Updates a data source
This method updates a data source changing its name, whether it is default or not, or its credentials. At least one change, that is, one of the optional parameters, must be specified.
Currently, the default MongoDB data source cannot be modified through this method.
| category | The data source category. |
| datasource | The data source name. |
| token | A project token. |
| name | The new name of the data source. If not specified the data source is not renamed. |
| _default | Whether the data source should become (if true) or cease to be (if false) the default one for its category. If not specified the data source does not change its default status. |
| body | The new data sources credentials as JSON. If not specified the data sources credentials are not changed |
|
inline |
Updates a data source
This method updates a data source changing its name, whether it is default or not, or its credentials. At least one change, that is, one of the optional parameters, must be specified.
Currently, the default MongoDB data source cannot be modified through this method.
| category | The data source category. |
| datasource | The data source name. |
| token | A project token. |
| name | The new name of the data source. If not specified the data source is not renamed. |
| _default | Whether the data source should become (if true) or cease to be (if false) the default one for its category. If not specified the data source does not change its default status. |
| body | The new data sources credentials as JSON. If not specified the data sources credentials are not changed |
|
inline |
Updates a collection item
This method updates a collection item.
Currently, this method is only available for MongoDB data sources.
| category | The data source category. |
| datasource | The data source name. |
| collection | The collection name. |
| identifier | The item identifier. |
| token | A project token. |
| body | The new item. |
|
inline |
Updates a collection item
This method updates a collection item.
Currently, this method is only available for MongoDB data sources.
| category | The data source category. |
| datasource | The data source name. |
| collection | The collection name. |
| identifier | The item identifier. |
| token | A project token. |
| body | The new item. |


FLOUNDERING A film review by Scott Renshaw Copyright 1995 Scott Renshaw
Starring: James LeGros, Nelson Lyon. Screenwriter/Director: Peter McCarthy.
John Boyz (James LeGros) is FLOUNDERING. In the days immediately following the Rodney King verdict riots, Los Angeles resident John is unemployed, plagued by insomnia and filled with an overwhelming sense of despair. And that's the good news. In the course of one day, John finds his meager savings confiscated by the IRS, his unemployment benefits cut off, his girlfriend in bed with another man and his strung out brother in need of a $3000 detox program. Teetering on the edge of sanity, John finds himself on a comic odyssey dominated by the spectre of class revolution and the visage of fascistic Police Chief Merryl Fence (Nelson Lyon).
This is the first directorial effort by Peter McCarthy, producer of such films as REPO MAN and TAPEHEADS, and those credits should tell you all you need to know about the style and tone of FLOUNDERING. It's a hilariously surreal examination of urban paranoia and hopelessness, filled with oddball characters, goofy stream-of-consciousness narrative and instantly quotable lines. FLOUNDERING is told through a voiceover narration by John, but it's not so much about John as it is about the chaotic world around him. John is only the tour guide, but his observations are wonderfully off-the-wall:
On the destruction in South Central L.A.: "Maybe we should leave it as a reminder ... then [Peter] Ueberroth will turn it into a riot theme park."
On romance: "True love is the ultimate fiction ... if you ever walk into a room and find yourself instantly attracted to someone, get out of that room as fast as you can."
On a sign in a bakery that reads, "Please don't feed the homeless beggars:" "Who the h*** should you feed?"
McCarthy's script is rich with such moments. Unfortunately, it's also rich with heavy-handed left-wing moralizing which could easily turn off those with differing points of view. Characters representing "The System," like Chief Fence and John's teacher- turned-corporate bigwig friend Doug, are essentially cardboard cutouts used to mouth opposing dogma. It's therefore very fortunate that so many of the other minor roles are so funny. Many of them are played by "name" actors in cameos, like John Cusack as a philosophical party-goer, Steve Buscemi as a friend of John's angry about child slavery rings, and Ethan Hawke as John's paranoid brother.
In the middle of it all is James LeGros as John, who adopts an appropriately blank Young Everyman quality. He's a guy with a good heart who finds himself overwhelmed by the apparent injustices in his world and his feelings of powerlessness to do anything about it. The snapshots taken by his mental camera provide a bitingly satirical collage of urban life, but surprisingly McCarthy doesn't opt for utter cynicism. Instead, he manages to balance black-humored sarcasm and social commentary with an ultimately optimistic message of personal responsibility. For those who enjoy their comedy with an edge and don't mind the occasional preaching, there's a real winner to be found in FLOUNDERING.
Besides, how can you not love a film that ends with two guitarists, one black and one white, singing a marvelously off-key duet of "(What's So Funny 'Bout) Peace, Love and Understanding?"
On the Renshaw scale of 0 to 10 riots: 8.
-- Scott Renshaw Stanford University Office of the General Counsel
.
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


Arriving at Charleston was in warm and sunny weather, we took a
dock at the Maritime Center Marina and spent the following 7
days tied up to the dock. Charleston has a great looking
bridge that is visible from most everywhere and on the trip so
far we have seen a variety of different types. Being at the dock
allowed for fresh water all the time and being hooked to power
full time was great, the weather was not :(. Not sure
where the cold weather came from but getting up to 50 degrees in
the morning just is not fun.
Glenn and Linda McConnell came down from Charlotte NC to visit
us, they are long time friends of Dean's family, see their visit
on the visitor page. We also had the previous owners of
the boat, Jim and Dorrell Antley, come back to give us tips and suggestions. Jim and Dorrell had cruised on the boat for
many years and have lots of
good memories and suggestions for the current owners. Bill
Hall of American Classic Tea Plantation came by as well, Bill
has owned boats in the past and has an eye for a large
catamaran. (Ours is quite small to Bill)
We were in Charleston for Halloween and built a scary
Halloween costume for Derek. Derek had been dreaming of a
"headless" costume and so between Derek and Kris they were able
to make one that received comments all night long. Bob and Anne
B were able to make an overnight sail to make it to Charleston
to also join us on the rounds of candy gathering.
The marina has a washing machine and dryer so some laundry could be
done. It usually had a line of people wanting to use it so
Kris tried to make sure she was first in line at 8 a.m.
There were some people who did not follow "proper" usage and
they caused a bit of problems with the others. Sam had
been having some issues with his food and that caused a bit more
laundry than anticipated.
Shops and more shops, at least that what it seems as you walk
around Charleston. There seems like there are more stores
and more things to buy then you might have time for. Kris
and Derek went shopping or at least browsing for good deals one
afternoon and even had the fun of tasting different honeys.
The local grocery store, Harris Teeter, was within 1/2 mile so
provisioning was just a short walk.
11/05/11 Charleston, so much to see and so little time to see it


Relic Watcher:
In all 4 directions, one piece of Kaerun's Memoir is stored.
If you're qualified, you'll know the contents of the book.
Place your hand on the reading desks where the memoirs are located, in the order of the story.
If the order of contents are correct for that reading desk, it will illuminate.
If the order is incorrect, you will be considered an intruder and you will be expelled.


--- layout: layout ---
Some of the projects I have worked recently include:
TOUCAN: Supervised learning approach to support discovery of biosynthetic gene clusters in fungi.
bioMine: A open source search engine for biomedical data based on Solr.
eRisk prediction: Approach developed for the CLEF eRisk 2017 shared task. Supervised learning models to detect early signs of mental health issues given user content from social media.
SemLinker: Entity Discovery and Linking (EDL) system developed for the EDL track at TAC-KBP 2014.
mycoSORT: Supervised learning approach to support triage of biomedical literature.


In this project, you'll build your first neural network and use it to predict daily bike rental ridership. We've provided some of the code, but left the implementation of the neural network up to you (for the most part). After you've submitted this project, feel free to explore the data and the model more.
%matplotlib inline
%config InlineBackend.figure_format = 'retina'
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
A critical step in working with neural networks is preparing the data correctly. Variables on different scales make it difficult for the network to efficiently learn the correct weights. Below, we've written the code to load and prepare the data. You'll learn more about this soon!
data_path = 'Bike-Sharing-Dataset/hour.csv'
rides = pd.read_csv(data_path)
rides.head()
This dataset has the number of riders for each hour of each day from January 1 2011 to December 31 2012. The number of riders is split between casual and registered, summed up in the cnt
column. You can see the first few rows of the data above.
Below is a plot showing the number of bike riders over the first 10 days or so in the data set. (Some days don't have exactly 24 entries in the data set, so it's not exactly 10 days.) You can see the hourly rentals here. This data is pretty complicated! The weekends have lower over all ridership and there are spikes when people are biking to and from work during the week. Looking at the data above, we also have information about temperature, humidity, and windspeed, all of these likely affecting the number of riders. You'll be trying to capture all this with your model.
rides[:24*10].plot(x='dteday', y='cnt')
Here we have some categorical variables like season, weather, month. To include these in our model, we'll need to make binary dummy variables. This is simple to do with Pandas thanks to get_dummies()
.
dummy_fields = ['season', 'weathersit', 'mnth', 'hr', 'weekday']
for each in dummy_fields:
dummies = pd.get_dummies(rides[each], prefix=each, drop_first=False)
rides = pd.concat([rides, dummies], axis=1)
fields_to_drop = ['instant', 'dteday', 'season', 'weathersit',
'weekday', 'atemp', 'mnth', 'workingday', 'hr']
data = rides.drop(fields_to_drop, axis=1)
data.head()
To make training the network easier, we'll standardize each of the continuous variables. That is, we'll shift and scale the variables such that they have zero mean and a standard deviation of 1.
The scaling factors are saved so we can go backwards when we use the network for predictions.
quant_features = ['casual', 'registered', 'cnt', 'temp', 'hum', 'windspeed']
# Store scalings in a dictionary so we can convert back later
scaled_features = {}
for each in quant_features:
mean, std = data[each].mean(), data[each].std()
scaled_features[each] = [mean, std]
data.loc[:, each] = (data[each] - mean)/std
We'll save the data for the last approximately 21 days to use as a test set after we've trained the network. We'll use this set to make predictions and compare them with the actual number of riders.
# Save data for approximately the last 21 days
test_data = data[-21*24:]
# Now remove the test data from the data set
data = data[:-21*24]
# Separate the data into features and targets
target_fields = ['cnt', 'casual', 'registered']
features, targets = data.drop(target_fields, axis=1), data[target_fields]
test_features, test_targets = test_data.drop(target_fields, axis=1), test_data[target_fields]
We'll split the data into two sets, one for training and one for validating as the network is being trained. Since this is time series data, we'll train on historical data, then try to predict on future data (the validation set).
# Hold out the last 60 days or so of the remaining data as a validation set
train_features, train_targets = features[:-60*24], targets[:-60*24]
val_features, val_targets = features[-60*24:], targets[-60*24:]
Below you'll build your network. We've built out the structure and the backwards pass. You'll implement the forward pass through the network. You'll also set the hyperparameters: the learning rate, the number of hidden units, and the number of training passes.
The network has two layers, a hidden layer and an output layer. The hidden layer will use the sigmoid function for activations. The output layer has only one node and is used for the regression, the output of the node is the same as the input of the node. That is, the activation function is $f(x)=x$. A function that takes the input signal and generates an output signal, but takes into account the threshold, is called an activation function. We work through each layer of our network calculating the outputs for each neuron. All of the outputs from one layer become inputs to the neurons on the next layer. This process is called forward propagation.
We use the weights to propagate signals forward from the input to the output layers in a neural network. We use the weights to also propagate error backwards from the output back into the network to update our weights. This is called backpropagation.
Hint: You'll need the derivative of the output activation function ($f(x) = x$) for the backpropagation implementation. If you aren't familiar with calculus, this function is equivalent to the equation $y = x$. What is the slope of that equation? That is the derivative of $f(x)$.
Below, you have these tasks:
self.activation_function
in __init__
to your sigmoid function.train
method.train
method, including calculating the output error.run
method.class NeuralNetwork(object):
def __init__(self, input_nodes, hidden_nodes, output_nodes, learning_rate):
# Set number of nodes in input, hidden and output layers.
self.input_nodes = input_nodes
self.hidden_nodes = hidden_nodes
self.output_nodes = output_nodes
# Initialize weights
self.weights_input_to_hidden = np.random.normal(0.0, self.input_nodes**-0.5,
(self.input_nodes, self.hidden_nodes))
self.weights_hidden_to_output = np.random.normal(0.0, self.hidden_nodes**-0.5,
(self.hidden_nodes, self.output_nodes))
self.lr = learning_rate
#### TODO: Set self.activation_function to your implemented sigmoid function ####
#
# Note: in Python, you can define a function with a lambda expression,
# as shown below.
self.activation_function = lambda x : 1 / (1 + np.exp(-x)) # Replace 0 with your sigmoid calculation.
### If the lambda code above is not something you're familiar with,
# You can uncomment out the following three lines and put your
# implementation there instead.
#
#def sigmoid(x):
# return 0 # Replace 0 with your sigmoid calculation here
#self.activation_function = sigmoid
def train(self, features, targets):
''' Train the network on batch of features and targets.
Arguments
---------
features: 2D array, each row is one data record, each column is a feature
targets: 1D array of target values
'''
n_records = features.shape[0]
delta_weights_i_h = np.zeros(self.weights_input_to_hidden.shape)
delta_weights_h_o = np.zeros(self.weights_hidden_to_output.shape)
for X, y in zip(features, targets):
#### Implement the forward pass here ####
### Forward pass ###
# TODO: Hidden layer - Replace these values with your calculations.
hidden_inputs = X.dot(self.weights_input_to_hidden) # signals into hidden layer 1 by 2
hidden_outputs = self.activation_function(hidden_inputs) # signals from hidden layer 1 by 2
# TODO: Output layer - Replace these values with your calculations.
final_inputs = hidden_outputs.dot(self.weights_hidden_to_output)# signals into final output layer
final_outputs = final_inputs # signals from final output layer
#### Implement the backward pass here ####
### Backward pass ###
# TODO: Output error - Replace this value with your calculations.
error = y - final_outputs # Output layer error is the difference between desired target and actual output.
# TODO: Backpropagated error terms - Replace these values with your calculations.
output_error_term = error
# TODO: Calculate the hidden layer's contribution to error
hidden_error = output_error_term * self.weights_hidden_to_output # 2 by 1
hidden_error_term = hidden_error.T * (hidden_outputs * (1 - hidden_outputs))
# Weight step (input to hidden)
delta_weights_i_h += X[None, :].T.dot(hidden_error_term)
# Weight step (hidden to output)
delta_weights_h_o += np.multiply(hidden_outputs[:,None], output_error_term)
# TODO: Update the weights - Replace these values with your calculations.
self.weights_hidden_to_output += self.lr * delta_weights_h_o / n_records # update hidden-to-output weights with gradient descent step
self.weights_input_to_hidden += self.lr * delta_weights_i_h / n_records # update input-to-hidden weights with gradient descent step
def run(self, features):
''' Run a forward pass through the network with input features
Arguments
---------
features: 1D array of feature values
'''
#### Implement the forward pass here ####
# TODO: Hidden layer - replace these values with the appropriate calculations.
hidden_inputs = features.dot(self.weights_input_to_hidden) # signals into hidden layer
hidden_outputs = self.activation_function(hidden_inputs) # signals from hidden layer
# TODO: Output layer - Replace these values with the appropriate calculations.
final_inputs = hidden_outputs.dot(self.weights_hidden_to_output) # signals into final output layer
final_outputs = final_inputs # signals from final output layer
return final_outputs
def MSE(y, Y):
return np.mean((y-Y)**2)
Run these unit tests to check the correctness of your network implementation. This will help you be sure your network was implemented correctly befor you starting trying to train it. These tests must all be successful to pass the project.
import unittest
inputs = np.array([[0.5, -0.2, 0.1]])
targets = np.array([[0.4]])
test_w_i_h = np.array([[0.1, -0.2],
[0.4, 0.5],
[-0.3, 0.2]])
test_w_h_o = np.array([[0.3],
[-0.1]])
class TestMethods(unittest.TestCase):
##########
# Unit tests for data loading
##########
def test_data_path(self):
# Test that file path to dataset has been unaltered
self.assertTrue(data_path.lower() == 'bike-sharing-dataset/hour.csv')
def test_data_loaded(self):
# Test that data frame loaded
self.assertTrue(isinstance(rides, pd.DataFrame))
##########
# Unit tests for network functionality
##########
def test_activation(self):
network = NeuralNetwork(3, 2, 1, 0.5)
# Test that the activation function is a sigmoid
self.assertTrue(np.all(network.activation_function(0.5) == 1/(1+np.exp(-0.5))))
def test_train(self):
# Test that weights are updated correctly on training
network = NeuralNetwork(3, 2, 1, 0.5)
network.weights_input_to_hidden = test_w_i_h.copy()
network.weights_hidden_to_output = test_w_h_o.copy()
network.train(inputs, targets)
self.assertTrue(np.allclose(network.weights_hidden_to_output,
np.array([[ 0.37275328],
[-0.03172939]])))
self.assertTrue(np.allclose(network.weights_input_to_hidden,
np.array([[ 0.10562014, -0.20185996],
[0.39775194, 0.50074398],
[-0.29887597, 0.19962801]])))
def runTest(self):
# Test correctness of run method
network = NeuralNetwork(3, 2, 1, 0.5)
network.weights_input_to_hidden = test_w_i_h.copy()
network.weights_hidden_to_output = test_w_h_o.copy()
self.assertTrue(np.allclose(network.run(inputs), 0.09998924))
suite = unittest.TestLoader().loadTestsFromModule(TestMethods())
unittest.TextTestRunner().run(suite)
Here you'll set the hyperparameters for the network. The strategy here is to find hyperparameters such that the error on the training set is low, but you're not overfitting to the data. If you train the network too long or have too many hidden nodes, it can become overly specific to the training set and will fail to generalize to the validation set. That is, the loss on the validation set will start increasing as the training set loss drops.
You'll also be using a method know as Stochastic Gradient Descent (SGD) to train the network. The idea is that for each training pass, you grab a random sample of the data instead of using the whole data set. You use many more training passes than with normal gradient descent, but each pass is much faster. This ends up training the network more efficiently. You'll learn more about SGD later.
This is the number of batches of samples from the training data we'll use to train the network. The more iterations you use, the better the model will fit the data. However, if you use too many iterations, then the model with not generalize well to other data, this is called overfitting. You want to find a number here where the network has a low training loss, and the validation loss is at a minimum. As you start overfitting, you'll see the training loss continue to decrease while the validation loss starts to increase.
This scales the size of weight updates. If this is too big, the weights tend to explode and the network fails to fit the data. A good choice to start at is 0.1. If the network has problems fitting the data, try reducing the learning rate. Note that the lower the learning rate, the smaller the steps are in the weight updates and the longer it takes for the neural network to converge.
The more hidden nodes you have, the more accurate predictions the model will make. Try a few different numbers and see how it affects the performance. You can look at the losses dictionary for a metric of the network performance. If the number of hidden units is too low, then the model won't have enough space to learn and if it is too high there are too many options for the direction that the learning can take. The trick here is to find the right balance in number of hidden units you choose.
import sys
### Set the hyperparameters here ###
iterations = 10000
learning_rate = 0.001
hidden_nodes = 4
output_nodes = 1 # fixed
def tuning(iterations=100, learning_rate=0.01, hidden_nodes=4):
"""wrapper to test different hyperparameters"""
N_i = train_features.shape[1]
network = NeuralNetwork(N_i, hidden_nodes, output_nodes, learning_rate)
losses = {'train':[], 'validation':[]}
for ii in range(iterations):
# Go through a random batch of 128 records from the training data set
batch = np.random.choice(train_features.index, size=128)
X, y = train_features.ix[batch].values, train_targets.ix[batch]['cnt']
network.train(X, y)
# Printing out the training progress
train_loss = MSE(network.run(train_features), train_targets['cnt'].values[:,None])
val_loss = MSE(network.run(val_features), val_targets['cnt'].values[:,None])
sys.stdout.write("\rProgress: {:2.1f}".format(100 * ii/float(iterations)) \
+ "% ... Training loss: " + str(train_loss)[:5] \
+ " ... Validation loss: " + str(val_loss)[:5])
sys.stdout.flush()
losses['train'].append(train_loss)
losses['validation'].append(val_loss)
return losses
from sklearn.model_selection import ParameterSampler
param_grid = {
"iterations": [100, 500, 1000],
"learning_rate": [0.1, 0.01, 0.001],
"hidden_nodes": [4, 12, 24]
}
random_seed = np.random.seed(123)
param_test = list(ParameterSampler(param_grid, n_iter=12))
param_test
# do a randomized search over grid
losses_ls = [tuning(**param) for param in param_test]
a=print(param_test[0])
def plot_nn(losses, param):
"""wrapper to plot training and validation losses"""
plt.figure()
plt.plot(losses['train'], label='Training loss')
plt.plot(losses['validation'], label='Validation loss')
plt.legend()
plt.title("learning_rate: {%.3f}, iteration: {%1.f}, hidden_nodes: {%1.f}" % (param['learning_rate'], param['iterations'], param['hidden_nodes']))
_ = plt.ylim()
for param, losses in zip(param_test, losses_ls):
plot_nn(losses, param)
learning_rate = 0.1
, iteration = 1000
, and hidden_nodes = 24
¶plot_nn(losses_ls[4], param_test[4])
### Set the hyperparameters here ###
iterations = 3500
learning_rate = 0.6
hidden_nodes = 24
output_nodes = 1 # fixed
N_i = train_features.shape[1]
network = NeuralNetwork(N_i, hidden_nodes, output_nodes, learning_rate)
losses = {'train':[], 'validation':[]}
for ii in range(iterations):
# Go through a random batch of 128 records from the training data set
batch = np.random.choice(train_features.index, size=128)
X, y = train_features.ix[batch].values, train_targets.ix[batch]['cnt']
network.train(X, y)
# Printing out the training progress
train_loss = MSE(network.run(train_features), train_targets['cnt'].values[:,None])
val_loss = MSE(network.run(val_features), val_targets['cnt'].values[:,None])
sys.stdout.write("\rProgress: {:2.1f}".format(100 * ii/float(iterations)) \
+ "% ... Training loss: " + str(train_loss)[:5] \
+ " ... Validation loss: " + str(val_loss)[:5])
sys.stdout.flush()
losses['train'].append(train_loss)
losses['validation'].append(val_loss)
burn_in = 200
plot_nn({"train": losses["train"][burn_in:],
"validation": losses["validation"][burn_in:]},
param={"iterations": iterations,
"learning_rate": learning_rate,
"hidden_nodes": 24})
val_loss
Here, use the test data to view how well your network is modeling the data. If something is completely wrong here, make sure each step in your network is implemented correctly.
fig, ax = plt.subplots(figsize=(8,4))
mean, std = scaled_features['cnt']
predictions = np.array(network.run(test_features))*std + mean
ax.plot(predictions, label='Prediction')
ax.plot((test_targets['cnt']*std + mean).values[:,None], label='Data')
ax.set_xlim(right=len(predictions))
ax.legend()
dates = pd.to_datetime(rides.ix[test_data.index]['dteday'])
dates = dates.apply(lambda d: d.strftime('%b %d'))
ax.set_xticks(np.arange(len(dates))[12::24])
_ = ax.set_xticklabels(dates[12::24], rotation=45)
Answer these questions about your results. How well does the model predict the data? Where does it fail? Why does it fail where it does?
Note: You can edit the text in this cell by double clicking on it. When you want to render the text, press control + enter
It predicts okay on the data. But clearly, it has room for improvement. For example, it over-predicts the data before Dec 21 and under-predicts afterwards. There are some effects haven't been picked up by the network.


| Name | Date of Account creation | E-mail address | Gender | Company | Profession | Date of Birth | Skills | Experience (years) | Actions | |
|---|---|---|---|---|---|---|---|---|---|---|
| {{student.full_name}} | {{student.created_at}} | {{student.email}} | {{student.gender}} | {{student.company}} | {{student.profession}} | {{student.dob}} | {{student.skills}} | {{student.experience}} | ||


#ftl output_format="HTML" auto_esc=true> <#import "layout/default.html" as layout><EMAIL_ADDRESS>Dear ${notificationTarget.name}
You have been invited to participate in this Innovation Funding Service project:
${applicationId}: ${projectName}
You will be joining as a ${role}.
<EMAIL_ADDRESS>href="${inviteUrl}" text="Accept invitation" />Yours sincerely
<EMAIL_ADDRESS>/> @layout.default>


--- type: buttons title: Button size modifier usage: Fancy larger buttons? Use `.mod-large` for a larger button, used in our login form. stylesheet: '/scss/elements/btn.scss' --- Default Large Small


LITTLE WOMEN
November 16-19, 2000
Directors - April Lightsey & Chan Geddie
THE CAST
Marmee March - Joy Berry
Mr. March - Randy Berry
Amy March - Katelyn Ellzey, Rebekah Staples
Jo March - Sara-Claire Lightsey, Emily Wright
Meg March - Amanda Pitts
Beth March - Tia March Robertson, Rachel Yarnell
Aunt March - Suzie Ellzey
Mr. Laurence - Dom White
Laurie Laurence - Scotty Whitehurst
Mrs. Tomlinson - CC Blackwell
Professor Bhaer - Will Casey
Mrs. Kirke - Sabrina Cummings
Nellie - Rebecca Ellzey
Anna - Toni Ellzey
Martha Moffett - Meghan Kenny
John Brooke - Hunter Lightsey
Ruth - Jesse McCraw
Hannah - Jamie Niemeyer
Katy - LeighAnn Jeannene
Clara Moffett - Peggy Powell
Kitty Kirke - Sherrie Rayner
Mary - Kris Ready
Jenny - Sarah Robinson
Sara Watson - Lyndsey Thomas
Daniel Kirke - Daniel Vial
Minnie Kirke - Mallory White
Tuppy - Mia Bella


{% extends "base.html" %} {% block content %}
Please contact us on<EMAIL_ADDRESS>if you would like to find out more.
Publications router aims to pass notifications about research articles to UK institutions matching the affiliations of the authors, including all the co-authors, or their ORCIDs.
One of its key aims is to assist institutions in their compliance with the policy on open access and the REF.
An ideal workflow would consist of two notifications for each article, one at acceptance and another at publication. This can be varied depending on your workflow and turn-around times from acceptance to publication.
The metadata can be supplied as JATS (or NLM) XML, for example, though other formats may well be possible. We are open to discussion on the details of this.
We are actively exploring additional options for ingesting notifications more flexibly, especially at acceptance.
Publications router takes no view on what the embargo period or licensing terms should be, but undertakes to pass these on to the institutions if you provide them. If you supply embargoed content and metadata specifying an embargo end-date that applies to it, we will require institutions to respect the embargo that you stipulate in this way. This commitment forms part of a contract between Jisc and participating institutions, and between Jisc and participating publishers.
More detail on how you can transmit this information to publications router is given in the technical documentation listed below.
Please see here for details of publications router architecture and how to connect to it.


I am passionate Android Developer with 2 years of experience.I also like web development and Machine Learning.I like to work with any new technology.Apart from programming I like to watch Hollywood movies,TV Series and Animes.My fields of expertise are as following


Attention: Deploying to Vercel automatically configures a global CDN for your Next.js project. You do not need to manually setup an Asset Prefix.
Note: Next.js 9.5+ added support for a customizable Base Path, which is better suited for hosting your application on a sub-path like
/docs
. We do not suggest you use a custom Asset Prefix for this use case.
To set up a CDN, you can set up an asset prefix and configure your CDN’s origin to resolve to the domain that Next.js is hosted on.
Open next.config.js
and add the assetPrefix
config:
const isProd = process.env.NODE_ENV === "production";
module.exports = {
// Use the CDN in production and localhost for development.
assetPrefix: isProd ? "https://cdn.mydomain.com" : "",
};
Next.js will automatically use your asset prefix for the JavaScript and CSS files it loads from the /_next/
path (.next/static/
folder). For example, with the above configuration, the following request for a JS chunk:
/_next/static/chunks/4b9b41aaa062cbbfeff4add70f256968c51ece5d.4d708494b3aed70c04f0.js
Would instead become:
https://cdn.mydomain.com/_next/static/chunks/4b9b41aaa062cbbfeff4add70f256968c51ece5d.4d708494b3aed70c04f0.js
The exact configuration for uploading your files to a given CDN will depend on your CDN of choice. The only folder you need to host on your CDN is the contents of .next/static/
, which should be uploaded as _next/static/
as the above URL request indicates. Do not upload the rest of your .next/
folder, as you should not expose your server code and other configuration to the public.
While assetPrefix
covers requests to _next/static
, it does not influence the following paths:
/_next/data/
requests for getServerSideProps
pages. These requests will always be made against the main domain since they’re not static./_next/data/
requests for getStaticProps
pages. These requests will always be made against the main domain to support Incremental Static Generation, even if you’re not using it (for consistency).


| Day | 9:15-10:15 | 10:20-11:20 | 11:25-12:25 | 12:30-1:30 | 2:30-3:30 | 3:35-4:35 | |
|---|---|---|---|---|---|---|---|
| Sunday | Communication Engineering | Microprocessor and Assembly Language Lab | Computer Graphics | Operating System | |||
| Monday | Operating System | System Analysis | Operating System Lab | ||||
| Tuesday | Microprocessor and Assembly Language | Operating System | Computer Graphics | ||||
| Wednesday | Microprocessor and Assembly Language | Communication Engineering | System Analysis | Computer Graphics | Computer Graphics Lab | ||
| Thursday | Microprocessor and Assembly Language | System Analysis | Communication Engineering | Communication Engineering Lab |


I was noticing the recent explosion of growth that the Steem chain has been experiencing in our user base. @penguinpablo keeps some pretty good stats on the whole thing.
Steem is blasting past 50k active users and getting ready to touch into the 60ks.
It’s driving our Alexa rating too:
“Inflation is the worst thing ever and must be stamped out”
I think I see a lot of this with crypto hounds. They seem to hate practically all forms of inflation. There’s a good reason for that sentiment. Inflation can cause a lot of harm to an economy. Especially a lot of inflation, and especially a lot of inflation in a somewhat developed (slowly growing) economy. Inflation in the USA is particularly bad because rich bankers are the primary recipients of the wealth and everyone else is stuck holding the bag of an inflated currency and the decreased purchasing power that comes with it.
A lot of folks are worried about hyperinflation. They also like how powerful a completely deflationary currency can be. There’s no doubt that a deflationary currency can do some pretty solid growth! Just look at bitcoin.
There’s a part of this discussion that clicked for me when I was watching this mainstream approach to the value of a currency and why a bit of inflation can be good.
I have gotten on board with a little bit of inflation can be a great thing for the platform, but now the question to me is how do we distribute that inflation so that the entire platform is able to experience the benefits?
Steem inflation is different than other token inflation. We have Proof of Brain, which means Posting = Mining
The price of doge has been rising. Here’s the price chart from livecoinwatch.com.
When that price is rising I might think, “Man I missed out on that opportunity,” but it doesn’t drive my desire to get into that community. Maybe since the inflation goes through mining I might want to mine a little more, but just cause the price is going up doesn’t mean that I want to go join a Doge Community forum and spend a ton of time on it. That’s not the case with Steem…
New Members
Please welcome @marcinromowski to Steem. He’s the 577,435th account created on the Steem platform.
I don’t know this dude, but if I had to guess he heard from a friend that you can make absurd amounts of money by blogging here. It doesn’t take any money to get started except possibly an instant sign up account.
What macrin is experiencing along with everyone else is the effect caused by platform inflation on the Steem blockchain and how we’ve put it to truly exceptional use!
Let’s look at inflation Steem
Right now it’s hard coded into the blockchain that we start at 10% platform inflation and it goes down 0.5% every year for a little less than 20 years. Right now we’re slowly lowering inflation and we’re in the 9% range.
There’s some good and bad in how our platform inflation works and you can see it in this diagram from @jesta’s steemdb.com.
Platform inflation is good if we use it well
First off I happen to like overall platform inflation.  This is where the top 100 accounts and their sock puppets own 93% of the steem or more.  Platform inflation going into Stake Weighted hands is one of my least favorite totally un-egalitarian things I’ve ever heard of. It’s a wealth sucking mechanism that takes capital from the users and pumps it into the richest accounts on the platform. That’s terrible! That’s what everyone in crypto is fighting.
This following image is from steemwhales.com and it’s data is a couple of months old, but this is what I’m talking about.
The distribution on this platform is worse than any time in feudal England. It’s worth noting that the 70 million steem that Steemit owns isn’t even included in this. The distribution picture is actually far worse!!!!

So, the counters to that are things like forking steemit or the devs off the chain, murdering the devs and while doing that extract keys out of them, or slowly over time distribute the stake through platform inflation to active users. We could have a Marxist revolution and go down to Austin with guns and seize the means of Steem production by force!!! That said… I run a peace group so I’m less inclined to fork people off the chain, coerce them with violence, or murder people. So, to me I think the inflation route is the way to go in part because it has some additional benefits that are unique to steem and truly extraordinary from an abundance for all perspective.
A couple types of inflation
To be clear there’s platform inflation, and if used well I like it a lot. Platform inflation is the new amount of Steem printed every year. I’m a fan of making this a witness variable, or hardcoding it to be 10% instead of the slowly declining thing that it is now. Platform inflation I perceive as a major growth driver for us, which I happen to think is one of the main reasons we’re mooning right now. I’m a big fan of this inflation type.
How does it help us moon? Well, ask yourself if you feel inclined to post more or own more now that steem is worth $5-9 and your post rewards just quintipled. If the answer is yes and you’re acting on that you’re making this platform grow because of platform inflation.  You have to join STEEM(IT)!!!” Then you’re in the group of people that are having a positive experience with platform inflation. This is increasing our value because there are more users, and out of those users some are buying Steem and that’s also driving the price upward!
Bad Inflation
Stake Weighted inflation is bad. I don’t know exactly how they were doing this a year ago when the price tanked down to 7 cents per Steem, but a remnant remains that’s hard coded in how the block operates and the effective amount can be seen in this Steemdb.com image.
The hard code says that 15% of all inflation will go to back to users through stake weighted inflation, but Steem is a complicated beast and as a consequence it doesn’t work exactly like that in practice. See that 9% that’s boxed in red? That’s 9% of the platform inflation going back to users through stake weighted inflation. So, let’s do some back of the envelope math right now.
260M steem. Call it 10% inflation. That’s 26M new steem. it’s supposed to be 15% but effectively it floats so I’ll call that 10%. That means roughly 2.6M steem is going back to users through stake weighted inflation, but that’s borked. 93% is going to the top 100 accounts so we’re funneling about 2.5M steem back to the already largest accounts. Right now that’s $12.5M usd. A year from now I’m betting that’s 125M USD. This is dumb. Let’s not do this anymore!!!
 They are two of the largest collective accounts and when you’re holding your steem in there they are getting the benefit of this platform inflation. Yes, THAT poloniex that let our wallet slip for months at a time was collecting assloads of free steem while doing it…
Part of why I hate it is that I don’t think it really does much for the platform. If a wealthy person gets 10 more Steem what’s he/she/furry care about that? They likely won’t change behavior all that much or promote the platform any more or less than they did before. If it goes into the hands of active users and especially new active users we’re likely to see a whole army of people running around telling everyone they know to blog on Steem. That sounds better to me. It grows the platform and brings more devs and communities on board, which will ultimately allow Steem to support a higher price.
I’m not mad at the devs. I’m not mad at Steem. I just thanked these guys. I’m not mad at our whales. I’m not anti investor, but I am anti-dumb investment. We need people growing the platform incentivized by life changing money distributed to many active users rather than already rich people getting slightly richer where it won’t really impact their behavior.
Good inflation use
The good type of inflation is platform inflation going to post rewards and curation (with a small percentage for witnesses). I know some of the other witnesses and whales aren’t totally happy with how the reward pool is working right now. There are some major whale vote trades happening pretty easily spotted in trending. There are whales that don’t distribute rewards to anyone but themselves, and a myriad of other problems. These are bad.
 Have you seen dtube? This chain has our own youtube service. Same with dsound and dlive.  And we’re rewarding them. Have you used Vessel (another @jesta baby)? That program is awesome. Post rewards are helping to fund that too. I’m just saying at the same time we can find abuse we can also find some pretty epic shit that we’re collectively making happen. Just cause there’s some abuse doesn’t mean the whole reward pool distributed to 50k people is a cesspool.
Could it be better? Yes! that’s why I support a separate pool for downvoting. Downvoting is necessary in linear rewards now that other types of consensus have been removed. But I don’t think the fact that it’s imperfect should make us avoid putting more rewards into the hands of authors and curators especially if we’re simply diverting new wealth from going into the already exceptionally wealthy.
So… this is long Aggroed…
So, my first idea was to turn the 9% stake weighted inflation into a worker proposal system.  It has a lot of supporters, but the large account naysayers basically say wait till SMTs. Ultimately there doesn’t seem to be any political will to implement this.
So, now it’s on to the second proposal
Change platform inflation to a hard coded 10% or a witness variable.
Cut the 15% hard coded/10% effective stake weighted portion of platform inflation and get rid of it entirely.
While we’re doing that let’s cut top witness pay a little while supporting backup witness pay and give ourselves an even more robust set of servers, community builders, and devs to make Steem the best spot on the web.
While we’re doing that let’s make a separate pool for down votes to make sure we send the platform inflation to good content, people, and projects and less to various forms of abuse.
What’s the upside?
This would effectively raise curation to authors and commenters, and we could at the same time make it so that the rotation of witnesses included 2 backup witnesses per 66 seconds instead of 1 backup per 63 seconds. This would knock top 20 witness pay down by 5% while simultaneously doubling the rewards for all the other witnesses. A handful of witnesses are asshats that basically don’t do shit for the platform except leach rewards, but there are lots of high quality devs and community builders that we could support while simultaneously increasing rewards to authors and curators.
Basically let’s support the active users on the platform as they broaden our reach and simultaneously support the witnesses who build stuff that allows this community to have a more stable and decentralized platform with better access, tools, and communities all over the world.
Since abuse is a concern let’s empower the community to fight abuse. HF19 requires more vigalence and community tools to fight abuse. Let’s make it happen!
The cost
Well, this would involve diverting somewhere around 2.5M new steem from going back to the richest steemians and instead pumping it out to the nearly 60k active users and 100-200 witnesses that work on projects on behalf of the block.
I’m pretty sure that we’ll get far farther as a platform moving inflation from those who need it least to those that spend time active promoting and building tools for this ecosystem day in and day out. So, yeah, the big accounts would miss out on some steem, but they’d have steem that was worth a lot more. They’ll figure out a way to cope…
These guys aren’t evil for having put it in there
To be honest before the price surge I now kinda understood the need to have it there. It was a compromise to keep the large investors from leaving. We desperately needed that to prop up our price, but as we’re now out of the $1 range I think we can reexamine our priorities a little as a platform.
As an aside we’re gonna need their support on this!!! The witnesses who can change things are effectively voted in by the whales. I have over 3000 votes on my witness, but about 12 votes still account for 70ish percent of my vote total. This isn’t gonna happen without the whales. It’s part political and part common sense to share I’m really not anti-whale. You guys are smart people. Hopefully you can understand how an army of people working on behalf of your investment (the Steem platform) is better than letting it sit in your Steem wallet.
One last time… what’s the tl;dr? Steem to the people not to the 0.01%!
There’s no political will for a worker proposal system (because SMTs and this whole platform can be a worker proposal system) so do a few things.
Change platform inflation to a hard coded 10% or a witness variable.
Cut the 15% hard coded/10% effective stake weighted portion of platform inflation and get rid of it entirely.
While we’re doing that let’s cut top witness pay a little while supporting backup witness pay and give ourselves an even more robust set of servers, community builders, and devs to make Steem the best spot on the web.
While we’re doing that let’s make a separate pool for down votes to make sure we send the platform inflation to good content, people, and projects and less to various forms of abuse.
Benefits:
This proposal will help platform distribution, which will make Steem a better experience for everyone.
This proposal will increase platform rewards for all but roughly 100 accounts who don’t need the extra money and many of those folks got the steem from a mined stake that was hyperinflated, which required practically no investment.
Changing witness pay will give us a more robust set of servers, community builders, and devs to help spread the gospel of Steem.
Having a separate pool for down voting will help ensure that rewards go to good people, posts, and projects rather than abuse and vote swaps.
Can you see how shoveling inflation rewards to active users instead of the richest accounts is beneficial to Steem as a whole?
This page is synchronized from the post: ‘Blockchain Heresy and Steem Economics: (Some) Steem platform inflation is a good thing! It just depends on how we use it!’