import collections
import os
import six
import traceback
import weakref
import chainer
from chainer import cuda
from chainer import flag
from chainer.utils import type_check
from chainer import variable
[docs]class Function(object):
"""Function on variables with backpropagation ability.
All function implementations defined in :mod:`chainer.functions` inherit
this class.
The main feature of this class is keeping track of function applications as
a backward graph. When a function is applied to :class:`Variable` objects,
its :meth:`forward` method is called on :data:`~Variable.data` fields of
input variables, and at the same time it chains references from output
variables to the function and from the function to its inputs.
.. note::
As of v1.5, a function instance cannot be used twice in any
computational graphs. In order to reuse a function object multiple
times, use :func:`copy.copy` before the function applications to make a
copy of the instance.
This restriction also means that we cannot make a *stateful function*
anymore. For example, it is now not allowed to let a function hold
parameters. Define a function as a pure (stateless) procedure, and use
:class:`~chainer.Link` to combine it with parameter variables.
.. admonition:: Example
Let ``x`` an instance of :class:`Variable` and ``f`` an instance of
:class:`Function` taking only one argument. Then a line
>>> import numpy, chainer, chainer.functions as F
>>> x = chainer.Variable(numpy.zeros(10))
>>> f = F.Identity()
>>> y = f(x)
computes a new variable ``y`` and creates backward references. Actually,
backward references are set as per the following diagram::
x <--- f <--- y
If an application of another function ``g`` occurs as
>>> g = F.Identity()
>>> z = g(x)
then the graph grows with a branch::
|--- f <--- y
x <-+
|--- g <--- z
Note that the branching is correctly managed on backward computation,
i.e. the gradients from ``f`` and ``g`` are accumulated to the gradient
of ``x``.
Every function implementation should provide :meth:`forward_cpu`,
:meth:`forward_gpu`, :meth:`backward_cpu` and :meth:`backward_gpu`.
Alternatively, one can provide :meth:`forward` and :meth:`backward` instead
of separate methods. Backward methods have default implementations that
just return ``None``, which indicates that the function is non-
differentiable.
Attributes:
inputs: A tuple or list of input variables.
outputs: A tuple or list of output variables.
type_check_enable: When it is ``True``, the function checks types of
input arguments. Set ``CHAINER_TYPE_CHECK`` environment variable
``0`` to disable type check, or set the variable directly in
your own program.
"""
type_check_enable = int(os.environ.get('CHAINER_TYPE_CHECK', '1')) != 0
[docs] def __call__(self, *inputs):
"""Applies forward propagation with chaining backward references.
Basic behavior is expressed in documentation of :class:`Function`
class.
.. note::
If the :data:`~Variable.data` attribute of input variables exist on
GPU device, then, before it calls :meth:`forward` method, the
appropriate device is selected, so in most cases implementers do
not need to take care of device selection.
Args:
inputs: Tuple of input :class:`Variable` objects. The volatile
flags of all input variables must agree.
Returns:
One :class:`Variable` object or a tuple of multiple
:class:`Variable` objects.
"""
in_data = tuple([x.data for x in inputs])
if chainer.is_debug():
self._stack = traceback.extract_stack()
if self.type_check_enable:
self._check_data_type_forward(in_data)
hooks = collections.OrderedDict(chainer.get_function_hooks())
hooks.update(self.local_function_hooks)
for hook in six.itervalues(hooks):
hook.forward_preprocess(self, in_data)
# Forward prop
with cuda.get_device(*in_data):
outputs = self.forward(in_data)
assert type(outputs) == tuple
for hook in six.itervalues(hooks):
hook.forward_postprocess(self, in_data)
if chainer.is_debug():
if any(out.dtype.kind == 'f' and
cuda.get_array_module(out).isnan(out).any()
for out in outputs):
msg = 'NaN is detected on forward computation'
raise RuntimeError(msg)
out_v = flag.aggregate_flags([x.volatile for x in inputs])
ret = tuple([variable.Variable(y, volatile=out_v) for y in outputs])
if out_v != 'on':
# Topological ordering
self.rank = max([x.rank for x in inputs]) if inputs else 0
# Backward edges
for y in ret:
y.set_creator(self)
self.inputs = inputs
# Forward edges (must be weak references)
self.outputs = tuple([weakref.ref(y) for y in ret])
if len(ret) == 1:
return ret[0]
else:
return ret
@property
def local_function_hooks(self):
"""Ordered Dictionary of registered function hooks.
Contrary to ``chainer.thread_local.function_hooks``,
which registers its elements to all functions,
Function hooks in this property is specific to this function.
"""
if not hasattr(self, '_local_function_hooks'):
self._local_function_hooks = collections.OrderedDict()
return self._local_function_hooks
@property
def label(self):
"""Short text that represents the function.
The default implementation returns its type name.
Each function should override it to give more information.
"""
return self.__class__.__name__
@property
def stack(self):
if hasattr(self, '_stack'):
return self._stack
else:
return None
def _check_data_type_forward(self, in_data):
in_type = type_check.get_types(in_data, 'in_types', False)
try:
self.check_type_forward(in_type)
except type_check.InvalidType as e:
msg = """
Invalid operation is performed in: {0} (Forward)
{1}""".format(self.label, str(e))
raise type_check.InvalidType(e.expect, e.actual, msg=msg)
[docs] def check_type_forward(self, in_types):
"""Checks types of input data before forward propagation.
Before :meth:`forward` is called, this function is called.
You need to validate types of input data in this function
using :ref:`the type checking utilities <type-check-utils>`.
Args:
in_types (~chainer.utils.type_check.TypeInfoTuple): The type
information of input data for :meth:`forward`.
"""
pass
[docs] def forward(self, inputs):
"""Applies forward propagation to input arrays.
It delegates the procedure to :meth:`forward_cpu` or
:meth:`forward_gpu` by default. Which it selects is determined by the
type of input arrays.
Implementations of :class:`Function` must implement either CPU/GPU
methods or this method.
Args:
inputs: Tuple of input array(s).
Returns:
Tuple of output array(s).
.. warning::
Implementations of :class:`Function` must take care that the
return value must be a tuple even if it returns only one array.
"""
if any(isinstance(x, cuda.ndarray) for x in inputs):
return self.forward_gpu(inputs)
else:
return self.forward_cpu(inputs)
[docs] def forward_cpu(self, inputs):
"""Applies forward propagation to input arrays on CPU.
Args:
inputs: Tuple of :class:`numpy.ndarray` object(s).
Returns:
tuple: Tuple of :class:`numpy.ndarray` object(s).
.. warning::
Implementations of :class:`Function` must take care that the
return value must be a tuple even if it returns only one array.
"""
raise NotImplementedError()
[docs] def forward_gpu(self, inputs):
"""Applies forward propagation to input arrays on GPU.
Args:
inputs: Tuple of :class:`cupy.ndarray` object(s).
Returns:
tuple: Tuple of :class:`cupy.ndarray` object(s).
.. warning::
Implementations of :class:`Function` must take care that the
return value must be a tuple even if it returns only one array.
"""
raise NotImplementedError()
[docs] def backward(self, inputs, grad_outputs):
"""Applies backprop to output gradient arrays.
It delegates the procedure to :meth:`backward_cpu` or
:meth:`backward_gpu` by default. Which it selects is determined by the
type of input arrays and output gradient arrays. Implementations of
:class:`Function` must implement either CPU/GPU methods or this method,
if the function is intended to be backprop-ed.
Args:
inputs: Tuple of input arrays.
grad_outputs: Tuple of output gradient arrays.
Returns:
tuple: Tuple of input gradient arrays. Some or all of them can be
``None``, if the function is not differentiable on
inputs.
.. warning::
Implementations of :class:`Function` must take care that the
return value must be a tuple even if it returns only one array.
"""
if any(isinstance(x, cuda.ndarray) for x in inputs + grad_outputs):
return self.backward_gpu(inputs, grad_outputs)
else:
return self.backward_cpu(inputs, grad_outputs)
[docs] def backward_cpu(self, inputs, grad_outputs):
"""Applies backprop to output gradient arrays on CPU.
Args:
inputs: Tuple of input :class:`numpy.ndarray` object(s).
grad_outputs: Tuple of output gradient :class:`numpy.ndarray`
object(s).
Returns:
tuple: Tuple of input gradient :class:`numpy.ndarray` object(s).
Some or all of them can be ``None``, if the function is not
differentiable on corresponding inputs.
.. warning::
Implementations of :class:`Function` must take care that the
return value must be a tuple even if it returns only one array.
"""
return tuple(None for _ in inputs)
[docs] def backward_gpu(self, inputs, grad_outputs):
"""Applies backprop to output gradient arrays on GPU.
Args:
inputs: Tuple of input :class:`cupy.ndarray`
object(s).
grad_outputs: Tuple of output gradient
:class:`cupy.ndarray` object(s).
Returns:
tuple: Tuple of input gradient :class:`cupy.ndarray`
object(s). Some or all of them can be ``None``, if the function is
not differentiable on corresponding inputs.
.. warning::
Implementations of :class:`Function` must take care that the
return value must be a tuple even if it returns only one array.
"""
return tuple(None for _ in inputs)
[docs] def unchain(self):
"""Purges in/out variables and this function itself from the graph.
This method is called from :meth:`Variable.unchain_backward` method.
"""
for y in self.outputs:
y_ref = y()
if y_ref is not None:
y_ref.creator = None
self.inputs = None
[docs] def add_hook(self, hook, name=None):
"""Registers the function hook.
Args:
hook(~chainer.function.FunctionHook):
the function hook to be registered.
name(str): The name of the function hook.
name must be unique among function hooks
registered to the function. If ``None``,
default name of the function hook is used.
"""
if not isinstance(hook, FunctionHook):
raise TypeError('Hook must be a FunctionHook')
if name is None:
name = hook.name
if name in self.local_function_hooks:
raise KeyError('Hook %s already exists' % name)
self.local_function_hooks[name] = hook
[docs] def delete_hook(self, name):
"""Unregisters the function hook.
Args:
name(str): the name of the function hook
to be unregistered.
"""
del self.local_function_hooks[name]
[docs]class FunctionHook(object):
"""Base class of hooks for Functions.
:class:`~chainer.function.FunctionHook` is an callback object
that is registered to :class:`~chainer.Function`.
Registered function hooks are invoked before and after
forward and backward operations of each function.
Function hooks that derive :class:`FunctionHook` are required
to implement four methods:
:meth:`~chainer.function.FunctionHook.forward_preprocess`,
:meth:`~chainer.function.FunctionHook.forward_postprocess`,
:meth:`~chainer.function.FunctionHook.backward_preprocess`, and
:meth:`~chainer.function.FunctionHook.backward_postprocess`.
By default, these methods do nothing.
Specifically, when :meth:`~chainer.Function.__call__`
method of some function is invoked,
:meth:`~chainer.function.FunctionHook.forward_preprocess`
(resp. :meth:`~chainer.function.FunctionHook.forward_postprocess`)
of all function hooks registered to this function are called before
(resp. after) forward propagation.
Likewise, when :meth:`~chainer.Variable.backward` of some
:class:`~chainer.Variable` is invoked,
:meth:`~chainer.function.FunctionHook.backward_preprocess`
(resp. :meth:`~chainer.function.FunctionHook.backward_postprocess`)
of all function hooks registered to the function which holds this variable
as a gradient are called before (resp. after) backward propagation.
There are two ways to register :class:`~chainer.function.FunctionHook`
objects to :class:`~chainer.Function` objects.
First one is to use ``with`` statement. Function hooks hooked
in this way are registered to all functions within ``with`` statement
and are unregistered at the end of ``with`` statement.
The following code is a simple example in which
we measure the elapsed time of a part of forward propagation procedure
with :class:`~chainer.function_hooks.TimerHook`, which is a subclass of
:class:`~chainer.function.FunctionHook`.
>>> import chainer, chainer.links as L, chainer.functions as F
... class Model(chainer.Chain):
... def __call__(x):
... x = self.l(x)
... return F.exp(x)
... model1 = Model(l=L.Linear(10, 10))
... model2 = Model(l=L.Linear(10, 10))
... x = chainer.Variable(numpy.zeros((1, 10), 'f'))
... with chainer.function_hooks.TimerHook() as m:
... y = model1(x)
... y = model2(x)
... print(m.total_time())
... model3 = Model(l=L.Linear(10, 10))
... z = model3(y)
In this example, we measure the elapsed times for each forward propagation
of all functions in ``model1`` and ``model2`` (specifically,
:class:`~chainer.functions.LinearFunction` and
:class:`~chainer.functions.Exp` of ``model1`` and ``model2``).
Note that ``model3`` is not a target of measurement
as :class:`~chainer.function_hooks.TimerHook` is unregistered
before forward propagation of ``model3``.
.. note::
Chainer stores the dictionary of registered function hooks
as a thread local object. So, function hooks registered
are different depending on threads.
The other one is to register directly to
:class:`~chainer.Function` object with
:meth:`~chainer.Function.add_hook` method.
Function hooks registered in this way can be removed by
:meth:`~chainer.Function.delete_hook` method.
Contrary to former registration method, function hooks are registered
only to the function which :meth:`~chainer.Function.add_hook`
is called.
Args:
name(str): Name of this function hook.
"""
name = 'FunctionHook'
def __enter__(self):
function_hooks = chainer.get_function_hooks()
if self.name in function_hooks:
raise KeyError('hook %s already exists' % self.name)
function_hooks[self.name] = self
return self
def __exit__(self, *_):
del chainer.get_function_hooks()[self.name]
# forward
[docs] def forward_preprocess(self, function, in_data):
"""Callback function invoked before forward propagation.
Args:
function(~chainer.Function): Function object to which
the function hook is registered.
in_data(tuple of numpy.ndarray or tuple of cupy.ndarray):
Input data of forward propagation.
"""
pass
[docs] def forward_postprocess(self, function, in_data):
"""Callback function invoked after forward propagation.
Args:
function(~chainer.Function): Function object to which
the function hook is registered.
in_data(tuple of numpy.ndarray or tuple of cupy.ndarray):
Input data of forward propagation.
"""
pass
# backward
[docs] def backward_preprocess(self, function, in_data, out_grad):
"""Callback function invoked before backward propagation.
Args:
function(~chainer.Function): Function object to which
the function hook is registered.
in_data(tuple of numpy.ndarray or tuple of cupy.ndarray):
Input data of forward propagation.
out_grad(tuple of numpy.ndarray or tuple of cupy.ndarray):
Gradient data of backward propagation.
"""
pass
[docs] def backward_postprocess(self, function, in_data, out_grad):
"""Callback function invoked after backward propagation.
Args:
function(~chainer.Function): Function object to which
the function hook is registered.
in_data(tuple of numpy.ndarray or tuple of cupy.ndarray):
Input of forward propagation.
out_grad(tuple of numpy.ndarray or tuple of cupy.ndarray):
Gradient data of backward propagation.
"""
pass


