EntryStream<K,V> |
EntryStream.append(Map<K,V> map) |
Returns a new EntryStream which is a concatenation of this stream
and the stream created from the supplied map entries.
|
EntryStream<K,V> |
EntryStream.append(K key,
V value) |
Returns a new EntryStream which is a concatenation of this stream
and the supplied key-value pair.
|
EntryStream<K,V> |
EntryStream.append(K k1,
V v1,
K k2,
V v2) |
Returns a new EntryStream which is a concatenation of this stream
and two supplied key-value pairs.
|
EntryStream<K,V> |
EntryStream.append(K k1,
V v1,
K k2,
V v2,
K k3,
V v3) |
Returns a new EntryStream which is a concatenation of this stream
and three supplied key-value pairs.
|
EntryStream<K,List<V>> |
EntryStream.collapseKeys() |
Merge series of adjacent stream entries with equal keys grouping the
corresponding values into List .
|
EntryStream<K,V> |
EntryStream.collapseKeys(BinaryOperator<V> merger) |
Merge series of adjacent stream entries with equal keys combining the
corresponding values using the provided function.
|
<A,R> EntryStream<K,R> |
EntryStream.collapseKeys(Collector<? super V,A,R> collector) |
Merge series of adjacent stream entries with equal keys combining the
corresponding values using the provided Collector .
|
<V> EntryStream<T,V> |
StreamEx.cross(Collection<? extends V> other) |
Performs a cross product of current stream with specified
Collection of elements.
|
<V> EntryStream<T,V> |
StreamEx.cross(Function<? super T,? extends Stream<? extends V>> mapper) |
Creates a new EntryStream whose keys are elements of current
stream and corresponding values are supplied by given function.
|
<V> EntryStream<T,V> |
StreamEx.cross(V... other) |
Performs a cross product of current stream with specified array of
elements.
|
EntryStream<K,V> |
EntryStream.distinctKeys() |
Returns a stream consisting of the elements of this stream which have
distinct keys (according to object equality).
|
EntryStream<K,V> |
EntryStream.distinctValues() |
Returns a stream consisting of the elements of this stream which have
distinct values (according to object equality).
|
static <K,V> EntryStream<K,V> |
EntryStream.empty() |
Returns an empty sequential EntryStream .
|
EntryStream<K,V> |
EntryStream.filterKeys(Predicate<? super K> keyPredicate) |
Returns a stream consisting of the elements of this stream which keys
match the given predicate.
|
EntryStream<K,V> |
EntryStream.filterKeyValue(BiPredicate<? super K,? super V> predicate) |
Returns a stream consisting of the elements of this stream which elements
match the given predicate.
|
EntryStream<K,V> |
EntryStream.filterValues(Predicate<? super V> valuePredicate) |
Returns a stream consisting of the elements of this stream which values
match the given predicate.
|
<KK> EntryStream<KK,V> |
EntryStream.flatMapKeys(Function<? super K,? extends Stream<? extends KK>> mapper) |
Returns an EntryStream consisting of the entries whose keys are
results of replacing source keys with the contents of a mapped stream
produced by applying the provided mapping function to each source key and
values are left intact.
|
<K,V> EntryStream<K,V> |
StreamEx.flatMapToEntry(Function<? super T,? extends Map<K,V>> mapper) |
Creates a new EntryStream populated from entries of maps produced
by supplied mapper function which is applied to the every element of this
stream.
|
<KK> EntryStream<KK,V> |
EntryStream.flatMapToKey(BiFunction<? super K,? super V,? extends Stream<? extends KK>> mapper) |
Returns an EntryStream consisting of the entries whose keys are
results of replacing source keys with the contents of a mapped stream
produced by applying the provided mapping function and values are left
intact.
|
<VV> EntryStream<K,VV> |
EntryStream.flatMapToValue(BiFunction<? super K,? super V,? extends Stream<? extends VV>> mapper) |
Returns an EntryStream consisting of the entries whose values are
results of replacing source values with the contents of a mapped stream
produced by applying the provided mapping function and keys are left
intact.
|
<VV> EntryStream<K,VV> |
EntryStream.flatMapValues(Function<? super V,? extends Stream<? extends VV>> mapper) |
Returns an EntryStream consisting of the entries whose values are
results of replacing source values with the contents of a mapped stream
produced by applying the provided mapping function to each source value
and keys are left intact.
|
static <K,V> EntryStream<K,V> |
EntryStream.generate(Supplier<? extends K> keySupplier,
Supplier<? extends V> valueSupplier) |
Returns an infinite sequential unordered EntryStream where each
entry key is generated by the provided keySupplier and each entry value is generated by the provided
valueSupplier .
|
EntryStream<V,K> |
EntryStream.invert() |
Returns a stream consisting of the Map.Entry objects which keys are
the values of this stream elements and vice versa.
|
<KK> EntryStream<KK,V> |
EntryStream.mapKeys(Function<? super K,? extends KK> keyMapper) |
Returns an EntryStream consisting of the entries whose keys are
modified by applying the given function and values are left unchanged.
|
<K,V> EntryStream<K,V> |
DoubleStreamEx.mapToEntry(DoubleFunction<? extends K> keyMapper,
DoubleFunction<? extends V> valueMapper) |
Returns an EntryStream consisting of the Map.Entry objects
which keys and values are results of applying the given functions to the
elements of this stream.
|
<K,V> EntryStream<K,V> |
IntStreamEx.mapToEntry(IntFunction<? extends K> keyMapper,
IntFunction<? extends V> valueMapper) |
Returns an EntryStream consisting of the Map.Entry objects
which keys and values are results of applying the given functions to the
elements of this stream.
|
<K,V> EntryStream<K,V> |
LongStreamEx.mapToEntry(LongFunction<? extends K> keyMapper,
LongFunction<? extends V> valueMapper) |
Returns an EntryStream consisting of the Map.Entry objects
which keys and values are results of applying the given functions to the
elements of this stream.
|
<K,V> EntryStream<K,V> |
StreamEx.mapToEntry(Function<? super T,? extends K> keyMapper,
Function<? super T,? extends V> valueMapper) |
Returns an EntryStream consisting of the Map.Entry objects
which keys and values are results of applying the given functions to the
elements of this stream.
|
<V> EntryStream<T,V> |
StreamEx.mapToEntry(Function<? super T,? extends V> valueMapper) |
Returns an EntryStream consisting of the Map.Entry objects
which keys are elements of this stream and values are results of applying
the given function to the elements of this stream.
|
<KK> EntryStream<KK,V> |
EntryStream.mapToKey(BiFunction<? super K,? super V,? extends KK> keyMapper) |
Returns an EntryStream consisting of the entries whose keys are
modified by applying the given function and values are left unchanged.
|
<KK> EntryStream<KK,V> |
EntryStream.mapToKeyPartial(BiFunction<? super K,? super V,? extends Optional<? extends KK>> keyMapper) |
Performs a mapping of the stream content to a partial function
removing the entries to which the function is not applicable.
|
<VV> EntryStream<K,VV> |
EntryStream.mapToValue(BiFunction<? super K,? super V,? extends VV> valueMapper) |
Returns an EntryStream consisting of the entries whose keys are
left unchanged and values are modified by applying the given function.
|
<VV> EntryStream<K,VV> |
EntryStream.mapToValuePartial(BiFunction<? super K,? super V,? extends Optional<? extends VV>> valueMapper) |
Performs a mapping of the stream content to a partial function
removing the entries to which the function is not applicable.
|
<VV> EntryStream<K,VV> |
EntryStream.mapValues(Function<? super V,? extends VV> valueMapper) |
Returns an EntryStream consisting of the entries whose keys are
left unchanged and values are modified by applying the given function.
|
EntryStream<K,V> |
EntryStream.nonNullKeys() |
Returns a stream consisting of the elements of this stream which key is
not null.
|
EntryStream<K,V> |
EntryStream.nonNullValues() |
Returns a stream consisting of the elements of this stream which value is
not null.
|
static <K,V> EntryStream<K,V> |
EntryStream.of(Iterator<? extends Map.Entry<K,V>> iterator) |
|
static <V> EntryStream<Integer,V> |
EntryStream.of(List<V> list) |
Returns an EntryStream object whose keys are indices of given
list and the values are the corresponding list elements.
|
static <K,V> EntryStream<K,V> |
EntryStream.of(Map<K,V> map) |
Returns an EntryStream object which contains the entries of
supplied Map .
|
static <K,V> EntryStream<K,V> |
EntryStream.of(Spliterator<? extends Map.Entry<K,V>> spliterator) |
|
static <K,V> EntryStream<K,V> |
EntryStream.of(Stream<? extends Map.Entry<K,V>> stream) |
Returns an EntryStream object which wraps given Stream of
Map.Entry elements
|
static <K,V> EntryStream<K,V> |
EntryStream.of(K key,
V value) |
Returns a sequential EntryStream containing a single key-value
pair
|
static <K,V> EntryStream<K,V> |
EntryStream.of(K k1,
V v1,
K k2,
V v2) |
Returns a sequential EntryStream containing two key-value pairs
|
static <K,V> EntryStream<K,V> |
EntryStream.of(K k1,
V v1,
K k2,
V v2,
K k3,
V v3) |
Returns a sequential EntryStream containing three key-value pairs
|
static <K,V> EntryStream<K,V> |
EntryStream.of(K k1,
V v1,
K k2,
V v2,
K k3,
V v3,
K k4,
V v4) |
Returns a sequential EntryStream containing four key-value pairs
|
static <K,V> EntryStream<K,V> |
EntryStream.of(K k1,
V v1,
K k2,
V v2,
K k3,
V v3,
K k4,
V v4,
K k5,
V v5) |
Returns a sequential EntryStream containing five key-value pairs
|
static <K,V> EntryStream<K,V> |
EntryStream.of(K k1,
V v1,
K k2,
V v2,
K k3,
V v3,
K k4,
V v4,
K k5,
V v5,
K k6,
V v6) |
Returns a sequential EntryStream containing six key-value pairs
|
static <K,V> EntryStream<K,V> |
EntryStream.of(K k1,
V v1,
K k2,
V v2,
K k3,
V v3,
K k4,
V v4,
K k5,
V v5,
K k6,
V v6,
K k7,
V v7) |
Returns a sequential EntryStream containing seven key-value pairs
|
static <K,V> EntryStream<K,V> |
EntryStream.of(K k1,
V v1,
K k2,
V v2,
K k3,
V v3,
K k4,
V v4,
K k5,
V v5,
K k6,
V v6,
K k7,
V v7,
K k8,
V v8) |
Returns a sequential EntryStream containing eight key-value pairs
|
static <K,V> EntryStream<K,V> |
EntryStream.of(K k1,
V v1,
K k2,
V v2,
K k3,
V v3,
K k4,
V v4,
K k5,
V v5,
K k6,
V v6,
K k7,
V v7,
K k8,
V v8,
K k9,
V v9) |
Returns a sequential EntryStream containing nine key-value pairs
|
static <K,V> EntryStream<K,V> |
EntryStream.of(K k1,
V v1,
K k2,
V v2,
K k3,
V v3,
K k4,
V v4,
K k5,
V v5,
K k6,
V v6,
K k7,
V v7,
K k8,
V v8,
K k9,
V v9,
K k10,
V v10) |
Returns a sequential EntryStream containing ten key-value pairs
|
static <V> EntryStream<Integer,V> |
EntryStream.of(V[] array) |
Returns an EntryStream object whose keys are indices of given
array and the values are the corresponding array elements.
|
static <T> EntryStream<T,T> |
EntryStream.ofPairs(List<T> list) |
Returns a sequential ordered EntryStream containing the possible
pairs of elements taken from the provided list.
|
static <T> EntryStream<T,T> |
EntryStream.ofPairs(T[] array) |
Returns a sequential ordered EntryStream containing the possible
pairs of elements taken from the provided array.
|
static <T,TT extends T> EntryStream<Integer,T> |
EntryStream.ofTree(T root,
Class<TT> collectionClass,
BiFunction<Integer,TT,Stream<T>> mapper) |
Return a new EntryStream containing all the nodes of tree-like
data structure in entry values along with the corresponding tree depths
in entry keys, in depth-first order.
|
static <T> EntryStream<Integer,T> |
EntryStream.ofTree(T root,
BiFunction<Integer,T,Stream<T>> mapper) |
Return a new EntryStream containing all the nodes of tree-like
data structure in entry values along with the corresponding tree depths
in entry keys, in depth-first order.
|
EntryStream<K,V> |
EntryStream.peekKeys(Consumer<? super K> keyAction) |
Returns a stream consisting of the entries of this stream, additionally
performing the provided action on each entry key as entries are consumed
from the resulting stream.
|
EntryStream<K,V> |
EntryStream.peekKeyValue(BiConsumer<? super K,? super V> action) |
Returns a stream consisting of the entries of this stream, additionally
performing the provided action on each entry key-value pair as entries
are consumed from the resulting stream.
|
EntryStream<K,V> |
EntryStream.peekValues(Consumer<? super V> valueAction) |
Returns a stream consisting of the entries of this stream, additionally
performing the provided action on each entry value as entries are
consumed from the resulting stream.
|
EntryStream<K,V> |
EntryStream.prefixKeys(BinaryOperator<K> op) |
Returns a new EntryStream which values are the same as this
stream values and keys are the results of applying the accumulation
function to this stream keys, going left to right.
|
EntryStream<K,V> |
EntryStream.prefixValues(BinaryOperator<V> op) |
Returns a new EntryStream which keys are the same as this stream
keys and values are the results of applying the accumulation function to
this stream values, going left to right.
|
EntryStream<K,V> |
EntryStream.prepend(Map<K,V> map) |
Returns a new EntryStream which is a concatenation of the stream
created from the supplied map entries and this stream.
|
EntryStream<K,V> |
EntryStream.prepend(K key,
V value) |
Returns a new EntryStream which is a concatenation of the
supplied key-value pair and this stream.
|
EntryStream<K,V> |
EntryStream.prepend(K k1,
V v1,
K k2,
V v2) |
Returns a new EntryStream which is a concatenation of two
supplied key-value pairs and this stream.
|
EntryStream<K,V> |
EntryStream.prepend(K k1,
V v1,
K k2,
V v2,
K k3,
V v3) |
Returns a new EntryStream which is a concatenation of three
supplied key-value pairs and this stream.
|
EntryStream<K,V> |
EntryStream.removeKeys(Predicate<? super K> keyPredicate) |
Returns a stream consisting of the elements of this stream which keys
don't match the given predicate.
|
EntryStream<K,V> |
EntryStream.removeKeyValue(BiPredicate<? super K,? super V> predicate) |
Returns a stream consisting of the elements of this stream which values
don't match the given predicate.
|
EntryStream<K,V> |
EntryStream.removeValues(Predicate<? super V> valuePredicate) |
Returns a stream consisting of the elements of this stream which values
don't match the given predicate.
|
EntryStream<T,Long> |
StreamEx.runLengths() |
Collapses adjacent equal elements and returns an EntryStream
where keys are input elements and values specify how many elements were
collapsed.
|
<KK> EntryStream<KK,V> |
EntryStream.selectKeys(Class<KK> clazz) |
Returns a stream consisting of the elements of this stream which keys are
instances of given class.
|
<VV> EntryStream<K,VV> |
EntryStream.selectValues(Class<VV> clazz) |
Returns a stream consisting of the elements of this stream which values
are instances of given class.
|
EntryStream<K,V> |
EntryStream.sorted() |
EntryStream<T,T> |
StreamEx.withFirst() |
Creates an EntryStream consisting of the Map.Entry objects
which keys are all the same and equal to the first element of this stream
and values are the rest elements of this stream.
|
static <K,V> EntryStream<K,V> |
EntryStream.zip(List<K> keys,
List<V> values) |
Returns a sequential EntryStream containing Entry objects
composed from corresponding key and value in given two lists.
|
static <K,V> EntryStream<K,V> |
EntryStream.zip(K[] keys,
V[] values) |
Returns a sequential EntryStream containing Entry objects
composed from corresponding key and value in given two arrays.
|
<V> EntryStream<T,V> |
StreamEx.zipWith(BaseStream<V,?> other) |
Creates a new EntryStream which keys are elements of this stream
and values are the corresponding elements of the supplied other stream.
|
<V> EntryStream<T,V> |
StreamEx.zipWith(Stream<V> other) |
Creates a new EntryStream which keys are elements of this stream
and values are the corresponding elements of the supplied other stream.
|


