Subject: Summer Meeting
Hello Team!
We hope that you are all enjoying your summer. However, it's
time to have our first summer meeting!
This Wednesday, August 14th we will have a meeting at OFS
from 7pm- 9pm. We will be unloading the trailer of the items
and robots we brought to our recent community events. The team will also
discuss the upcoming off-season.
This message was sent by the ÜberBots mass email system. If you are receiving this message in error, please email<EMAIL_ADDRESS>If you wish to remove yourself from the list manually, follow the instructions here. If you have other questions or comments, please email the webmaster.
Please do not reply to this message.


Published as-is. Metadata can be parsed from a comment at the start of a file.
Apple.html
Banana.html
Cherry.html
You can make Blot ignore a file if you start its name with an underscore..
You can use a comment at the start of an HTML file to specify metadata.
The comment containing metadata in an HTML file
must start on the file's first line.
Blot will serve an HTML file with the following path:
/files/_post.html
At the following URL
/files/posts


Even in hard cases it's not usually too hard
Somtimes the graph is disconnected
There aren't usually very many nodes
Branch-and-bound techniques work just fine


Landing Page
Special Projects
This story is part of a series of specially designed stories that represents some of the best journalism The Post has to offer. Check out the rest of the special projects here.
TAYLOR JOHNSTON
05.25.17
Whether it’s an Ohio or an NFL game, Athens offers a variety of places where you can go to watch whatever game you want to — even if you left Peden Stadium at halftime.
Here are the best places to catch games in Athens.
Blake Nissen | FILE
Nate Wheeland, a Junior studying Political Science, rubs his eyes while watching the World Series Game 7 in Lucky’s. The Indians lost the 2016 World Series to the Cubs 4-3.
The original big-game hangout spot. Whether your team is in California or you're a fan of the local team, Buffalo Wild Wings has NFL Sunday Ticket, so you'll be able to watch any NFL game. Located at the top of Union Street and just across the street from Bromley Hall, the restaurant is easily accessible. Also, watching Thursday Night Football is always an option due to Buffalo Wild Wings’ “Boneless Wing Night.”
Red Brick is a small tavern on Court Street, but it can be a great time during sporting events. It is a “Browns bar,” so if you are a Browns fan, Red Brick is always an option to watch your team. Even if you aren't a Browns fan, the crowd in Red Brick tends to be younger, so finding friends while watching sports is easy.
Located near the end of Court Street, Courtside Pizza allows customers to enjoy a slice of pizza and grab a booth in front of the massive TVs behind the bar. During halftime, you can step outside onto the patio and relax.
If there’s a game that takes place on a Wednesday, you’re in luck. Wednesday is “Slice Night,” and Courtside has 50-cent slices of cheese pizza.
Don't feel like going out for the game? No worries. Just invite some friends over, order Avalanche Pizza, Wings Over Athens or DP Dough and relax while enjoying the game. You can't go wrong with just staying in.
Back to The Orientation GuideLanding Page
This story is part of a series of specially designed stories that represents some of the best journalism The Post has to offer. Check out the rest of the special projects here.


---- Order {{ name }} cancelled ---- {{ 'logo.png' | asset_url | img_tag }} % if billing_address.name %}
Dear {{ billing_address.name }},
{% endif %}Your order {{ name }} was cancelled {% case cancel_reason %}{% when 'customer' %}at your request.{% when 'inventory' %}because we did not have enough stock to fulfill your order.{% when 'fraud' %}because we suspect it is fraudulent.{% when 'other' %}due to unforseen circumstances.{% endcase %}
{% if financial_status == 'voided' %}Your payment has been voided.{% elsif financial_status == 'credited' %}Your payment has been refunded.{% endif %}
Please reply to this email if you have any questions or concerns.
Sincerely,
{{shop_name}}


Defense, Gardner, Blue star in Temple’s 17-7 victory
TAMPA, Fla. (AP) - Sam Franklin scooped up a fumble and returned it 39 yards for Temple’s second touchdown and the Owls went on to a 17-7 victory over South Florida on Thursday night.
Christian Braswell punched the ball out of the grasp of receiver Terrence Horne and Franklin grabbed it and raced down the left sideline for a 14-0 lead in the third quarter.
Jager Gardner rushed for a career-high 133 yards on 25 carries, including a 57-yarder, while Jadan Blue caught 11 passes for 121 yards for the Owls. Quincy Roche led the defense with 3½ of the Owls’ nine sacks.
Kenny Yeboah took a 1-yard pass from Todd Centeio with 1½ minutes left in the first half to complete a nine-play, 80-yard drive for the Owls (6-3, 3-2), who snapped a tie for third place with USF (4-5, 2-3) in the American Athletic Conference’s East Division.
Jordan McCloud threw a 14-yard TD pass to Bryce Miller late in the third quarter for the Bulls’ lone score before Owls kicker Will Mobley booted a career-tying 44-yard field goal early in the fourth quarter.
Sign up for Daily Newsletters
Copyright © 2019 The Washington Times, LLC.
Please read our comment policy before commenting.


They said what?! Pros react to Jan Blachowicz’s win over Ronaldo Souza at UFC Sao Paulo
by Lucas RezendeIn a close and not so thrilling bout, Jan Blachowicz managed to stuff Ronaldo Souza’s takedowns and outstruck his opponent en route to a split decision victory at UFC Sao Paulo. On Twitter, pro fighters reacted to this snoozer of a fight.


Menu
Click the left side. Then, you can control the character.
Click the right side. Then, you can control the camera.
Maze's Size
33 x 25
15 x 11
25 x 21
35 x 31
45 x 41
55 x 51
65 x 61
75 x 71
85 x 81
95 x 91
Walk Speed
Slow
Medium
Fast
Game Start
Start Game
All Reset


- NetworkUtils - Class in com.cmput301f20t14.bookbox
-
This class contains handles making the POST request to the google books
library to retrieve the book information from a given ISBN
- NetworkUtils() - Constructor for class com.cmput301f20t14.bookbox.NetworkUtils
-
- newEmailText - Variable in class com.cmput301f20t14.bookbox.fragments.UpdateEmailFragment
-
- newInstance(String) - Static method in class com.cmput301f20t14.bookbox.fragments.AcceptedFragment
-
- newInstance(String) - Static method in class com.cmput301f20t14.bookbox.fragments.BorrowedFragment
-
- newInstance(Image) - Static method in class com.cmput301f20t14.bookbox.fragments.ImageFragment
-
Creates a new instance the takes an image from the attached
activity an bundles it to be used later for the imageView.
- newInstance(Image, boolean) - Static method in class com.cmput301f20t14.bookbox.fragments.ImageFragment
-
Creates a new instance that takes an image from the attached activity
and bundles it to be used later for the imageView.
- newInstance(String) - Static method in class com.cmput301f20t14.bookbox.fragments.OutRequestFragment
-
- newInstance(User) - Static method in class com.cmput301f20t14.bookbox.fragments.ProfileFragment
-
Creates a new instance the takes an user from the attached
activity an bundles it to be used later for the profile view.
- newPassword - Variable in class com.cmput301f20t14.bookbox.fragments.UpdatePasswordFragment
-
- newPhoneText - Variable in class com.cmput301f20t14.bookbox.fragments.UpdatePhoneFragment
-
- Notification - Class in com.cmput301f20t14.bookbox.entities
-
This class represents a notification object
- Notification(String, Book, String, String, String) - Constructor for class com.cmput301f20t14.bookbox.entities.Notification
-
Constructor of the Notification class
- notificationIDHash - Variable in class com.cmput301f20t14.bookbox.activities.NotificationsActivity
-
- NotificationList - Class in com.cmput301f20t14.bookbox.adapters
-
ArrayAdapter subclass used to represent a Notification object in
a list with layout as in notification_content.xml
- NotificationList(Context, ArrayList<Notification>) - Constructor for class com.cmput301f20t14.bookbox.adapters.NotificationList
-
- notificationNumber - Variable in class com.cmput301f20t14.bookbox.activities.NotificationsActivity
-
- notifications - Variable in class com.cmput301f20t14.bookbox.activities.NotificationsActivity
-
- notifications - Variable in class com.cmput301f20t14.bookbox.adapters.NotificationList
-
- NOTIFICATIONS - Static variable in class com.cmput301f20t14.bookbox.entities.Notification
-
- NotificationsActivity - Class in com.cmput301f20t14.bookbox.activities
-
This is the activity where the user can view their
notifications that they receive.
- NotificationsActivity() - Constructor for class com.cmput301f20t14.bookbox.activities.NotificationsActivity
-
- NotificationsActivityTest - Class in com.cmput301f20t14.bookbox
-
- NotificationsActivityTest() - Constructor for class com.cmput301f20t14.bookbox.NotificationsActivityTest
-


{% extends "layout.html" %} {% block content %}
Lets Play.
Benny B
Contributing Partner
About Me: Avid Patriots fan, playing guitar in my off time.
Discord: Benny B#9182
AJ Stein
Contributing Partner
About Me: OU CS student, working towards developing video games.
Discord: Color#6812
Hunter Burden
Contributing Partner
About Me: OU CS student who loves DnD and Video Games
Discord: HunterBurden#8770
Alex S
Contributing Partner
About Me: Codes nonstop
Discord: Alshaun#1859


