Every couple of years I reflect on the most influential books that I’ve read. Going back several years these are the books that I most remember from my university days and time working in industry that have influenced how I think.
Non-fiction and textbooks
The Little MLer by Matthias Felleisen
A whimsical set of discussions around a set of small Standard ML projects. Convey’s the large ideas in typed functional programming, concerning polymorphism, higher order functions and algebraic datatypes.
Gödel, Escher, Bach by Douglas Hofstadter
A strange discussion about formal systems and their occurrence in multiple domains of human thinking, from philosophy and linguistics to computer science. The book is highly non-linear and probably should be read in that fashion.
Galois Theory by Ian Stewart
Stewart’s short presentation of the subject works up to Abel-Ruffini theorem in a particularly elegant way, and much more concisely than Artin’s presentation.
Calculus by Michael Spivak
Although more a of a book on real analysis, it is a beautifully written book that covers the idea of calculus and real functions. The clarity of Spivak’s presentation and motivating examples is rare to find. Although it would be hard to teach this book in an introductory course, it is a must read after the fact.
Mathematics, Form and Function by Saunders MacLane
MacLane’s popular discussion about the large-scale structure of mathematics and the underlying common ideas that gave rise to his formalization of category theory. Should be required reading for first year math undergraduates to understand the ideas that drive mathematical discovery and unification.
Number, the Language of Science by Tobias Dantzig
Tobias discusses the historical concept of mathematics from the rudimentary counting of prehistoric man to the counterintuitive and bizarre ideas at the edges of modern math.
The Book of Numbers by John Conway
A whimsical book on number theory that I remember distinctively from my childhood. Probably the only children’s book that touches on complex analysis and hypersurreal numbers.
Structure and Interpretation of Computer Programs by Gerald Jay Sussman
The classical introductory computer science book in scheme. Widely considered a classic for good reasons, it really conveys the core ideas that underlying modern computing better than other introductory text.
Introduction to Functional Programming (1st Edition) by Richard Bird and Philip Wadler
The beautiful introductory text that really conveys the elegance of the core ideas of typed functional programming. Every core idea is precisely motivated by the most perfect example of usage. This was the book that really turned me on to programming in Haskell.
Types and Programming Languages by Benjamin Pierce
Pierce’s book on type theory (TAPL) was revolutionary and has become the “bible” of programming language theory. Although some chapters are a little dated, the core ideas and algorithms are foundational to modern programming language design. Although this book is great at explaining the implementation of type-checkers there is not yet that covers the full end-to-end implementation of modern functional compilers.
Software Foundations by Benjamin Pierce
Software is the ground-breaking book about the methods of constructing machine verifiably correct software using the Coq proof assistant. On top of this it’s also one of the only thorough introductions to the progress and preservation proofs that underlying the core verification of language semantics.
Artificial Intelligence by Russell and Norvig
A great book on the many of the core ideas of Artificial Intelligence that emerged before the first AI winter. The chapter on knowledge representation is a bit dated and doesn’t yet cover some modern ideas like fluent calculus or advances in temporal logic.
The Quest for Omega by Gregory Chaitin
Chaitin’s popularized account of information theory and the derivation of the constant of his namesakes, the halting probability that represents the probability that a randomly constructed program will halt. Does a great job of detailing the many paradoxes that arise out of simple questions about computing.
The Structure of Scientific Revolutions by Thomas Kuhn
The most famous philosophy of science book of the last century. Kuhn challenged the then prevailing views of scientific progress and shed light on the social structure of how prevailing theories change and come to be accepted. Although many people disagree with some of the thesis, it’s a must read for any grad student working in the natural sciences.
The Art of Doing Science and Engineering by Richard Hamming
The notes from Richard Hamming’s lecture series mentoring young scientists and engineers about his experiences at Bell Labs. In particular his lecture about You and Your Research should be watched by everyone regardless of involvement in science.
Category Theory by Steve Awodey
Category theory is a outgrowth branch of abstract algebra with incredibly diverse applications. The most modern textbook on category, although the original MacLane texts are still excellent this tracks many of the more recent notational conventions and ideas.
Visual Complex Analysis by Tristan Needham
Tristan’s groundbreaking book on complex analysis was one of the first texts on this subject written in the age of modern computer graphing tools and sheds an amazing amount of geometric insight into an otherwise very abstract field of analysis.
Geometric Algebra for Physicists by Chris Doran
Doran’s book is the most thorough derivation of the core physical laws (Classical mechanics, Maxwell’s equations, Noether’s theorem, Dirac equation, Einstein field equation) from the geometric algebra perspective. There’s no new information per se, but the alternative formalism is often much more concise as in the case of the Maxwell’s equations.
Tensor Calculus for Physics by Dwight Neuenschwander
I spent several months studying the formalism for tensor calculus from the traditional texts and it was terrible. Many years later I discovered this book which distills all the core ideas needed for general relativity down into a book 1/6th the size.
Term Rewriting and all That by Franz Baader
A rather old book about a very niche topic: term rewriting. Term rewriting is a very general framework for building sets of transformations over symbols and their synthesis. It’s a very broad subject that finds applications compilers, type theory, knowledge representation and machine learning. It’s a shame it’s not studied more often.
The Implementation of Functional Programming Languages by Simon Peyton Jones
One of the most important books written on compiler design and largely the only resource ever written the full engineering details going into functional compilers.
An Introduction to Analysis Zaring
My favorite real analysis text that I read in conjunction to a course using Rudin. Has a much more casual presentation and motivates the core ideas much better than the usual lemma/proof chug of the canonical texts. This book has been out of print for 20 years, so good luck finding it.
Functional Differential Geometry by Gerald Jay Sussman
A implementation of the core ideas of differential geometry implemented in a computable form as a Scheme program.
The C Programming Language by Brian Kernighan and Dennis Ritchie
The book everyone learns C from, although a bit dated it still has a certain elegance to it’s minimalist approach to a minimalist language.
Coders at Work by Peter Siebel
A collection of interviews with some of he greatest programmers of our generation, and their perspectives on the state of the craft of programming. Particularly the interviews with Simon Peyton Jones and Joe Armstrong are particularly good.
The Demon-Haunted World Carl Sagan
Carl Sagan’s strangely prescient discussion about the role of science and scientific reasoning has in society. The main thesis is that the “candle” of scientific progress is a fragile construction that could very well be extinguished by ignorance and superstition.
Fiction, graphic novels and biographies.
Diaspora by Greg Egan
Diaspora focuses on post-human existence when humanity has “speciated” out into three separate transhuman species. It questions the meaning of human existence in a transhuman world where human desires are bound up up with ancestral human biology and what meaning do lives and desires have, and what serves as the basis of values when biology no longer forms a part of life. Also one of the only fiction to use the word “fiber bundle” as part of the story.
Every tunnel in the Mines was built from the steps of a watertight proof; every theorem, however deeply buried, could be traced back to every one of its assumptions.
God Emperor of Dune by Frank Herbert
The Dune series traces the lives of the Atreides family, whose patriarch Paul discovers a psychoactive substance called “spice” which unlocks his ability to perceive the future. Paul discovers the terrible truth of being an Oracle - the more a prophetic vision is fulfilled, the harder it is to avoid the rest of the vision; and the terrible ramifications a prescient messiahs and hero worship has for humanity’s long term future.  One of the greatest series ever written in my option.
It has occurred to me more than once that holy boredom is good and sufficient reason for the invention of free will.
Prelude to Foundation by Issac Asimov
Asimov’s seminal work about the collapse and rebirth of a advanced galactic-spanning civilization and the mathematical cult that architects the future course of human history to a new golden age.
We’ve been blinded by Seldon’s psychohistory, one of the first propositions of which is that the individual does not count, does not make history, and that complex social and economic factors override him, make a puppet out of him.
Anathem by Neal Stephenson
In a fictional world a series of technological catastrophes force the planet’s scientists, scholars and philosophers - known as the avout — to live apart from the ‘Sæcular world’ of society at large and are not permitted access to modern technology. The avout spend their days engaged in theoretical research until another plant-wide catastrophe forces them to emerge from their cloisted existence.
And it happened all the time that the compromise between two perfectly rational alternatives was something that made no sense at all.
The Man Who Loved Only Numbers by Paul Hoffman
Paul Erdős was one of the most prolific mathematicians of the 20th century, and simultaneously one of the most eccentric people who ever lived. He’s particularly known for monumental contributions to Ramsey theory and combinatorics.
As a joke I said, “What is the purpose of Life?” “Proof and conjecture, and keep the Supreme Fascist’s score low.”
Einstein by Walter Isaacson
Isaccson’s great biography of Einstein really outlines the struggle of Einstein’s life and the humanity of one of the greatest physicists beyond just the Annus Mirabilis years. In particular his accounts of the war and the details of his personal life are much more sad than one might expect.
When you write biographies, whether it’s about Ben Franklin or Einstein, you discover something amazing: They are human.
The Culture Series by Iain Banks
The culture series is one of the few modern scifi that posit a post-scarcity interstellar utopia. In the far future the galaxy is largely dominated by an alliance of advanced races called The Culture. The civilization is grapples with the moral and systematic issues present with artificial super-intelligence, trans-humanism, and dealings with both less advanced and transcendent species.
Reason shapes the future, but superstition infects the present.


Sorry, there are errors in this sample submission.
Check that the following fields are not left blank:
{{error}}
{% endfor %}If the error is a problem with the d_number click here to check that this sample does not already exist or to modify sample.
To enter new data, click here.


Software
I’m an active developer, maintainer, or contributor to several projects in the Python data science community. Projects I maintain or have made significant contributions to include:
Dask
Dask is a library for flexible parallel computing in Python. It provides parallelized NumPy array and Pandas DataFrame objects as well as a task scheduling interface for scientific computing in larger-than-memory or distributed environments.
PyCondor
PyCondor is a Python package for constructing and submitting jobs to an HTCondor distributed cluster. It was designed to provide built-in functionality to help automate common workflow tasks with a user-friendly API.
PyUnfold
PyUnfold is a Python package for implementing Bayesian iterative unfolding. It is built on top of the Python scientific computing stack, bringing iterative unfolding methods fully into the Python ecosystem.
- J. Bourbeau et al., (2018). PyUnfold: A Python package for iterative unfolding. Journal of Open Source Software, 3(26), 741, https://doi.org/10.21105/joss.00741.
I also contribute to other projects such as scikit-learn, Dask-ML, MLxtend, and more.
Details about my open source contributions are available on GitHub.


When the 'enabled' state of a button tag is changed, we have to invalidate distribution.
Button 1
Button 2
Button 3
Button 4


WITNESS LIST State, Federal & International Relations Committee April 6, 1999-8:00A HB 1887 For: Braun, John (National Guard Assoc. of Texas) James, III, Daniel (Adjutant General's Dept., Texas National Guard) Shine, Hugh (Self and 149th Aviation Battalion, Texas Army National Guard) Registering, but not testifying: For: King, Lewis (Self) Pyeatt, Dale (National Guard Assoc. of Texas) On: Best, John (Research and Oversight Council on Worker's Compensation) Birdwell, Bruce (State Office of Risk Management) HB 2083 For: Gilyard, Roy (City of El Paso) Registering, but not testifying: For: Erben, Randy (Texas Border Infrastructure Coalition) HB 2757 Against: Sneed, Robert C. (Texas Land Title Assoc.) On: Graves, Stan (Texas Historical Commission) Registering, but not testifying: For: Berlanga, Hugo (City of Austin) Carr, Snapper (Texas Municipal League) Against: Neeley, Karen (Independent Bankers Assoc. of Texas) Sandberg, Eric (Texas Savings and Community Bankers Assoc.) HB 2767 Registering, but not testifying: For: Bujanda, M. (Self and Martinez and Associates) Martinez, Mario (City of Brownsville) HB 3442 Registering, but not testifying: For: Roach, Judy (Texas Cemeteries Assoc.) On: Hite, Gerron (Texas Historical Commission) HCR 134 Against: Baumbach, Susan (Texas Health Care Assoc.)


migraine perfusion CBF study brain interictal maps using imaging left {border-style cerebral headache matter px;} #ffffff;} patients arterial value MRI aura studies gray ASL performed spin temporal Headache correlation labeling tissue clinical data individual normalized General analysis blood hyperperfusion increased probability structural Chinese Hamilton Neurol PLA altered attack changes disease flow functional images mask normal pseudo-continuous px; {font-family Cephalalgia Chen HAMD Med customized font-size migraineurs pc-ASL phase processing research superior used ./s--- Foundation contrast did double; hemiplegic positive region significantly technique (the Alsop Cerebral China Detre Funding HAMA However, Liu MIDAS Scale VAS Zhiye abnormal associated border-color border-width compared comparison current depression duration generate gyrus hypersensitivity hypoperfusion information methods neural previous primary regional showed solid; study, supporting visual volume {font-style {font-weight Department EM. PWI Pain Science T-TPM Voxel-wise Wang abnormalities acquired alteration anxiety applied bold computed connectivity controls cortex courier; days decreased depressive disorders distribution, dynamic em; emission episodic generated headache, image included located neurogenic observed padding patients. pattern photon pole presented provide pt;} role scale segmented sequence spin-labeled stimulation subjects supported tomography vascular