At the end of last weeks sprint I couldn't share some of my work on DOM interactions, normally I have a system for sharing the work I do with my facilitator to see my progress using a platform called GitHub
I had 'saved' it without seeing that it had given an error message, it wasn't until my facilitator asked where this work was did I try again and noticed the error message
I tried, restarting, then logging out of and into again, unfortunately none of these fixed the problem I had so I had to recreate the entry and copy the completed work and save again.
Sometimes the simple start again approach is the one that works!
When it comes to technical solutions I find creating a simple list of steps on a piece of paper has been a helpful start, explaining the problem to someone else, it doesn't have to be a technical expert a clear question helps get a clear answer.
Following that there are a number of forums like stackoverflow and experts exchange(paid) the offer experts. This generally needs to be a very specific defined domain related question.
I had a problem where I needed to filter for a matching word but they could be different and random capitalisation. My solution was to convert the input string to lowercase before filtering.


\documentclass{article}
\usepackage[mathrm,colour,cntbysection]{czt}
\CountDefstrue
\begin{document}
\section{Introduction}
This is a specification of a simple scheduler and assembler. The system contains a set of registers and a block of memory. Processes can be created, with each containing a sequence on instructions that are executed on the system. The instruction format is a simplified format of the Intel x86 architecture. Processes are scheduled based on the credit system that is found in the Linux 2.0 kernel.
\section{Stack}
This specification was written as a test spec for the CZT project. As a result, there are parts that may appear to be specified in a strange way - this is to test out the tools on a large set of Z.
A generic stack.
\ZDeclSummary
Ok, lets see the value of \thecntZunboxed!
\section{Definitions}
Firstly, we define some basic types and functions that are used throughout the specification.
$singleton$ is the set of all sets whose size is less than or equal to~$1$. This is included only to have a generic axiom definition.
The basic type of this system is a word, which specifically, is an unsigned octet. An unsigned word is used so references to memory etc a 1-relative.
Then, we define the size of the memory block, and give it a value for animation purposes.
A $LABEL$ is used to label instructions for $jump$ instructions etc, although 'jump' hasn't been specified yet.
Now we define the different instructions, as well as their operands. A $CONSTANT$ is used both as a constant value, as well as a memory reference for load and store instructions.
An instruction is specified as a instruction name, a sequence of operands, and optionally, a label.
\ZDeclSummary
\section{System}
The system consists of a set of registers, and a block of memory. There is also a buffer for displaying output.
Initially, all registers and memory hold the minimum $WORD$ value. The output buffer is empty.
The system can have arithmetic and memory instructions.
A print instruction prints the value of a register.
$val$ maps constants to their value, and $dereference$ dereferences the value of a register, transitively if required.
The specification of the arithmetic instructions.
The {\tt load} operation loads a constant from memory. The second parameter is an index to the memory location from which the constant is loaded.
{\tt loadConst} loads a constant into a register. The second parameter the constant to be loaded.
Store the value of a register in memory.
The specification of the stack instructions on the system.
This executes an instruction on the on the system. $inst?$ is the instruction to execute, and $base?$ is the base memory value of the executing process. If the instruction is a {\tt load} or {\tt store} instruction, the memory reference must offset using the base value.
\ZDeclSummary
\section{Scheduler}
This part of the specification is the scheduler.
Here, we declare the set of process IDs, the priority values, and the default number of credits a process receives when it is created.
The possible status that a process can hold.
A process consists of a process ID, a status, a number of credits, and a priority. Each process has a sequence of instructions to be executed on the assembler, with a pointer to the current instruction. The memory that a process can occupy is between a base and limit value. Instructions must only access memory with a value less than the limit, but they know nothing about the base value - this is added onto the memory index provided by the instruction when an instruction is executed. Each procss also contains a stack and values for all registers, which are used to store values when the process is suspended.
The $sort$ function takes the credits and priorities of all processes, and returns a sequence of process IDS sorted firstly by their credits (the more credits a process has, the higher preference they get), and if the credits are equal, then their priority. If the priority is equal, then the order is non-deterministic.
To interrupt a process during execution, the kernel must be in $kernel$ mode.
For the scheduler, we track which mode the operating system is in, as well as declaring three ``secondary'' variables, $waiting$, $running$, and $ready$, to keep the sets of waiting running, and ready variables respecitvely. In fact, $ready$ is a sequence, and is ordered based on the credits that each process has. A process with more credits will have a higher priority. This is fair scheduling, because at each timer interrupt (the $tick$ operation specified below), the current process losses one credit, therefore, process spending a lot of time executing will eventually have a low priority.
This uses semicolons as conjunctions for predicates, which conforms to the grammar in the ISO standard, but according to the list of differences between ZRM and ISO Z on Ian Toyn's website, semicolons can no longer be used to conjoin predicates.
$newProcess$ creates a new process with a unique process ID and a specified priority, and places this new process on the ready queue.
We define a schema that contains only the variables that do not change when a reschedule occurs.
A reschedule occurs when all ready processes have no credits. Every process, not just the ready processes, have their credits re-calculated using the formula $credits = credits/2 + priority$. This implies that the ready process with the highest priority will be the next process executed.
We declare a new schema that contains only the state variables that do not change when a status change occurs.
Interrupts the currently executing process if the new process is of a higher priority then the current process and the kernel is in $kernel$ mode.
Remove the currently running process and put it back in the ready queue.
A process becomes blocked if it is waiting on a resource such a an IO device, or waiting on another process
We declare a schema containing only the variables that change for an unblock.
Unblocks a process that is blocked by another process.
Remove a process from the system
Update the details in the process table when each instruction is executed, as well as communicate the current instruction and the base value for the current process.
\begin{theorem}{PreconditionCheck} \vdash? \forall Scheduler @ \pre~update\_process\_table \end{theorem}
\ZDeclSummary
\end{document}