HomoGraphy2d Class
This kernel calculates perspective transform between point sets. Result is 3x3 Matrix
// create homography kernel
// you can reuse it for different point sets
var homo_kernel = new HomoGraphy2d();
var homo_transform = new Matrix_t(3, 3, jsfeat.F32_t | jsfeat.C1_t);
var count = 33;
var from = [];
var to = [];
for(var i = 0; i < count; ++i) {
// you can use keypoint_t structure
// or just provide object with x and y properties
from[i] = { "x":Math.random()*320, "y":Math.random()*240 };
to[i] = { "x":from[i].x + 5, "y":from[i].y+5 };
}
homo_kernel.run(from, to, homo_transform, count);
// you can also calculate transform error for each point
var error = new Matrix_t(count, 1, F32_t | C1_t);
homo_kernel.error(from, to, homo_transform, error.data, count);
Constructor
HomoGraphy2d
()
Item Index
Methods
- check_subset deprecated
- checkSubset
- error
- run


Returns an array with only the unique values from the first array, by excluding all values from additional arrays using strict equality for comparisons.
Install with npm
$ npm i arr-diff --save
Install with bower
$ bower install arr-diff --save
Return the difference between the first array and additional arrays.
Params
a
{Array}b
{Array}returns
{Array}Example
var diff = require('arr-diff');
var a = ['a', 'b', 'c', 'd'];
var b = ['b', 'c'];
console.log(diff(a, b))
//=> ['a', 'd']
Install dev dependencies:
$ npm i -d && npm test
Pull requests and stars are always welcome. For bugs and feature requests, please create an issue.
Jon Schlinkert
Copyright © 2015 Jon Schlinkert Released under the MIT license.
This file was generated by verb on Sat Dec 05 2015 23:24:53 GMT-0500 (EST).


{{ search_num_results }} page(s) found for "{{ search_term }}"
{{ page.description }}
{{ page.date }} by {{ page.author }}


We know that coding bootcamp is too expensive, so we born for train people who want to dive into coding bootcamp, because we don't want to see people getting fail in coding bootcamp like us. After you graduated from this online coding bootcamp, we hope you guys can have a lot of knowledge to dive more deeper in programming, let's grow up together!


This document provides instructions for integrating Openfire authentication, users, and groups with your custom database tables. This is useful when your users already have accounts in an external system and you do not wish to duplicate those accounts in Openfire. If your user information is available via an LDAP directory rather than custom database tables, see the LDAP guide.
Simple integration with a custom database lets users authenticate using their existing username and password. Optionally, you can configure Openfire to load user profile and group information from your custom database. Any group in Openfire can be designated as a shared group, which means that you can pre-populate user's rosters using groups.
The integration requires that you enter customized database queries to access your database. You'll need to be familiar with your database table structure and simple SQL. Your custom database can be a different database on a different server from the Openfire database -- you'll enter database connection information as part of the configuration.
In order to configure your server to integrate with your custom database tables:
You must specify the connection string for your database as well as the JDBC driver.
Below is a sample config file section (note: the "..." sections in the examples indicate areas where the rest of the config file would exist):
<jive> ... <jdbcProvider> <driver>com.mysql.jdbc.Driver</driver> <connectionString>jdbc:mysql://localhost/dbname?user=username&password=secret</connectionString> </jdbcProvider> ... </jive>
The simplest possible integration with a custom external database is authentication integration. Use the following settings to enable authentication integration.
Below is a sample config file section:
<jive> ... <provider> <auth> <className>org.jivesoftware.openfire.auth.JDBCAuthProvider</className> </auth> </provider> <jdbcAuthProvider> <passwordSQL>SELECT password FROM user_account WHERE username=?</passwordSQL> <passwordType>plain</passwordType> </jdbcAuthProvider> ... </jive>
You'll most likely want to change which usernames are authorized to login to the admin console. By default, only the user with username "admin" is allowed to login. However, you may have different users in your LDAP directory that you'd like to be administrators. The list of authorized usernames is controlled via the admin.authorizedUsernames property. For example, to let the usersnames "joe" and "jane" login to the admin console:
<jive> ... <admin> ... <authorizedUsernames>joe, jane</authorizedUsernames> </admin> ... </jive>
Another option is to use an AdminProvider. AdminProvider instances are responsible for listing the administrators users dynamically. The default use the authorizedUsernames setting previously explained. JDBCAdminProvider allows to list the administrators from a SQL query. For example:
<jive> ... <provider> ... <admin> <className>org.jivesoftware.openfire.admin.JDBCAdminProvider</className> </admin> ... </provider> <jdbcAdminProvider> <getAdminsSQL>SELECT userid FROM user_account WHERE administrator='Y'</getAdminsSQL> </jdbcAdminProvider> ... </jive>
Optionally, Openfire can load user data from your custom database. If you enable user integration you must also enable authentication integration (see above). Use the following settings to enable user integration.
Below is a sample config file section. Note that the single provider section must include all providers that should be configured:
<jive> ... <provider> <auth> <className>org.jivesoftware.openfire.auth.JDBCAuthProvider</className> </auth> <user> <className>org.jivesoftware.openfire.user.JDBCUserProvider</className> </user> </provider> <jdbcAuthProvider> <passwordSQL>SELECT password FROM user_account WHERE username=?</passwordSQL> <passwordType>plain</passwordType> </jdbcAuthProvider> <jdbcUserProvider> <loadUserSQL>SELECT name,email FROM myUser WHERE username=?</loadUserSQL> <userCountSQL>SELECT COUNT(*) FROM myUser</userCountSQL> <allUsersSQL>SELECT username FROM myUser</allUsersSQL> <searchSQL>SELECT username FROM myUser WHERE</searchSQL> <usernameField>username</usernameField> <nameField>name</nameField> <emailField>email</emailField> </jdbcUserProvider> ... </jive>
Openfire can load group data from your custom database. If you enable group integration you must also enable authentication integration; you'll also likely want to enable user integration (see above). Use the following settings to enable group integration.
Below is a sample config file section.  AND isAdmin='N'</loadMembersSQL> <loadAdminsSQL>SELECT username FROM myGroupUsers WHERE groupName=? AND isAdmin='Y'</loadAdminsSQL> </jdbcGroupProvider> ... </jive>


I chose to take programming because i really love technology therefore i really just want to have a deeper understanding of what a computer is especially the software part..yea..


${'Number of resources to be changed' | t}: ${totalCount}
${'Predicted execution time' | t}: ${predictedTime} min
${'Selected change type' | t}: ${action | t}
${'Selected metadata' | t}: ${metadata.label | inCurrentLanguage} (${metadata.name}, ID: ${metadata.id})
${'Selected template' | t}:
${change.displayStrategy}
${'Metadata value change preview' | t}:
| Id | ${'Label' | t} | ${metadata.label | inCurrentLanguage} ${'before the change' | t} | ${metadata.label | inCurrentLanguage} ${'after the change' | t} |
|---|---|---|---|
| ${resource.id} | ${resource | resourceLabel} |
|
|
${'Target place' | t}: ${'Selected transition' | t}: ${ transitionOrPlaceLabel | inCurrentLanguage }
${'Current place change preview' | t}:
| Id | ${'Label' | t} | ${'Current place before change' | t} | ${'Current place after change' | t} |
|---|---|---|---|
| ${resource.id} | ${resource | resourceLabel} |
|
|


{% extends 'shared/base.html' %} {% block title %}utf9k{% endblock %} {% block nav %}utf9k{% endblock %} {% block blog %}[ blog ]{% endblock %} {% block content %}
No blog posts
Nothing has been written anything yet!


Imental
Care for you
Home
Questionnaire
Chatbot
Materials
Personal Center
Hello!     {{ tag }}
Questionnaire Result
Suggested reading
https://en.wikipedia.org/wiki/{{ tag3 }}
Talk with chatbot


|
OPAE C API
-..
FPGA API
|
#include <iostream>
#include <string>
#include <sstream>
#include <exception>
#include <glob.h>
#include <time.h>
#include "afu_test.h"
Go to the source code of this file.
Data Structures | |
| class | hssi_afu |
Macros | |
| #define | ETH_AFU_DFH 0x0000 |
| #define | ETH_AFU_ID_L 0x0008 |
| #define | ETH_AFU_ID_H 0x0010 |
| #define | TRAFFIC_CTRL_CMD 0x0030 |
| #define | TRAFFIC_CTRL_DATA 0x0038 |
| #define | TRAFFIC_CTRL_PORT_SEL 0x0040 |
| #define | AFU_SCRATCHPAD 0x0048 |
| #define | READ_CMD 0x00000001ULL |
| #define | WRITE_CMD 0x00000002ULL |
| #define | ACK_TRANS 0x00000004ULL |
| #define | AFU_CMD_SHIFT 32 |
| #define | WRITE_DATA_SHIFT 32 |
| #define | NO_TIMEOUT 0xffffffffffffffffULL |
Typedefs | |
| using | test_afu = opae::afu_test::afu |
| #define ETH_AFU_DFH 0x0000 |
Definition at line 38 of file hssi_afu.h.
| #define ETH_AFU_ID_L 0x0008 |
Definition at line 39 of file hssi_afu.h.
| #define ETH_AFU_ID_H 0x0010 |
Definition at line 40 of file hssi_afu.h.
| #define TRAFFIC_CTRL_CMD 0x0030 |
Definition at line 41 of file hssi_afu.h.
| #define TRAFFIC_CTRL_DATA 0x0038 |
Definition at line 42 of file hssi_afu.h.
| #define TRAFFIC_CTRL_PORT_SEL 0x0040 |
Definition at line 43 of file hssi_afu.h.
| #define AFU_SCRATCHPAD 0x0048 |
Definition at line 44 of file hssi_afu.h.
| #define READ_CMD 0x00000001ULL |
Definition at line 46 of file hssi_afu.h.
| #define WRITE_CMD 0x00000002ULL |
Definition at line 47 of file hssi_afu.h.
| #define ACK_TRANS 0x00000004ULL |
Definition at line 48 of file hssi_afu.h.
| #define AFU_CMD_SHIFT 32 |
Definition at line 49 of file hssi_afu.h.
| #define WRITE_DATA_SHIFT 32 |
Definition at line 50 of file hssi_afu.h.
| #define NO_TIMEOUT 0xffffffffffffffffULL |
Definition at line 52 of file hssi_afu.h.
| using test_afu = opae::afu_test::afu |
Definition at line 35 of file hssi_afu.h.


