Remoting
For an introduction of remoting capabilities of Akka please see Location Transparency.
Preparing your ActorSystem for Remoting
The Akka remoting is a separate jar file. Make sure that you have the following dependency in your project:
"com.typesafe.akka" %% "akka-remote" % "2.2.3"
To enable remote capabilities in your Akka project you should, at a minimum, add the following changes to your application.conf file:
akka {
actor {
provider = "akka.remote.RemoteActorRefProvider"
}
remote {
enabled-transports = ["akka.remote.netty.tcp"]
netty.tcp {
hostname = "<IP_ADDRESS>"
port = 2552
}
}
}
As you can see in the example above there are four things you need to add to get started:
- Change provider from akka.actor.LocalActorRefProvider to akka.remote.RemoteActorRefProvider
- Add host name - the machine you want to run the actor system on; this host name is exactly what is passed to remote systems in order to identify this system and consequently used for connecting back to this system if need be, hence set it to a reachable IP address or resolvable name in case you want to communicate across the network.
- Add port number - the port the actor system should listen on, set to 0 to have it chosen automatically
Note
The port number needs to be unique for each actor system on the same machine even if the actor systems have different names. This is because each actor system has its own networking subsystem listening for connections and handling messages as not to interfere with other actor systems.
The example above only illustrates the bare minimum of properties you have to add to enable remoting. All settings are described in Remote Configuration.
Types of Remote Interaction
Akka has two ways of using remoting:
- Lookup : used to look up an actor on a remote node with actorSelection(path)
- Creation : used to create an actor on a remote node with actorOf(Props(...), actorName)
In the next sections the two alternatives are described in detail.
Looking up Remote Actors
actorSelection(path) will obtain an ActorSelection to an Actor on a remote node, e.g.:
val selection =
context.actorSelection("akka.tcp://actorSystemName@<IP_ADDRESS>:2552/user/actorName")
As you can see from the example above the following pattern is used to find an actor on a remote node:
akka.<protocol>://<actor system>@<hostname>:<port>/<actor path>
Once you obtained a selection to the actor you can interact with it they same way you would with a local actor, e.g.:
selection ! "Pretty awesome feature"
To acquire an ActorRef for an ActorSelection you need to send a message to the selection and use the sender reference of the reply from the actor. There is a built-in Identify message that all Actors will understand and automatically reply to with a ActorIdentity message containing the ActorRef. This can also be done with the resolveOne method of the ActorSelection, which returns a Future of the matching ActorRef.
Note
For more details on how actor addresses and paths are formed and used, please refer to Actor References, Paths and Addresses.
Creating Actors Remotely
If you want to use the creation functionality in Akka remoting you have to further amend the application.conf file in the following way (only showing deployment section):
akka {
actor {
deployment {
/sampleActor {
remote = "akka.tcp://sampleActorSystem@<IP_ADDRESS>:2553"
}
}
}
}
The configuration above instructs Akka to react when an actor with path /sampleActor is created, i.e. using system.actorOf(Props(...), "sampleActor"). This specific actor will not be directly instantiated, but instead the remote daemon of the remote system will be asked to create the actor, which in this sample corresponds to sampleActorSystem@<IP_ADDRESS>:2553.
Once you have configured the properties above you would do the following in code:
val actor = system.actorOf(Props[SampleActor], "sampleActor")
actor ! "Pretty slick"
The actor class SampleActor has to be available to the runtimes using it, i.e. the classloader of the actor systems has to have a JAR containing the class.
Note
In order to ensure serializability of Props when passing constructor arguments to the actor being created, do not make the factory an inner class: this will inherently capture a reference to its enclosing object, which in most cases is not serializable. It is best to create a factory method in the companion object of the actor’s class.
Serializability of all Props can be tested by setting the configuration item akka.actor.serialize-creators=on. Only Props whose deploy has LocalScope are exempt from this check.
Note
You can use asterisks as wildcard matches for the actor paths, so you could specify: /*/sampleActor and that would match all sampleActor on that level in the hierarchy. You can also use wildcard in the last position to match all actors at a certain level: /someParent/*. Non-wildcard matches always have higher priority to match than wildcards, so: /foo/bar is considered more specific than /foo/* and only the highest priority match is used. Please note that it cannot be used to partially match section, like this: /foo*/bar, /f*o/bar etc.
Programmatic Remote Deployment
To allow dynamically deployed systems, it is also possible to include deployment configuration in the Props which are used to create an actor: this information is the equivalent of a deployment section from the configuration file, and if both are given, the external configuration takes precedence.
With these imports:
import akka.actor.{ Props, Deploy, Address, AddressFromURIString }
import akka.remote.RemoteScope
and a remote address like this:
val one = AddressFromURIString("akka.tcp://sys@host:1234")
val two = Address("akka.tcp", "sys", "host", 1234) // this gives the same
you can advise the system to create a child on that remote node like so:
val ref = system.actorOf(Props[SampleActor].
withDeploy(Deploy(scope = RemoteScope(address))))
Watching Remote Actors
Watching a remote actor is not different than watching a local actor, as described in Lifecycle Monitoring aka DeathWatch.
Warning
Caveat: Watching an ActorRef acquired with actorFor does not trigger Terminated for lost connections. actorFor is deprecated in favor of actorSelection. Acquire the ActorRef to watch with Identify and ActorIdentity as described in Identifying Actors via Actor Selection.
Failure Detector
Under the hood remote death watch uses heartbeat messages and a failure detector to generate Terminated message from network failures and JVM crashes, in addition to graceful termination of watched actor.
The heartbeat arrival times is interpreted by an implementation of The Phi Accrual Failure Detector.
The suspicion level of failure is given by a value called phi. The basic idea of the phi failure detector is to express the value of phi on a scale that is dynamically adjusted to reflect current network conditions.
The value of phi is calculated as:
phi = -log10(1 - F(timeSinceLastHeartbeat))
where F is the cumulative distribution function of a normal distribution with mean and standard deviation estimated from historical heartbeat inter-arrival times.
In the Remote Configuration you can adjust the akka.remote.watch-failure-detector.threshold to define when a phi value is considered to be a failure.
A low threshold is prone to generate many false positives but ensures a quick detection in the event of a real crash. Conversely, a high threshold generates fewer mistakes but needs more time to detect actual crashes. The default threshold is 10 and is appropriate for most situations. However in cloud environments, such as Amazon EC2, the value could be increased to 12 in order to account for network issues that sometimes occur on such platforms.
The following chart illustrates how phi increase with increasing time since the previous heartbeat.
Phi is calculated from the mean and standard deviation of historical inter arrival times. The previous chart is an example for standard deviation of 200 ms. If the heartbeats arrive with less deviation the curve becomes steeper, i.e. it is possible to determine failure more quickly. The curve looks like this for a standard deviation of 100 ms.
To be able to survive sudden abnormalities, such as garbage collection pauses and transient network failures the failure detector is configured with a margin, akka.remote.watch-failure-detector.acceptable-heartbeat-pause. You may want to adjust the Remote Configuration of this depending on you environment. This is how the curve looks like for acceptable-heartbeat-pause configured to 3 seconds.
Serialization
When using remoting for actors you must ensure that the props and messages used for those actors are serializable. Failing to do so will cause the system to behave in an unintended way.
For more information please see Serialization
Routers with Remote Destinations
It is absolutely feasible to combine remoting with Routing. This is also done via configuration:
akka {
actor {
deployment {
/serviceA/aggregation {
router = "round-robin"
nr-of-instances = 10
target {
nodes = ["akka.tcp://app@<IP_ADDRESS>:2552", "akka.tcp://app@<IP_ADDRESS>:2552"]
}
}
}
}
}
This configuration setting will clone the actor “aggregation” 10 times and deploy it evenly distributed across the two given target nodes.
Description of the Remoting Sample
There is a more extensive remote example that comes with the Akka distribution. Please have a look here for more information: Remote Sample This sample demonstrates both, remote deployment and look-up of remote actors. First, let us have a look at the common setup for both scenarios (this is common.conf):
akka {
actor {
provider = "akka.remote.RemoteActorRefProvider"
}
remote {
netty.tcp {
hostname = "<IP_ADDRESS>"
}
}
# Uncomment the following four lines to employ the 'secure cookie handshake'
# This requires the client to have the known secure-cookie and properly
# transmit it to the server upon connection. Because both the client and server
# programs use this common.conf file, they will both have the cookie
#remote {
# secure-cookie = "0009090D040C030E03070D0509020F050B080400"
# require-cookie = on
#}
}
This enables the remoting by installing the RemoteActorRefProvider and chooses the default remote transport. All other options will be set specifically for each show case.
Note
Be sure to replace the default IP <IP_ADDRESS> with the real address the system is reachable by if you deploy onto multiple machines!
Remote Lookup
In order to look up a remote actor, that one must be created first. For this purpose, we configure an actor system to listen on port 2552 (this is a snippet from application.conf):
calculator {
include "common"
akka {
# LISTEN on tcp port 2552
remote.netty.tcp.port = 2552
}
}
Then the actor must be created. For all code which follows, assume these imports:
class LookupApplication extends Bootable {
val system =
ActorSystem("LookupApplication", ConfigFactory.load.getConfig("remotelookup"))
val remotePath =
"akka.tcp://CalculatorApplication@<IP_ADDRESS>:2552/user/simpleCalculator"
val actor = system.actorOf(Props(classOf[LookupActor], remotePath), "lookupActor")
def doSomething(op: MathOp): Unit =
actor ! op
def startup() {
}
def shutdown() {
system.shutdown()
}
}
class LookupActor(path: String) extends Actor {
context.setReceiveTimeout(3.seconds)
sendIdentifyRequest()
def sendIdentifyRequest(): Unit =
context.actorSelection(path) ! Identify(path)
def receive = {
case ActorIdentity(`path`, Some(actor)) ⇒
context.setReceiveTimeout(Duration.Undefined)
context.become(active(actor))
case ActorIdentity(`path`, None) ⇒ println(s"Remote actor not availible: $path")
case ReceiveTimeout ⇒ sendIdentifyRequest()
case _ ⇒ println("Not ready yet")
}
def active(actor: ActorRef): Actor.Receive = {
case op: MathOp ⇒ actor ! op
case result: MathResult ⇒ result match {
case AddResult(n1, n2, r) ⇒
printf("Add result: %d + %d = %d\n", n1, n2, r)
case SubtractResult(n1, n2, r) ⇒
printf("Sub result: %d - %d = %d\n", n1, n2, r)
}
}
}
object LookupApp {
def main(args: Array[String]) {
val app = new LookupApplication
println("Started Lookup Application")
while (true) {
if (Random.nextInt(100) % 2 == 0)
app.doSomething(Add(Random.nextInt(100), Random.nextInt(100)))
else
app.doSomething(Subtract(Random.nextInt(100), Random.nextInt(100)))
Thread.sleep(200)
}
}
}
The actor doing the work will be this one:
class SimpleCalculatorActor extends Actor {
def receive = {
case Add(n1, n2) ⇒
println("Calculating %d + %d".format(n1, n2))
sender ! AddResult(n1, n2, n1 + n2)
case Subtract(n1, n2) ⇒
println("Calculating %d - %d".format(n1, n2))
sender ! SubtractResult(n1, n2, n1 - n2)
}
}
and we start it within an actor system using the above configuration
val system = ActorSystem("CalculatorApplication",
ConfigFactory.load.getConfig("calculator"))
val actor = system.actorOf(Props[SimpleCalculatorActor], "simpleCalculator")
With the service actor up and running, we may look it up from another actor system, which will be configured to use port 2553 (this is a snippet from application.conf).
remotelookup {
include "common"
akka {
remote.netty.tcp.port = 2553
}
}
The actor which will query the calculator is a quite simple one for demonstration purposes
class LookupActor(path: String) extends Actor {
context.setReceiveTimeout(3.seconds)
sendIdentifyRequest()
def sendIdentifyRequest(): Unit =
context.actorSelection(path) ! Identify(path)
def receive = {
case ActorIdentity(`path`, Some(actor)) ⇒
context.setReceiveTimeout(Duration.Undefined)
context.become(active(actor))
case ActorIdentity(`path`, None) ⇒ println(s"Remote actor not availible: $path")
case ReceiveTimeout ⇒ sendIdentifyRequest()
case _ ⇒ println("Not ready yet")
}
def active(actor: ActorRef): Actor.Receive = {
case op: MathOp ⇒ actor ! op
case result: MathResult ⇒ result match {
case AddResult(n1, n2, r) ⇒
printf("Add result: %d + %d = %d\n", n1, n2, r)
case SubtractResult(n1, n2, r) ⇒
printf("Sub result: %d - %d = %d\n", n1, n2, r)
}
}
}
and it is created from an actor system using the aforementioned client’s config.
val system =
ActorSystem("LookupApplication", ConfigFactory.load.getConfig("remotelookup"))
val remotePath =
"akka.tcp://CalculatorApplication@<IP_ADDRESS>:2552/user/simpleCalculator"
val actor = system.actorOf(Props(classOf[LookupActor], remotePath), "lookupActor")
def doSomething(op: MathOp): Unit =
actor ! op
Requests which come in via doSomething will be sent to the client actor, which will use the actor reference that was identified earlier. Observe how the actor system name using in actorSelection matches the remote system’s name, as do IP and port number. Top-level actors are always created below the "/user" guardian, which supervises them.
Remote Deployment
Creating remote actors instead of looking them up is not visible in the source code, only in the configuration file. This section is used in this scenario (this is a snippet from application.conf):
remotecreation {
include "common"
akka {
actor {
deployment {
/advancedCalculator {
remote = "akka.tcp://CalculatorApplication@<IP_ADDRESS>:2552"
}
}
}
remote.netty.tcp.port = 2554
}
}
For all code which follows, assume these imports:
class LookupApplication extends Bootable {
val system =
ActorSystem("LookupApplication", ConfigFactory.load.getConfig("remotelookup"))
val remotePath =
"akka.tcp://CalculatorApplication@<IP_ADDRESS>:2552/user/simpleCalculator"
val actor = system.actorOf(Props(classOf[LookupActor], remotePath), "lookupActor")
def doSomething(op: MathOp): Unit =
actor ! op
def startup() {
}
def shutdown() {
system.shutdown()
}
}
class LookupActor(path: String) extends Actor {
context.setReceiveTimeout(3.seconds)
sendIdentifyRequest()
def sendIdentifyRequest(): Unit =
context.actorSelection(path) ! Identify(path)
def receive = {
case ActorIdentity(`path`, Some(actor)) ⇒
context.setReceiveTimeout(Duration.Undefined)
context.become(active(actor))
case ActorIdentity(`path`, None) ⇒ println(s"Remote actor not availible: $path")
case ReceiveTimeout ⇒ sendIdentifyRequest()
case _ ⇒ println("Not ready yet")
}
def active(actor: ActorRef): Actor.Receive = {
case op: MathOp ⇒ actor ! op
case result: MathResult ⇒ result match {
case AddResult(n1, n2, r) ⇒
printf("Add result: %d + %d = %d\n", n1, n2, r)
case SubtractResult(n1, n2, r) ⇒
printf("Sub result: %d - %d = %d\n", n1, n2, r)
}
}
}
object LookupApp {
def main(args: Array[String]) {
val app = new LookupApplication
println("Started Lookup Application")
while (true) {
if (Random.nextInt(100) % 2 == 0)
app.doSomething(Add(Random.nextInt(100), Random.nextInt(100)))
else
app.doSomething(Subtract(Random.nextInt(100), Random.nextInt(100)))
Thread.sleep(200)
}
}
}
The client actor looks like in the previous example
class CreationActor(remoteActor: ActorRef) extends Actor {
def receive = {
case op: MathOp ⇒ remoteActor ! op
case result: MathResult ⇒ result match {
case MultiplicationResult(n1, n2, r) ⇒
printf("Mul result: %d * %d = %d\n", n1, n2, r)
case DivisionResult(n1, n2, r) ⇒
printf("Div result: %.0f / %d = %.2f\n", n1, n2, r)
}
}
}
but the setup uses only actorOf:
val system =
ActorSystem("RemoteCreation", ConfigFactory.load.getConfig("remotecreation"))
val remoteActor = system.actorOf(Props[AdvancedCalculatorActor],
name = "advancedCalculator")
val localActor = system.actorOf(Props(classOf[CreationActor], remoteActor),
name = "creationActor")
def doSomething(op: MathOp): Unit =
localActor ! op
Observe how the name of the server actor matches the deployment given in the configuration file, which will transparently delegate the actor creation to the remote node.
Pluggable transport support
Akka can be configured to use various transports to communicate with remote systems. The core component of this feature is the akka.remote.Transport SPI. Transport implementations must extend this trait. Transports can be loaded by setting the akka.remote.enabled-transports configuration key to point to one or more configuration sections containing driver descriptions.
An example of setting up the default Netty based SSL driver as default:
akka {
remote {
enabled-transports = [akka.remote.netty.ssl]
netty.ssl.security {
key-store = "mykeystore"
trust-store = "mytruststore"
key-store-password = "changeme"
key-password = "changeme"
trust-store-password = "changeme"
protocol = "TLSv1"
random-number-generator = "AES128CounterSecureRNG"
enabled-algorithms = [TLS_RSA_WITH_AES_128_CBC_SHA]
}
}
}
An example of setting up a custom transport implementation:
akka {
remote {
applied-transports = ["akka.remote.mytransport"]
mytransport {
# The transport-class configuration entry is required, and
# it must contain the fully qualified name of the transport
# implementation
transport-class = "my.package.MyTransport"
# It is possible to decorate Transports with additional services.
# Adapters should be registered in the "adapters" sections to
# be able to apply them to transports
applied-adapters = []
# Driver specific configuration options has to be in the same
# section:
some-config = foo
another-config = bar
}
Remote Events
It is possible to listen to events that occur in Akka Remote, and to subscribe/unsubscribe to these events you simply register as listener to the below described types in on the ActorSystem.eventStream.
Note
To subscribe to any remote event, subscribe to RemotingLifecycleEvent. To subscribe to events related only to the lifecycle of associations, subscribe to akka.remote.AssociationEvent.
Note
The use of term "Association" instead of "Connection" reflects that the remoting subsystem may use connectionless transports, but an association similar to transport layer connections is maintained between endpoints by the Akka protocol.
By default an event listener is registered which logs all of the events described below. This default was chosen to help setting up a system, but it is quite common to switch this logging off once that phase of the project is finished.
Note
In order to switch off the logging, set akka.remote.log-remote-lifecycle-events = off in your application.conf.
To be notified when an association is over ("disconnected") listen to DisassociatedEvent which holds the direction of the association (inbound or outbound) and the addresses of the involved parties.
To be notified when an association is successfully established ("connected") listen to AssociatedEvent which holds the direction of the association (inbound or outbound) and the addresses of the involved parties.
To intercept errors directly related to associations, listen to AssociationErrorEvent which holds the direction of the association (inbound or outbound), the addresses of the involved parties and the Throwable cause.
To be notified when the remoting subsystem is ready to accept associations, listen to RemotingListenEvent which contains the addresses the remoting listens on.
To be notified when the remoting subsystem has been shut down, listen to RemotingShutdownEvent.
To intercept generic remoting related errors, listen to RemotingErrorEvent which holds the Throwable cause.
Remote Security
Akka provides a couple of ways to enhance security between remote nodes (client/server):
- Untrusted Mode
- Security Cookie Handshake
Untrusted Mode
As soon as an actor system can connect to another remotely, it may in principle send any possible message to any actor contained within that remote system. One example may be sending a PoisonPill to the system guardian, shutting that system down. This is not always desired, and it can be disabled with the following setting:
akka.remote.untrusted-mode = on
This disallows sending of system messages (actor life-cycle commands, DeathWatch, etc.) and any message extending PossiblyHarmful to the system on which this flag is set. Should a client send them nonetheless they are dropped and logged (at DEBUG level in order to reduce the possibilities for a denial of service attack). PossiblyHarmful covers the predefined messages like PoisonPill and Kill, but it can also be added as a marker trait to user-defined messages.
In summary, the following operations are ignored by a system configured in untrusted mode when incoming via the remoting layer:
- remote deployment (which also means no remote supervision)
- remote DeathWatch
- system.stop(), PoisonPill, Kill
- sending any message which extends from the PossiblyHarmful marker interface, which includes Terminated
Note
Enabling the untrusted mode does not remove the capability of the client to freely choose the target of its message sends, which means that messages not prohibited by the above rules can be sent to any actor in the remote system. It is good practice for a client-facing system to only contain a well-defined set of entry point actors, which then forward requests (possibly after performing validation) to another actor system containing the actual worker actors. If messaging between these two server-side systems is done using local ActorRef (they can be exchanged safely between actor systems within the same JVM), you can restrict the messages on this interface by marking them PossiblyHarmful so that a client cannot forge them.
Secure Cookie Handshake
Akka remoting also allows you to specify a secure cookie that will be exchanged and ensured to be identical in the connection handshake between the client and the server. If they are not identical then the client will be refused to connect to the server.
The secure cookie can be any kind of string. But the recommended approach is to generate a cryptographically secure cookie using this script $AKKA_HOME/scripts/generate_config_with_secure_cookie.sh or from code using the akka.util.Crypt.generateSecureCookie() utility method.
You have to ensure that both the connecting client and the server have the same secure cookie as well as the require-cookie option turned on.
Here is an example config:
akka.remote {
secure-cookie = "090A030E0F0A05010900000A0C0E0C0B03050D05"
require-cookie = on
}
SSL
SSL can be used as the remote transport by adding akka.remote.netty.ssl to the enabled-transport configuration section. See a description of the settings in the Remote Configuration section.
The SSL support is implemented with Java Secure Socket Extension, please consult the offical Java Secure Socket Extension documentation and related resources for troubleshooting.
Note
When using SHA1PRNG on Linux it's recommended specify -Djava.security.egd=file:/dev/./urandom as argument to the JVM to prevent blocking. It is NOT as secure because it reuses the seed. Use '/dev/./urandom', not '/dev/urandom' as that doesn't work according to Bug ID: 6202721.
Remote Configuration
There are lots of configuration properties that are related to remoting in Akka. We refer to the following reference file for more information:
#####################################
# Akka Remote Reference Config File #
#####################################
# This is the reference config file that contains all the default settings.
# Make your edits/overrides in your application.conf.
# comments about akka.actor settings left out where they are already in akka-
# actor.jar, because otherwise they would be repeated in config rendering.
akka {
actor {
serializers {
akka-containers = "akka.remote.serialization.MessageContainerSerializer"
proto = "akka.remote.serialization.ProtobufSerializer"
daemon-create = "akka.remote.serialization.DaemonMsgCreateSerializer"
}
serialization-bindings {
# Since com.google.protobuf.Message does not extend Serializable but
# GeneratedMessage does, need to use the more specific one here in order
# to avoid ambiguity
"akka.actor.SelectionPath" = akka-containers
"com.google.protobuf.GeneratedMessage" = proto
"akka.remote.DaemonMsgCreate" = daemon-create
}
deployment {
default {
# if this is set to a valid remote address, the named actor will be
# deployed at that node e.g. "akka://sys@host:port"
remote = ""
target {
# A list of hostnames and ports for instantiating the children of a
# router
# The format should be on "akka://sys@host:port", where:
# - sys is the remote actor system name
# - hostname can be either hostname or IP address the remote actor
# should connect to
# - port should be the port for the remote server on the other node
# The number of actor instances to be spawned is still taken from the
# nr-of-instances setting as for local routers; the instances will be
# distributed round-robin among the given nodes.
nodes = []
}
}
}
}
remote {
### General settings
# Timeout after which the startup of the remoting subsystem is considered
# to be failed. Increase this value if your transport drivers (see the
# enabled-transports section) need longer time to be loaded.
startup-timeout = 10 s
# Timout after which the graceful shutdown of the remoting subsystem is
# considered to be failed. After the timeout the remoting system is
# forcefully shut down. Increase this value if your transport drivers
# (see the enabled-transports section) need longer time to stop properly.
shutdown-timeout = 10 s
# Before shutting down the drivers, the remoting subsystem attempts to flush
# all pending writes. This setting controls the maximum time the remoting is
# willing to wait before moving on to shut down the drivers.
flush-wait-on-shutdown = 2 s
# Reuse inbound connections for outbound messages
use-passive-connections = on
# Controls the backoff interval after a refused write is reattempted.
# (Transports may refuse writes if their internal buffer is full)
backoff-interval = 0.01 s
# Acknowledgment timeout of management commands sent to the transport stack.
command-ack-timeout = 30 s
# If set to a nonempty string remoting will use the given dispatcher for
# its internal actors otherwise the default dispatcher is used. Please note
# that since remoting can load arbitrary 3rd party drivers (see
# "enabled-transport" and "adapters" entries) it is not guaranteed that
# every module will respect this setting.
use-dispatcher = ""
### Security settings
# Enable untrusted mode for full security of server managed actors, prevents
# system messages to be send by clients, e.g. messages like 'Create',
# 'Suspend', 'Resume', 'Terminate', 'Supervise', 'Link' etc.
untrusted-mode = off
# Should the remote server require that its peers share the same
# secure-cookie (defined in the 'remote' section)? Secure cookies are passed
# between during the initial handshake. Connections are refused if the initial
# message contains a mismatching cookie or the cookie is missing.
require-cookie = off
# Generate your own with the script availbale in
# '$AKKA_HOME/scripts/generate_config_with_secure_cookie.sh' or using
# 'akka.util.Crypt.generateSecureCookie'
secure-cookie = ""
### Logging
# If this is "on", Akka will log all inbound messages at DEBUG level,
# if off then they are not logged
log-received-messages = off
# If this is "on", Akka will log all outbound messages at DEBUG level,
# if off then they are not logged
log-sent-messages = off
# Sets the log granularity level at which Akka logs remoting events. This setting
# can take the values OFF, ERROR, WARNING, INFO, DEBUG, or ON. For compatibility
# reasons the setting "on" will default to "debug" level. Please note that the effective
# logging level is still determined by the global logging level of the actor system:
# for example debug level remoting events will be only logged if the system
# is running with debug level logging.
# Failures to deserialize received messages also fall under this flag.
log-remote-lifecycle-events = on
# Logging of message types with payload size in bytes larger than
# this value. Maximum detected size per message type is logged once,
# with an increase threshold of 10%.
# By default this feature is turned off. Activate it by setting the property to
# a value in bytes, such as 1000b. Note that for all messages larger than this
# limit there will be extra performance and scalability cost.
log-frame-size-exceeding = off
### Failure detection and recovery
# Settings for the Phi accrual failure detector (http://ddg.jaist.ac.jp/pub/HDY+04.pdf
# [Hayashibara et al]) used by the remoting subsystem to detect failed
# connections.
transport-failure-detector {
# FQCN of the failure detector implementation.
# It must implement akka.remote.FailureDetector and have
# a public constructor with a com.typesafe.config.Config and
# akka.actor.EventStream parameter.
implementation-class = "akka.remote.PhiAccrualFailureDetector"
# How often keep-alive heartbeat messages should be sent to each connection.
heartbeat-interval = 1 s
# Defines the failure detector threshold.
# A low threshold is prone to generate many wrong suspicions but ensures
# a quick detection in the event of a real crash. Conversely, a high
# threshold generates fewer mistakes but needs more time to detect
# actual crashes.
threshold = 7.0
# Number of the samples of inter-heartbeat arrival times to adaptively
# calculate the failure timeout for connections.
max-sample-size = 100
# Minimum standard deviation to use for the normal distribution in
# AccrualFailureDetector. Too low standard deviation might result in
# too much sensitivity for sudden, but normal, deviations in heartbeat
# inter arrival times.
min-std-deviation = 100 ms
# Number of potentially lost/delayed heartbeats that will be
# accepted before considering it to be an anomaly.
# This margin is important to be able to survive sudden, occasional,
# pauses in heartbeat arrivals, due to for example garbage collect or
# network drop.
acceptable-heartbeat-pause = 3 s
}
# Settings for the Phi accrual failure detector (http://ddg.jaist.ac.jp/pub/HDY+04.pdf
# [Hayashibara et al]) used for remote death watch.
watch-failure-detector {
# FQCN of the failure detector implementation.
# It must implement akka.remote.FailureDetector and have
# a public constructor with a com.typesafe.config.Config and
# akka.actor.EventStream parameter.
implementation-class = "akka.remote.PhiAccrualFailureDetector"
# How often keep-alive heartbeat messages should be sent to each connection.
heartbeat-interval = 1 s
# Defines the failure detector threshold.
# A low threshold is prone to generate many wrong suspicions but ensures
# a quick detection in the event of a real crash. Conversely, a high
# threshold generates fewer mistakes but needs more time to detect
# actual crashes.
threshold = 10.0
# Number of the samples of inter-heartbeat arrival times to adaptively
# calculate the failure timeout for connections.
max-sample-size = 200
# Minimum standard deviation to use for the normal distribution in
# AccrualFailureDetector. Too low standard deviation might result in
# too much sensitivity for sudden, but normal, deviations in heartbeat
# inter arrival times.
min-std-deviation = 100 ms
# Number of potentially lost/delayed heartbeats that will be
# accepted before considering it to be an anomaly.
# This margin is important to be able to survive sudden, occasional,
# pauses in heartbeat arrivals, due to for example garbage collect or
# network drop.
acceptable-heartbeat-pause = 4 s
# How often to check for nodes marked as unreachable by the failure
# detector
unreachable-nodes-reaper-interval = 1s
# After the heartbeat request has been sent the first failure detection
# will start after this period, even though no heartbeat mesage has
# been received.
expected-response-after = 3 s
}
# After failed to establish an outbound connection, the remoting will mark the
# address as failed. This configuration option controls how much time should
# be elapsed before reattempting a new connection. While the address is
# gated, all messages sent to the address are delivered to dead-letters.
# If this setting is 0, the remoting will always immediately reattempt
# to establish a failed outbound connection and will buffer writes until
# it succeeds.
retry-gate-closed-for = 0 s
# If the retry gate function is disabled (see retry-gate-closed-for) the
# remoting subsystem will always attempt to reestablish failed outbound
# connections. The settings below together control the maximum number of
# reattempts in a given time window. The number of reattempts during
# a window of "retry-window" will be maximum "maximum-retries-in-window".
retry-window = 60 s
maximum-retries-in-window = 3
# The length of time to gate an address whose name lookup has failed
# or has explicitly signalled that it will not accept connections
# (remote system is shutting down or the requesting system is quarantined).
# No connection attempts will be made to an address while it remains
# gated. Any messages sent to a gated address will be directed to dead
# letters instead. Name lookups are costly, and the time to recovery
# is typically large, therefore this setting should be a value in the
# order of seconds or minutes.
gate-invalid-addresses-for = 60 s
# This settings controls how long a system will be quarantined after
# catastrophic communication failures that result in the loss of system
# messages. Quarantining prevents communication with the remote system
# of a given UID. This function can be disabled by setting the value
# to "off".
quarantine-systems-for = 60s
# This setting defines the maximum number of unacknowledged system messages
# allowed for a remote system. If this limit is reached the remote system is
# declared to be dead and its UID marked as tainted.
system-message-buffer-size = 1000
# This setting defines the maximum idle time after an individual
# acknowledgement for system messages is sent. System message delivery
# is guaranteed by explicit acknowledgement messages. These acks are
# piggybacked on ordinary traffic messages. If no traffic is detected
# during the time period configured here, the remoting will send out
# an individual ack.
system-message-ack-piggyback-timeout = 1 s
# This setting defines the time after messages that have not been
# explicitly acknowledged or negatively acknowledged are resent.
# Messages that were negatively acknowledged are always immediately
# resent.
resend-interval = 1 s
### Transports and adapters
# List of the transport drivers that will be loaded by the remoting.
# A list of fully qualified config paths must be provided where
# the given configuration path contains a transport-class key
# pointing to an implementation class of the Transport interface.
# If multiple transports are provided, the address of the first
# one will be used as a default address.
enabled-transports = ["akka.remote.netty.tcp"]
# Transport drivers can be augmented with adapters by adding their
# name to the applied-adapters setting in the configuration of a
# transport. The available adapters should be configured in this
# section by providing a name, and the fully qualified name of
# their corresponding implementation. The class given here
# must implement akka.akka.remote.transport.TransportAdapterProvider
# and have public constructor without parameters.
adapters {
gremlin = "akka.remote.transport.FailureInjectorProvider"
trttl = "akka.remote.transport.ThrottlerProvider"
}
### Default configuration for the Netty based transport drivers
netty.tcp {
# The class given here must implement the akka.remote.transport.Transport
# interface and offer a public constructor which takes two arguments:
# 1) akka.actor.ExtendedActorSystem
# 2) com.typesafe.config.Config
transport-class = "akka.remote.transport.netty.NettyTransport"
# Transport drivers can be augmented with adapters by adding their
# name to the applied-adapters list. The last adapter in the
# list is the adapter immediately above the driver, while
# the first one is the top of the stack below the standard
# Akka protocol
applied-adapters = []
transport-protocol = tcp
# The default remote server port clients should connect to.
# Default is 2552 (AKKA), use 0 if you want a random available port
# This port needs to be unique for each actor system on the same machine.
port = 2552
# The hostname or ip to bind the remoting to,
# InetAddress.getLocalHost.getHostAddress is used if empty
hostname = ""
# Enables SSL support on this transport
enable-ssl = false
# Sets the connectTimeoutMillis of all outbound connections,
# i.e. how long a connect may take until it is timed out
connection-timeout = 15 s
# If set to "<id.of.dispatcher>" then the specified dispatcher
# will be used to accept inbound connections, and perform IO. If "" then
# dedicated threads will be used.
# Please note that the Netty driver only uses this configuration and does
# not read the "akka.remote.use-dispatcher" entry. Instead it has to be
# configured manually to point to the same dispatcher if needed.
use-dispatcher-for-io = ""
# Sets the high water mark for the in and outbound sockets,
# set to 0b for platform default
write-buffer-high-water-mark = 0b
# Sets the low water mark for the in and outbound sockets,
# set to 0b for platform default
write-buffer-low-water-mark = 0b
# Sets the send buffer size of the Sockets,
# set to 0b for platform default
send-buffer-size = 256000b
# Sets the receive buffer size of the Sockets,
# set to 0b for platform default
receive-buffer-size = 256000b
# Maximum message size the transport will accept, but at least
# 32000 bytes.
# Please note that UDP does not support arbitrary large datagrams,
# so this setting has to be chosen carefully when using UDP.
# Both send-buffer-size and receive-buffer-size settings has to
# be adjusted to be able to buffer messages of maximum size.
maximum-frame-size = 128000b
# Sets the size of the connection backlog
backlog = 4096
# Enables the TCP_NODELAY flag, i.e. disables Nagle’s algorithm
tcp-nodelay = on
# Enables TCP Keepalive, subject to the O/S kernel’s configuration
tcp-keepalive = on
# Enables SO_REUSEADDR, which determines when an ActorSystem can open
# the specified listen port (the meaning differs between *nix and Windows)
# Valid values are "on", "off" and "off-for-windows"
# due to the following Windows bug: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4476378
# "off-for-windows" of course means that it's "on" for all other platforms
tcp-reuse-addr = off-for-windows
# Used to configure the number of I/O worker threads on server sockets
server-socket-worker-pool {
# Min number of threads to cap factor-based number to
pool-size-min = 2
# The pool size factor is used to determine thread pool size
# using the following formula: ceil(available processors * factor).
# Resulting size is then bounded by the pool-size-min and
# pool-size-max values.
pool-size-factor = 1.0
# Max number of threads to cap factor-based number to
pool-size-max = 2
}
# Used to configure the number of I/O worker threads on client sockets
client-socket-worker-pool {
# Min number of threads to cap factor-based number to
pool-size-min = 2
# The pool size factor is used to determine thread pool size
# using the following formula: ceil(available processors * factor).
# Resulting size is then bounded by the pool-size-min and
# pool-size-max values.
pool-size-factor = 1.0
# Max number of threads to cap factor-based number to
pool-size-max = 2
}
}
netty.udp = ${akka.remote.netty.tcp}
netty.udp {
transport-protocol = udp
}
netty.ssl = ${akka.remote.netty.tcp}
netty.ssl = {
# Enable SSL/TLS encryption.
# This must be enabled on both the client and server to work.
enable-ssl = true
security {
# This is the Java Key Store used by the server connection
key-store = "keystore"
# This password is used for decrypting the key store
key-store-password = "changeme"
# This password is used for decrypting the key
key-password = "changeme"
# This is the Java Key Store used by the client connection
trust-store = "truststore"
# This password is used for decrypting the trust store
trust-store-password = "changeme"
# Protocol to use for SSL encryption, choose from:
# Java 6 & 7:
# 'SSLv3', 'TLSv1'
# Java 7:
# 'TLSv1.1', 'TLSv1.2'
protocol = "TLSv1"
# Example: ["TLS_RSA_WITH_AES_128_CBC_SHA", "TLS_RSA_WITH_AES_256_CBC_SHA"]
# You need to install the JCE Unlimited Strength Jurisdiction Policy
# Files to use AES 256.
# More info here:
# http://docs.oracle.com/javase/7/docs/technotes/guides/security/SunProviders.html#SunJCEProvider
enabled-algorithms = ["TLS_RSA_WITH_AES_128_CBC_SHA"]
# There are three options, in increasing order of security:
# "" or SecureRandom => (default)
# "SHA1PRNG" => Can be slow because of blocking issues on Linux
# "AES128CounterSecureRNG" => fastest startup and based on AES encryption
# algorithm
# "AES256CounterSecureRNG"
# The following use one of 3 possible seed sources, depending on
# availability: /dev/random, random.org and SecureRandom (provided by Java)
# "AES128CounterInetRNG"
# "AES256CounterInetRNG" (Install JCE Unlimited Strength Jurisdiction
# Policy Files first)
# Setting a value here may require you to supply the appropriate cipher
# suite (see enabled-algorithms section above)
random-number-generator = ""
}
}
}
}
Note
Setting properties like the listening IP and port number programmatically is best done by using something like the following:
ConfigFactory.parseString("akka.remote.netty.tcp.hostname=\"<IP_ADDRESS>\"")
.withFallback(ConfigFactory.load());
Contents


Back to Web Ring
Fantastic Mr. Fox
by Roald Dahl
Table of Contents
Map
The Nasty Farmers
Something inside
Something inside pt 2
Bang!
j diggin
Big Crater
!!!
Good News for Mrs. Fox
Holed "Diggers"
Stealing a Whole Buffet
Drunk Mouse
Dinner Party
The End
About the Author
About this Project
Quick Look


Disconnected :(
New
Duplicate
Undo
Redo
Publish
Restart
Save
/home/yuri/sample.fab
Fable | Version 1.0


The Status View shows the user’s projects with their overall health during the last twelve/twenty-four hours. Every hour is represented by a slice of the donut inside the tile, below the project’s name. The most recent measure is in the top left, the oldest in the top right of the donut. If a projects current health drops below 75%, a border with the according color is added to the tile to make the project stand out. The intention of this view is to give the user a more detailed overview of their projects than in the dashboard view while at the same time retaining high visibility of the user’s projects. The donut chart is meant to remind the user of a clock where the measured values go back in time counter clockwise.


The first person to go over the Falls in a barrel and survive was a 63 year old female schoolteacher.
High wire tightrope acts used to be performed across the river.
About Niagara Falls
Twenty percent of the worlds freshwater lies in the Great Lakes, and most flows over Niagara Falls. Is there more mist at the Falls? Is it man made or natural coincidence?The flow of water was stopped completely over both falls on March 29th 1848 due to an ice jam in the upper river for several hours. This is the only known time to have occurred.
Interesting facts about Niagara Falls
The flow over the American Falls was stopped completely for several months in 1969. The idea was to determine the feasibility of removing the large amount of loose rock from the base of the falls to enhance it's appearance. In the end the final decision was that the expense would be too great.
History
The word "Niagara" is derived from the Iroquois Indian word "Onguiaahra" meaning "the strait". There is an international boundary between the United States and Canada. Before the invention of film, tourists would sketch pictures of the Falls. The flow was also halted over both falls on March 30th 1848 due to an ice jam in the upper river. The movies Niagara and Superman were filmed in part at the Falls. In the past ten years, two daredevils lost their lives trying to conquer Niagara. In the evenings, intense spotlights bathe the falls with different shades of color.
The movies Niagara and Superman were filmed in part at the Falls.
The tremendous volume of water never stops flowing, However, the falling water and mist create ice formations along the banks of the falls and river. This can result in mounds of ice as thick as fifty feet. If the winter is cold for long enough, the ice will completely stretch across the river and form what is known as the "ice bridge". This ice bridge can extend for several miles down river until it reaches the area known as the lower rapids.
Comments 2
EKATERINA BURCEVA June 9, 2015 8:26 pm
Peak visitor traffic occurs in the summertime, when Niagara Falls are both a daytime and evening attraction. From the Canadian side, floodlights illuminate both sides of the falls for several hours after dark
Reply
JOHN DARKLIN June 10, 2016 9:21 pm
Thanks for this article
Reply
EKATERINA BURCEVA June 11, 2015 5:54 am
The oldest and best known tourist attraction at Niagara Falls is the Maid of the Mist boat cruise, named for an ancient Ongiara Indian mythical character
Reply


HAL 9000 💻🔴
Give them a number....
....They'll give you a list
Give HAL 9000 your number and get a big list


Hello all
I am planning to use an EmonTx V3, a Raspi with RFM69CW, the EmonHub and push data to Emoncms.org.
For my 3-phase system, I would like to display on Emoncms the following parameters:
reactivePower, reactivePower1, reactivePower2, reactivePower3, apparentPower, powerFactor, Irms and the other values that are already calculated in the below sketch.
From sketch "emonTxV3_4_3Phase_Voltage.ino", I should have everything I need (if I am not mistaken) to calculate the above values.
My question: Where should I do the math? In the Arduino sketch and then update the PayloadTx, on the Raspi (where?) or on Emoncms?
I have checked the different functions available on Emoncms and I think I would need the square root which is not available.
What would you suggest?
Thanks for your help.
By the way, this OpenEnergyMonitor project is fantastic.
Walter
Re: 3-phase system: need to calculate/display more parameters
I think the natural place to do that will be in the emonTx, but you have a problem if you want the quadrature component of current in order to get vars - you won't know the sign (inductive/capacitive) from the data available. The only way I think to resolve that would be to calculate vars directly by generating (using the array of stored values) a set of quadrature voltage waves that are shifted 90 ° from the true voltage waves.
And I think you may have a bigger problem. There is already a suspected problem in that sketch with data corruption due to lack of memory, so it might not be possible to include the extra code that you will require.
Re: 3-phase system: need to calculate/display more parameters
Ok, thanks for your quick answer. As first step, I will assume the reactive power is inductive in each phase. Then, I am going to write down the formulas in the sketch, compile and see the results.
I am still waiting for the hardware to come from the shop. So, until there, I can't test anything.
Walter
Re: 3-phase system: need to calculate/display more parameters
Remember also there's Reactive power, and there's Reactive power. The IEEE definition of Reactive power is:
If you've got a modern digital revenue meter that displays Real and Reactive power, it will most likely use that IEEE definition for Reactive power. In the IEEE world, there are three orthogonal components that make up Apparent power: (Real, Reactive, Distortion).
A common (and much easier to calculate) definition of Reactive power is:
Reactive power = (Apparent2 - Real2)1/2
Leaving aside for a moment Robert's point that you need to do further work to determine the sign, those two definitions only produce the same result when there are no harmonics present, i.e. both V and I are sinusoidal. In that rare case, the IEEE Distortion component is zero and so their 3-dimensional model collapses down into 2-dimensions.
A simplification to the IEEE definition to help you get your head around it, is to assume for a moment that your V is a perfect sine wave. In that case all the terms bar the first in that sum disappear because Vn = 0 where n > 1. In that case:
Reactive power = V * I50 * sin(Ø50) (i.e. n=1, and showing the frequency rather than the harmonic number)
So Reactive power is then calculated on just the 50Hz component of the I signal. All the remaining harmonic components of the I signal are booked to Distortion power (because there is no corresponding component in V to get them included in the Reactive power definition). Only the 50Hz stuff can have a sign (i.e. be leading or lagging V) because it's the only component that has a V to compare against.
To the extent that your V signal does have some harmonics, then some of that Distortion power will get dragged back into the Reactive column (complete with sign), but by and large the I signal is way more distorted than the V signal.
As an example, in my house where I have a fairly pure V signal, and lots of I distortion due to all the SMPSs, I see a much larger Distortion component than I do Reactive component:
If I calculated Reactive power via the second formula above, I'd get:
(2512 * 0.672 - 1262)1/2 = 111.4 VAR
but using the first formula I get 13.8 VAR (almost all of that "missing" apparent power has been booked to Distortion).
Arguably, the bigger number is more useful because it reflects the total I load you're putting on the network. It's only relatively recently (with the large scale availability of DSPs) that meters are measuring the Reactive power as defined by the IEEE (the much smaller number in that example). It's potentially even up to individual energy providers as to which definition they prefer.
Here's another way to visualise it. These guys are assuming no harmonics in V, and use S for apparent power:


Element
-
A component represents a small reusable piece of code of element to be rendered. This behaves as all elements of UIKit’s UITableView and UICollectionView, and can be easily support SwiftUI by used in conjunction with the
View
protocol.Example for the simple component:
struct Label: Component { var text: String init(_ text: String) { self.text = text } func renderContent() -> UILabel { return UILabel() } func render(in content: UILabel) { content.text = text } }
Example for use with SwiftUI:
See moreextension Label: View {} struct ContentView: View { var body: some View { VStack { Text("This is SwiftUI view") Label("This is Carbon component") } } }
Declaration
Swift
public protocol Component
-
Represents a component that can be uniquely identify.
Example for the simple identified component:
See morestruct UserLabel: IdentifiableComponent { var id: Int64 var name: String func renderContent() -> UILabel { return UILabel() } func render(in content: UILabel) { content.text = name } }
Declaration
Swift
public protocol IdentifiableComponent : CellsBuildable, Component
-
Represents a section of list UI, containing header node, footer node and collection of cell nodes. This works as an intermediary for
DifferenceKit
.Example for simple section.
See moreSection( id: 0, header: Label("Header"), footer: Label("Footer"), cells: { Label("Cell 0") .identified(by: \.text) Label("Cell 1") .identified(by: \.text) Label("Cell 2") .identified(by: \.text) } )
Declaration
Swift
public struct Section


Anita Chaudhary is a Licensed Lower Secondary Level Educator currently working at Nepal Basic School, Binayi Triveni,
Nawalparasi as an English Teacher. She has a master's degree in English. She believes creative lessons and engaging classrooms help the
student learn critical thinking, problem-solving and collaboration skills. She also believes education should be such that students can apply to their everyday life.
She is also a Life Insurance agent of Asian Life Insurance.
Major English
Major English
Major English
Apart from being an educator, Anita Chaudhary enjoys traveling to new places.
When indoors, She likes cooking a variety of delicacies and reading self-help books.


Password protected HTML file for inputing the winning Score >
Contains: input boxes:
Q1: Team X Score, Team Y Score
Q2: Team X Score, Team Y Score
Q3: Team X Score, Team Y Score
Final: Team X Score, Team Y Score >
Submit Button
>> Submit button sends winner information to "Set Winner" Function on Etherum Contract Game.sol


Lewis Hamilton confident he can take on F1's new young talent
by Adam NewtonSix time F1 champion Lewis Hamilton says that he believes he still has the ability to take on F1's new generation of talented drivers, despite being over a decade older than most of them. 34-year old Hamilton is still at the top of his game, as shown by his storming run to the title this year, picking up ten race wins on the way.
The likes of Max Verstappen, Charles Leclerc and Alex Albon have shown their ability in recent weeks and months, and with even more talent in the pipeline with the likes of Lando Norris, George Russell and Esteban Ocon also showing very positive signs.
These guys may be the future of F1, but right now Hamilton is the master and he says he can still compete with the new wave of talent.
He told motorsport.com: “It’s inevitable that the youngsters are going to come through. There’s often a wave of young talent that manages to make its way through to Formula 1.
“I think Formula 1’s got a lot of new young blood with a lot of potential and they really are the future of the sport.
“Fortunately I feel that whilst the number [of years] shows a little bit higher, I feel like I’m able to still kick it with these guys.
“So I’m excited for the future, racing with these guys and if we can get these teams to be closer, then we’re going to see more awesome battles like [Brazil] and I think that would be great.”


The objective of the Geologic Toolbox project is to provide software tools which bring geologic data into the GIS world and to allow geoscientists the combined use of GIS data (such as traditional base layers, map services, etc.) and representations of geologic 3-d models.
As a first step, a collection of functions to import geologic layer models and borehole information into ESRI's ArcGIS Pro environment is provided. Basically, the GeologicToolbox comprises of ArcPy scripts that can be executed from ArcGIS Pro's user interface.
Furthermore, additional Java implementations which run independently from ArcGIS Pro can be used. The Java code inside the GeologicToolbox repository mainly addresses Java programmers (although everyone should be able to run them from the command line). To execute these helpers a suitable Java Runtime Environment (JRE) and the current Java-code from the 52n Triturus project is needed.
We expect that the offered toolbox functionality will grow in the near future. You are welcome to participate!


Appitizers
Pot Stickers
7
Fried Wontons
5
Spring Rolls
6
Soups
Hot and Sour Soup
Sm5/lrg10
Egg Drop Souop
Sm5/lrg10
Won Ton Soup
Sm5/lrg10
Vegetables
Sauteed Broccoli
8
Assorted Vegetables
8
Hot Braised Been Curd
8
Vegetables with Fried Tofu
8
Pork
Mu Shu Pork
9
Sweet and Sour Pork
9
Twice Cooked Pork
9
Beef
Mongolian Beef
10
Szechuan Beef
10
Broccoli Beef
10
Green Pepper Beef
10
Mushroom
10
Chicken
Mushroon Chicken
9
Kung Pao Chicken
9
Broccoli Chicken
9
Cashew Chicken
9
Garlic Chicken
9
Vegetables with Chicken
9
Mu Shu Chicken
9
Seafood
Kung Pao Prawns
11
Deep Fried Prawns
11
Sweet and Sour Prawns
11
Vegetables Prawns
11
Staple Food
House or Shrimp Fried Rice
9
Chicken or Vegetable
8
House or Shrimp Cow Mein
9
Chicken or Vegetable Chow Mein
8
Steamed Rice
4
Drinks
Soft Drinks
1.5/20oz


Opening credits of David Lynch's Blue Velvet. My intention was to make a portrait of the United States from the 50s : too perfect during the day, transforming at night, when things distort and become elusive and unreal.
Synopsis : While going to visit his father recovering a heart attack, Jeffrey finds a human hear in the grass. Then he decides to investigate with Sandy, the inspector's daughter. They suspect Dorothy Vallens, a cabaret singer with weird habits...  After that, he tries to comfort her and becomes prisoner of her strange love.
The opening credits tries to evoke the transition from the pure light of the day to the particular atmosphere of the night, made of artificial electric lights. I used stereotyped pictures of America and highly saturated them which makes them even more artifical. Distortion on images and typography retranscribes the idea of transformation and strangeness. The sizzling saturated music makes the atmosphere as disturbing as the character's psychology. Music : I know - David Lynch


Import CSV
Upload a .csv file with two columns: "name" and "id".
Download Example
Choose file
Submit


| Property | Description | Data Type |
|---|---|---|
|
protocol identifier
required |
Trial identifier used by lead organization, ie. Center for Experimental Therapeutics Program (CTEP) ID or Industry Sponsored ID. This is usually a short identifier. Example: E4412. | < string > |
|
assay creator
required |
Indicates what site is filling out the assay. |
<
string
>
|
|
slide scanner model
required |
Model version of the slide scanner instrument. |
<
string
>
|
|
staining platform
required |
Staining platform used for tissue sample labeling. |
<
string
>
|
|
autostainer model
required |
Model version of the autostainer instrument. |
<
string
>
|
|
antibody name
required |
Antibody type collected for this study. | < string > |
|
company
required |
Company from which antibody sample was derived. | < string > |
|
clone
required |
Resulting type of antibody clone from primary antibody sample. | < string > |
|
catalogue number
required |
Antibody registry catalog number assigned to antibody sample. | < string > |
|
lot number
required |
Identification number assigned to the particular quantity or lot of material from manufacturer. | < string > |
|
dilution
required |
Concentration ratio for antibody dilution. | < string > |
|
incubation time
required |
Time duration of antibody incubation. | < string : time > |
|
incubation temperature
required |
Temperature used for antibody incubation. | < string > |
Sample
| Property | Description | Data Type |
|---|---|---|
|
cimac id
required |
Specimen identifier assigned by the CIMAC-CIDC Network. Formatted as CTTTPPPSS.AA for trial code TTT, participant PPP, sample SS, and aliquot AA. |
<
string
>
as regex ^C[A-Z0-9]{3}[A-Z0-9]{3}[A-Z0-9]{2}.[0-9]{2}$
|
|
IHC image
required |
Information about an image file. | image |
Marker call
| Property | Description | Data Type |
|---|---|---|
|
marker positive
required |
Indicates whether the marker is considered positive by clinical trial guidelines (if applicable). |
<
string
>
|
Chromogenic IHC (please specify one score/metric)
| Property | Description | Data Type |
|---|---|---|
| tumor proportion score | Tumor Proportion Score (TPS) is the percentage of viable tumor cells showing marker staining relative to all viable tumor cells. (0-1) | < number , string > |
| combined positive score | Combined Positive Score (CPS) is the percentage of marker staining cells (tumor cells and cells that are non-tumor) relative to all viable tumor cells. (0-1) | < number , string > |
| inflammatory cells | Percentage of inflammatory cells (non-tumor cells) showing marker staining relative to all inflammatory cells. (0-1) | < number , string > |
| positive inflammatory cell area | Area of PD-L1+ Inflammatory Cells over the area of TSI + IT as a percentage. (0-1) | < number , string > |
| intensity | A measure of the intensity or brightness of the protein. (0-3) | < number , string > |
| % expression | A percentage of the relevant cells considered positive. (0-100) | < number , string > |
| h score | A summation of the percentage of area stained at each intensity level multiplied by the weighted intensity. (0-300) | < integer , string > |
| comment | A text comment regarding this slide. | < string > |


{% extends "home/base.html" %} {% load static %} {% block body-content %}
{% endblock %} {% block youtube-content %}Follow our heros through the many perils that face them on the latest skyblocks map.
Our bleeding edge modpack featuring the best tech mods available for Minecraft 1.10.2


Back
Inputs
Basic Usage
Sign Up
Fixed Labels
Username
Password
Sign In
Floating Labels
Username
Password
Sign In
Stacked Labels
Username
Password
Sign In


| 004:066 Khan | : |
And if We had ordered them (saying), "Kill yourselves (i.e. the innnocent ones kill the guilty ones) or leave your homes," very few of them would have done it; but if they had done what they were told, it would have been better for them, and would have strengthened their (Faith); |
| 004:066 Maulana | : |
And if We had enjoined them, Lay down your lives or go forth from your homes, they would not have done it except a few of them. And if they had done what they are exhorted to do, it would certainly have been better for them and more strengthening: |
| 004:066 Pickthal | : |
And if We had decreed for them: Lay down your lives or go forth from your dwellings, but few of them would have done it; though if they did what they are exhorted to do it would be better for them, and more strengthening; |
| 004:066 Rashad | : |
Had we decreed for them: "You must offer your lives," or "Give up your homes," they would not have done it, except for a few of them. (Even if such a command was issued,) had they done what they were commanded to do, it would have been better for them, and would prove the strength of their faith. |
| 004:066 Sarwar | : |
Had We commanded them to kill themselves or abandon their homes, only a few of them would have done it. If they had done what they had been advised to do, it would have strengthened their faith, |
| 004:066 Shakir | : |
And if We had prescribed for them: Lay down your lives or go forth from your homes, they would not have done it except a few of them; and if they had done what they were admonished, it would have certainly been better for them and best in strengthening (them); |
| 004:066 Sherali | : |
And if WE had commanded them: Slay your people or leave your homes,' they would not have done it except a few of them; and if they had done what they are exhorted to do, it would surely have been better for them and conducive to greater strength; |
| 004:066 Yusufali | : |
If We had ordered them to sacrifice their lives or to leave their homes, very few of them would have done it: But if they had done what they were (actually) told, it would have been best for them, and would have gone farthest to strengthen their (faith); |
Concepts/Themes Covered: العلاقات القضائية > أحكام قانونية > النفي Judicial Relationships>Legal Rules>Negation الديانات > بنو إسرائيل > جزاؤهم لو آمنوا Religions>Children of Israel>Their Reward in case they had Believed in Him الديانات > بنو إسرائيل > معاندتهم و تكذيبهم و قتلهم الأنبياء Religions>Children of Israel> Their Opposition, their Denial and their Killing the Prophets الديانات > النصارى > أجرهم لو آمنوا Religions>The Christians>Their Reward if they Believed in Allah
This tool uses eight English parallel translations for the Holy Quran imported from Mr. Clay Smith. You can also visit Qurany Concepts for browsing the Quran themes or topics. If you want to search the Holy Quran for keywords, please visit Qurany Keywords.


2021.03.20
- Ignore duplicate calling keys.
- Message details in Member Chat activity.
- Tulip server discontinued.
2021.02.27
- Corrected raw SQLite queries.
- Decreased awaitTermination() values. Method may stall Smoke.
- ETags for bypassing congestion.
- Reliable distribution of deliverable text messages. Requires reinstall as new database fields have been introduced.
- Replaced checkboxes with switches.
- Tool tips.
- Warn if the time server cannot be queried.
2021.02.10
- Fewer locks.
- Improved process termination.
- New server tulip-ipv4.tilaa.cloud.
2021.01.30
- Retain Fire messages.
- Weak references.
2021.01.20
- Corrected reset of local authentication key.
- Obfuscate local authentication and encryption keys.
- Prepare Steam key container properly.
2021.01.10
- Avoid creating tasks for completed Steams.
- Free Steam resources.
- Sort sub-title IP address.
2020.12.25
- Bouncy Castle 1.68.
- Corrected comparisons of byte arrays.
- Disable context menus if public keys are not available.
- Estimate the number of physical cores for Argon2id. Smoke must be reinstalled.
- Future-proofing Smoke.
- Guard String.indexOf().
- Hide ephemeral key types for Other Steam destinations.
2020.12.15
- Future-proofing cryptographic primitives.
- New Steam database field. Please reinstall Smoke.
- Permanent RSA keys are now 4096 bits.
- Steam keys: McEliece, RSA.
- Super McEliece (m = 13, t = 118).
2020.11.15
- Bouncy Castle 1.67.
- Disable Chat:Send if there is at least one selected participant without a session key pair.
- Efficient ArrayList::remove(). Remove from the end of the array.
- Full, reliable, Steam! File sharing.
- Improved TLS handshake-completed state.
- Issue Settings::prepareListeners() shortly after the Settings activity has been instantiated.
- Monitor connection activity; decreased polling.
- Notify the user of incorrect device time via https://worldtimeapi.org/api/timezone/Etc/UTC.txt. Optional.
- Prepare initial private keys during a public-key exchange.
- Provide message-read responses to SmokeStack instances.
- Random identities need not be recorded to databases.
- Removed SecureRandom.getInstance("SHA1PRNG").
- Removed verbose threads and replaced with events.
- Request Ozone messages shortly after a TCP connection has been established or a TLS session has been established.
- SipHash-128.
- Write local identity immediately upon completion of TLS handshake.
2020.04.07
- Artificial random-access Steam files.
- New Scripts directory.
- Retain Steam rates.
2020.04.05
- Clear Smokescreen password.
- Static variables.
2020.04.04
- Bouncy Castle 1.65!
- Denote Juggernaut protocol failures and successes.
- Kernel broadcast receiver for immediate delivery of internal instructions.
- McEliece Pointcheval conversion. Smoke must be reinstalled!
- Non-TLS devices.
- Partial Steam.
- Passthrough devices.
- Smokescreen, or, application lock.
2020.01.01
- Happy New Year!
- New Argon2id parameters.
2019.12.30
- Argon2id key-derivation function.
2019.12.10
- Allow Android to recycle bitmaps.
- Corrected the private server authentication protocol.
2019.11.30
- Support various McEliece parameters.
2019.11.25
- Bouncy Castle version 1.64.
- Corrected primary key in participants table. Please reinstall Smoke.
- Corrected widget states during initialization.
2019.09.30
- Bouncy Castle version 1.63.
- Exit option. May be incomplete on some devices.
- Guard socket buffers.
- New icons.
- Save attachments to Downloads (Internal Storage -> Download).
- Settings -> View Details functional on Android 9.
2019.04.14
- JuggerKnot.
- Properly create strings from bytes. Ozones and participants must be redefined.
2019.04.04
- Allow removal of participant public keys.
- Close Java streams.
- Default socket buffer sizes.
- Juggernaut Protocol.
- Minor Fire layout changes.
- Release resources on onPause(), onStop().
- Removed deepCopy().
- Smoke Alias. Change your credentials while preserving your relationships.
2019.03.03
- Allow removal of specific messages in MemberChat.
- Decreased maximum buffer size from 32 MiB to 8 MiB.
- Prefer delete() over setLength(0) on buffers.
- Recycle bitmaps.
2019.02.25
- Bouncy Castle version 1.61.
- Material icons.
- Optional foreground service.
2019.02.02
- Array lengths may not be negative.
- Automatic removal of incorrect network data. Smoke and SmokeStack.
- Corrected conditional in UdpMulticastNeighbor::send(). SmokeStack.
- Disable Nagle's algorithm.
- Energy and iterations.
- Optional initialization of Ozone during neighbor definition.
- Orderly shutdown of schedules.
- Pause schedules, notify if necessary.
- Replaced Spongy Castle with Bouncy Castle. Please replace existing listeners. SmokeStack.
- SNAP!
- Smaller lock regions.
- SmokeStack confirmation for identity sharing of personal identity.
- StringBuilder over StringBuffer if possible.
2018.10.10
- Compute SHA-512 display digest of PEM(certificate).
- Inspect length in String::substring().
- New server (tulip-ipv4.tilaa.cloud).
2018.09.01
- Allow resending of messages.
- Deleting Fiasco keys lacked proper confirmation.
- Denote messages which have been read by the recipient.
- Denote messages which have been sent.
- Depict Smoke failures.
- Lock SipHash::hmac().
- New participants_messages database fields. Requires new installation.
2018.08.19
- Allow generation of only PK material in Settings.
- Allow new participant names via context menus; Settings::Participants.
- Automatically set the Ozone to the Smoke ID on new installations.
- Blocking socket reads.
- Bouncy Castle at version 1.60.
- Calling via ephemeral McEliece; MemberChat only.
- Clear internal messaging log on Chat::Clear.
- Corrected faulty widget listeners in Fire.
- Corrected slight time differences between time stamps in messages destined for SmokeStacks and messages destined for participants.
- Increased key-publishing period from 15 seconds to 45 seconds. Also removed self-publishing.
- Material Design-compliant color selections.
- McEliece parameters m = 12, t = 68. Compatibility with m = 11, t = 50 is preserved.
- Messages in MemberChat will not be duplicated in the Chat activity.
- New Fiasco Keys column in Settings::Participants.
- New chat-message format. Incompatible with previous releases.
- Pause threads when possible.
- Periodically request Ozone messages.
- Private servers through SmokeStack.
- Removed the superfluous name field from the participants database table.
- Replaced complex if-statements with switch statements.
- Several member variables in the Neighbor class were defined as static. Corrected.
- Share capabilities and identities shortly after the SSL/TLS handshake has completed on TCP sockets.
- Shared keys without signatures are now accepted and properly depicted in Settings.
- Sign encryption and signature public keys as pairs.
- Singular member pages. Single image attachments included.
- Uniquely-persistent Fire identities.
- Viewing of member details now available via Settings::Participants context menu.
2018.05.05
- Forward secrecy from the past.
2018.04.04
- LocalBroadcastManager instances.
- Single ID per Fire.
2018.03.15
- Congestion-control improvements.
- Corrected nested locks (isNetworkConnected()).
- Insert-or-throw SQLite database queries.
- The ProgressDialog class has been deprecated. ProgressBars have now been added.
- The replace method may not be available in a hash table; put().
2018.03.03
- Attempt socket connections regardless of WiFi availability. Insight.
- Automatically import rosemary-ipv4.tilaa.cloud:4710 on new installations.
- Corrected local echo behavior.
- Echo Fire, if possible!
- Fire Digest Key and Salt fields may not be empty. Corrected.
- Host translation must be performed before every socket connection attempt.
- Large-area congestion-control mutex.
- Partition messages over UDP links into 576-byte datagrams.
- Provide the HMAC algorithm during identity distribution.
- The Call widget should only be enabled if a network is present.
- Time-tag SmokeStack-bound messages before departure. Otherwise, SmokeStack instances will discard expired messages.
- Wonderful documentation.
2018.02.20
- Abort simultaneous calls.
- Inspect WiFi availability before attempting socket connections.
- New Chat background color.
- Prepare calling public-key pairs without locking calling queue object.
- Replaced integers with long integers where necessary.
- Set Fire height to 60% of screen height.
2018.02.10
- Allow empty Fire participant names.
- Allow purging of neighbor queues.
- Automatic, oscillatory EPKS.
- Avoid non-essential operations if network channels are not available.
- Depict corrupted database entries.
- Enabled Nagle's algorithm.
- Introduced McEliece-Fujisaki via Bouncy Castle. Cross-communications supported.
- Minimum password length set to one character.
- New Fire key generation. Destination tags are required for SmokeStack.
- Participant name changes should be reflected in the Chat activity.
- Trim Channel, Digest Key, and Salt values on Fire.
2018.01.05
- Fire, or, group communications. Compatible with Spot-On.
- Increased lane widths to 8 MiB.
2017.08.19
- Set a non-zero SO_TIMEOUT as some devices do not unblock socket reads after sockets are closed.
2017.07.20
- AndroidManifest.xml was missing WakeLock permissions.
- Do not attempt to send duplicate data.
- Do not specify timeouts in socket reads as separate threads are responsible for socket reads.
- Removed all Thread.sleep() instances.
- Replaced StringBuilder Neighbor member with StringBuffer. StringBuffer is thread-safe.
- Signed release.
- WiFi lock.
2017.07.16
- Less activity on disconnected neighbors.
2017.07.09
- Detect existing key pairs in writeParticipant().
- Smaller database transaction areas.
2017.07.07
- Do not automatically purge the temporary identity for offline message retrieval unless some inactive period has elapsed.
- Issue SQLiteDatabase.update() whenever a participant is added. This will allow for replacing of participant names without removal of existing data.
- SmokeStack as a private public key repository.


The official website of the Olympic Game is: http://www.olympic.org/
The 2018 Winter Olympics are in PyeongChang, South Korea.


Welcome,{{username}}
Home
Logout
Profile
Skills Posting
Skilled in or seeking
{% for line in skills %}
{{line.keyword}}
{% endfor %}
Your matches
{% for line in matches %}
NetID: {{line.username}}
Name: {{line.firstname}} {{line.lastname}}
Gender: {{line.gender}}
Email: {{line.email}}
School: {{line.school_name}}
Major: {{line.major}}
Skill: {{line.keyword}}
{% if line.idea != "" %}
Idea: {{line.idea}}
{% endif %}
{% endfor %}


'This phrase should appear as normal, starting with a single quote.'
When you've got single quotes (') in a line, they're regular quotes.


Array2XML: A class to convert array in PHP to XML It also takes into account attributes names unlike SimpleXML in PHP It returns the XML in form of DOMDocument class for further manipulation.
It throws exception if the tag name or attribute name has illegal chars.
Author : Lalit Patel Website: http://www.lalit.org/lab/convert-php-array-to-xml-with-attributes License: Apache License 2.0 http://www.apache.org/licenses/LICENSE-2.0 Version: 0.1 (10 July 2011) Version: 0.2 (16 August 2011) - replaced htmlentities() with htmlspecialchars() (Thanks to Liel Dulev) - fixed a edge case where root node has a false/null/0 value. (Thanks to Liel Dulev) Version: 0.3 (22 August 2011) - fixed tag sanitize regex which didn't allow tagnames with single character. Version: 0.4 (18 September 2011) - Added support for CDATA section using @cdata instead of @value. Version: 0.5 (07 December 2011) - Changed logic to check numeric array indices not starting from 0. Version: 0.6 (04 March 2012) - Code now doesn't @cdata to be placed in an empty array Version: 0.7 (24 March 2012) - Reverted to version 0.5 Version: 0.8 (02 May 2012) - Removed htmlspecialchars() before adding to text node or attributes.
Usage: $xml = Array2XML::createXML('root_node_name', $php_array); echo $xml->saveXML();
createXML(string $node_name, array $arr) : \FIT\NetopeerBundle\Models\DomDocument
string
array
\FIT\NetopeerBundle\Models\DomDocument
init($version, $encoding, $format_output)
bool2str($v)
convert(string $node_name, array $arr) : \FIT\NetopeerBundle\Models\DOMNode
string
array
\FIT\NetopeerBundle\Models\DOMNode
getXMLRoot()
isValidTagName($tag)
$encoding
$xml


--- layout: post title: Sheepherder, 1937 date: 2014-07-27 16:33:53.000000000 -05:00 type: post parent_id: '0' published: true password: '' status: publish categories: [] tags: - lithograph - southwest meta: _publicize_pending: '1' publicize_facebook_url: https://facebook.com/ publicize_twitter_user: darribas publicize_twitter_url: http://t.co/vrJcWLymYk _wpas_done_31944: '1' _publicize_done_external: a:1:{s:7:"twitter";a:1:{i:14787941;b:1;}} author: login: dreamessenceonthemove email<EMAIL_ADDRESS>display_name: darribas first_name: Daniel last_name: Arribas-Bel permalink: "/2014/07/27/sheepherder-1937/" excerpt: |- Peter Hurd, 1904-1984. Amon Carter museum. Fort Worth, TX. ---
Peter Hurd (1904-1984).
Amon Carter museum. Fort Worth, TX.


-
How do I add a friend in Zom?
Zom has a few options for adding friends. You can add/invite friends right after you register, as well as by clicking on the 'Add friend' icon on bottom right of the 'Friends' page.
SMS: You can invite friends using your regular SMS. FYI - Charges may apply if your cellular service provider charges you for sending texts.
Share: You can share an invite link for FREE through all communication apps like Email, Chat, Social Networking apps, etc.
Scan: If your friend is right next to you, you can scan QR Codes to add. It is quick and simple.
Direct Invite: You won't run out of options if you or your friend resist regular communication apps. You can directly add their username into your friend list.
-
How do I start chatting?
Go to the Chat page. Click on the + (plus) sign at the bottom right. Choose a friend you want to chat with and you are ready to chat.
-
How do I send a voice message?
Click on the Microphone icon to the right of text box. Keep pressing the talk button while you record your voice and once you finish, release it and the message will automatically be sent to your contact.
-
How do I cancel a voice message before sending/while recording?
If you have started recording a message, but want to re-record or not send the message at all, just swipe up and release.
-
How do I send an image?
Click on the Attach icon to the left of the text box.
The first option is to select existing photos from your photo gallery. The second option is to take picture and send.
-
How do I send a sticker?
Click on the Attach icon to the left of the text box. Select the Smiley face icon and swipe left to see all available sticker packs. Zom stickers are unique and fun!
-
How do I know if my contact has received my msg?
You will see the double check mark, instead of just the single "sent" checkmark.
-
How do I delete contacts?
Go to the 'Friends' page and press on the Friend you want to delete. A delete option will appear. Click on 'OK'. You can always connect with that friend again by adding them back into Zom.
-
How do I start a group chat?
Go to the Zom 'Menu' (three vertical dots on to right) and select 'Create a Group'. Create a name suitable for the group and click on 'Connect'. Once the group is created, on top right, select the 'Add friend' icon to start adding friends to the group. Enjoy being constantly connected to your loved ones!
To delete a group, in 'Chat' page, swipe the group to the right.
-
How do I add a friend in Zom?
Zom has a few options for adding friends. You can add/invite friends right after you register, as well as by clicking on the 'Add friend to Zom' button in 'Chats' and 'Add Buddy' button in 'Compose'.
SMS: You can invite friends using your regular SMS. FYI - Charges may apply if your cellular service provider charges you for sending texts.
Share: You can share an invite link for FREE through all communication apps like Email, Chat, Social Networking apps, etc.
Scan: If your friend is right next to you, you can scan QR Codes to add. It is quick and simple.
Direct Invite: You won't run out of options if you or your friend resist regular communication apps. You can directly add their username into your friend list.
-
How do I start chatting?
Click on the 'Compose' image on top left on Chats page. Select a friend to chat with and click on the check mark at the top right of the screen and you are ready to chat.
-
How do I send a voice message?
Click on the Microphone icon to the right of text box. Keep pressing the talk button while you record your voice and once you finish, release it and the message will automatically be sent to your contact.
-
How do I cancel a voice message before sending/while recording?
If you have started recording a message, but want to re-record or not send the message at all, just swipe up and release.
-
How do I send an image?
Click on the Camera icon to the left of the text box. Choose the first option, 'Take Photo or Video' to take an instant photo or select 'Photo Library' for sending existing photos.
-
How do I send a sticker?
Click on the Camera icon to the left of the text box and select 'Sticker' and choose a sticker from the sticker packs.
-
How do I know if my contact has received my msg?
----
-
How do I delete contacts?
Press on the contact you want to delete. Swipe to the left and click on Delete.
-
How do I start a group chat?
To start a 'Group' in an iOS device, go to the 'Compose' page and click on the contact you want to add to the group. Once the check mark appears, continue selecting others to add to the group and then 'Click' on the Check Mark icon on top right of the screen. Enter a group name and click on 'OK' and you are set to connect.


|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object | +--be.ac.kuleuven.cs.ips2.project2002.logicCircuits.LogicCircuit
LogicCircuit instances represent electronic logic circuits. Their
main property is that they have a boolen value (getValue()
).
When the value changes, instances of this type send
ValueChangedEvent
s to registered
ValueChangedListener
s.
To make it easier to identify logic circuit instances in a user
interface, all logic circuit instances have a String name
getName()
.
2 kinds of logic circuits are discerned:
This class offers final support for the name property, the boolean
value property, and administration and notification of the value
changed listeners and dependents.
setValue(boolean)
changes the actual value of this logic
circuit instance, taking care of all necessary notifications.
This method is protected, because some subtypes, more specifically
gates, cannot offer this functionality publicly. Their boolean value
is under their control, and should not be mutable by a user.
For demonstration purposes, instances of this type are required to
notify interested DemoUpdateListener
s when they start contemplating
a change in the local boolean value, and when this process is completed
(whether the value was actually changed or not). This class offers final
support for the administration of those listeners.
| Field Summary | |
static java.lang.String |
CVS_AUTHOR
|
static java.lang.String |
CVS_DATE
|
static java.lang.String |
CVS_REVISION
|
static java.lang.String |
CVS_SOURCE
|
static java.lang.String |
CVS_STATE
|
static java.lang.String |
CVS_TAG
|
| Constructor Summary | |
LogicCircuit(java.lang.String name,
boolean initialValue)
|
| Method Summary | |
void |
addDemoUpdateListener(DemoUpdateListener listener)
|
void |
addDependentGate(LogicGate dependent)
|
void |
addValueChangedListener(ValueChangedListener listener)
|
boolean |
equals(java.lang.Object other)
This method is not really overwritten (we only call the super implementation). |
java.util.Set |
getDemoUpdateListeners()
Returns the set of registered DemoUpdateListeners. |
java.util.Set |
getDependentGates()
Returns the set of registered dependents. |
int |
getFanOut()
The number of dependent gates. |
java.lang.String |
getName()
|
boolean |
getValue()
|
java.util.Set |
getValueChangedListeners()
Returns the set of registered ValueChangedListeners. |
boolean |
hasSameValue(LogicCircuit other)
This logic circuit has the same value as |
boolean |
isDependent(LogicGate lg)
|
void |
removeDemoUpdateListener(DemoUpdateListener listener)
|
void |
removeDependentGate(LogicGate dependent)
|
void |
removeValueChangedListener(ValueChangedListener listener)
|
protected void |
setValue(boolean value)
Set the boolean value of |
java.lang.String |
toString()
A string representation of this. |
protected void |
updateDependentGates()
Notify all registered dependents about a boolean value change, so that they can update themselves. |
protected void |
valueUpdateCompleted()
Notify all registered DemoUpdateListeners about the completion of a value update. |
protected void |
valueUpdateStarts()
Notify all registered DemoUpdateListeners about the start of a value update. |
| Methods inherited from class java.lang.Object |
|
| Field Detail |
public static final java.lang.String CVS_SOURCE
public static final java.lang.String CVS_REVISION
public static final java.lang.String CVS_DATE
public static final java.lang.String CVS_STATE
public static final java.lang.String CVS_TAG
public static final java.lang.String CVS_AUTHOR
| Constructor Detail |
public LogicCircuit(java.lang.String name, boolean initialValue)
name
- A string used to identify this logic circuit.initialValue
- The initial value for the boolean value of the new instance.| Method Detail |
public final java.lang.String getName()
public final boolean getValue()
public final boolean hasSameValue(LogicCircuit other)
Object.equals(Object)
for
this. Instances of this class have to work with referential semantics
in different places, such as collections. Logic circuits with the
same boolean value are not necessarily equal.protected final void setValue(boolean value)
Set the boolean value of
If getValue()
, nothing happens.
value
- The new value of this logic circuit.public final java.util.Set getValueChangedListeners()
public final void addValueChangedListener(ValueChangedListener listener)
listener
- The object to be notified of a change of our boolean value.public final void removeValueChangedListener(ValueChangedListener listener)
listener
- The object no longer to be notified of a change of our boolean value.public final java.util.Set getDemoUpdateListeners()
public final void addDemoUpdateListener(DemoUpdateListener listener)
listener
- The object to be notified about the update progress.public final void removeDemoUpdateListener(DemoUpdateListener listener)
listener
- The object no longer to be notified about the update progress.protected final void valueUpdateStarts()
protected final void valueUpdateCompleted()
public final java.util.Set getDependentGates()
public final int getFanOut()
public final boolean isDependent(LogicGate lg)
public final void addDependentGate(LogicGate dependent)
dependent
- The object to be notified of a change of our boolean value.public final void removeDependentGate(LogicGate dependent)
dependent
- The object no longer to be notified of a change of our boolean value.protected final void updateDependentGates()
public final boolean equals(java.lang.Object other)
equals
in class java.lang.Object
public java.lang.String toString()
toString
in class java.lang.Object
|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


ScholarX is an exclusive 3-month program aimed at providing mentoring support to a selected pool of High Potential undergraduate students based in Sri Lanka ideally by a Sri Lankan expat currently engaged with one of the world’s top universities or Fortune 500 companies. It’s our free premium mentoring platform by Sri Lankans for Sri Lankans working towards creating a culture of knowledge and expertise sharing without the limitation of geographical borders.
| Name | University | Mentor | |
|---|---|---|---|


Simple slideshows via the web, in sync on the phone/tablet/computer of audience members.
Are you in the audience, waiting for a presentation?


France survive scare to make winning start at Davis Cup finals
Canada become the first country to reach the quarter-finals and Spain level their opening tie against Russia.
Top seeds France avoided a big upset with a narrow victory over Japan in their opening match at the Davis Cup finals in Madrid.
Jo-Wilfried Tsonga easily beat Yasutaka Uchiyama 6-2 6-1 but Gael Monfils suffered a 7-5 6-2 loss to Yoshihito Nishioka, sending the contest to a deciding doubles rubber.
French duo Pierre-Hugues Herbert and Nicolas Mahut have not had much time to adjust to the conditions after winning the ATP Finals in London on Sunday and found themselves a set down before recovering to beat Uchiyama and Ben McLachlan 6-7 (4) 6-4 7-5.
After the relative success of the crowds on day one – which organisers announced totalled more than 12,000 – the morning session on Tuesday was a disappointment.
French fans, traditionally among the most passionate, have been arguably the most critical of the switch to a World Cup-style event and most have boycotted despite the relatively short journey.
Mahut said: “It is a strange feeling. When you play Davis Cup, usually the stadium is full. But once you start and you play with France on the back, you forget everything. You play for yourself, you play for the captain, you play for the guys, and for people who are supporting us.
“We need to win to see if later in the week there will be more people in the stands.”
It was a huge contrast to their last match, the final 12 months ago, when a capacity crowd in Lille cheered on the hosts in their defeat by Croatia.
Herbert added: “Actually, it was pretty special because it was the first time I hear myself singing the Marseillaise song.
Argentina were comprehensive 3-0 winners over Chile in Group Three, with all their victories coming in straight sets, while Kazakhstan defeated Holland 2-1 in Group E.
Dutch number one Robin Haase upset Alexander Bublik to send the tie to a deciding doubles rubber, where Bublik gained revenge over Haase and Jean-Julien Rojer alongside Mikhail Kukushkin.
Canada became the first country to reach the quarter-finals, winning their group by beating USA.
Australia also won, beating Colombia 3-0 with wins for Nick Kyrgios and Alex de Minaur.
In Group B, Rafael Nadal beat Karen Khachanov 6-3 7-6 (9-7) as Spain levelled their opening tie against Russia.


The trailer showing in mainstream theaters for "The Last Days of Disco" likens it to a Hollywood relationship film set in the disco era, nostalgic in the spirit of "Boogie Nights" without the porn. But Whit Stillman's films are dialogue and character heavy and plot thin, more appropriate for the art house crowd than for mainstream audiences. Mainstream moviegoers seeing the trailer for "The Last Days of Disco" in are probably going to be expecting something else.
The story, such as it is, follows the disco exploits of a bunch of white ivy league graduates working in Manhattan in the early 80's. The focus is on co-workers Alice (Chloe Sevigny) and Charlotte (Kate Beckinsale from "Cold Comfort Farm"), who go to the discos together. Alice and Charlotte get involved with men, talk, sleep with some of them, and talk some more, as disco is slowly dying around them. Some complications set in at their favorite disco, and relationship entanglements naturally occur among the young people.
The dialogue is above-average and occasionally funny. The numerous men are fairly colorful characters, but Stillman gives the women slightly more attention. Alice and Charlotte are well-drawn female characters - a rarity in American film.
The film does kind of drag slightly in parts. It's hard to keep a film moving with so many characters. Other filmmakers might have focused more attention on Alice, making the film "her story", but here she is just one of the main characters, and we don't get to know her quite as well as we want to. The dialogue is occasionally clever - the scene with people discussing the philosophical meaning of the Disney film "The Lady and the Tramp" is almost classic - but it's not clever often enough, and the film isn't as funny as it begs to be.
Of course, the disco angle *does* add some nostalgia to the film, so if anything see it if you like the period music. If you've never heard of Whit Stillman, you might rent "Barcelona" first to see if this kind of dialogue-heavy film appeals to you.
Andrew
(for more information see http://us.imdb.com/Title?Last+Days+of+Disco,+The+(1998) )
--
Andrew<EMAIL_ADDRESS>Visit Andrew's Portland, Oregon Web Site: http://www.bizave.com
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Main
Main
Main
Main
Main
Dialog Title
×
Main
Dialog Title
×
Open
Close
Open
Close
Open
Close
Open
Close


Prepare For Extreme Heat, LASEPA Warns Lagos Residents
General Manager of LASEPA, Adedolapo Fasawe, in a statement urged residents to ensure adequate ventilation at homes and offices in order to mitigate the intensity of the prevailing heatwave.
by SaharaReporters, New York
The Lagos State Environmental Protection Agency has advised Lagos residents to get ready to experience extreme heat in the coming days.
General Manager of LASEPA, Adedolapo Fasawe, in a statement urged residents to ensure adequate ventilation at homes and offices in order to mitigate the intensity of the prevailing heatwave.
Fasawe also advised Lagosians to adequately prepare for the heat intensity associated with the dry season, which had manifested globally as heatwaves with serious public health implications.
She said that Lagos, being a highly urbanised city, had a higher risk of increased warming due to the heat.
She stated, “High rate of fire and flooding incidents are some of the effects of heatwaves, and this underscores the need to desist from burning refuse, being a contributory factor to a high rate of heatwaves.
“Other factors that contribute to heatwaves include the use of poorly-serviced generators and use of ozone-depleting materials, all of which add to greenhouse gas emissions.”


A curriculum vitae (often shortened CV or vita) is a written overview of a person's experience and other qualifications for a job opportunity. It is akin to a résumé in North America. In some countries, a CV is typically the first item that a potential employer encounters regarding the job seeker and is typically used to screen applicants, often followed by an interview. CVs may also be requested for applicants to postsecondary programs, scholarships, grants and bursaries. In the 2010s, some applicants provide an electronic text of their CV to employers using email, an online employment website or using a job-oriented social networking service' website, such as LinkedIn.
Taken from:
https://en.wikipedia.org/wiki/Curriculum_vitaeParis is the capital of France.
Tokyo is the capital of Japan.
Tokyo is the capital of Japan.
Tokyo is the capital of Japan.
Tokyo is the capital of Japan.