Define AWS IAM policies with ease using a smaller, quicker-to-read format.
ALLOW dynamodb:Batch*, dynamodb:DeleteItem ON dynamodb:::table/push*; ALLOW s3:PutRecord ON kinesis:::stream/push*;
[ { "Effect": "Allow", "Action": [ "dynamodb:Batch*", "dynamodb:DeleteItem" ], "Resource": [ "arn:aws:dynamodb:::table/push*" ] }, { "Effect": "Allow", "Action": [ "s3:PutRecord" ], "Resource": [ "arn:aws:kinesis:::stream/push*" ] } ]
Integrate cogito into your workflow using:


48 empty bottles gathered after WebMD First Thursday. Reuse > recycle. One step closer to accommodating latest batches in secondary.
1/7/2010, 5:44:40 PM
Favs: 0
Retweets: 0
link--- layout: tweet ---
48 empty bottles gathered after WebMD First Thursday. Reuse > recycle. One step closer to accommodating latest batches in secondary.
1/7/2010, 5:44:40 PM
Favs: 0
Retweets: 0
link


Architectural Adventures in Startups and Enterprise
Julie Ng
W1 FWD Build Week
20 June 2017
About Me
- Enterprise Architect, Allianz Deutschland AG
- Previously: UX Designer, Full Stack Developer, failed entrepreneuer
Allianz ATCs
- Agile Training Center
- Internal Startup Laboratory
- Startup methodologies and technologies
What is architecture?
Design decisions about any system that keep implementators and maintainers form exercising needless creativity.
- D'Souza, Wills. Objects, Components, and Frameworks with UML: The Catalysis (SM) Approach; Addison-Wesley Professional 1998
Decisions
- Make informed decisions.
- Your decisions are for you, not me or internet hype.
- Stand by your decisions - have opinions…
- …loosely held - you will be wrong.
Source: Monteiro, Mike. Design Is a Job. A Book Apart 2012
An Opinionated Approach
Skateboard, Bike, Car
Source: Wilkinson, Andrew. "Building Products The MetaLab Way"
https://medium.com/@awilkinson/skateboard-bike-car-6bec841ed96e
→ Iterate!
Architecture and Clean Code
It is not necessary to do a Big Design Up Front (BDUF). In fact, BDUF is even harmful because it inhibits adapting to change
- Martin, Robert C. Clean Code (p. 167).
→ flexibility - always be learning and adapting
Small and Testable
A system with many small classes as no more moving parts than a system with a few large classes.
- Martin, Robert C. Clean Code (p. 139).
→ Maintainable software
Continuous Delivery
Image Source:
https://www.cloudbees.com/sites/default/files/
→ Move fast and automate learning


Delta flight attendant accused of being almost 7 times over alcohol limit
by Yaron SteinbuchA Delta flight attendant from Brooklyn has been accused of being almost seven times over the alcohol limit while on duty at London’s Heathrow Airport, according to a report.
Lemara Thompson, 27, allegedly had 135 milligrams of alcohol per 100 milliliters of blood in her body at the major transportation hub on June 16, the UK’s Metro reported.
She was charged with performing an aviation function with a blood-alcohol level over the prescribed limit, which is 20 milligrams for people performing duties relating to an airliner, according to Civil Aviation Authority rules and the Railways and Transport Safety Act.
Thompson, who lives on Ocean Avenue in Brooklyn, did not appear at Uxbridge Magistrates’ Court for a hearing Wednesday but responded to the court via mail, according to the report.
Chair Magistrate Alison White adjourned the case for two weeks to give Thompson notice to travel to the British court or to set up a video link. She is expected to appear in court on Dec. 4.
Delta did not immediately respond to a request for comment.


AppWebsocket connections use JSON messages for communication. Those messages are normaly received and processed by the application. But sometimes it is wanted to build modules for re-occurring communication types that can be reused. This can be done using JSON APIs. The idea is that many JSON APIs can be attached to a single AppWebsocket connection and each of them processes the JSON messages with a specific "api" attribute.
This framework provides base classes and interfaces that are needed to implement JSON APIs and attach them to a connection.
| File | common/interface/json_api.h |
| Classes |
JsonApiContext UJsonApiContext JsonApi IJsonApiConnection |
class JsonApiContext {
public:
JsonApiContext() {
providers = 0;
}
void RegisterJsonApi(class UJsonApiContext * provider) {
provider->next = providers;
providers = provider;
}
class JsonApi * CreateJsonApi(const char * name, class IJsonApiConnection * connection, class json_io & msg, word base) {
for (class UJsonApiContext * p = providers; p; p = p->next) {
if (!strcmp(name, p->Name())) return p->CreateJsonApi(connection, msg, base);
}
return 0;
}
class JsonApi * JsonApiRequested(const char * name, class IJsonApiConnection * connection) {
for (class UJsonApiContext * p = providers; p; p = p->next) {
if (!strcmp(name, p->Name())) return p->JsonApiRequested(connection);
}
return 0;
}
class UJsonApiContext * providers;
};
The class JsonApiContext must be used as base class by an object using other Json Api implementations. Typically the instance class of an app uses this class as base class. This class is passed as argument on the constructor of AppWebsocket so that for incoming messages an api implementation can be found.
class UJsonApiContext {
public:
virtual class JsonApi * CreateJsonApi(class IJsonApiConnection * connection, class json_io & msg, word base) = 0;
virtual class JsonApi * JsonApiRequested(class IJsonApiConnection * connection) { return 0; };
virtual const char * Name() = 0;
class UJsonApiContext * next;
};
This class is used as base class by an api implementation. With this class the api is added to the list of providers for a given JsonApiContext.
class JsonApi {
public:
virtual ~JsonApi() {};
virtual const char * Name() = 0;
virtual void JsonApiStart() {};
virtual void Message(class json_io & msg, word base, const char * mt, const char * src) = 0;
virtual void JsonApiConnectionClosed() = 0;
};
This is the base class for JSON APIs. One instance can be attached to one connection. So for each connection the application has to create a new JsonApi instance.
| class json_io & msg | The JSON structure containing the message. |
| word base |
The ID of the base element of the message inside the msg structure. Pass it to the get functions of json_io to read the attributes of the message.
Example:
const char * text = msg.get_string(base, "text"); |
| const char * mt | The message type of the message. |
| const char * src | The src is used for multiplexing on the remote side. If specified, all answers to this message should contain the same src value. |
class IJsonApiConnection {
public:
virtual ~IJsonApiConnection() {}
virtual void RegisterJsonApi(class JsonApi * api) = 0;
virtual void UnRegisterJsonApi(class JsonApi * api) = 0;
virtual void JsonApiMessage(class json_io & msg, char * buffer) = 0;
virtual void JsonApiMessageComplete() = 0;
virtual bool JsonApiPermission(const char * api) = 0;
};
This interface represents a websocket connection that supports plugging-in JsonApi instances. A well-known implementation of the interface is AppWebsocket.
| class JsonApi * api | The JsonApi object that shall be attached. |
| class JsonApi * api | The JsonApi object that shall be removed. |
| class json_io & msg | A JSON structure containing the message. |
| char * buffer | A buffer that is big enough to contain the whole encoded message including NULL termination. |
| const char * api | The name of the API. |


_________________
A chart of photographs opposing modesty versus self-expression by the contrast between a frontal portrait and a GIF where the face is only partly visible. Project with Charlotte Pezé, Guillaume Pontes et Léa François.


Data Scientist - Santa Monica, CA
Roku is looking for a Programming & Engagement Data Scientist to join our Core Analytics Team. You will be part of a centralized analytics team, with all the benefits that entails: a world class peer group to support you, centrally maintained tools, career growth, and more. You will also primarily support one business line (Programming & Engagement), giving you the focus needed for you to make a real impact.
In this role, you will leverage one of the world's largest streaming data sets and cutting-edge Big Data tools and to optimize engagement on the Roku platform. In addition to designing and analyzing complex A/B tests and natural experiments, you will uncover insights that help Roku make optimal programming decisions such as what content to acquire and how to serve it up to customers. We hire individuals with a results-oriented focus, high orders of creative and analytical thinking, and excellent technical problem-solving abilities. Data Scientists do not simply execute on product roadmaps but are required to transform nebulous business opportunities into detailed and action-oriented plans that coincide with the plans of product and engineering colleagues.
Responsibilities
Quickly and methodically transform business problems into detailed and practical analytical plans
Design and analyze A/B tests
Apply appropriate methods (e.g.: propensity score matching) to make robust inferences from observational data
Apply a variety of methods (e.g.: predictive modeling, clustering, visualization) to formulate new hypothesis that suggest changes or enhancements to products or business models
Clearly communicate complex results and methods to business audiences
Use SQL, Hive and other data gathering and manipulation tools to create cleansed datasets ready for analysis
Partner with engineering and product teams to plan strategically and streamline development
Minimum Qualifications:
4+ years of experience as a data scientist in entertainment, technology, finance, or ad-tech
Entertainment industry experience preferred due to the programming nature of this role
Excellent coding ability in R, Python, Scala
Working knowledge of Big Data architecture and excellent SQL
Applicable knowledge of probability theory
Experience across a broad range of machine learning algorithms and expertise with at least a few
Experience designing control-test experiments
Academic background in math, physics, computer science, economics
Proven track record building end to end data science products
Strong communication and high-resolution view of the business context
#LI-SS1


