The Times They Are A'Changing
Review of Hairspray (1988)
Seen on 25 October 1998 with Laura at the American Museum of the Moving Image for $16 (part of missed double feature)
If you take John Waters's word as the Gospel Truth, and as far as I can see, there is no reason you ought not to, music was a lot more fun before the Beatles "came along and ruined everything." Hairspray is a homage to that era, when dances had names and watched them on local versions of American Bandstand. According to John Waters, all the dances you see in Hairspray were ones he "knew and did them drunk at home with his friends."
Because Hairspray is campy and a lot of fun, the teens are very clean cut, sober, and if they are addicted to anything, it's hairspray and mirrors, and yeah, dancing.
For those of you who have somehow missed the last ten years, or simply never saw Hairspray, its the simple story of the Turnblads versus the von Tussles. A hefty Tracy Turnblad (Ricki Lake in her movie debut) auditions for the Corny Collins show, much to the ire of bitchy Amber von Tussle (Colleen Fitzpatrick), who's on the Student Council and doesn't like too much competition, or fat girls.
It's also 1962 and segregation is still in high gear; the Corny Collins show still has a "Negro Day" and there is no interracial dancing. But as luck would have it, Tracy's best friend Penny Pingleton (Leslie Ann Powers) falls in love with Seaweed (Clayton Prince), a black boy. He's the son of Motormouth Mabel (played by Ruth Brown herself), who is determined to teach the white children how to dance the "Bird" as well as integrate NOW.
And so the fun ensues. Tracy becomes a celebrity, does ads for Mr. Pinky's Hefty Hideaway store for big gals, and even woos Amber's boyfriend, Link (Michael St. Gerard). The girls squabble, and eventually, so do their parents. Divine and Jerry Stiller are Tracy's parents, Debbie Harry and Sonny Bono are the von Tussles.
When it was made, Hairspray was the most mainstream and tame of John Waters's movies, with Female Trouble and Polyester being the most representative of his body of work. Hairspray still retained the "shocking" aspects that were Waters's trademark--close ups of zits being exploded, rats crawling over a foot during a makeout session in an alley, a time bomb in a up hairdo. It's all a lot of fun, though, if not a little unreal. In real life, integration didn't happen; the show was run off the air by parents who were "more racist than the kids," according to Waters.

Pia Zadora and Ric Ocasik appear as beatniks. Shawn Thompson as Corny Collins; Mink Stole as his sidekick Tammy. Writer and director John Waters appears as the doctor who tries, unsuccessfully to hypnotize Penny into only liking white boys.
Ten Years Later
At the museum, John Waters spoke about Hairspray and his work in general, and took questions from the audience. One thing that shocks just about everybody is that Hairspray is now a staple of children's parties. Waters said that he is often recognized by children as "the doctor from that movie." He also says that Ricki Lake had just been turned down for a job by the Gap before he cast her in the movie, but he knew she was destined for greatness (or a least fame--have you seen Mrs. Winterborne? Not great, not at all).
He's also a little more than shocked to discover one of his movies on the AFI's Top 100 films-of-all-time list.
He also noted that Divine, who looked like a lot of the woman in the Baltimore neighborhood in which he grew up (also depicted in Hairspray), died shortly after the movie was released, and her fame was about to be fulfilled. He also told us that people leave donuts, dresses, and eyemake-up on Divine's grave.

More movie reviews by Seth Bookey, with graphics, can be found at http://www.geocities.com/Athens/2679/kino.html
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


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
[SSI error [imdb-online-1107.imdb.com ]. /usr/local/httpd/html/backlinks.html: Illegal seek]


Posts
-
Kickin' in Kildalton - Part 2
Let’s revisit the Laphroaig 10 alongside the Ardbeg 10. I poured 15 mL neat of each in Glencairns.
Tags: Scotch, Islay, Ardbeg 10, Laphroaig 10
-
Kickin' in Kildalton - Part 1
I spent the day snowtubing with Whiskey Kid #1. We were just a few minutes away from a New Hampshire liquor barn and she graciously agreed to a quick trip. Fortunately for her, I had my shopping list ready and it was a quick trip. I picked up enough to fill out my 8 month plan (with one summer exception) and bring my yearly total up to ~$700. I’ve got too much whisky stock… better drink some of it!
Tags: Scotch, Islay, Ardbeg 10, Lagavulin 16
-
Accountability
It’s easy to get overly excited when jumping into a new hobby, especially one as delicious as whiskey. It can also be fiscally and physically dangerous when jumping into a new hobby, especially one as delicious as whiskey. Alcoholism is far too real and can capture anyone. I really want to keep this a fun and sustainable hobby. But just a hobby.
Tags: NoWhiskey
-
You Spey, I Spey - Part 4
Tearing into my final 50 mL Speyside sampler tonight, Speyburn 10.
Tags: Scotch, Speyside, Speyburn 10
-
You Spey, I Spey - Part 3
Cracking open two more Speyside 50 mL samplers today - Glenlivet 12 and Glenfiddich 12. I get these confused all the time. I poured 15 mLs of each into Glencairns and promptly forgot which was which. This bodes well for the tasting…
Tags: Scotch, Speyside, Glenlivet 12, Glenfiddich 12
-
You Spey, I Spey - Part 2
I lucked into 50 mL samples of The Macallan 12 Year Sherry Cask and 12 Year Double Cask. These are classy samplers that come with their own box. That’s probably why they cost so much more than the Jack samples I’ll get to when I venture stateside.
Tags: Scotch, Speyside, Macallan 12, Macallan Double Cask 12
-
You Spey, I Spey - Part 1
Speyside has the largest concentration of Scotland’s distillers and seems to have just as many styles. I was fortunate enough to grab a good deal on one famous bottle and pickup a handful of Speyside samplers. This should keep me busy for a couple weeks. First up, that famous bottle:
Tags: Scotch, Speyside, Aberlour A'bunadh 60
-
Sampling Ireland - Part 5
Time to wrap up this sampling of Ireland.
Tags: Irish, Tullamore DEW, Redbreast 12
-
Sampling Ireland - Part 4
I have a number of guiding principles in undertaking this whiskey quest:
Tags: Irish, Jameson, Redbreast 12
-
Sampling Ireland - Part 3
Despite a desire to drink Lagavulin, I’m going to stick it out and continue with my Irish samples. I’m revisiting the 50 mL samples of Bushmills Original and Jameson standard. I prefered the Bushmills on the first sampling - I liked its smoother taste and gingery finish. How do these hold up on second tasting?
Tags: Irish, Bushmills Original, Jameson
-
Sampling Ireland - Part 2
Turns out I was even too tired yesterday to even bring in my suitcase containing my new whiskies. I brought the suitcase inside tonight and the bottles were quite cold. But hey, let’s turn this into an experiment. Trying the Redbreast 12 and Lagavulin Distiller’s Edition.
Tags: Irish, Redbreast 12, Scotch, Islay, Lagavulin Distillers 2017
-
Too Tired for Whiskey
I had a long day of travel to get home after a long week away from the family. I was exhausted and spent what remaining energy I had on the family. No whisky or whiskey today.
Tags: NoWhiskey
-
Old Fashioned Interlude
Long, long day of work on travel today. Grabbed a delightful dinner with a coworker and sampled an Old Fashioned. I think it came with some kind of bourbon. The nose was mostly citrus from the fresh orange peel. The taste was strong, sweet and bitter. I remember more about the conversation than the drink. Sometimes that’s the way it should be.
Tags: Cocktail, Bourbon, Old Fashioned
-
Sampling Ireland - Part 1
Travel affords one ample opportunity to pick up 50 mL sample bottles. I picked up numerous samples representing all varieties of whiskies. I figured this was a good way to get a good idea of different styles. Today kicks off the sampling series by putting the ‘e’ in whiskey with a trip to Ireland.
Tags: Irish, Bushmills Original, Tullamore DEW, Jameson, Redbreast 12
-
Smoke Week - Part 8
Smoke is powerful. So powerful that this week goes to 8.
Tags: Scotch, Islay, Lagavulin 16, Lagavulin Distillers 2017
-
Smoke Week - Part 7
I was hoping to try out some new smoky whiskys while on travel. Unfortunately, the work schedule hasn’t been amenable to visiting bars. Fortunately, some Lagavulin 16 and Laphroaig 10 made the trip with me in some little nippers.
Tags: Scotch, Islay, Lagavulin 16, Laphroaig 10
-
Smoke Week - Part 6
Whisky Bob flew cross country today and took the opportunity to revisit an old “smoky” friend in the form of Johnnie Walker Black. JW Black was my go to “fancy” drink in college and I remember it having a bit of a kick. I liked to drink it on the rocks and with Dr. Pepper. Johnnie seems to be looked down upon in some whisky circles - not sure if it’s because of its popularity or aggressive marketing. That viewpoint has tainted my own and I’m coming into this not expecting much.
Tags: Scotch, Scotch Blend, Johnnie Walker Black
-
Smoke Week - Part 5
I completed a big task at work today. As the end was near, I experienced a craving for something smokey and sweet. Good thing I had 10 mL or so from my 50 mL sample bottle of Uigeadail left over from the other day waiting for me at home. I poured it neat in a Glencairn. My rebottling effort seemed to work as this is the same whisky I remember from the other day. It’s intensely smoky and sweet. It’s really tasty but I wish there were more complexity. I wonder if a full 750 mL bottle might be better? There are also other smoky whiskies with sherry finishes to be tried another day…
Tags: Scotch, Islay, Ardbeg Uigeadail
-
Smoke Week - Part 4
Pure Laphroaig 10 today. Neat 15 mL pour in a Glencairn.  The body thickens as I chew. Smoke and medicine. Warming. The sea lingers. A good dram to sit with and think with after a long day.
Tags: Scotch, Islay, Laphroaig 10
-
Smoke Week - Part 3
I’ll taste Laphroaig 10 and Lagavulin 16 today alongside the distillers’ notes. I’m curious to see if the notes have any impact on my enjoyment of these two drams and if they help me learn some new vocabulary. I come into this tasting with a noticable preference for the complexity of the Lagavulin 16. My wallet really wants me to develop more of a taste for the Laphroaig 10.
Tags: Scotch, Islay, Lagavulin 16, Laphroaig 10
-
Smoke Week - Part 2
Whisky Bob had a long, long day so this will be short. Sampling the Lagavulin 16 I couldn’t finish last night and a fresh pour. The pour from last night was left neat in a Glencairn and covered overnight.  The fresh pour has a much higher alcohol burn on the nose.
Tags: Scotch, Islay, Lagavulin 16
-
Smoke Week - Part 1
Tags: Scotch, Islay, Lagavulin 16, Laphroaig 10, Ardbeg Uigeadail
-
Highland Park 12 - Part 7
Wrapping up the week of Highland Park 12 today. Took advantage of a leisurely working around the home to sample a few pours. First up is a small 15 mL pour neat in a Glencairn. I chose this amount to see if I could squeeze out three pours from a 50 mL sampler bottle… it’s not quite enough to get a full sense of the whisky. Think I need to go to 25 mL pours in the future. A decent amount of alcohol on the nose. There’s some other sort of medicinal scent here I can’t quite describe but it’s been here every time. Getting a lot of smoke in the body this time. After sitting awhile, get more toffee/carmally notes. Swirl it around to release the alcohol and I get less “dark” and more “bright” flavors for lack of better vocabulary.  This continues to be very pleasant. This 15 mL pour cost $0.86 prorated from a $43 750 mL bottle.
Tags: Scotch, Island, Highland Park 12, Islay, Ardbeg Uigeadail
-
Highland Park 12 - Part 6
It’s the penultimate day of Highland Park 12 week here at Whisky Bob’s and I feel like doing something stupid…
Tags: Scotch, Island, Highland Park 12
-
Highland Park 12 - Part 5
HP12 neat 25 mL pour into a Glencairn (cost $1.43 prorated from a $43 750 mL bottle). Nose: dull rubbing alcohol revealing a pleasant sweetness and light smokiness. Smells delicious. I have a new appreciation for this whisky after drinking the Lagavulin 16 yesterday. I really need to up my “smoke” vocabulary as these are smokey yet completely different. The HP12 has smoke and a medicinal quality on the backend. More sweetness on the nose. Drying and ashy finish. Really long pleasant finish.
Tags: Scotch, Island, Highland Park 12
-
Highland Park 12 - Part 4
Pouring Highland Park 12 in a Riedel Vinum whiskey glass today to mix things up. Getting a lot more alcohol burn on the nose and much less sweetness than with the Glencairn glass. The smoke is very forward here. Flavors are about the same with the Vinum as the Glencairn. The Vinum is easier to drink from but I’ve become so accustomed to the Glencairn after just a couple days that it actually felt a bit strange. Think I prefer the Glencairn overall but will be using both in the coming days and decades.
Tags: Scotch, Island, Highland Park 12, Islay, Lagavulin 16
-
Highland Park 12 - Part 3
Starting off with Highland Park 12 neat in a Glencairn. Lots of sweetness on the nose with some alcohol burn. Get a lot of smokiness in the mouth when I close my mouth and breathe through my nose. Add a few drops of filtered water to the dram. The sweetness is subdued and I get more smoke on the nose now. Feels more watery in my mouth (duh). After sitting a bit, get a bit more winey type of smell. There’s a bit of meat flavor up front that’s quickly overcome by the smoke. Leave it sitting awhile and get a bit more butterscotch on the nose. Think I like it neat better though I appreciate some new stuff being brought out with water.
Tags: Scotch, Island, Highland Park 12
-
Highland Park 12 - Part 2
Whisky Bob only ate a banana today so this neat pour of Highland Park 12 in a Glencairn packs a punch. There’s a lot of sweetness and the smokiness on the finish comes through when I chew a bit. It’s like a very pleasing cigar in my mouth. Very dry finish. Despite the empty stomach, I’m able to hold the liquor in my mouth a lot easier today - hooray for dulled senses! Getting more wood notes on the nose. Some vanilla. There’s a nice warming feeling. Some numbing. I enjoy this.
Tags: Scotch, Island, Highland Park 12
-
Highland Park 12 - Part 1
Whisky Bob starting things off here with a week of daily Highland Park 12. Highland Park is the northernmost Scottish Distillery on the Orkney archipelago. Their whiskys are renowned for their complex flavor profiles that touch on all the Scottish regions.  I picked up an older non-Viking 750 mL bottle of their standard 12 year release in suburban Boston for $43.
Tags: Scotch, Island, Highland Park 12
subscribe via RSS