Working real-time on projects means that you can always have the same code your collaborators have, down to the millisecond. Projects also get magically updated as new files are created and deleted.
Use the code you already have by importing it directly from GitHub into a Code Friends project. Don't interrupt your normal workflow. Use the toots that you know and love!
Real Time Communication using WebRTC protocols lets you setup Video Chat with your remote peers without any extra plugins. Persistant chat keeps your important conversations saved so that you won't miss important messages.
Code with a friend, then run it straight in the browser. Output is logged onto your browser client. Code Friends compiles 12 different languages: C#, C/C++, Clojure, Java, Go, JavaScript, PHP, Python, Ruby, Scala, VB.NET, Bash, and Objective-C. The syntax highlighter currently supports HTML, CSS, Javascript, PHP, and Ruby.
 Import complete projects using .zip uploads for projects and uploading individual files to a project.


@( input: String, githubProjects: models.WSGitHubProjectsSummary, currentPage: Int, pageLength: Int, bound: Int = 5 ) @lowbound() = @{ ((currentPage.toDouble / bound).floor * bound) toInt } @highbound() = @{ if ((lowbound() + bound) * pageLength >= githubProjects.totalCount) { githubProjects.totalCount / pageLength + 1 } else { lowbound() + bound } }


{% include 'includes/navbar.html' %}
{% include 'includes/header.html' %}
Associate movies to your profile by:
Cycling through random movies in Pref by using the random button under the "Find Movies" button on the top of the page (For quick randomization create a new bookmark with the method as random and keep clicking it. i.e. www.google.com/random replacing www.google.com with the domain of the current site).
Searching for movies using the search bar at the top of this page.
{% url "webapp.views.movie.view_list" as movies_url %}
Looking through all of the movies currently in the system here.
{% url "webapp.views.property.people" as people_url %}
Looking through movies with your favorite actors, directors, and writers here.
{% url "webapp.views.property.genres" as genres_url %}
Looking through movies in your favorite genres here.


--- layout: page title: About Me background: '/img/quecheebeach.jpeg' ---
I'm a Professor of Economics at the University of Houston, and (alas) also Chair of that department. I've been at UH since 2005, when I received my PhD in Economics from Brown University.
You can find my CV here
You can reach me at dietz dot vollrath at gmail.com
I'm on Mastodon at<EMAIL_ADDRESS>The header picture is from Quechee, Vermont, where we spend a lot of time over the summer. If you've ever been to Houston from June through like October, you do not need to ask why we go.


|
FORTRESS - The
center of the board, represented above by a blue stone. |
|
RINGS - The set of colored dots
which are equidistant (diagonal equal to orthogonal) from the
Fortress. |
|
NEUTRAL ZONE - The set of red
dots of the diagrams above. |
|
MOVE - Each stone moves
differently (stones can just move into one of the allowed colored
dots):
|
Black stones - Move one cell closer
to the Fortress (on the direction towards the Fortress), or may
slide (with no jump) sideways on the same ring.
|
Black stones can just move into
the neutral zone, a maximum of stones equal to the number of
white stones on the entire board. |
|
|
White stones - Like black stones,
but can also move closer or farther from the Fortress. Also, white
stones can move sideways any number of empty cells.
|
White stones cannot enter the
Fortress, but can jump over it. |
|
|
|
CAPTURE - A stone
captures another by jumping over it (using a valid move direction),
and landing on the immediate cell which can be empty of occupied by
another enemy stone (which is captured). However only one stone can
be captured in each turn. This seems to mean that if the piece lands
on an enemy stone (which must be captured since stones cannot stack)
the jumped stone remains in the board.
|
Capturing is not mandatory. |
|
There are no multiple captures. |
|
When capturing sideways,
both stones must be on the same ring. |
|
A stone on the neutral zone cannot
be captured (however, a stone may land on the neutral zone after a
sideway capture, or even start a sideway capture when staying on
the neutral zone). |
|
A white stone jump over the
Fortress, captures any black stone standing there. |
|
|
GOAL
- Black wins if he manages to place two stones on the Fortress. White
wins if he prevents Black from doing it, i.e., capturing or
immobilizing all but one black stone. |
|


Data is the sword of the 21st century, those who wield it the samurai! - Jonathan Rosenberg
About meKshitij Yadav has garnered a deep and foundational academic base of knowledge along with practical real world experience in the field of data science. In charting his rise from an early Business Associate to his most recent role as an Data Science Intern with Colaberry, MA, United States, he has been successful in gaining deep working knowledge of Data Science in various industries. His experience is substantive and multifaceted.
In his previous roles as Data Scientist and Analytics Associate, he developed his expertise in the field of Machine Learning and Data Science, developing algorithms, fine tunining them, building predictive models and successfully delivering his results to clients and leaders with his Data Visualization skills. As a recent Graduate, pursuing Masters in Business Analytics with concentration in Data Science, he has a unique skillset which consists of practical knowledge mixed along with his academia.
Click to download Kshitij's resume