offchaincb.rs
// File: runtime/src/offchaincb.rs
Offchain Worker Callback Example
This is a minimal example module to show case how the runtime can and should interact with an offchain worker asynchronously.
This example plays simple ping-pong with authenticated off-chain workers:
Once a signed transaction to ping
is submitted, the runtime emits the Ping
event. After every block the offchain worker is triggered. If it sees the Ping
event in the current block, it reacts by sending a signed transaction to call
pong
. When pong
is called, it emits an Ack
event so it easy to track
with existing UIs whether the Ping-Pong-Ack happened. The offchain worker does
not react on Ack
.
However, because the pong
contains trusted information (the nonce
) the runtime
can't verify by itself - the key reason why we have the offchain worker in the
first place, we can't allow just anyone to call pong
. Instead the runtime has a
local list of authorities
-keys that allowed to evoke pong
. In this simple example
this list can only be extended via a root call (e.g. sudo
). In practice more
complex management models and session based key rotations should be conidered, but
this is out of the scope of this example
Ensure we're no_std
when compiling for Wasm. Otherwise our Vec
and operations
on it will fail with invalid
.
#![cfg_attr(not(feature = "std"), no_std)]
We have to import a few things
use rstd::prelude::*;
use app_crypto::RuntimeAppPublic;
use support::{decl_module, decl_event, decl_storage, StorageValue, dispatch::Result};
use system::{ensure_signed, ensure_root};
use system::offchain::SubmitSignedTransaction;
use core::convert::TryInto;
Our local KeyType.
For security reasons the offchain worker doesn't have direct access to tohe keys
but only to app-specific subkeys, which are defined and grouped by their KeyTypeId.
We define it here as ofcb
(for offchain callback
). Yours should be specific to
the module you are actually building.
pub const KEY_TYPE: app_crypto::KeyTypeId = app_crypto::KeyTypeId(*b"ofcb");
The module's main configuration trait.
pub trait Trait: system::Trait {
The regular events type.
Extended by a few TryInto
and other traits so we can match this back
with our localised event from within the offchain worker after it was emitted.
type Event: From<Event<Self>> + Into<<Self as system::Trait>::Event> + From<<Self as system::Trait>::Event> + TryInto<Event<Self>>;
A dispatchable call type. We need to define it for the offchain worker to
reference the pong
function it wants to call.
type Call: From<Call<Self>>;
Let's define the helper we use to create signed transactions with
type SubmitTransaction: SubmitSignedTransaction<Self, <Self as Trait>::Call>;
The local keytype
type KeyType: RuntimeAppPublic + From<Self::AccountId> + Into<Self::AccountId> + Clone;
}
Then we need some events. The runtime and offchain worker can't talk to one another directly, but the runtime can emit events that the offchain worker then react upon. In
decl_event!(
pub enum Event<T> where AccountId = <T as system::Trait>::AccountId {
Emitted when someone asks us to ping
Ping(u8, AccountId),
When we received a Pong, we also Ack it.
Ack(u8, AccountId),
}
);
In this example, we only use the store to keep the list of currently authorised keys
decl_storage! {
trait Store for Module<T: Trait> as OffchainCb {
The current set of keys that may submit pongs
Authorities get(authorities): Vec<T::AccountId>;
}
}
The actual Module definition. This is where we create the callable functions
decl_module! {
pub struct Module<T: Trait> for enum Call where origin: T::Origin {
Initializing events
fn deposit_event() = default;
The entry point function: emitting a Ping
event with the given nonce
.
pub fn ping(origin, nonce: u8) -> Result {
It first ensures the function was signed, then it emits the Ping
event
with our nonce and author. Finally it results with Ok
.
let who = ensure_signed(origin)?;
Self::deposit_event(RawEvent::Ping(nonce, who));
Ok(())
}
Called from the offchain worker to respond to a ping
pub fn pong(origin, nonce: u8) -> Result {
We don't allow anyone to pong
but only those authorised in the authorities
set at this point. Therefore after ensuring this is singed, we check whether
that given author is allowed to pong
is. If so, we emit the Ack
signal,
otherwise we've just consumed their fee.
let author = ensure_signed(origin)?;
if Self::is_authority(&author) {
Self::deposit_event(RawEvent::Ack(nonce, author));
}
Ok(())
}
Runs after every block within the context and current state of said block.
fn offchain_worker(_now: T::BlockNumber) {
As pongs
are only accepted by authorities, we only run this code,
if a valid local key is found, we could submit them with.
if let Some(key) = Self::authority_id() {
Self::offchain(&key);
}
}
Simple authority management: add a new authority to the set of keys that
are allowed to respond with pong
.
pub fn add_authority(origin, who: T::AccountId) -> Result {
In practice this should be a bit cleverer, but for this example it is enough
that this is protected by a root-call (e.g. through governance like sudo
).
let _me = ensure_root(origin)?;
if !Self::is_authority(&who){
<Authorities<T>>::mutate(|l| l.push(who));
}
Ok(())
}
}
}
We've moved the helper functions outside of the main decleration for briefety.
impl<T: Trait> Module<T> {
The main entry point, called with account we are supposed to sign with
fn offchain(key: &T::AccountId) {
This iterates through all events emitted by the current block and
attempts to convert them into a local event
of this module to find
the Ping
s emitted.
Once a ping is found, we inform the user via a command line print
and emit the pong and respond by calling pong
as a transaction
signed with the given key.
This would be the place, where a regular offchain worker would go off
and do its actual thing before reponding async at a later point in time.
Note, that even though this is run directly on the same block, as we are creating a new transaction, this will only react in the following block.
for e in <system::Module<T>>::events() {
let evt: <T as Trait>::Event = e.event.into();
if let Ok(Event::<T>::Ping(nonce, _who)) = evt.try_into() {
runtime_io::print("Received ping, sending pong");
let call = Call::pong(nonce);
let _ = T::SubmitTransaction::sign_and_submit(call, key.clone().into());
}
}
}
Helper that confirms whether the given AccountId
can sign pong
transactions
fn is_authority(who: &T::AccountId) -> bool {
Self::authorities().into_iter().find(|i| i == who).is_some()
}
Find a local AccountId
we can sign with, that is allowed to pong
fn authority_id() -> Option<T::AccountId> {
Find all local keys accessible to this app through the localised KeyType.
Then go through all keys currently stored on chain and check them against
the list of local keys until a match is found, otherwise return None
.
let local_keys = T::KeyType::all().iter().map(
|i| (*i).clone().into()
).collect::<Vec<T::AccountId>>();
Self::authorities().into_iter().find_map(|authority| {
if local_keys.contains(&authority) {
Some(authority)
} else {
None
}
})
}
}
lib.rs
// File: runtime/src/lib.rs
Based off the regular Substrate Node Template runtime.
#![cfg_attr(not(feature = "std"), no_std)]
#![recursion_limit="256"]
#[cfg(feature = "std")]
include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
use rstd::prelude::*;
use primitives::{OpaqueMetadata, crypto::key_types};
use sr_primitives::{
ApplyResult, transaction_validity::TransactionValidity, generic, create_runtime_str,
impl_opaque_keys, AnySignature
};
use sr_primitives::traits::{NumberFor, BlakeTwo256, Block as BlockT, DigestFor, StaticLookup, Verify, ConvertInto, SaturatedConversion};
use sr_primitives::weights::Weight;
use babe::{AuthorityId as BabeId};
use grandpa::{AuthorityId as GrandpaId, AuthorityWeight as GrandpaWeight};
use grandpa::fg_primitives::{self, ScheduledChange};
use client::{
block_builder::api::{CheckInherentsResult, InherentData, self as block_builder_api},
runtime_api as client_api, impl_runtime_apis
};
use version::RuntimeVersion;
#[cfg(feature = "std")]
use version::NativeVersion;
#[cfg(any(feature = "std", test))]
pub use sr_primitives::BuildStorage;
pub use timestamp::Call as TimestampCall;
pub use balances::Call as BalancesCall;
pub use sr_primitives::{Permill, Perbill};
pub use support::{StorageValue, construct_runtime, parameter_types};
Additionally, we need system
here
use system::offchain::TransactionSubmitter;
Everything else is as usual
pub type BlockNumber = u32;
pub type Signature = AnySignature;
pub type AccountId = <Signature as Verify>::Signer;
pub type AccountIndex = u32;
pub type Balance = u128;
pub type Index = u32;
pub type Hash = primitives::H256;
pub type DigestItem = generic::DigestItem<Hash>;
We import our own module here.`
mod offchaincb;
pub mod opaque {
use super::*;
pub use sr_primitives::OpaqueExtrinsic as UncheckedExtrinsic;
pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
pub type Block = generic::Block<Header, UncheckedExtrinsic>;
pub type BlockId = generic::BlockId<Block>;
pub type SessionHandlers = (Grandpa, Babe);
impl_opaque_keys! {
pub struct SessionKeys {
#[id(key_types::GRANDPA)]
pub grandpa: GrandpaId,
#[id(key_types::BABE)]
pub babe: BabeId,
}
}
}
pub const VERSION: RuntimeVersion = RuntimeVersion {
spec_name: create_runtime_str!("offchain-cb"),
impl_name: create_runtime_str!("offchain-cb"),
authoring_version: 3,
spec_version: 4,
impl_version: 4,
apis: RUNTIME_API_VERSIONS,
};
pub const MILLISECS_PER_BLOCK: u64 = 6000;
pub const SLOT_DURATION: u64 = MILLISECS_PER_BLOCK;
pub const EPOCH_DURATION_IN_BLOCKS: u32 = 10 * MINUTES;
pub const MINUTES: BlockNumber = 60_000 / (MILLISECS_PER_BLOCK as BlockNumber);
pub const HOURS: BlockNumber = MINUTES * 60;
pub const DAYS: BlockNumber = HOURS * 24;
pub const PRIMARY_PROBABILITY: (u64, u64) = (1, 4);
#[cfg(feature = "std")]
pub fn native_version() -> NativeVersion {
NativeVersion {
runtime_version: VERSION,
can_author_with: Default::default(),
}
}
parameter_types! {
pub const BlockHashCount: BlockNumber = 250;
pub const MaximumBlockWeight: Weight = 1_000_000;
pub const AvailableBlockRatio: Perbill = Perbill::from_percent(75);
pub const MaximumBlockLength: u32 = 5 * 1024 * 1024;
pub const Version: RuntimeVersion = VERSION;
}
impl system::Trait for Runtime {
type AccountId = AccountId;
type Call = Call;
type Lookup = Indices;
type Index = Index;
type BlockNumber = BlockNumber;
type Hash = Hash;
type Hashing = BlakeTwo256;
type Header = generic::Header<BlockNumber, BlakeTwo256>;
type Event = Event;
type WeightMultiplierUpdate = ();
type Origin = Origin;
type BlockHashCount = BlockHashCount;
type MaximumBlockWeight = MaximumBlockWeight;
type MaximumBlockLength = MaximumBlockLength;
type AvailableBlockRatio = AvailableBlockRatio;
type Version = Version;
}
parameter_types! {
pub const EpochDuration: u64 = EPOCH_DURATION_IN_BLOCKS as u64;
pub const ExpectedBlockTime: u64 = MILLISECS_PER_BLOCK;
}
impl babe::Trait for Runtime {
type EpochDuration = EpochDuration;
type ExpectedBlockTime = ExpectedBlockTime;
}
impl grandpa::Trait for Runtime {
type Event = Event;
}
impl indices::Trait for Runtime {
type AccountIndex = u32;
type ResolveHint = indices::SimpleResolveHint<Self::AccountId, Self::AccountIndex>;
type IsDeadAccount = Balances;
type Event = Event;
}
parameter_types! {
pub const MinimumPeriod: u64 = 5000;
}
impl timestamp::Trait for Runtime {
type Moment = u64;
type OnTimestampSet = Babe;
type MinimumPeriod = MinimumPeriod;
}
parameter_types! {
pub const ExistentialDeposit: u128 = 500;
pub const TransferFee: u128 = 0;
pub const CreationFee: u128 = 0;
pub const TransactionBaseFee: u128 = 0;
pub const TransactionByteFee: u128 = 1;
}
impl balances::Trait for Runtime {
type Balance = Balance;
type OnFreeBalanceZero = ();
type OnNewAccount = Indices;
type Event = Event;
type TransactionPayment = ();
type DustRemoval = ();
type TransferPayment = ();
type ExistentialDeposit = ExistentialDeposit;
type TransferFee = TransferFee;
type CreationFee = CreationFee;
type TransactionBaseFee = TransactionBaseFee;
type TransactionByteFee = TransactionByteFee;
type WeightToFee = ConvertInto;
}
impl sudo::Trait for Runtime {
type Event = Event;
type Proposal = Call;
}
We need to define the AppCrypto for the keys that are authorized
to pong
pub mod offchaincb_crypto {
pub use crate::offchaincb::KEY_TYPE;
use primitives::sr25519;
app_crypto::app_crypto!(sr25519, KEY_TYPE);
impl From<Signature> for super::Signature {
fn from(a: Signature) -> Self {
sr25519::Signature::from(a).into()
}
}
}
We need to define the Transaction signer for that using the Key definition
type OffchainCbAccount = offchaincb_crypto::Public;
type SubmitTransaction = TransactionSubmitter<OffchainCbAccount, Runtime, UncheckedExtrinsic>;
Now we configure our Trait usng the previously defined primitives
impl offchaincb::Trait for Runtime {
type Call = Call;
type Event = Event;
type SubmitTransaction = SubmitTransaction;
type KeyType = OffchainCbAccount;
}
Lastly we also need to implement the CreateTransaction signer for the runtime
impl system::offchain::CreateTransaction<Runtime, UncheckedExtrinsic> for Runtime {
type Signature = Signature;
fn create_transaction<F: system::offchain::Signer<AccountId, Self::Signature>>(
call: Call,
account: AccountId,
index: Index,
) -> Option<(Call, <UncheckedExtrinsic as sr_primitives::traits::Extrinsic>::SignaturePayload)> {
let period = 1 << 8;
let current_block = System::block_number().saturated_into::<u64>();
let tip = 0;
let extra: SignedExtra = (
system::CheckVersion::<Runtime>::new(),
system::CheckGenesis::<Runtime>::new(),
system::CheckEra::<Runtime>::from(generic::Era::mortal(period, current_block)),
system::CheckNonce::<Runtime>::from(index),
system::CheckWeight::<Runtime>::new(),
balances::TakeFees::<Runtime>::from(tip),
);
let raw_payload = SignedPayload::new(call, extra).ok()?;
let signature = F::sign(account.clone(), &raw_payload)?;
let address = Indices::unlookup(account);
let (call, extra, _) = raw_payload.deconstruct();
Some((call, (address, signature, extra)))
}
}
Then all this can be put together
construct_runtime!(
pub enum Runtime where
Block = Block,
NodeBlock = opaque::Block,
UncheckedExtrinsic = UncheckedExtrinsic
{
System: system::{Module, Call, Storage, Config, Event},
Timestamp: timestamp::{Module, Call, Storage, Inherent},
Babe: babe::{Module, Call, Storage, Config, Inherent(Timestamp)},
Grandpa: grandpa::{Module, Call, Storage, Config, Event},
Indices: indices::{default, Config<T>},
Balances: balances,
Sudo: sudo,
Nothing special here.
OffchainCB: offchaincb::{Module, Call, Event<T>, Storage},
}
);
pub type Address = <Indices as StaticLookup>::Source;
pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
pub type Block = generic::Block<Header, UncheckedExtrinsic>;
pub type SignedBlock = generic::SignedBlock<Block>;
pub type BlockId = generic::BlockId<Block>;
pub type SignedExtra = (
system::CheckVersion<Runtime>,
system::CheckGenesis<Runtime>,
system::CheckEra<Runtime>,
system::CheckNonce<Runtime>,
system::CheckWeight<Runtime>,
balances::TakeFees<Runtime>
);
pub type UncheckedExtrinsic = generic::UncheckedExtrinsic<Address, Call, Signature, SignedExtra>;
Just that the Signature Signer needs this aditional definition as well
pub type SignedPayload = generic::SignedPayload<Call, SignedExtra>;
pub type CheckedExtrinsic = generic::CheckedExtrinsic<AccountId, Call, SignedExtra>;
pub type Executive = executive::Executive<Runtime, Block, system::ChainContext<Runtime>, Runtime, AllModules>;
impl_runtime_apis! {
impl client_api::Core<Block> for Runtime {
fn version() -> RuntimeVersion {
VERSION
}
fn execute_block(block: Block) {
Executive::execute_block(block)
}
fn initialize_block(header: &<Block as BlockT>::Header) {
Executive::initialize_block(header)
}
}
impl client_api::Metadata<Block> for Runtime {
fn metadata() -> OpaqueMetadata {
Runtime::metadata().into()
}
}
impl block_builder_api::BlockBuilder<Block> for Runtime {
fn apply_extrinsic(extrinsic: <Block as BlockT>::Extrinsic) -> ApplyResult {
Executive::apply_extrinsic(extrinsic)
}
fn finalize_block() -> <Block as BlockT>::Header {
Executive::finalize_block()
}
fn inherent_extrinsics(data: InherentData) -> Vec<<Block as BlockT>::Extrinsic> {
data.create_extrinsics()
}
fn check_inherents(block: Block, data: InherentData) -> CheckInherentsResult {
data.check_extrinsics(&block)
}
fn random_seed() -> <Block as BlockT>::Hash {
System::random_seed()
}
}
impl client_api::TaggedTransactionQueue<Block> for Runtime {
fn validate_transaction(tx: <Block as BlockT>::Extrinsic) -> TransactionValidity {
Executive::validate_transaction(tx)
}
}
This comes with new templates now, if you don't have it, you have to implement this trait in order for the Offchain Worker to be triggerd.
impl offchain_primitives::OffchainWorkerApi<Block> for Runtime {
fn offchain_worker(number: NumberFor<Block>) {
Executive::offchain_worker(number)
}
}
impl fg_primitives::GrandpaApi<Block> for Runtime {
fn grandpa_pending_change(digest: &DigestFor<Block>)
-> Option<ScheduledChange<NumberFor<Block>>>
{
Grandpa::pending_change(digest)
}
fn grandpa_forced_change(digest: &DigestFor<Block>)
-> Option<(NumberFor<Block>, ScheduledChange<NumberFor<Block>>)>
{
Grandpa::forced_change(digest)
}
fn grandpa_authorities() -> Vec<(GrandpaId, GrandpaWeight)> {
Grandpa::grandpa_authorities()
}
}
impl babe_primitives::BabeApi<Block> for Runtime {
fn startup_data() -> babe_primitives::BabeConfiguration {
babe_primitives::BabeConfiguration {
median_required_blocks: 1000,
slot_duration: Babe::slot_duration(),
c: PRIMARY_PROBABILITY,
}
}
fn epoch() -> babe_primitives::Epoch {
babe_primitives::Epoch {
start_slot: Babe::epoch_start_slot(),
authorities: Babe::authorities(),
epoch_index: Babe::epoch_index(),
randomness: Babe::randomness(),
duration: EpochDuration::get(),
secondary_slots: Babe::secondary_slots().0,
}
}
}
impl substrate_session::SessionKeys<Block> for Runtime {
fn generate_session_keys(seed: Option<Vec<u8>>) -> Vec<u8> {
let seed = seed.as_ref().map(|s| rstd::str::from_utf8(&s).expect("Seed is an utf8 string"));
opaque::SessionKeys::generate(seed)
}
}
}


1. Generate monthly bar plot of crimes
2. Most/Least Populous Neighbourhoods
3. Crime Count in neighbourhoods
4. Highest Crime/Population ratio


Name
Email
Date
Select a day
Watch Now Instantly
Watch Later Today
Tue, March 10, 2020
Wed, March 11, 2020
Thu, March 12, 2020
Time
Select a time
RESERVE MY SPOT NOW


|
|---|
| Now we beseech you, brethren, by the coming of our Lord Jesus Christ, and by our gathering together unto him,
|
|---|
| ᎾᏍᎩᏃ, ᎢᏓᎵᏅᏟ, ᎢᏨᏔᏲᏎᎭ ᎤᎷᎯᏍᏗ ᎨᏒ ᎢᎦᏤᎵ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ, ᎠᎴ ᎾᏍᎩ ᏪᏓᏓᏟᏌᏁᏗ ᎨᏒ ᎤᎬᏩᎵ,
|
|---|
Na-s-gi-no, i-da-li-nv-tli, i-tsv-ta-yo-se-ha u-lu-hi-s-di ge-sv i-ga-tse-li U-gv-wi-yu-hi Tsi-sa Ga-lo-ne-dv, a-le na-s-gi we-da-da-tli-sa-ne-di ge-sv u-gv-wa-li,
|
|---|
|
|---|
| That ye be not soon shaken in mind, or be troubled, neither by spirit, nor by word, nor by letter as from us, as that the day of Christ is at hand.
|
|---|
| ᎾᏍᎩ ᏞᎩᏉ ᏤᏥᏖᎸᎾᏗᏱ ᏂᎨᏒᎾ ᏕᏣᏓᏅᏛᎢ, ᎠᎴ ᎢᏣᏕᏯᏔᏁᏗᏱ ᏂᎨᏒᎾ, ᎾᏍᏉ ᎠᏓᏅᏙ ᎬᏗ, ᎠᎴ ᎦᏬᏂᏒᎯ, ᎠᎴ ᎪᏪᎵ ᎪᏪᎳᏅᎯ ᎬᏗ ᎠᏴ ᎣᎦᏓᏅᏏᏛ ᏥᎨᏐ ᎢᏳᏍᏗ; ᎾᏍᎩ ᎦᎶᏁᏛ ᎤᏤᎵ ᎢᎦ ᎤᏍᏆᎸᎯᏕᏅ ᏥᎨᏐ ᎾᏍᎩᏯᎢ.
|
|---|
Na-s-gi tle-gi-quo tse-tsi-te-lv-na-di-yi ni-ge-sv-na de-tsa-da-nv-dv-i, a-le i-tsa-de-ya-ta-ne-di-yi ni-ge-sv-na, na-s-quo a-da-nv-do gv-di, a-le ga-wo-ni-sv-hi, a-le go-we-li go-we-la-nv-hi gv-di a-yv o-ga-da-nv-si-dv tsi-ge-so i-yu-s-di; na-s-gi Ga-lo-ne-dv u-tse-li i-ga u-s-qua-lv-hi-de-nv tsi-ge-so na-s-gi-ya-i.
|
|---|
|
|---|
| Let no man deceive you by any means: for that day shall not come, except there come a falling away first, and that man of sin be revealed, the son of perdition;
|
|---|
| ᎠᏎ ᏞᏍᏗ ᎩᎶ ᏱᏥᎵᏓᏍᏔᏁᏍᏗ; ᎥᏝᏰᏃ [ᎾᎯᏳ ᎢᎦ ᎤᎵᏰᎢᎶᎯᏍᏗ ᏱᎩ] ᎬᏂ ᎢᎬᏱ ᎠᏂᏑᎵᎪᎨᏍᏗ, ᎠᎴ ᎾᏍᎩ Ꮎ ᎠᏍᎦᏯ ᎠᏍᎦᎾ ᏧᎸᏫᏍᏓᏁᎯ ᎬᏂᎨᏒ ᎾᎬᏁᎸᎭ, ᎾᏍᎩ ᎠᏛᏗᏍᎩ ᎤᏪᏥ;
|
|---|
A-se tle-s-di gi-lo yi-tsi-li-da-s-ta-ne-s-di; v-tla-ye-no [na-hi-yu i-ga u-li-ye-i-lo-hi-s-di yi-gi] gv-ni i-gv-yi a-ni-su-li-go-ge-s-di, a-le na-s-gi na a-s-ga-ya a-s-ga-na tsu-lv-wi-s-da-ne-hi gv-ni-ge-sv na-gv-ne-lv-ha, na-s-gi a-dv-di-s-gi u-we-tsi;
|
|---|
|
|---|
| Who opposeth and exalteth himself above all that is called God, or that is worshipped; so that he as God sitteth in the temple of God, shewing himself that he is God.
|
|---|
| ᎾᏍᎩ ᏥᏓᎦᏘᎴᎦ ᎠᎴ ᎦᎸᎳᏗᏢ ᏥᎾᏓᏛᏁᎭ ᏂᎦᎥ ᎤᏁᎳᏅᎯ ᎨᎪᏎᏗ ᏥᎩ, ᎠᎴ ᎨᎦᏓᏙᎵᏍᏓᏁᎯ ᏥᎩ; ᎾᏍᎩ ᎢᏳᏍᏗ ᎤᏁᎳᏅᎯ ᎾᏍᎩᏯ ᎤᏬᎳ ᎤᏁᎳᏅᎯ ᎤᏤᎵ ᎠᏓᏁᎸᎢ, ᎤᏩᏒ ᎬᏂᎨᏒ ᎾᏓᏛᏁᎭ ᎤᏁᎳᏅᎯ ᎨᏒᎢ.
|
|---|
Na-s-gi tsi-da-ga-ti-le-ga a-le ga-lv-la-di-tlv tsi-na-da-dv-ne-ha ni-ga-v U-ne-la-nv-hi ge-go-se-di tsi-gi, a-le ge-ga-da-do-li-s-da-ne-hi tsi-gi; na-s-gi i-yu-s-di U-ne-la-nv-hi na-s-gi-ya u-wo-la U-ne-la-nv-hi u-tse-li a-da-ne-lv-i, u-wa-sv gv-ni-ge-sv na-da-dv-ne-ha U-ne-la-nv-hi ge-sv-i.
|
|---|
|
|---|
| Remember ye not, that, when I was yet with you, I told you these things?
|
|---|
| ᏝᏍᎪ ᏱᏣᏅᏔ, ᎾᏍᎩ ᎠᏏ ᏥᏨᏰᎳᏗᏙᎲᎩ ᎾᏍᎩ ᎯᎠ ᎢᏨᏃᎮᎮᎸᎢ?
|
|---|
Tla-s-go yi-tsa-nv-ta, na-s-gi a-si tsi-tsv-ye-la-di-do-hv-gi na-s-gi hi-a i-tsv-no-he-he-lv-i?
|
|---|
|
|---|
| And now ye know what withholdeth that he might be revealed in his time.
|
|---|
| ᎪᎯᏃ ᏥᎩ ᎢᏗᎦᏔᎭ ᎢᏳᏍᏗ ᎠᏲᏍᏙᏗᏍᎬ ᎬᏂᎨᏒ ᎢᏯᎬᏁᏗᏱ ᎾᎯᏳ ᎬᏂᎨᏒ ᎢᏯᎬᏁᏗ ᎨᏒᎢ.
|
|---|
Go-hi-no tsi-gi i-di-ga-ta-ha i-yu-s-di a-yo-s-do-di-s-gv gv-ni-ge-sv i-ya-gv-ne-di-yi na-hi-yu gv-ni-ge-sv i-ya-gv-ne-di ge-sv-i.
|
|---|
|
|---|
| For the mystery of iniquity doth already work: only he who now letteth will let, until he be taken out of the way.
|
|---|
| ᎤᏕᎵᏛᏰᏃ ᎠᏍᎦᎾ ᎦᏳᎳ ᏚᎸᏫᏍᏓᏁᎭ; ᎪᎯᏍᎩᏂ ᎨᏒ ᎠᏲᏍᏙᏗᏍᎩ ᏥᎩ ᎤᏲᏍᏙᏓᏁᎮᏍᏗ ᎬᏂ ᎠᏥᎧᎲᏒᎭ.
|
|---|
U-de-li-dv-ye-no a-s-ga-na ga-yu-la du-lv-wi-s-da-ne-ha; go-hi-s-gi-ni ge-sv a-yo-s-do-di-s-gi tsi-gi u-yo-s-do-da-ne-he-s-di gv-ni a-tsi-ka-hv-sv-ha.
|
|---|
|
|---|
| And then shall that Wicked be revealed, whom the Lord shall consume with the spirit of his mouth, and shall destroy with the brightness of his coming:
|
|---|
| ᎾᎯᏳᏃ ᎾᏍᎩ Ꮎ ᎠᏍᎦᎾ ᎬᏂᎨᏒ ᏅᏓᏰᎬᏁᎵ, ᎾᏍᎩ ᎤᎬᏫᏳᎯ ᏨᏛᏛᏔᏂ ᎠᏓᏅᏙ ᎠᎰᎵ ᏅᏓᏳᏓᎴᏅᎯ ᎬᏗ, ᎠᎴ ᏨᏛᏛᏔᏂ ᏓᎬᏔᏂ ᎬᏂᎨᏒ ᎾᎬᏁᎲ ᎾᎯᏳ ᎦᎷᏨᎭ;
|
|---|
Na-hi-yu-no na-s-gi na a-s-ga-na gv-ni-ge-sv nv-da-ye-gv-ne-li, na-s-gi U-gv-wi-yu-hi tsv-dv-dv-ta-ni a-da-nv-do a-ho-li nv-da-yu-da-le-nv-hi gv-di, a-le tsv-dv-dv-ta-ni da-gv-ta-ni gv-ni-ge-sv na-gv-ne-hv na-hi-yu ga-lu-tsv-ha;
|
|---|
|
|---|
| Even him, whose coming is after the working of Satan with all power and signs and lying wonders,
|
|---|
| ᎾᏍᎩ Ꮎ ᎤᎷᎯᏍᏗ ᎨᏒ ᎾᏍᎩᏯ ᏎᏓᏂ ᏧᎸᏫᏍᏓᏁᏗ ᏚᎸᏫᏍᏓᏁᎮᏍᏗ ᎬᏗᏍᎨᏍᏗ ᎤᏣᏘ ᎤᎵᏂᎩᏛ ᎨᏒᎢ, ᎠᎴ ᎤᏍᏆᏂᎪᏗ ᎠᎴ ᎦᏰᎪᎩ ᎤᏰᎸᏛᎢ,
|
|---|
Na-s-gi na u-lu-hi-s-di ge-sv na-s-gi-ya Se-da-ni tsu-lv-wi-s-da-ne-di du-lv-wi-s-da-ne-he-s-di gv-di-s-ge-s-di u-tsa-ti u-li-ni-gi-dv ge-sv-i, a-le u-s-qua-ni-go-di a-le ga-ye-go-gi u-ye-lv-dv-i,
|
|---|
|
|---|
| And with all deceivableness of unrighteousness in them that perish; because they received not the love of the truth, that they might be saved.
|
|---|
| ᎠᎴ ᎬᏗᏍᎨᏍᏗ ᎤᏣᏘ ᎤᏓᎵᏓᏍᏗ ᏂᏚᏳᎪᏛᎾ ᎨᏒ ᎠᏁᎲ ᎾᏍᎩ ᎨᏥᏛᏙᏗ ᎨᏒᎢ; ᏅᏗᎦᎵᏍᏙᏗᏍᎬ ᏂᏚᎾᏓᏂᎸᏨᎾ ᎨᏒ ᏚᏳᎪᏛ ᎠᎨᏳᏗ ᎨᏒᎢ, ᎾᏍᎩ ᎦᎨᏥᏍᏕᎸᏗ ᎢᏳᎵᏍᏙᏗᏱ.
|
|---|
A-le gv-di-s-ge-s-di u-tsa-ti u-da-li-da-s-di ni-du-yu-go-dv-na ge-sv a-ne-hv na-s-gi ge-tsi-dv-do-di ge-sv-i; nv-di-ga-li-s-do-di-s-gv ni-du-na-da-ni-lv-tsv-na ge-sv du-yu-go-dv a-ge-yu-di ge-sv-i, na-s-gi ga-ge-tsi-s-de-lv-di i-yu-li-s-do-di-yi.
|
|---|
|
|---|
| And for this cause God shall send them strong delusion, that they should believe a lie:
|
|---|
| ᎠᎴ ᎾᏍᎩ ᎢᏳᏍᏗ ᎤᏁᎳᏅᎯ ᎤᏓᏅᏍᏗ ᎨᏎᏍᏗ ᎤᏂᎷᏤᏗᏱ ᎤᎵᏂᎩᏛ ᎤᏂᎶᏄᎮᏍᎩ ᎾᏍᎩ ᎢᏳᏩᏂᏐᏗ ᎤᏃᎯᏳᏗᏱ ᎦᏰᎪᎩ ᎨᏒᎢ;
|
|---|
A-le na-s-gi i-yu-s-di U-ne-la-nv-hi u-da-nv-s-di ge-se-s-di u-ni-lu-tse-di-yi u-li-ni-gi-dv u-ni-lo-nu-he-s-gi na-s-gi i-yu-wa-ni-so-di u-no-hi-yu-di-yi ga-ye-go-gi ge-sv-i;
|
|---|
|
|---|
| That they all might be damned who believed not the truth, but had pleasure in unrighteousness.
|
|---|
| ᎾᏍᎩ ᏗᎬᏩᎾᏚᎪᏓᏁᏗ ᎢᏳᎵᏍᏙᏗᏱ ᎾᏂᎥ ᎾᏍᎩ Ꮎ ᎾᏃᎯᏳᎲᏍᎬᎾ ᏚᏳᎪᏛ ᎨᏒᎢ, ᏂᏚᏳᎪᏛᎾᏍᎩᏂ ᎨᏒ ᎠᏃᎯᏳᎲᏍᎩ.
|
|---|
na-s-gi di-gv-wa-na-du-go-da-ne-di i-yu-li-s-do-di-yi na-ni-v na-s-gi na na-no-hi-yu-hv-s-gv-na du-yu-go-dv ge-sv-i, ni-du-yu-go-dv-na-s-gi-ni ge-sv a-no-hi-yu-hv-s-gi.
|
|---|
|
|---|
| But we are bound to give thanks alway to God for you, brethren beloved of the Lord, because God hath from the beginning chosen you to salvation through sanctification of the Spirit and belief of the truth:
|
|---|
| ᎠᏎᏃ ᎣᎦᏚᏓᎳ ᏂᎪᎯᎸ ᎣᏣᎵᎡᎵᏤᏗᏱ ᎤᏁᎳᏅᎯ ᏂᎯ ᎨᏒ ᎤᎬᏩᎵ, ᎢᏓᎵᏅᏟ ᎤᎬᏫᏳᎯ ᎢᏥᎨᏳᎯ, ᏅᏗᎦᎵᏍᏙᏗᎭ ᎤᏁᎳᏅᎯ ᏧᏓᎴᏅᎲ ᏅᏓᎬᏩᏓᎴᏅᏛ ᎢᏣᏑᏰᏒ ᎡᏥᏍᏕᎸᏗᏱ ᎬᏙᏗᏱ ᎠᏓᏅᏙ ᎢᏥᏅᎦᎵᏍᎬᎢ, ᎠᎴ ᎢᏦᎯᏳᏒ ᎤᏙᎯᏳᎯ ᎨᏒᎢ;
|
|---|
A-se-no o-ga-du-da-la ni-go-hi-lv o-tsa-li-e-li-tse-di-yi U-ne-la-nv-hi ni-hi ge-sv u-gv-wa-li, i-da-li-nv-tli U-gv-wi-yu-hi i-tsi-ge-yu-hi, nv-di-ga-li-s-do-di-ha U-ne-la-nv-hi tsu-da-le-nv-hv nv-da-gv-wa-da-le-nv-dv i-tsa-su-ye-sv e-tsi-s-de-lv-di-yi gv-do-di-yi A-da-nv-do i-tsi-nv-ga-li-s-gv-i, a-le i-tso-hi-yu-sv u-do-hi-yu-hi ge-sv-i;
|
|---|
|
|---|
| Whereunto he called you by our gospel, to the obtaining of the glory of our Lord Jesus Christ.
|
|---|
| ᎾᎿᎭᏥᏕᏲᎧᏅ ᎣᏍᏛ ᎧᏃᎮᏛ ᎣᎦᏤᎵ ᏥᏥᏯᏅᏔᏅ, ᎢᏥᏩᏛᏗᏱ ᎦᎸᏉᏗᏳ ᎨᏒ ᎢᎦᏤᎵ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ ᎤᏤᎵᎦ.
|
|---|
Na-hna tsi-de-yo-ka-nv o-s-dv ka-no-he-dv o-ga-tse-li tsi-tsi-ya-nv-ta-nv, i-tsi-wa-dv-di-yi ga-lv-quo-di-yu ge-sv i-ga-tse-li U-gv-wi-yu-hi Tsi-sa Ga-lo-ne-dv u-tse-li-ga.
|
|---|
|
|---|
| Therefore, brethren, stand fast, and hold the traditions which ye have been taught, whether by word, or our epistle.
|
|---|
| ᎾᏍᎩ ᎢᏳᏍᏗ, ᎢᏓᎵᏅᏟ, ᎤᎵᏂᎩᏛ ᏕᏥᏙᎨᏍᏗ, ᎠᎴ ᏕᏥᏂᏴᏎᏍᏗ ᏗᏕᏲᏗ ᎨᏒ ᎾᏍᎩ ᏄᏍᏛ ᎡᏤᏲᏅᎢ, ᎾᏍᏉ ᎦᏬᏂᏒᎯᏉ ᏱᎩ, ᎠᎴ ᏫᏨᏲᏪᎳᏁᎸᎯ ᏱᎩ.
|
|---|
Na-s-gi i-yu-s-di, i-da-li-nv-tli, u-li-ni-gi-dv de-tsi-do-ge-s-di, a-le de-tsi-ni-yv-se-s-di di-de-yo-di ge-sv na-s-gi nu-s-dv e-tse-yo-nv-i, na-s-quo ga-wo-ni-sv-hi-quo yi-gi, a-le wi-tsv-yo-we-la-ne-lv-hi yi-gi.
|
|---|
|
|---|
| Now our Lord Jesus Christ himself, and God, even our Father, which hath loved us, and hath given us everlasting consolation and good hope through grace,
|
|---|
| ᎾᏍᎩᏃ ᎢᎦᏤᎵ ᎤᎬᏫᏳᎯ ᏥᏌ ᎦᎶᏁᏛ ᎤᏩᏒ, ᎠᎴ ᎤᏁᎳᏅᎯ, ᎾᏍᎩ ᎢᎩᏙᏓ, ᎾᏍᎩ ᎢᎩᎨᏳᎯᏳ ᏥᎨᏒᎩ, ᎠᎴ ᏥᎩᏁᎸ ᎤᎵᏍᏆᏗᏍᏗ ᏂᎨᏒᎾ ᎠᏓᎦᎵᏍᏓᏗᏍᎩ, ᎠᎴ ᎣᏍᏛ ᎤᏚᎩ ᎬᏗ ᎨᏒ ᏅᏓᏳᏓᎴᏅᎯ ᎬᏩᎦᏘᏯ ᎤᏓᏙᎵᏍᏗ ᎨᏒᎢ,
|
|---|
Na-s-gi-no i-ga-tse-li U-gv-wi-yu-hi Tsi-sa Ga-lo-ne-dv u-wa-sv, a-le U-ne-la-nv-hi, na-s-gi I-gi-do-da, na-s-gi i-gi-ge-yu-hi-yu tsi-ge-sv-gi, a-le tsi-gi-ne-lv u-li-s-qua-di-s-di ni-ge-sv-na a-da-ga-li-s-da-di-s-gi, a-le o-s-dv u-du-gi gv-di ge-sv nv-da-yu-da-le-nv-hi gv-wa-ga-ti-ya u-da-do-li-s-di ge-sv-i,
|
|---|
|
|---|
| Comfort your hearts, and stablish you in every good word and work.
|
|---|
| ᎾᏍᎩ ᏗᏥᎦᎵᏍᏓᏕᏗ ᎨᏎᏍᏗ ᏗᏥᎾᏫ, ᎠᎴ ᏗᏣᎵᏂᎪᎯᏍᏙᏗ ᎨᏎᏍᏗ ᏂᎦᎥ ᎣᏍᏛ ᎨᏒ ᎢᏥᏬᏂᎯᏍᏗᏱ ᎠᎴ ᏗᏥᎸᏫᏍᏓᏁᏗᏱ.
|
|---|
Na-s-gi di-tsi-ga-li-s-da-de-di ge-se-s-di di-tsi-na-wi, a-le di-tsa-li-ni-go-hi-s-do-di ge-se-s-di ni-ga-v o-s-dv ge-sv i-tsi-wo-ni-hi-s-di-yi a-le di-tsi-lv-wi-s-da-ne-di-yi.
|
|---|


{% extends "layout_multi_sections.html" %} {% block page_title %} Events {% endblock %} {% block css_register %} {% endblock %} {% block main_nav %} {% include "townhall/includes/main_nav.html" %} {% endblock %} {% block header %}
Buy tickets online for events. This service is facilitated by Tickets.com and uses the TicketSafe TM security system which ensures that your credit card details are protected.
Please note a booking fee of £1 per ticket applies to music and
comedy events except for the Town Hall Tours where the fee will be 75p
per ticket.
There are some tickets that you can only book through the Box Office on +44 (0)113 224 3801. These include:
■ Subscriptions and season savers
■ Tickets for groups of 10 or more
■ Tickets for wheelchair users
+44(0)<PHONE_NUMBER>
The booking line is open from 10am to 6pm Monday to Saturday.
Please note that a fee of £2.50 will apply per transaction for all events except film screenings and tours where the fee will be £1 per transaction
Please note: under 16s must be accompanied by an adult for all events.
City Centre Box Office, The Carriageworks, The Electric Press, 3 Millennium Square, Leeds, LS2 3AD
The Box Office is open to personal callers from 10am to 6pm Monday - Saturday.
The City Centre Box Office accepts bookings by most credit/debit cards. Cheques should be made payable to Leeds City Council. There is a £1 charge to cover postage of tickets. Alternatively, please enclose a stamped addressed envelope.
Discounted tickets are available for selected performances for students, over 60s, unwaged and under 18s. Please check with the Box Office on +44 (0)113 376 0318 for discounts applicable to your chosen event.
For the Leeds International Orchestral Season patrons with
disabilities and their essential carers may obtain two tickets for the
price of one via the Essential Carer Scheme. Relevant documentation must
be produced to prove eligibility for the scheme.
For further
information and to apply, please download the Essential Carer Scheme
document or alternatively contact the Box Office on +44 (0)113 376 0318 and a form can be posted out to you. Unfortunately our online sales
software doesn't currently support the option to purchase discounted
tickets online.
Leeds International Orchestral Season discounts
Over 60s: £1.50 reduction on all non-subscription tickets.
Under 18s, Full-time Students: 50% reduction on all tickets.
Unwaged: 50% reduction on all non-subscription tickets.
Our online sales software doesn't currently support the option to choose wheelchair spaces, however, the Box Office will be happy to advise you on seating options. Please call +44 (0)113 376 0318.
Substantial savings can be made by subscribing to the Leeds International Orchestral Season. The subscription scheme is the easy way to organise your concert-going, enabling you to choose the concerts you would like to attend and save money.
25% discount when you book for all 20 concerts
20% discount when you book between 10-19 concerts of your choice
15% discount when you book between 5 and 9 concerts of your choice
By subscribing to as few as five concerts you can:
For further information on subscriptions please contact the Box Office on +44 (0)113 376 0318.
View the interactive seating plan of Leeds Town Hall


andythewhale
<EMAIL_ADDRESS>I'm Andy. This is a blog about weird stuff. It'll eventually be about programming.
Read More
Posts
May 26, 2017
life and projects
May 15, 2017
hey, this is my first time posting with you guys
subscribe
via RSS


source file: /Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/botocore/waiter.py
file stats: 176 lines, 32 executed: 18.2% covered
1. # Copyright 2012-2014 Amazon.com, Inc. or its affiliates. All Rights Reserved. 2. # 3. # Licensed under the Apache License, Version 2.0 (the "License"). You 4. # may not use this file except in compliance with the License. A copy of 5. # the License is located at 6. # 7. # http://aws.amazon.com/apache2.0/ 8. # 9. # or in the "license" file accompanying this file. This file is 10. # distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF 11. # ANY KIND, either express or implied. See the License for the specific 12. # language governing permissions and limitations under the License. 13. import jmespath 14. import logging 15. import time 16. 17. from botocore.utils import get_service_module_name 18. from botocore.docs.docstring import WaiterDocstring 19. from .exceptions import WaiterError, ClientError, WaiterConfigError 20. from . import xform_name 21. 22. 23. logger = logging.getLogger(__name__) 24. 25. 26. def create_waiter_with_client(waiter_name, waiter_model, client): 27. """ 28. 29. :type waiter_name: str 30. :param waiter_name: The name of the waiter. The name should match 31. the name (including the casing) of the key name in the waiter 32. model file (typically this is CamelCasing). 33. 34. :type waiter_model: botocore.waiter.WaiterModel 35. :param waiter_model: The model for the waiter configuration. 36. 37. :type client: botocore.client.BaseClient 38. :param client: The botocore client associated with the service. 39. 40. :rtype: botocore.waiter.Waiter 41. :return: The waiter object. 42. 43. """ 44. single_waiter_config = waiter_model.get_waiter(waiter_name) 45. operation_name = xform_name(single_waiter_config.operation) 46. operation_method = NormalizedOperationMethod( 47. getattr(client, operation_name)) 48. 49. # Create a new wait method that will serve as a proxy to the underlying 50. # Waiter.wait method. This is needed to attach a docstring to the 51. # method. 52. def wait(self, **kwargs): 53. Waiter.wait(self, **kwargs) 54. 55. wait.__doc__ = WaiterDocstring( 56. waiter_name=waiter_name, 57. event_emitter=client.meta.events, 58. service_model=client.meta.service_model, 59. service_waiter_model=waiter_model, 60. include_signature=False 61. ) 62. 63. # Rename the waiter class based on the type of waiter. 64. waiter_class_name = str('%s.Waiter.%s' % ( 65. get_service_module_name(client.meta.service_model), 66. waiter_name)) 67. 68. # Create the new waiter class 69. documented_waiter_cls = type( 70. waiter_class_name, (Waiter,), {'wait': wait}) 71. 72. # Return an instance of the new waiter class. 73. return documented_waiter_cls( 74. waiter_name, single_waiter_config, operation_method 75. ) 76. 77. 78. class NormalizedOperationMethod(object): 79. def __init__(self, client_method): 80. self._client_method = client_method 81. 82. def __call__(self, **kwargs): 83. try: 84. return self._client_method(**kwargs) 85. except ClientError as e: 86. return e.response 87. 88. 89. class WaiterModel(object): 90. SUPPORTED_VERSION = 2 91. 92. def __init__(self, waiter_config): 93. """ 94. 95. Note that the WaiterModel takes ownership of the waiter_config. 96. It may or may not mutate the waiter_config. If this is a concern, 97. it is best to make a copy of the waiter config before passing it to 98. the WaiterModel. 99. 100. :type waiter_config: dict 101. :param waiter_config: The loaded waiter config 102. from the <service>*.waiters.json file. This can be 103. obtained from a botocore Loader object as well. 104. 105. """ 106. self._waiter_config = waiter_config['waiters'] 107. 108. # These are part of the public API. Changing these 109. # will result in having to update the consuming code, 110. # so don't change unless you really need to. 111. version = waiter_config.get('version', 'unknown') 112. self._verify_supported_version(version) 113. self.version = version 114. self.waiter_names = list(sorted(waiter_config['waiters'].keys())) 115. 116. def _verify_supported_version(self, version): 117. if version != self.SUPPORTED_VERSION: 118. raise WaiterConfigError( 119. error_msg=("Unsupported waiter version, supported version " 120. "must be: %s, but version of waiter config " 121. "is: %s" % (self.SUPPORTED_VERSION, 122. version))) 123. 124. def get_waiter(self, waiter_name): 125. try: 126. single_waiter_config = self._waiter_config[waiter_name] 127. except KeyError: 128. raise ValueError("Waiter does not exist: %s" % waiter_name) 129. return SingleWaiterConfig(single_waiter_config) 130. 131. 132. class SingleWaiterConfig(object): 133. """Represents the waiter configuration for a single waiter. 134. 135. A single waiter is considered the configuration for a single 136. value associated with a named waiter (i.e TableExists). 137. 138. """ 139. def __init__(self, single_waiter_config): 140. self._config = single_waiter_config 141. 142. # These attributes are part of the public API. 143. self.description = single_waiter_config.get('description', '') 144. # Per the spec, these three fields are required. 145. self.operation = single_waiter_config['operation'] 146. self.delay = single_waiter_config['delay'] 147. self.max_attempts = single_waiter_config['maxAttempts'] 148. 149. @property 150. def acceptors(self): 151. acceptors = [] 152. for acceptor_config in self._config['acceptors']: 153. acceptor = AcceptorConfig(acceptor_config) 154. acceptors.append(acceptor) 155. return acceptors 156. 157. 158. class AcceptorConfig(object): 159. def __init__(self, config): 160. self.state = config['state'] 161. self.matcher = config['matcher'] 162. self.expected = config['expected'] 163. self.argument = config.get('argument') 164. self.matcher_func = self._create_matcher_func() 165. 166. def _create_matcher_func(self): 167. # An acceptor function is a callable that takes a single value. The 168. # parsed AWS response. Note that the parsed error response is also 169. # provided in the case of errors, so it's entirely possible to 170. # handle all the available matcher capabilities in the future. 171. # There's only three supported matchers, so for now, this is all 172. # contained to a single method. If this grows, we can expand this 173. # out to separate methods or even objects. 174. 175. if self.matcher == 'path': 176. return self._create_path_matcher() 177. elif self.matcher == 'pathAll': 178. return self._create_path_all_matcher() 179. elif self.matcher == 'pathAny': 180. return self._create_path_any_matcher() 181. elif self.matcher == 'status': 182. return self._create_status_matcher() 183. elif self.matcher == 'error': 184. return self._create_error_matcher() 185. else: 186. raise WaiterConfigError( 187. error_msg="Unknown acceptor: %s" % self.matcher) 188. 189. def _create_path_matcher(self): 190. expression = jmespath.compile(self.argument) 191. expected = self.expected 192. 193. def acceptor_matches(response): 194. if 'Error' in response: 195. return 196. return expression.search(response) == expected 197. return acceptor_matches 198. 199. def _create_path_all_matcher(self): 200. expression = jmespath.compile(self.argument) 201. expected = self.expected 202. 203. def acceptor_matches(response): 204. if 'Error' in response: 205. return 206. result = expression.search(response) 207. if not isinstance(result, list) or not result: 208. # pathAll matcher must result in a list. 209. # Also we require at least one element in the list, 210. # that is, an empty list should not result in this 211. # acceptor match. 212. return False 213. for element in result: 214. if element != expected: 215. return False 216. return True 217. return acceptor_matches 218. 219. def _create_path_any_matcher(self): 220. expression = jmespath.compile(self.argument) 221. expected = self.expected 222. 223. def acceptor_matches(response): 224. if 'Error' in response: 225. return 226. result = expression.search(response) 227. if not isinstance(result, list) or not result: 228. # pathAny matcher must result in a list. 229. # Also we require at least one element in the list, 230. # that is, an empty list should not result in this 231. # acceptor match. 232. return False 233. for element in result: 234. if element == expected: 235. return True 236. return False 237. return acceptor_matches 238. 239. def _create_status_matcher(self): 240. expected = self.expected 241. 242. def acceptor_matches(response): 243. # We don't have any requirements on the expected incoming data 244. # other than it is a dict, so we don't assume there's 245. # a ResponseMetadata.HTTPStatusCode. 246. status_code = response.get('ResponseMetadata', {}).get( 247. 'HTTPStatusCode') 248. return status_code == expected 249. return acceptor_matches 250. 251. def _create_error_matcher(self): 252. expected = self.expected 253. 254. def acceptor_matches(response): 255. # When the client encounters an error, it will normally raise 256. # an exception. However, the waiter implementation will catch 257. # this exception, and instead send us the parsed error 258. # response. So response is still a dictionary, and in the case 259. # of an error response will contain the "Error" and 260. # "ResponseMetadata" key. 261. return response.get("Error", {}).get("Code", "") == expected 262. return acceptor_matches 263. 264. 265. class Waiter(object): 266. def __init__(self, name, config, operation_method): 267. """ 268. 269. :type name: string 270. :param name: The name of the waiter 271. 272. :type config: botocore.waiter.SingleWaiterConfig 273. :param config: The configuration for the waiter. 274. 275. :type operation_method: callable 276. :param operation_method: A callable that accepts **kwargs 277. and returns a response. For example, this can be 278. a method from a botocore client. 279. 280. """ 281. self._operation_method = operation_method 282. # The two attributes are exposed to allow for introspection 283. # and documentation. 284. self.name = name 285. self.config = config 286. 287. def wait(self, **kwargs): 288. acceptors = list(self.config.acceptors) 289. current_state = 'waiting' 290. # pop the invocation specific config 291. config = kwargs.pop('WaiterConfig', {}) 292. sleep_amount = config.get('Delay', self.config.delay) 293. max_attempts = config.get('MaxAttempts', self.config.max_attempts) 294. num_attempts = 0 295. 296. while True: 297. response = self._operation_method(**kwargs) 298. num_attempts += 1 299. for acceptor in acceptors: 300. if acceptor.matcher_func(response): 301. current_state = acceptor.state 302. break 303. else: 304. # If none of the acceptors matched, we should 305. # transition to the failure state if an error 306. # response was received. 307. if 'Error' in response: 308. # Transition to a failure state, which we 309. # can just handle here by raising an exception. 310. raise WaiterError( 311. name=self.name, 312. reason=response['Error'].get('Message', 'Unknown'), 313. last_response=response 314. ) 315. if current_state == 'success': 316. logger.debug("Waiting complete, waiter matched the " 317. "success state.") 318. return 319. if current_state == 'failure': 320. raise WaiterError( 321. name=self.name, 322. reason='Waiter encountered a terminal failure state', 323. last_response=response, 324. ) 325. if num_attempts >= max_attempts: 326. raise WaiterError( 327. name=self.name, 328. reason='Max attempts exceeded', 329. last_response=response 330. ) 331. time.sleep(sleep_amount)


dist_proto.base_dist_protocol module¶
Base abstract Distribution connection class
-
class
pyrlang.dist_proto.base_dist_protocol.
BaseDistProtocol
(node_name: str)¶ Bases:
asyncio.protocols.Protocol
Defines Erlang distribution protocol (shared parts). Concrete implementations for incoming (DistServerProtocol) and outgoing (DistClientProtocol) are located in the corresponding modules.
-
ALIVE
= 'alive'¶
-
CONNECTED
= 'conn'¶
-
DISCONNECTED
= 'disconn'¶
-
RECV_CHALLENGE
= 'recv_challenge'¶
-
RECV_CHALLENGE_ACK
= 'recv_challenge_ack'¶
-
RECV_NAME
= 'recvname'¶
-
RECV_STATUS
= 'recv_status'¶
-
WAIT_CHALLENGE_REPLY
= 'wait_ch_reply'¶
-
static
check_digest
(digest: bytes, challenge: int, cookie: str) → bool¶ Hash cookie + the challenge together producing a verification hash and return if they match against the offered 'digest'.
-
connection_lost
(_exc)¶ Handler is called when the client has disconnected
-
connection_made
(transport: asyncio.transports.Transport)¶ Connection has been accepted and established (callback).
-
data_received
(data: bytes) → None¶ Called when some data is received.
The argument is a bytes object.
-
destroy
()¶
-
get_node
()¶ Use this to get access to the Pyrlang node which owns this protocol. :rtype: pyrlang2.node.Node
-
inbox_
= None¶ Inbox is used to ask the connection to do something.
-
async
listen_on_inbox
()¶
-
static
make_digest
(challenge: int, cookie: str) → bytes¶
-
node_db
= <pyrlang.node_db.NodeDB object>¶
-
node_name_
= None¶ Name of the running Erlang node.
-
on_packet
(data: bytes) → bytes¶
-
on_packet_connected
(data: bytes) → bytes¶ Handle incoming dist packets in the connected state.
-
async
on_passthrough_message
(control_term, msg_term)¶ On incoming 'p' message with control and data, handle it. :raises DistributionError: when 'p' message is not a tuple
-
packet_len_size_
= None¶ Packet size header is variable, 2 bytes before handshake is finished and 4 bytes afterwards.
-
peer_distr_version_
= None¶ Protocol version range supported by the remote peer. Erlang/OTP versions 19-20 supports protocol version 7, older Erlangs down to R6B support version 5.
-
protocol_error
(msg)¶
-
report_dist_connected
()¶
-
state_
= None¶ FSM state for the protocol state-machine.
-


Implementing an Event Listener
The JavaServer Faces technology supports action events and value-change events for components.
Action events occur when the user activates a component that implements ActionSource. These events are represented by the class javax.faces.event.ActionEvent.
Value-change events occur when the user changes the value of a component that implements EditableValueHolder. These events are represented by the class javax.faces.event.ValueChangeEvent.
One way to handle events is to implement the appropriate listener classes. Listener classes that handle the action events in an application must implement the interface javax.faces.event.ActionListener. Similarly, listeners that handle the value-change events must implement the interface javax.faces.event.ValueChangeListener.
This section explains how to implement the two listener classes.
To handle events generated by custom components, you must implement an event listener and an event handler and manually queue the event on the component. See Handling Events for Custom Components for more information.
Note - You do not need to create an ActionListener implementation to handle an event that results solely in navigating to a page and does not perform any other application-specific processing. See Writing a Method to Handle Navigation for information on how to manage page navigation.
Implementing Value-Change Listeners
A ValueChangeListener implementation must include a processValueChange(ValueChangeEvent) method. This method processes the specified value-change event and is invoked by the JavaServer Faces implementation when the value-change event occurs. The ValueChangeEvent instance stores the old and the new values of the component that fired the event.
In the Duke's Bookstore case study, the NameChanged listener implementation is registered on the name UIInput component on the bookcashier.xhtml page. This listener stores into session scope the name the user entered in the text field corresponding to the name component.
The bookreceipt.xhtml subsequently retrieves the name from the session scope:
<h:outputFormat title="thanks" value="#{bundle.ThankYouParam}"> <f:param value="#{sessionScope.name}"/> </h:outputFormat>
When the bookreceipt.xhtml page is loaded, it displays the name inside the message:
"Thank you, {0}, for purchasing your books from us."
Here is part of the NameChanged listener implementation:
public class NameChanged extends Object implements ValueChangeListener { @Override public void processValueChange(ValueChangeEvent event) throws AbortProcessingException { if (null != event.getNewValue()) { FacesContext.getCurrentInstance().getExternalContext(). getSessionMap().put("name", event.getNewValue()); } } }
When the user enters the name in the text field, a value-change event is generated, and the processValueChange(ValueChangeEvent) method of the NameChanged listener implementation is invoked. This method first gets the ID of the component that fired the event from the ValueChangeEvent object, and it puts the value, along with an attribute name, into the session map of the FacesContext instance.
Registering a Value-Change Listener on a Component explains how to register this listener onto a component.
Implementing Action Listeners
An ActionListener implementation must include a processAction(ActionEvent) method. The processAction(ActionEvent) method processes the specified action event. The JavaServer Faces implementation invokes the processAction(ActionEvent) method when the ActionEvent occurs.
The Duke's Bookstore case study uses two ActionListener implementations, LinkBookChangeListener and MapBookChangeListener. See Handling Events for Custom Components for details on MapBookChangeListener.
Registering an Action Listener on a Component explains how to register this listener onto a component.


Kind, Actionable, and Specific
26 de mayo 2015
Pairing Up
Pairing:
- What was it like to pair with others? I love pairing with others! I have had so many positive and productive pairing sessions so far. I appreicate the structure that DBC has encouraged us to work with: check in with each other, communicate your vision for driving and navigating, and collaborate to solve a problem. I remember feeling nervous for the first pairing session because I didn't want to be the underprepared pair who didn't contribute. I was also curious - how are others feeling about moving through these challenges? Are their questions and struggles the same as mine? What drove them to join DBC? I love meeting new people and hearing your story so I look forward to the check-in a lot.
- What was fun or rewarding about pairing? The best part of pairing is encouraging someone else and supporting them in their learning. I think that a pairing session is successful when I can help you build up your understanding of what we are doing. I don't feel so great when I leave a session not feeling stronger in what I'm doing (that only happened once). Another fun part of pairing is obviously getting the code to work the way we want! That feels SO good!
- What was frustrating or difficult? It is difficult for me to speak up and communicate if the ebb and flow isn't working for me. When I feel confused by the content or off-balance in how we are working together, I struggle saying, "hey, can we pause? I'm not feeling it." I should probably just say that, right? You know what is interesting? I'd rather have a good vibe going on and not get a working solution than have an uncomfortable vibe and beautiful code.
Feedback
- DBC and a culture of feedback Oh, feedback. I appreciate that DBC takes so much time in setting a culture of feedback. They took time to set the standard for feedback so that we all are on the same page about what feedback looks and feels like, when it happens and how it should make an impact on your learning and pairing.
- How did you feel when you read your feedback? Impressed! Each piece of feedback is meaningful and relevant. Actually, a lot of it is what I was thinking when I reflected on our pairing session. I am grateful for the encouragement and positive vibes and equally empowered by the suggestions that can take me to the next level as a pair and web developer.
- Based on the feedback you've received, what are you going to do to improve next time you pair? I am writing my pseudocode on paper, in order as we talk through it. I think the first few challenges were 'easy' enough to talk through and write but someone mentioned that I should write the steps down as we go to stay organized. Done. I am and it is paying off - I was able to pseudocode and solve the first three challenges of the week on my first attempt!. Thank you, anonymous feedback unicorn. You encouraged me to do something simple yet powerful!
- How was it to write feedback? What was most difficult for you when writing feedback for your pair? I have experience giving feedback through my previous role as teacher coach. I'd observe a teacher, give feedback by using a rubric with pre-defined criteria and facilitating a co-reflection before showing my feedback. It was very structured and also included a value. That was tough. So, providing kind, actionable and spcific feedback is something I've done for a long time. But, this is a different environment and I don't know how much experience my fellow grasshoppers have with receiving and giving feedback. I write feedback that I'd want to read about myself. If it is actionable, I'll have something to do differently because of the feedback. If it is kind, I'll nod and feel valued. If it is specific, I'll know
Overall, what do you think of using pairing and feedback to guide your learning?
I think it is going to be an essential part of my learning experience for many reasons.
- Life is better when shared in community!
- Listening to how someone else is digesting what we are learning will help me strengthen my own understanding and also clear up links between chunks of learning that I haven't mastered. That has already happened!
- Teaching is the best way to learn so pairing with someone that I can encourage and guide to a stronger understanding is the best feeling!
- Feedback is a way for me to learn how others perceive me as a teammate - both in how they feel working with me and how much I contribute technically. I hope to contribute in meaningful ways and have some fun doing it, so I strive to hear that type of feedback.


Summer of 2015, Swati Agarwal graduated from the National Institute of Fashion Technology, India with many awards. Five months later, Swati started her eponymous label which began with a workforce of just two persons. Over the year, she has successfully built a clothing brand which has a very strong social perspective. Quick to understand the demands of the Indian market, Swati has created a brand that has represented a comfort zone to global Indians and remained undestroyed through major socio-economical-political changes.
Fashion is a popular style or practice, especially in clothing, footwear, accessories, makeup, body piercing, or furniture. Fashion is a distinctive and often habitual trend in the style in which a person dresses. It is the prevailing styles in behaviour and the newest creations of textile designers.Because the more technical term costume is regularly linked to the term "fashion" the use of the former has been relegated to special senses like fancy dress or masquerade wear, while "fashion" generally means clothing,including the study of it.


NUnitLite started out life as a separate version of the NUnit framework, with fewer features and a built-in test runner. It ran on devices as well as on desktop .NET and mono and allowed users to create executable tests without the overhead of a full NUnit installation.
With NUnit 3.0, the NUnitLite framework has been merged with the full NUnit framework. There is now only one framework, nunit.framework.dll. The built-in runner, which was a part of the old NUnitLite, is now packaged as nunitlite.dll.
To run tests under NUnitLite, proceed as follows:
public static void Main(string[] args) { new TextUI().Execute(args); }
If you install the NUnitLite runner via the NuGet package, steps 2 and 3 are handled automatically. Both assemblies are installed and referenced and a file, Program.cs, is added to your project with a Main() like that above.
As seen in the following screen shot, the output from an NUnitLite run is quite similar to that from the console runner.


This is where you can find the lyrics of all Lord Shiva mantras or devotional hymns in English and Devanagari script. You will also find the meaning of Shiva mantras and devotional hymns in English. Shiva mantras are read to please Lord Shiva.
| Maha Mrityunjaya Mantra |
| Shiva Tandava Stotra |
| Shiva Aarti |
| Shiva Kavach |


Discord Bug Searcher
Realized by
y3ll0wlife
formatted by
alangueite
Desktop
Linux
Android
iOS
Store
Overlay
Website


BED AND BREAKFAST A film review by Ken Johnson Copyright 1993 Ken Johnson
104 min., PG-13, Comedy, 1992 Director: Robert Ellis Miller Cast: Roger Moore, Talia Shire, Colleen Dewhurst, Nina Siemaszko, Ford Rainey, Jamie Walters, Stephen Root
Talia Shire runs a Bed and Breakfast with her daughter Nina Siemaszko and her mother-in-law Colleen Dewhurst. One day Siemaszko finds Roger Moore washed up on the beach outside of their house. They take him in and find out that he has amnesia. Dewhurst makes him the handyman for the Bed and Breakfast.
BED AND BREAKFAST was filmed in York Beach, Maine in either 1989 or 1990, I believe. Since I live just down the seacoast from there and remember reading and hearing a lot about the filming, when it came to the local theaters I had to go and see it. I enjoyed this film and highly recommend that you attempt to see it. On a scale of zero to five, I give BED AND BREAKFAST a four. BED AND BREAKFAST is rated PG-13 for explicit language and adult situations.
This film was not what I was expecting. I was expecting through what I had seen in the local papers some sort of drama about New England life. I was pleased that instead, the film was a good natured comedy. BED AND BREAKFAST has now been released on video cassette, so it shouldn't be too hard to find.
I found this film very enjoyable to just sit back and watch. The film has a great cast. Roger Moore (THE NAKED FACE, LIVE AND LET DIE) is great as the stranger. Talia Shire (THE GODFATHER, COLD HEAVEN) is wonderful as the mother who is trying to keep Nina Siemaszko going straight. Colleen Dewhurst (THE BOY WHO COULD FLY) is exceptionally great as Talia Shire's mother. I think that Colleen Dewhurst was the best out of the entire cast. Nina Siemaszko (WILD ORCHID 2: TWO SHADES OF BLUE) is very good as Talia Shire's daughter. For the teenage girls there is Jamie Walters ("The Heights"), who does what he does best, looks cute for the girls. This film is very well written and is beautifully photographed. The director, Robert Ellis Miller, does a great job, getting excellent shots to go with the film.
-------- Ken Johnson<EMAIL_ADDRESS>.
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


Date of Referral: [_date] [_time]
Organisation/Name: [referrer-name]
Email: [referrer-email]
Telephone: [referrer-telephone]
Name: [referree-name]
Address: [referree-address]
Date of Birth: [referree-dob]
Telephone: [referree-telephone]
Adults: [referral-adults]
Children: [referral-children]
Child Ages: [referral-child-ages]
Reason: [referral-support]
-- This e-mail was sent from a contact form on [_site_title] ([_site_url])


Ensure that the last call to a mock function has returned a specified value.
Optionally, you can provide a type for the expected value via a generic. This is particuarly useful for ensuring expected objects have the right structure.
Ensure that a mock function is called with specific arguments on an Nth call.
Optionally, you can provide a type for the expected arguments via a generic. Note that the type must be either an array or a tuple.
Ensure that the nth call to a mock function has returned a specified value.
Optionally, you can provide a type for the expected value via a generic. This is particuarly useful for ensuring expected objects have the right structure.
Checks that a value is what you expect. It uses ===
to check strict equality.
Don't use toBe
with floating-point numbers.
Optionally, you can provide a type for the expected value via a generic. This is particuarly useful for ensuring expected objects have the right structure.
Ensures that a mock function is called.
Ensures that a mock function is called an exact number of times.
Ensure that a mock function is called with specific arguments.
Optionally, you can provide a type for the expected arguments via a generic. Note that the type must be either an array or a tuple.
Using exact equality with floating point numbers is a bad idea. Rounding means that intuitive things fail. The default for numDigits is 2.
Ensure that a variable is not undefined.
When you don't care what a value is, you just want to ensure a value is false in a boolean context.
For comparing floating point numbers.
For comparing floating point numbers.
Ensure that an object is an instance of a class.
This matcher uses instanceof
underneath.
Optionally, you can provide a type for the expected value via a generic. This is particuarly useful for ensuring expected objects have the right structure.
For comparing floating point numbers.
For comparing floating point numbers.
Used to check that a variable is NaN.
This is the same as .toBe(null)
but the error messages are a bit nicer.
So use .toBeNull()
when you want to check that something is null.
 In JavaScript, there are six falsy values:
false
, 0
, ''
, null
, undefined
, and NaN
. Everything else is truthy.
Used to check that a variable is undefined.
Used when you want to check that an item is in a list.
For testing the items in the list, this uses ===
, a strict equality check.
Optionally, you can provide a type for the expected value via a generic. This is particuarly useful for ensuring expected objects have the right structure.
Used when you want to check that an item is in a list. For testing the items in the list, this matcher recursively checks the equality of all fields, rather than checking for object identity.
Optionally, you can provide a type for the expected value via a generic. This is particuarly useful for ensuring expected objects have the right structure.
Used when you want to check that two objects have the same value. This matcher recursively checks the equality of all fields, rather than checking for object identity.
Optionally, you can provide a type for the expected value via a generic. This is particuarly useful for ensuring expected objects have the right structure.
Ensures that a mock function is called.
Ensures that a mock function is called an exact number of times.
Ensure that a mock function is called with specific arguments.
Optionally, you can provide a type for the expected arguments via a generic. Note that the type must be either an array or a tuple.
If you have a mock function, you can use .toHaveBeenLastCalledWith
to test what arguments it was last called with.
Optionally, you can provide a type for the expected arguments via a generic. Note that the type must be either an array or a tuple.
Ensure that a mock function is called with specific arguments on an Nth call.
Optionally, you can provide a type for the expected arguments via a generic. Note that the type must be either an array or a tuple.
Use to test the specific value that a mock function last returned. If the last call to the mock function threw an error, then this matcher will fail no matter what value you provided as the expected return value.
Optionally, you can provide a type for the expected value via a generic. This is particuarly useful for ensuring expected objects have the right structure.
Used to check that an object has a .length
property
and it is set to a certain numeric value.
Use to test the specific value that a mock function returned for the nth call. If the nth call to the mock function threw an error, then this matcher will fail no matter what value you provided as the expected return value.
Optionally, you can provide a type for the expected value via a generic. This is particuarly useful for ensuring expected objects have the right structure.
Use to check if property at provided reference keyPath exists for an object. For checking deeply nested properties in an object you may use dot notation or an array containing the keyPath for deep references.
Optionally, you can provide a value to check if it's equal to the value present at keyPath
on the target object. This matcher uses 'deep equality' (like toEqual()
) and recursively checks
the equality of all fields.
Use to test that the mock function successfully returned (i.e., did not throw an error) at least one time
Use to ensure that a mock function returned successfully (i.e., did not throw an error) an exact number of times. Any calls to the mock function that throw an error are not counted toward the number of times the function returned.
Use to ensure that a mock function returned a specific value.
Optionally, you can provide a type for the expected value via a generic. This is particuarly useful for ensuring expected objects have the right structure.
Check that a string matches a regular expression.
This ensures that a value matches the most recent snapshot with property matchers. Instead of writing the snapshot value to a .snap file, it will be written into the source code automatically. Check out the Snapshot Testing guide for more information.
This ensures that a value matches the most recent snapshot with property matchers. Instead of writing the snapshot value to a .snap file, it will be written into the source code automatically. Check out the Snapshot Testing guide for more information.
Used to check that a JavaScript object matches a subset of the properties of an object
Optionally, you can provide an object to use as Generic type for the expected value. This ensures that the matching object matches the structure of the provided object-like type.
This ensures that a value matches the most recent snapshot with property matchers. Check out the Snapshot Testing guide for more information.
This ensures that a value matches the most recent snapshot. Check out the Snapshot Testing guide for more information.
Ensure that a mock function has returned (as opposed to thrown) at least once.
Ensure that a mock function has returned (as opposed to thrown) a specified number of times.
Ensure that a mock function has returned a specified value at least once.
Optionally, you can provide a type for the expected value via a generic. This is particuarly useful for ensuring expected objects have the right structure.
Use to test that objects have the same types as well as structure.
Optionally, you can provide a type for the expected value via a generic. This is particuarly useful for ensuring expected objects have the right structure.
Used to test that a function throws when it is called.
If you want to test that a specific error is thrown inside a function.
Used to test that a function throws a error matching the most recent snapshot when it is called. Instead of writing the snapshot value to a .snap file, it will be written into the source code automatically.
Used to test that a function throws a error matching the most recent snapshot when it is called.
Generated using TypeDoc
Ensures the last call to a mock function was provided specific args.
Optionally, you can provide a type for the expected arguments via a generic. Note that the type must be either an array or a tuple.


Provides an interface to the C implementation of the random number generator with multiple independent streams developed by L'Ecuyer et al (2002). The main purpose of this package is to enable the use of this random number generator in parallel R applications.
| Version: | 0.3-4 |
| Published: | 2015-09-18 |
| Author: | Hana Sevcikova [aut, cre], Tony Rossini [aut], Pierre L'Ecuyer [cph] (author of the underlying C code) |
| Maintainer: | Hana Sevcikova <hanas at uw.edu> |
| License: | GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| URL: | http://www.iro.umontreal.ca/~lecuyer/myftp/papers/streams00.pdf |
| NeedsCompilation: | yes |
| Materials: | ChangeLog |
| In views: | Distributions, HighPerformanceComputing |
| CRAN checks: | rlecuyer results |
| Reference manual: | rlecuyer.pdf |
| Package source: | rlecuyer_0.3-4.tar.gz |
| Windows binaries: | r-devel: rlecuyer_0.3-4.zip, r-release: rlecuyer_0.3-4.zip, r-oldrel: rlecuyer_0.3-4.zip |
| OS X binaries: | r-release: rlecuyer_0.3-4.tgz, r-oldrel: rlecuyer_0.3-4.tgz |
| Old sources: | rlecuyer archive |
| Reverse depends: | AMOEBA, CNprep, MicSim, pbdSLAP, snowFT |
| Reverse imports: | MonteCarlo, pbdMPI |
| Reverse suggests: | bigGP, dclone, geoCount, latentnet, qle, snow |
Please use the canonical form https://CRAN.R-project.org/package=rlecuyer to link to this page.


Learn about Blockchain, Digital, and Crypto Currency
Blockchain technology and crypto currencies have the potential to reshape and improve Hawaii's economy
Crypto
The word "crypto" in crypto currency refers to the cryptographic hashing that is involved in the proof of work function used to verify transactions on the public ledger. Each cryptocurrency has their own cryptographic hashing and ledger scheme but at the heart of it is a hash function. All transactions are grouped together by time and hashed together to create what is called a block.
Blockchain
When all transactions for a given time period, about every 10 minutes for bitcoin, are hashed together they create a "block". These blocks contain the hash of a previous block, all the transactions for that timeframe and the current hash of the block. A hash is a series of bits, often represented as letters and numbers, that result from a hash function. A hash function creates a unique hash for any given input. Having the hash from the previous block contained in the current block creates the concept of a chain which links every block to the previous block before it; hence chain of blocks or blockchain
Bitcoin
Bitcoin is a single unit of a digital currency. Bitcoin was the first example of a cryptocurrency and blockchain implementation. Bitcoin has a deflationary model in that the number of bitcoins in circulation is finite. A unique and advantageous quality of bitcoin and digital currency that sets it apart from fiat currencies like the dollar is that these cryptocurrencies can be divided into fractional amounts where as the smallest dollar value is a penny.
Inter Planetary File System
Inter Planetary File System (IPFS) is a concept that is based off of blockchain technology. The idea is that data can be stored on the blockchain and distributed for the benefit of robustness and accessibility. The blockchain is immutable which means that it cannot be changed. What is written to blockchain remains on the blockchain. Thus (IPFS) utilizes this idea to create persistent storage that can be accessed at anytime. This is advantageous when compared to cloud services such as Dropbox and Google Drive because if any of these service providers servers are compromised, the data will be loss. Yes, they implement redundancy but with IPFS every node participating in the network contains a copy of the data and can be recovered. An attack or disaster would have to take out all nodes for all data to be loss, which is a low probability. Many decentralized applications are beginning to use IPFS and IPFS like storage schemes to house their data.
DAPPS
Decentralized applications or DAPPS are applications that run on the blockchain in a decentralized fashion.
Purchasing FAQ
- What are some important topics?
- Important differences between centralized and decentralized
- Do I need to understand the cryptographic has or blockchain to use digital currencies?
- No, cryptocurrency use does not require this knowledege but it is handy to know


@* * Copyright 2023 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @(printFriendly: Boolean = false)(implicit messages: Messages) @import views.html.helpers._
@messages("awrs.application_status.info.approved.line1")
@messages("awrs.application_status.info.approved.line2.printOnly")
@Html(messages("awrs.application_status.info.approved.line2","",""))
@messages("awrs.application_status.info.approved.line3.printOnly")
@Html(messages("awrs.application_status.info.approved.line3","",""))
@messages("awrs.application_status.info.approved.line4")
@messages("awrs.application_status.info.approved.line5")
@Html(messages("awrs.application_status.info.approved.line6","",""))
@messages("awrs.application_status.info.approved.line7")
@printFriendly match { case false => {@awrsStatusPageSignInPara(messages)} case true => {} }