K2k
Jugal
Logout
@csrf
Home
Create new question
Question
Question Type
Short Answer
Multiple Choice
Check Box
Paragraph
Answer
Save
Question
Question Type
Short Answer
Multiple Choice
Check Box
Paragraph
Answer
Add option
Add option


Toggle navigation
Return to Main Site
Thank You!
Please Expect a Response in 2 Business Days.
Redirecting in 5 seconds...
Return to Main Site


Use MSBlobBuilder to build a blob with two strings, then read the blob. Input two different strings in the input text boxes and then click the "Build Blob" button.


|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
public interface TopicMapStoreIF
PUBLIC: A topic map store is used to represent the connection between one topic map and a repository where the data instantiating that topic map is held (in an implementation-specific form). This interface is used to retrieve a topic map from such a repository and to save changes back to the repository. Implementations can be made for different kinds of repositories. The interface supports a simple transaction model.
A topic map store is opened either explicitly through the open() method or implicitly via the getTopicMap() method. If the store is transactional, a new transaction is created when the store is opened.
To make persistent changes in the topic map, use the commit method. To roll back any changes since the last commit (or open), call the abort method. (Note that this only works with transactional stores).
Make sure that you close the store when you are done in order to release resources held by the store. A closed store can be reopened. Closing a transactional store aborts the current transaction, so commit before you close.
| Field Summary | |
|---|---|
static int |
IN_MEMORY_IMPLEMENTATION
PUBLIC: Constant that identifies the in-memory topic map implementation. |
static int |
RDBMS_IMPLEMENTATION
PUBLIC: Constant that identifies the rdbms topic map implementation. |
| Method Summary | |
|---|---|
void |
abort()
PUBLIC: Aborts and deactivates the top-level transaction; all changes made inside the root transaction are lost. |
void |
close()
PUBLIC: Closes the store and aborts the transaction if active. |
void |
commit()
PUBLIC: Commits and deactivates the top-level transaction. |
void |
delete(boolean force)
PUBLIC: Deletes the TopicMapIF from the data store. |
LocatorIF |
getBaseAddress()
PUBLIC: Gets a locator of the topic map in the store. |
int |
getImplementation()
PUBLIC: Returns the topic map implementation identifier. |
String |
getProperty(String propertyName)
PUBLIC: Returns the value of the specified topic map store property. |
TopicMapReferenceIF |
getReference()
INTERNAL: Returns a topic map reference for this store. |
TopicMapIF |
getTopicMap()
PUBLIC: Gets the topic map that is accessible through the root transaction of the store. |
boolean |
isOpen()
PUBLIC: Returns true if the store is open (because opening a transactional store starts a transaction, "true" also means a transaction is in progress). |
boolean |
isReadOnly()
PUBLIC: Returns true if the store is usable for read-only purposes only. |
boolean |
isTransactional()
PUBLIC: Returns true if the store supports transactions. |
void |
open()
PUBLIC: Opens the store, and starts a new transaction on a transactional store. |
void |
setBaseAddress(LocatorIF base_address)
EXPERIMENTAL: Sets the persistent base address of the store. |
void |
setReference(TopicMapReferenceIF reference)
INTERNAL: Sets the topic map reference for this store. |
| Field Detail |
|---|
static final int IN_MEMORY_IMPLEMENTATION
static final int RDBMS_IMPLEMENTATION
| Method Detail |
|---|
int getImplementation()
IN_MEMORY_IMPLEMENTATION
or RDBMS_IMPLEMENTATION
flags.boolean isTransactional()
boolean isOpen()
void open()
void close()
LocatorIF getBaseAddress()
void setBaseAddress(LocatorIF base_address)
TopicMapIF getTopicMap()
void commit()
void abort()
void delete(boolean force) throws NotRemovableException
If the force flag is false and the topic map contains any objects, i.e. topics and associations, a NotRemovableException will be thrown. The topic map will not be modified or closed if this is so.
If the force flag is true, the topic map will be deleted even if it contains any objects.
Note: if you're retrieved the store via a TopicMapReferenceIF then call delete(boolean) on the reference instead.
NotRemovableException
boolean isReadOnly()
String getProperty(String propertyName)
TopicMapReferenceIF getReference()
void setReference(TopicMapReferenceIF reference)
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


A client can provide you with feedback using the screen below
A client can select the sunny icon to indicate that you did Great, or the cloudy icon to indicate that you did Good, or the rainy icon to indicate that you did OK, and finally the thundery icon to indicate that you DID NOT DO WELL
Once the client sends the feedback, you will receive a text message containing a link to the feedback.
You have to sign into your NeatStreak account to view the feedback.
You can view the feedback in the list agreement