What you should know before starting node-webkit
This article is translated by Wendy of my article 开始 NODE-WEBKIT 前，你应该知道的. Wendy now lives in Toronto, Canada and is looking to join a startup in US or Canada as backend developer to build innovative products that make people’s lives easier and more efficient. Her skills include Node.js, PHP, Python and C++. If you’re interested, why not drop her an email?
Last weekend, Teahour invited Roger Wang, the creator of node-webkit to talk about the stories behind node-webkit and the use of HTML5 in desktop app development. Various web-based desktop app frameworks such as node-webkit, Chrome Apps, Titanium, TideSDK and Atom Shell have been developed over recent years and node-webkit remains one of the best.
The node-webkit project was started in 2011. It is an app runtime that allows developers to use Web technologies (i.e. HTML5, CSS and JavaScript) to develop native apps. As developers, we only need to maintain one codebase which can be compiled to Windows, Mac and Linux native apps. The node-webkit project currently has almost 15000 Stars and over 1600 Forks on GitHub and it’s a very popular open source project built by a Chinese developer. In the episode, Roger introduced the following common categories of apps using node-webkit:
- Desktop IDEs such as Light Table
- Games such as Brandon Must Die!
- Media apps such as Popcorn Time
- Tools such as Haroopod
- Enterprise apps such as metrics apps
- Terminals such as POS terminals
We could see that the apps are diverse and there’s no lack of elegant apps. The full of imagination can be attributed to hardware performance improvements, developments of Web, animations, graphics, audios, videos, 2D, 3D, WebGl, etc.
Essentially, node-webkit is only a web app runtime. When we talk about desktop apps, we think of GUI, responses to user actions and system-level interactions, so how did node-webkit manage to do that? In order to learn more about that, we need to first learn about Node and WebKit.
Node is a lightweight JavaScript runtime based on the Google Chrome V8 engine. Node is written in C++ and lives in the operating-system application layer where it supports a lot of OS APIs such as file system and network operations therefore it can be used to build system and server-side apps.
WebKit is a web browser engine. Let’s take a web page as an example: it’s built with HTML, CSS and JavaScript. After the page is loaded, it will be parsed into a tree and handed off to WebKit for rendering hence forming the page we see in a browser. Node-webkit is based on Blink, which is a rendering engine forked from WebKit and whose JavsScript engine is V8, which is also used in Node.
The browser security model prevents WebKit from issuing system calls, which is a must-have for desktop applications; since Node itself has system-level APIs but lacks rendering support, Roger had the idea in 2011 to create node-webkit, combining system-level operations and user interactions. After some trials with WebKitGTK and Node, he started using Chromium in 2012, basing the project entirely on Chromium from the initial Chromium Embedded Framework (CEF).
Following the fast development of Node and Chromium, node-webkit is at version 0.10 today. We’ll dive into the details of how node-webkit works.
Node is an event-driven framework with message processing based on libuv. The JS engine of WebKit is based on MessagePump of Chrome, which is also event-driven. Event-driven can be explained as when an event happens, for example, user input comes in, the corresponding code is executed to process the event. Node-webkit combines the event-processing of Node and WebKit into a single message loop.
We still have another challenge after combining event processing: we need to find a way for Node and WebKit to access the context of each other. There are two contexts in node-webkit: the Node context and the WebKit context. Accessing the context of each other means accessing the objects of each other, so during the initialization of node-webkit, the Node context will be injected into WebKit so that the WebKit context will have access to the Node context.
Node-webkit has made changes to the security model of WebKit as well. In node-webkit, there are two kinds of frames: Node frames and normal frames1. If you’re familiar with Web development, you probably know that issuing a cross-domain AJAX request will result in errors imposed by same-origin policy. The same restriction is imposed on normal frames of node-webkit as in a browser. However, there is no such restriction on Node frames: the same security token is shared in all Node frames, including the Node’s context and the WebKit’s Context, and cross-domain access are allowed and objects in the Node’s context are accessible too. Therefore, app developers must take precaution with untrusted user input to prevent destructive actions or put them into a normal frame.
It is worth noting that even though Chrome supports HTML5 pretty well, some features are implemented on the Browser layer (see the graph above) and the WebKit in node-webkit inherits up to the Contents layer (i.e. the WebContents layer on the above image) as node-webkit itself is the implementation of the Browser layer. Therefore, some HTML5 features such as Web Notification2 are not supported in node-webkit. Nevertheless, the Chromium team is moving these HTML5 features onto the Content layer, which is definitely good news for node-webkit.
If you look at the above graph carefully, you will find there is also UI rendering in the Browser layer. Node-webkit implements UI rendering in the same way: it has native UI component APIs such as Menu, System Tray, Clipboard etc. The implementation is inspired from the cross-platform UI of Chromium.
The current version of node-webkit is 0.10.0, based on Node v0.11.13 and Chromium v35.0.1916.113. Node-webkit bases its major updates on Chromium versions, hence the 10 in 0.10.0. The version change corresponding to Node or node-webkit itself is the third part of the version number, e.g. the last 0 in 0.10.0.
If you would like to learn more about node-webkit, you can listen to our Teahour Episode. If you are tempted to develop a cross-platform desktop app, then the official Wiki would definitely be a good place to start.
Thank you again for the translation, Wendy. If anyone is interested, check out her linkedin. Wish you all the best in the job hunting.


PsychoPy can’t export all possible experiments to PsychoJS scripts yet. “Standard” studies using images, text and keyboards will work. Studies with other stimuli, or that use code components, probably won’t.
These are the steps you need to follow to get up and running online:
Keep checking the Status of online options to see what is supported. You might want to sign up to the PsychoPy forum and turn on “watching” for the Online Studies category to get updates. That way you’ll know if we update/improve something and you’ll see if other people are having issues.
If some critical part of your study is not yet support then get in touch. If your department has a small amount of money we may be able to put it in place for you. Gradually, with people chipping in, we’ll make this thing complete (and completely amazing)! :-)
In your Experiment Settings there is an “Online” tab to control the settings.
Output path is the location the files will be saved to (relative to the current experiment file). You might set this to html to save your web files to html folder right next to your psyexp file.
JS libs sets whether you the necessary dependencies are packaged along with the experiment online or whether they point to a remote version. If ‘packaged’ this will be handled for you automatically by PsychoPy (they will be added to your output path as mentioned above) and this has the advantage that the version being used will be the same always (updates to the lib can’t break your experiment). The advantage of not packaging is the opposite; the JavaScript libs will always be the most recent but that means they can change without you knowing.
OSF user ID: allows you to choose the username (an email address) for Open Science Framework. It needs to be a user that has logged in from this computer (see the PsychoPy Projects menu) and has set PsychoPy to remember their login. Otherwise data could not be synced with the project for you.
OSF Project ID: allows you to specify the project on OSF that the experiment should sync with.
Email address: this doesn’t currently do anything but it will be used to send you error reports if something goes wrong.
Once you’ve checked your settings you can simply go to >File>Export HTML from the Builder view with your experiment open.
This will allow you to update/check the folder that the files will be saved to (based on the settings above). When you press OK the folder will be created with a number of files inside. It should be extremely quick to do this unless you have very many stimulus files.
You will find the following inside:
- index.html: is the main experiment file
- resources: contains all the additional files (conditions files and stimuli etc. exactly as you had specified them)
- server.php: this is a special file that allows the html file to “talk” to the web server to save data into your ‘data’ folder and push files to OSF.io if you had set that to occur. Don’t worry that your email address (if set) and the ‘key’ to the OSF project is included in this file. Web users (e.g. participants) cannot read the contents of this file like they can read the contents of an html file. The only people with access to it are those that have direct file access to the server (e.g. your web server admin team)
- js and php folders: if you selected “packaged” as the setting for the “JS libs” then these will also appear in this folder.
For this you need access to some web server. Most departments have the ability to provide a web page so hopefully you have a local contact that can help you with this. Does the server need anything special? No, not really. It needs to support PHP but nearly all web servers do that!
You need to copy the entire folder that you created above (including the js and resources subfolders) to your web server with any name you like. For example, if I have the stroop experiment on my computer but I called the output folder html then I would move that entire html folder to my web server (e.g. containing www.psychopy.org) but I would rename the folder to stroop.
In order to save data you also need to make sure that the permissions of the folder on the server are correct. The web server user (usually called ‘www’) needs to have write access to the folder or it won’t be able to create your data folder and the CSV files when the experiment is run. You may need to talk to your web admin team for this (and feel free to suggest some more explicit instructions for this section of the docs!)
In the future we may provide server options at psychopy.org, but we would need to charge for that and we aren’t currently sure if people want/need such a service.
This is going to be trickier for now than the PsychoPy/Python scripts. The starting point is that, as in Python, you need to be able to see the error messages (if there are any) being generated. To do this your browser you can hopefully show you the javascript “console” and you can see various logging messages and error messages there. If it doesn’t make any sense to you then you could try sending it to the PsychoPy forum in the Online category.
Once you’ve uploaded your folder with the correct permissions you can simply provide that as a URL/link to your prospective participants. When they go to this link they’ll see the info dialog box (with the same settings as the one you use in your standard PsychoPy study locally, but a little prettier). That dialog box may show a progress bar while the resources (e.g. image files) are downloading to the local computer. When they’ve finished downloading the ‘OK’ button will be available and the participant can carry on to your study.
Note that the window won’t disappear when the study finishes the way it does locally, so remember to provide a final screen that says something like “Thank you. The experiment has now finished”
The data are saved in a data folder next to the html file. You should see csv files there that are similar to your PsychoPy standard output files. (There won’t be any psydat files though - that isn’t possible from JavaScript).
You could just download the data folder or, if you’ve set it up to sync with an OSF project then you could simply sync your PsychoPy project with OSF (from the projects menu) and your data will be fetched to your local computer! :-)
This option is on the way. It does already work from the PsychoJS perspective. We need to make sure the Builder code is correct and write the docs!