|
||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
See:
Description
| Interface Summary | |
| ByteChunk.ByteInputChannel | |
| ByteChunk.ByteOutputChannel | |
| CharChunk.CharInputChannel | |
| CharChunk.CharOutputChannel | When we need more space we'll either grow the buffer ( up to the limit ) or send it to a channel. |
| Class Summary | |
| Ascii | This class implements some basic ASCII character handling functions. |
| B2CConverter | Efficient conversion of bytes to character . |
| Base64 | This class provides encode/decode for RFC 2045 Base64 as defined by RFC 2045, N. |
| ByteChunk | This class is used to represent a chunk of bytes, and utilities to manipulate byte[]. |
| C2BConverter | Efficient conversion of character to bytes. |
| CharChunk | Utilities to manipluate char chunks. |
| DateTool | Deprecated. Will be replaced with a more efficient impl, based on FastDateFormat, with an API using less objects. |
| HexUtils | Library of utility methods useful in dealing with converting byte arrays to and from strings of hexadecimal digits. |
| MessageBytes | This class is used to represent a subarray of bytes in an HTTP message. |
| MessageBytes.MessageBytesFactory | |
| TimeStamp | Main tool for object expiry. |
| UDecoder | All URL decoding happens here. |
| UEncoder | Efficient implementation for encoders. |
| UTF8Decoder | Moved from ByteChunk - code to convert from UTF8 bytes to chars. |
Encoding is a critical operation for performance. There are few tricks in this package - the C2B and B2C converters are caching a ISReader/OSWriter and keep everything allocated to do the conversions in any VM without any garbage.
This package must accomodate future extensions and additional converters ( most imporant: the nio.charset, which should be detected and used if available ). Also, we do have one hand-written UTF8Decoder, and other tuned encoders could be added.
My benchmarks ( I'm costin :-) show only small differences between C2B, B2C and hand-written codders/decoders, so UTF8Decoder may be disabled.
|
||||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


This section describes the flow a node will follow during its entire lifetime.
When they join the network, they won't yet be a member of any section.
First,they will have to bootstrap with their proxy node, receive a RelocateInfo and attempt to join the
section that this RelocateInfo is pointing to.
Once they have a full section, they will be able to operate as a full section member.
OWN_SECTION refers to this node's own section.
It is an Option<Prefix>.
While a node is being relocated, the value will be none. Once they get accepted into a section, it
becomes Some(that_section_s_prefix)
This function gets called when a node just joined the Network.
At this stage, we are connected to a proxy node and they indicate to us which section we should join.
Once a node has joined a section (indicated by OWN_SECTION.is_some()), they will be able to perform as a
member of that section until they are relocated away from it.
See StartSectionMemberNode graph for details.
First Create new identity with public key-pair
The node connects to a proxy with the new identity to use for joining the new section as a full node.
Once a node knows where to be relocated, they will follow this flow to become a full member of the
section.
This covers resource proof from the point of view of the node being resource-proofed.
The output of this function is an Option. If we fail resource proof, it is none, which means we will
have to bootstrap again. If it is Some, it contains the RelocateInfo we need to join this section.
See JoiningRelocateCandidate graph for details.
This is from the point of view of a node trying to join a section as a full member.
This node is going to connect, send Rpc::CandidateInfo, and then perform the resource proof until it receives a Rpc::NodeApproval to complete this stage
successfully.
If the node is not accepted, after time out, it will try another section as a new node.
Timeout triggered to resend messages that have not been replied to:
Either Rpc::ConnectionInfoRequest or Rpc::CandidateInfo
Timeout to stop trying to resource proof if so much time has elapsed that we will not be able to succeed.
Return the next part of the resource proof for the given elder.
inputs:
- elder name
Return connected nodes and unconnected nodes in the given collection.
inputs:
- elder names
Return true if we already received Rpc::ResourceProof for that node.
inputs:
- elder name
The RelocatedInfo given to the routine and used to send CandidateInfo
Once a node has joined a section, they need to be ready to take on multiple roles simultaneously:
Deal with relocation:
The section as a whole will sometimes act as the source and sometimes as the destination of
relocations. This means nodes will sometimes relocate away from this section and sometimes relocate
to this section. Nodes in this section will need to perform the right flow to deal with both of
these situations.
Decide who's an elder or a plain old adult as well as when to merge or split.
Decide who is online and offline.
All of these flows are happening simultaneously, but they share a common event loop. At any time, either all
flows or all but one flows must be in a "wait" state. (If an event is handled by multiple active event
loops, the one with the highest number handles it.)
If our section decides to relocates us, we will have to stop functioning as a member of our section and go
back to the previous flow where we will "Rebootstrap" so we can become a member of a different section.
As a member of a section, our section will sometimes receive a node that is being relocated. These diagrams
are from the point of view of one of the nodes in the section, doing its part to handle the node that is
trying to relocate to this section.
Deciding when to accept an incoming relocation
This flow represents what we do when a section contacts us to relocate one of their nodes to our
section.
The process starts as we receive an Rpc::ExpectCandidate from this node.
We vote for it in PARSEC to be sure all members of the section process it in the same order.
Once it reaches consensus, we are ready to process that candidate by letting them connect (see
StartRelocatedNodeConnection) and then perform the resource_proof (see StartResourceProof).
There are some subtleties, such as the fact that we only want to process one candidate at a time, but this
is the general idea.
We receive this RPC from a section that wants to relocate a node to our section.
The node is not communicating with us yet, only once we sent Rpc::ExpectCandidateAcceptResponse to the
originating section.
On receiving it, we vote for Parsec::ExpectCandidate to process it in the same order as other members of
our section.
It kickstarts the entire chain of events in this diagram.
Note that we could also see consensus on Parsec::ExpectCandidate before we ourselves voted for it in
PARSEC, as long as enough members of our section did.
We want to accept at most one incoming relocation at a time into our section.
The count_waiting_proofing_or_hop function returns the count of nodes that we have yet to resource proof
or relocate through a new hop, (States from State::WaitingCandidateInfo until it reaches State::Online
or State::Relocated).
When the output of this function is not 0 and we reach consensus on Parsec::ExpectCandidate, we send a
Rpc::ExpectCandidateRefuseResponse to the would-be-incoming-node so they can try another section or try
again later.
If we already accepted a candidate, reply with the same info we provided intially and returned by
get_waiting_candidate_info.
If we know of a section that has a shorter prefix than ours, we prefer for them to receive this incoming
node rather than ourselves as it will help keep the Network's sections tree balanced.
This shorter_prefix_section is a function that will return None if we are the shortest of any section we
know, Some if there is a better candidate.
If it is Some, we will relocate the new node to them instead of completing the relocation to our own
section.
send_rpc( Rpc::ExpectCandidateAcceptResponse) to
source section"]
SendExpectCandidateAcceptResponse --> LoopEnd
SendRefuse["send_rpc( Rpc::ExpectCandidateRefuseResponse) to source section"]
SendRefuse --> LoopEnd
Resource proof from a destination's point of view
Manage node with NodeState=State::WaitingCandidateInfo.
When we periodically decide to resource proof a node, we check if any node is ready for it:
State::WaitingCandidateInfo state.
Once the candidate is connected, it sends its CandidateInfo to each Elders it was given in RelocatedInfo.
As an elder, I will send the candidate a Rpc::ResourceProof. This gives them the "problem to solve". As they
solve it, they will send me ResourceProofResponses. These will be parts of the proof. On receiving valid
parts, I must send a ResourceProofReceipt. Once they finally send me the last valid part, they passed their
resource proof and I vote for Parsec::Online (essentially accepting them as a member of my section).
At any time during this process, they may timeout (The whole process it taking longer than expected), in
which case I will decided to reject them and vote for Parsec::PurgeCandidate.
This process ends once I reach consensus on either accepting the candidate (Parsec::Online) or refusing them
(Parsec::PurgeCandidate).
It is possible that both reach the quorum consensus, in which case the second one will be discarded. It
won't cause issues as consistency is the only property that matters here: if we accept someone who then went
Offline, we will be able to detect they are Offline later with the standard Offline detection mechanism. But
it is more likely that they took close to the time limit to complete their proof.
Return true if
The given CandidateInfo is valid,
It matches one of our nodes that is in the State::WaitingCandidateInfo state,
The message_src (from the current RPC) is consistent with the CandidateInfo's new_public_id
Return a candidate ready to be resource proofed (First node in State::WaitingCandidateInfo state)
Convert the candidate node at the target interval address to a node using the new_public_id.
Update the state of the node with the given state.
Option<(Candidate)>.
The candidate we are currently resource proofing old_public_id, if any.
Once we've voted a node online, we don't care to handle further ResourceProofResponses from them.
This local variable helps us with this.
The candidate sends this RPC that contains part of a proof. It may continue to be sent by a node we have
not accepted, even if consensus was reached to add it.
It may also still be sent by a candidate we have rejected. It's OK to discard the RPC in these cases as
it is no longer relevant.
The same node could be accepted by some nodes who would vote Parsec::Online, but also time out for some
other nodes who would vote for Parsec::PurgeCandidate.
If it's the case, we only want to process the first of these two events and discard the other one.
Provides an external entry point to cancel the currently processed nodes: Restart the resource proofing
with all involved voters.
This will be called for example after merge/split as the new nodes would become voters.
send_rpc( Rpc::ResourceProof) to CANDIDATE_INFO.new_public_id"]
RequestRP --> LoopEnd
RPC -- Rpc::ResourceProofResponse from CANDIDATE_INFO --> ProofResponse((Proof))
ProofResponse((Check))
SendProofReceipt["send_rpc( Rpc::ResourceProofReceipt) for proof"]
ProofResponse -- "Valid Part or End otherwise" --> SendProofReceipt
VoteParsecOnline["vote_for( Parsec::Online)
As members of a section, each node must keep track of how many "work units" other nodes have performed.
Once a node has accumulated enough work units to gain age, the section must work together to relocate that
node to a new section where they can become 1 age unit older.
These diagrams detail how this happens.
Deciding that a member of our section should be relocated away
In these diagrams, we are modelling the simple version of node ageing that we decided to implement for
Fleming: Work units are incremented for all nodes in the section every time a timeout reaches
consensus.
Because a quorum of elders must have voted for this timeout, the malicious nodes can't arbitrarily speed up
the ageing of their nodes.
Once a node has accumulated enough work units to be relocated, if no other node is currently in
State::RelocatingAgeIncrease we set its state to State::RelocatingAgeIncrease. This node will then be
actually relocated in StartRelocateSrc (see StartRelocateSrc).
Because of this, we will generally only relocate one adult at a time (except in case of merge).
In the context of Fleming, nodes (especially adults) aren't doing meaningful work such as handling
data.
As a proxy, we use a time based metric to estimate how much work nodes have done (i.e: how long they
remained in State::Online and responsive).
A local timeout wouldn't do here as it would allow malicious nodes to artificially age nodes in their
sections faster. However, by reaching quorum on the fact a timeout happened, we ensure that at least one
honest node has voted for the timeout.
All nodes start the WorkUnitTimeout. On expiry, they vote for a WorkUnitIncrement in PARSEC and restart
the timer.
This function increments the number of work units for all members of my peer_list (remember that
n_work_units is a member of the PeerState struct).
Returns true if we have any node currently relocating: With node state State::RelocatingAgeIncrease
only.
There will most often be zero or one such nodes, unless a merge occurs in which case there may be
multiple.
Nodes coming back online, or needing an extra hop are not considered here.
This function will return the best candidate for relocation, if any.
First, it will only consider members of our peer_list that have the state: State::Online
We use the condition with has_relocating_node() to limit the number of State::Online nodes to relocate
to one (except possibly in case of a merge).
It can return for instance the node with the largest number of work units for which the number of work
units is greater than 2^age.
This function mutates our peer_list to set the state (for example set State::RelocatingAgeIncrease for
the node).
inputs:
- node
- state
side-effect:
- mutates peer_list
At this stage, we handle nodes that were marked for relocation.

Or that section will send us a Rpc::ExpectCandidateRefuseResponse, then we will retry later.
Or that RPC or the response is lost, then we will retry later.
When we receive Rpc::ExpectCandidateAcceptResponse or Rpc::ExpectCandidateRefuseResponse, we vote for it in
PARSEC, regardless of the order of operations, so it will be consensused.
The first Parsec::ExpectCandidateAcceptResponse consensused for a node will be the single valid relocation.
We will sign the relocation info through parsec and send to the node that is being relocated the
RelocatedInfo they will need.
At this point, we will purge their information since this node isn't a member of our section any more.
Elders are not considered for relocation: Elder nodes in State::RelocatingAgeIncrease will eventually get
demoted to adults (see StartMergeSplitAndChangeElders) at which point they may be relocated.
We prioritise relocating our Adults, then just relocated nodes that need another hop, then nodes coming back
online.
Also of note: We may be relocating multiple nodes (i.e because of merge, or node relocating to us or node
coming back online), but we will only handle one at a time per CheckRelocateTimeOut event.
Throttling is otherwise handled in flows setting the relocating states.
Takes ALREADY_RELOCATING for the nodes it will ignore.
Returns the best node to relocate and the target address to send it to
There may be multiple nodes relocating, for example because of a merge. Take the best one (oldest), and
choose a target address.
The target address is one managed by one of our neighbours. This could be random, or the current
old_public_id with a single bit of the prefix flipped.
This would help ensure that source and destination remain neighbours, even if the source splits.
Using a target address instead of a section ensures we deliver the message even if the destination
splits or merges.
There are 3 states the node may be: State::RelocatingAgeIncrease, State::RelocatingHop, and
State::RelocatingBackOnline.
Nodes will be selected in this order: State::RelocatingAgeIncrease, State::RelocatingHop and then
State::RelocatingBackOnline and tie break by age then name.
This ensures that we prioritise good node relocation.
Note: It may be possible for a node to relocate to its sibling, and complete relocation after a merge
occurred.
The nodes we ignore when selecting a new node to send Rpc::ExpectCandidate for.
Local states are not carried over on merge or split, so we will resend Rpc::ExpectCandidate earlier than
we would otherwise.
Is it a valid node that is not yet relocated (i.e State is State::RelocatingAgeIncrease,
State::RelocatingHop or State::RelocatingBackOnline).
Exactly one of these RPCs will be sent to us from the destination section as a response to our section's
Rpc::ExpectCandidate.
When this happens, we will immediately vote for it in PARSEC as we need to act in the same order as
anyone else in our section.
In case we re-sent the Rpc::ExpectCandidate, we may receive more than one
Rpc::ExpectCandidateRefuseResponse and Rpc::ExpectCandidateAcceptResponse. In this case we will pass on
the first Rpc::ExpectCandidateAcceptResponse to our Candidate.
Trigger relocation: Candidate will disconnect on receiving that RPC
This RPC contains the Rpc::ExpectCandidateAcceptResponse info, and the signatures proving the source
section received it and decided that particular response is the one to relocate to.
In case we re-sent the Rpc::ExpectCandidate, we may receive more than one
Rpc::ExpectCandidateAcceptResponse.
In this case we must ensure that no single node could act on that other
Rpc::ExpectCandidateAcceptResponse and be accepted by the destination. this means the signatures must be
provided only once the Rpc::ExpectCandidateAcceptResponse is agreed.
RelocatedInfo will contain the Rpc::ExpectCandidateAcceptResponse info and the quorum of signatures
gathered from PARSEC vote on Parsec::RelocatedInfo.
(allow resend)"]
RefusedCandidate --> LoopEnd
CheckIsAccept -- Parsec::ExpectCandidateAcceptResponse --> VoteProvableRelocateInfo
VoteProvableRelocateInfo["set_node_state( node, State::Relocated{accept_info} (Vote for same
relocation if merge/split so only one valid proof
exists)
Process for Adult/Elder promotion and demotion including merge
This flow updates the elder status of our section nodes if needed.
Because it is interlinked, it also handles merging and splitting section: When merging or splitting, no
elder change can happen.
However other flows continue, so relocating to and from the section is uninterrupted:
As for incrementing work units, we want to update the eldership status of all nodes in a section on a
synchronised, regular basis.
For this reason, it makes sense to have a timer going through Parsec.
Note that this timer has to be only as fast as needed so that it remains highly unlikely that 1/3 of the
elders in any section would go offline within one timer's duration.
A section sends a Rpc::Merge to their neighbour section when they are ready to merge at the given
SectionInfo digest. The RPC contains the SectionInfo of the originating section.
In this flow, we handle both situations:
Our neighbour triggers the merge and we receive their Rpc::Merge.
We then vote for Parsec::NeighbourMerge.
We trigger the merge ourselves (see ProcessMerge flow)
We vote for this Parsec event on receiving a Rpc::Merge from our neighbour section.
It contains the information about them that we need for merging. When this PARSEC event reaches
consensus in PARSEC, we store that information by calling store_merge_infos.
This function is used to store the merge information from a neighbour section locally.
Once it has been stored, has_merge_infos will return true and we will be ready to enter the ProcessMerge
flow.
This function indicates that we received sufficient information from our neighbour section needing a
merge, and reached consensus on it.
We are ready to start the merging process with them.
This function indicates that we need merging (as opposed to a merge triggered by our neighbour's
needs).
The details for the trigger are still in slight flux, but here are some possibilities:
The number of State::Online adults plus elders is below our min section size of 10 elder plus
90 Adults
A certain proportion of the adults in this section are marked Offline
If any of our elders is not State::Online, they must be demoted to a plain old adult.
If this happens, the oldest adult must be promoted to the elder state as a replacement.
Alternatively, if any of our State::Online adult nodes is older than any of our elders, the youngest
elder must be demoted and this adult must be promoted.
Note that elder changes are only processed when the section is not in the middle of handling a merge.
This function indicates that we need splitting.
The details for the trigger are still in slight flux, but here are some possibilities:
The number of State::Online adults plus elders is above our min section size of 10 elder plus 90
Adults + buffer
Process Adult/Elder promotion and demotion needed from last check
Vote for Parsec::Add for new elders,Parsec:: Remove for no longer elders and Parsec::NewSectionInfo
This handles any change, it does not care whether one or all elders are changed, this is decided by the
calling function.
At any time, there must be exactly NUM_ELDERS (say 10) elders per section.
To maintain this invariant, we must handle multiple eldership changes atomically
We accomplish this by voting for all the membership changes needed at once and waiting for all these
votes to reach consensus before reflecting the status change in our chain.
A list of PublicId.
The content of the NewSectionInfo parsec event that reached consensus.
This function updates the eldership status of each node in the chain based on the new section info: the
nodes with their public id in new_section_info are the exact set of current elders.
Input:
new_section_info: Set<PublicId>
The new section info that just reached consensus.
Side-effect:
Mutates the chain.
graph TB
ProcessElderChange["ProcessElderChange (Take elder changes) (shared state)"]
style ProcessElderChange fill:#f9f,stroke:#333,stroke-width:4px
EndRoutine["End of ProcessElderChange (shared state)"]
style EndRoutine fill:#f9f,stroke:#333,stroke-width:4px
ProcessElderChange --> MarkAndVoteSwapNewElder
MarkAndVoteSwapNewElder["vote_for(Parsec::Add) for new elders vote_for(Parsec::Remove) for now adults
nodes vote_for(Parsec::NewSectionInfo)
Send Rpc::Merge, and take over handling any Parsec::NeighbourMerge.
Complete when one merge has completed, and a NewSectionInfo is consensused.
If multi-stage merges are required, they will require calling this function again
While in this sanctuary, our SectionInfo shall not be disturbed by elder changes.
This stops us from changing our SectionInfo after indicating to our neighbour the last SectionInfo before
merge.
We send it to our sibling section (or sections with longer prefix) on entering ProcessMerge, containing our own SectionInfo.
We send Merge irrespective of whether we are the section that triggered the merge. This allows all
sections involved in the merge to receive a Rpc::Merge, which is how Parsec::NeighbourMerge gets voted
for.
This PARSEC event indicates that our neighbour section is ready to merge with us.
It is voted for in the StartMergeSplitAndChangeElders flow, on receipt of a Rpc::Merge.
It contains their SectionInfo (or digest for it).
Store the neighbour's merge info, may not be sibling in case of multi merge
Did we store the neighbour's merge info for our sibling
Remove the stored sibling's merge info and return the NewSectionInfo.
Once we are ready to merge, have received our neighbour's SectionInfo through their Rpc::Merge, and
subsequently reached consensus on the Parsec::NeighbourInfo we voted for, we have all the information
needed to decide on the membership of our post-merge section.
This is the Parsec::NewSectionInfo.
With the Parsec::NewSectionInfo in hands, completing the merge process consists on joining the newly
formed section and leaving the old one behind.
Vote for the two Parsec::NewSectionInfo to gather required signatures
Wait for all these votes to reach consensus before reflecting the status change in our chain.
Both sections need to be consensused before we move on so we do not leave one behind with not enough
voters.
With the NewSectionInfo in hands, completing the split process consists on joining the correct newly
formed section and leaving the old one behind.
A list of PublicId.
The content of the NewSectionInfo parsec event that reached consensus that we are now a member of.
graph TB
ProcessSplit["ProcessSplit (Take elder changes) (shared state)"]
style ProcessSplit fill:#f9f,stroke:#333,stroke-width:4px
EndRoutine["End of ProcessSplit (shared state)"]
style EndRoutine fill:#f9f,stroke:#333,stroke-width:4px
ProcessSplit --> VoteNewSections
VoteNewSections["vote_for(Parsec::NewSectionInfo) for the two new sections
Successfully relocate a node from source to destination section
Sent by the source section when a candidate needs to relocate
Contains:
old_public_id: PublicId - The joining node's current public ID.
new_age: u8 - The joining node's new public id age.
Decided by source section, could be +1 or /2 depending on why we relocate.
(If we want to allow early relocate, we could also add carried over work units.)
Sent by destination section when a candidate is accepted
Contains:
target_interval: (XorName, XorName) - The interval into which the joining node should join.
section_info: SectionInfo - The destination section that the joining node will trust.
Sent by destination section when a candidate is refused
Contains: Empty
Sent by source section when a candidate is relocated to the relocated node
Contains:
target_interval: (XorName, XorName) - The interval into which the joining node should join.
section_info: SectionInfo - The destination section that the joining node will trust and connect to.
proof: Signatures - Quorum of signature for the candidate to prove the source section relocated
it with these infos.
Sent by the joining node to each elders of the section it is joining to initiate the joining process
Contains:
old_public_id: PublicId - PublicId from before relocation.
new_public_id: PublicId - PublicId from after relocation.
signature_using_old: Signature - Signature of concatenated PublicIds using the pre-relocation
key.
signature_using_new: Signature - Signature of concatenated PublicIds and signature_using_old
using the post-relocation key.
new_client_auth: Authority - Client authority from after relocation.
source_proof: Signatures - Quorum of signature from the source section proving the source
approved that relocation.
This will be checked against the stored information in the candidate node state.
Sent to collect information needed to establish a direct connection: Unchanged
Sent to process resource proof: Unchanged
Sent by destination section when a candidate becomes an adult / resource proof is completed.
Contains: Empty (Any information needed by an adult/elder should be sent to all connected members, and
updated as it changes)
sequenceDiagram
participant Src as Source Section
participant Node as Relocating Node
participant Dst as Destination Section
loop FindDestination
Src->>+Dst: Routing RPC: Rpc::ExpectCandidate
opt Refuse
Dst-->>Src: Routing RPC: Rpc::ExpectCandidateRefuseResponse
end
end
Dst-->>-Src: Routing RPC: Rpc::ExpectCandidateAcceptResponse
Src->>Node: Direct node-to-node RPC: Rpc::RelocatedInfo
loop NodeConnection
Node->>+Dst: Proxied Routing RPC: Rpc::ConnectionInfoRequest
Dst-->>-Node: Proxied Routing RPC: Rpc::ConnectionInfoResponse
Node->>Dst: Direct node-to-node RPC to group: Rpc::CandidateInfo
end
Dst->>Node: Direct node-to-node RPC: Rpc::ResourceProof
loop ResProof
Node->>+Dst: Direct node-to-node RPC: Rpc::ResourceProofResponse
Dst-->>-Node: Direct node-to-node RPC: Rpc::ResourceProofReceipt
end
Dst->>Node: Unproxied Group RPC: Rpc::NodeApproval


Who are you?
This sign-in form lets you log in using your existing profile on other websites! It currently supports the following:
Try pasting your profile URL into the box and we'll see if it's supported.
If you have your own website, you can use that too, by adding an OpenID or IndieAuth provider! I recommend SimpleID 1.0.2 or SelfAuth, or if you're running WordPress you can install plugins for OpenID or IndieAuth!
Much of this is specific to how I plan on implementing Authl.


http://www.susangranger.com/
Susan Granger's review of "THE PERFECT STORM" (Warner Bros.)
"More people die on fishing boats, per capita, than working in any other job in the U.S.. Every journey a fishing boat makes can be an all-or-nothing risk. It is life at its most exhilarating and its most terrifying," says director Wolfgang Petersen ("Das Boot"). And that's just what he captures in this true story of struggle and humanity aboard a swordfishing boat, the Andrea Gail, sailing out of Gloucester, Massachusetts, in late October, 1991. Early in Bill Wittliff's screenplay, based on Sebastian Junger's best-seller, we meet the crew of six. The veteran captain (George Clooney) is frustrated because he can't find fish on the Grand Banks, yet a rival skipper (Mary Elizabeth Mastrantonio) brings in huge hauls. His right-hand man (Mark Walhberg) needs money to build a new life with his girl-friend (Diane Lane). There's a devoted dad (John C. Reilly) with an estranged wife and son, a free-spirited Jamaican (Allen Payne), a lonely guy (John Hawkes), and a last-minute replacement with a bad attitude (William Fichtner). The skipper's convinced he can change his bad luck streak in remote Flemish Cap, and he does. But then trouble begins. There's a rogue wave, a man overboard and the ice machine breaks - with 60,000 lb. of fish that could spoil. But that's minor compared with a deadly monster storm approaching which a Boston meteorologist describes as "a disaster of epic proportions" that also threatens the lives of a Coast Guard helicopter rescue team trying to save three people stranded on a sailboat on the high seas. It's formulaic and there are cliches, but the walls of water, created by fluid dynamics simulating real-life phenomena, are awesome. On the Granger Movie Gauge of 1 to 10, "The Perfect Storm" is a terrifying, suspenseful 8. Hang on for the white-knuckle thrill ride of the summer!
========== X-RAMR-ID: 25054 X-Language: en X-RT-ReviewID: 254129 X-RT-TitleID: 1097762 X-RT-SourceID: 742 X-RT-AuthorID: 1274 X-RT-RatingText: 8/10
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


Fits ideal point model described in Carroll, Lewis, Lo, Poole and Rosenthal (2013), "The Structure of Utility in Models of Spatial Voting," American Journal of Political Science 57(4): 1008–1028, <doi:10.1111/ajps.12029>.
| Version: | 0.6 |
| Depends: | stats, coda, wnominate, pscl, MCMCpack |
| Published: | 2017-10-08 |
| Author: | Royce Carroll, Christopher Hare, Jeffrey B. Lewis, James Lo, Keith T. Poole, and Howard Rosenthal |
| Maintainer: | Christopher Hare <cdhare at ucdavis.edu> |
| License: | GPL-2 |
| URL: | http://k7moa.com/alphanominate.htm |
| NeedsCompilation: | yes |
| Citation: | anominate citation info |
| CRAN checks: | anominate results |
| Reference manual: | anominate.pdf |
| Package source: | anominate_0.6.tar.gz |
| Windows binaries: | r-devel: anominate_0.6.zip, r-release: anominate_0.6.zip, r-oldrel: anominate_0.6.zip |
| OS X binaries: | r-release: anominate_0.6.tgz, r-oldrel: anominate_0.6.tgz |
| Old sources: | anominate archive |
Please use the canonical form https://CRAN.R-project.org/package=anominate to link to this page.


jQuery Syntax Highlighter provides an elegant and simplistic interface for using Google's Prettify with jQuery. We also add a series of features that aren't possible just using Prettify, to ensure that you get the best experience possible:
code
and
pre
elements for SEO and semantic relevance!
Note! Currently Internet Explorer 6-8 have an
issue
with rendering new lines on code elements, until a fix is found
please use pre
elements instead.
So let's walk through it.
If your page already has jQuery included then you can skip this step.

And that's all there is to it in regards to installation. You don't actually have to download anything! now that is neat. Alternatively you could use a local copy of jQuery Syntax Highlighter instead of the CDN copy, but we'll leave that to you. So moving on, how do we let Syntax Highlighter know that we want to highlight our code block?
So you have you standard code block of let's say javascript code, which looks like this:
The following code block is what I would like to syntax highlight:
 // Define our Function function checkMeaningOfLife ( decimal, success ) { if ( parseInt(decimal,10) === 42 ) { window.console.log(success); } }; // Define our Variables var str = 'The meaning of life is true', decimal = 42.00; // Fire our Function checkMeaningOfLife(decimal,success);

And we want to highlight it. We can do this two ways. One is letting the Syntax Highlighter auto-detect which language you are using, the other is a more SEO friendly approach where we explicitly specify which language we want to use.
To highlight our code and auto-detect the language, we would simply add
the classname highlight
to our code block. This will look
like so:
The following code block is what I would like to syntax highlight:
 // Define our Function function checkMeaningOfLife ( decimal, success ) { if ( parseInt(decimal,10) === 42 ) { window.console.log(success); } }; // Define our Variables var str = 'The meaning of life is true', decimal = 42.00; // Fire our Function checkMeaningOfLife(decimal,success);

We can also highlight our code by specifying the language used
explicitly. This is good in case we don't trust the auto-detection
script or if we would like some
SEO benefits
by being more semantic (explicit with our markup). To do this we would
simply add the classname language-javascript
to our code
block, where the text javascript
is the name of the
language we are using. This will look like so:
The following code block is what I would like to syntax highlight:
 // Define our Function function checkMeaningOfLife ( decimal, success ) { if ( parseInt(decimal,10) === 42 ) { window.console.log(success); } }; // Define our Variables var str = 'The meaning of life is true', decimal = 42.00; // Fire our Function checkMeaningOfLife(decimal,success);

Sweet! That was too easy!. But there is one every important thing we have to take note of before we continue. And that is encoding our HTML within code blocks such that it is not actually interpreted by the browser as html! Eeee. So let's read about that.
An extremely important thing with using code blocks is making sure you
are encoding your HTML properly within your code blocks. This is because
if you don't your web browser will think it has to run that code,
despite it being in a code
or pre
element!
Argh! That could really cause problems... So what we want to do is
whenever we want to include code blocks (regardless of whether or not we
are wanting to syntax highlight them) we always must remember to encode
the HTML entities appropriately! So we do this by converting all the
characters which are <
to <
and all
the >
to >
. So for instance let's
look at the following code sample:

  I'm a span element. I hope I've been escaped properly... as otherwise I will be :-( and the browser will be :-O

Looks good, but this is how we actually code it in our HTML:

  I'm a span element. I hope I've been escaped properly... as otherwise I will be :-( and the browser will be :-O

Hrmmm. Interesting... But once you've got that nailed, then there really are not worries and you're all good to go. If you are a keen person, you may want also want check out the source code for this demo to gain a better grasp of this issue.
There is also one quite important thing. Internet Explorer 6-8 will
struggle displaying newlines using code
elements. This is a
known issue and has been documented in various locations with no known
fix
1
2
3
. In the meantime please use pre
elements instead of
code
elements. You can achieve the same SEO semantic
benefits by adding the classname code
to your
pre
element like so:

  I'm a span element. I hope I've been escaped properly... as otherwise I will be :-( and the browser will be :-O

Great! So that is all there is too it and all you need to know to install and use the Syntax Highlighter. You can quit reading and start working on your project right now, or you could learn a little bit more.
Syntax Highlighter is also ajax friendly. This means we can load in dynamic code blocks into our page which we would like highlighted, and actually highlight them without problem. Let's see how we can do this with the following snippet of javascript code:
var $content = $('
This is an upcoming code black:// I am some code
'); $content.syntaxHighlight(); // will highlight the code block found inside
If you are using
jQuery Sparkle
(a Do-Not-Repeat-Yourself jQuery Framework aimed at simplifying your
development with powerful tools) then calling
$content.sparkle()
will also call
$content.syntaxHighlight()
automatically for us.
This work is powered by coffee and distributed for free. Donations are how we afford our coffee. Coffee is how we stay awake after our day job hours to work on things like this free open-source project which you're looking at. So go ahead, and get that warm fuzzy feeling knowing you just helped some poor fellow working after hours for free to buy his coffee. You only need to spare a few dollars, or as much as you feel this piece of work is worth. Thanks so much. Alternatively; if you are not in a donating mood, then spreading the word about this project on twitter, your blog, or whatever is just as good. Thanks a bunch, we appreciate the help deeply.
This work is licensed under a MIT License.


#ngTasty
v
Quick Start
Contribute
Component
Table
simple
simple $http
complete
with sorting
with pagination
with filters
with custom pagination
with custom sorting
with custom theme
Table server side
simple
complete
with sorting
with pagination
with filters
reload callback
Service
WebSocket
Debounce
Throttle
Filter
Filter Int
Range
Camelize
Slugify


New
Active
Total
Deaths
Critical
Recovered
Developed by: Nusry KR
Source: https://rapidapi.com/api-sports/api/covid-193


A report from the course SOFTWARE DEVELOPMENT FOR THE WEB TASK
S01
Did you before know about the techniques Git, GitHub, Markdown and/or GitHub Pages?
I know a little about git, github, github page. They are version control tools in order to update and backtrack code versions.I have been using same kind of tools in several projects before. However, i don't know markdown before, but since you mentioned it, i googled it. Now i know it's a kind of label language, more or less like html. Our readme.md page is written in this language.
Have you ever created websites before?
Yes, i have created an album before, using the Bootstrap framework. But it's not a satifying work. So i am not going to show you.
Briefly explain your experience and knowledge of web application development.
I know the components of a website. I have finished several dynamic web site before. So I would like to describe myself as freshman with certain basis. However, i don't know much about server-side coding. I have learned several language working for server-side before, but never have been using them before.
What is your TIL for this course section?
Today, i have got our learning schedule and framework. I have the outline of the structure of whole website. THere is also a lot of stuff I learned before, but Mikael help us review them in a more clear way like basic html language. I have been using git before but mostly through IDE or git Desktop, so i also learnt how to use git through command line which makes me looks more professional.
S02
Here is the text for this section.
S03
Here is the text for this section.
S04
Here is the text for this section.
S05
Here is the text for this section.
S06
Here is the text for this section.
S07
Here is the text for this section.
S08
Here is the text for this section.
S09
Here is the text for this section.
S10
Here is the text for this section.


from mc.flows.flow_engine import FlowEngine
[docs]class FlowRecordClient(object):
def __init__(self, mc_db=None, queue_key=None, use_locks=False):
"""
Args:
mc_db (mc_db): mc_db.
queue_key (str): key for the flow queue to use.
use_locks (bool): if True, create a lock record when creating.
a job_record. This can be used to add a lock reference to
parent flows which create nested flows.
"""
self.mc_db = mc_db
self.queue_key = queue_key
self.use_locks = use_locks
[docs] def create_flow_record(self, flow_kwargs=None):
"""
Args:
flow_kwargs (dict): a dictionary of flow parameters.
Returns:
flow_meta (dict): a dictionary of metadata that can be passed to
get_flow_record to retrieve a flow.
"""
flow_record = self.mc_db.create_item(
item_type='flow', item_kwargs=flow_kwargs)
if self.use_locks:
parent_key = flow_kwargs.get('parent_key')
if parent_key:
self.mc_db.create_lock(
lockee_key=parent_key, locker_key=flow_record['key'])
flow_meta = {'key': flow_record['key']}
return flow_meta
[docs] def get_flow_record(self, flow_meta=None):
"""
Args:
flow_meta (dict): dictionary of metadata, as per
create_flow_record.
Returns:
flow_record (dict): a flow_record.
"""
return self.mc_db.get_item_by_key(
item_type='flow', key=flow_meta['key'])
[docs] def create_flow_record_from_flow_spec(self, flow_spec=None):
"""Create a flow record from flow spec.
Converts flow_spec to flow via flow_engine.
Args:
flow_spec (dict): a flow_spec
Returns:
flow_record (dict): a flow_record.
"""
flow = FlowEngine.flow_spec_to_flow(flow_spec=flow_spec)
flow_dict = FlowEngine.flow_to_flow_dict(flow=flow)
return self.create_flow_record(flow_kwargs=flow_dict)
[docs] def claim_flow_records(self):
"""
Returns:
flow_records (dict): a list of flow_records.
"""
claimed = self.mc_db.claim_queue_items(
queue_key=self.queue_key)['items']
return claimed
[docs] def patch_and_release_flow_record(self, flow_record=None, patches=None):
"""Patches a flow_record and clears its 'claimed' value.
Args:
flow_record (dict): a partial flow_record dict containing at least
the 'key' field.
patches (dict): a dict of flow_record kwargs to update.
Returns:
flow_record (dict): a patched flow dict.
"""
patched = self.mc_db.patch_item(
item_type='flow', key=flow_record['key'],
patches={'claimed': False, **patches}
)
if self.use_locks:
if patches.get('status') in {'FAILED', 'COMPLETED'}:
self.mc_db.release_locks(locker_keys=[flow_record['key']])
return patched


{% extends "prose.html" %} {% block title %}Bioregistry Schema{% endblock %} {% block content %}
This section describes the JSON schema used Bioregistry. It can be accessed here.
This section describes the schema used in the RDF dumps of the Bioregistry used with prefix
bioregistry.schema
and URL https://bioregistry.io/schema/#


BrandAPI
@protocol BrandAPI <NSObject>
Protocol of the Brand API methods.
-
Returns the configuration information of the owner’s current model.
To retrieve the configuration of a specific model the method
-[BrandAPI getConfig:callback:]
should be used.Declaration
Objective-C
- (void)getConfig:(nonnull void (^)(NSDictionary *_Nonnull))callback;
Swift
optional func getConfig(_ callback: ((UnsafeMutablePointer<Int32>?) -> Void)!)
Parameters
callback
A Block that will the receive the configuration as parameter.
-
Returns the configuration information of a specific brand and model.
If no model is provided then returns the information of the owner’s current model.
The options map accepts the following keys:
brand - The brand of the model.
model - The name of the model.
country - The country where the model will be provided, some materials/colors might not be available.
flag - A specific flag that may change the provided materials/colors available.
filter - If the configuration should be filtered by the country and/or flag (defaults
TRUE
).
Declaration
Objective-C
- (void)getConfig:(NSDictionary *_Nullable)options callback:(nonnull void (^)(NSDictionary *_Nonnull))callback;
Swift
optional func getConfig(_ options: Any!, callback: ((UnsafeMutablePointer<Int32>?) -> Void)!)
Parameters
options
A map with options.
callback
A Block that will the receive the configuration as parameter.
-
Returns the configuration information of the owner’s current model.
To retrieve the configuration of a specific model the method
-[BrandAPI getConfigP:callback:]
should be used.Return Value
A Promise that will be resolved with the configuration.
-
Returns the configuration information of a specific brand and model. If no model is provided
then returns the information of the owner’s current model.
The options map accepts the following keys:
brand - The brand of the model.
model - The name of the model.
country - The country where the model will be provided, some materials/colors might not be available.
flag - A specific flag that may change the provided materials/colors available.
filter - If the configuration should be filtered by the country and/or flag (defaults
TRUE
).
Declaration
Objective-C
- (nonnull Promise *)getConfigP:(nonnull NSDictionary *)options;
Swift
optional func getConfigP(_ options: Any!) -> Any!
Parameters
options
A map with options.
Return Value
A Promise that will be resolved with the configuration.


To understand why we need to track R(t) please read The Metric We Need to Manage COVID-19
To see how South African Covid-19 interventions compare to others go to our global R(t) tracker
To understand why we need to track R(t) please read The Metric We Need to Manage COVID-19
To see how South African Covid-19 interventions compare to others go to our global R(t) tracker


{% extends "base.html" %} {% block title %}Maps - {% endblock %} {% block css %}{% endblock %} {% block rows %}
This is a simple map using data downloaded from opendurham.nc.gov
and saved locally in /static/data/map-of-durham.geojson
.
The map layer comes from Open Street Map and the renderer is Leaflet.


- Quality
- Apparel & Beauty
- Home appliance mobile phone
- Computer digital
- 3C movement
- Love to eat
- Mother and baby home
- Book car
- Game Finance
- Travel health
- Not enough shopping yet
- Top
-
Product Intro
£83.9£99.9
-
Product Intro
£17.90£29.90
-
Product Intro
£20.70£44.90
-
Product Intro
£399.00£599.00
-
Product Intro
£5999.00£6499.00
-
Product Intro
£9588.00£10288.00
-
Product Intro
£848.00£899.00
-
Product Intro
£379.00£698.00
-
Product Intro
£3088.00£3299.00
-
Product Intro
£99.90£199.00


|
|
| Duration | 0.0 sec |
|---|---|
| Tests | 34 |
| Failures | 6 |
| Test case: | Ensure workload has valid label values |
|---|---|
| Outcome: | Skipped |
| Duration: | 0.0 sec |
| Failed | Incorrect value for key(s) under `labels` - the vales syntax is not valid so the Kubernetes engine will not accept it |
| Skipped | All failing configs skipped |
1 occurrences - metadata.name: rss-site (kind: Deployment) 1 skipped - metadata.name: rss-site (kind: Deployment)
skipped
| Test case: | Ensure each container has a configured liveness probe |
|---|---|
| Outcome: | Skipped |
| Duration: | 0.0 sec |
| Failed | Missing property object `livenessProbe` - add a properly configured livenessProbe to catch possible deadlocks |
| Skipped | All failing configs skipped |
1 occurrences - metadata.name: rss-site (kind: Deployment) 1 skipped - metadata.name: rss-site (kind: Deployment)
skipped


Before Change
libfn = utils.get_lib_fn("cropImageF%i" % cropped_image.dimension)
itkimage = libfn(cropped_image.pointer, full_image.pointer, 1, 1, [], [])
return iio.ANTsImage(pixeltype="float", dimension=cropped_image.dimension,
components=cropped_image.components, pointer=itkimage).clone(inpixeltype)
After Change
itkimage = libfn(cropped_image.pointer, full_image.pointer, 1, 1, [], [])
ants_image = iio.ANTsImage(pixeltype="float", dimension=cropped_image.dimension,
components=cropped_image.components, pointer=itkimage)
if inpixeltype != "float":
ants_image = ants_image.clone(inpixeltype)
return ants_image


View Students
News
More
About
Add Events
Contact
Report an issue
Sign up
Log in
Number of Participants (Remove this - Use backend)
Add Names
1st participant is the Team leader


A.I. ARTIFICIAL INTELLIGENCE (2001) / *** 1/2
Directed by Steven Spielberg. Screenplay by Spielberg, from a story by Ian Watson, based on the short story "Supertoys Last All Summer Long" by Brian Aldiss. Starring Haley Joel Osment, Frances O'Connor, Jude Law. Running time: 146 minutes. Rated PG by the MFCB. Reviewed on August 22nd, 2001.
By SHANNON PATRICK SULLIVAN
Synopsis: David (Osment), a child-like robot programmed to express love, is given to a family whose son was placed in suspended animation because he suffers from an incurable disease. But when the son unexpectedly returns, David is no longer needed. His "mother" (O'Connor) abandons him rather than let him be destroyed. Finding friendship with another robot, Gigolo Joe (Law), David sets off on a quest to find the Blue Fairy, who he believes will help him regain his mother's love.
Review: How do we define a person? Where does "artificial" end and "intelligence" begin? Is there a difference between someone who loves us, and something programmed to do so? These are the questions raised by "A.I.", a film directed by Spielberg but so reminiscent of its originator, Kubrick, that his ghost haunts almost every frame. "A.I." wraps these conundrums in a quest, but at the end of the quest lie more questions. The answers are left to the viewers, who are pulled en route in every direction. Is David's longing for his mother proof of his humanity? Perhaps, but still, David is undeniably not human, as we are periodically reminded. Whatever one concludes, "A.I." is certainly one of the most thought-provoking films in recent memory. It is abetted by spectacular performances, with Osment proving he is perhaps the best child actor working today. David is endearing, but a persistent awkward edge reminds us of his artificiality. And Spielberg's visuals are stunning, perfectly complementing "A.I."'s central contradiction. His humans live in a stark world of clinical coldness; the robots inhabit a chaotic, colourful universe. The humans are passive and remote; the robots cling desperately to life. And although "A.I." does suffer from an extended coda that never quite works, it remains a fine tribute to the genius that was Kubrick.
Copyright © 2001 Shannon Patrick Sullivan. Archived at The Popcorn Gallery, http://www.physics.mun.ca/~sps/movies.html
| Shannon Patrick Sullivan |<EMAIL_ADDRESS>| +---------------------------------+---------------------------------+ / Doctor Who: A Brief History of Time (Travel) go.to/drwho-history \ \__ We are all in the gutter but some of us are looking at the stars __/
========== X-RAMR-ID: 29379 X-Language: en X-RT-ReviewID: 247027 X-RT-TitleID: 1108184 X-RT-SourceID: 886 X-RT-AuthorID: 1699 X-RT-RatingText: 3.5/4
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


Fairy Tales and Other Traditional Stories
by FCIT
“The Golden River”
by John Ruskin
Additional Information
- Year Published: 0
- Language: English
- Country of Origin: England
- Source: John Ruskin, King of the Golden River
-
Readability:
- Flesch–Kincaid Level: 4.3
- Word Count: 2,433
- Genre: Fairy Tale/Folk Tale
- Keywords: merit
- ✎ Cite This
Downloads
There was once a beautiful little valley, where the sun was warm, and the rains fell softly; its apples were so red, its corn so yellow, its grapes so blue, that it was called the Treasure Valley. Not a river ran into it, but one great river flowed down the mountains on the other side, and because the setting sun always tinged its high cataract with gold after the rest of the world was dark, it was called the Golden River. The lovely valley belonged to three brothers. The youngest, little Gluck, was happy-hearted and kind, but he had a hard life with his brothers, for Hans and Schwartz were so cruel and so mean that they were known everywhere around as the “Black Brothers.” They were hard to their farm hands, hard to their customers, hard to the poor, and hardest of all to Gluck.
At last the Black Brothers became so bad that the Spirit of the West Wind took vengeance on them; he forbade any of the gentle winds, south and west, to bring rain to the valley. Then, since there were no rivers in it, it dried up, and instead of a treasure valley it became a desert of dry, red sand. The Black Brothers could get nothing out of it, and they wandered out into the world on the other side of the mountain-peaks; and little Gluck went with them.
Hans and Schwartz went out every day, wasting their time in wickedness, but they left Gluck in the house to work. And they lived on the gold and silver they had saved in Treasure Valley, till at last it was all gone. The only precious thing left was Gluck’s gold mug. This the Black Brothers decided to melt into spoons, to sell; and in spite of Gluck’s tears, they put it in the melting pot, and went out, leaving him to watch it.
Poor little Gluck sat at the window, trying not to cry for his dear golden mug, and as the sun began to go down, he saw the beautiful cataract of the Golden River turn red, and yellow, and then pure gold.
“Oh, dear!” he said to himself, “how fine it would be if the river were really golden! I needn’t be poor, then.”
“It wouldn’t be fine at all!” said a thin, metallic little voice, in his ear.
“Mercy, what’s that!” said Gluck, looking all about. But nobody was there.
Suddenly the sharp little voice came again.
“Pour me out,” it said, “I am too hot!”
It seemed to come right from the oven, and as Gluck stood, staring in fright, it came again, “Pour me out; I’m too hot!”
Gluck was very much frightened, but he went and looked in the melting pot. When he touched it, the little voice said, “Pour me out, I say!” And Gluck took the handle and began to pour the gold out.
First came out a tiny pair of yellow legs; then a pair of yellow coat-tails; then a strange little yellow body, and, last, a wee yellow face, with long curls of gold hair. And the whole put itself together as it fell, and stood up on the floor,—the strangest little yellow dwarf, about a foot high!
“Dear, me!” said Gluck.
But the little yellow man said, “Gluck, do you know who I am? I am the King of the Golden River.”
Gluck did not know what to say, so he said nothing; and, indeed, the little man gave him no chance. He said, “Gluck, I have been watching you, and what I have seen of you, I like. Listen, and I will tell you something for your good. Whoever shall climb to the top of the mountain from which the Golden River falls, and shall cast into its waters three drops of holy water, for him and him only shall its waters turn to gold. But no one can succeed except at the first trial, and anyone who casts unholy water in the river will be turned into a black stone.”
And then, before Gluck could draw his breath, the King walked straight into the hottest flame of the fire, and vanished up the chimney!
When Gluck’s brothers came home, they beat him black and blue, because the mug was gone. But when he told them about the King of the Golden River they quarrelled all night, as to which should go to get the gold. At last, Hans, who was the stronger, got the better of Schwartz, and started off. The priest would not give such a bad man any holy water, so he stole a bottleful. Then he took a basket of bread and wine, and began to climb the mountain.
He climbed fast, and soon came to the end of the first hill. But there he found a great glacier, a hill of ice, which he had never seen before. It was horrible to cross,—the ice was slippery, great gulfs yawned before him, and noises like groans and shrieks came from under his feet. He lost his basket of bread and wine, and was quite faint with fear and exhaustion when his feet touched firm ground again.
Next he came to a hill of hot, red rock, without a bit of grass to ease the feet, or a particle of shade. After an hour’s climb he was so thirsty that he felt that he must drink. He looked at the flask of water. “Three drops are enough,” he thought; “I will just cool my lips.” He was lifting the flask to his lips when he saw something beside him in the path. It was a small dog, and it seemed to be dying of thirst. Its tongue was out, its legs were lifeless, and a swarm of black ants were crawling about its lips. It looked piteously at the bottle which Hans held. Hans raised the bottle, drank, kicked at the animal, and passed on.
A strange black shadow came across the blue sky.
Another hour Hans climbed; the rocks grew hotter and the way steeper every moment. At last he could bear it no longer; he must drink. The bottle was half empty, but he decided to drink half of what was left. As he lifted it, something moved in the path beside him. It was a child, lying nearly dead of thirst on the rock, its eyes closed, its lips burning, its breath coming in gasps. Hans looked at it, drank, and passed on.
A dark cloud came over the sun, and long shadows crept up the mountain-side.
It grew very steep now, and the air weighed like lead on Hans’s forehead, but the Golden River was very near. Hans stopped a moment to breathe, then started to climb the last height.
As he clambered on, he saw an old, old man lying in the path. His eyes were sunken, and his face deadly pale.
“Water!” he said; “water!”
“I have none for you,” said Hans; “you have had your share of life.” He strode over the old man’s body and climbed on.
A flash of blue lightning dazzled him for an instant, and then the heavens were dark.
At last Hans stood on the brink of the cataract of the Golden River. The sound of its roaring filled the air. He drew the flask from his side and hurled it into the torrent. As he did so, an icy chill shot through him; he shrieked and fell. And the river rose and flowed over
The Black Stone.
When Hans did not come back Gluck grieved, but Schwartz was glad. He decided to go and get the gold for himself. He thought it might not do to steal the holy water, as Hans had done, so he took the money little Gluck had earned, and bought holy water of a bad priest. Then he took a basket of bread and wine, and started off.
He came to the great hill of ice, and was as surprised as Hans had been, and found it as hard to cross. Many times he slipped, and he was much frightened at the noises, and was very glad to get across, although he had lost his basket of bread and wine. Then he came to the same hill of sharp, red stone, without grass or shade, that Hans had climbed. And like Hans he became very thirsty. Like Hans, too, he decided to drink a little of the water. As he raised it to his lips, he suddenly saw the same fair child that Hans had seen.
“Water!” said the child. “Water! I am dying.”
“I have not enough for myself,” said Schwartz, and passed on.
A low bank of black cloud rose out of the west.
When he had climbed for another hour, the thirst overcame him again, and again he lifted the flask to his lips. As he did so, he saw an old man who begged for water.
“I have not enough for myself,” said Schwartz, and passed on.
A mist, of the colour of blood, came over the sun.
Then Schwartz climbed for another hour, and once more he had to drink. This time, as he lifted the flask, he thought he saw his brother Hans before him. The figure stretched its arms to him, and cried out for water.
“Ha, ha,” laughed Schwartz, “do you suppose I brought the water up here for you?” And he strode over the figure. But when he had gone a few yards farther, he looked back, and the figure was not there.
Then he stood at the brink of the Golden River, and its waves were black, and the roaring of the waters filled all the air. He cast the flask into the stream. And as he did so the lightning glared in his eyes, the earth gave way beneath him, and the river flowed over
The Two Black Stones.
When Gluck found himself alone, he at last decided to try his luck with the King of the Golden River. The priest gave him some holy water as soon as he asked for it, and with this and a basket of bread he started off.
The hill of ice was much harder for Gluck to climb, because he was not so strong as his brothers. He lost his bread, fell often, and was exhausted when he got on firm ground. He began to climb the hill in the hottest part of the day. When he had climbed for an hour he was very thirsty, and lifted the bottle to drink a little water. As he did so he saw a feeble old man coming down the path toward him.
“I am faint with thirst,” said the old man; “will you give me some of that water?”
Gluck saw that he was pale and tired, so he gave him the water, saying, “Please don’t drink it all.” But the old man drank a great deal, and gave back the bottle two-thirds emptied. Then he bade Gluck good speed, and Gluck went on merrily.
Some grass appeared on the path, and the grasshoppers began to sing.
At the end of another hour, Gluck felt that he must drink again. But, as he raised the flask, he saw a little child lying by the roadside, and it cried out pitifully for water. After a struggle with himself Gluck decided to bear the thirst a little longer. He put the bottle to the child’s lips, and it drank all but a few drops. Then it got up and ran down the hill.
All kinds of sweet flowers began to grow on the rocks, and crimson and purple butterflies flitted about in the air.
At the end of another hour, Gluck’s thirst was almost unbearable. He saw that there were only five or six drops of water in the bottle, however, and he did not dare to drink. So he was putting the flask away again when he saw a little dog on the rocks, gasping for breath. He looked at it, and then at the Golden River, and he remembered the dwarf’s words, “No one can succeed except at the first trial”; and he tried to pass the dog. But it whined piteously, and Gluck stopped. He could not bear to pass it. “Confound the King and his gold, too!” he said; and he poured the few drops of water into the dog’s mouth.
The dog sprang up; its tail disappeared, its nose grew red, and its eyes twinkled. The next minute the dog was gone, and the King of the Golden River stood there. He stooped and plucked a lily that grew beside Gluck’s feet. Three drops of dew were on its white leaves. These the dwarf shook into the flask which Gluck held in his hand.
“Cast these into the river,” he said, “and go down the other side of the mountains into the Treasure Valley.” Then he disappeared.
Gluck stood on the brink of the Golden River, and cast the three drops of dew into the stream. Where they fell, a little whirlpool opened; but the water did not turn to gold. Indeed, the water seemed vanishing altogether. Gluck was disappointed not to see gold, but he obeyed the King of the Golden River, and went down the other side of the mountains.
When he came out into the Treasure Valley, a river, like the Golden River, was springing from a new cleft in the rocks above, and flowing among the heaps of dry sand. And then fresh grass sprang beside the river, flowers opened along its sides, and vines began to cover the whole valley. The Treasure Valley was becoming a garden again.
Gluck lived in the Valley, and his grapes were blue, and his apples were red, and his corn was yellow; and the poor were never driven from his door. For him, as the King had promised, the river was really a River of Gold.