frbs: Fuzzy Rule-Based Systems for Classification and Regression Tasks
An implementation of various learning algorithms based on fuzzy rule-based systems (FRBSs) for dealing with classification and regression tasks. Moreover, it allows to construct an FRBS model defined by human experts.
FRBSs are based on the concept of fuzzy sets, proposed by Zadeh in 1965, which aims at
representing the reasoning of human experts in a set of IF-THEN rules, to
handle real-life problems in, e.g., control, prediction and inference, data
mining, bioinformatics data processing, and robotics. FRBSs are also known
as fuzzy inference systems and fuzzy models. During the modeling of an
FRBS, there are two important steps that need to be conducted: structure
identification and parameter estimation. Nowadays, there exists a wide
variety of algorithms to generate fuzzy IF-THEN rules automatically from
numerical data, covering both steps. Approaches that have been used in the
past are, e.g., heuristic procedures, neuro-fuzzy techniques, clustering
methods, genetic algorithms, squares methods, etc. Furthermore, in this
version we provide a universal framework named 'frbsPMML', which is adopted
from the Predictive Model Markup Language (PMML), for representing FRBS
models. PMML is an XML-based language to provide a standard for describing
models produced by data mining and machine learning algorithms. Therefore,
we are allowed to export and import an FRBS model to/from 'frbsPMML'.
Finally, this package aims to implement the most widely used standard
procedures, thus offering a standard package for FRBS modeling to the R
community.
Downloads:
Reverse dependencies:
| Reverse imports: |
exprso |
| Reverse suggests: |
mlr |
Linking:
Please use the canonical form
https://CRAN.R-project.org/package=frbs
to link to this page.


ALKA-SELTZER FRUIT CHEWS- calcium carbonate tablet, chewable
Bayer HealthCare LLC, Consumer Care
Disclaimer: Most OTC drugs are not reviewed and approved by FDA, however they may be marketed if they comply with applicable regulations and policies. FDA has not evaluated whether this product complies.
Active ingredient (in each chewable tablet)
Calcium carbonate 750 mg
Uses
for the relief of:
- acid indigestion
- heartburn
- sour stomach
- upset stomach associated with these symptoms
Warnings
Do not use if you have ever had an allergic reaction to this product or any of its ingredients
Ask a doctor or pharmacist before use if you are presently taking a prescription drug. Antacids may interact with certain prescription drugs.
When using this product
- do not take more than 10 chewable tablets in a 24-hour period
- do not use the maximum dosage of this product for more than 2 weeks except under the advice and supervision of a physician
- constipation may occur
If pregnant or breast-feeding, ask a health professional before use.
Keep out of reach of children.
Directions
- adults and children 12 years and over: chew and swallow 1-2 chewable tablets every 2 to 4 hours as symptoms occur, or as directed by a doctor
- children under 12 years: consult a doctor
- do not take more than 10 chewable tablets in a 24-hour period
Other information
-
each chewable tablet contains: calcium 300 mg
- contains FD&C Yellow No. 5 (tartrazine) as a color additive
- store at room temperature. Avoid humidity. Close cap tightly after use.
Inactive ingredients
acacia, beeswax, carmine, carnauba wax, citric acid, corn starch, corn syrup, DL-alpha tocopherol, FD&C blue #1 aluminum lake, FD&C red #40 aluminum lake, FD&C yellow #5 lake (tartrazine), FD&C yellow #6, FD&C yellow #6 aluminum lake, FD&C yellow #6 lake, flavors, hydrogenated coconut oil, medium chain triglycerides, methyl paraben, modified starch, phosphoric acid, pregelatinized modified starch, propyl paraben, propylene glycol, purified water, shellac, sodium benzoate, sorbic acid, sorbitol, soy lecithin, sucrose, titanium dioxide
Questions or comments?
1-800-986-0369 (Mon – Fri 9AM – 5PM EST) or www.alkaseltzer.com
Distributed by:
Bayer HealthCare LLC
P.O. Box 1910
Morristown, NJ 07962-1910 USA
PRINCIPAL DISPLAY PANEL - 36 Tablet Bottle Label
NEW!
Orange
Lemon
Strawberry
Alka-
Seltzer®
Calcium Carbonate /
Antacid
FRUIT CHEWS
FOR FAST RELIEF OF
- HEARTBURN
- ACID INDIGESTION
- UPSET STOMACH
36 CHEWABLE TABLETS


We also compiled a large corpus of unreliable news articles. These articles come from different types of unreliable sources including satire, propaganda, and hoaxes. See table below for more details:
| News type | Source | # Doc | # Tokens/Doc |
|---|---|---|---|
| Satire | The Onion | 14,170 | 350 |
| Satire | Borowitz Report | 627 | 250 |
| Satire | Clickhole | 188 | 303 |
| Hoax | American News | 6,914 | 204 |
| Hoax | DC Gazette | 5,133 | 582 |
| Propaganda | Natural News | 15,580 | 857 |
| Propaganda | Activist Report | 17,869 | 1,169 |
Labelled Unreliable News Data Set
Collection of rated statments from Politifact fact-checkers (as of Mar 2016) and their connected sites ( punditfact). Statements are rated on 6 pt. scale from True to Pants-on-fire-False. More details about the rubric that is used at Politifact can be found at the politifact website.
~10,000 graded politifact statements
We compiled the following lexicons for textual analysis of "dramatic" language found in unreliable (esp. hoax and propaganda) articles. All of the following lists were compiled from Wiktionary and include:
Design by TEMPLATED under the Creative Commons Attribution 3.0 license


Olivia Newton-John’s iconic ‘Grease’ outfit sells for $405G at auction
by Ebony BowdenThe skin-tight pants and black leather jacket Olivia Newton-John wore in 1978’s “Grease” have sold for $405,000 at auction — nearly twice what they were expected to fetch.
An unnamed buyer on Saturday shelled out $243,200 for the jacket and $162,500 for the pants made famous by the four-time Grammy Award-winning actress in the hit film’s “You’re the One that I Want,” finale.
Martin Nolan, executive director of Julien’s Auctions, which hosted the event, told The Post last week he expected the items to sell for $260,000 — just over what the buyer paid for Newton-John’s leather jacket alone.
OLIVIA NEWTON-JOHN SHARES HER MINDSET AMID CANCER BATTLE: 'I'M STRONG'
“If you ask Olivia, she thinks it’ll go for a million dollars,” Nolan said Wednesday of the outfit. “It’s so iconic, I wouldn’t be surprised.”
“She wore them a couple weeks ago — they still fit,” he added.
The slinky pants actually predate the film by nearly two decades. In an interview with Reuters last week, Newton-John said the zipper on the pants, made in the 1950s, was broken and she had to be sewn into them for the film.
The sexy outfit was among 500 items the Australia-born actress, now 71, auctioned to raise funds for her breast cancer charity. Newton-John is currently in her third battle with the disease.
Also up for auction was Newton-John’s custom Pink Ladies jacket embroidered with “Sandy,” the name of her character in the movie, a signed “Grease” script, and her white cowboy boots from the 1980 flick “Xanadu.”

This article originally appeared on Page Six.