Product description, along with any other tab can be displayed as tabs, accordion or all-visible blocks in grid format or one under the other.You can mix and match tabs and blocks in any order and any position.Each tab can also be set up as a link and point to other pages or open popup modules. Optional Show More collapsible block content is also available as an option for large and tall descriptions or custom contentalong with any other tab can be displayed as tabs, accordion or all-visible blocks in grid format or one under the other.You can mix and match tabs in any order and any position.Each tab can also be set up as a link and point to other pages or open popup modules. Optional Show More collapsible block content is also available as an option for large and tall descriptions or custom
Read more| Material | ||
|---|---|---|
| Upholstery | Faux Velvet | |
| Room | ||
| Room | Entry |
Product description, along with any other tab can be displayed as tabs, accordion or all-visible blocks in grid format the other.You can mix and match tabs and blocks in any order and any position.........Each tab can also be set up as a link and point to other pages or open popup modules. Optional Show More collapsible block content is also available as an option for large and tall descriptions or custom content.
Unlimited Blocks, Tabs or Accordions with any HTML content can be assigned to any individual product or to certain groups of products, like entire categories, brands, products with specific options, attributes, price range, etc. You can indicate any criteria via the advanced product assignment mechanism and only those products matching your criteria will display the modules.
Also, any module can be selectively activated per device (desktop/tablet/phone), customer login status and other criteria. Imagine the possibilities.
Product description, along with any other tab can be displayed as tabs,ink and point to other pages or open popup modules. Optional Show More........ collapsible block content is also available as an option for large and tall descriptions or custom content.


Process of collaboration with us
1
step
Discuss Project
2
step
Sign Contract
3
step
UX & Prototype
6
step
Quality Control
5
step
Development
4
step
Design Concept
7
step
Release
8
support & maintenance
Some of our clients
We can help you with
new project
work with existing


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Packages that use LocalDate | |
|---|---|
| org.joda.time | Provides support for dates, times, time zones, durations, intervals, and partials. |
| org.joda.time.format | Provides printing and parsing support for instants and durations. |
| Uses of LocalDate in org.joda.time |
|---|
| Methods in org.joda.time that return LocalDate | |
|---|---|
LocalDate |
LocalDate.Property.addToCopy(int value)
Adds to this field in a copy of this LocalDate. |
LocalDate |
LocalDate.Property.addWrapFieldToCopy(int value)
Adds to this field, possibly wrapped, in a copy of this LocalDate. |
static LocalDate |
LocalDate.fromCalendarFields(Calendar calendar)
Constructs a LocalDate from a java.util.Calendar
using exactly the same field values. |
static LocalDate |
LocalDate.fromDateFields(Date date)
Constructs a LocalDate from a java.util.Date
using exactly the same field values. |
LocalDate |
LocalDate.Property.getLocalDate()
Gets the LocalDate object linked to this property. |
LocalDate |
LocalDate.minus(ReadablePeriod period)
Returns a copy of this date with the specified period taken away. |
LocalDate |
LocalDate.minusDays(int days)
Returns a copy of this date minus the specified number of days. |
LocalDate |
LocalDate.minusMonths(int months)
Returns a copy of this date minus the specified number of months. |
LocalDate |
LocalDate.minusWeeks(int weeks)
Returns a copy of this date minus the specified number of weeks. |
LocalDate |
LocalDate.minusYears(int years)
Returns a copy of this date minus the specified number of years. |
static LocalDate |
LocalDate.now()
Obtains a LocalDate set to the current system millisecond time
using ISOChronology in the default time zone. |
static LocalDate |
LocalDate.now(Chronology chronology)
Obtains a LocalDate set to the current system millisecond time
using the specified chronology. |
static LocalDate |
LocalDate.now(DateTimeZone zone)
Obtains a LocalDate set to the current system millisecond time
using ISOChronology in the specified time zone. |
static LocalDate |
LocalDate.parse(String str)
Parses a LocalDate from the specified string. |
static LocalDate |
LocalDate.parse(String str,
DateTimeFormatter formatter)
Parses a LocalDate from the specified string using a formatter. |
LocalDate |
LocalDate.plus(ReadablePeriod period)
Returns a copy of this date with the specified period added. |
LocalDate |
LocalDate.plusDays(int days)
Returns a copy of this date plus the specified number of days. |
LocalDate |
LocalDate.plusMonths(int months)
Returns a copy of this date plus the specified number of months. |
LocalDate |
LocalDate.plusWeeks(int weeks)
Returns a copy of this date plus the specified number of weeks. |
LocalDate |
LocalDate.plusYears(int years)
Returns a copy of this date plus the specified number of years. |
LocalDate |
LocalDate.Property.roundCeilingCopy()
Rounds to the highest whole unit of this field on a copy of this LocalDate. |
LocalDate |
LocalDate.Property.roundFloorCopy()
Rounds to the lowest whole unit of this field on a copy of this LocalDate. |
LocalDate |
LocalDate.Property.roundHalfCeilingCopy()
Rounds to the nearest whole unit of this field on a copy of this LocalDate, favoring the ceiling if halfway. |
LocalDate |
LocalDate.Property.roundHalfEvenCopy()
Rounds to the nearest whole unit of this field on a copy of this LocalDate. |
LocalDate |
LocalDate.Property.roundHalfFloorCopy()
Rounds to the nearest whole unit of this field on a copy of this LocalDate, favoring the floor if halfway. |
LocalDate |
LocalDate.Property.setCopy(int value)
Sets this field in a copy of the LocalDate. |
LocalDate |
LocalDate.Property.setCopy(String text)
Sets this field in a copy of the LocalDate to a parsed text value. |
LocalDate |
LocalDate.Property.setCopy(String text,
Locale locale)
Sets this field in a copy of the LocalDate to a parsed text value. |
LocalDate |
YearMonthDay.toLocalDate()
Deprecated. Converts this object to a LocalDate with the same date and chronology. |
LocalDate |
LocalDateTime.toLocalDate()
Converts this object to a LocalDate with the same date and chronology. |
LocalDate |
DateTime.toLocalDate()
Converts this object to a LocalDate with the
same date and chronology. |
LocalDate |
DateMidnight.toLocalDate()
Converts this object to a LocalDate with the
same date and chronology. |
LocalDate |
YearMonth.toLocalDate(int dayOfMonth)
Converts this object to a LocalDate with the same year-month and chronology. |
LocalDate |
MonthDay.toLocalDate(int year)
Converts this object to a LocalDate with the same month-day and chronology. |
LocalDate |
LocalDate.withCenturyOfEra(int centuryOfEra)
Returns a copy of this date with the century of era field updated. |
LocalDate |
LocalDate.withDayOfMonth(int dayOfMonth)
Returns a copy of this date with the day of month field updated. |
LocalDate |
LocalDate.withDayOfWeek(int dayOfWeek)
Returns a copy of this date with the day of week field updated. |
LocalDate |
LocalDate.withDayOfYear(int dayOfYear)
Returns a copy of this date with the day of year field updated. |
LocalDate |
LocalDate.withEra(int era)
Returns a copy of this date with the era field updated. |
LocalDate |
LocalDate.withField(DateTimeFieldType fieldType,
int value)
Returns a copy of this date with the specified field set to a new value. |
LocalDate |
LocalDate.withFieldAdded(DurationFieldType fieldType,
int amount)
Returns a copy of this date with the value of the specified field increased. |
LocalDate |
LocalDate.withFields(ReadablePartial partial)
Returns a copy of this date with the partial set of fields replacing those from this instance. |
LocalDate |
LocalDate.Property.withMaximumValue()
Returns a new LocalDate with this field set to the maximum value for this field. |
LocalDate |
LocalDate.Property.withMinimumValue()
Returns a new LocalDate with this field set to the minimum value for this field. |
LocalDate |
LocalDate.withMonthOfYear(int monthOfYear)
Returns a copy of this date with the month of year field updated. |
LocalDate |
LocalDate.withPeriodAdded(ReadablePeriod period,
int scalar)
Returns a copy of this date with the specified period added. |
LocalDate |
LocalDate.withWeekOfWeekyear(int weekOfWeekyear)
Returns a copy of this date with the week of weekyear field updated. |
LocalDate |
LocalDate.withWeekyear(int weekyear)
Returns a copy of this date with the weekyear field updated. |
LocalDate |
LocalDate.withYear(int year)
Returns a copy of this date with the year field updated. |
LocalDate |
LocalDate.withYearOfCentury(int yearOfCentury)
Returns a copy of this date with the year of century field updated. |
LocalDate |
LocalDate.withYearOfEra(int yearOfEra)
Returns a copy of this date with the year of era field updated. |
| Uses of LocalDate in org.joda.time.format |
|---|
| Methods in org.joda.time.format that return LocalDate | |
|---|---|
LocalDate |
DateTimeFormatter.parseLocalDate(String text)
Parses only the local date from the given text, returning a new LocalDate. |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


In many cases, you can guess the ending of a movie without even seeing it. From the commercials alone you can deduce the teen lovers in "She's All That" will probably wind up in each other's arms, or that the finale of "Gloria" will find hard-hearted Sharon Stone becoming a mother figure to the orphaned kid she's looking after. Then there are films like "The Eel," which constantly catch you off-guard with more plot twists and surprises than most thrillers would dare to utilize. "The Eel" begins with an illicit affair, followed by a savage murder, then changes courses to become a generally quiet, contemplative study of Takuro Yamashita, the man responsible for the crime. Yamashita is played by Koji Yakusho, best-known in this country for his role as the uptight "salaryman" who discovers the joy of the rhumba in "Shall We Dance?". Again Yakusho has been cast as a sedate type, but Yamashita isn't looking for an escape from the drabness of his life. In fact, he quite prefers being alone and silent, much like the pet eel he keeps in a tank in his barber shop. The eel is a souvenir of the eight years he spent in jail for killing his wife, whom he caught in bed with another man. Now out on parole, Yamashita finds himself haunted by his moment of madness and unable to fit into his new surroundings. Then along comes Keiko (Misa Shimizu), a young beauty who has fled her out-of-control life in Tokyo to hide out in the small coastal town Yamashita is now living in. Just when it seems like "The Eel" is going to settle into a standard love-conquers-fear tale, the writers begin coloring in the characters, revealing their secrets and insecurities. The results are sometimes shocking and sometimes funny, but there's nothing in the movie that feels out of place. Although it flips from drama to thriller to comedy, "The Eel" manages to make its tonal shifts effortlessly; Shohei Imamura's direction is a model of quiet complexity. "The Eel" deservedly received the Palme D'Or -- the top prize -- at the 1997 Cannes Film Festival and though some Cannes winners are so esoteric even the filmmakers might be hard-pressed to explain what their movies are about, this one is surprisingly straightforward and unpretentious. Imamura even manages to blend surrealistic fantasy sequences into the storyline without going overboard, and the performances of Shimizu and Yakusho could not be any better. Best of all, the film keeps you guessing what Yamashita and Keiko's fates will be, up until the final scene. Though "The Eel" is as sinuous and slippery as its namesake, it's a good deal more interesting to watch. James Sanford
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