Welcome to
Paradise
Island Resort!
The
best
place to vacation!
This resort is so nice, that it has its own webpage!
Accommodations
Activities
Travel Arrangements
Pictures


| 043:020 Khan | : |
And they said: "If it had been the Will of the Most Beneficent (Allah), we should not have worshipped them (false deities)." They have no knowledge whatsoever of that. They do nothing but lie! |
| 043:020 Maulana | : |
And they say: If the Beneficent had pleased, we should not have worshipped them. They have no knowledge of this; they only lie. |
| 043:020 Pickthal | : |
And they say: If the Beneficent One had (so) willed, we should not have worshipped them. They have no knowledge whatsoever of that. They do but guess. |
| 043:020 Rashad | : |
They even said, "If the Most Gracious willed, we would not have worshipped them." They have no basis for such a claim; they only conjecture. |
| 043:020 Sarwar | : |
The pagans say, "Had the Beneficent God wanted, we would not have worshipped them (idols)." Whatever they say is not based on knowledge. It is only a false conjecture. |
| 043:020 Shakir | : |
And they say: If the Beneficent Allah had pleased, we should never have worshipped them. They have no knowledge of this; they only lie. |
| 043:020 Sherali | : |
And they say, 'If the Gracious God had so willed, we should not have worshiped them.' They have no knowledge whatsoever of that. They do nothing but conjecture. |
| 043:020 Yusufali | : |
("Ah!") they say, "If it had been the will of (Allah) Most Gracious, we should not have worshipped such (deities)!" Of that they have no knowledge! they do nothing but lie! |
Concepts/Themes Covered: أركان الإسلام > التوحيد > الشرك والمشركون > الشُبَه التي يحتج بها المشركون Pillars of Islam> Islamic> Polytheism and the Polytheists> The Pretexts Offered by the Polytheists as a Proof أركان الإسلام > التوحيد > الكافرون > التهكم بالكفار Pillars of Islam> Islamic> The Disbelievers> The Mockery against the Disbelievers أركان الإسلام > التوحيد > الكافرون > شُبه الكفار واحتجاجهم بالقدر Pillars of Islam> Islamic> The Disbelievers> The Disbelievers' Pretexts and Their Plea in Destiny الإيمان > الملائكة > الإيمان بهم Faith> The Angels> To Believe in them
This tool uses eight English parallel translations for the Holy Quran imported from Mr. Clay Smith. You can also visit Qurany Concepts for browsing the Quran themes or topics. If you want to search the Holy Quran for keywords, please visit Qurany Keywords.


Students plan rally at B.C. education minister’s office as district strike enters third week
Saanich School District students plan to rally outside Rob Fleming’s constituency office in Victoria
by Nina GrossmanA group of students are set to gather outside the education minister’s constituency office in Victoria on Wednesday to demand an end to a weeks-long strike in the Saanich School District.
READ ALSO: SD63 says grade 12 students ‘will not lose their graduation year’ due to strike
“We intend to ask Minister [Rob] Fleming to direct the parties to remain at the table and resolve the strike as soon as possible,” says an email from student Grace Warren.
“If that cannot be done, we will be asking Minister Fleming to introduce return-to-work legislation and allow for classes to resume while an arbitrator works with the parties to reach a resolution.”
READ ALSO: Saanich Peninsula families to rally in support of striking support staff
More than 7,000 students within the district have been home from school since the job action started on Oct. 28.
The main sticking point for unionized support staff is low wages, with the union asking for them to be brought in line with those in surrounding school districts.
READ ALSO: Pay disparity at heart of Saanich schools strike has 45-year-old roots


Oh no, there aren't any vans running now but we'll send one as soon as possible!
Van {{$index+1}}
Space: {{isFull(van)}}
Next Stop:
Contact Driver
{{van.contact}}
{{location.location}}


Free up your staff
Sealed is a unique and premium amenity that reduces your operating costs.
Your staff are busy leasing and assisting residents, and shouldn’t be spending time
managing packages. Let them do the job you hired them for.
 Large packages not fitting in your overflowing lockers?
We can handle any number and size of packages, preventing
overflow and elminating space constraints.
Luxury and convenience
Residents expect their packages to arrive safely and on-time. Our unique service makes your listings more attractive to residents.
Happy residents stay longer and
complain less.
Focus on what matters
The WSJ reports that each
package can take 10 minutes to handle. With hundreds of deliveries a month, this costs property managers thousands of dollars.
With more time to do their job, leasing agents can keep more
units filled and increase revenue.
Unlimited Packages
Property managers don't have to worry about packages filling up the leasing office, lobby or front desk.
Any-Sized Packages
Large or small, we deliver it exactly on your residents schedule.
Relieve Staff
Free up time and let staff focus on leasing, customer service, and doing their job.
Same-Day Delivery
Our automated service center gets packages to residents faster than manual processing in the lobby.
Easy App
Residents can schedule deliveries for when they are home. No more complaints to property managers.
Increase Revenue
Improve resident experience while reducing operating costs and letting agents focus on leasing.