This document is also available in this non-normative format: Diff from previous Editors Draft .
Copyright © 2010-2011 W3C ® ( MIT , ERCIM , Keio ), All Rights Reserved. W3C liability , trademark and document use rules apply.
A
global
distributed
Social
Web
requires
that
each
person
be
able
to
control
their
identity,
that
this
identity
be
linkable
across
sites
-
placing
each
person
in
a
Web
of
relationships
-
and
that
it
be
possible
to
authenticate
globally
with
such
identities
allowing
each
user
identities.
By
making
distributed
authentication
easy
one
can
allow
everybody
to
protect
their
resources
and
enable
his
their
preferred
privacy
settings.
This
specification
outlines
a
simple
universal
identification
mechanism
that
is
distributed,
openly
extensible,
improves
privacy,
security
and
control
over
how
each
person
can
identify
themselves
in
order
to
allow
fine
grained
access
control
to
their
information
on
the
Web.
It
does
this
by
applying
the
best
practices
of
Web
Architecture
whilst
building
on
well
established
widely
deployed
protocols
and
standards
such
as
RDF
including
HTML,
XHTML,
URIs,
HTTP,
TLS,
X509
Certificates,
and
TLS.
RDF
Semantics.
There are a number of concepts that are covered in this document that the reader may want to be aware of before continuing. General knowledge of public key cryptography and RDF [ RDF-PRIMER ] is necessary to understand how to implement this specification. WebID uses a number of specific technologies like HTTP over TLS [ HTTP-TLS ], X.509 certificates [ X509V3 ], RDF/XML [ RDF-SYNTAX-GRAMMAR ] and XHTML+RDFa [ XHTML-RDFA ].
A general Introduction is provided for all that would like to understand why this specification is necessary to simplify usage of the Web.
The terms used throughout this specification are listed in the section titled Terminology .
Developers that are interested in implementing this specification will be most interested in the sections titled Authentication Sequence and Authentication Sequence Details .
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
This document is produced from work by the W3C WebID Incubator Group . This is an internal draft document and may not even end up being officially published. It may also be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress. The source code for this document is available at the following URI: https://dvcs.w3.org/hg/WebIDThis document was published by the WebID XG as an Editor's Draft. If you wish to make comments regarding this document, please send them to<EMAIL_ADDRESS>( subscribe , archives ). All feedback is welcome.
Publication
as
a
an
Editor's
Draft
does
not
imply
endorsement
by
the
W3C
Membership.
This
is
a
draft
document
and
may
be
updated,
replaced
or
obsoleted
by
other
documents
at
any
time.
It
is
inappropriate
to
cite
this
document
as
other
than
work
in
progress.
This document was produced by a group operating under the 5 February 2004 W3C Patent Policy . W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy .
This section is non-normative.
The
WebID
specification
is
designed
to
help
alleviate
the
difficultly
that
remembering
different
logins,
passwords
protocol
enables
secure,
efficient
and
settings
for
websites
has
created.
maximally
user
friendly
authentication
on
the
Web.
It
is
also
designed
to
provide
a
universal
and
extensible
mechanism
enables
people
to
express
public
and
private
information
about
yourself.
This
section
outlines
the
motivation
behind
the
specification
and
authenticate
onto
any
site
by
simply
clicking
on
one
of
the
relationship
certificates
proposed
to
other
similar
specifications
that
are
them
by
their
browser.
These
certificates
can
be
created
by
any
Web
Site
for
their
users
in
active
use
today.
1.1
Motivation
This
section
is
non-normative.
It
one
click.
The
identifier,
known
as
the
WebID
,
is
a
fundamental
design
criteria
of
the
Web
to
enable
individuals
and
organizations
to
control
how
they
interact
with
URI
whose
sense
can
be
found
in
the
rest
associated
Profile
Page
,
a
type
of
society.
This
includes
how
one
expresses
their
identity,
public
information
and
personal
details
to
social
networks,
Web
sites
and
services.
web
page
that
any
Social
Network
user
is
familiar
with.
Semantic
These
WebIDs
can
be
used
to
build
a
Web
of
trust
using
vocabularies
such
as
Friend-of-a-Friend
(FOAF)
permit
distributed
hyperlinked
social
networks
to
exist.
This
vocabulary,
along
with
other
vocabularies,
allow
one
to
add
information
and
services
protection
to
distributed
social
networks.
One
major
criticism
of
open
networks
is
that
they
seem
to
have
no
way
of
protecting
the
personal
information
distributed
on
the
web
or
limiting
access
to
resources.
Few
foaf
by
allowing
people
are
willing
to
make
all
link
together
their
personal
information
public,
many
would
like
large
pieces
to
be
protected,
making
it
available
only
to
profiles
in
a
selected
group
public
or
protected
manner.
Such
a
web
of
agents.
Giving
access
to
information
is
very
similar
to
giving
access
to
services.
There
are
many
occasions
when
people
would
like
services
to
only
trust
can
then
be
accessible
to
members
of
used
by
a
group,
such
as
Service
to
make
authorization
decisions,
by
allowing
only
friends,
family
members,
colleagues
access
to
post
an
article,
photo
or
comment
resource
depending
on
the
properties
of
an
agent,
such
that
the
he
is
known
by
some
relevant
people,
works
at
a
blog.
How
does
one
do
this
in
a
flexible
way,
without
requiring
given
company,
is
a
central
point
family
member,
is
part
of
access
control?
some
group,
...
Using
a
process
made
popular
by
OpenID,
we
show
The
WebID
protocol
specifies
how
one
a
Service
can
tie
authenticate
a
User
Agent
user
after
requesting
his
Certificate
without
needing
to
rely
on
this
being
signed
by
a
URI
well
known
Certificate
Authority.
This
is
done
by
proving
that
one
has
write
access
to
dereferencing
the
URI.
WebID
is
an
authentication
protocol
which
uses
X.509
certificates
Profile
,
and
checking
if
it
describes
the
user
as
being
in
control
of
the
the
private
key
related
to
associate
a
User
Agent
(Browser)
the
Public
Key
published
in
the
Certificate
she
used
to
a
Person
identified
via
a
URI.
A
authenticate.
WebID
profile
authentication
can
also
be
used
for
OpenID,
WebID
provides
a
few
additional
features
automatic
authentication
by
robots,
such
as
trust
management
via
digital
signatures,
and
free-form
extensibility
via
RDF.
By
using
the
existing
SSL
certificate
exchange
mechanism,
WebID
integrates
smoothly
with
existing
Web
browsers,
including
browsers
web
crawlers
of
linked
data
repositories,
which
could
be
agents
working
on
mobile
devices.
WebID
also
permits
automated
session
login
behalf
of
users
to
help
them
in
addition
their
daily
tasks.
The
WebID
protocol
is
not
limited
to
interactive
session
login.
Additionally,
all
data
authentication
on
the
World
Wide
Web,
but
can
work
with
any
TLS
based
protocol.
This
specification
is
encrypted
divided
in
the
following
sections.
This
section
gives
a
high
level
overview
of
the
WebID
Protocol,
and
guaranteed
to
only
be
received
by
presents
the
person
or
organization
organisation
of
the
specification
and
the
conventions
used
throughout
the
document.
Section
2
lists
the
preconditions
that
was
intended
need
to
receive
it.
be
in
place
for
any
authentication
sequence
to
be
successful:
which
include
the
creation
of
a
WebID
Profile
and
the
creation
of
a
WebID
Certificate
2.
Preconditions
Section
3
on
the
WebID
Protocol
describes
in
detail
how
a
server
can
authenticate
a
user.
Subject
Alternative
Name
WebID
published
there.
This
is
usually
done,
because
the
TLS
Service
Light
did
not
verify
the
SAN
using
a
Certificate
Authority
signature.
But
it
can
also
be
done
to
verify
that
the
Certificate
is
still
valid.
Subject
Alternative
Name
extension
with
at
least
one
URI
entry
identifying
the
Subject
.
This
URI
should
be
one
of
the
URIs
with
a
dereferenceable
secure
scheme,
such
as
https://
.
Dereferencing
this
URI
should
return
a
representation
containing
RDF
data.
For
example,
a
certificate
identifying
the
WebID
URI
https://bob.example/profile#me
would
contain
the
following:
X509v3 extensions: ... X509v3 Subject Alternative Name: URI:https://bob.example/profile#meAnd it would have a WebID Profile at
https://bob.example/profile
Such
a
URI
is
known
as
a
WebID
.
Most profiles are currently written out in either of those formats. Whether or not XHTML+RDFa 1.1, both either serialization of RDF should be required serialization formats in the specification is currently under heavy debate and is open to change.
Examples assume the following namespace prefix bindings unless otherwise stated:
| Prefix | IRI |
|---|---|
cert
|
http://www.w3.org/ns/auth/cert# |
xsd
|
http://www.w3.org/2001/XMLSchema# |
foaf
|
http://xmlns.com/foaf/0.1/ |
ex
|
https://bob.example/profile# |
The
ex:
namespace
is
a
URI
that
refers
to
Bob's
profile,
where
Bob
is
an
imaginary
charcter
character
well
known
in
security
circles.
The
user
agent
will
create
Key
Chain
must
have
a
Identification
Certificate
with
a
Subject
Alternative
Name
URI
entry.
This
URI
must
be
one
that
dereferences
to
a
document
the
user
controls
so
that
he
can
publish
the
public
key
of
the
Identification
for
that
Certificate
at
this
URI.
For
example,
if
a
user
Bob
controls
https://bob.example/profile
,
then
his
WebID
can
be
https://bob.example/profile#me
When
creating
a
certificate
it
is
very
important
to
put
an
nice
choose
a
user
friendly
Common
Name
(CN)
for
the
user,
that
will
allow
him
to
distinguish
between
different
certificates
he
may
have,
such
as
a
personal
or
a
business
certificate.
certificate,
when
selecting
one
from
his
browser.
In
the
example
below
the
CN
is
Bob
(personal)
.
This
name
can
then
also
be
used
displayed
by
any
server
authenticating
the
user
to
immediately
find
as
a
way
to
address
the
user.
human
friendly
label.
The
WebID
URL
itself
should
not
usually
be
used
as
a
visible
identifier
for
human
users,
rather
it
should
be
thought
of
as
a
hyperlink
in
an