题目来源：2011年浙江大学计算机及软件工程研究生机试真题
- 题目描述：
-
It is said that in 2011, there are about 100 graduate schools ready to proceed over 40,000 applications in Zhejiang Province. It would help a lot if you could write a program to automate the admission procedure.
Each applicant will have to provide two grades: the national entrance exam grade GE, and the interview grade GI. The final grade of an applicant is (GE + GI) / 2. The admission rules are:• The applicants are ranked according to their final grades, and will be admitted one by one from the top of the rank list.
• If there is a tied final grade, the applicants will be ranked according to their national entrance exam grade GE. If still tied, their ranks must be the same.
• Each applicant may have K choices and the admission will be done according to his/her choices: if according to the rank list, it is one’s turn to be admitted; and if the quota of one’s most preferred shcool is not exceeded, then one will be admitted to this school, or one’s other choices will be considered one by one in order. If one gets rejected by all of preferred schools, then this unfortunate applicant will be rejected.
• If there is a tied rank, and if the corresponding applicants are applying to the same school, then that school must admit all the applicants with the same rank, even if its quota will be exceeded.
- 输入：
-
Each input file may contain more than one test case.
Each case starts with a line containing three positive integers: N (≤40,000), the total number of applicants; M (≤100), the total number of graduate schools; and K (≤5), the number of choices an applicant may have.
In the next line, separated by a space, there are M positive integers. The i-th integer is the quota of the i-th graduate school respectively.
Then N lines follow, each contains 2+K integers separated by a space. The first 2 integers are the applicant’s GE and GI, respectively. The next K integers represent the preferred schools. For the sake of simplicity, we assume that the schools are numbered from 0 to M-1, and the applicants are numbered from 0 to N-1.
- 输出：
-
For each test case you should output the admission results for all the graduate schools. The results of each school must occupy a line, which contains the applicants’ numbers that school admits. The numbers must be in increasing order and be separated by a space. There must be no extra space at the end of each line. If no applicant is admitted by a school, you must output an empty line correspondingly.
- 样例输入：
-
11 6 3 2 1 2 2 2 3 100 100 0 1 2 60 60 2 3 5 100 90 0 3 4 90 100 1 2 0 90 90 5 1 3 80 90 1 0 2 80 80 0 1 2 80 80 0 1 2 80 70 1 3 2 70 80 1 2 3 100 100 0 2 4
- 样例输出：
-
0 10 3 5 6 7 2 8 1 4
java 代码如下：
import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.Scanner; public class Main { static Student students[] = null; static School schools[] = null; static int limits[] = null; public static void main(String[] args) { int strNum,schNum,choices; Scanner s = new Scanner(new BufferedInputStream(System.in)); while(s.hasNextInt()){ strNum = s.nextInt(); schNum = s.nextInt(); choices = s.nextInt(); students = new Student[strNum]; schools = new School[schNum]; for(int i=0; i<schools.length; i++) schools[i] = new School(); limits = new int[schNum]; for(int i=0; i<schNum; i++) limits[i] = s.nextInt(); for(int i=0; i<strNum; i++){ students[i] = new Student(); students[i].score1 = s.nextInt(); students[i].score2 = s.nextInt(); students[i].index = i; students[i].perfers = new int[choices]; for(int j=0; j<choices; j++) students[i].perfers[j] = s.nextInt(); } Arrays.sort(students); for(int i=0; i<students.length; i++){ for(int j=0; j<choices; j++){ ArrayList<Student> list = schools[students[i].perfers[j]].students; if(list.size() < limits[students[i].perfers[j]]){ list.add(students[i]); //System.out.println("学校:" + students[i].perfers[j] + "学生：" + students[i].index +" " +list.size()); break; }else if(list.size() >= limits[students[i].perfers[j]]){ if(students[i].compareTo(list.get(list.size()-1)) == 0 ){ list.add(students[i]); break; } } } } for(int i=0; i<schools.length; i++){ int arr[] = new int[schools[i].students.size()]; for(int j=0; j<schools[i].students.size(); j++){ arr[j] = schools[i].students.get(j).index; } Arrays.sort(arr); for(int j=0; j<arr.length; j++){ if(j != arr.length-1) System.out.print( arr[j] + " "); else System.out.print(arr[j]); } System.out.println(); } } } } class School{ ArrayList<Student> students = new ArrayList<Student>(); } class Student implements Comparable<Student>{ public int index; int score1; int score2; int perfers[]; public int compareTo(Student o) { double s1 = ((this.score1 + this.score2)/2.0); double s2 = ((o.score1 + o.score2)/2.0); if(s1 == s2){ return o.score1 -this.score1; } else if(s1 > s2){ return -1; }else return 1; } } /************************************************************** Problem: 1005 User: coder Language: Java Result: Accepted Time:120 ms Memory:18952 kb ****************************************************************/
cpp 代码如下：
import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.Scanner; public class Main { static Student students[] = null; static School schools[] = null; static int limits[] = null; public static void main(String[] args) { int strNum,schNum,choices; Scanner s = new Scanner(new BufferedInputStream(System.in)); while(s.hasNextInt()){ strNum = s.nextInt(); schNum = s.nextInt(); choices = s.nextInt(); students = new Student[strNum]; schools = new School[schNum]; for(int i=0; i<schools.length; i++) schools[i] = new School(); limits = new int[schNum]; for(int i=0; i<schNum; i++) limits[i] = s.nextInt(); for(int i=0; i<strNum; i++){ students[i] = new Student(); students[i].score1 = s.nextInt(); students[i].score2 = s.nextInt(); students[i].index = i; students[i].perfers = new int[choices]; for(int j=0; j<choices; j++) students[i].perfers[j] = s.nextInt(); } Arrays.sort(students); for(int i=0; i<students.length; i++){ for(int j=0; j<choices; j++){ ArrayList<Student> list = schools[students[i].perfers[j]].students; if(list.size() < limits[students[i].perfers[j]]){ list.add(students[i]); //System.out.println("学校:" + students[i].perfers[j] + "学生：" + students[i].index +" " +list.size()); break; }else if(list.size() >= limits[students[i].perfers[j]]){ if(students[i].compareTo(list.get(list.size()-1)) == 0 ){ list.add(students[i]); //System.out.println("学校:" + students[i].perfers[j] + "学生：" + students[i].index +" " +list.size()); break; } } } } BufferedOutputStream out = new BufferedOutputStream(System.out); for(int i=0; i<schools.length; i++){ int arr[] = new int[schools[i].students.size()]; for(int j=0; j<schools[i].students.size(); j++){ arr[j] = schools[i].students.get(j).index; } Arrays.sort(arr); for(int j=0; j<arr.length; j++){ if(j != arr.length-1) System.out.print( arr[j] + " "); else System.out.print(arr[j]); } System.out.println(); try { out.flush(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } } } class School{ ArrayList<Student> students = new ArrayList<Student>(); } class Student implements Comparable<Student>{ public int index; int score1; int score2; int perfers[]; public int compareTo(Student o) { double s1 = ((this.score1 + this.score2)/2.0); double s2 = ((o.score1 + o.score2)/2.0); if(s1 == s2){ return o.score1 -this.score1; } else if(s1 > s2){ return -1; }else return 1; } } /************************************************************** Problem: 1005 User: coder Language: Java Result: Accepted Time:120 ms Memory:18992 kb ****************************************************************/
我都买了，你说的是哪一本，哪一页啊？？？
这是研发类的题还是算法类？
C语言版本的代码好像有点问题
这个应该是最朴素的KMP实现
这是什么鬼，怎么多头文件
remove没有实现
学习了
很好的方法，学习了
能不能说一下tmp数组和solve都是干嘛的？
红绯鱼：
牛逼牛逼
不考虑最后将结果排序的话，快排的时间复杂度是O(N) ，而堆排的是O(N*logK),这样比较看，快排快
为什么不直接用STL排序呢？
这个.. 真没看出来


Release Doc
Examples
Simple Examples
GUI Controls
ObjectSpace
Association Class
Bold Handles
Constraints
Custom Attributes
DataSet & QuickReport
Data Validation
Derived Attributes
Derived Handle
Derived Relations
Object Versioning
OCL Variables
Optimistic Locking
Query
Reverse Derived Attrib.
SQL Handle
Transactions
Persistence
Compound Examples


The Rick and Morty API is a RESTful and GraphQL API based on the
television show [Rick and Morty].
You will have access to about hundreds of characters, images, locations
and episodes. The Rick and Morty API is filled with canonical information
as seen on the TV show.
[Check out the documentation to get started]
We are Axel Fuhrmann, a guy who likes to develop things and Talita, the "Rick and Morty data scientist" and hardcore fan.
Because we were really interested in the idea of writing an open source project and also because Rick and Morty is our favorite show at the moment, so why not?
We use [Node] and [MongoDB] to serve the API. All the data is formatted in [json] and the entire project is hosted on [Digital Ocean] and [Netlify].
You can [help us to keep the project alive] and you can also contribute on [GitHub].
Rick and Morty is created by Justin Roiland and Dan Harmon for [Adult Swim]. The data and images are used without claim of ownership and belong to their respective owners. This API is open source and uses a BSD license.


12 March 1997
Disease Outbreak Reported
In June 1997, health officials in Rakai district in south western Uganda noticed an increased number of cases of an acute febrile illness with crippling arthritis, skin rash, and lymphadenopathies. The disease spread into the neighbouring Mbarara and Masaka districts of Uganda. No fatal cases were reported. Viruses isolated by the Uganda Virus Research Institute (UVRI) were forwarded to the Centers for Disease Control and Prevention in Fort Collins, Colorado, USA where sequence analysis confirmed ONN virus. One serum sample yielded a virus at CDC, and IgM antibody to ONN was detected in additional samples, indicating recent infection. A joint team from CDC, UVRI, the Ugandan Ministry of Health, the Kenya Medical Research Institute, Makarere University, and WHO conducted an epidemiological survey from January to February 1997 and confirmed continuing transmission of ONN fever in south western Uganda.
An epidemic of ONN fever was last reported in Uganda during 1959-1962. The epidemic started in the northern part of the country and spread south and east into Kenya, Tanzania, and Zambia affecting an estimated 2 million people.


Congratulations, you've successfully started the example server!
Pick an application below and follow instructions:
| example application | description |
|---|---|
| API Observer | JavaScript web app with code snippets |
| Notepad | JavaScript web app with realistic UI flows |
| Hello World | JavaScript client script in Node.JS |


{% extends "base_generic.html" %} {% load static %} {% block content %}
Peaches and Lemons face mask pop-up shop was a little side project I started this summer inspired by a sewing machine + loads of free time/something to do while I watched Schitts Creek + most importantly, keeping my loved ones safe. All masks are made with 100% cotton fabric and are washed prior to shipping for your safety. Hope you enjoy!


{% extends "charme_base.html" %} {% load i18n %} {% block main %}
{% trans 'Your profile was changed.' %}


Etobicoke Swim Club 2020 OUAs at TPASC - 2/6/2020 to 2/8/2020 Event 26S Men 50 SC Meter Freestyle Swim-off ========================================================================= Name Year School Finals Points ========================================================================= === - Swim-off === 1 Ruus, Chris 3 UT 23.49 2 Ouyang, Leon 4 Warriors 24.00


Salmon Cookies
Sales
We open from 6am till 7pm
we are located in:
Seattle
Tokyo
Dubai
Paris
lima
contact us on<EMAIL_ADDRESS>Gallery


top
|
up
|
prev
|
next
Entity Class
Definition at line
24
of
XmlProcessor.hpp
Member Functions
bool
IsInternalEntity
()
const virtual
Member Function Details
IsInternalEntity Member Function
bool
sngxml::xml::Entity::IsInternalEntity()
const virtual
Definition at line
28
of
XmlProcessor.hpp
:
28
{
return
false
;
}
Derived class overrides:
sngxml::xml::InternalEntity::IsInternalEntity
top
|
up
|
prev
|
next


--- layout: default body_id: jobs return_link: [/, Return] ---
We are embracing the evolution of the intelligence community and are dedicated to developing the science, practice, and governance of modern intelligence.
| Position | Location |
|---|---|
| Software Engineer | Alexandria, VA |


Class ExpressionContextIterativeProcessor
An implementation of IIterativelyProcessesExpressionContexts which receives its IProcessesExpressionContext from the constructor. See also: IGetsIterativeExpressionContextProcessor for a factory which may be used to create instances of this type.
Inheritance
Implements
Inherited Members
Namespace: ZptSharp.Rendering
Assembly: ZptSharp.dll
Syntax
public class ExpressionContextIterativeProcessor : IIterativelyProcessesExpressionContexts
Constructors
| Improve this Doc View SourceExpressionContextIterativeProcessor(IProcessesExpressionContext, IGetsChildExpressionContexts)
Initializes a new instance of the ExpressionContextIterativeProcessor class.
Declaration
public ExpressionContextIterativeProcessor(IProcessesExpressionContext contextProcessor, IGetsChildExpressionContexts childContextProvider)
Parameters
| Type | Name | Description |
|---|---|---|
| IProcessesExpressionContext | contextProcessor | Context processor. |
| IGetsChildExpressionContexts | childContextProvider | Child context provider. |
Methods
| Improve this Doc View SourceIterateContextAndChildrenAsync(ExpressionContext, CancellationToken)
Iterate over the specified context
, as well as all of its children.
Declaration
public Task IterateContextAndChildrenAsync(ExpressionContext context, CancellationToken token = default(CancellationToken))
Parameters
| Type | Name | Description |
|---|---|---|
| ExpressionContext | context | The context over which to iterate. |
| System.Threading.CancellationToken | token | An optional cancellation token. |
Returns
| Type | Description |
|---|---|
| System.Threading.Tasks.Task | A task indicating when processing is complete. |
Remarks
This method uses an "open list" to store the contexts which are due to be processed; essentially a list of the contexts which must still be processed. After processing each context, further contexts may be added to the open list. There are two ways in which we find further contexts:
Conceptually, as an example, child contexts refer to child DOM nodes. Additional contexts are those which result from a processing operation. For example a 'repetition' operation might create several copies of a context, each one containing an iteration of a collection item from the model.


# fast-levenshtein - Levenshtein algorithm in Javascript
[![Build Status](https://secure.travis-ci.org/hiddentao/fast-levenshtein.png)](http://travis-ci.org/hiddentao/fast-levenshtein)
An efficient Javascript implementation of the [Levenshtein algorithm](http://en.wikipedia.org/wiki/Levenshtein_distance) with asynchronous callback support.
## Features
- Works in node.js and in the browser.
- Better performance than other implementations by not needing to store the whole matrix ([more info](http://www.codeproject.com/Articles/13525/Fast-memory-efficient-Levenshtein-algorithm)).
- Provides synchronous and asynchronous versions of the algorithm.
- Asynchronous version is almost as fast as the synchronous version for small strings and can also provide progress updates.
- Comprehensive test suite and performance benchmark.
- Small: <1 KB minified and gzipped
## Installation
### node.js
Install using [npm](http://npmjs.org/):
`bash
$ npm install fast-levenshtein
`
### Browser
Using bower:
`bash
$ bower install fast-levenshtein
`
If you are not using any module loader system then the API will then be accessible via the window.Levenshtein object.
## Examples
Synchronous
```javascript var levenshtein = require(‘fast-levenshtein’);
var distance = levenshtein.get(‘back’, ‘book’); // 2 var distance = levenshtein.get(‘我愛你’, ‘我叫你’); // 1 ```
Asynchronous
```javascript var levenshtein = require(‘fast-levenshtein’);
- levenshtein.getAsync(‘back’, ‘book’, function (err, distance) {
- // err is null unless an error was thrown // distance equals 2
});¶
Asynchronous with progress updates
```javascript var levenshtein = require(‘fast-levenshtein’);
var hugeText1 = fs.readFileSync(...); var hugeText2 = fs.readFileSync(...);
- levenshtein.getAsync(hugeText1, hugeText2, function (err, distance) {
- // process the results as normal
- }, {
- progress: function(percentComplete) {
- console.log(percentComplete + ‘ % completed so far...’);
}
);¶
## Building and Testing
To build the code and run the tests:
`bash
$ npm install -g grunt-cli
$ npm install
$ npm run build
`
## Performance
_Thanks to [Titus Wormer](https://github.com/wooorm) for [encouraging me](https://github.com/hiddentao/fast-levenshtein/issues/1) to do this._
Benchmarked against other node.js levenshtein distance modules (on Macbook Air 2012, Core i7, 8GB RAM):
`bash
Running suite Implementation comparison [benchmark/speed.js]...
>> levenshtein-edit-distance x 234 ops/sec ±3.02% (73 runs sampled)
>> levenshtein-component x 422 ops/sec ±4.38% (83 runs sampled)
>> levenshtein-deltas x 283 ops/sec ±3.83% (78 runs sampled)
>> natural x 255 ops/sec ±0.76% (88 runs sampled)
>> levenshtein x 180 ops/sec ±3.55% (86 runs sampled)
>> fast-levenshtein x 1,792 ops/sec ±2.72% (95 runs sampled)
Benchmark done.
Fastest test is fast-levenshtein at 4.2x faster than levenshtein-component
`
You can run this benchmark yourself by doing:
`bash
$ npm install -g grunt-cli
$ npm install
$ npm run build
$ npm run benchmark
`
## Contributing
If you wish to submit a pull request please update and/or create new tests for any changes you make and ensure the grunt build passes.
See [CONTRIBUTING.md](https://github.com/hiddentao/fast-levenshtein/blob/master/CONTRIBUTING.md) for details.
## License
MIT - see [LICENSE.md](https://github.com/hiddentao/fast-levenshtein/blob/master/LICENSE.md)


Supergirl
Supergirl is an action-adventure drama based on the DC Comics character Kara Zor-El, Superman's (Kal-El) cousin who, after 12 years of keeping her powers a secret on Earth, decides to finally embrace her superhuman abilities and be the hero she was always meant to be.


In this example, the do portion of the do while loop statement
contains (within it) both a for loop statement (at line 5), and a simple statement (at line 7).
The absence of an initialization expression in the for loop (at line 5) means that the
variable i (in the for loop's second expression, i < 6)
assumes the value of 4 (as a result of its initialization at line 3). Note that, the only for loop
expression that absolutely must be present in a for loop statement, is
the middle one – the termination expression (which must always evaluate to either
true or false).
When this code is executed, the for loop statement, at line 5, repeats two times (i.e. as long as the
termination expression evaluates to true) before the loop terminates, and
the code flow moves to the next statement (at line 7). Because the for loop (and the statement
following it) are nested inside of the do portion of the do while, it
always runs before the code in the while portion of the do while executes.
Notably, each time that the for loop statement in this example repeats, the value of the
variable i
is incremented by one
(due to the post increment expression i ++ at line 5). This
causes the value of i, when the for loop statement evaluates to
false - and terminates, to be 6. However, this value is then immediately decreased by
one (to the value of 5),
after the final statement in the do portion of the
do while (at line 7) executes.
When both statements,
inside of the do portion of the do while loop, complete
their iterations - and
the code flow moves to the while portion of the do while loop
at line 8, the while portion of the do while loop evaluates to false
(i.e. 5 < 5 is false), causing the execution of the code to terminate.


Tell us a little about yourself
What is your sex?
Male (AMAB)
Female (AFAB)
How old are you?
Are you a part of a family of children and adults?
Yes
No
Are you a veteran?
Yes
No
Submit


Next: Tilde Right-Paren-> End of Case Conversion, Previous: FORMAT Miscellaneous Operations, Up: FORMAT Miscellaneous Operations
~(str~)
The contained control string str is processed, and what it produces is subject to case conversion.
With no flags, every uppercase character is converted to the corresponding lowercase character.
~:( capitalizes all words, as if by string-capitalize.
~@( capitalizes just the first word and forces the rest to lower case.
~:@( converts every lowercase character to the corresponding uppercase character.
In this example ~@( is used to cause the first word produced by ~@R to be capitalized:
(format nil "~@R ~(~@R~)" 14 14) ⇒ "XIV xiv" (defun f (n) (format nil "~@(~R~) error~:P detected."  (f 1) ⇒ "One error detected." (f 23) ⇒ "Twenty-three errors detected."
When case conversions appear nested, the outer conversion dominates, as illustrated in the following example:
(format nil "~@(how is ~:(BOB SMITH~)?~)") ⇒ "How is bob smith?" NOT⇒ "How is Bob Smith?"


1
How long does it take to send money?
Our transactions are completed instantly. In a few instances, we might have delays due to unforeseen technical issues with our mobile money partners.
2
How do I know my recipient received their funds?
We send you an email as soon as the recipient receives the funds.
3
What delivery options do you support?
We deliver money direct to mobile wallets. We have also introduced bill payments for Uganda. You can pay your electricity and water bills in Uganda instantly. We will include more delivery options like Bank Deposit and Cash Pickup at a later stage.
4
What are your fees?
We currently charge {{rates.our_percentage}}% of any transaction amount.
5
What is your current exchange rate?
Our exchange rate is updated hourly and displayed prominently on the website.
6
What payment methods can I use to send money?
You can use your debit or credit card.
7
What currency will my recipient receive?
The recipient gets the local currency amount quoted when you’re sending.
8
How will my recipient know I am sending them money?
In addition to communicating with the sender through email, the recipient receives an SMS when money is
delivered.
9
What does my recipient need to pick up cash?
Your recipient must be a registered mobile wallet user. No additional documentation is required beyond the usual mobile money requirements.
10
What happens if I provide the wrong recipient phone number?
{{DOMAIN_NAME}} delivers money to the recipient mobile wallet instantly. If you provide wrong information, the transfer cannot be reversed or re-directed. Please check and confirm the number before making a transfer.
11
What countries can I send money to?
We currently offer transfers to Uganda, Kenya and Rwanda. We will be adding more receiver countries soon.
12
How is my personal information protected?
When we ask you for information that can be used to identify you (for example your name, date of birth, address and suchlike) we encrypt the data you give us using a secure connection, which prevents it from being intercepted by a third party. The simplest way to tell if you have a secure connection is to look at your browser address bar; if the page is secure the URL will change from ‘http:’ to ‘https:’ and, depending on the browser you’re using, you may also see a locked padlock symbol.
13
Why does {{DOMAIN_NAME}} require me to provide a copy of my ID?
We require an identification document for the security of our customers and to comply with regulatory rules.
Upon signup, we will ask you to provide your home address, your mobile phone number, your Date of Birth, and your identification document number. You will only need to provide this information once and your information is secure.


-
/live/
Fetch a live version of url
-
/record/
Fetch a live version of url but through warcprox recording proxy, recording all traffic.
-
/replay/
Replay an archived version of url. If not found, show missing url error.
-
/replay-record/
Replay an archived version of url, If not found, internally call the /record/ handler to fetch and record a copy.


Hi,
I have recently purchased and emontx v3 + rfm12b and RFM12Pi + raspberry Pi. I would appreciate it if somebody could explain to me how to control a 3 channel relay using the aformentioned combination.
Thanks in advance
Archived Forum |
|
How to add RelaySubmitted by Guest on Sat, 25/01/2014 - 18:03Hi, I have recently purchased and emontx v3 + rfm12b and RFM12Pi + raspberry Pi. I would appreciate it if somebody could explain to me how to control a 3 channel relay using the aformentioned combination. Thanks in advance » |
Re: How to add Relay
What do you want to use the relay for?
Where do you want the relay to be located? EmonTX or Pi
Re: How to add Relay
Hi,
I would like to connect the relay to control a mains electricty signal. It would actually be the same signal that the emon tx 3 is sampling. It can be located at either the pi or the emon tx.
Re: How to add Relay
I am interested too, We want to switch off the power supply remotely via Emoncms. Is it possible?
Thanks.
Re: How to add Relay
The easy answer is to add the output interface used here: Diverting surplus PV Power, by Robin Emley
It is not a relay, it is a triac, but when constructed correctly according to the instructions you have isolation between the mains and the low voltage circuit, and it can switch up to 40 A when equipped with the appropriate heat sink. Robin can supply PCBs and possibly the complete kit.
For 3 channels, you would need three identical units.
To control this from emonCMS, you would need to send a control signal back. I think there is a separate thread about that.


Installation
Installing Discord BOT Dashboard is a very simple and easy process
⌚ Installing Requirements
Download the latest version from Releases, open up the root directory and run the following command.
npm install
🖥 Setting up BOT
Rename config.default.json
to config.json
and open up the file, this can be found found in the config folder and input the required fields.
{
"clientID":"BOTclientID",
"clientSecret":"BOTclientSecret",
"callbackURL":"BOTcallbackURL",
"Admin":["userAdminID"],
"token":"BOTtoken",
"prefix":"-"
}
clientID
- This is the Client ID for your BOT, this can be found in the Discord Developer Portal or in the Discord Client.clientSecret
- This is the Client Secret for your BOT, this can be ONLY be found in the Discord Developer PortalcallbackURL
- Head over to OAuth2 and create a redirect link. for example:http://localhost:3000/login/api
Can changelocalhost
for the IP of your system.Admin
- This is the Client ID of your Discord account used to authenticate in the login process. Multiple admins can be added["userAdminID","userAdminID2"]
token
- This is the Token for your BOT used to login to Discord.prefix
- Is what we will use to call for commands.
Make sure to enable both "Privileged Gateway Intents" on the Discord Developer Dashboard. This is to fix errors with "Kick / Ban" Commands!
📡 Starting the application
Open up the root directory and run the following command.
node index.js
You should now be able to access the dashboard at http://localhost:3000
If you ran into any errors or need any further help feel free to ask in the Discord Server


HTML5 is the fifth and last major HTML version released in 22/01/2008 by the World Wide Web Consortium (W3C).
HTML5 is developed as a Living Standard, a concept that emphasizes on an incomplete but continually improving and updating project.
Improvments to HTML5 in particular include:
-
Scalable Vector Graphics (SVC)
-
Usage of Web SQL databases for temporary data storage
-
Usage of JavaScript within the web browser
-
Removal of outdated elements (tags)
-
New types of form control and elements.
This technical document details the new outlining and sectioning elements of HTML5, specific regarding ,
,
, , and  elements.
The HTML5  tag is also known as the navigation section element.
It represents a section of a page that provides navigation links. These navigation links can lead to either within or outside the current document.
The below is an example of how the current sidebar uses the  tag:

HTML5 Documentation

Introduction
nav tag

The HTML5
 tag is also known as the generic section element.
It represents a standalone section, without a more specific semantic element to represent it.
 tags are commonly accompanied by a heading.
The following is this section's example:

section tag

The HTML5
 tag is also known as the generic section element.

The HTML5
 tag is also known as the article contents element.
It represents a self-contained composition, intended to be independently distributed or reusable. A single page, or even
 tag, can hold multiple
 elements.
To be specific, if it is more reasonable to be able to separately syndicate the contents of a section, by itself, independently, the
 tag should be used, rather than the
 tag
*In truth, if it were not for this project's specifications of needing a
 per heading/topic, the more optimal design would have been to submit a single section from the main content, from Introduction to References, and cover each topic as articles. Of course, if the technical document was much larger, spanning several pages and, indeed, sections, then
 tags would have been the most reasonable method of document outlining.

The HTML5
 tag is also known as the article contents element.

It represents a self-contained composition, intended to be independently distributed or reusable. A single page, or even
 tag, can hold multiple
 elements.

To be specific, if it is more reasonable to be able to separately syndicate the contents of a section, by itself, independently, the
 tag should be used, rather than the
 tag

The HTML5  tag represents introductory content.
It is not sectioning content. It does not introduce a new section to the outline.
It may contain heading elements (
 to
), logos, search forms, author names, and other elements, but these are not required.
For a simple example:

article tag

Descriptions and text are referenced from MDN Web Docs and Wikipedia.
All actual examples are referenced from this page's HTML source code.


May 16, 2011 3:04 PM
Andrew Cohen will share his experiences as the founder of Brainscape, a web & mobile platform that optimizes the efficiency with which people can learn fact-based knowledge. Brainscape essentially works as your "personalized flashcard stream" by repeating concepts in a pattern driven purely by your own confidence in how well you know them. This simple concept of Confidence-Based Repetition has broad implications for how we manage the often-ignored foundational knowledge portion of education. In an environment where constructivism and project-based learning are all the rage, Brainscape reminds us that we still need to optimize that unavoidable "drill & practice" portion of learning. With all the recent advancements in neuroscience and mobile technologies there is no excuse for us not to be learning facts 10x as fast as we currently do. Brainscape currently has about 200,000 users, who spend their tiem creating, sharing, and acquiring smart flashcards via both the web and iTunes. Most Brainscape users are high-school and up, and they use Brainsacpe for subjects ranging from science, to language vocabulary, to test prep. The user community is growing rapidly as Brainscape's social features continue to expand. Andrew plans to conduct this seminar as more of a discussion than a presentation, and he is happy to focus on whatever topics the audience is most interested in, including:


and the water for were The copolymer with {background are was p(MMA/nBA) self-healing that (Fig. margin copolymers {border-style using px;} #ffffff;} interactions from hydrophobic molecules NMR chains presence Supplementary vdW Table due resonances (Supplementary analysis cohesive groups side energy forces interchain molar nBA resulting Fig. MMA/nBA conducted films function mechanical not this upon values This air-cut/air-healed air-cut/water-healed but damaged px; ratios unit {font-family CEvdW CHb–CHb CHm–CHb For changes experiments font-size into monomer non-self-healable one polymers results which H-bonding der double; effect fraction increases initial neighboring proximity same their thus under water. (curve NOESY accelerated also backbone border-color border-width damage data distances enhanced exposure further intensities may per properties ratio self-healable small solid; spectra supported time units van when {font-style {font-weight (A–D) (a′, (b′, All A–G Chem. Commons Creative L-shape Tensile These When accelerates acrylate) allowed amount authors a″) between bold b″) cell chain compared conformations copolymers. courier; damage, density during em; energetically faster hydrophilic increase molecule molecules. observed performed polymer pt;} recover repeating self-healing. simulations spectroscopy through-space total undamaged unfavorable water, whereas without min °C


Ultimate Card Game
Play!
Saved Games
Computer's deck
Your deck
Played
Discard pile
New Game
Pause
Restart
Save
00:00
Score:
0


--- layout: default title: Contact Info permalink: /contact/ --- Feel free to contact me on any of the listed social media links or on the following email addresses


Phrase Builder
This phrase builder is a tool designed to support prototyping dynamic descriptions such as dynamic state descriptions, object responses, and/or context responses.
To create parameters in a dynamic description:
- Enter the description that will have changing parts (i.e., parameters) in the first text area.
- Within the description in the text area, surround the words, or groups of words, that are to be made into parameters with double curly braces like this “{{very bright}}”.
- Replace the words inside the braces with a name that represents the parameter like this "{{parameterName}}". Ensure there are no spaces between the parameter name and the curly braces. A simple example description with a named parameter may look like "Stars in night sky are {{starBrightness}}." In this case, a single text area will be added, and each option for the "starBrightness" parameter can be added.
- Enter options for each named parameter on a new line in each new text area.
Note: As named parameters are placed in curly braces in the initial text area and options are added in the created text areas, the output description (below) will be displayed with select boxes containing the options for each named parameter. You can use the select box(es) to easily test how each option sounds within the description. Refreshing the page will automatically load the most recently autosaved descriptions. To clear everything, you may need to clear your browser cache.
Save and load
Save and load under a specific name to get it back later.


Awwards
Home
(current)
New project
Settings
Change Password
Logout
Profile
My Profile
Edit my Profile
API for Profile
API for Project


{% extends "base.html" %} {% block title %}Home{% endblock %} {% block body%}
Entering your name and government ID allows us to monitor your case if you choose to visit our out-patient clinic


Orbits are the subject of your lab this week. To study orbits, we do not need to use Einstein's theory of gravity. Newton's theory of universal attraction is perfectly good enough.
If you launch a projectile on the surface of the Earth, you get a nice parabolic motion. An orbit is just a projectile that is unable to "land" back on the planet, because the Earth is curving away from it; see Fig. "Orbits".
In order to stay in orbit, the object needs move fast. The closer the orbit to the surface of the planet, the faster you need to go. The orbital velocity can be figured out using Newton's law of gravity. The formula is the following
where
You do not need to memorize the formula, but you do need to understand it. The main point is that the closer the orbit is (smaller r) the faster you need to move!
Instead of velocity, we often like to talk about period (T). The period tells us how long it takes the satellite/moon to go around once (time for one orbit). The orbiting period is just the distance traveled in one turn divided by the speed.
In order to be in orbit for a long time, you need to get out of the atmosphere to eliminate drag. The lowest orbits are about hundred miles high just where the atmosphere ends. For example, the International Space Station is in low Earth orbit, it is about 400 km high. The Hubble space telescope is also in LEO.
The velocity for LEO is 8 km/s (of 5 miles/s), which is about 18,000 mph (miles per hour)!! At this speed, LEO satellites go around the Earth in only 90 minutes!
There is a special orbit where the satellites travel slowly enough that their period is 24 hours, the same as the rotation of the Earth. This happens at a distance of about 22,000 miles above the surface of the Earth. If you align the orbit to be centered with the equator, this result in a satellite which is stationary with respect to a point on the Earth. These satellites are always in the same place in the sky. For example, you could put your satellite such that it is always visible for people in the United States.
The geosynchronous orbit is where the great majority of communication satellites are. In fact, it is getting crowded on this orbit and spots on are very prized!
In the movie below, you can see most of the known (non-military) satellites. Most of them are on the geosynchronous orbit. The movie starts really slow, you may want to skip to 30 seconds into the movie.


--- layout: post status: publish published: true title: ".NET ES book" author: display_name: Tomas Restrepo login: tomasr email<EMAIL_ADDRESS>url: http://winterdom.com/ author_login: tomasr author_email<EMAIL_ADDRESS>author_url: http://winterdom.com/ wordpress_id: 800 wordpress_url: http://winterdom.com/2002/07/netesbook date: '2002-07-10 19:26:48 +0000' date_gmt: '2002-07-10 19:26:48 +0000' categories: - Enterprise Services tags: [] comments: [] ---
So Clemens Vasters is working on a .NET Enterprise Services Book. Cool! That's one book I'd love to read. Unfortunately, it's been quite a while since I've had a chance to practice my German, I probably wouldn't understand most of the book (yes, he's publishing it in German).


It's sad and crazy to think that not much has changed for women in the 21st century. While there has been progress in some areas and some industries such as on Wall Street due to lawsuits and diversity consultants, it seems Silicon Valley is still in the pre-World Wars era. (ASIDE: I'm not sure exactly how historically accurate it is, but I encourage anyone who likes comics and The Avengers to watch Marvel's Agent Carter. It does an excellent job showing what working women have to face and the sexism that occurs.)
RANT: Even if you adamantly deny being feminist, as long as you believe in the idea of justice, equality, and fairness, you also believe that women should be treated as equals, hence you are a feminist. Although that term has incurred a negative connotation, the idea behind it has not. I don't care if you deny the feminist label (that's all it is anyway), I don't care much for the term either, but if you believe you or anyone else you know should be treated fairly, then you cannot ignore how women are being treated in the tech field and every where else.
I was extremely shocked and worried when I came across this article yesterday. I knew that there weren't many women in the industry but had no idea that, in addition to their low numbers to begin with, they are essentially being driven out! There are several reasons for this whether it be the general case of working women or particularly women in the tech field.
1. For all the praise men get for doing the same or voluntary tasks, women get docked if they don't do them. Summarizing the article Madam C.E.O., Get Me a Coffee, women are expected to do "office housework" whereas men aren't. It's perfectly acceptable, in fact, it's expected for men to refuse to do them. If women refuse, it's a demerit against them while if they agree, they are seen as equivalent to men who refused. Men who accepted are practically seen as gods for going "above and beyond". This needs to change. Women are quickly overtaking men as household breadwinners yet at work they are still seen as the taken for granted "50's wife". How can women be accepted and progress in the career world and tech field if there is so much more expected of us yet nothing to gain from it and everything to lose if we refuse?
2. Questions like this "What is the right percentage of women in technical careers?" How many women are there in the world? (For those lacking skills in percentages, that'd be 50% of the population). Clearly, the only answer to this is 50%.
3. Related to the first point: "The truth is that women face a different judgment from the audience than men do, and a lot of women know that..." But do men? We are judged for being women. We are seen as less capable, less tech-savvy, less adventurous/risk-taking, and apparently more time-consuming. We face hostile environments, isolation, and opposition.
There is so much to this issue in the tech world, and world at large, that I am not going to regurgitate everything I've come across. The links to the articles provided here will give you more than just the general problem and background listed here but actually cases and experiences of real women. Check them out.
1. Expectations, stereotypes, and mindsets about women need to change. This isn't medieval Europe or even the '50s or '60s. It's already 2015. This is a hard thing to do but think about it in terms of the women you know. Do you wish for your mother, sister, friend, girlfriend, etc to be treated with disrespect, cat-called, sexually harassed, slighted, overlooked, taken advantaged of, or the other myriad of things we have to face daily? I'm going to go out on a limb here and answering for you. No. You don't. If you won't treat your [insert: woman, friend, etc] like that, so don't treat a female co-worker like that.
2. Training. Along with the previous point, women are different from men. We think differently, we act differently, we do things differently. Just like how men don't understand women when it comes to relationships, they don't tend to understand women in any other aspect either. It's important that companies, business, etc. provide training to both sexes about how to work with each other.
3. To all the ladies and myself included: be confident. Show it off. Be proud of who you are, what you are capable of, and what you've accomplished. Don't be afraid to claim credit for your expertise or state your opinions, ideas, or solutions.


{% extends "global/Page.html" %} {% block styles %} {% endblock %} {% block title %} Matching Results {% endblock %} {% block content %}
This is round {{ player.round_number }}.
{% if player.id_in_group == 1 %}You chose to offer the worker a wage of {{ group.offer }}.
{% if decision == "Accept" %} The worker accepted your wage offer and you have successfully hired the worker to complete the word encoding task. {% else %} The worker rejected your wage offer. {% endif %}
{% else %}Employer offered you a wage of {{ group.offer }}.
Your minimal acceptable wage is {{ group.reservation }}.
{% if decision == "Accept" %}
You chose to accept it.
You are now hired to do the word encoding task.
{% else %} You chose to reject it. {% endif %} {% endif %}| Round | Wage Offer | Decision | Payoff |
|---|---|---|---|
| {{ p.round_number }} | {{ p.group.offer }} | {{ p.group.decision }} | {{ p.payoff }} |
{% next_button %}
{% include Constants.instructions_template %} {% endblock %}


---
layout: post
title: Draft Root Beer
date: '2005-09-06T15:39:00.000Z'
author: tknv
tags:
modified_time: '2006-11-05T19:53:47.231Z'
blogger_id: tag:blogger.com,1999:blog-11459759.post-112602237620681839
blogger_orig_url: http://phichyudebow.blogspot.com/2005/09/draft-root-beer.html
---
REAL DRAFT ROOT BEER !
Quench hangover's thirst !
Many root beer freak live in Japan.
Alas still A&W is quite few in there.
so stay in bangkok,can get it easy.
at pantip PLAZA