Training Events Management
Title
Type
Course
Seminar
Code
Overview
Days
Total Places
Price (Exc. Vat)
Who Should Attend?
Pre Requisites
Material Covered
Partner
Instances
Start Date
Location
Places Left
Registration Url
Event Code
Save


Worked for me like 1 day perfectly. Now i see Battlelog like it used to be. I have reinstalled twice, updated chrome, but nothing helps. Get better Battlelog expansion is turned on. Any help?
RenjiNSK
Helping Hand
Works fine for me... Try to reset the browser's cache/data.
Never had that issue beffore.
BrainFooLong
Administrator
What problem you have specially?
Don't you see the BBLog Center Icon?
Do you miss only some features?
Greetz
Topicstarter
Guest
I don't see that Better BLOG logo thingy in the side of the news feed. When typing forum post, i didn't have the options, now youtube videos don't show up. Seems like i'm missing all the features. Chrome version 18.0.1025.162, i hope you check out the issue, i found the extension very useful.
BrainFooLong
Administrator
Have you any other addons installed that maybe blocks execution of bblog?
Maybe try it with firefox to verify it depends on chrome.
Greetz
Topicstarter
Guest
Cache: Cleared
Other extensions: Removed,
Firefox: Didn't work.
Reinstalled: Yes
Now i have no why it doesn't work. :/ Could the problem somehow be in my computer? Btw, thanks for good service/helping admins.
Topicstarter
Guest
I have no idea*
BrainFooLong
Administrator
Please try to create a new Firefox Profile and test it again.
Google for the how-to. "firefox profile manager"
PS: A Sticky Thread in this bug forum describe it more detailed.
http://getbblog.com/viewtopic.php?f=3&t=304
Greetz
MrMurderx1221
I have the same issue since downloading 1.6.
Cleared my cache, reinstalled, done everything.
It worked fine for weeks before this update.