code,
especially
if
anchor.
That
is
the
resulting
resource
has
an
html
representation.
CN
should
be
a
label
and
the
WebID
a
pointer.
As an example to use throughout this specification here is the following certificate as an output of the openssl program.
Certificate: Data: Version: 3 (0x2) Serial Number: 5f:df:d6:be:2c:73:c1:fb:aa:2a:2d:23:a6:91:3b:5c Signature Algorithm: sha1WithRSAEncryption Issuer: O=FOAF+SSL, OU=The Community of Self Signers, CN=Not a Certification Authority Validity Not Before: Jun 8 14:16:14 2010 GMT Not After : Jun 8 16:16:14 2010 GMT Subject: O=FOAF+SSL, OU=The Community Of Self Signers, CN=Bob (Personal) Subject Public Key Info: Public Key Algorithm: rsaEncryption Public-Key: (2048 bit) Modulus: 00:cb:24:ed:85:d6:4d:79:4b:69:c7:01:c1:86:ac: c0:59:50:1e:85:60:00:f6:61:c9:32:04:d8:38:0e: 07:19:1c:5c:8b:36:8d:2a:c3:2a:42:8a:cb:97:03: 98:66:43:68:dc:2a:86:73:20:22:0f:75:5e:99:ca: 2e:ec:da:e6:2e:8d:15:fb:58:e1:b7:6a:e5:9c:b7: ac:e8:83:83:94:d5:9e:72:50:b4:49:17:6e:51:a4: 94:95:1a:1c:36:6c:62:17:d8:76:8d:68:2d:de:78: dd:4d:55:e6:13:f8:83:9c:f2:75:d4:c8:40:37:43: e7:86:26:01:f3:c4:9a:63:66:e1:2b:b8:f4:98:26: 2c:3c:77:de:19:bc:e4:0b:32:f8:9a:e6:2c:37:80: f5:b6:27:5b:e3:37:e2:b3:15:3a:e2:ba:72:a9:97: 5a:e7:1a:b7:24:64:94:97:06:6b:66:0f:cf:77:4b: 75:43:d9:80:95:2d:2e:85:86:20:0e:da:41:58:b0: 14:e7:54:65:d9:1e:cf:93:ef:c7:ac:17:0c:11:fc: 72:46:fc:6d:ed:79:c3:77:80:00:0a:c4:e0:79:f6: 71:fd:4f:20:7a:d7:70:80:9e:0e:2d:7b:0e:f5:49: 3b:ef:e7:35:44:d8:e1:be:3d:dd:b5:24:55:c6:13: 91:a1 Exponent: 65537 (0x10001) X509v3 extensions: X509v3 Basic Constraints: critical CA:FALSE X509v3 Key Usage: critical Digital Signature, Non Repudiation, Key Encipherment, Key Agreement Netscape Cert Type: SSL Client, S/MIME X509v3 Subject Key Identifier: 08:8E:A5:5B:AE:5D:C3:8B:00:B7:30:62:65:2A:5A:F5:D2:E9:00:FA X509v3 Subject Alternative Name: critical URI:https://bob.example/profile#me Signature Algorithm: sha1WithRSAEncryption cf:8c:f8:7b:b2:af:63:f0:0e:dc:64:22:e5:8a:ba:03:1e:f1: ee:6f:2c:f5:f5:10:ad:4c:54:fc:49:2b:e1:0d:cd:be:3d:7c: 78:66:c8:ae:42:9d:75:9f:2c:29:71:91:5c:29:5b:96:ea:e1: e4:ef:0e:5c:f7:07:a0:1e:9c:bf:50:ca:21:e6:6c:c3:df:64: 29:6b:d3:8a:bd:49:e8:72:39:dd:07:07:94:ac:d5:ec:85:b1: a0:5c:c0:08:d3:28:2a:e6:be:ad:88:5e:2a:40:64:59:e7:f2: 45:0c:b9:48:c0:fd:ac:bc:fb:1b:c9:e0:1c:01:18:5e:44:bb: d8:b8
Should
we
formally
require
the
Issuer
to
be
O=FOAF+SSL,
OU=The
Community
of
Self
Signers,
CN=Not
a
Certification
Authority.
This
was
discussed
on
the
list
as
allowing
servers
to
distinguish
certificates
that
are
foaf+Ssl
foaf+SSL
enabled
from
others.
Will
probably
need
some
very
deep
TLS
thinking
to
get
this
right.
The
above
certificate
is
no
longer
valid,
as
I
took
an
valid
certificate
and
change
the
time
and
WebID.
As
a
result
the
Signatiure
signature
is
now
false.
A
completely
valid
certificate
should
be
generated
to
avoid
nit-pickers
picking
nits
nits.
Many tools exist to create a Certificate. Some keychains allow a user to create the Certificate directly with a friendly User Interface. But using a keychain on the client still requires the public key to be published on the server as detailed in the next section. It is possible to combine the creation of the key with its publication in one step in such a way as to allow the server to make the decision of what the WebID should be, by using the HTML 5 keygen element. This element can be placed in an HTML5 form, where on submitting the form, the browser asks the Key Chain to create a public and private key pair, and on receiving the public part of that keypair the Client can sends a keyrequest as part of the form to the Service . The Service can then create a WebID Certificate and return it to the Client to pass onto the KeyChain . In that way the Server is in the position to best make the decisions of what the Certificate should say and what the WebID should be without the private key ever leaving the secure Key Chain . The user experience for this Certificate creation is a one click operation.
The
WebID
Profile
document
must
expose
the
relation
between
the
WebID
URI
and
the
Identification
Agent
's
public
key
s
using
the
cert
ontologies,
ontology
as
well
as
the
standard
xsd
datatypes.
The
set
of
relations
to
be
published
at
the
WebID
Profile
document
can
be
presented
in
a
graphical
notation
as
follows.
The document can publish many more relations than are of interest to the WebID protocol, as shown in the above graph by the grayed out relations. For example Bob can publish a depiction or logo, so that sites he authenticates to can personalise the user experience. He can post links to people he knows, where those are have WebIDs published on other sites, in order to create a distributed Social Web. He can also publish relations to protected documents, where he keeps more information for people who authenticate, such as his friend Alois or his friends friends who may not yet know him personally, such as Alice.
The
protocol
does
not
depend
on
any
particular
serialisation
of
the
graph,
provided
that
agents
are
able
to
parse
that
serialisation
and
obtain
the
graph
automatically.
Technologies
such
as
GRDDL
[
GRDDL-PRIMER
]
for
example
permit
any
XML
format
to
be
transformed
automatically
to
a
graph
of
relations.
Yet
for
reasons
of
interoperabity
interoperability
is
has
been
decided
that
the
document
must
be
published
at
least
in
one
of
RDFa
[XHTML-RDFA]
or
RDF/XML
[RDF-SYNTAX-GRAMMAR].
HTTP
Content
Negotiation
[SWBP-VOCAB-PUB]
can
be
employed
to
aid
in
publication
and
discovery
of
multiple
distinct
serialisations
of
the
same
graph
at
the
same
URL.
Irrespective
of
whether
content
negotiation
can
or
not
be
employed,
if
an
HTML
representation
of
the
WebID
profile
is
published,
it
is
suggested
that
the
provider
uses
the
HTML
<link>
element
to
allow
discovery
of
the
various
alternate
representations
of
the
graph
which
may
be
available:
  <link rel="alternate" type="application/rdf+xml" href="profile.rdf"/> <link rel="alternate" type="text/turtle" href="profile.ttl"/> ...  ...
It is particularly useful to have one of the representations be in HTML or XHTML even if it is not marked up in RDFa as this allows people using a web browser to understand what the information at that URI represents.
A
widely
used
format
for
writing
RDF
graphs
by
hand
is
the
Turtle
notation.
It
is
easy
to
learn
to
use,
is
very
handy
for
commmunicating
communicating
over
e-mail
and
on
mailing
lists,
and
can
then
be
transformed
into
RDF/XML
automatically.
It
is
also
very
similar
to
the
SPARQL
query
language.
@prefix : <http://www.w3.org/ns/auth/cert#> . @prefix xsd: <http://www.w3.org/2001/XMLSchema#> . @prefix foaf: <http://xmlns.com/foaf/0.1/> . @prefix bob: <https://bob.example/profile#> . @prefix rdfs: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . bob:me a foaf:Person; foaf:name "Bob"; foaf:knows <https://example.edu/p/Alois#MSc>; foaf:weblog <http://bob.example/blog>; :key [ a :RSAPublicKey; rdfs:label "made on 23 November 2011 on my laptop"; :modulus "cb24ed85d64d794b69c701c186acc059501e856000f661c93204d8380e07191c5c8b368d2ac32a428acb970398664368dc2a867320220f755e99ca2eecdae62e8d15fb58e1b76ae59cb7ace8838394d59e7250b449176e51a494951a1c366c6217d8768d682dde78dd4d55e613f8839cf275d4c8403743e7862601f3c49a6366e12bb8f498262c3c77de19bce40b32f89ae62c3780f5b6275be337e2b3153ae2ba72a9975ae71ab724649497066b660fcf774b7543d980952d2e8586200eda4158b014e75465d91ecf93efc7ac170c11fc7246fc6ded79c37780000ac4e079f671fd4f207ad770809e0e2d7b0ef5493befe73544d8e1be3dddb52455c61391a1"^^xsd:hexBinary; :exponent 65537 ; ] .
There
are
many
ways
of
writing
out
the
above
graph
using
RDFa
in
html.
HTML.
Here
is
just
one
example
of
what
a
WebID
profile
could
look
like.
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.0//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-1.dtd">   <title>Welcome to Bob's Home Page</title>
 Bob
My Good Friends

Alois

My RSA Public Keys

I made this key on the 23 November 2011 from my laptop.

Modulus (hexadecimal)

cb24ed85d64d794b69c701c186acc059501e856000f661c93204d8380e07191c5c8b368d2ac32a428acb970398664368dc2a867320220f755e99ca2eecdae62e8d15fb58e1b76ae59cb7ace8838394d59e7250b449176e51a494951a1c366c6217d8768d682dde78dd4d55e613f8839cf275d4c8403743e7862601f3c49a6366e12bb8f498262c3c77de19bce40b32f89ae62c3780f5b6275be337e2b3153ae2ba72a9975ae71ab724649497066b660fcf774b7543d980952d2e8586200eda4158b014e75465d91ecf93efc7ac170c11fc7246fc6ded79c37780000ac4e079f671fd4f207ad770809e0e2d7b0ef5493befe73544d8e1be3dddb52455c61391a1

Exponent (decimal)

65537

The
style="word-wrap:
break-word;
white-space:
pre-wrap;"
attributes
allow
the
number
to
be
displayed
on
more
than
one
line
so
that
it
will
wrapped
across
lines
and
not
just
continue
off
to
the
right
of
the
screen.
In order to make the above modulus easy to read for humans who may wish to compare it with the modulus in their browser, one can add some javascript. Add some javascript here that adds a : between every two characters, and that splits the line up in chunks.
If a WebID provider would rather prefer not to mark up his data in RDFa, but just provide a human readable format for users and have the RDF graph appear in a machine readable format such as RDF/XML then he may publish the link from the HTML to a machine readable format (it this is available at a dedicated URI) as follows:

<link rel="alternate" type="application/rdf+xml" href="profile.rdf"/>

 ...

  <link rel="alternate" type="application/rdf+xml" href="profile.rdf"/>   ...