A project, form, and submission API Url.
Available options to configure the Javascript API.
The Action ID derived from a provided Action url.
A specific action api endoint.
The actions url provided a form url as the source.
The base API url of the Form.io Platform. Example: https://api.form.io
The Form ID derived from the provided source.
A specific form url derived from the provided source.
The forms url derived from the provided source.
If this is a non-project url, such is the case for Open Source API.
The project type.
The Project ID found within the provided source.
A specific project endpoint derived from the provided source.
The Projects Endpoint derived from the provided source.
The query string derived from the provided src url.
The roleID derieved from the provided source.
A specific Role URL provided the source.
The roles endpoint derived from the provided source.
The submission ID provided a submission url.
A specific submissions URL derived from a provided source.
The submissions URL derived from the provided source.
A direct interface to the Form.io fetch Headers polyfill.
The project url to use for Authentication.
The base API url of the Form.io Platform. Example: https://api.form.io
The Form.io API Cache. This ensures that requests to the same API endpoint are cached.
De-registers a plugin.
The plugin you wish to deregister.
Handles events fired within this SDK library.
A direct interface to the Form.io fetch polyfill.
Returns a plugin provided the name of the plugin.
The name of the plugin you would like to get.
Stores all of the libraries lazy loaded with Formio.requireLibrary
method.
The namespace used to save the Form.io Token's and variables within an application.
The path type for the project.
Allows a Plugin to alter the behavior of the JavaScript library.
Gets a value from a Plugin
Wait for a plugin function to complete.
A function within the plugin.
The project API url of the Form.io Project. Example: https://examples.form.io
Set to true if the project url has been established with Formio.setProjectUrl()
Registers a new plugin.
The Plugin object.
The name of the plugin you wish to register.
All of the auth tokens for this session.
The version of this library.
Instance method for Formio.accessInfo
Returns the action information for a specific action, such as "save".
const formio = new Formio('https://examples.form.io/example/actions/save');
formio.actionInfo().then((info) => {
console.log(info);
});
The name of the action you would like to get information for. i.e. "save", "webhook", etc.
Returns a list of available actions
`Determine if the current user can submit a form.
Instance method for Formio.currentUser
Options to pass to Formio.request
Deletes a remote resource of any provided type.
The type of resource to delete. "submission", "form", etc.
Delete an action
const formio = new Formio('https://examples.form.io/example/action/234234234234');
formio.deleteAction().then(() => {
console.log('Action was deleted.');
});
Deletes a form.
const formio = new Formio('https://examples.form.io/example');
formio.deleteForm().then(() => {
console.log('Deleted!');
});
Deletes a project
const formio = new Formio('https://examples.form.io');
formio.deleteProject();
Deletes a role within a project.
Deletes a submission.
Get a PDF download url for a submission, which will generate a new PDF of the submission. This method will first fetch a temporary download token, and then append this to the download url for this form.
const formio = new Formio('https://examples.form.io/example/submission/324234234234234');
formio.getDownloadUrl().then((url) => {
console.log(url);
});
Get the ID of a form.
const formio = new Formio('https://examples.form.io/example');
formio.getFormId().then((formId) => {
console.log(formId);
});
Get the project ID of project.
const formio = new Formio('https://examples.form.io');
formio.getProjectId().then((projectId) => {
console.log(projectId);
};
Returns a temporary authentication token for single purpose token generation.
The amount of seconds to wait before this temp token expires.
The allowed path string inn the format GET:/path
The options passed to {@link Formio#getToken}
Returns the JWT token for this instance.
The following options are provided.
Returns the index (array of records) for any provided type.
The type of resource to fetch the index of. "submission", "form", etc.
A query object to pass to the request.
Determine if a string ID is a valid MongoID.
The id that should be tested if it is avalid id.
The type of resource to fetch the index of. "submission", "form", etc.
A query object to pass to the request.
Loads a form action.
const formio = new Formio('https://examples.form.io/example/action/234234234234');
formio.loadAction().then((action) => {
console.log(action);
});
Query parameters similar to {@link Formio#load}.
Loads all actions within a form.
const formio = new Formio('https://examples.form.io/example');
formio.loadActions().then((actions) => {
console.log(actions);
});
Query parameters similar to {@link Formio#load}.
Loads a form.
const formio = new Formio('https://examples.form.io/example');
formio.loadForm().then((form) => {
console.log(form);
});
Query parameters similar to {@link Formio#load}.
Loads all forms within a project.
const formio = new Formio('https://examples.form.io');
formio.loadForms().then((forms) => {
console.log(forms);
});
Query parameters similar to {@link Formio#load}.
Query parameters to pass to {@link Formio#load}.
Loads a role within a project.
const formio = new Formio('https://examples.form.io/role/234234234234');
formio.loadRole().then((role) => {
console.log(role);
});
Load all roles within a project.
const formio = new Formio('https://examples.form.io');
formio.loadRoles().then((roles) => {
console.log(roles);
});
Loads a specific submissionn.
const formio = new Formio('https://examples.form.io/example/submission/23423423423423423');
formio.loadSubmission().then((submission) => {
console.log(submission);
});
Query parameters similar to {@link Formio#load}.
Loads all submissions within a form.
const formio = new Formio('https://examples.form.io/example');
formio.loadSubmissions({
params: {
limit: 25,
'data.lastName__regex': 'smith'
}
}).then((submissions) => {
// Should print out 25 submissions where the last name contains "smith".
console.log(submissions);
});
Query parameters similar to {@link Formio#load}.
The request resource type. "submission", "form", etc.
The URL to request.
The request method. GET, PUT, POST, DELETE, or PATCH
The data to pass to the request (for PUT, POST, and PATCH methods)
Save a document record using "upsert". If the document does not exist, it will be created, if the _id is provided, it will be updated.
The type of resource to fetch the index of. "submission", "form", etc.
The resource data object.
Create a new or update an existing action.
const formio = new Formio('https://examples.form.io/example');
formio.saveAction({
data: {
name: 'webhook',
title: 'Webhook Action',
method: ['create', 'update', 'delete'],
handler: ['after'],
condition: {},
settings: {
url: 'https://example.com',
headers: [{}],
block: false,
forwardHeaders: false
}
}
}).then((action) => {
console.log(action);
});
const formio = new Formio('https://examples.form.io/example/action/234234234234');
formio.loadAction().then((action) => {
action.title = 'Updated title';
formio.saveAction(action).then(() => {
console.log('Done!');
});
});
The action JSON
Create or Update a specific form.
const formio = new Formio('https://examples.form.io');
formio.saveForm({
title: 'Employee',
type: 'resource',
path: 'employee',
name: 'employee',
components: [
{
type: 'textfield',
key: 'firstName',
label: 'First Name'
},
{
type: 'textfield',
key: 'lastName',
label: 'Last Name'
}
]
});
const formio = new Formio('https://examples.form.io/example');
formio.loadForm().then((form) => {
form.title = 'Changed Title';
formio.saveForm(form).then(() => {
console.log('DONE!!!');
});
});
The Form JSON to create or update.
Saves or Updates a project.
const formio = new Formio();
formio.saveProject({
title: 'My Project',
path: 'myproject',
name: 'myproject'
});
const formio = new Formio('https://examples.form.io');
formio.loadProject().then((project) => {
project.title = 'Title changed';
formio.saveProject(project).then(() => {
console.log('Done saving project!');
});
});
The project JSON to create or update.
Create a new or Update an existing role within a project.
const formio = new Formio('https://examples.form.io');
formio.saveRole({
title: 'Employee',
description: 'A person who belongs to a company.'
}).then((role) => {
console.log(role);
});
const formio = new Formio('https://examples.form.io/role/234234234234234');
formio.loadRole().then((role) => {
role.title = 'Manager';
formio.saveRole(role).then(() => {
console.log('DONE');
});
});
Creates a new or Updates an existing submission.
const formio = new Formio('https://examples.form.io/example');
formio.saveSubmission({
data: {
firstName: 'Joe',
lastName: 'Smith'
}
}).then((submission) => {
// This will now be the complete submission object saved on the server.
console.log(submission);
});
const formio = new Formio('https://examples.form.io/example/submission/23423423423423423');
formio.loadSubmission().then((submission) => {
submission.data.lastName = 'Thompson';
formio.saveSubmission(submission).then(() => {
console.log('DONE');
});
});
The submission JSON object.
Sets the JWT token for this instance.
The JWT token to set.
The following options are provided.
Returns the user permissions to a form and submission.
The user or current user if undefined. For anonymous, use "null"
The form or current form if undefined. For no form check, use "null"
The submisison or "index" if undefined.
Return the access information about a Project, such as the Role ID's for that project, and if the server is configured to do so, the Form and Resource access configurations that the authenticated user has access to.
The Formio instance.
Clears the runtime internal API cache.
Clones the response from the API so that it cannot be mutated.
Return the currentUser object. This will fetch the user from the server and respond with the Submission JSON of that user object.
The Formio instance
The options passed to Formio.getUser
Returns the current base url described at Formio.setBaseUrl
Gets the project path type.
Returns the Project url described at Formio.setProjectUrl
Returns the token set within the application for the user.
The options as follows.
Returns the user JSON.
Options as follows
Determines if a lazy loaded library is ready to be used.
The name of the library to check.
Loads a list of all projects.
Formio.loadProjects().then((projects) => {
console.log(projects);
});
Query parameters similar to {@link Formio#load}.
Performs a logout of the Form.io application. This will reset all cache, as well as make a request to the logout endpoint of the Form.io api platform.
A Formio instance.
Options passed to both Formio.setToken as well as Formio.setUser
Make an API request and wrap that request with the Form.io Request plugin system. This is very similar to the {Formio.request} method with a difference being that it will pass the request through the Form.io request plugin.
An instance of the Formio class.
The request resource type. "submission", "form", etc.
The URL to request.
The request method. GET, PUT, POST, DELETE, or PATCH
The data to pass to the request (for PUT, POST, and PATCH methods)
Much like Formio.currentUser, but instead automatically injects the Bearer tokens into the headers to perform a Token swap of the OAuth token which will then return the JWT token for that user.
The Formio instance
An OAuth Bearer token to use for a token swap between the OAuth provider and Form.io
Perform an Okta Authentication process using the Okta SDK.
Options that are passed directly to the Okta SDK constructor
Returns the query passed to a page in JSON object format.
Returns an array of roles for the project, which includes the ID's and names of those roles.
The Formio instance.
Execute an API request to any external system. This is a wrapper around the Web fetch method.
Formio.request('https://examples.form.io').then((form) => {
console.log(form);
});
The URL to request.
The request method. GET, PUT, POST, DELETE, or PATCH
The data to pass to the request (for PUT, POST, and PATCH methods)
An object of headers to pass to the request.
Lazy load a remote library dependency.
The internal name to give to the library you are loading. This is useful for caching the library for later use.
The name of the global property that will be added to the global namespace once the library has been loaded. This is used to check to see if the property exists before resolving the promise that the library is ready for use.
The URL of the library to lazy load.
Determines if polling should be used to determine if they library is ready to use. If set to false, then it will rely on a global callback called ${name}Callback where "name" is the first property passed to this method. When this is called, that will indicate when the library is ready. In most cases, you will want to pass true to this parameter to initiate a polling method to check for the library availability in the global context.
Perform a SAML initialization.
Options to pass to the SAML initialization process.
The Auth URL can be set to customize the authentication requests made from an application. By default, this is just the same value as Formio.projectUrl
The authentication url
Sets the BaseURL for the application.
The URL of the Base API url.
Sets the project path type.
Sets the Project Url for the application. This is an important method that needs to be set for all applications. It is documented @ Formio.setBaseUrl.
The project api url.
Sets the JWT in storage to be used within an application.
The JWT token to set.
Sets the current user within the application cache.
JSON object of the user you wish to set.
A common static method to trigger any SSO processes. This method is really just an alias for other static methods.
The type of SSO to trigger. 'saml' is an alias for Formio.samlInit, and 'okta' is an alias for Formio.oktaInit.
Options to pass to the specific sso methods
Generated using TypeDoc
The Formio interface class. This is a minimalistic API library that allows you to work with the Form.io API's within JavaScript.
Usage
Creating an instance of Formio is simple, and takes only a path (URL String). The path can be different, depending on the desired output. The Formio instance can also access higher level operations, depending on how granular of a path you start with.
Where endpoint is any valid API endpoint within Form.io. These URL's can provide a number of different methods depending on the granularity of the endpoint. This allows you to use the same interface but have access to different methods depending on how granular the endpoint url is. options is defined within the {link Formio.constructor} documentation.
Here is an example of how this library can be used to load a form JSON from the Form.io API's


Share your scientific, journalistic and educational material with the world in a reproducible and interactive way
The myBinder.org project drastically lowers the bar to sharing and re-using software. For the user to try out someone else's work requires only clicking a single link. For the author to prepare a binder-ready project is much easier than having to support many different platforms and for many projects involves little additional work. However Binder itself is a tool that requires some investment to master. The majority of researchers, journalists and educators have not yet discovered the Binder project or have heard it mentioned but do not know how to get started.
At this workshop you will learn how others are using myBinder.org and related tools. At the end of the workshop you will be able to take some of your own content (in a R or Jupyter notebook) and prepare it so that it can be used by others on myBinder.org.
These are the confirmed locations for the build a binder workshops. For details on how to apply to take part checkout each location's page.
09:00 - 09:15 |
Doors open |
09:15 - 09:30 |
Welcome, admin, safety, CoC, goal of the day |
09:15 - 09:30 |
Introduction round, who are you, what do you want to get out of this |
09:45 - 10:30 |
Introduction to binder, showcasing creative uses of binder |
10:30 - 11:00 |
Coffee break |
11:00 - 12:30 |
Zero2Binder - How to get a repository to work on mybinder.org |
12:30 - 13:30 |
Lunch |
13:30 - 14:00 |
Quiet work time - catch up on your email or chat with others |
14:00 - 14:01 |
Welcome back |
14:01 - 15:15 |
Work on your own Binder - get your own repository working on mybinder.org |
15:15 - 15:45 |
Coffee break |
15:45 - 16:45 |
TBD |
16:45 - 17:15 |
Cool things from today, show and tell what you worked on |
17:15 - 17:30 |
Wrap up, where to next? |
17:30 |
Hang out if you want to. |


Seven countries sign up to further collaboration to combat fake news online
by By Digital Desk staffA declaration has been signed by law makers from seven countries to advance international collaboration on the regulation of social media.

The countries that signed up to the principles are Ireland, Australia, Finland, Estonia, Singapore, UK and USA.
Members of the International Grand Committee on Disinformation and 'Fake News' signed the agreed principles in Leinster House this evening, at the end of a day-long meeting in the Seanad Chamber.
Committee chair Hildegarde Naughton said: “In addition to the set of principles, we have all agreed that individual States should put in place a moratorium on micro-targeted political advertising that contains false or misleading information until such time as regulation is in place.”
She said the issue of misleading political ads online was a common theme during the day’s evidence.
It was the third meeting of the ICG. The ICG met for the first time in Westminster at the end of 2019 and in Ottawa in May 2019.
READ MORE
Victim's rights campaigner says Kriegel family's words were 'the most important' she's heard


| Package | Description |
|---|---|
| net.glowstone | |
| net.glowstone.block | |
| net.glowstone.chunk | |
| net.glowstone.command | |
| net.glowstone.entity | |
| net.glowstone.io | |
| net.glowstone.io.anvil | |
| net.glowstone.io.data | |
| net.glowstone.io.entity | |
| net.glowstone.io.nbt | |
| net.glowstone.io.structure | |
| net.glowstone.scheduler |
This package contains the core of Glowstone's threading model.
|
| Modifier and Type | Method and Description |
|---|---|
GlowWorld |
GlowServer.createWorld(org.bukkit.WorldCreator creator) |
GlowWorld |
GlowServer.getWorld(String name) |
GlowWorld |
GlowServer.getWorld(UUID uid) |
| Constructor and Description |
|---|
Explosion(org.bukkit.entity.Entity source,
GlowWorld world,
double x,
double y,
double z,
float power,
boolean incendiary,
boolean breakBlocks)
Creates a new explosion.
|
| Modifier and Type | Method and Description |
|---|---|
GlowWorld |
GlowBlockState.getWorld() |
GlowWorld |
GlowBlock.getWorld() |
| Modifier and Type | Method and Description |
|---|---|
GlowWorld |
GlowChunk.getWorld()
The world of this chunk.
|
| Constructor and Description |
|---|
ChunkManager(GlowWorld world,
ChunkIoService service,
org.bukkit.generator.ChunkGenerator generator)
Creates a new chunk manager with the specified I/O service and world generator.
|
| Modifier and Type | Method and Description |
|---|---|
static GlowWorld |
CommandUtils.getWorld(org.bukkit.command.CommandSender sender)
Returns the world that the given command sender is referring to when not specifying one.
|
| Modifier and Type | Field and Description |
|---|---|
protected GlowWorld |
GlowEntity.world
The world this entity belongs to.
|
| Modifier and Type | Method and Description |
|---|---|
GlowWorld |
GlowEntity.getWorld()
The world this entity belongs to.
|
| Modifier and Type | Method and Description |
|---|---|
void |
WorldStorageProvider.setWorld(GlowWorld world)
Initializes the storage to correspond to the given world.
|
| Modifier and Type | Method and Description |
|---|---|
void |
AnvilWorldStorageProvider.setWorld(GlowWorld world) |
| Constructor and Description |
|---|
WorldFunctionIoService(GlowWorld world,
File dataDir) |
| Modifier and Type | Method and Description |
|---|---|
static GlowEntity |
EntityStorage.loadEntity(GlowWorld world,
CompoundTag compound)
Load a new entity in the given world from the given data tag.
|
| Constructor and Description |
|---|
NbtStructureDataService(GlowWorld world,
File structureDir)
Creates the instance for the given world's structures.
|
NbtWorldMetadataService(GlowWorld world,
File dir)
Creates the instance for the given world's metadata.
|
| Modifier and Type | Method and Description |
|---|---|
abstract T |
StructureStore.createNewStructure(GlowWorld world,
Random random,
int chunkX,
int chunkZ)
Create a new structure of this store's type in the given world.
|
GlowTemple |
TempleStore.createNewStructure(GlowWorld world,
Random random,
int chunkX,
int chunkZ) |
abstract T |
StructureStore.createStructure(GlowWorld world,
int chunkX,
int chunkZ)
Create a structure of this store's type in the given world.
|
GlowTemple |
TempleStore.createStructure(GlowWorld world,
int chunkX,
int chunkZ) |
static GlowStructure |
StructureStorage.loadStructure(GlowWorld world,
CompoundTag compound)
Load a structure in the given world from the given data tag.
|
| Modifier and Type | Method and Description |
|---|---|
GlowWorld |
WorldScheduler.addWorld(GlowWorld world)
Attempts to start scheduled ticks for a world.
|
GlowWorld |
WorldScheduler.getWorld(String name)
Returns the world with a given name.
|
GlowWorld |
WorldScheduler.getWorld(UUID uid)
Returns the world with a given UUID.
|
| Modifier and Type | Method and Description |
|---|---|
List<GlowWorld> |
WorldScheduler.getWorlds()
Returns an immutable list of the currently scheduled worlds.
|
| Modifier and Type | Method and Description |
|---|---|
GlowWorld |
WorldScheduler.addWorld(GlowWorld world)
Attempts to start scheduled ticks for a world.
|
boolean |
WorldScheduler.removeWorld(GlowWorld world)
Stops scheduled ticks for a world.
|
Copyright © 2021. All rights reserved.


Session storage
Session storage stores data only till tab/window is closed
Print all variables in session storage
for(var i=0; i<sessionStorage.length; i++) {- console.log(sessionStorage.key(i), " = ", sessionStorage.getItem(sessionStorage.key(i)));
}
Local storage
Local storage is persistent storage
Browser has one storage for one domain (multiple apps on same domain can share same storage)
Accessed via javascript setItem() and getItem()
Print all variables in local storage
for(var i=0; i<localStorage.length; i++) {- console.log(localStorage.key(i), " = ", localStorage.getItem(localStorage.key(i)));
}
Database storage
ALL STORAGES CAN BE INSPECTED VIA Developer tools > STORAGE TAB


About
This minimalistic website is the result of a lot of borrowing. The goal was to not use a framework or media queries. This project will give you an introduction to HTML, CSS, Markdown, and how build tools work without have to install anything extra on the Mac.


- Please create a small project using Line messaging API for getting a notification when your Line Bot can not
answer a question to the customer more than 10 second
Note: If user send messages that contain "test" in them, it will be forwarded to admin group
(Refers to the message not meeting the conditions for the bot's response.).


BMI Calculator
Select a method to Compute BMI
Metric
Imperial
Enter Weight in kilograms:
Enter Height:
Enter Weight in pounds:
Enter Height in Feet:
Enter Height in Inches:


Booked Trades
New Trade
Sell CCY
Sell Amount
Buy CCY
Buy Amount
Rate
Date Booked
{{x.SellCurrency}}
{{x.SellAmount}}
{{x.BuyCurrency}}
{{x.BuyAmount}}
{{x.Rate}}
{{x.DateBooked}}


TO CHOOSE A WIFE.
ASCERTAIN the day of the young woman's birth, and refer to the last chapter of Proverbs. Each verse from the 1st to the 31st is supposed to indicate, either directly or indirectly, the character, and to guide the searcher--the verse corresponding with her age indicating the woman's character.


Server error
We'll look into it.
Try returning home
.
{% include "ext/uservoice.html" %} {% include "ext/goog.html" %} {% include "ext/chrome_frame.html" %}


After months of work to bring our ideas to life, we unveiled our CapsuleMate prototype at the 2019 Mechatronics
symposium.
It was a fun day spent chatting with fellow students and the general public who were curious about our design and it’s applications.
We were able to share our goals, learnings and most of all, actually demonstrate CapsuleMate in action. For anyone who wasn’t able to see
it live, check out a quick compilation of it on Youtube
With symposium wrapped up, the team celebrated our success with some much deserved Korean food. Now, we look forward to completing
the report and reaching the finish line (graduation is in sight!). As excited as we are with our progress, we currently do not have any
plans to refine Capsulemate’s design or pursue this project any further. It’s been a great 8 months filled with lots of learning,
iteration and most of all fun! For anyone who has followed along with all of CapsuleMate’s progress, thank you!
We had a blast and are grateful to have had the opportunity to work on this project.
Regards,
Anne, Vivian, Martin, Tyurina
Left: Our Symposium booth Right: Tired Team eating Korean food
Week 8 Update: The Light at the End of the Tunnel
After 8 months of work, we’re finally at T- 3 days till symposium, hooray! This past week was spent putting the finishing touches on
the entire assembly, but mainly writing the accompanying software to have the pill dispenser work from start to finish.
Now that all the loose ends have been tied, we can dedicate this post to a step by step breakdown of the pill dispenser in action.
First, the pharmacist/user will provide all the information that the pill dispenser requires for the setup using the simple web interface.
Left: The Website to Load Pill Information Right: The Information Required Per Quadrant
The Raspberry Pi then receives this information and prompts the user to load the pills in succession. After all the quadrants are loaded,
the screen tells the user that loading is complete and when the pill will be dispensed next.
Video Left: The cylinders turning to start loading Image Right: Sample Loading Message
Finally, when it is time to dispense, the appropriate quadrant starts the sequence of operations required to dispense the pills.
First, the continuous servo motors starts up and stirs the pills to dislodge any that might be stuck in the storage compartment.
Then, the photoresistor verifies that a pill is in place and ready to dispense. At this point, the solenoid is powered causing the pill
to fall through the tubes and land in the nifty drawer we assembled this week. Finally, the buzzer is sounded at the end to alert the
user that a pill is dispensed.
Video Left: Sequence of Events to Dispense Video Right: Continuous Dispensing
Tada, and that is the pill dispenser in action! To look at the code more in-depth
check out the repository containing all the operational logic.
In the next couple of days, we will smooth out some minor aesthetic details and get the dispenser ready for the big day.
We’ll check back, after symposium is done!
Week 7 Update: The Puzzle is Coming Together
This week was a blur of action assembling all the bits and pieces into something ressembling a pill dispenser.
This involved ample time soldering the PCBs along with general assembly of each quadrant (the solenoid, servo motors, photoresistor etc.).
We also got around to designing and assembling the screen and button components both pictured below. Though chaotic the dispenser it starting
to take shape and we are thrilled!
Left: MVP Pill Dispenser Right: The User Interface
This week, progress was made towards the software. Up until now, software has been on the back burner as this project is
mechanically intensive. However, now that we are closing in on symposium it became a larger focus. We wrote the functions to control
the pill dispenser (i.e turning the cylinder, pushing the solenoid) and also found a cool Python library that easily allows us to schedule
tasks to occur at arbitrary times such as dispensing pills. All the code is sitting in our public
repository.
Next week we will tie up the remaining loose ends to get a fully functional dispenser end to end. For now enjoy some videos
of not one, but two quadrants working!
Video Left: Quadrant One Cylinder Turning Video Right: Quadrant Two Cylinder Turning
Week 6 Update: ¼ of the Way There!
Last week we got one quadrant of the dispenser working for the demo. This week we were able to get rid of the breadboard and start
using our fresh PCBs. In addition, we finally found some time to assemble the storage container and said goodbye to the infamous
cardboard walls from all the previous iterations. Next week, we will focus heavily on organizing and cleaning up the software
which up until this point has been run as separate scripts. For now, enjoy a video of one quad in action and a sneak peek of
what the final assembly will look like!
Video: Quadrant one of four in action
Left: Quad Cross Section Middle: Final Storage Container
Week 5 Update: Demo Time!
This week was an eventful one with the Iron Ring Ceremony happening on Feb 9th (we were all very excited to receive our rings!).
Alongside that, it was time to demo the progress on our FYDP. Our goal for the demo was to have one quadrant of the machine working
end to end. Thankfully, we were able to accomplish this by adding in the photoresistor to detect when pills have been dispensed
(check out Week 4).
In addition, over a few weeks time we made important modifications to our design. This includes adding gears to rotate the cylinder
component 360 degrees and moving the photoresistor to sit inside the pusher piece. To hold everything in place
we modified the basket holding the motor to also fit the gears, printed out the remaining storage funnels,
and laser cut the acrylic divider walls.
Left: New Motor Basket, Middle: Dividing Walls, Right: Storage Funnels
We then designed and ordered the PCB’s that will control the solenoids and motor. The order from PCB way came very quickly and is pictured below with the original design.
Next week: We will assemble the frame of the final structure, solder the PCB and make headway towards finishing the electro-mechanical build.
Week 4 Update: Photoresistor + LED
This past week we tested the last electrical component required to get quadrant one of the dispenser up and running.
This is the photoresistor and LED combo that verifies that a pill is actually dispensed in order to prevent false positives.
In our initial design, we toyed around with several different sensors to verify the pill dispensed such a load sensor and an
RGB colour sensor to verify based on weight or colour respectively. Ultimately, we chose a photoresistor and LED combo that
would sit inside the final dispensing tube. Upon testing the system we realized that while the photoresistor worked correctly,
the pill fell down through the tube too quickly for the photoresistor to recognize a change in light intensity. In the videos below
you can see the pill fall through the tube however in the second video you can that the photoresistor barely recognizes a change in value.
Video 1: The Photoresistor and LED setup inside the tube. Video 2: The photoresistor detecting the pill
We then brainstormed alternate solutions, one of which was to re-locate the photoresistor to the bottom of the tube so
that the pill would be stationary; thus, giving the photoresistor enough time to detect it. When this didn’t work we rethought
our strategy for the pill dispenser. The purpose of the photoresistor and the LED combo is to verify that a pill is actually
dispensed by the solenoid and prevent false positives. Therefore, we can detect the pill anytime after it is dispensed not
solely as it’s falling through the tube. For this reason, we decided to relocate the photosensor into the side of the pusher
piece where the pill remains stationary for several seconds until it is dropped into the tube.
Video 3: A large change in light intensity detected by the photoresistor
In the video above, the photo resistor values increase by 200 when the pill is detected. With some more testing, we found
that the photosensor seemed to output the greatest difference in values without the LED shining on it.
The contrast between the ambient light and the presence of the pill seemed sufficient, but we will test this again on the
final build and pick a solution that maximizes the change in light intensity. Either way, with this we managed to complete
all the functions (mechanical and electrical) required to get one quadrant of the structure working!
Week 3 Update: The Power of Gears
Last week we left off with the struggle of finding non-continuous 360 servo motors to rotate the cylinder component.
While it is possible to turn a regular servo motor into a continuous rotation one, there were no hacks to make the opposite true.
We scoured the interwebs some more and disgruntedly accepted that we would have to replace servos for stepper motors.
This was undesirable because stepper motors require separate boards to control them, which then need to be stacked on top of the Pi.
We then had the ingenious idea of converting the servo motor’s 180 degrees range to 360 degrees using gears (2:1 gear ratio)
We quickly made a CAD model of the gears and after iterating to find the correct size we 3D printed them.
With a little bit of sanding, some will power and Martin holding everything in place, we tested the prototype and found it successful!
In the video below you can see that the cylinder is able to rotate from funnels 1 - 4 even though the servo motor only supports ~160 degrees of rotation.
Now that we extended the range of motion of the servo motors, we will update the code so that the funnels of the cylinder align to the
storage component correctly. We will also modify the CAD for the base plate to accommodate for the gears.
This week, we also tested the pill detection strategy by assembling prototype 1 of the light sensor + photoresistor but we will
talk about that more in next week’s blog post. Anyway, we are 75% of the way to automating a quadrant of the whole structure and are
excited to see it working end-to-end!
Week 2 Update: RIP Raspberry PI & One Quadrant Assembly
This week the team went in with the goal of assembling a full quadrant of the full pill dispensing apparatus.
Right off the bat there was a slight hitch, namely that our Raspberry Pi had died. This was a problem since it controls the solenoid for dispensing, the stirring rods, the alignment cylinder and basically our entire apparatus.
Nevertheless, this unexpected hump turned out to be a valuable lesson about static electricity and that anything with exposed electronics including the Raspberry Pi is vulnerable to it.
We replaced the PI and reviewed ESD precautions by investing in an anti-static strap, and generally discharging static by touching a grounded metal object before touching the PI.
With the new PI in place, we were able to assemble a full quadrant of the structure and power it with electronics. We laser cut the base (which will house all the electrical components) out of acrylic sheets.
Then, we mounted the dispensing structure above it to see a full quadrant in operation.
v
As a bonus, we connected the electronics available (servomotors to control the stirring rod and the solenoid to push out pills) to get a quasi-automated structure as seen in the video below. As anticipated, with the aid of the stirring stick the pills dislodge from the storage container, then the pusher piece and solenoid combo successfully isolate one pill to dispense.
Next steps
Assembling this quadrant gave the team an opportunity to observe nuances with the physical build that weren’t noticed in the CAD designs. As expected we discovered a few changes we need to make with the remaining parts before printing them:
→ Reduce the size of the base plates to 14cm x 14 cm so they fit together better on top of the base
→ Design a more sturdy stirring rod
→ Support the motor so that it stays aligned in the centre of the storage compartment.
We also discovered that the servo motor we purchased only supported continuous 360 rotation, and cannot turn to a specified angle. Since our cylinder component needs to be turned a certain amount we ordered new motors.In this upcoming week, we will focus on the photosensor and LED combo to detect whether a pill has fallen, which should be the last step to produce a fully automated mechanism.
Week 1 Update: When Gravity Just Isn't Enough
Coming into 2019, we moved out of the design phase and started building the first iteration of the full mechanical structure. This includes the dispensing mechanism prototyped early last fall, the storage component, and the tube with the photosensor. To see earlier updates of the dispensing mechanism and some other CAD designs check out our gallery page.
To begin, we started by 3D printing the components and fitting them together. After printing out the bits and assembling one quadrant of the final structure we identified the first hurdle. The pills did not fall out of the storage component as expected. Instead, they jammed in the storage component, totally unreachable by the dispensing mechanism as seen in the video below.
Fluke solution: Frustrated with the problem, we knocked the storage component around a little bit and realized that with enough of a push the pills would dislodge. Then came the problem of how to automate this motion. After pondering for a few days we came up with several creative solutions to address the problem of the jammed pills (the viable ones are listed below):
→ A slide or conveyer belt within the storage vault to keep the pills moving. The con to this solution is how to go about accomodating a conveyer with the existing design.
→ Another idea is to make the entire storage container vibrate. One concern with this idea is how much vibration is required to keep the pills moving. In addition, there is difficulty decoupling the storage component from the rest of the chassis.
After many rounds of brainstorming, we came to the easiest solution, a rotating arm in the centre of the storage component to prevent the pills from getting jammed. The benefit of this idea is that it is minimally invasive to our current design and was easy to test out. Immediately, we went about making a quick prototype as seen below.
The straw has an arm at the bottom that sweeps the bottom of the storage funnel and dislodges any stuck pills. Content with the first test we went about automating it by adding a motor to control the rotation.
Success, we will update our SolidWorks model to reflect these changes and continue to move forward!


Jessica Lam
(Product Lead)
🅱RUH
Daniel Antonio
(Web Designer)
I like long walks to the fridge and memes.
Ryan Lee
(Web Designer)
Give me a < br />.
Dominique Kitchenakow
(Front-End Dev)
Sneezing while driving is honestly a near death experience.
Simon Huang
(Front-End Dev)
Why did the programmer quit? Because he didn't get arrays.
Jazmine McGinnis
(Front-End Dev)
!false. It's funny because it's true.


After you've prepared the list of project files, Code Co-op will start adding them to the project database. For each new extension, it will display the following dialog:
There are four basic categories of files: header, source, other text, and binary. The most important is the distinction between binary files and other types. Once you assign binary type to a file, you won't be able to see its file differences (which are hard to display for non-text files). The rule of thumb is that files that are not divided into reasonably short lines of text (by newline characters) should be added as binary. In particular images, animations, MP3s, Microsoft Office documents, Access databases, etc., should be treated as binary files. On the other hand, Visual Studio solution and project files (.sln, .vcproj) should be added as (other) text files.


The workflow is the following :
RESThub uses Spring Security OAuth2 implementation on the server-side.
To use it, add this dependency in your pom.xml :
<dependency>
<groupId>org.resthub</groupId>
<artifactId>resthub-oauth2-spring-security</artifactId>
<version>1.1</version>
</dependency>
And here is a sample configuration to be added in your applicationContext.xml :
<security:authentication-manager>
<security:authentication-provider user-service-ref="myUserDetailsService" />
</security:authentication-manager>
<security:http entry-point-ref="oauth2ProcessingFilterEntryPoint" create-session="never">
<security:access-denied-handler ref="oauth2AccessDeniedHandler" />
<security:intercept-url pattern="api/**"/>
</security:http>
<bean id="oauth2AccessDeniedHandler" class="org.springframework.security.web.access.AccessDeniedHandlerImpl"/>
<bean id="tokenServices" class="org.springframework.security.oauth2.provider.token.InMemoryOAuth2ProviderTokenServices" />
<oauth2:provider client-details-service-ref="clientDetails" token-services-ref="tokenServices" >
<oauth2:verification-code disabled="true"/>
</oauth2:provider>
<oauth2:client-details-service id="clientDetails" >
<oauth2:client clientId="myClientID" authorizedGrantTypes="password" />
</oauth2:client-details-service>
You will also have to add these lines to your web.xml, below the contextConfigLocation context-param block :
<filter>
<filter-name>springSecurityFilterChain</filter-name>
<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
</filter>
<filter-mapping>
<filter-name>springSecurityFilterChain</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<filter>
<filter-name>JpaFilter</filter-name>
<filter-class>org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter</filter-class>
</filter>
You can have a look to Booking or Identity manager sample applications to see how it works.
You will certainly have communications between protected resource services. If you choose to use tokens between your protected service, as described in the (TODO) server-to-server profile, we offer you some utilities to do that.
In your “client” resource server:
This class stores in memory tokens you may need to access as many protected resource as you want. You have to configure it:
WARNING - For this first release, client id/secret ARE end-user credential, so you need a “Technical user” in your authorization service that will represent your java clients
You can use in many ways this utility class:
Some example? Spring bean definition
<bean name="tokenRepository" class="org.resthub.oauth2.client.TokenRepository">
<property name="clientId" value="foo"/>
<property name="clientSecret" value="bar"/>
<property name="authorizationEndPoints">
<list>
<value>http://XXX.XXX.XXX.XXX:YYY/oauth/authorize</value>
</list>
</property>
</bean>
Java code:
@Inject
protected TokenRepository tokenRepository;
// Enrich and trigger a request.
String resourceName = "/myResource";
HttpClient httpClient = ClientFactory.create();
XXX result = tokenRepository.enrich(httpClient.path(resourceName)).get(XXX.class);


Brothers Osborne Thanksgiving halftime show slammed after power goes out amid technical issues
by Tyler McCarthyCountry duo The Brothers Osborne had to win back the crowd after technical difficulties caused the power to go out in the middle of their halftime show at a Thanksgiving Day football game.
The country singers, T.J. and John Osborne, performed at the game between the Chicago Bears and the Detroit Lions at the Ford Field in Detroit, Mich. on Thursday. As seen in videos posted to social media by those in attendance, the show hit a speed bump when they began to sing their hit single “Stay A Little Longer.”
COUNTRY DUO BROTHERS OSBORNE NOT AFRAID TO SPEAK THEIR MINDS
Just as they start to get into the vocals, the power cut out and the packed stadium went eerily silent for a beat before groans and boos emerge from the crowd. The Wrap reports that one of the country singers said, “We’ll get it figured out,” while people behind the scenes worked quickly to restore power so the show could go on.
The outlet notes that the fans were particularly impatient with the singers as the first two attempts to start the show were marred by sound issues even before the power went out.
After several minutes, the third time was the charm and the brothers were able to continue with their show. Still, the power outage was captured by many fans in the stands, some of whom took to Twitter to lambast the country stars and the stadium for the gaffe.
“Uhhhh....halftime? What happened?” one user who shared video of the incident wrote.
GRAMMY'S 'TEARS IN HEAVEN' LAS VEGAS SHOOTING TRIBUTE SLAMMED ON SOCIAL MEDIA
“When the Detroit Lions forget to pay their electric bill,” one user mocked.
Detroit: They can't even do a halftime show properly," a third user joked. "It's probably for the best.
CLICK HERE TO GET THE FOX NEWS APP
Representatives for the singers did not immediately respond to Fox News' request for comment.


| quasiquotation {rlang} | R Documentation |
Quasiquotation is the mechanism that makes it possible to program
flexibly with tidy evaluation grammars like dplyr. It is enabled in
all tidyeval quoting functions, the most fundamental of which are
quo()
and expr()
.
Quasiquotation is the combination of quoting an expression while allowing immediate evaluation (unquoting) of part of that expression. We provide both syntactic operators and functional forms for unquoting.
The !!
operator unquotes its argument. It gets evaluated
immediately in the surrounding context.
The !!!
operator unquotes and splices its argument. The
argument should represent a list or a vector. Each element will
be embedded in the surrounding call, i.e. each element is
inserted as an argument. If the vector is named, the names are
used as argument names.
If the vector is a classed object (like a factor), it is
converted to a list with base::as.list()
to ensure proper
dispatch. If it is an S4 objects, it is converted to a list with
methods::as()
.
Use qq_show()
to experiment with quasiquotation or debug the
effect of unquoting operators. qq_show()
quotes its input,
processes unquoted parts, and prints the result with
expr_print()
. This expression printer has a clearer output than
the base R printer (see the documentation topic).
qq_show(expr)
expr |
An expression to be quasiquoted. |
When a function takes multiple named arguments
(e.g. dplyr::mutate()
), it is difficult to supply a variable as
name. Since the LHS of =
is quoted, giving the name of a variable
results in the argument having the name of the variable rather than
the name stored in that variable. This problem is right up the
alley for the unquoting operator !!
. If you were able to unquote
the variable when supplying the name, the argument would be named
after the content of that variable.
Unfortunately R is very strict about the kind of expressions
supported on the LHS of =
. This is why we have made the more
flexible :=
operator an alias of =
. You can use it to supply
names, e.g. a := b
is equivalent to a = b
. Since its syntax is
more flexible you can unquote on the LHS:
name <- "Jane" list2(!!name := 1 + 2) exprs(!!name := 1 + 2) quos(!!name := 1 + 2)
Like =
, the :=
operator expects strings or symbols on its LHS.
Note that unquoting on the LHS of :=
only works in top level
expressions.
These terms have a rich history in Lisp languages, and live on in
modern languages like
Julia
and
Racket.
Calling UQ()
and UQS()
with the rlang namespace qualifier is
deprecated as of rlang 0.3.0. Just use the unqualified forms
instead:
# Bad rlang::expr(mean(rlang::UQ(var) * 100)) # Ok rlang::expr(mean(UQ(var) * 100)) # Good rlang::expr(mean(!!var * 100))
Supporting namespace qualifiers complicates the implementation of unquotation and is misleading as to the nature of unquoting operators (which are syntactic operators that operates at quotation-time rather than function calls at evaluation-time).
UQ()
and UQS()
were soft-deprecated in rlang 0.2.0 in order
to make the syntax of quasiquotation more consistent. The prefix
forms are now `!!`()
and `!!!`()
which is
consistent with other R operators (e.g. `+`(a, b)
is the
prefix form of a + b
).
Note that the prefix forms are not as relevant as before because
!!
now has the right operator precedence, i.e. the same as
unary -
or +
. It is thus safe to mingle it with other
operators, e.g. !!a + !!b
does the right thing. In addition the
parser now strips one level of parentheses around unquoted
expressions. This way (!!"foo")(...)
expands to foo(...)
.
These changes make the prefix forms less useful.
Finally, the named functional forms UQ()
and UQS()
were
misleading because they suggested that existing knowledge about
functions is applicable to quasiquotation. This was reinforced by
the visible definitions of these functions exported by rlang and
by the tidy eval parser interpreting rlang::UQ()
as !!
. In
reality unquoting is not a function call, it is a syntactic
operation. The operator form makes it clearer that unquoting is
special.
# Quasiquotation functions quote expressions like base::quote() quote(how_many(this)) expr(how_many(this)) quo(how_many(this)) # In addition, they support unquoting. Let's store symbols # (i.e. object names) in variables: this <- sym("apples") that <- sym("oranges") # With unquotation you can insert the contents of these variables # inside the quoted expression: expr(how_many(!!this)) expr(how_many(!!that)) # You can also insert values: expr(how_many(!!(1 + 2))) quo(how_many(!!(1 + 2))) # Note that when you unquote complex objects into an expression, # the base R printer may be a bit misleading. For instance compare # the output of `expr()` and `quo()` (which uses a custom printer) # when we unquote an integer vector: expr(how_many(!!(1:10))) quo(how_many(!!(1:10))) # This is why it's often useful to use qq_show() to examine the # result of unquotation operators. It uses the same printer as # quosures but does not return anything: qq_show(how_many(!!(1:10))) # Use `!!!` to add multiple arguments to a function. Its argument # should evaluate to a list or vector: args <- list(1:3, na.rm = TRUE) quo(mean(!!!args)) # You can combine the two var <- quote(xyz) extra_args <- list(trim = 0.9, na.rm = TRUE) quo(mean(!!var , !!!extra_args)) # The plural versions have support for the `:=` operator. # Like `=`, `:=` creates named arguments: quos(mouse1 := bernard, mouse2 = bianca) # The `:=` is mainly useful to unquote names. Unlike `=` it # supports `!!` on its LHS: var <- "unquote me!" quos(!!var := bernard, mouse2 = bianca) # All these features apply to dots captured by enquos(): fn <- function(...) enquos(...) fn(!!!args, !!var := penny) # Unquoting is especially useful for building an expression by # expanding around a variable part (the unquoted part): quo1 <- quo(toupper(foo)) quo1 quo2 <- quo(paste(!!quo1, bar)) quo2 quo3 <- quo(list(!!quo2, !!!syms(letters[1:5]))) quo3


{% load staticfiles %}
HOME
Med-Easy
Predict Disease
Search Hospitals
Sign Up
Login
Previous
Next
×
Mobile Number :-
Password :-
Login
Cancel
Forgot
password?


|
Aspen MUD
Aspen is a light-weight, barebones mud engine written in c++ utilizing Lua for its' scripting engine.
|
#include <playerManager.h>
Public Member Functions | |
| std::list< Player * > * | GetPlayers () |
| bool | AddPlayer (Player *player) |
| bool | RemovePlayer (Player *player) |
| Player * | FindPlayer (const std::string &name) const |
| Player * | LoadPlayer (const std::string &name) const |
| void | Shutdown () |
| void | Update () |
This class manages all of the players online. Also provides useful utilities such as broadcast.
| bool PlayerManager::AddPlayer | ( | Player * | player | ) |
Adds the player to the players list. Only connected players should be added. Inactive players shouldn't be in this list.
| [in] a pointer to the player object to add. |
| std::list< Player * > * PlayerManager::GetPlayers | ( | ) |
Returns: a pointer to a list of pointers to player objects.
| bool PlayerManager::RemovePlayer | ( | Player * | player | ) |
Removes the specified player from the list of active players.
| [in] A pointer to the player object |
| void PlayerManager::Shutdown | ( | ) |
Should only be called by world's internal workings.
| void PlayerManager::Update | ( | ) |
Should only be called by world's internal workings.


Created by @patokeilty
Disclosure: ideas and materials borrowed from Linux Foundation online courses and material
Borrows heavily from the UNIX operating system because it was written to be a free and open source version of UNIX.
A partition is a logical part of the disk, whereas a filesystem is a method of storing/finding files on a hard disk
Windows vs Linux| Windows | Linux | |
| Partition | Disk1 | /dev/sda1 |
| Filesystem type | NTFS/FAT32 | EXT3/EXT4/XFS... |
| Mounting Parameters | DriveLetter | MountPoint |
| Base Folder where OS is stored | C drive | / |
Linux systems store their important files according to a standard layout called the Filesystem Hierarchy Standard, or FHS.
see external link Wikipedia FHS entry
Main sources of information
$ man 3 printf
$ man -a printf
$ info
$ info login
$ cat --help
$ help cd
Most input lines entered at the shell prompt have three basic elements:
The command is the name of the program, may be followed by options (or switches) that modify what the command may do. Options start with one or two dashes in order to differentiate them from arguments, which represent what the command operates on, e.g. -p or --print,
$ tail -f /tmp/adb.log
$ which diff
$ cd; cd ~ # change to home directory
$ cd ~/tmp/;
$ cd - # change to previous
$ cd ..; cd ../../ # move 1, 2 levels up
$ pwd
$ ls -alt .
$ tree -L 1 /home
$ touch new_file
$ mkdir test-dir
$ rm new_file
$ rm -r test-dir
$ cat ~/.profile
$ tail -f /var/log/syslog
$ man ls
$ info mysql
$ echo 'hola'
$ pushd ./tmp
$ dirs
$ popd
$ dirs
By default there are 3 standard file streams (or descriptors) available:
all open files are represented internally by what are called file descriptors, using numbers starting at zero: stdin is file descriptor 0, stdout is file descriptor 1, and stderr is file descriptor 2
We can redirect the 3 standard filestreams so that we can get input from either a file or another command instead of from our keyboard, and we can write output and errors to files or send them as input for subsequent commands, e.g.
$ less < ~/.profile
$ cat ~/.profile | less
$ ls -a ~ > /tmp/ls-output.txt
$ ls /tmp/inexistent 2> /tmp/error.txt
$ ls /tmp/inexistent > /tmp/error.txt 2>&1
The UNIX/Linux philosophy is to have many simple and short programs (or commands) cooperate together to produce quite complex results.
In order to accomplish this, extensive use of pipes (| symbol)is made; you can pipe the output of one command or program into another as its input
$ ls -alt /tmp/ | grep 'txt' |sort -u
$ locate txt #search files with 'txt' in filename
$ updatedb #update locate database
$ find /usr/lib -name gcc;
$ find ./dev -name 'README'
$ find /var/log/ -name syslog*
$ find /var/log/ -name 'syslog*' -exec ls -alt {} ';'
$ find /var/log/ -size +100k
$ find /var/log/ -ctime +3
$ find /var/log/ -ctime +3 -or -size +100k
Package management systems provide two tool levels
| Operation | RPM | Deb |
| Install a package | rpm –i foo.rpm | dpkg --install foo.deb |
| Install a package with dependencies from repository | yum install foo | apt-get install foo |
| Remove a package | rpm –e foo.rpm | dpkg --remove foo.deb |
| Remove a package and dependencies using repository | yum remove foo | apt-get remove foo |
| Update package to a newer version | rpm –U foo.rpm | dpkg --install foo.deb |
| Update package using repository and resolving dependencies | yum update foo | apt-get upgrade foo |
| Update entire system | yum update | apt-get dist-upgrade |
| Show all installed package | yum list installed | dpkg --list |
| Get information about an installed package including files | rpm –qil foo | dpkg --listfiles foo |
| Show available package with "foo" in name | yum list foo | apt -cache search foo |
| Show all available package | yum list | apt-cache dumpavail |
| What packages does a file belong to? | rpm –qf file | dpkg --search file |
Each filesystem resides on a hard disk partition. Partitions help to organize the contents of disks according to the kind of data contained and how it is used
$ fdisk -l /dev/sda
separate partitions are often used system programs, regular users data, and temporary files
The mount command is used to attach a filesystem (which can be local to the computer or on a network) somewhere within the filesystem tree
$ mount /dev/sda5 /home
$ mount /dev/dvd /media/data
The command df -Th (disk-free) will display information about mounted filesystems including usage statistics about currently used and available space.
$ df -hT
Certain filesystems like the one mounted at /proc are called pseudo filesystems because they have no permanent presence anywhere on disk.
The /proc filesystem contains runtime system information (e.g. system memory, devices mounted, hardware configuration, etc)
Each user has a home directory, usually placed under /home. The /root (slash-root) directory on modern Linux systems is no more than the root user's home directory.
$ ls /home
The /bin directory contains executable binaries, essential commands used in single-user mode, and essential commands required by all system users. e.g. ps, ls, cp
note: there are internal shell commands, and external or executable binaries/scripts
The /sbin directory is used for essential binaries related to system administration, like ifconfig, shutdown.
$ ls /bin
$ ls /sbin
The /dev directory contains device nodes, a type of pseudo-file used by most hardware and software devices, except for network devices.
The /var directory contains files that are expected to change in size and content as the system is running (var stands for variable)
The /etc directory is the home for system configuration files.
The /boot directory contains the few essential files needed to boot the system
The Grand Unified Bootloader (GRUB) files (such as /boot/grub/grub.conf) are also found under the /boot directory
/lib contains libraries (common code shared by applications and needed for them to run) for the essential programs in /bin and /sbin. The /media directory is typically located where removable media, such as CDs, DVDs and USB drives are mounted
The /boot directory contains the few essential files needed to boot the system
The /usr directory contains user space programs and scripts
diff is used to compare files and directories.
$ diff .bashrc .bashrc~
note: you can compare three files at once using diff3
Many modifications to source code and configuration files are distributed utilizing patches, patch files are actually produced by running diff.
$ patch -p1 < patchfile
$ patch originalfile patchfile
In Linux, a file's extension often does not categorize it, rather its content does.
$ file /usr/bin/perl
| Command | Usage |
| $ tar xvf mydir.tar | Extract all the files in mydir.tar into the mydir directory |
| $ tar zcvf mydir.tar.gz mydir | Create the archive and compress with gzip |
| $ tar jcvf mydir.tar.bz2 mydir | Create the archive and compress with bz2 |
| $ tar Jcvf mydir.tar.xz mydir | Create the archive and compress with xz |
| $ tar xvf mydir.tar.gz | Extract all the files in mydir.tar.gz into the mydir directory. Note you do not have to tell tar it is in gzip format. |


Choose your Animal Crossing island villagers based on their home exteriors! Use the dropdown menu to filter by house properties like architecture, color, or material.
I created the house data myself. I made up the architecture types, and all of the properties I set are a best guess. If you have feedback on the values I assigned to the homes you can find me on Twitter, Instagram, or GitHub by clicking the social icons below.


A small lightweight javascript library making snowfall effect
SnowFall Canvas Display
SnowFall Icon Display
SnowFall Image Display
SnowFall Svg Display
SnowFall Text Display


We examine methodologies!
- e-enable one-to-one applications
- exploit synergistic relationships
- engineer collaborative communities
- utilize proactive technologies
- extend rich convergence
- syndicate distributed methodologies
- e-enable real-time paradigms
- transition turn-key e-business
- engineer end-to-end e-commerce
- strategize plug-and-play functionalities
- mesh real-time systems
- iterate plug-and-play synergies


Vincent Cheung Foreign Operations department Hang Seng Bank 11/F Hang Seng Wanchai Building, 200 Hennessy Road, Wanchai Hello, I am Mr Vincent Cheung, of the Hang Seng Bank 11/F Hang Seng Wanchai Building, 200 Hennessy Road, Wanchai . An Iragi named Fadi Basem,a business man made a numbered fixed deposit of (346,736,899.68 HKD) for 18 calendar months, this is valued to Fourty Four million Five Hundred Thousand United State Dollars only in my branch. Upon maturity several notice was sent to him, even during the war, four years ago (2003). Again after the war another notification was sent and still no response came from him. We later found out that Fadi Basem and his family had been killed during the war in Gunfire that hit their home at Mukaradeeb where his personal oil well was. After further investigation it was also discovered that Fadi Basem did not declare any next of kin in his official papers including the paper work of his bank deposit. And he also confided in me the last time he was at my office that no one except me knew of his deposit in my bank. So, Fourty Four million Five Hundred Thousand United State Dollars is still lying in my bank and no one will ever come forward to claim it. What bothers me is that according to the laws of my country at the expiration five years six months the funds will revert to the ownership of the Hong Kong Government if nobody applies to claim the funds. My proposal, We are prepared to place you as the next of kin in a position to instruct HANG SENG BANK to release the deposit to you as the closest surviving relation. Upon receipt of the deposit, we am prepared to share the money with you on to be agreed on percentages. That is: I will simply nominate you as the next of kin and have them release the deposit to you. I would have gone ahead to ask the funds be released to me, but that would have drawn a straight line in my involvement in claiming the deposit.I assure you that I could have the deposit released to you within the coming weeks. I will simply inform the bank of the final closing of the file relating to the late customer, I will then officially communicate with my Bank and instruct them to release the deposit to you. With these: all is done. I am aware of the consequences of this proposal. I ask that if you find no interest in this project that you should discard this mail. I ask that you do not be vindictive and destructive. If my offer is of no appeal to you,delete this message and forget I ever contacted you. Do not destroy my career because you do not approve of my proposal. You may not know this but people like myself who have made tidy sums out of comparable situations run the whole private banking sector. I am not a criminal and what I do, I do not find against good conscience, this may be hard for you to understand, but the dynamics of my industry dictates that I make this move. Such opportunities only come ones way once in a lifetime. I cannot let this chance pass me by, for once I find myself in total control of my destiny. These chances wont pass me by. I ask that you do not destroy my chance, if you will not work with me let me know and let me move on with my life but do not destroy me. I am a family man and this is an opportunity to provide them with new opportunities. There is a reward for this project and it is a task well worth undertaking. I have evaluated the risks and the only risk I have here is from you refusing to work with me and alerting my bank. I am the only one who knows of this situation, good fortune has blessed you with a name that has planted you into the center of relevance in my life. Lets share the blessing. If you give me positive signals, I will initiate this process towards a conclusion. I wish to inform you that should you contact me via official channels; I will deny knowing you and about this project. I repeat, I do not want you contacting me through my official phone lines nor do I want you contacting me through my official email account. Contact me only through the numbers I will provide for you and also through the email account that i will provide therein in this email. Further more be informed that the fact that you are a foreigner gives you the privilege to stand in as my deceased client beneficiary as my deceased client had no relation all his family died with him during the war and I can not use my relations because its not accepted here in Hong Kong. Also I am very confident that we will be able to establish the trust that is needed to complete this deal and all that I need from the time been is your willingness and commitment so that we can end this in the next two weeks. What you need to understand about this transaction is that I will make sure that it passes through all international banking laws regards to this I will give the transaction the proper documentation that is required to perfect the finishing. Your only obligation in this transaction will be to set up the offshore accounts that can accommodate these funds and I will give you more light later once you agree to partner with me. Like I said before there is no risk involve as it will pass through international banking laws and all documents related to this transaction will be sent to you by post for your perusal and trust. I do not want any direct link between you and me. My official lines are not secure lines as they are periodically monitored to assess our level of customer care in line with our Total Quality Management Policy. Please observe this instruction religiously. Please, again, note I am a family man, I have a wife and children. I send you this mail not without a measure of fear as to what the consequences, but I know within me that nothing ventured is nothing gained and that success and riches never come easy or on a platter of gold. This is the one truth I have learned from my private banking clients. Do not betray my confidence. If we can be of one accord, we should plan a meeting, soon. Should you be interested I will prefer you to reach me via email. Your earliest response to this letter will be appreciated. I await your response. Mr.Cheung mailcheung001@yahoo.com


Choose Your Favorite Genre and Create Your Playlist
menu
Personal Playlist
Top Ten
Home
Personal Playlist
Top Ten
Home
Rock
R&B
Classical
Classic Rock
Alternative Rock
Rap
Metal
Pop
Latin
Jazz
EDM
Country
Reggae
Zydeco
Techno
Blues


| 899 | (A) | and that lede at the laste hym of lyfe broghte |
| 905 | (C) | At þe laste þat lorde . out of lyfe hym browgħte |
| 891 | (D) | And at last þe lord out of lyf hym brogħt |
| 868 | (E) | & atte þe last þis lord . out of lyf hym brougħe |
| (Ex) | ---- no text ---- | |
| 923 | (L) | & at þe last þat lord out of lyf hym broȝt |
| 841 | (P) | And at þe laste þe lede hym on lyfe broght |
| 877 | (U) | And atte last that lede / out of lyf brougħt |
| (V) | ---- no text ---- |


In this example you can add name to the exported file by filling the exported-file-name attribute.
In this example no file name was given, so the exported file name will be the default one.
In this example background color is set light blue.
In this example no file name was given, so the exported file name will be the default one.
In this example the export link is outside the chart.


|
Quadruple plot of 4 cruciform coped stones. Trefoils engraved at foot of each memorial. Numbered from North to South for transcription.
Plot 1 North face No inscription.
Plot 1 South face.
IN MEMORY OF EMMA PRITCHETT WHO DIED JUNE XIV MDCCCLXXXVI AGED LXIII YEARS
Plot 2 North face.
IN MEMORY OF WILLIAM PRITCHETT WHO DIED APRIL 1 MDCCCLXXVII. AGED LXVI YEARS.
Plot 2 South face.
IN MEMORY OF EDWARD CHARLES PRITCHETT WHO DIED DECR XXV MDCCCLXXXV AGED LIV YEARS.
Plot 3 North face.
IN MEMORY OF MARIA YOUNGEST DAUGHTER OF WILLIAM & ANN PRITCHETT WHO DIED MAY XII MDCCCLVII AGED XXVIII YEARS
Plot 3 West face.
Lord, Thou [___], th[_] [___] of thy house and the place here thine honour [___]
Plot 3 South face.
ANN WIFE OF WILLIAM PRITCHETT DIED AUG IV MDCCCLX AGED LX YEARS
Plot 4 North face.
IN MEMORY OF [WILLIAM] PRITCHETT WHO DIED JUNE XXIX MDCCCLX1V AGED LXXI YEARS
Plot 4 South face.
JOHN SO[N] O[F] WIL[LIAM] [&] ANN PRITCH[ETT] BORN DEC XXV MDCCC[___] DIED MARCH XXV MDCCCLVIII
Burial Register: A560 A570 A606 A663 B114 B123 B132
|
|