This is an experimental API.
Get the StackTrace attached to o.
If object o was thrown and caught in a dart:async method, a StackTrace object was attached to it. Use getAttachedStackTrace to get that object.
Returns null if no StackTrace was attached.
Runs the given callback asynchronously.
Callbacks registered through this function are always executed in order and are guaranteed to run before other asynchronous events (like Timer events, or DOM events).
Warning: it is possible to starve the DOM by registering asynchronous callbacks through this method. For example the following program will run the callbacks without ever giving the Timer callback a chance to execute:
Timer.run(() { print("executed"); }); // Will never be executed; foo() { asyncRun(foo); // Schedules [foo] in front of other events. } main() { foo(); }
A Completer is used to produce Futures and supply their value when it becomes available.
A service that provides values to callers, and wants to return Futures can use a Completer as follows:
Completer completer = new Completer(); // send future object back to client... return completer.future; ... // later when value is available, call: completer.complete(value); // alternatively, if the service cannot produce the value, it // can provide an error: completer.completeError(error);
The future that will contain the result provided to this completer.
Whether the future has been completed.
Completes the future synchronously.
This constructor should be avoided unless the completion of the future is known to be the final result of another asynchronous operation. If in doubt use the default Completer constructor.
Example:
var completer = new Completer.sync(); // The completion is the result of the asynchronous onDone event. // No other operation is performed after the completion. It is safe // to use the Completer.sync constructor. stream.listen(print, onDone: () { completer.complete("done"); });Bad example. Do not use this code. Only for illustrative purposes:
var completer = new Completer.sync(); // The completion is the result of the asynchronous onDone event. // However, there is still code executed after the completion. This // operation is *not* safe. stream.listen(print, onDone: () { completer.complete("done"); foo(); // This operation follows the completion. });WARNING This constructor is experimental and could disappear or change behavior.
Completes future with the supplied values.
All listeners on the future will be immediately informed about the value.
Complete future with an error.
Completing a future with an error indicates that an exception was thrown while trying to produce a value.
The argument exception should not be null
.
Indicates that loading of libraryName is deferred.
Applies to library imports, when used as metadata.
Example usage:
@lazy import 'foo.dart' as foo; const lazy = const DeferredLibrary('com.example.foo'); void main() { foo.method(); // Throws a NoSuchMethodError, foo is not loaded yet. lazy.load().then(onFooLoaded); } void onFooLoaded(_) { foo.method(); }
Ensure that libraryName has been loaded.
The value of the returned future is true if this invocation of load caused the library to be loaded.
An interface that abstracts creation or handling of Stream events.
Create a data event
Create an async error.
Request a stream to close.
Stream that transforms another stream by intercepting and replacing events.
This Stream is a transformation of a source stream. Listening on this stream is the same as listening on the source stream, except that events are intercepted and modified by a StreamEventTransformer before becoming events on this stream.
Adds a subscription to this stream.
On each data event from this stream, the subscriber's onData handler is called. If onData is null, nothing happens.
On errors from this stream, the onError handler is given a object describing the error.
If this stream closes, the onDone handler is called.
If cancelOnError is true, the subscription is ended when the first error is reported. The default is false.
A Future represents a delayed computation. It is used to obtain a not-yet available value, or error, sometime in the future. Receivers of a Future can register callbacks that handle the value or error once it is available. For example:
Future<int> future = getFuture(); future.then((value) => handleValue(value)) .catchError((error) => handleError(error));A Future can be completed in two ways: with a value ("the future succeeds") or with an error ("the future fails"). Users can install callbacks for each case. The result of registering a pair of callbacks is a new Future (the "successor") which in turn is completed with the result of invoking the corresponding callback. The successor is completed with an error if the invoked callback throws. For example:
Future<int> successor = future.then((int value) { // Invoked when the future is completed with a value. return 42; // The successor is completed with the value 42. }, onError: (e) { // Invoked when the future is completed with an error. if (canHandle(e)) { return 499; // The successor is completed with the value 499. } else { throw e; // The successor is completed with the error e. } });If a future does not have a successor but is completed with an error, it forwards the error message to the global error-handler. This special casing makes sure that no error is silently dropped. However, it also means that error handlers should be installed early, so that they are present as soon as a future is completed with an error. The following example demonstrates this potential bug:
var future = getFuture(); new Timer(new Duration(milliseconds: 5), () { // The error-handler is only attached 5ms after the future has been // received. If the future fails in the mean-time it will forward the // error to the global error-handler, even though there is code (just // below) to handle the error. future.then((value) { useValue(value); }, onError: (e) { handleError(e); }); });In general we discourage registering the two callbacks at the same time, but prefer to use then() with one argument (the value handler), and to use catchError() for handling errors. The missing callbacks (the error-handler for then(), and the value-handler for catchError()), are automatically configured to "forward" the value/error. Separating value and error-handling into separate registration calls usually leads to code that is easier to reason about. In fact it makes asynchronous code very similar to synchronous code:
// Synchronous code. try { int value = foo(); return bar(value); } catch (e) { return 499; }Equivalent asynchronous code, based on futures:
Future<int> future = foo(); // foo now returns a future. future.then((int value) => bar(value)) .catchError((e) => 499);Similar to the synchronous code, the error handler (registered with catchError()) is handling the errors for exceptions coming from calls to 'foo', as well as 'bar'. This would not be the case if the error-handler was registered at the same time as the value-handler.
Futures can have more than one callback-pairs registered. Each successor is treated independently and is handled as if it was the only successor.
Creates a future containing the result of calling computation asynchronously with runAsync.
if the result of executing computation throws, the returned future is completed with the error. If a thrown value is an AsyncError, it is used directly, instead of wrapping this error again in another AsyncError.
If the returned value is itself a Future, completion of the created future will wait until the returned future completes, and will then complete with the same result.
If a value is returned, it becomes the result of the created future.
Creates a future that completes after a delay.
The future will be completed after the given duration has passed with the result of calling computation. If the duration is 0 or less, it completes no sooner than in the next event-loop iteration.
If computation is not given or null
then it will behave as if computation was set to () => null
. That is, it will complete with null
.
If calling computation throws, the created future will complete with the error.
See Completers, for futures with values that are computed asynchronously.
A future that completes with an error in the next event-loop iteration.
See Completer to create a Future and complete it later.
Creates a future containing the result of immediately calling computation.
if the result of executing computation throws, the returned future is completed with the error. If a thrown value is an AsyncError, it is used directly, instead of wrapping this error again in another AsyncError.
If the returned value is itself a Future, completion of the created future will wait until the returned future completes, and will then complete with the same result.
A future whose value is available in the next event-loop iteration.
If value is not a Future, using this constructor is equivalent to new Future.sync(() => value)
.
See Completer to create a Future and complete it later.
Creates a Stream that sends this' completion value, data or error, to its subscribers. The stream closes after the completion value.
Handles errors emitted by this Future.
Returns a new Future f
.
When this completes with a value, the value is forwarded to f
unmodified. That is, f
completes with the same value.
When this completes with an error, test is called with the error's value. If the invocation returns true, onError is called with the error. The result of onError is handled exactly the same as for then's onError.
If test returns false, the exception is not handled by onError, but is thrown unmodified, thus forwarding it to f
.
If test is omitted, it defaults to a function that always returns true.
Example:
foo .catchError(..., test: (e) => e is ArgumentError) .catchError(..., test: (e) => e is NoSuchMethodError) .then((v) { ... });This method is equivalent to:
Future catchError(onError(error), {bool test(error)}) { this.then((v) => v, // Forward the value. // But handle errors, if the [test] succeeds. onError: (e) { if (test == null || test(e)) { return onError(e); } throw e; }); }
Perform an async operation for each element of the iterable, in turn.
Runs f for each element in input in order, moving to the next element only when the Future returned by f completes. Returns a Future that completes when all elements have been processed.
The return values of all Futures are discarded. Any errors will cause the iteration to stop and will be piped through the returned Future.
When this future completes with a value, then onValue is called with this value. If this future is already completed then the invocation of onValue is delayed until the next event-loop iteration.
Returns a new Future f
which is completed with the result of invoking onValue (if this completes with a value) or onError (if this completes with an error).
If the invoked callback throws an exception, the returned future f
is completed with the error.
If the invoked callback returns a Future f2
then f
and f2
are chained. That is, f
is completed with the completion value of f2
.
If onError is not given, it is equivalent to (e) { throw e; }
. That is, it forwards the error to f
.
In most cases, it is more readable to use catchError separately, possibly with a test
parameter, instead of handling both value and error in a single then call.
Wait for all the given futures to complete and collect their values.
Returns a future which will complete once all the futures in a list are complete. If any of the futures in the list completes with an error, the resulting future also completes with an error. Otherwise the value of the returned future will be a list of all the values that were produced.
Register a function to be called when this future completes.
The action function is called when this future completes, whether it does so with a value or with an error.
This is the asynchronous equivalent of a "finally" block.
The future returned by this call, f
, will complete the same way as this future unless an error occurs in the action call, or in a Future returned by the action call. If the call to action does not return a future, its return value is ignored.
If the call to action throws, then f
is completed with the thrown error.
If the call to action returns a Future, f2
, then completion of f
is delayed until f2
completes. If f2
completes with an error, that will be the result of f
too. The value of f2
is always ignored.
This method is equivalent to:
Future<T> whenComplete(action()) { this.then((v) { var f2 = action(); if (f2 is Future) return f2.then((_) => v); return v }, onError: (e) { var f2 = action(); if (f2 is Future) return f2.then((_) { throw e; }); throw e; }); }
A source of asynchronous data events.
A Stream provides a sequence of events. Each event is either a data event or an error event, representing the result of a single computation. When the Stream is exhausted, it may send a single "done" event.
You can listen() on a stream to receive the events it sends. When you listen, you receive a StreamSubscription object that can be used to stop listening, or to temporarily pause events from the stream.
When an event is fired, the listeners at that time are informed. If a listener is added while an event is being fired, the change will only take effect after the event is completely fired. If a listener is canceled, it immediately stops receiving events.
When the "done" event is fired, subscribers are unsubscribed before receiving the event. After the event has been sent, the stream has no subscribers. Adding new subscribers after this point is allowed, but they will just receive a new "done" event as soon as possible.
Streams always respect "pause" requests. If necessary they need to buffer their input, but often, and preferably, they can simply request their input to pause too.
There are two kinds of streams: The normal "single-subscription" streams and "broadcast" streams.
A single-subscription stream allows only a single listener at a time. It holds back events until it gets a listener, and it may exhaust itself when the listener is unsubscribed, even if the stream wasn't done.
Single-subscription streams are generally used for streaming parts of contiguous data like file I/O.
A broadcast stream allows any number of listeners, and it fires its events when they are ready, whether there are listeners or not.
Broadcast streams are used for independent events/observers.
The default implementation of isBroadcast returns false. A broadcast stream inheriting from Stream must override isBroadcast to return true
.
Returns the first element.
If this is empty throws a StateError. Otherwise this method is equivalent to this.elementAt(0)
Reports whether this stream is a broadcast stream.
Reports whether this stream contains any elements.
Returns the last element.
If this is empty throws a StateError.
Counts the elements in the stream.
Returns the single element.
If this is empty or has more than one element throws a StateError.
Creates a new single-subscription stream from the future.
When the future completes, the stream will fire one event, either data or error, and then close with a done-event.
Creates a single-subscription stream that gets its data from data.
Creates a stream that repeatedly emits events at period intervals.
The event values are computed by invoking computation. The argument to this callback is an integer that starts with 0 and is incremented for every event.
If computation is omitted the event values will all be null
.
Checks whether test accepts any element provided by this stream.
Completes the Future when the answer is known. If this stream reports an error, the Future will report that error.
Returns a multi-subscription stream that produces the same events as this.
If this stream is single-subscription, return a new stream that allows multiple subscribers. It will subscribe to this stream when its first subscriber is added, and unsubscribe again when the last subscription is canceled.
If this stream is already a broadcast stream, it is returned unmodified.
Checks whether match occurs in the elements provided by this stream.
Completes the Future when the answer is known. If this stream reports an error, the Future will report that error.
Skips data events if they are equal to the previous data event.
The returned stream provides the same events as this stream, except that it never provides two consequtive data events that are equal.
Equality is determined by the provided equals method. If that is omitted, the '==' operator on the last provided data element is used.
Discards all data on the stream, but signals when it's done or an error occured.
When subscribing using drain, cancelOnError will be true. This means that the future will complete with the first error on the stream and then cancel the subscription.
In case of a done
event the future completes with the given futureValue.
Returns the value of the indexth data event of this stream.
If an error event occurs, the future will end with this error.
If this stream provides fewer than index elements before closing, an error is reported.
Checks whether test accepts all elements provided by this stream.
Completes the Future when the answer is known. If this stream reports an error, the Future will report that error.
Creates a new stream from this stream that converts each element into zero or more events.
Each incoming event is converted to an Iterable of new events, and each of these new events are then sent by the returned stream in order.
Finds the first element of this stream matching test.
Returns a future that is filled with the first element of this stream that test returns true for.
If no such element is found before this stream is done, and a defaultValue function is provided, the result of calling defaultValue becomes the value of the future.
If an error occurs, or if this stream ends without finding a match and with no defaultValue function provided, the future will receive an error.
Reduces a sequence of values by repeatedly applying combine.
Executes action on each data event of the stream.
Completes the returned Future when all events of the stream have been processed. Completes the future with an error if the stream has an error event, or if action throws.
Creates a wrapper Stream that intercepts some errors from this stream.
If this stream sends an error that matches test, then it is intercepted by the handle function.
An AsyncError e
is matched by a test function if test(e)
returns true. If test is omitted, every error is considered matching.
If the error is intercepted, the handle function can decide what to do with it. It can throw if it wants to raise a new (or the same) error, or simply return to make the stream forget the error.
If you need to transform an error into a data event, use the more generic Stream.transformEvent to handle the event by writing a data event to the output sink
Finds the last element in this stream matching test.
As firstWhere, except that the last matching element is found. That means that the result cannot be provided before this stream is done.
Adds a subscription to this stream.
On each data event from this stream, the subscriber's onData handler is called. If onData is null, nothing happens.
On errors from this stream, the onError handler is given a object describing the error.
If this stream closes, the onDone handler is called.
If cancelOnError is true, the subscription is ended when the first error is reported. The default is false.
Creates a new stream that converts each element of this stream to a new value using the convert function.
Binds this stream as the input of the provided StreamConsumer.
Reduces a sequence of values by repeatedly applying combine.
Finds the single element in this stream matching test.
Like lastMatch, except that it is an error if more than one matching element occurs in the stream.
Skips the first count data events from this stream.
Skip data events from this stream while they are matched by test.
Error and done events are provided by the returned stream unmodified.
Starting with the first data event where test returns true for the event data, the returned stream will have the same events as this stream.
Provides at most the first n values of this stream.
Forwards the first n data events of this stream, and all error events, to the returned stream, and ends with a done event.
If this stream produces fewer than count values before it's done, so will the returned stream.
Forwards data events while test is successful.
The returned stream provides the same events as this stream as long as test returns true
for the event data. The stream is done when either this stream is done, or when this stream first provides a value that test doesn't accept.
Collects the data of this stream in a List.
Collects the data of this stream in a Set.
Chains this stream as the input of the provided StreamTransformer.
Returns the result of streamTransformer.bind
itself.
Creates a new stream from this stream that discards some data events.
The new stream sends the same error and done events as this stream, but it only sends the data events that satisfy the test.
The target of a Stream.pipe call.
The Stream.pipe call will pass itself to this object, and then return the resulting Future. The pipe should complete the future when it's done.
A controller with the stream it controls.
This controller allows sending data, error and done events on its stream. This class can be used to create a simple stream that others can listen on, and to push events to that stream.
It's possible to check whether the stream is paused or not, and whether it has subscribers or not, as well as getting a callback when either of these change.
If the stream starts or stops having listeners (first listener subscribing, last listener unsubscribing), the onSubscriptionStateChange
callback is notified as soon as possible. If the subscription stat changes during an event firing or a callback being executed, the change will not be reported until the current event or callback has finished. If the pause state has also changed during an event or callback, only the subscription state callback is notified.
If the subscriber state has not changed, but the pause state has, the onPauseStateChange
callback is notified as soon as possible, after firing a current event or completing another callback. This happens if the stream is not paused, and a listener pauses it, or if the stream has been resumed from pause and has no pending events. If the listeners resume a paused stream while it still has queued events, the controller will still consider the stream paused until all queued events have been dispatched.
Whether to invoke a callback depends only on the state before and after a stream action, for example firing an event. If the state changes multiple times during the action, and then ends up in the same state as before, no callback is performed.
If listeners are added after the stream has completed (sent a "done" event), the listeners will be sent a "done" event eventually, but they won't affect the stream at all, and won't trigger callbacks. From the controller's point of view, the stream is completely inert when has completed.
Whether there is a subscriber on the Stream.
Whether the stream is closed for adding more events.
If true, the "done" event might not have fired yet, but it has been scheduled, and it is too late to add more events.
Whether the subscription would need to buffer events.
This is the case if the controller's stream has a listener and it is paused, or if it has not received a listener yet. In that case, the controller is considered paused as well.
A broadcast stream controller is never considered paused. It always forwards its events to all uncanceled listeners, if any, and let them handle their own pausing.
Returns a view of this object that only exposes the EventSink interface.
The stream that this controller is controlling.
A controller with a stream that supports only one single subscriber.
If sync is true, events may be passed directly to the stream's listener during an add, addError or close call. If sync is false, the event will be passed to the listener at a later time, after the code creating the event has returned.
The controller will buffer all incoming events until the subscriber is registered.
The onPause function is called when the stream becomes paused. onResume is called when the stream resumed.
The onListen callback is called when the stream receives its listener and onCancel when the listener ends its subscription.
If the stream is canceled before the controller needs new data the onResume call might not be executed.
A controller where stream can be listened to more than once.
The Stream returned by stream is a broadcast stream. It can be listened to more than once.
The controller distributes any events to all currently subscribed listeners. It is not allowed to call add, addError, or close before a previous call has returned.
If sync is true, events may be passed directly to the stream's listener during an add, addError or close call. If sync is false, the event will be passed to the listener at a later time, after the code creating the event has returned.
Each listener is handled independently, and if they pause, only the pausing listener is affected. A paused listener will buffer events internally until unpaused or canceled.
If sync is false, no guarantees are given with regard to when multiple listeners get the events, except that each listener will get all events in the correct order. If two events are sent on an async controller with two listeners, one of the listeners may get both events before the other listener gets any. A listener must be subscribed both when the event is initiated (that is, when add is called) and when the event is later delivered, in order to get the event.
The onListen callback is called when the first listener is subscribed, and the onCancel is called when there are no longer any active listeners. If a listener is added again later, after the onCancel was called, the onListen will be called again.
Send or enqueue an error event.
Also allows an objection stack trace object, on top of what EventSink allows.
Base class for transformers that modifies stream events.
A StreamEventTransformer transforms incoming Stream events of one kind into outgoing events of (possibly) another kind.
Subscribing on the stream returned by bind() is the same as subscribing on the source stream, except that events are passed through the transformer before being emitted. The transformer may generate any number and types of events for each incoming event. Pauses on the returned subscription are forwarded to this stream.
An example that duplicates all data events:
class DoubleTransformer<T> extends StreamEventTransformer<T, T> { void handleData(T data, EventSink<T> sink) { sink.add(value); sink.add(value); } } someTypeStream.transform(new DoubleTransformer<Type>());The default implementations of the "handle" methods forward the events unmodified. If using the default handleData() the generic type T needs to be assignable to S.
Act on incoming data event.
The method may generate any number of events on the sink, but should not throw.
Act on incoming done event.
The method may generate any number of events on the sink, but should not throw.
Act on incoming error event.
The method may generate any number of events on the sink, but should not throw.
An Iterable like interface for the values of a Stream.
This wraps a Stream and a subscription on the stream. It listens on the stream, and completes the future returned by moveNext() when the next value becomes available.
NOTICE: This is a tentative design. This class may change.
The current value of the stream.
Only valid when the future returned by moveNext completes with true
as value, and only until the next call to moveNext.
Create a StreamIterator on stream.
Cancels the stream iterator (and the underlying stream subscription) early.
The stream iterator is automatically canceled if the moveNext future completes with either false
or an error.
If a moveNext call has been made, it will complete with false
as value, as will all further calls to moveNext.
If you need to stop listening for values before the stream iterator is automatically closed, you must call cancel to ensure that the stream is properly closed.
Wait for the next stream value to be available.
It is not allowed to call this function again until the future has completed. If the returned future completes with anything except true
, the iterator is done, and no new value will ever be available.
The future may complete with an error, if the stream produces an error.
A StreamSink unifies the asynchronous methods from StreamConsumer and the synchronous methods from EventSink.
The EventSink methods can't be used while the addStream is called. As soon as the addStream's Future completes with a value, the EventSink methods can be used again.
If addStream is called after any of the EventSink methods, it'll be delayed until the underlying system has consumed the data added by the EventSink methods.
When EventSink methods are used, the done Future can be used to catch any errors.
The done Future completes with the same values as close, except for the following case:
Close the StreamSink. It'll return the done Future.
A control object for the subscription on a Stream.
When you subscribe on a Stream using Stream.listen, a StreamSubscription object is returned. This object is used to later unsubscribe again, or to temporarily pause the stream's events.
Returns true if the StreamSubscription is paused.
Returns a future that handles the onDone and onError callbacks.
This method overwrites the existing onDone and onError callbacks with new ones that complete the returned future.
In case of an error the subscription will automatically cancel (even when it was listening with cancelOnError
set to false
).
In case of a done
event the future completes with the given futureValue.
Cancels this subscription. It will no longer receive events.
If an event is currently firing, this unsubscription will only take effect after all subscribers have received the current event.
Set or override the data event handler of this subscription.
Set or override the done event handler of this subscription.
Set or override the error event handler of this subscription.
Request that the stream pauses events until further notice.
If resumeSignal is provided, the stream will undo the pause when the future completes. If the future completes with an error, it will not be handled!
A call to resume will also undo a pause.
If the subscription is paused more than once, an equal number of resumes must be performed to resume the stream.
Resume after a pause.
The target of a Stream.transform call.
The Stream.transform call will pass itself to this object and then return the resulting stream.
Create a StreamTransformer that delegates events to the given functions.
This is actually a StreamEventTransformer where the event handling is performed by the function arguments. If an argument is omitted, it acts as the corresponding default method from StreamEventTransformer.
Example use:
stringStream.transform(new StreamTransformer<String, String>( handleData: (Strung value, EventSink<String> sink) { sink.add(value); sink.add(value); // Duplicate the incoming events. }));
Stream wrapper that only exposes the Stream interface.
Returns a multi-subscription stream that produces the same events as this.
If this stream is single-subscription, return a new stream that allows multiple subscribers. It will subscribe to this stream when its first subscriber is added, and unsubscribe again when the last subscription is canceled.
If this stream is already a broadcast stream, it is returned unmodified.
Adds a subscription to this stream.
On each data event from this stream, the subscriber's onData handler is called. If onData is null, nothing happens.
On errors from this stream, the onError handler is given a object describing the error.
If this stream closes, the onDone handler is called.
If cancelOnError is true, the subscription is ended when the first error is reported. The default is false.
Creates a new timer.
The callback callback is invoked after the given duration. A negative duration is treated similar to a duration of 0.
If the duration is statically known to be 0, consider using run.
Frequently the duration is either a constant or computed as in the following example (taking advantage of the multiplication operator of the Duration class):
const TIMEOUT = const Duration(seconds: 3); const ms = const Duration(milliseconds: 1); startTimeout([int milliseconds]) { var duration = milliseconds == null ? TIMEOUT : ms * milliseconds; return new Timer(duration, handleTimeout); }Note: If Dart code using Timer is compiled to JavaScript, the finest granularity available in the browser is 4 milliseconds.
Creates a new repeating timer.
The callback is invoked repeatedly with duration intervals until canceled. A negative duration is treated similar to a duration of 0.
Cancels the timer.
Runs the given callback asynchronously as soon as possible.
This function is equivalent to new Timer(Duration.ZERO, callback)
.


Windows Security Server Hardening Security Templates
Hardening your systems (Servers, Workstations, Applications, etc.) ensures that every system is secured in accordance to your organizations standards. Microsoft has a “Solution Accelerator” called Security Compliance Manager that allows System Administrators or IT Pro’s to create security templates that help harden their systems in a manageable, repeatable, way. In addition to SCM, you can build your own by using the standard MMC console and adding the Security Templates Snap-In to the console - this gives you a more refined configuration, but can be cumbersome.
Microsoft Security Compliance Manager
With Security Compliance Manager you are able to view Microsoft's (along with experts in the field) recommended security baseline configurations. With this knowledge you are able to view their recommendations, thus improving your system hardening. When installing SCM 3.o (http: //technet.microsoft.com/en-us/solutionaccelerators/cc835245.aspx) you will need to have SQL Express installed, which the application takes care if you don't have it currently installed.Once the application is running you will see three main content windows. The first is the list of all variations of configurations by Microsoft (note the “Other Baselines” at the bottom). In the center pane you are greeted by the “Welcome Screen” - the first step I always do when installing SCM is to click on “Download Microsoft baselines automatically”. By doing this, it should download the most recent configuration settings.
Once they are downloaded, you should see more options in the first pane (Microsoft Baselines). Next, select the baseline “root” that you want to examine and then select a specific configuration section within that baseline. Once doing so, you should see tons of settings that apply to that configuration (this is similar to Group Policy Objects) and if you select one of these “GPOish” settings you will see further detail.
Now, if you’ve selected an item in the center pane then you should have noticed the far right pane change - this is the action pane. The action pane is similar to all other Microsoft products and allows you take certain actions as necessary.
For Example:
- Launch SCM 3.0
- Click on "Download Microsoft baselines automatically"
- Next select Windows 8.1 (expand the arrow)
- You should see something similar to this
- Next, select "Windows 8.1 Computer Security Compliance 1.0"
- You should see tons of options in the center pane - select the very first option (Interactive Logon: Machine account lockout threshold)
- You may notice that everything is grayed out. To make changes at this point you will need to duplicate this setting. When doing this, it will add it to your "Other Baselines" option at the bottom of the left-side pane (Don't do this now).
- Do you see the option underneath this setting (when selected) that says "Setting Details" - select this now.
- Within this section you see more detailed information that relates to the:
- GPO Path
- Description of this setting
- Additional Details
- Vulnerabilities related to this setting
- Potential Impacts of this setting
- Countermeasures that can be taken
Once importing settings into the SCM Console you are able to generate changes and create Group Policy Security Templates that you can then apply to your Domain or Local Group Policy. It’s ideal to base this off of your current configurations, but you could go through all of these settings and create a custom Security Template from scratch if you are so inclined.
INF Templates with MMC
Besides using Microsoft Security Compliance Manager, you can also create Security Templates by using the standard Windows MMC (Microsoft Management Console) console. With this option, you are able to create INF templates which will allow you to configure specific settings for lets say an IIS, Domain Controller, Hyper-V, etc. server. When you create these Security Templates, then you know that every (IIS, DC, Hyper-V) server has a very specific configuration from the beginning, thus ensuring that all of your configurations are the same across the entire domain/forest/network.- Open MMC.exe
- Go to File -> Add/Remove Snap-In...
- Select "Security Templates"
- Click Add
- Click Ok
- Expand "Security Templates" - you should see a path similar to the following
- C:\Users\%USERNAME%\Documents\Security\Templates
- Right click on this path and select -> New Template
- Give the Template a name and a brief description (if needed)
- You should now see your newly created Security Template underneath the path above
Another example of “Security Templates” settings is the “Registry” setting. The “Registry” setting allows you to configure permissions for certain Registry Hives (i.e. SAM, HARDWARE, SYSTEM, SECURITY, SOFTWARE, Etc.). To add specific permissions (hardening) to Registry hives/keys, you must right-click the “Registry” setting and select “Add Key”.
Using INF Security Templates can greatly reduce unwanted configurations of systems/services/applications, but you must understand and test these configurations before deploying them. Once you have tested your INF Security Templates you can then deploy them using Group Policy or PowerShell.
Using Security Templates from Microsoft and the Security Compliance Manager allows for a more robust configuration that has been proven to reduce your security risk. If you’re wanting a bit more of a custom approach or wanting to experiment, you can create very precise Security Templates using the built-in MMC console. Either way, creating a standard “Golden” image with a predefined Security Template will reduce errors by busy SysAdmins as well as ensuring that every system has the appropriate configurations applied without “admin” interaction.
Additional Info:
- Look at C:\Windows\Inf for built-in Security Templates to help you on your way
- Checkout the Security Compliance Manager site for more information: http: //technet.microsoft.com/en-us/solutionaccelerators/cc835245.aspx
- Check out this quick write-up: http: //www.techrepublic.com/blog/it-security/use-ms-security-compliance-manager-to-secure-your-windows-environment/ (it's a bit older, but its a good read)
- Check out this video: http: //www.windowsecurity.com/articles-tutorials/windows_os_security/Video-Security-Compliance-Manager-25-Understanding-Baselines.html


Grids / Selection Events
Event log:
- {{ev.name}}{{ev.info}}
This sample presents how to handle selection events in TreeGrid directive, AngularJS. Whenever a column or row is selected, the following events are fired:
- afterSelect - Occurs after column or row is selected
- beforeSelect - Occurs before column or row is selected
- selectionChanged - Occurs when selection changes
The event object carried with beforeSelect and afterSelect events, can be either colum or a row object. Depending on value of object's type field, you can determine whether a column or a row is selected.
By handling beforeSelect event you can prevent object from becoming selected, based on custom conditions set in your code. In our example, whenever orders for customer 'Frankenversand' are clicked, the selection process is cancelled.


|
My Project
|
This file contains the definition, types and structure for server. More...
#include "opcua_common.h"
Go to the source code of this file.
Classes | |
| struct | EdgeNodeItem |
| Structure which represents the Node information. More... | |
| struct | EdgeReference |
| Structure which represents the references between Nodes. More... | |
| struct | EdgeArgument |
| Structure which represents the arguments information. More... | |
| struct | EdgeMethod |
| Structure which represents the method request data. More... | |
Typedefs | |
| typedef struct EdgeNodeId | EdgeNodeId |
| typedef struct EdgeNodeItem | EdgeNodeItem |
| Structure which represents the Node information. | |
| typedef struct EdgeReference | EdgeReference |
| Structure which represents the references between Nodes. | |
| typedef enum EdgeArgumentType | EdgeArgumentType |
| Enum which represents the argument types. | |
| typedef enum EdgeArgValType | EdgeArgValType |
| Enum which represents the value type of argument. | |
| typedef struct EdgeArgument | EdgeArgument |
| Structure which represents the arguments information. | |
| typedef void(* | method_func) (int inpSize, void **input, int outSize, void **output) |
| Method callback function. More... | |
| typedef struct EdgeMethod | EdgeMethod |
| Structure which represents the method request data. | |
Enumerations | |
| enum | EdgeArgumentType { IN_OUT_ARGUMENTS = 1, IN_ARGUMENT = 2, OUT_ARGUMENT = 3, VOID_ARGUMENT = 4 } |
| Enum which represents the argument types. More... | |
| enum | EdgeArgValType { SCALAR = 0, ARRAY_1D = 1, ARRAY_2D = 2 } |
| Enum which represents the value type of argument. More... | |
This file contains the definition, types and structure for server.
| typedef void(* method_func) (int inpSize, void **input, int outSize, void **output) |
Method callback function.
| [in] | inpSize | Number of input arguments. |
| [in] | input | Input data. |
| [in] | outSize | Number of output arguments. |
| [out] | outout | Output data. |
| enum EdgeArgumentType |
| enum EdgeArgValType |


Open Data API for UIUC
Unofficial Open Data API for the University of Illinois at Urbana-Champaign. Provides data for various services on campus such as Dining, Weather, Wi-Fi, etc. The API is built with Python, Flask + Flask RESTful, and Redis. Interest in the project was gauged here. This is still very much a WIP, so please feel free to submit an issue or contribute!
Note: This is an unofficial API and is not supported or controlled by the University of Illinois at Urbana-Champaign itself. Any questions, comments, feedback or feature requests should be directed to xasos or via an issue in this repo.
Base URL: http://uiuc-api.herokuapp.com
Output: JSON
Get information about food options from all dining halls.
GET /dining/:hall/:dateFrom/:dateTo
Get detailed menus from specific dining halls.
List of Halls:
| Residence Hall | Dining Hall | Hall Nickname | Hall ID |
|---|---|---|---|
| Lincoln Avenue (LAR) | Lincoln/Allen Dining Hall | lar | 5 |
| Lincoln Avenue (LAR) | Field of Greens | fieldofgreens | 12 |
| Lincoln Avenue (LAR) | Leafy! | leafy | 13 |
| Pennsylvania Avenue (PAR) | PAR Dining Hall | par | 2 |
| Pennsylvania Avenue (PAR) | Penn Station | pennstation | 14 |
| Illinois Street (ISR) | ISR Dining Hall | isr | 3 |
| Illinois Street (ISR) | CHOMPS | chomps | 18 |
| Illinois Street (ISR) | Cocina Mexicana | cocinamexicana | 10 |
| Illinois Street (ISR) | Taste of Asia | tasteofasia | 17 |
| Ikenberry | Ikenberry Dining Hall | ikenberrydininghall | 1 |
| Ikenberry | 57 North | 57north | 7 |
| Ikenberry | Better Burger | betterburger | 20 |
| Ikenberry | Caffeinator | caffeinator | 9 |
| Ikenberry | Neo Soul Ingredient | neosoulingredient | 21 |
| Florida Avenue (FAR) | FAR Dining Hall | far | 6 |
| Florida Avenue (FAR) | Cracked Egg Café | crackedeggcafe | 8 |
| Florida Avenue (FAR) | Soul Ingredient | soulingredient | 16 |
| Busey-Evans | Busey-Evans Dining Hall | buseyevans | 4 |
| Busey-Evans | Busey Bean and Green | buseybeanandgreen | 11 |
| Busey-Evans | Oodles | oodles | 19 |
Hall
route parameter can use the Hall ID or Hall nickname when querying.
Example Query:
http://uiuc-api.herokuapp.com/dining/par/2015-11-08/2015-11-08
Response:
{
"Menus":{
"Item":[
{
"EventDate":1446962400,
"DiningMenuID":52456,
"ServiceUnit":"Arugula's Serving",
"Course":"Salads",
"CourseSort":250,
"FormalName":"Fruit & Nut Chicken Salad",
"Meal":"Dinner",
"Traits":"Eggs,Soy,Tree Nuts,",
"DiningOptionID":2,
"ScheduleID":9,
"ItemID":5978
},
{
"EventDate":1446962400,
"DiningMenuID":50688,
"ServiceUnit":"Arugula's Serving",
"Course":"Salads",
"CourseSort":250,
"FormalName":"Macaroni Salad",
"Meal":"Dinner",
"Traits":"Corn,Eggs,Gluten,Soy,Vegetarian,Wheat,",
"DiningOptionID":2,
"ScheduleID":9,
"ItemID":3208
},
...
...
GET /dining/search/:query
Search dining halls for specific foods.
Example Query:
http://uiuc-api.herokuapp.com/dining/search/pasta
Response:
{
"Data":{
"Table":[
{
"name":"ItemList",
"Row":[
{
"Item_IntID":"16596",
"FormalName":"BLT Pasta Salad",
"ScheduleIDs":[
{
"ScheduleID":4,
"DiningOptionID":4,
"EventDate":1447221600
}
]
},
{
"Item_IntID":"17136",
"FormalName":"Campanelle Pasta",
"ScheduleIDs":[
{
"ScheduleID":21,
"DiningOptionID":5,
"EventDate":1447653600
},
{
"ScheduleID":42,
"DiningOptionID":1,
"EventDate":1447308000
},
{
"ScheduleID":42,
"DiningOptionID":1,
"EventDate":1447912800
}
]
},
...
...
GET /dining/
Example Query:
http://uiuc-api.herokuapp.com/dining/search/pasta
Response:
...
...
(https://web.housing.illinois.edu/MobileDining/WebService/SettingTable.aspx?k=7A828F94-620B-4EE3-A56F-328036CC3C04&t=json&ts=5-10-2012%2014:30:00) (https://web.housing.illinois.edu/MobileDining/WebService/MyBalances.asmx/GetBalances?k=7A828F94-620B-4EE3-A56F-328036CC3C04&HT=) (https://web.housing.illinois.edu/MobileDining/WebService/MobileDining.asmx/SearchMenus?k=7A828F94-620B-4EE3-A56F-328036CC3C04&SearchPhrase=salsa)
Get weather information from the Department of Atmospheric Sciences.
GET /weather
Get Champaign-Urbana weather information from the Williard Airport weather station.
Example Query:
http://uiuc-api.herokuapp.com/weather
Response:
{
"weather_station_location": "Willard Airport",
"last_recorded_time": "1446098674",
"weather_condition": "Cloudy Skies",
"temperature": "54",
"dew_point": "45",
"relative_humidity": "71%",
"winds": "NW at 17 mph",
"visibility": "10 miles",
"pressure": "1020.0 mb (30.13 in)",
"sunrise": "7:13AM",
"sunset": "6:01PM",
"images": {
"latest_radar_image": "https://www.atmos.illinois.edu/weather/tree/prods/current/nicerad/nicerad_N.gif",
"storm_total_precip_image": "https://www.atmos.illinois.edu/weather/tree/prods/current/niceradilxpretx/niceradilxpretx_N.gif",
"surface_temp_image": "https://www.atmos.illinois.edu/weather/tree/prods/current/sfctmp/sfctmp_N.gif",
"surface_dew_point_temp_image": "https://www.atmos.illinois.edu/weather/tree/prods/current/sfctdp/sfctdp_N.gif",
"sea_level_pressure": "https://www.atmos.illinois.edu/weather/tree/prods/current/sfcslp/sfcslp_N.gif",
"mdw_surface_observations": "https://www.atmos.illinois.edu/weather/tree/prods/current/sfcslp/sfcslp_N.gif",
"composite_ir_image": "https://www.atmos.illinois.edu/weather/tree/prods/current/satconusenhir/satconusenhir_N.gif",
"composite_enhanced_ir_image": "https://www.atmos.illinois.edu/weather/tree/prods/current/satnoamir/satnoamir_N.gif"
},
"": ""
}
Get Wi-Fi information for various places around campus.
GET /wifi
Example Query:
http://uiuc-api.herokuapp.com/wifi
Response:
{
"weather_station_location": "Willard Airport"
}
GET /wifi/nearme/:latitude/:longitude
Example Query:
http://uiuc-api.herokuapp.com/wifi
Response:
{
"weather_station_location": "Willard Airport"
}
Get information about campus laundry.
GET /laundry
Get washing machine/dryer usage information for all residence halls.
Example Query:
http://uiuc-api.herokuapp.com/laundry
Response:
{
"location": {
"name": "University of Illinois at Urbana",
"code": "urba7723",
"networked": "false",
"company": "Jetz Service Co",
"rooms": [{
"id": "110959186",
"name": "1107 West Green",
"networked": "A",
"machines": [{
"port": "1",
"label": "1",
"description": "Front-Load Washer",
"status": "Available",
"startTime": "0000-00-00 00:00:00",
"timeRemaining": "0"
}, {
"port": "2",
"label": "2",
"description": "Front-Load Washer",
"status": "Available",
"startTime": "0000-00-00 00:00:00",
"timeRemaining": "0"
}, {
"port": "3",
"label": "3",
"description": "Front-Load Washer",
"status": "Available",
"startTime": "0000-00-00 00:00:00",
"timeRemaining": "0"
},
...
...
Search the university directory for students, academic departments, and faculty/staff.
GET /directory/search/:searchType/:query
Search types:
| Search Type | Search Type ID |
|---|---|
| All | all |
| Faculty/Staff | faculty |
| Student | student |
| NetID | netid |
| Department | department |
| Phone | phone |
searchType
route parameter can use the Search Type ID when querying.
Example Query:
http://uiuc-api.herokuapp.com/directory/search/netid/npant3
Response:
{
"success": "true",
"type": "student",
"email"<EMAIL_ADDRESS>}
Get stories, classifieds, events, and more from UIUC's campus newspaper, The Daily Illini.
GET /dailyillini/search/:query
Example Query:
http://uiuc-api.herokuapp.com/directory/search/netid/npant3
Response:
Search the university directory for students, academic departments, and faculty/staff.
GET /directory/search/:searchType/:query
Search types:
| Search Type | Search Type ID |
|---|---|
| All | all |
| Faculty/Staff | faculty |
| Student | student |
| NetID | netid |
| Department | department |
| Phone | phone |
searchType
route parameter can use the Search Type ID when querying.
Example Query:
http://uiuc-api.herokuapp.com/directory/search/netid/npant3
Response:
Get the Fighting Illini's athletic schedule across all sports.
GET /directory/search/:searchType/:query
Search types:
| Search Type | Search Type ID |
|---|---|
| All | all |
| Faculty/Staff | faculty |
| Student | student |
| NetID | netid |
| Department | department |
| Phone | phone |
searchType
route parameter can use the Search Type ID when querying.
Example Query:
http://uiuc-api.herokuapp.com/directory/search/netid/npant3
Response:
UIUC's Student Services Development Team offers an API for information on Class Schedule, Course Catalog, and Gened data. However, since the data is not publibly available, you must sign up for access here.
The Champaign-Urbana Mass Transit District offers an API for transporation information in the Champaign-Urbana metropolitan area. There are several API wrappers and Open-source applications written with the CUMTD API on GitHub as well as in their App Garage.
$ pip install -r requirements.txt
$ python api.py
$ pip install -r requirements.txt
$ heroku create
$ (git add, git commit)
$ git push heroku master
If you've built a wrapper for this API, feel free to add it to this list by sending a PR!
Some apps built using this API:
| Name | Description | URL |
|---|---|---|
| uiuc-cli | CLI to university services | https://github.com/xasos/uiuc-cli |
If you've built an app using this API, feel free to add it to this list by sending a PR!
Please refer to the Contributing Guidelines before submitting any pull requests!
The To-Do List can be found here.
So far, x users have used the API and over y requests have been made!
Use of this API


R/ml_clustering_power_iteration.R
ml_power_iteration.Rd
Power iteration clustering (PIC) is a scalable and efficient algorithm for clustering vertices of a graph given pairwise similarities as edge properties, described in the paper "Power Iteration Clustering" by Frank Lin and William W. Cohen. It computes a pseudo-eigenvector of the normalized affinity matrix of the graph via power iteration and uses it to cluster vertices. spark.mllib includes an implementation of PIC using GraphX as its backend. It takes an RDD of (srcId, dstId, similarity) tuples and outputs a model with the clustering assignments. The similarities must be nonnegative. PIC assumes that the similarity measure is symmetric. A pair (srcId, dstId) regardless of the ordering should appear at most once in the input data. If a pair is missing from input, their similarity is treated as zero.
ml_power_iteration( x, k = 4, max_iter = 20, init_mode = "random", src_col = "src", dst_col = "dst", weight_col = "weight", ... )
| x | A ‘spark_connection’ or a ‘tbl_spark’. |
|---|---|
| k | The number of clusters to create. |
| max_iter | The maximum number of iterations to run. |
| init_mode | This can be either “random”, which is the default, to use a random vector as vertex properties, or “degree” to use normalized sum similarities. |
| src_col | Column in the input Spark dataframe containing 0-based indexes of all source vertices in the affinity matrix described in the PIC paper. |
| dst_col | Column in the input Spark dataframe containing 0-based indexes of all destination vertices in the affinity matrix described in the PIC paper. |
| weight_col | Column in the input Spark dataframe containing non-negative edge weights in the affinity matrix described in the PIC paper. |
| ... | Optional arguments. Currently unused. |
A 2-column R dataframe with columns named "id" and "cluster" describing the resulting cluster assignments
if (FALSE) { library(sparklyr) sc <- spark_connect(master = "local") r1 <- 1 n1 <- 80L r2 <- 4 n2 <- 80L gen_circle <- function(radius, num_pts) { # generate evenly distributed points on a circle centered at the origin seq(0, num_pts - 1) %>% lapply( function(pt) { theta <- 2 * pi * pt / num_pts radius * c(cos(theta), sin(theta)) } ) } guassian_similarity <- function(pt1, pt2) { dist2 <- sum((pt2 - pt1)^2) exp(-dist2 / 2) } gen_pic_data <- function() { # generate points on 2 concentric circle centered at the origin and then # compute pairwise Gaussian similarity values of all unordered pair of # points n <- n1 + n2 pts <- append(gen_circle(r1, n1), gen_circle(r2, n2)) num_unordered_pairs <- n * (n - 1) / 2 src <- rep(0L, num_unordered_pairs) dst <- rep(0L, num_unordered_pairs) sim <- rep(0, num_unordered_pairs) idx <- 1 for (i in seq(2, n)) { for (j in seq(i - 1)) { src[[idx]] <- i - 1L dst[[idx]] <- j - 1L sim[[idx]] <- guassian_similarity(pts[[i]], pts[[j]]) idx <- idx + 1 } } tibble::tibble(src = src, dst = dst, sim = sim) } pic_data <- copy_to(sc, gen_pic_data()) clusters <- ml_power_iteration( pic_data, src_col = "src", dst_col = "dst", weight_col = "sim", k = 2, max_iter = 40 ) print(clusters) }


HNEFATAFL
Traditional ~ 400 AD Scandinavia
The game of Tablut was discovered by Carl von Linné at Kvikkjokk, Sweden, in 1732. It is almost certainly the Old Norse board-game known as "Hnefatafl", mentioned in the Icelandic sagas. The word hnefatafl is a compound of Hnefi (meaning fist) and Tafl (ultimately from tabula and meaning board). The rules have been developed by Martin Skoglund, Historisk Form, in collaboration with Inga Lundström of the National Museum of Antiquities. [from www.expomedia.se/tablut/eng/history.htm]
The game was popular in the Viking homelands in Scandinavia as early as 400 AD and was carried by the Vikings to the lands they conquered. Over the centuries the game developed and different versions of the board have been found by archaeologists in sites from Ireland to the Ukraine. Occasionally referred to in manuscripts the game was known as Hnefatafl which means literally "king's table". Its decline began in the 11th century as chess grew in popularity. It soon lingered on only in remote country districts. [from http://viking.no/e/life/egames.htm]
The game is played on the following board with this setup:
- MOVE - Each piece (soldier and King) slide any number of empty cells on a orthogonal straight line, i.e., like a chess Rook.
- CAPTURE - Captures are custodian, i.e., an enemy soldier is captured when two friendly pieces are positioned one on either side of the enemy, either vertically of horizontally (but not diagonally).
- If a piece moves to a position between two enemy counters it will not be captured.
- It's possible to capture an enemy piece by trapping him between a piece and one of the green dots.
- The King is only captured if it is surrounded on all sides by attacking pieces.
- The center board (the throne) can also be used as if it was a friendly stone, to capture the King.
- GOAL - The King's side wins by moving his King to one of the board corners (the green dot cells). The other side wins by capturing the King.
This version has a big flaw, it is too easy to win when playing the King side. There is some mistake between the real rules (already lost?) and the written ones. You can try playing it here.
According to Mats Winther: No wonder that it is an unfair game [...] according to experts at the Historical Museum, Stockholm, the king can be captured like any other piece, by sandwiching it between *two* pieces . It is only at the center position that four pieces are needed to capture it. On the squares directly adjacent to the central square three pieces can capture the king, since the central square is used as a capture-square. Otherwise only two pieces are necessary, and one piece is enough if the king is positioned to any of the corner squares (since these are capture-squares). If four pieces are needed to capture the king, then the attacker's game is hopeless.
An example Moving to one of the red dots, would capture the respective green piece.
Alea Evangelii was the Saxon variant and used a nineteen by nineteen board - it was apparently the only board game played by the Saxons. It takes its modern name from the opening line of the XIIth century manuscript (around 1140) it is documented by: "Incipit alea evangelii quam Dubinsi…". Some commentators suggest that this arrangement represents a sea-battle, with a King's ship defended by twenty-four white ships and a fleet of forty-eight dark attackers. [from www.gamecabinet.com/history/Hnef.html]
From the same website, some strategy notes: The King's forces usually possess a slight advantage, despite being outnumbered. Tactically, the defender (King's men) must arrange for the King to escape the board. Therefore, the defender should try to capture as many attackers as possible to clear an escape route, while not trying too hard to protect his own men since they, too, can block the King's escape. The attacker's object is not only to prevent the King's escape, but also to capture him. The best way to do this is to avoid making captures early in the game, instead scattering the attackers to block possible escape routes.
An interesting way to play this game, is to reduce the King's power so that it can only moves to an adjacent orthogonal cell. This rule change balances things a bit more.
Much more information can be found at Traditional Games, in Games of the Viking & Anglo-Saxon Age and in this website (where it is also possible to download a playing software). There is a ZRF to play the more complex form of Hnefatafl with Zillions. It's possible to play online with human opponents at Ludoteka.
Other board layouts (by Damian Walker)
The initial game layout of a game called Ard Ri, played in Scotland. Some web sources say that in this variant the pieces move only one space at a time.
One of two proposed layouts for the game of brandubh, played in Ireland. This game is mentioned at least twice in contemporary poetry. One extract describes a brandubh board with a king and four men around him; another extract mentions five pieces of one color against eight of another. This is the layout used in the evaluation version of Zillions of Games.
This is another layout for brandubh, proposed in the periodical Eigse: a Journal of Irish Studies, in 1946.
This is a popular layout for constructions of the 11x11 game. It is used in the DOS game Viking Siege, as well some commercial game sets.
This is the layout for Tawlbwrdd, given by R. C. Bell in his book Board and Table Games from Many Civilizations (volume 2).
This is another suggested layout for the 11x11 board, put forward because of its similarity to Tablut.
There is a very similar modern game called Papillon's Escape with the following setup:
Another commercial variant for this old game is 1970's Swords & Shields from Milton Bradley publisher.


Sort Tests by the Names Down .
{{test.time}}
Algortim Accuracy in this test: {{accuracy}}
Algortim Accuracy in this test: {{accuracy2}}


Deuteronomy 23:24
When thou comest into thy neighbor's vineyard, then thou mayest eat grapes thy fill at thine own pleasure; but thou shalt not put any in thy vessel.


Move mouse over list item to mark it as read.
In real world, it may be better idea to mark items as read when application tab in browser is activated. You can check out stackoverflow answer about how to subscribe to such events.
Last notification: ∞ seconds ago.
Next one will be shown in ∞ seconds.
There're no unread items. Add new item for new notification


Fascinated since childhood by the power of images, and the strength of the performances, I resolutely turn to the
photography quite late in 2006 with the purchase of my first digital SLR. My first favorite themes
are related to my other interests, and I quickly turn to concert photography, taste
which will not fail over time. Over time, I developed my artistic practice, and am attracted to others
themes, including architectural photography, which I appreciate the strong ability to immerse the viewer in
a vast and exotic world ... but also by food photography, and more immediately evocative dimension!
Since 2013, I also immersed in film photography, fascinated by the image of an approach to patience
and precision. Child of digital, I still feel a strong respect for the original know-how; Stadium
Next will be the installation of my laboratory to develop my own film and prints. By himself pure, as
Everytime.
Attracted by the underground circles, I like to hang my gaiters in all kinds of concerts, but also meet
promising artstes, explore and discover their world, and their capacity building. So you will find,
more galleries devoted to concert photography, various "live reports" and interviews in the section
"Music" of this website.
I try to do my photographic approach as my life, a coherent universe, where the visual resonates with
meaning. I like to find an ecstatic expression on the face of an artist in concert, or enter a building by emphasizing its
functionality or, conversely, its unique demonstration effect! some iréelles images yet taken of our world
daily, or rather my travels as an invitation to always better observe the world around us,
its many facets ...
If you are interested in my work, surprised by a shot, wanting to order a print, or a curious item
together, you can write me at the following address: contact@nokturnalclash.fr.


A cross-browser library of CSS animations. As easy to use as an easy thing. Read the Official Animate CSS Repository for a full list of instructions and other options.
To animate an element, add the class .animated
to an element together with the animate classes in the following examples below.

...

To animate an element, add the class .animated
to an element together with the animate classes in the following examples below.
To animate an element, add the class .animated
to an element together with the animate classes in the following examples below.
To animate an element, add the class .animated
to an element together with the animate classes in the following examples below.
To animate an element, add the class .animated
to an element together with the animate classes in the following examples below.
To animate an element, add the class .animated
to an element together with the animate classes in the following examples below.
To animate an element, add the class .animated
to an element together with the animate classes in the following examples below.
To animate an element, add the class .animated
to an element together with the animate classes in the following examples below.
To animate an element, add the class .animated
to an element together with the animate classes in the following examples below.
To animate an element, add the class .animated
to an element together with the animate classes in the following examples below.
To animate an element, add the class .animated
to an element together with the animate classes in the following examples below.