RDF/XML is easy to generate automatically from structured data, be it in object notation or in relational databases. Parsers for it are also widely available.
<?xml version="1.0"?> <rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#" xmlns:cert="http://www.w3.org/ns/auth/cert#" xmlns:xsd="http://www.w3.org/2001/XMLSchema#" xmlns:foaf="http://xmlns.com/foaf/0.1/"> <foaf:Person rdf:about="https://bob.example/profile#me"> <foaf:name>Bob</foaf:name> <foaf:weblog rdf:resource="http://bob.example/blog"/> <cert:key> <cert:RSAPublicKey> <rdfs:label>made on 23 November 2011 on my laptop</rdfs:label> <cert:modulus rdf:datatype="http://www.w3.org/ns/auth/cert#hexBinary"> cb24ed85d64d794b69c701c186acc059501e856000f661c93204d8380e07191c5c8b368d2ac32a428acb970398664368dc2a867320220f755e99ca2eecdae62e8d15fb58e1b76ae59cb7ace8838394d59e7250b449176e51a494951a1c366c6217d8768d682dde78dd4d55e613f8839cf275d4c8403743e7862601f3c49a6366e12bb8f498262c3c77de19bce40b32f89ae62c3780f5b6275be337e2b3153ae2ba72a9975ae71ab724649497066b660fcf774b7543d980952d2e8586200eda4158b014e75465d91ecf93efc7ac170c11fc7246fc6ded79c37780000ac4e079f671fd4f207ad770809e0e2d7b0ef5493befe73544d8e1be3dddb52455c61391a1 </cert:modulus> <cert:exponent rdf:datatype="http://www.w3.org/ns/auth/cert#integer">65537</cert:exponent> </cert:RSAPublicKey> </cert:key> </foaf:Person> </rdf:RDF>
TODO: the dsa ontology
What should the time to live be on a WebID document?
TODO: discuss other formats and GRDDL, XSPARQL options for xml formats
summarize and point to content negotiation documents
A WebID Certificate identifies the Subject alone and no one else, if and only if she is the only one to control the corresponding private key. It is very important therefore that the Subject take care of keeping the private key secure. This can be done by keeping it in the Key Chain of a personal machine in an account that is password protected and free of viruses, or best of all on some physical device where the private key is inaccessible to be read by any software. In the second case having the device implies that the private key has not been lost or copied. In the first case the user has to be more careful for signals of misuse.
In
either
situation
if
the
Subject
is
suspicious
that
his
private
key
has
been
taken,
then
he
can
disable
future
authentications
for
that
certificate
by
removing
the
corresponding
public
key
from
his
WebID
Profile
.
If
the
profile
contains
more
than
one
public
key
for
the
Subject
then
it
is
suggested
that
each
public
key
contain
a
label
to
help
the
user
locate
the
key.
In
the
examples
above
an
rdfs:label
with
a
creation
date
was
used
for
this
purpose.
In
order
to
give
the
full
context
of
a
Client
interaction
with
a
Server
we
will
illustrate
the
protocol
with
the
following
sequence
diagram.
Bob
initiates
a
connection
to
Alice
's
server
via
a
TLS
enabled
protocol
such
as
https
HTTPS
in
order
to
access
a
Protected
Resource
or
a
Protected
Service.
The
Protected
Resource
must
be
served
over
a
TLS-Light
Service
,
that
will
not
do
full
CA
authentication
of
Client
Certificate
s
it
receives.
The
Protected
Resource
may
be
a
document
served
over
https,
HTTPS,
but
it
could
also
be
a
SOAP
service,
or
some
other
resource.
This
resource
is
protected
by
a
Guard,
which
uses
a
WebID
Verifier
to
verify
the
non
Certified
WebIds
WebIDs
found
in
the
certificate.
Once
the
verification
succeeds
the
Guard
checks
to
see
if
the
Agent
identified
by
the
WebID
is
allowed
access
to
the
resource,
by
using
trusted
information
from
the
Web
and
access
control
rules.
The steps in detail are as follows:
Subject
Alternative
Name
extension
of
the
WebID
Certificate
.
A
WebID
Certificate
may
contain
multiple
URI
entries
which
are
considered
claimed
WebID
s
at
this
point,
since
they
have
not
been
verified.
The
Verification
Agent
may
verify
as
many
or
as
few
WebIDs
it
has
time
for.
It
may
do
it
in
parallel
and
asynchronously.
However
that
is
done,
a
claimed
WebIDs
can
only
be
considered
verified
if
the
following
steps
have
been
accomplished
successfully:
This section covers details about each step in the authentication process.
Standard SSLv3 and TLSv1 and upwards can be used to establish the connection between the Client and the TLS Agent listening on the Service's port.
Many servers allow a simple form of TLS client side authentication to be setup when configuring a TLS Agent : they permit the agent to be authenticated in WANT or NEED mode. If the client sends a certificate, then neither of these have an impact on the WebID Verification steps (4) and (5). Nevertheless, from a user interaction perspective both of these are problematic as they either force (NEED) or ask the user to authenticate himself even if the resource he wishes to interact with is public and requires no authentication. People don't usually feel comfortable authenticating to a web site on the basis of a certificate alone. They prefer human readable text, and detailed error messages which the HTTP layer deliver. It is better to move the authentication to the application layer Guard as it has a lot more information about the application state. Please see the WebID Wiki for implementation pointers in different programming languages and platforms to learn about how this can be done and to share your experience.
Once the TLS connection has been setup, the application layer protocol interaction can start. This could be an HTTP GET request on the protected resource for example.
If the protocol permits it, the Client can let the Application layer, and especially the Guard know that the client can authenticate with a WebID Certificate, and even if it wishes to do so. This may be useful both to allow the Server to know that it can request the client certificate, and also in order to make life easier for Robots that may find it a lot more convenient to be authenticated at the TLS layer.
Bergi proposed a header for HTTP which could do this. Please summarise it.
TLS
allows
the
server
to
request
a
Certificate
from
the
Client
using
the
CertificateRequest
message
[section
7.4.4]
of
TLS
v1.1
[
RFC5246
].
Since
WebID
TLS
authentication
does
not
rely
on
CA's
signing
the
certificate
to
verify
the
WebID
Claims
made
therein,
the
Server
does
not
need
to
restrict
the
certificate
it
receives
by
the
CA's
they
were
signed
by.
It
can
therefore
leave
the
certificate_authorities
field
blank
in
the
request.
From our experience leaving the certificate_authorities field empty leads to the correct behavior on all browsers and all TLS versions.
A security issue with TLS renegotiation was discovered in 2009, and an IETF fix was proposed in [ RFC5746 ] which is widely implemented.
If the Client does not send a certificate, because either it does not have one or it does not wish to send one, other authentication procedures can be pursued at the application layer with protocols such as OpenID, OAuth, BrowserID, etc...
As
far
as
possible
it
is
important
for
the
server
to
request
the
client
certificate
in
WANT
mode,
not
in
NEED
mode.
If
the
request
is
made
in
NEED
mode
then
connections
will
be
broken
off
if
the
client
does
not
send
a
certificate.
This
will
break
the
connection
at
the
application
protocol
layer,
and
so
will
lead
to
a
very
bad
user
experience.
The
server
should
therfore
therefore
avoid
doing
this
unless
it
can
be
confident
that
the
client
has
a
certificate
-
which
it
may
be
because
the
client
advertised
that
in
some
other
way
to
the
server.
Is there some normative spec about what NEED and WANT refer to?
The Verification Agent is given a list of WebIDs associated with a public key. It needs to verify that the agent identified by that WebID is indeed the agent that controls the private key of the given public key. It does this by looking up the definition of the WebID. A WebID is a URI, and it's meaning can be had by dereferencing it using the protocol indicated in its scheme.
If we first consider WebIDs with fragment identifiers, we can explain the logic of this as follows. As is explained in the RFC defining URIs [ RFC3986 ]
The fragment identifier component of a URI allows indirect identification of a secondary resource by reference to a primary resource and additional identifying information. The identified secondary resource may be some portion or subset of the primary resource, some view on representations of the primary resource, or some other resource defined or described by those representations. [...] The semantics of a fragment identifier are defined by the set of representations that might result from a retrieval action on the primary resource.
In order therefore to know the meaning of WebID containing a fragment identifier, one needs to dereference the resource referred to without the fragment identifier. This resource will describe the referent of the WebID in some way. If it says that the referent of the WebID is the agent that controls the private key of the given public key, then this is a definite description that can be considered to be a definition of the WebID: it gives its meaning.
The
trust
that
can
be
had
in
that
statement
is
therefore
the
trust
that
one
can
have
in
one's
having
received
the
correct
representation
of
the
document
that
defined
that
WebID.
An
https
HTTPS
WebID
will
therefore
be
a
lot
more
trustworthy
than
an
https
HTTP
WebID
by
a
factor
of
the
likelyhood
likelihood
of
man
in
the
middle
attacks.
Once
that
is
proven
then
the
trust
one
can
have
in
the
agent
at
the
end
of
the
TLS
connection
being
the
referent
of
the
WebID
is
related
to
the
trust
one
has
in
the
cryptography,
and
the
likelyhood
likelihood
that
the
private
key
could
have
been
stolen.
Add explanation for URI with redirect.
So
the
The
Verification
Agent
needs
to
fetch
the
document,
if
it
does
not
have
a
valid
one
in
cache.
The
Verification
Agent
must
be
able
to
process
documents
in
RDF/XML
[
RDF-SYNTAX-GRAMMAR
]
and
RDFa
in
XHTML
[
XHTML-RDFA
].
The
result
of
this
processing
should
be
a
graph
of
RDF
relations
that
is
queryable,
as
explained
in
the
next
section.
It
is
suggested
that
the
Verification
Agent
should
set
the
Accept-Header
to
request
application/rdf+xml
with
a
higher
priority
than
text/html
and
application/xhtml+xml
.
The
reason
is
that
it
is
quite
likely
that
many
sites
will
produce
non
marked
up
html
HTML
and
leave
the
graph
to
the
pure
rdf
formats.
If the Guard wishes to have the most up-to-date Profile document for an HTTPS URL, it can use the HTTP cache control headers to get the latest versions.
To
check
a
WebID
claim
one
has
to
find
if
the
graph
returned
by
the
profile
relates
the
WebID
to
the
Certificate
Public
Key
with
the
cert:key
relation.
In
other
words
one
has
to
check
if
those
statements
are
present
in
the
graph.
Testing for patterns in graphs is what the SPARQL query language is designed to do [ RDF-SPARQL-QUERY ]. We will first look at how to use this as it is also the simplest method, and then what some other programmatic options may be.
Below
is
the
SPARQL
Query
Template
which
should
be
used
for
an
RSA
public
key.
It
contains
three
variables
?webid
,
?mod
and
?exp
that
need
to
be
replaced
by
the
appropriate
values:
PREFIX : <http://www.w3.org/ns/auth/cert#> PREFIX xsd: <http://www.w3.org/2001/XMLSchema#> ASK { ?webid :key [ :modulus ?mod; :exponent ?exp; ] . }
The variables to be replaced for each WebID claim are:
| Variable | Details on its value. |
|---|---|
?webid
|
should
be
replaced
by
the
WebID
Resource.
In
the
SPARQL
notation
that
is
the
URL
string
would
be
placed
between
<...>
in
the
position
of
the
?webid
variable.
|
?mod
|
should
be
replaced
by
the
modulus
written
as
a
xsd:hexBinary
as
specified
by
the
cert:modulus
relation.
All
leading
double
0
bytes
(written
"00"
in
hexadecimal)
should
be
removed.
The
resulting
"XXX"^^xsd:hexBinary
|
?exp
|
should be replaced by the public exponent written as an xsd:integer typed literal. In SPARQL as in Turtle notation this can just be written directly as an integer. |
Assuming
that
we
received
Bob's
key
whose
modulus
starts
with
cb24ed85d64d794b6...
and
whose
exponent
is
65537
then
the
following
query
should
be
used:
PREFIX : <http://www.w3.org/ns/auth/cert#> PREFIX xsd: <http://www.w3.org/2001/XMLSchema#> ASK { <https://bob.example/profile#me> :key [ :modulus "cb24ed85d64d794b69c701c186acc059501e856000f661c93204d8380e07191c5c8b368d2ac32a428acb970398664368dc2a867320220f755e99ca2eecdae62e8d15fb58e1b76ae59cb7ace8838394d59e7250b449176e51a494951a1c366c6217d8768d682dde78dd4d55e613f8839cf275d4c8403743e7862601f3c49a6366e12bb8f498262c3c77de19bce40b32f89ae62c3780f5b6275be337e2b3153ae2ba72a9975ae71ab724649497066b660fcf774b7543d980952d2e8586200eda4158b014e75465d91ecf93efc7ac170c11fc7246fc6ded79c37780000ac4e079f671fd4f207ad770809e0e2d7b0ef5493befe73544d8e1be3dddb52455c61391a1"^^xsd:hexBinary; :exponent 65537; ] . }
An
ASK
query
simply
returns
true
or
false.
If
it
returns
true,
then
the
key
was
found
in
the
graph
with
the
proper
relation
and
the
claim
has
been
is
verified.
In
order
to
allow
the
class
of
queries
defined
by
the
template
above
to
return
true
when
asked
of
graphs
where
the
hexBinary
or
the
exponent
contains
whitespace
characters
in
initial
and
final
position,
the
query
engine
must
support
the
D-entailment
regime
for
xsd:hexBinary
and
xsd:integer
as
specified
in
SPARQL
1.1
Entailment
Regimes
.
For verifiers that do not have access to a SPARQL query engine but can query the RDF data programmatically, it is relatively easy to emulate the above SPARQL query programmatically. There are a number of ways of doing this, some more efficient than others.
If
the
RDF
library
does
datatype
normalisation
of
all
literals
before
loading
them,
then
the
most
efficient
way
to
execute
this
would
be
to
start
by
searching
for
all
triples
whose
subjects
have
relation
cert:modulus
to
the
literal
which
in
our
example
was
"cb24ed..."^^xsd:hexBinary
.
One
would
then
iterate
through
all
the
subjects
of
the
relations
that
satisfied
that
condition,
which
would
most
likely
never
number
more
than
one,
and
from
there
filter
out
all
those
that
were
the
object
of
the
cert:modulus
relation
of
the
WebID
-
in
the
example
bob:me
.
Finally
one
would
verify
that
one
of
the
keys
that
had
satisfied
those
relations
also
had
the
cert:exponent
relation
to
the
number
which
in
the
example
above
is
"65537"^^xsd:integer
.
For
triples
stores
that
do
not
normalise
literals
on
loading
a
DSA
key.
We
graph,
the
normalization
will
need
to
add
an
ontology
for
DSA
too.
be
done
after
the
query
results
and
before
matching
those
with
the
values
from
the
Certificate
.
Because
one
could
not
rely
on
the
modulus
having
been
normalized,
one
would
have
to
start
with
the
WebID
-
bob:me
and
find
all
it's
cert:key
relations
to
objects
-
which
we
know
to
be
keys
-
and
then
iterate
through
each
of
those
keys'
modulus
and
exponent,
and
verify
if
the
normalised
version
of
the
value
of
those
relation
is
equal
to
the
numbers
found
in
the
certificate.
If
one
such
key
is
found
then
the
answer
is
true
,
otherwise
the
answer
will
be
false
.
The WebID Profile is a structured document that contains identification credentials for the Identification Agent expressed using the Resource Description Framework [ RDF-CONCEPTS ]. The following sections describe how to express certain common properties that could be used by Verification Agent s and other entities that consume a WebID Profile .
Personal details are the most common requirement when registering an account with a website. Some of these pieces of information include an e-mail address, a name and perhaps an avatar image. This section includes properties that should be used when conveying key pieces of personal information but are not required to be present in a WebID Profile :
Cryptographic details are important when Verification Agent s and Identification Agent s interact. The following properties should be used when conveying cryptographic information in WebID Profile documents:
cert:identity was previously used to associate an RSAPublicKey with a WebID URI. cert:identity has been deprecated in favor of its inverse property cert:key. Implementors are encouraged to publish WebID Profile Documents using cert:key. During this transitional period, implementations consuming WebID Profile Documents might still support the deprecated cert:identity as well as the stable cert:key.
This section is non-normative.
2011-12-12 Fixed several errors in examples and diagrams, clarified TLS-Light, added SSL renegotiation, key chain and cache control, updated list people in acknowledgments.
2011-11-23 Wide ranging changes: Rewrote the Verification algorithm now enhanced with a detailed sequence diagram. Moved to new ontology using xsd:hexBinary datatypes and removed rsa: ontology. Rewrote vocabulary section using clearer names. All these changes required serious rewriting everywhere.
2011-02-10 Move to W3C WebID XG . Updates from previous unofficial WebID group include changes on RDF/XML publishing in HTML, clarification on multiple SAN URIs and WebID verification steps.
2010-08-09 Updates from WebID community: moved OpenID/OAuth sections to separate document, switched to the URI terminology instead of URL, added "Creating the certificate" and "Publishing the WebID Profile document" sections with a WebID graph and serializations in Turtle and RDFa, improved SPARQL queries using literal notation with cert datatypes, updated list of contributors, and many other fixes.
2010-07-25 Added WebID Profile section.
2010-07-18 Updates from WebID community related to RDF/XML support, authentication sequence corrections, abstract and introduction updates.
2010-07-11 Initial version.
This section is non-normative.
The following people have been instrumental in providing thoughts, feedback, reviews, criticism and input in the creation of this specification:


Comments
-
Greg Hurrell
Steps to reproduce? Can't get it to do what you describe here.
-
bugzilla user 69
To reproduce pick a track that has an album cover (to be sure that it exists on amazon). Stop synergy and delete the art from the album covers directory. Restart synergy and play that track. On my 17" powerbook I see the artwork get fetched and put in the folder but even when I bring up the floater again while the track is playing I still only get the synergy icon. However if I skip forward to any other track and then back to the track in question the floater shows the proper album art.
-
LangerStuff
Same for me. The cover s downloaded, but not shown in the floater. When I open the track again it is displayed correctly.
-
Greg Hurrell
Although I couldn't reproduce this when it was first reported, I too can now reproduce it with the latest version of Synergy. I had a look at the code yesterday to see why this might be happening and I couldn't immediately see the cause, but I'm going to keep looking and see if I can figure out what's going wrong...
Marking as ASSIGNED.
-
Darkside
Another vote for this fix. I'm using Synergy on a media center to display the floater constantly on a TV, and it's quite annoying.
I've found that actions like pausing the track and even unchecking the track in iTunes while it's playing will cause the floater to update.
-
Greg Hurrell
Changing assignment to reflect my new email address.
http://wincent.com/a/news/archives/2006/05/change_of_email.php
-
Greg Hurrell
See also:
http://wincent.com/a/support/forums/showflat.php?Number=1031
Couldn't figure out the cause of this last time I looked but am going to take another look now. I'd like to get this squished for 3.0.
-
Kevan Smith
Finding the same bug on an upgrade to Leopard. Updated to sysnergy 3.2 but that didn't fix it.
Confirm the album art is downloaded but not displayed the first time a track starts to play. Pausing the track and then starting it will display the downloaded artwork. Artwork is displayed on the second and subsequent plays.
Annoying as it all worked fine prior to my upgrade to Leopard.
-
Greg Hurrell
(In reply to comment #8)
Finding the same bug on an upgrade to Leopard. Updated to sysnergy 3.2 but that didn't fix it.
Confirm the album art is downloaded but not displayed the first time a track starts to play. Pausing the track and then starting it will display the downloaded artwork. Artwork is displayed on the second and subsequent plays.
Annoying as it all worked fine prior to my upgrade to Leopard.
Kevan, I suspect that what you're seeing is actually a different issue that is specific to Leopard. Check out bug #601:
Add a comment
Comments are now closed for this issue.


ActionProtocol
public protocol ActionProtocol
A protocol for Action
s for generic constraints and code reuse.
-
The type of the values output from the action.
Declaration
Swift
associatedtype Output
-
The type of the values used as inputs to the action.
Declaration
Swift
associatedtype Input
-
The type of errors emitted by the action.
Declaration
Swift
associatedtype Error : Error
-
The type of errors emitted when applying the action.
Declaration
Swift
associatedtype ApplyError : Error
-
Whether the action is currently executing.
Declaration
Swift
var isExecuting: Property<Bool> { get }
-
Whether the action is currently enabled.
Declaration
Swift
var isEnabled: Property<Bool> { get }
-
A signal of all values generated from all units of work of the
Action
.In other words, this sends every value from every unit of work that the
Action
executes.Declaration
Swift
var values: Signal<Output, NoError> { get }
-
A signal of all errors generated from all units of work of the
Action
.In other words, this sends every error from every unit of work that the
Action
executes.Declaration
Swift
var errors: Signal<Error, NoError> { get }
-
The lifetime of the
Action
.Declaration
Swift
var lifetime: Lifetime { get }
-
Create a
SignalProducer
that would attempt to create and start a unit of work of theAction
. TheSignalProducer
would forward only events generated by the unit of work it created.Declaration
Swift
func apply(_ input: Input) -> SignalProducer<Output, ApplyError>
Parameters
input
A value to be used to create the unit of work.
Return Value
A producer that forwards events generated by its started unit of work, or returns an appropriate
ApplyError
indicating the specific error that happened.
-
apply()
Extension methodCreate a
SignalProducer
that would attempt to create and start a unit of work of theAction
. TheSignalProducer
would forward only events generated by the unit of work it created.Declaration
Swift
public func apply() -> SignalProducer<Output, ApplyError>
Return Value
A producer that forwards events generated by its started unit of work, or returns an appropriate
ApplyError
indicating the specific error that happened.


Your answers will be shared with classmates. Feel free to answer only questions you are comfortable sharing with.


Dylan Best
Github
LinkedIn
Resume
About
Portfolio
(current)
Contact
Portfolio
Day Planner
+
Github
Weather Dashboard
+
Github
Note Taker
+
Github
Node Express Handlebars
+
Github
Work Bytes
+
Github
Outdoor Adventure Buddies
+
Github


|
New Tech Book Store® |
| |
|
Why buy from us?
* Over 4.5 million books Join the book club
* Get 10% discount Customer service
* All orders are executed in the least possible time. |


COURSE OUTLINE
1. World Civilization I (this course introduces the world history from dawn of civilization to the early modern era. topics in this course includes: European civilization, Asian civilization, African civilization, American civilizations, Greco-Roman civilization, Christian culture, Islamic culture, Traditional culture, Byzantine culture.)
2. World Civilization II (this course introducesnworld history from early modern era to the present. topics in this course includes: the cultures of Africa , cultures of Europe, cultures of India, cultures of China, cultures Japan, and cultures of America.)
3. Western Civilization I (this course introduces western civilization from pre-history to the early modern era. topics in this course includes : ancient Greece, Rome, and Christian Institutions of the Middle Ages and the emergence of national monarchies in western Europe.)
4. Western Civilization II (this course introduces western civilization from the early modern era to the present. topics in this course includes: the religious wars, the industrial revolution, World War I and II, and the Cold War.)
5. American History I (this course is a survey of American History from pre-history through the civil War era. topics in this course includes: the migrations to the Americas, the colonial and revolutionary periods, the development of the Republic, and the Civil War.)
6. American History II (this course survey the American history from the Civil War era to the present. topics in this course includes: industrilization in America, immigration of Americans, the Great Deppresion of America, the major American wars, the Cold War, and social conflict)
7. Hispanic Civilizatin (this course survey the cultural history of Spain and its impact on the New World. topics in this course includes: Spanish and Latin American culture, literature, religion and the arts.)


Sign In
Get Started
Contact
Home
Contact
Our Address
Toronto, Canada
Phone Number
+1<PHONE_NUMBER>
Send A Message
Leave A Comment
bike gps
Start a Consultation For Free
No payment required.
Get Started Now


Copyright Bruce Wilcox<EMAIL_ADDRESS>www.brilligunderstanding.com
Revision 2/18/2018 cs8.1
You can run an interactive debugger environment (IDE) if you have Windows. You launch it by going to BINARIES and double clicking on ChatScript IDE. It will load your bot, just as running ChatScript will. And you can type input into the input window and see output in the output window just like normal ChatScript. But you can do so much more…
You can set breakpoints on lines of code, be they actions in a macro, rules in a topic, or the topic itself. You can break on when CS will output a message to the user (to see where it comes from). You can break on change in value of a variable. You can single step in, over, out. You can display values of user, system, and match variables.
Before you can run the IDE you should compile your scripts under CS 8.0 or higher. You can actually do that from the IDE itself.
The IDE is a wrapper around the CS engine. Instead of launching
ChatScript.exe
from BINARIES you launch
ChatScriptIDE.exe
. This will load your project just as the
main engine does and then come to rest in the IDE, awaiting your
commands.
The script window displays your source file, information on the debugger commands, debugging commands (:xxx), IDE commands, and system variables (and important CS interchange variables).
Your script files will also be displayed when you request it (:i filename) or when some breakpoint requires it to show you where you are.
The script window has your code. To the left of that are line numbers from the file. And to the left of the line numbers are CS tag id’s of rules. IF you have a breakpoint set, you will see a B between the line number and your script. The entire area of of tags and line numbers is clickable to enable and disable a breakpoint at that line.
The window is also sensitive to having parts of your script clicked upon. If you click on a variable, be it $var, _var, %var, ^var, or @nvar, the current value will get added to the variables window and the value constantly displayed there. An @n variable shows the count of how many facts it has. You can remove an entry from the variables window by clicking on it.
Clicking on a function name will change the script window to display that function. The debugger will highlight where it is in blue. When you are executing your code and the debugger enters a breakpoint of some kind, the script window will show you where you currently are, displaying your script and highlighting in blue where you are. It will also put << to the left of rule tags/line numbers to indicate this is where you actually are. The callstack of where you are will be displayed in the stack window.
If you click on a rule label (like that in a ^reuse) then the system will take you to that label.
Clicking on a concept or topic name will change the script window to that’s definition.
The first line is a list of “windows” you can see. The first name in the list is always the current windows, and if you left-click on something else in that list, it is moved to first position and displayed.
If the bar gets too crowded, right-click on a name and the name is removed from the bar.
Above the file names title bar is text that shows you the current username and the current bot name and botid. `bob=>rose(0)
Left-click before a script line (in the number or tag area) and the system will establish a breakpoint (and put a B after the line number). If your code executes to that point, it will stop and give you control. Click again in the same area and the breakpoint is removed.
If you Right-click before a script line, the system create a transient breakpoint there and run code. The breakpoint will be removed when execution is stopped by some breakpoint (that one or a different one).
Here is where you type input for CS or for the IDE.
IDE input is prefixed with :i
. Naming a function or
variable or concept set is just like clicking on it in the script
window. It will put the variable in the variables window or display the
code in the script window. You can also name a rule label and code
display will jump to there. Not the full topic label, just what you put
as the label in u: MYLABEL () ...
, i.e., MYLABEL.
:i ~control
Above is the classic way to bring up the control script whereby you can then set a breakpoint. And if you type in a rule label as argument, it will take you to that label. Handy when you know where you want to debug in particular.
If the engine is currently running, you can give IDE commands but the IDE will refuse input for the engine.
Messages from the IDE as well as results or tracing from the engine are displayed here. While it is scrollable, if too much information is in the buffer it will truncate the older output.
When you are in the IDE at a breakpoint, this shows you the calling
hierarchy of where you are. Each scope is numbered (low is deepest, high
is most recent). The possible scopes are a topic, a rule, a function, an
if, or a while. Scopes that have output actions (rules, if, while,
function), will display that you are at that scope by displaying it with
()
. You cannot walk in and execute code within a pattern or
an if test or a loop count evaluation, so when the scope is within
executable output, it will display it with {n}
, where
n
is the internal code offset of where you are, and it will
show you the upcoming code it is about to execute. There is also
lvl:n
data, which is internal data about what recursive
level the output interpreter is at (mostly irrelevant to you).
If you click on one of these scope lines, the system will display the
code of that scope in the script window and any local variables ($_xxx
and ^xxx) in the variables window. It will have a title of
local variables
.
This window shows current values of global variables you have
requested (updated whenever you end up in the IDE). If you clicked on a
scope line, it shows the values of local variables for that scope. You
can flip back to viewing globals by pressing the globals
button.
When variables are displayed, after the variable it tells you how many characters the value has.
If you click to the left of a global variable, it will set a breakpoint for when the value of that variable changes and will put a B before it. Click again in that area and it removes the breakpoint. You can request a break when the value becomes =, <, or > some value using
:i varname = test
:i varname > 5 -- integer values only
:i varname < 5 -- integer values only
You can also use various engine debug commands while at a break,
including :trace
and :word
. Just dont try to
use things that have massive impact, like
:document, :source, :reset, :bot, :user, :restart
At the bottom of the main window the system prints out useful statistics about resource usage. It shows you how much of a resource is currently in use, and what the least amount available has ever been seen.
‘Memory’ is the available space for stack + heap. If this gets down toward 10M, you might want to allocate more text space to the program.
‘Buffer’ is how many preallocated large buffers (typically 80K) are in use. If it gets to be <10, you might want to allocate more.
DICT
is how many dictionary entries are available. Less
than 5K probably indicates you want to allocate more.
FACT
is how many facts are available to be created. Less
than 5K probably indicates you want to allocate more.
The window above the script window tells you information about the
current user input. By default it shows you the adjusted
input, what the tokenizer and various NLP corrections have been made to
result in the input the system is actually processing at present.
L-click anywhere in the sentence box and it changes to show you the
raw
input, what the user provided (after tokenization).
L-click again and it shows you the canonical
form of the
input.
L-click again and it returns to the adjusted
form of the
input.
If you R-click on a word, it will show you the concepts it is involved in in the output window.
Resume execution until complete or a new breakpoint is hit.
Try to go in deeper into the current thing. For a topic that will be its first rule. For a rule, if the pattern matches, it will be the output of it. For a function it will be the code of the function.
If the system cannot go in, it will stop at the next available opportunity. Ie., the next action, rule, pass out of the function or topic.
Leave the current level of behavior and stop as soon thereafter. For a topic, it leaves the topic, for a rule it leaves the topic. If within actions of a rule, it leaves that rule. For a function it leaves that function.
Stay at the current level of behavior. If at a topic, move on to the next topic (having executed all its rules). If a rule, move on to the next rule (possibly having executed all its actions). If a function, step over the function (executing all its actions) and return to caller. If withing actions of a function then execute the current action and move to the next one. If inside a rule, do the current action and move to the next.
If the engine is currently executing script, stop that execution as soon as possible and enter the IDE. Otherwise note that you want to stop, so that on the next user input the IDE takes control immediately.
Breakpoint when the system wants to print output to the user. This is useful to see why you are getting the output you get.
Breakpoint if any system function return a failure code. These typically suggest you passed it bad arguments. With this, you can see when this happens.
Cntrl-lclick tells the debugger to terminate current input and return to top level.
L-click removes all breakpoints currently set (not including variable breaks). R-click temporarily disables all breakpoints set (including variable breaks and msg break and fail break). R-click again to re-enable.
Restore variable window to showing global variables if it is currently showing locals of some callframe.
As you move from location to location in the stack window, you create
a breadcrumb trail, and Back
will take you back from where
you were. If you need to rapidly return to where you are currently
executing code, just click on the last callframe in the stack
window.
Changes the font size. Left click for smaller. Right click for bigger.