{% extends "application_projects/project_detail.html" %} {% load approval_tools %} {% load static %} {% block admin_actions %}
This project is missing the following documents:
This will move the project into contracting and notify the compliance team.
This cannot be undone
{% include 'funds/includes/delegated_form_base.html' with form=add_approval_form value='Approve'%}You confirm that the uploaded contract is acceptable for commencing the project.
This cannot be undone.
{% include 'funds/includes/delegated_form_base.html' with form=approve_contract_form value='Confirm' %}


Sample run of chapter's interpreter examples
// In file concurrency/Actors.scala import scala.actors._ object SillyActor extends Actor { def act() { for (i <- 1 to 5) { println("I'm acting!") Thread.sleep(1000) } } }
scala> SillyActor.start() I'm acting! res4: scala.actors.Actor = SillyActor$@1945696 scala> I'm acting! I'm acting! I'm acting! I'm acting!
scala> Thread.sleep(5000) asdf
// In file concurrency/Actors.scala import scala.actors._ object SeriousActor extends Actor { def act() { for (i <- 1 to 5) { println("To be or not to be.") Thread.sleep(1000) } } }
scala> SillyActor.start(); SeriousActor.start() res3: scala.actors.Actor = seriousActor$@1689405 scala> To be or not to be. I'm acting! To be or not to be. I'm acting! To be or not to be. I'm acting! To be or not to be. I'm acting! To be or not to be. I'm acting!
scala> Thread.sleep(5000) asdf
scala> import scala.actors.Actor._ scala> val seriousActor2 = actor { | for (i <- 1 to 5) | println("That is the question.") | Thread.sleep(1000) | } scala> That is the question. That is the question. That is the question. That is the question. That is the question.
scala> SillyActor ! "hi there"
// In file concurrency/Actors.scala val echoActor = actor { while (true) { receive { case msg => println("received message: "+ msg) } } }
scala> echoActor ! "hi there" received message: hi there scala> echoActor ! 15 scala> received message: 15
scala> val intActor = actor { | receive { | case x: Int => // I only want Ints | println("Got an Int: "+ x) | } | } intActor: scala.actors.Actor = scala.actors.Actor$$anon$1@34ba6b
scala> intActor ! "hello" scala> intActor ! math.Pi
scala> intActor ! 12 Got an Int: 12
scala> import scala.actors.Actor._ import scala.actors.Actor._ scala> self ! "hello" scala> self.receive { case x => x } res6: Any = hello
scala> self.receiveWithin(1000) { case x => x } // wait a sec! res7: Any = TIMEOUT
// In file concurrency/Actors.scala object NameResolver extends Actor { import java.net.{InetAddress, UnknownHostException} def act() { react { case (name: String, actor: Actor) => actor ! getIp(name) act() case "EXIT" => println("Name resolver exiting.") // quit case msg => println("Unhandled message: "+ msg) act() } } def getIp(name: String): Option[InetAddress] = { try { Some(InetAddress.getByName(name)) } catch { case _:UnknownHostException => None } } }
scala> NameResolver.start() res0: scala.actors.Actor = NameResolver$@90d6c5 scala> NameResolver ! ("www.scala-lang.org", self) scala> self.receiveWithin(0) { case x => x } res2: Any = Some(www.scala-lang.org/<IP_ADDRESS>) scala> NameResolver ! ("wwwwww.scala-lang.org", self) scala> self.receiveWithin(0) { case x => x } res4: Any = None
// In file concurrency/Actors.scala def act() { loop { react { case (name: String, actor: Actor) => actor ! getIp(name) case msg => println("Unhandled message: " + msg) } } }
actor { Thread.sleep(time) mainActor ! "WAKEUP" }
// In file concurrency/Actors.scala val sillyActor2 = actor { def emoteLater() { val mainActor = self actor { Thread.sleep(1000) mainActor ! "Emote" } } var emoted = 0 emoteLater() loop { react { case "Emote" => println("I'm acting!") emoted += 1 if (emoted < 5) emoteLater() case msg => println("Received: "+ msg) } } }
scala> sillyActor2 ! "hi there" scala> Received: hi there I'm acting! I'm acting! I'm acting!
def act() { loop { react { case (name: String, actor: Actor) => actor ! (name, getIp(name)) } } }
lookerUpper ! ("www.scala-lang.org", self)
case class LookupIP(hostname: String, requester: Actor) lookerUpper ! LookupIP("www.scala-lang.org", self)
// In file concurrency/Actors.scala import scala.actors.Actor._ import java.net.{InetAddress, UnknownHostException} case class LookupIP(name: String, respondTo: Actor) case class LookupResult( name: String, address: Option[InetAddress] ) object NameResolver2 extends Actor { def act() { loop { react { case LookupIP(name, actor) => actor ! LookupResult(name, getIp(name)) } } } def getIp(name: String): Option[InetAddress] = { // As before (in Listing 30.3) } }
trait Simulant extends Actor class Wire extends Simulant
// In file concurrency/ParallelSimulation.scala case class Ping(time: Int) case class Pong(time: Int, from: Actor)
class Clock extends Actor { private var running = false private var currentTime = 0 private var agenda: List[WorkItem] = List() }
// In file concurrency/ParallelSimulation.scala case class WorkItem(time: Int, msg: Any, target: Actor)
// In file concurrency/ParallelSimulation.scala case class AfterDelay(delay: Int, msg: Any, target: Actor)
// In file concurrency/ParallelSimulation.scala case object Start case object Stop
// In file concurrency/ParallelSimulation.scala class Clock extends Actor { private var running = false private var currentTime = 0 private var agenda: List[WorkItem] = List() private var allSimulants: List[Actor] = List() private var busySimulants: Set[Actor] = Set.empty
// In file concurrency/ParallelSimulation.scala start()
// In file concurrency/ParallelSimulation.scala def add(sim: Simulant) { allSimulants = sim :: allSimulants }
// In file concurrency/ParallelSimulation.scala def act() { loop { if (running && busySimulants.isEmpty) advance() reactToOneMessage() } }
// In file concurrency/ParallelSimulation.scala def advance() { if (agenda.isEmpty && currentTime > 0) { println("** Agenda empty. Clock exiting at time "+ currentTime+".") self ! Stop return } currentTime += 1 println("Advancing to time "+currentTime) processCurrentEvents() for (sim <- allSimulants) sim ! Ping(currentTime) busySimulants = Set.empty ++ allSimulants }
// In file concurrency/ParallelSimulation.scala private def processCurrentEvents() { val todoNow = agenda.takeWhile(_.time <= currentTime) agenda = agenda.drop(todoNow.length) for (WorkItem(time, msg, target) <- todoNow) { assert(time == currentTime) target ! msg } }
// In file concurrency/ParallelSimulation.scala def reactToOneMessage() { react { case AfterDelay(delay, msg, target) => val item = WorkItem(currentTime + delay, msg, target) agenda = insert(agenda, item) case Pong(time, sim) => assert(time == currentTime) assert(busySimulants contains sim) busySimulants -= sim case Start => running = true case Stop => for (sim <- allSimulants) sim ! Stop exit() } }
// In file concurrency/ParallelSimulation.scala def act() { loop { react { case Stop => exit() case Ping(time) => if (time == 1) simStarting() clock ! Pong(time, self) case msg => handleSimMessage(msg) } } }
// In file concurrency/ParallelSimulation.scala trait Simulant extends Actor { val clock: Clock def handleSimMessage(msg: Any) def simStarting() { } def act() { loop { react { case Stop => exit() case Ping(time) => if (time == 1) simStarting() clock ! Pong(time, self) case msg => handleSimMessage(msg) } } } start() }
// In file concurrency/Circuit.scala class Circuit { val clock = new Clock // simulation messages // delay constants // Wire and Gate classes and methods // misc. utility methods }
// In file concurrency/Circuit.scala case class SetSignal(sig: Boolean) case class SignalChanged(wire: Wire, sig: Boolean)
// In file concurrency/Circuit.scala val WireDelay = 1 val InverterDelay = 2 val OrGateDelay = 3 val AndGateDelay = 3
// In file concurrency/Circuit.scala class Wire(name: String, init: Boolean) extends Simulant { def this(name: String) { this(name, false) } def this() { this("unnamed") } val clock = Circuit.this.clock clock.add(this) private var sigVal = init private var observers: List[Actor] = List()
// In file concurrency/Circuit.scala def handleSimMessage(msg: Any) { msg match { case SetSignal(s) => if (s != sigVal) { sigVal = s signalObservers() } } } def signalObservers() { for (obs <- observers) clock ! AfterDelay( WireDelay, SignalChanged(this, sigVal), obs) }
// In file concurrency/Circuit.scala override def simStarting() { signalObservers() }
// In file concurrency/Circuit.scala def addObserver(obs: Actor) { observers = obs :: observers } override def toString = "Wire("+ name +")"
// In file concurrency/Circuit.scala private object DummyWire extends Wire("dummy")
// In file concurrency/Circuit.scala abstract class Gate(in1: Wire, in2: Wire, out: Wire) extends Simulant {
// In file concurrency/Circuit.scala def computeOutput(s1: Boolean, s2: Boolean): Boolean
// In file concurrency/Circuit.scala val delay: Int
// In file concurrency/Circuit.scala val clock = Circuit.this.clock clock.add(this)
// In file concurrency/Circuit.scala in1.addObserver(this) in2.addObserver(this)
// In file concurrency/Circuit.scala var s1, s2 = false
// In file concurrency/Circuit.scala def handleSimMessage(msg: Any) { msg match { case SignalChanged(w, sig) => if (w == in1) s1 = sig if (w == in2) s2 = sig clock ! AfterDelay(delay, SetSignal(computeOutput(s1, s2)), out) } }
// In file concurrency/Circuit.scala def orGate(in1: Wire, in2: Wire, output: Wire) = new Gate(in1, in2, output) { val delay = OrGateDelay def computeOutput(s1: Boolean, s2: Boolean) = s1 || s2 } def andGate(in1: Wire, in2: Wire, output: Wire) = new Gate(in1, in2, output) { val delay = AndGateDelay def computeOutput(s1: Boolean, s2: Boolean) = s1 && s2 }
// In file concurrency/Circuit.scala def inverter(input: Wire, output: Wire) = new Gate(input, DummyWire, output) { val delay = InverterDelay def computeOutput(s1: Boolean, ignored: Boolean) = !s1 }
// In file concurrency/Circuit.scala def probe(wire: Wire) = new Simulant { val clock = Circuit.this.clock clock.add(this) wire.addObserver(this) def handleSimMessage(msg: Any) { msg match { case SignalChanged(w, s) => println("signal "+ w +" changed to "+ s) } } }
// In file concurrency/Circuit.scala def start() { clock ! Start }
// In file concurrency/Adders.scala trait Adders extends Circuit { def halfAdder(a: Wire, b: Wire, s: Wire, c: Wire) { val d, e = new Wire orGate(a, b, d) andGate(a, b, c) inverter(c, e) andGate(d, e, s) } def fullAdder(a: Wire, b: Wire, cin: Wire, sum: Wire, cout: Wire) { val s, c1, c2 = new Wire halfAdder(a, cin, s, c1) halfAdder(b, s, sum, c2) orGate(c1, c2, cout) } }
val circuit = new Circuit with Adders
val circuit = new Circuit with Adders with Multiplexers with FlipFlops with MultiCoreProcessors
// In file concurrency/Demo.scala object Demo { def main(args: Array[String]) { val circuit = new Circuit with Adders import circuit._ val ain = new Wire("ain", true) val bin = new Wire("bin", false) val cin = new Wire("cin", true) val sout = new Wire("sout") val cout = new Wire("cout") probe(ain) probe(bin) probe(cin) probe(sout) probe(cout) fullAdder(ain, bin, cin, sout, cout) circuit.start() } }
Advancing to time 1 Advancing to time 2 signal Wire(cout) changed to false signal Wire(cin) changed to true signal Wire(ain) changed to true signal Wire(sout) changed to false signal Wire(bin) changed to false Advancing to time 3 Advancing to time 4 Advancing to time 5 Advancing to time 6 Advancing to time 7 Advancing to time 8 Advancing to time 9 Advancing to time 10 signal Wire(cout) changed to true Advancing to time 11 Advancing to time 12 Advancing to time 13 Advancing to time 14 Advancing to time 15 Advancing to time 16 Advancing to time 17 Advancing to time 18 signal Wire(sout) changed to true Advancing to time 19 Advancing to time 20 Advancing to time 21 signal Wire(sout) changed to false ** Agenda empty. Clock exiting at time 21.
|
For more information about Programming in Scala, Second Edition (the "Stairway Book"), please visit: http://www.artima.com/shop/programming_in_scala_2ed and: |
Copyright © 2007-2010 Artima, Inc. All rights reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. |


Family Gardens keeps your family engaged with your garden by giving you the supplies to make your garden thrive —so you always have what ’s needed to keep your garden bountiful.
We customize each box to fit you.
We ship you all the supplies you need.
Enjoy growing with family and friends.
You get all the supplies to make your garden a success.
Every GardenBox™ comes with easy to understand directions.
Teach the value of gardening and know where food comes from.
Spend more time with family, doing things that really matter.
You'll harvest more than you ever thought possible.
We provide tasty and healthy recipe options.


Add text field
Add password field
Add hidden field
Add select
Add text area
Add content editable
Add 100 hidden tables
update
Attach new handler to the FORM
Attach new handler to INPUTS
Show polling pool
Show source pool
updatePlus
Attach new handler to the FORM
Attach new handler to INPUTS
Show polling pool
Show source pool
heavy
Attach new handler to the FORM
Attach new handler to INPUTS
Show polling pool
Show source pool
×
×
hidden
×
Option 1
Option 2
Option 3
×
×
KEEP CALM
AND POLL THE POOL
×
100 hidden tables :-)
×


| Package | Description |
|---|---|
| org.apache.jena.reasoner |
The Jena2 reasoner subsystem is designed to allow a range of inference
engines to be plugged into Jena.
|
| org.apache.jena.reasoner.rulesys |
Provides a selection of simple rule engines for Jena inference models.
|
| org.apache.jena.reasoner.rulesys.impl |
Internal implementation objects used by the rule system interpreters
and compilers.
|
| org.apache.jena.reasoner.transitiveReasoner |
This package contains a reasoner which supports transitive-reflexive closure
of subPropertyOf and subClassOf relations.
|
| org.apache.jena.util |
Miscellaneous collection of utility classes.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
TriplePattern.compatibleWith(TriplePattern pattern)
Compare two patterns for compatibility - i.e.
|
boolean |
Finder.contains(TriplePattern pattern)
Return true if the given pattern occurs somewhere in the find sequence.
|
boolean |
FGraph.contains(TriplePattern pattern)
Return true if the given pattern occurs somewhere in the find sequence.
|
ExtendedIterator<Triple> |
Finder.find(TriplePattern pattern)
Basic pattern lookup interface.
|
ExtendedIterator<Triple> |
FGraph.find(TriplePattern pattern)
Basic pattern lookup interface.
|
ExtendedIterator<Triple> |
BaseInfGraph.find(TriplePattern pattern)
Basic pattern lookup interface.
|
ExtendedIterator<Triple> |
Finder.findWithContinuation(TriplePattern pattern,
Finder continuation)
Extended find interface used in situations where the implementator
may or may not be able to answer the complete query.
|
ExtendedIterator<Triple> |
FGraph.findWithContinuation(TriplePattern pattern,
Finder continuation)
Extended find interface used in situations where the implementator
may or may not be able to answer the complete query.
|
abstract ExtendedIterator<Triple> |
BaseInfGraph.findWithContinuation(TriplePattern pattern,
Finder continuation)
Extended find interface used in situations where the implementator
may or may not be able to answer the complete query.
|
boolean |
TriplePattern.subsumes(TriplePattern arg)
Compare two patterns and return true if arg is a more
specific (more grounded) version of this one.
|
boolean |
TriplePattern.variantOf(TriplePattern pattern)
Test if a pattern is just a variant of this pattern.
|
| Modifier and Type | Method and Description |
|---|---|
ExtendedIterator<Triple> |
LPBackwardRuleInfGraph.find(TriplePattern pattern)
Basic pattern lookup interface.
|
ExtendedIterator<Triple> |
FBRuleInfGraph.find(TriplePattern pattern)
Basic pattern lookup interface.
|
ExtendedIterator<Triple> |
BasicForwardRuleInfGraph.find(TriplePattern pattern)
Basic pattern lookup interface.
|
ExtendedIterator<Triple> |
LPBackwardRuleInfGraph.findDataMatches(TriplePattern pattern)
Match a pattern just against the stored data (raw data, schema,
axioms) but no derivation.
|
ExtendedIterator<Triple> |
FBRuleInfGraph.findDataMatches(TriplePattern pattern)
Search the combination of data and deductions graphs for the given triple pattern.
|
ExtendedIterator<Triple> |
BackwardRuleInfGraphI.findDataMatches(TriplePattern pattern)
Match a pattern just against the stored data (raw data, schema,
axioms) but no backchaining derivation.
|
ExtendedIterator<Triple> |
FBRuleInfGraph.findFull(TriplePattern pattern)
Internal variant of find which omits the filters which block illegal RDF data.
|
ExtendedIterator<Triple> |
LPBackwardRuleInfGraph.findWithContinuation(TriplePattern pattern,
Finder continuation)
Extended find interface used in situations where the implementator
may or may not be able to answer the complete query.
|
ExtendedIterator<Triple> |
FBRuleInfGraph.findWithContinuation(TriplePattern pattern,
Finder continuation)
Extended find interface used in situations where the implementator
may or may not be able to answer the complete query.
|
ExtendedIterator<Triple> |
BasicForwardRuleInfGraph.findWithContinuation(TriplePattern pattern,
Finder continuation)
Extended find interface used in situations where the implementator
may or may not be able to answer the complete query.
|
Triple |
BindingEnvironment.instantiate(TriplePattern pattern)
Instantiate a triple pattern against the current environment.
|
| Modifier and Type | Class and Description |
|---|---|
class |
MutableTriplePattern
Variant of the normal TriplePattern object which can be updated in place
to avoid store turn over.
|
| Modifier and Type | Method and Description |
|---|---|
TriplePattern |
BindingVector.partInstantiate(TriplePattern goal)
Bind the variables in a goal pattern using the binding environment, to
generate a more specialized goal
|
| Modifier and Type | Method and Description |
|---|---|
List<RuleClauseCode> |
LPRuleStore.codeFor(TriplePattern goal)
Return an ordered list of RuleClauseCode objects to implement the given
query pattern.
|
static RETEClauseFilter |
RETEClauseFilter.compile(TriplePattern clause,
int envLength,
List<Node> varList)
Create a filter node from a rule clause.
|
static Triple |
LPInterpreter.deref(TriplePattern t)
Return a dereferenced copy of a triple.
|
ExtendedIterator<Triple> |
LPBRuleEngine.find(TriplePattern goal)
Start a new interpreter running to answer a query.
|
Generator |
LPBRuleEngine.generatorFor(TriplePattern goal)
Return a generator for the given goal (assumes that the caller knows that
the goal should be tabled).
|
Generator |
LPBRuleEngine.generatorFor(TriplePattern goal,
List<RuleClauseCode> clauses)
Return a generator for the given goal (assumes that the caller knows that
the goal should be tabled).
|
Triple |
LPBindingEnvironment.instantiate(TriplePattern pattern)
Instantiate a triple pattern against the current environment.
|
Triple |
BindingVector.instantiate(TriplePattern pattern)
Instantiate a triple pattern against the current environment.
|
Triple |
BindingStack.instantiate(TriplePattern pattern)
Instantiate a triple pattern against the current environment.
|
boolean |
LPRuleStore.isTabled(TriplePattern goal)
Return true if the given goal is tabled, currently this is true if the
predicate is a tabled predicate or the predicate is a wildcard and some
tabled predicates exist.
|
static boolean |
FRuleEngine.match(TriplePattern pattern,
Triple triple,
BindingStack env)
Test if a TriplePattern matches a Triple in the given binding
environment.
|
void |
EnvironmentFrameWithDerivation.noteMatch(TriplePattern pattern,
int pc)
Instantiate and record a matched subgoal
|
TriplePattern |
BindingVector.partInstantiate(TriplePattern goal)
Bind the variables in a goal pattern using the binding environment, to
generate a more specialized goal
|
List<Rule> |
RuleStore.rulesFor(TriplePattern goal)
Return a list of rules that match the given goal pattern
|
static BindingVector |
BindingVector.unify(TriplePattern goal,
TriplePattern head,
int numRuleVars)
Unify a goal with the head of a rule.
|
| Constructor and Description |
|---|
Generator(LPInterpreter interpreter,
TriplePattern goal)
Constructor.
|
LPInterpreter(LPBRuleEngine engine,
TriplePattern goal)
Constructor used to construct top level calls.
|
LPInterpreter(LPBRuleEngine engine,
TriplePattern goal,
boolean isTop)
Constructor.
|
LPInterpreter(LPBRuleEngine engine,
TriplePattern goal,
List<RuleClauseCode> clauses,
boolean isTop)
Constructor.
|
TopLevelTripleMatchFrame(LPInterpreter interpreter,
TriplePattern goal)
Constructor.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
TransitiveGraphCache.contains(TriplePattern pattern)
Return true if the given pattern occurs somewhere in the find sequence.
|
ExtendedIterator<Triple> |
TransitiveInfGraph.find(TriplePattern pattern)
Basic pattern lookup interface.
|
ExtendedIterator<Triple> |
TransitiveGraphCache.find(TriplePattern pattern)
Basic pattern lookup interface.
|
ExtendedIterator<Triple> |
TransitiveInfGraph.findWithContinuation(TriplePattern pattern,
Finder continuation)
Extended find interface used in situations where the implementator
may or may not be able to answer the complete query.
|
ExtendedIterator<Triple> |
TransitiveGraphCache.findWithContinuation(TriplePattern pattern,
Finder continuation)
Extended find interface used in situations where the implementator
may or may not be able to answer the complete query.
|
Finder |
TransitiveEngine.getFinder(TriplePattern pattern,
Finder continuation)
Return a Finder instance appropriate for the given query.
|
| Modifier and Type | Method and Description |
|---|---|
static String |
PrintUtil.print(TriplePattern triple)
Return a simplified print string for a TriplePattern
|
Licenced under the Apache License, Version 2.0


{% block subject %} {% if subject %} Tag '{{ meta.tag_name.0 }} has changed value to '{{ meta.tag_name.1 }}' {% endif %} {% endblock %} {% block frommail %} {% if frommail %} IPC<EMAIL_ADDRESS>{% endif %} {% endblock %}
Tag {{ object.tag_name }} has changed its value. Its newer value is {{ meta.tag_name.1}}
See if you intended this change. If not, you may need to escalate. This change has happened earliest an hour before {{ ts }}


Module that parses timestamps into Twitter time.
- Source:
Requires
- module:moment
Members
(inner, constant) day :number
A day in miliseconds
Type:
- number
- Source:
(inner, constant) hour :number
An hour in miliseconds
Type:
- number
- Source:
(inner, constant) minute :number
A minute in miliseconds
Type:
- number
- Source:
(inner, constant) second :number
A second in miliseconds
Type:
- number
- Source:
Methods
(static) dmTime(timestamp) → {string}
A timestamp parser function used to parse Twitters direct messages.
Parameters:
| Name | Type | Description |
|---|---|---|
timestamp |
string | A timestamp as a string |
- Source:
Returns:
A timestamp fitting for the API
- Type
- string
(static) tweetTime(timestamp) → {string}
A timestamp parser function used to parse Twitters Tweets.
Parameters:
| Name | Type | Description |
|---|---|---|
timestamp |
string | A timestamp as a string |
- Source:
Returns:
A timestamp fitting for the API
- Type
- string


What are virtual meetings?
A virtual meeting is when people from around the world, regardless of their location, use video, audio and text in order meet together online.
Virtual meetings allow people to share information, experiences and data in real-time without the need for being physically located in the same room together. Virtual meetings often use video teleconference (VTC) software, such as Microsoft’s Skype or Teams, Adobe’s Connect or Zoom, just to name a few.
Taking meetings virtually has been steadily gaining in popularity in recent years (and even more so in recent months due to social distancing requirements) with many businesses choosing to become more digital.
They are designed to replace in-person meetings, so that employees don’t have to travel to a specific location in order to attend them. Instead, they can simply dial in from wherever they are based.
In particular, this way of meeting is beneficial to companies who are also choosing to embrace the rise of remote working in their strategies, allowing more employees to work independent of being at the office. Virtual meetings allow all employees to be included in important discussions regardless of where they are based, which greatly increases business inclusivity.
This is particularly enhanced if businesses adopt a certain set of protocols to their meetings, such as everyone turning on their webcam and microphone, allowing for a more personal, connected meeting, akin to everyone being co-located.
In fact, according to Gigaom,? 87% of remote team members feel more connected to their team when they can use video conferencing.
So why should businesses use virtual meetings?
There are a myriad of benefits associated with having virtual meetings as opposed to face-to-face ones, which can assist business in making that key decision to go virtual.
- Convenience
Virtual meetings bring a lot of natural convenience to businesses. This isn’t just because it saves the company the hassle of using real-time devices such as projectors or paper presentations, but also because it allows you to have an ‘all hands on deck’ meeting, even when others are busy elsewhere; such as working away on business trips or simply working from home.
This convenience is adopted across training sessions and interviews too, as they can be conducted via virtual meeting in the same manner. Meeting rooms are no lo
- Reduce expenses
In-person business meetings mean hotels, meals, rental cars, car parking tickets, and even airfares in order to make them happen, all of which can cause significant cost to the business.
With virtual meetings, an organisation will not have to spend their budget on such items, as meeting attendees are not coming together physically in order to conduct their business.
The meeting can still take place with everyone just where they are.
What’s more, meetings can take place rapidly one after another without the need to travel to a new hotel and begin the process all over again.
- Inclusivity
We’ve mentioned it before but making your meetings virtual can really help the inclusivity of your business.
If you have remote or home workers, or colleagues who are unable to make the journey into the office for whatever reason, there is no need for them to be excluded from potentially important meetings, nor the hassle of rescheduling or trying to realign diaries.
What are the best platforms for running virtual meetings?
- Zoom
At VTT, we love Zoom. It’s easy to use, the basic package is free, it’s simple to set up and you can invite people to a meeting with a single clicked link.
Zoom is a huge, simple video conferencing and messaging platform that works across almost any device. It’s suite of functionality offers easy, widespread usability, enabling quick adoption and quick start up, joining and collaboration tools for everyone to use.
- Microsoft Teams
We also use Microsoft Teams here at VTT for our virtual meetings. As we are already using the platform as a hub for chat, collaboration and news, we find it simple to organise our meetings, particularly at short notice.
If you wanted to have a larger meeting, Teams has the functionality to organise people into breakout rooms, to simulate splitting a room into groups in order to better discuss ideas or processes moving forward.
- Join.me
While we haven’t used it ourselves, Join.me is a piece of very friendly, virtual meeting software. It is available on all devices and can host up to 10 individuals on the screen at the same time.
It is great for easy presentations, sales demos and video call discussions.
- Skype
Skype is one of the best pieces of virtual meeting software available. It has both a free and paid version available.
The free version allows video conferencing calls to be made free of charge, with the only requirement being that they must be other Skype users.
The paid version of this allows the user to call those who do not have skype, which can be helpful when wanting to include external attendees to the meeting.
- Google Hangouts
Google hangouts is a great way to conduct virtual meetings too, though we think it works better for internal meetings rather than externals. It includes instant messaging, video chat and SMS functionality. It can cater for up to 10 participants in a single meeting and is also available across many mobile devices too.
It works similarly to Microsoft Teams and is most regularly implemented by teams in order to stay in contact throughout the day and easily be able to schedule meetings with colleagues effectively.
What are the benefits of virtual meetings?
There are many benefits that can be gained by using virtual meetings as opposed to face-to-face. They are quickly becoming the most efficient way to hold meetings in business today.
So here is a list of the top benefits that can be enjoyed if virtual meetings are adopted.
-
hey are more cost effective
As we mentioned above, making your meetings virtual makes them hugely cost effective compared to physical meetings. They only require a computer or mobile with an internet connection in order to attend.
There is no travel, no accommodation, no physical meeting room. Merely investing in a good platform for continued use could save your business a great deal.
-
It is inclusive
The technological advancement in our modern world has seen the internet improve greatly, so much so that users on the web can connect and interact from almost any part of the world.
By meeting via the internet, office space is saved that would have previously been used to hold a meeting, particularly when the number of participants was large. The internet has no maximum room capacity, though your choice of virtual meeting software might do.
-
It allows sharing in real-time
Participants of virtual meetings can share information, whether text, audio, or video in moments. Most virtual meeting platforms have the ability to send files, share screens or record data in a number of ways which makes it even easier for relevant information to reach the right person.
Also, there is no paper waste, as printing off the information and providing enough copies for everyone that might have previously ended up in the recycling, needn’t be printed at all.
-
They allow increased opportunities
It is not always possible to attend every phsyical meeting you are invited to, due to other commitments, location or time.
Virtual meetings, however, give people the opportunity to attend from their workspace. Often, due to the convenience and speed of which they are scheduled, the meetings tend to be quicker and more efficient, without the need for build up ‘coffee talk’ or general chatter, making the meeting more streamlined.
-
They have less impact on the environment
As we have touched on above, making the shift to having virtual meetings greatly reduces the need for travel and unnecessary printing.
Everyone can attend the meeting from their workspace, wherever that is, and all files can be shared electronically rather than being printed.
This helps businesses who are increasingly becoming aware of their carbon footprint and environmental impact to significantly reduce their unnecessary outputs.
How to run a successful virtual meeting?
Virtual meetings are fantastic tools for increased inclusivity and convenience, but there is often a concern that people won’t be ‘as engaged’ in a virtual meeting as they are a face-to-face one.
Here are some tips for how to run a successful virtual meeting.
-
Turn the video on
Since you are all going to be separated by a screen, the best thing to do to encourage maximum participation is to have everyone turn their cameras on.
This is key in getting engagement for several reasons. Firstly, everyone will more likely feel like they are in a room together.
Also, facial expressions are important. Without video, you can’t see if someone is nodding, or desperately shaking their head, nor smiling or frowning. Facial expressions matter.
If you need a few tips and guidance, we also wrote a blog on 5 tips how to rock your webcam! Check it out here
-
Cut out reporting!

The solution to this is to send out a simple half page in advance of the meeting to report on just the key items.
Spend the time in the areas that matter, the interaction, the decisions, the people. Anyone can read a report on their own, it doesn’t need to be presented to them during these valuable moments.
-
Connect people
People perform much better when they are comfortable with each other, which can cultivate a greater degree of honesty and mutual interest as well as harnessing diversity.
As the facilitator of the meeting, it is your job to help people get to know one another, to make them feel connected so they can have a productive meeting, and quickly get over any social awkwardness.
-
Avoid the mute button
In a co-located meeting, there are some social norms - you wouldn’t get up and walk around the room, not paying attention to what’s going on.
A virtual meeting is no different; you shouldn’t put yourself on mute and start answering your emails. If the meeting is going to be successful, you need to be prepared for the live, interactive discussion, laughter and creativity.
-
No multitasking
Did you know only 2% of the entire population can multitask? The number of those who think they can multitask is much higher. Which one are you?
Once, multitasking was thought of as a way to get many things done at once, however, now as science shows us, it is now understood to be a way to do many things poorly.
Not only is it bad for the brain, it’s bad for the team. However, there is good news. By putting on your video camera and avoiding the mute button, multitasking risk is greatly reduced. It is hard to check emails and pretend to be engaged. Much easier just to be engaged in your meeting, don’t you agree?
What about participants in virtual meetings?
 While virtual meetings are likely part of your daily working routine, it can still be easy to fall into some meeting bad habits.
So to keep your meetings productive and professional, here are some simple etiquette rules;
- Leave your keyboard alone: the sound of typing is distracting and you’re not concentrating on the meeting at hand
- Dress appropriately: while it may be tempting to attend the meeting in your pjs, you will feel more focused in the meeting if you dress smartly and be of neat appearance
- Be aware of your surroundings: be careful what is in your background when you are on video
- Be aware of your background noise: nothing is more frustrating for other participants if there is a phantom noise coming from someone’s mic and it can deter others from speaking if they are competing with external factors
- Speak up: when you join the meeting say hi and don’t be afraid to express opinions on the discussions at hand. That’s why you are there!
- No food allowed: for similar reasons to the background noise, people will unlikely appreciate hearing or watching you eat during your meeting
- Stay seated and present: don’t multitask! Be super present in the meeting, it will improve your focus
Conclusion
Virtual meetings are a fantastic tool that deserve to be used and maximised by every organisation. With the current pressures of the world, the increased need for remote and home working, virtual meetings will be more commonplace as we move forward into this remote future.
Like any new skill set or organisational change, you will find the way that works best for you and your team, and it will be through practice that the finesse will follow.
If you find yourself needing a little help however, we do offer several virtual workshops with virtual meetings included.
You can find out more about them on the virtual workshops page of our website, or by contacting us. We would be more than happy to assist you.


2 references to AssertNotDisposed
System.Management.Automation (2)
engine\hostifaces\PowerShell.cs (2)
4071
AssertNotDisposed
();
4107
AssertNotDisposed
();


SPI Words¶
There are a number of words for controlling SPI peripherals available on each of the supported microcontrollers. These are as follows:
Note that spi values as mentioned below vary between the different supported platforms. The following applies:
On the RP2040 the available spi values are 0 and 1.
On the STM32F411 the available spi values are 1 through 5.
On the STM32F407 the available spi values are 1 through 3.
On the STM32L476 the available spi values are 1 through 3.
On the STM32F746 the available spi values are 1 through 6.
spi
¶
These words are in the spi
module:
All platforms¶
enable-spi
¶
( spi – )
Enable an SPI peripheral.
disable-spi
¶
( spi – )
Disable an SPI peripheral. Note that SPI peripherals are disabled by default.
enable-spi-tx
¶
( spi – )
Enable SPI peripheral transmit.
disable-spi-tx
¶
( spi – )
Disable SPI peripheral transmit.
master-spi
¶
( spi – )
Set an SPI peripheral to be a master. This must be done with the SPI peripheral disabled.
slave-spi
¶
( spi – )
Set an SPI peripheral to be a slave. This must be done with the SPI peripheral disabled.
spi-baud!
¶
( baud spi – )
Set the baud of a master SPI peripheral. This must be done with the SPI peripheral disabled.
motorola-spi
¶
( sph spo spi – )
Set the protocol of an SPI peripheral to Motorola SPI, with SPO/CPOL set to spo and SPH/CPHA set to sph. This must be done with the SPI peripheral disabled.
ti-ss-spi
¶
( spi – )
Set the protocol of an SPI peripheral to TI synchronous serial. This must be done with the SPI peripheral disabled.
spi-data-size!
¶
( data-size spi – )
Set the word size of an SPI peripheral to data-size bits; on the RP2040, STM32L476, and STM32F746 any value from 4 to 16 is permitted, whereas on the STM32F407 and STM32F411 only 8 and 16 are permitted. This must be done with the SPI peripheral disabled.
>spi
¶
( c spi – )
Emit a word to an SPI peripheral.
spi>
¶
( spi – c )
Read a word from an SPI peripheral.
buffer>spi
¶
( addr bytes spi – )
Write a buffer of data to an SPI peripheral as a master, discarding the data returned by the slave. Note that this assumes that the SPI peripheral is in 8 bit mode.
spi>buffer
¶
( add bytes filler spi – )
Read a buffer of data from an SPI peripheral as a master, transmitting a filler byte for each byte sent to the slave. Note that this assumes that the SPI peripheral is in 8 bit mode.
>spi?
¶
( spi – flag )
Get whether an SPI peripheral is ready to emit a word.
spi>?
¶
( spi – flag )
Get whether a word is ready to be read from an SPI peripheral.
drain-spi
¶
( spi – )
Empty an SPI peripheral’s receive buffer.
flush-spi
¶
( spi – )
Flush an SPI peripheral’s transmit buffer.
spi-alternate
¶
( spi – )
The alternate function for a given SPI peripheral. Note that using spi-pin
is recommended as some SPI peripherals may have multiple alternate functions in practice depending on the particular pin.
spi-pin
¶
( spi pin – )
Set the alternate function for pin to configure it for spi.
spi-rx-handler!
¶
( xt spi – )
Set an SPI RX handler called when the SPI interrupt is called for RX data. Note that this may not be called if spi>
is called before the SPI interrupt has the chance to be invoked. A value of 0 indicates no handler.
x-invalid-spi
¶
( – )
Invalid SPI peripheral exception.
x-invalid-spi-clock
¶
( – )
Invalid SPI clock setting exception.
x-invalid-spi-data-size
¶
( – )
Invalid SPI data size setting exception.
RP2040 only¶
enable-spi-loopback
¶
( spi – )
Enable SPI loopback mode for an SPI peripheral.
disable-spi-loopback
¶
( spi – )
Disable SPI loopback mdoe for an SPI peripheral.
natl-microwire-spi
¶
( spi – )
Set the protocol of the SPI peripheral to National Semiconductor Microwire.
STM32F407, STM32F411, STM32L476, and STM32F746 only¶
msb-first-spi
¶
( spi – )
Set an SPI peripheral to have MSB-first data. This must be done with the SPI peripheral disabled.
lsb-first-spi
¶
( spi – )
Set an SPI peripheral to have LSB-first data. This must be done with the SPI peripheral disabled.
enable-spi-ssm
¶
( spi – )
Enable SPI software slave management by master SPI peripherals. This must be done with the SPI peripheral disabled.
disable-spi-ssm
¶
( spi – )
Disable SPI software slave management by master SPI peripherals. This must be done with the SPI peripheral disabled.
spi-ssm!
¶
( ssi spi – )
Set the software slave management selection for master SPI peripherals.
1-line-spi
¶
( spi – )
Set an SPI peripheral to one-wire mode.
2-line-spi
¶
( spi – )
Set an SPI peripheral to two-wire mode (the default).
1-line-spi-in
¶
( spi – )
Set the single wire in one-wire mode to be an input.
1-line-spi-out
¶
( spi – )
Set the single wire in one-wire mode to be an output.


2 Kings 18:34
Where are the gods of Hamath, and of Arpad? where are the gods of Sepharvaim, Hena, and Ivah? have they delivered Samaria out of mine hand?


This extension provides syntactic sugar for getting and setting elements
for user-defined indexed types. For instance, we can define python-like
dictionaries with
module Dict = structinclude Hashtbl
let ( .%{} ) tabl index = find tabl index
let ( .%{}<- ) tabl index value = add tabl index value
endlet dict =
let dict = Dict.create 10 inlet () =
dict.Dict.%{"one"} <- 1;
letopen Dict in
dict.%{"two"} <- 2 in
dict
Multi-index are also supported through a second variant of indexing operators
let (.%[;..]) = Bigarray.Genarray.get
let (.%{;..}) = Bigarray.Genarray.get
let (.%(;..)) = Bigarray.Genarray.get
which is called when an index literals contain a semicolon separated list
of expressions with two and more elements:
let sum x y = x.%[1;2;3] + y.%[1;2]
(* is equivalent to *)let sum x y = (.%[;..]) x [|1;2;3|] + (.%[;..]) y [|1;2|]
In particular this multi-index notation makes it possible to uniformly handle
indexing Genarray and other implementations of multidimensional arrays.
module A = Bigarray.Genarray
let (.%{;..}) = A.get
let (.%{;..}<- ) = A.set
let (.%{ }) a k = A.get a [|k|]
let (.%{ }<-) a k x = A.set a [|k|] x
let syntax_compare vec mat t3 t4 =
vec.%{0} = A.get vec [|0|]
&& mat.%{0;0} = A.get mat [|0;0|]
&& t3.%{0;0;0} = A.get t3 [|0;0;0|]
&& t4.%{0;0;0;0} = t4.{0,0,0,0}
Beware that the differentiation between the multi-index and single index
operators is purely syntactic: multi-index operators are restricted to
index expressions that contain one or more semicolons ;. For instance,
let pair vec mat = vec.%{0}, mat.%{0;0}
is equivalent to
let pair vec mat = (.%{ }) vec 0, (.%{;..}) mat [|0;0|]
Notice that in the vec case, we are calling the single index operator, (.%{}), and
not the multi-index variant, (.{;..}).
For this reason, it is expected that most users of multi-index operators will need
to define conjointly a single index variant
let (.%{;..}) = A.get
let (.%{ }) a k = A.get a [|k|]


Class AutoSyncAdvancedMultiSpatialMap<T>
A version of AdvancedMultiSpatialMap<T> which takes items that implement IPositionable, and uses that interface's properties/events to automatically ensure items are recorded at the proper positions in the spatial map when they move and that the position fields are updated if the spatial map's move functions are used.
Namespace: SadRogue.Primitives.SpatialMaps
Assembly: TheSadRogue.Primitives.dll
Syntax
public class AutoSyncAdvancedMultiSpatialMap<T> : Object, ISpatialMap<T>, IReadOnlySpatialMap<T>, IEnumerable<ItemPositionPair<T>>, IEnumerable where T : class, IPositionable
Type Parameters
| Name | Description |
|---|---|
| T | The type of object that will be contained by this spatial map. |
Remarks
This class automatically keeps the spatial map position of each object synced up with their Position property; you may either use the Move functions of the spatial map, in which case the Position fields of the objects are updated as appropriate, or you may change the Position field, in which case the spatial map position is updated to match.
If you want to manually control the positions of items in the spatial map, you should use AdvancedMultiSpatialMap<T> instead.
Constructors
AutoSyncAdvancedMultiSpatialMap(IEqualityComparer<T>, IListPool<T>, IEqualityComparer<Point>, Int32)
Constructor.
Declaration
public AutoSyncAdvancedMultiSpatialMap(IEqualityComparer<T> itemComparer, IListPool<T> listPool, IEqualityComparer<Point> pointComparer = null, int initialCapacity = 32)
Parameters
| Type | Name | Description |
|---|---|---|
| IEqualityComparer<T> | itemComparer | Equality comparer to use for comparison and hashing of type T. Be especially mindful of the efficiency of its GetHashCode function, as it will determine the efficiency of many AdvancedMultiSpatialMap functions. |
| IListPool<T> | listPool | The list pool implementation to use. Specify NoPoolingListPool<T> to disable pooling entirely. This implementation may be shared with other spatial maps if you wish, however be aware that no thread safety is implemented by the default list pool implementations or the spatial map itself. |
| IEqualityComparer<Point> | pointComparer | Equality comparer to use for comparison and hashing of points, as object are added to/removed from/moved around the spatial map. Be especially mindful of the efficiency of its GetHashCode function, as it will determine the efficiency of many AdvancedMultiSpatialMap functions. Defaults to the default equality comparer for Point, which uses a fairly efficient generalized hashing algorithm. |
| Int32 | initialCapacity | The initial maximum number of elements the AdvancedMultiSpatialMap can hold before it has to internally resize data structures. Defaults to 32. |
AutoSyncAdvancedMultiSpatialMap(IEqualityComparer<T>, IEqualityComparer<Point>, Int32)
Constructor.
Declaration
public AutoSyncAdvancedMultiSpatialMap(IEqualityComparer<T> itemComparer, IEqualityComparer<Point> pointComparer = null, int initialCapacity = 32)
Parameters
| Type | Name | Description |
|---|---|---|
| IEqualityComparer<T> | itemComparer | Equality comparer to use for comparison and hashing of type T. Be especially mindful of the efficiency of its GetHashCode function, as it will determine the efficiency of many AdvancedMultiSpatialMap functions. |
| IEqualityComparer<Point> | pointComparer | Equality comparer to use for comparison and hashing of points, as object are added to/removed from/moved around the spatial map. Be especially mindful of the efficiency of its GetHashCode function, as it will determine the efficiency of many AdvancedMultiSpatialMap functions. Defaults to the default equality comparer for Point, which uses a fairly efficient generalized hashing algorithm. |
| Int32 | initialCapacity | The initial maximum number of elements the AdvancedMultiSpatialMap can hold before it has to internally resize data structures. Defaults to 32. |
Properties
Count
The number of items in the spatial map.
Declaration
public int Count { get; }
Property Value
| Type | Description |
|---|---|
| Int32 |
Items
Enumerable of the items stored in the spatial map: for use to iterate over all items with a foreach loop.
Declaration
public IEnumerable<T> Items { get; }
Property Value
| Type | Description |
|---|---|
| IEnumerable<T> |
Positions
Enumerable of all positions that contain items.
Declaration
public IEnumerable<Point> Positions { get; }
Property Value
| Type | Description |
|---|---|
| IEnumerable<Point> |
Methods
Add(T)
Adds the given item at its position, provided the item is not already in the spatial map. If the item is already added, throws ArgumentException.
Declaration
public void Add(T item)
Parameters
| Type | Name | Description |
|---|---|---|
| T | item | The item to add. |
Add(T, Point)
Changes the position field of the given item to the given value, and then adds it to the spatial map, provided the item is not already in the spatial map. If the item is already added, throws ArgumentException.
Declaration
public void Add(T item, Point position)
Parameters
| Type | Name | Description |
|---|---|---|
| T | item | The item to add. |
| Point | position | The position at which to add the new item. |
Add(T, Int32, Int32)
Changes the position field of the given item to the given value, and then adds it to the spatial map, provided the item is not already in the spatial map. If the item is already added, throws ArgumentException.
Declaration
public void Add(T item, int x, int y)
Parameters
| Type | Name | Description |
|---|---|---|
| T | item | The item to add. |
| Int32 | x | x-value of the position to add item to. |
| Int32 | y | y-value of the position to add item to. |
AsReadOnly()
Returns a read-only reference to the spatial map. Convenient for "safely" exposing the spatial as a property, without allowing direct modification.
Declaration
public IReadOnlySpatialMap<T> AsReadOnly()
Returns
| Type | Description |
|---|---|
| IReadOnlySpatialMap<T> | The current spatial map, as a "read-only" reference. |
CanAdd(T)
Returns true if the given item can be added at its current position, eg. if the item is not already in the spatial map; false otherwise.
Declaration
public bool CanAdd(T newItem)
Parameters
| Type | Name | Description |
|---|---|---|
| T | newItem | Item to add. |
Returns
| Type | Description |
|---|---|
| Boolean | True if the item can be successfully added at its current position; false otherwise. |
CanAdd(T, Point)
Returns true if the given item can be added at the given position, eg. if the item is not already in the spatial map; false otherwise.
Declaration
public bool CanAdd(T newItem, Point position)
Parameters
| Type | Name | Description |
|---|---|---|
| T | newItem | Item to add. |
| Point | position | Position to add item to. |
Returns
| Type | Description |
|---|---|
| Boolean | True if the item can be successfully added at the position given; false otherwise. |
CanAdd(T, Int32, Int32)
Returns true if the given item can be added at the given position, eg. if the item is not already in the spatial map; false otherwise.
Declaration
public bool CanAdd(T newItem, int x, int y)
Parameters
| Type | Name | Description |
|---|---|---|
| T | newItem | Item to add. |
| Int32 | x | X-value of the position to add item to. |
| Int32 | y | Y-value of the position to add item to. |
Returns
| Type | Description |
|---|---|
| Boolean | True if the item can be successfully added at the position given; false otherwise. |
CanMove(T, Point)
Returns true if the given item can be moved from its current location to the specified one, eg. the item is contained within the spatial map; false otherwise.
Declaration
public bool CanMove(T item, Point target)
Parameters
| Type | Name | Description |
|---|---|---|
| T | item | Item to move. |
| Point | target | Location to move item to. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the given item can be moved to the given position; false otherwise. |
CanMove(T, Int32, Int32)
Returns true if the given item can be moved from its current location to the specified one, eg. the item is contained within the spatial map; false otherwise.
Declaration
public bool CanMove(T item, int targetX, int targetY)
Parameters
| Type | Name | Description |
|---|---|---|
| T | item | Item to move. |
| Int32 | targetX | X-value of the location to move item to. |
| Int32 | targetY | Y-value of the location to move item to. |
Returns
| Type | Description |
|---|---|
| Boolean | true if the given item can be moved to the given position; false otherwise. |
CanMoveAll(Point, Point)
Returns true if there are items at current
and all items at that position
can be moved to target
; false otherwise.
Declaration
public bool CanMoveAll(Point current, Point target)
Parameters
| Type | Name | Description |
|---|---|---|
| Point | current | Location to move items from. |
| Point | target | Location to move items to. |
Returns
| Type | Description |
|---|---|
| Boolean | true if all items at the position current can be moved to the position target; false if one or more items cannot be moved or there are no items to move. |
CanMoveAll(Int32, Int32, Int32, Int32)
Returns true if there are items at the current position specified, and all items at that position can be moved to the target position; false otherwise.
Declaration
public bool CanMoveAll(int currentX, int currentY, int targetX, int targetY)
Parameters
| Type | Name | Description |
|---|---|---|
| Int32 | currentX | X-value of the location to move items from. |
| Int32 | currentY | Y-value of the location to move items from. |
| Int32 | targetX | X-value of the location to move items to. |
| Int32 | targetY | Y-value of the location to move items to. |
Returns
| Type | Description |
|---|---|
| Boolean | true if all items at the position current can be moved to the position target; false if one or more items cannot be moved or there are no items to move. |
Clear()
Clears all items out of the spatial map.
Declaration
public void Clear()
Contains(T)
Returns whether or not the spatial map contains the given item.
Declaration
public bool Contains(T item)
Parameters
| Type | Name | Description |
|---|---|---|
| T | item | The item to check for. |
Returns
| Type | Description |
|---|---|
| Boolean | True if the given item is contained in the spatial map, false if not. |
Contains(Point)
Returns if there is an item in the spatial map at the given position or not.
Declaration
public bool Contains(Point position)
Parameters
| Type | Name | Description |
|---|---|---|
| Point | position | The position to check for. |
Returns
| Type | Description |
|---|---|
| Boolean | True if there is some item at the given position, false if not. |
Contains(Int32, Int32)
Returns if there is an item in the spatial map at the given position or not.
Declaration
public bool Contains(int x, int y)
Parameters
| Type | Name | Description |
|---|---|---|
| Int32 | x | The x-value of the position to check for. |
| Int32 | y | The y-value of the position to check for. |
Returns
| Type | Description |
|---|---|
| Boolean | True if there is some item at the given position, false if not. |
GetEnumerator()
Used by foreach loop, so that the class will give ISpatialTuple objects when used in a foreach loop. Generally should never be called explicitly.
Declaration
public IEnumerator<ItemPositionPair<T>> GetEnumerator()
Returns
| Type | Description |
|---|---|
| IEnumerator<ItemPositionPair<T>> | An enumerator for the spatial map. |
GetItemsAt(Point)
Gets the item(s) at the given position if there are any items, or returns nothing if there is nothing at that position.
Declaration
public ListEnumerator<T> GetItemsAt(Point position)
Parameters
| Type | Name | Description |
|---|---|---|
| Point | position | The position to return the item(s) for. |
Returns
| Type | Description |
|---|---|
| ListEnumerator<T> | The item(s) at the given position if there are any items, or nothing if there is nothing at that position. |
GetItemsAt(Int32, Int32)
Gets the item(s) at the given position if there are any items, or returns nothing if there is nothing at that position.
Declaration
public ListEnumerator<T> GetItemsAt(int x, int y)
Parameters
| Type | Name | Description |
|---|---|---|
| Int32 | x | The x-value of the position to return the item(s) for. |
| Int32 | y | The y-value of the position to return the item(s) for. |
Returns
| Type | Description |
|---|---|
| ListEnumerator<T> | The item(s) at the given position if there are any items, or nothing if there is nothing at that position. |
GetPositionOf(T)
Gets the position associated with the given item in the spatial map. If the item does not exist in the spatial map, throws ArgumentException.
Declaration
public Point GetPositionOf(T item)
Parameters
| Type | Name | Description |
|---|---|---|
| T | item | The item to get the position for. |
Returns
| Type | Description |
|---|---|
| Point | The position associated with the given item. |
GetPositionOfOrNull(T)
Gets the position associated with the given item in the spatial map, or null if that item is not found.
Declaration
public Nullable<Point> GetPositionOfOrNull(T item)
Parameters
| Type | Name | Description |
|---|---|---|
| T | item | The item to get the position for. |
Returns
| Type | Description |
|---|---|
| Nullable<Point> | The position associated with the given item, if it exists in the spatial map, or null if the item does not exist. |
Move(T, Point)
Moves the item specified to the position specified, updating its Position field accordingly. If the item does not exist in the spatial map, the function throws ArgumentException.
Declaration
public void Move(T item, Point target)
Parameters
| Type | Name | Description |
|---|---|---|
| T | item | The item to move. |
| Point | target | The position to move it to. |
Move(T, Int32, Int32)
Moves the item specified to the position specified, updating its Position field accordingly. If the item does not exist in the spatial map or is already at the target position, the function throws ArgumentException.
Declaration
public void Move(T item, int targetX, int targetY)
Parameters
| Type | Name | Description |
|---|---|---|
| T | item | The item to move. |
| Int32 | targetX | X-value of the location to move it to. |
| Int32 | targetY | Y-value of the location to move it to. |
MoveAll(Point, Point)
Moves all items at the specified source location to the target location, updating their Position fields accordingly. Throws ArgumentException if there are no items to be moved.
Declaration
public void MoveAll(Point current, Point target)
Parameters
| Type | Name | Description |
|---|---|---|
| Point | current | Location to move items from. |
| Point | target | Location to move items to. |
MoveAll(Int32, Int32, Int32, Int32)
Moves all items at the specified source location to the target location, updating their Position fields accordingly. Throws ArgumentException if there are no items to be moved.
Declaration
public void MoveAll(int currentX, int currentY, int targetX, int targetY)
Parameters
| Type | Name | Description |
|---|---|---|
| Int32 | currentX | X-value of the location to move items from. |
| Int32 | currentY | Y-value of the location to move items from. |
| Int32 | targetX | X-value of the location to move items to. |
| Int32 | targetY | Y-value of the location to move items to. |
MoveValid(Point, Point)
Moves all items at the specified source location that can be moved to the target location. Returns all items that were moved.
Declaration
public List<T> MoveValid(Point current, Point target)
Parameters
| Type | Name | Description |
|---|---|---|
| Point | current | Location to move items from. |
| Point | target | Location to move items to. |
Returns
| Type | Description |
|---|---|
| List<T> | All items that were moved, or an empty list if no items were moved. |
MoveValid(Point, Point, List<T>)
Moves all items at the specified source location that can be moved to the target location. Adds all items that were moved to the given list.
Declaration
public void MoveValid(Point current, Point target, List<T> itemsMovedOutput)
Parameters
| Type | Name | Description |
|---|---|---|
| Point | current | Location to move items from. |
| Point | target | Location to move items to. |
| List<T> | itemsMovedOutput | A list to which all items successfully moved are added. |
MoveValid(Int32, Int32, Int32, Int32)
Moves all items at the specified location that can be moved to the target one. Returns all items that were moved.
Declaration
public List<T> MoveValid(int currentX, int currentY, int targetX, int targetY)
Parameters
| Type | Name | Description |
|---|---|---|
| Int32 | currentX | X-value of the location to move items from. |
| Int32 | currentY | Y-value of the location to move items from. |
| Int32 | targetX | X-value of the location to move items to. |
| Int32 | targetY | Y-value of the location to move items to. |
Returns
| Type | Description |
|---|---|
| List<T> | All items that were moved, or nothing if no items were moved. |
MoveValid(Int32, Int32, Int32, Int32, List<T>)
Moves all items at the specified source location that can be moved to the target location. Adds all items that were moved to the given list.
Declaration
public void MoveValid(int currentX, int currentY, int targetX, int targetY, List<T> itemsMovedOutput)
Parameters
| Type | Name | Description |
|---|---|---|
| Int32 | currentX | X-value of the location to move items from. |
| Int32 | currentY | Y-value of the location to move items from. |
| Int32 | targetX | X-value of the location to move items to. |
| Int32 | targetY | Y-value of the location to move items to. |
| List<T> | itemsMovedOutput | A list to which all items successfully moved are added. |
Remove(T)
Removes the item specified, if it exists. Throws ArgumentException if the item is not in the spatial map.
Declaration
public void Remove(T item)
Parameters
| Type | Name | Description |
|---|---|---|
| T | item | The item to remove. |
Remove(Point)
Removes all items at the specified location from the spatial map. Returns all items that were removed.
Declaration
public List<T> Remove(Point position)
Parameters
| Type | Name | Description |
|---|---|---|
| Point | position | Position to remove items from. |
Returns
| Type | Description |
|---|---|
| List<T> | All items that were removed, or an empty list if no items were removed. |
Remove(Int32, Int32)
Removes all items at the specified location from the spatial map. Returns all items that were removed.
Declaration
public List<T> Remove(int x, int y)
Parameters
| Type | Name | Description |
|---|---|---|
| Int32 | x | X-value of the position to remove items from. |
| Int32 | y | Y-value of the position to remove items from. |
Returns
| Type | Description |
|---|---|
| List<T> | All items that were removed, or nothing if no items were removed. |
ToString()
Returns a string representation of the spatial map.
Declaration
public override string ToString()
Returns
| Type | Description |
|---|---|
| String | A string representation of the spatial map. |
ToString(Func<T, String>)
Returns a string representation of the spatial map, allowing display of the spatial map's items in a specified way.
Declaration
public string ToString(Func<T, string> itemStringifier)
Parameters
| Type | Name | Description |
|---|---|---|
| Func<T, String> | itemStringifier | Function that turns an item into a string. |
Returns
| Type | Description |
|---|---|
| String | A string representation of the spatial map. |
TryAdd(T)
Adds the given item at its position, provided the item is not already in the spatial map. If the item is already added, returns false.
Declaration
public bool TryAdd(T item)
Parameters
| Type | Name | Description |
|---|---|---|
| T | item | The item to add. |
Returns
| Type | Description |
|---|---|
| Boolean | True if the item was successfully added; false otherwise. |
TryAdd(T, Point)
Changes the position field of the given item to the given value, and then adds it to the spatial map, provided the item is not already in the spatial map. If the item is already added, nothing is changed and the function returns false.
Declaration
public bool TryAdd(T item, Point position)
Parameters
| Type | Name | Description |
|---|---|---|
| T | item | The item to add. |
| Point | position | The position at which to add the new item. |
Returns
| Type | Description |
|---|---|
| Boolean | True if the item was successfully added; false otherwise. |
TryAdd(T, Int32, Int32)
Changes the position field of the given item to the given value, and then adds it to the spatial map, provided the item is not already in the spatial map. If the item is already added, nothing is changed and the function returns false.
Declaration
public bool TryAdd(T item, int x, int y)
Parameters
| Type | Name | Description |
|---|---|---|
| T | item | The item to add. |
| Int32 | x | x-value of the position to add item to. Must match the item's Position field. |
| Int32 | y | y-value of the position to add item to. Must match the item's Position field. |
Returns
| Type | Description |
|---|---|
| Boolean | True if the item was successfully added; false otherwise. |
TryGetPositionOf(T, out Point)
Attempts to get the position of the given item in the spatial map. If successful, the function will return
true and the position will be stored in the position
parameter. If the item was not found,
position
will have the default value for Point, and the function will return false.
Declaration
public bool TryGetPositionOf(T item, out Point position)
Parameters
| Type | Name | Description |
|---|---|---|
| T | item | Item to retrieve the position of. |
| Point | position | The position of the item if found, or default(Point) if not. |
Returns
| Type | Description |
|---|---|
| Boolean | True if the item was found in the spatial map, false otherwise. |
TryMove(T, Point)
Attempts to move the given item from its current location to the specified one. Does nothing and returns false if the item cannot be moved to the given location.
Declaration
public bool TryMove(T item, Point target)
Parameters
| Type | Name | Description |
|---|---|---|
| T | item | Item to move. |
| Point | target | Location to move item to. |
Returns
| Type | Description |
|---|---|
| Boolean | True if the item was moved; false if not. |
TryMove(T, Int32, Int32)
Attempts to move the given item from its current location to the specified one. Does nothing and returns false if the item cannot be moved to the given location.
Declaration
public bool TryMove(T item, int targetX, int targetY)
Parameters
| Type | Name | Description |
|---|---|---|
| T | item | Item to move. |
| Int32 | targetX | X-value of the location to move item to. |
| Int32 | targetY | Y-value of the location to move item to. |
Returns
| Type | Description |
|---|---|
| Boolean | True if the item was moved; false if not. |
TryMoveAll(Point, Point)
Moves all items at the specified source location to the target location. Returns false if one or more items cannot be moved or there are no items to be moved.
Declaration
public bool TryMoveAll(Point current, Point target)
Parameters
| Type | Name | Description |
|---|---|---|
| Point | current | Location to move items from. |
| Point | target | Location to move items to. |
Returns
| Type | Description |
|---|---|
| Boolean | True if all items at |
TryMoveAll(Int32, Int32, Int32, Int32)
Moves all items at the specified source location to the target location. Returns false if one or more items cannot be moved or there are no items to be moved.
Declaration
public bool TryMoveAll(int currentX, int currentY, int targetX, int targetY)
Parameters
| Type | Name | Description |
|---|---|---|
| Int32 | currentX | X-value of the location to move items from. |
| Int32 | currentY | Y-value of the location to move items from. |
| Int32 | targetX | X-value of the location to move items to. |
| Int32 | targetY | Y-value of the location to move items to. |
Returns
| Type | Description |
|---|---|
| Boolean | True if all items at (currentX, currentY) were moved to (targetX, targetY); false otherwise. |
TryRemove(T)
Removes the item specified, if it exists. If the item is not in the spatial map, returns false.
Declaration
public bool TryRemove(T item)
Parameters
| Type | Name | Description |
|---|---|---|
| T | item | The item to remove. |
Returns
| Type | Description |
|---|---|
| Boolean | True if the item was successfully removed; false otherwise. |
TryRemove(Point)
Attempts to remove all items at the specified location from the spatial map. Returns true if the items were successfully removed; false if one or more failed.
Declaration
public bool TryRemove(Point position)
Parameters
| Type | Name | Description |
|---|---|---|
| Point | position | Position to remove items from. |
Returns
| Type | Description |
|---|---|
| Boolean | True if the items were successfully removed; false otherwise |
TryRemove(Int32, Int32)
Attempts to remove all items at the specified location from the spatial map. Returns true if the items were successfully removed; false if one or more failed.
Declaration
public bool TryRemove(int x, int y)
Parameters
| Type | Name | Description |
|---|---|---|
| Int32 | x | X-value of the position to remove items from. |
| Int32 | y | Y-value of the position to remove items from. |
Returns
| Type | Description |
|---|---|
| Boolean | True if the items were successfully removed; false otherwise |
Events
ItemAdded
Event that is fired directly after an item has been added to the spatial map.
Declaration
public event EventHandler<ItemEventArgs<T>> ItemAdded
Event Type
| Type | Description |
|---|---|
| EventHandler<ItemEventArgs<T>> |
ItemMoved
Event that is fired directly after an item in the spatial map has been moved.
Declaration
public event EventHandler<ItemMovedEventArgs<T>> ItemMoved
Event Type
| Type | Description |
|---|---|
| EventHandler<ItemMovedEventArgs<T>> |
ItemRemoved
Event that is fired directly after an item has been removed from the spatial map.
Declaration
public event EventHandler<ItemEventArgs<T>> ItemRemoved
Event Type
| Type | Description |
|---|---|
| EventHandler<ItemEventArgs<T>> |
Explicit Interface Implementations
IReadOnlySpatialMap<T>.GetItemsAt(Point)
Declaration
IEnumerable<T> IReadOnlySpatialMap<T>.GetItemsAt(Point position)
Parameters
| Type | Name | Description |
|---|---|---|
| Point | position |
Returns
| Type | Description |
|---|---|
| IEnumerable<T> |
IReadOnlySpatialMap<T>.GetItemsAt(Int32, Int32)
Declaration
IEnumerable<T> IReadOnlySpatialMap<T>.GetItemsAt(int x, int y)
Parameters
| Type | Name | Description |
|---|---|---|
| Int32 | x | |
| Int32 | y |
Returns
| Type | Description |
|---|---|
| IEnumerable<T> |


Alexander Blinn |
Taylor Toxin |
Alexandra Spicebush |
Taylor Toxin |
Hannah Sleep |
Ella Grievous |
Sofia Doleful |
Alexandra Spicebush |
William Grantee |
William Grantee |
Eli Jayden Olivine |
Henry Betide |
Andrew Domingo |
Andrew Domingo |
Brody Fairport |
Hannah Sleep |
Zachary Obviate |
Alexandra Spicebush |


{{- $data := getJSON $.Site.Params.sales -}}
The Vanilla JS Academy has helped over {{ index $data "message" }} people learn to solve problems and think in JavaScript.


User stories:
I can pass a URL as a parameter and I will receive a shortened URL in the JSON response.
When I visit that shortened URL, it will redirect me to my original link.
https://little-url.herokuapp.com/new/https://www.google.com
https://little-url.herokuapp.com/new/http://foo.com:80
{ "original_url":"http://foo.com:80", "short_url":"https://little-url.herokuapp.com/8170" }
https://little-url.herokuapp.com/2871
https://www.google.com/


Home
Uploads
{{elem.user}}
Like
{{elem.likes}} Likes
Comments
{{elem.comments.length}} Comments
{{comm.user}}
{{comm.comm}}
Username:
Photo:
Comments
{{comm.comm}}


Meshblu is a secure cross-protocol, machine-to-machine instant messaging platform with an open plugin architecture for connectors
Secure cross-protocol messaging platform with APIs supporting HTTP, WebSockets, MQTT, CoAP, AMQP, and XMPP.
Javascript-based open plugin architecture for connecting and communicating with any IoT device i.e. Phillips Hue, Nest, Wemo, etc.
Realtime sensor and message event streaming to any datastore in any network i.e. Splunk, Mongo, Hadoop, etc.
Javascript-based open plugin architecture for connecting and communicating with any REST API or SaaS service i.e. Slack, Twitter, Netscaler, etc.
Twitter is designed for human communications. Meshblu is designed for machine communications. Like Twitter, Meshblu allows machines to "follow" or subscribe to other machines messages. Machines can "tweet" or broadcast messages to any other machine subscribed to its events. Machines can "direct message" or private message one or more other machines.
Like Twitter, Meshblu has a messaging firehose. With the proper permissions, machines can "spy" on other machines or groups of machines and receive all events and messages related to a machine or group of machines. Meshblu firehose data can stream directly into private datastores such as Splunk, Mongo, or even Hadoop.
Unlike Twitter, Meshblu's communications between machines are encrypted with private/public keys. Meshblu also institudes a set of whitelists and blacklists to determine which other machines are allowed (or not allowed) to discover, message, subscribe, and configure each machine. In addition to HTTP protocol traffic, Meshblu has APIs for communicating with other IoT protocols including: WebSockets, MQTT, CoAP, AMQP, and XMPP. Machines speaking any of these protocols can communicate to any other machine connected to Meshblu regardless of protocol.
Meshblu has a built-in device directory. Each machine, smart device, and REST API service is represented as a unique UUID in our device directory. Each UUID in the device directory is basically a JSON document store allowing you to get and set properties, permissions, and even data associated with the UUID.
The current state of each machine or device can also be stored in the device directory. This allows you to tell a device that it should be green rather than sending it a message to turn green. Regardless if the message is received or missed, the smart device turns green as soon as the state is update and/or the device has Internet connectivity to read its state.
Meshblu supports an open plugin architecture for connecting smart IoT devices and REST APIs / SaaS services to its messaging engine. Once connected to Meshblu, our JSON Rules Engine can be used to automate events and messages based on state or messages received from these devices and services. Our connectors are typically written in Javascript.
Device Connectors REST Connectors
Here are a few examples on getting started with Meshblu.


我對於資訊科技與影像傳播相當有興趣，喜歡看網路影片及探索其拍攝方式
I am very interested in information technology and video communication. I like watching online movies and exploring how to shoot them.
在課餘時間，我喜歡上網觀看許多Youtube創作者和與音樂相關的MV影片，探索其拍攝內容，並學習如何剪輯及拍攝方法。平時也會騎著車到處晃晃，享受在道路、山路上騎乘的感受，同時利用相片與影片記錄平時騎車的日常。
In my spare time, I like watching Youtube creators videos and music-related MV videos online, exploring their shooting content, and learning how to edit and shoot. Usually, I will ride around the city and enjoy the feeling of riding on the roads. At the same time, I use photos and videos to record the daily life of cycling.


Issue 46
Welcome to Haskell Weekly! Haskell is an advanced, purely functional programming language. This is a weekly summary of what’s going on in its community. You can subscribe to the email newsletter or the Atom feed.
Want to contribute to Haskell Weekly? Send us a message on Twitter or open an issue on GitHub.
News from the Haskell community
-
A new command,
script
, has been added, intended to make the script interpreter workflow more reliable, easier to use, and more efficient. -
Programmers usually learn “Haskell as a second language” and try to connect its concepts to things they understand from past experience. Java programmers ask whether Haskell’s typeclasses are like Java’s interfaces. This is okay for initial intuition, but it obscures some important differences.
-
A read-eval-print-loop is an interactive shell that repeatedly takes input from the user, evaluates it, and prints out the result. We often see such REPLs come bundled along with programming language toolkits, providing an interactive environment for that language. In this article, we will look at how we can create our very own REPL in Haskell.
-
Partial patterns in do blocks: let vs return
We’ve introduced partiality into our function! Instead of being well behaved and returning a
Nothing
, our program now creates an impure exception that blows up in our face, definitely not what we wanted with a simple refactoring. The problem here is that, when usinglet
, an incomplete pattern match turns into a partial value. -
When you should use lists in Haskell (Mostly, you should not)
One goal of language design is to make typical expected usage easy to write. Once the design is cast in stone, this becomes self-fulfilling: unsuspecting users of the language will write programs in what they think is idiomatic style, as suggested by built-in syntactical convenience. So it seems that it is typical Haskell to: not declare types for identifiers, and use machine numbers and lists all over the place.
-
Every Haskell package has a Cabal file, which contains metadata about the package. Have you ever wondered what a minimal Cabal file looks like? In other words, what is the minimum amount of data you absolutely need to include in a Cabal file so that it yields a fully functional Haskell package?
-
Haskell performance benchmarks
I think we’re missing a general “standard data structures performance” source of data. The “When You Should Use Lists” discussion had a striking lack of citations of actual benchmarks. I think there should be a place people can reference when they decide on a data structure.
-
Designing the Backpack signature ecosystem
Suppose you are a library writer interested in using Backpack. Backpack says that you can replace a direct dependency on a function, type or package with one or more signatures. You typecheck against a signature and your end user picks how they want to eventually implement the signature.
-
Linear types make performance more predictable
Ever since Jean-Yves Girard discovered linear logic in 1986, researchers around the world have been going: “Wow! Resource tracking; this must be useful for programming languages”. After all, any real computation on a real machine takes resources (memory pages, disk blocks, interrupts, buffers etc) that then aren’t available anymore unless restored somehow.
-
A San Francisco Bay Area and Silicon Valley Haskell Hackathon. Come join a group of Haskell hackers to enjoy a weekend of learning, sharing, and hacking on a variety of projects. Bring your laptop! All skill levels are welcome.
Package of the week
This week’s package of the week is hpack, an alternative format for Haskell packages.
Send us a message on Twitter to nominate next week’s package!