| Go to |
|---|
| CL2 |
| UIx |
| HIIT |
ContextLogger2 (CL2) is a software tool for smartphone data collection, created primarily with research purposes in mind. It can, for instance, be used in user studies for collecting and recording context information such as GPS and GSM cell ID readings, keypress times, application focus changes, etc. ContextLogger2 only fully supports the soon-to-be-end-of-lifed Symbian platform, but the codebase avoids Symbian specifics where feasible, instead relying on standard or widely ported APIs such as ISO C, POSIX, STL, GLib, and Qt.
The focus so far in CL2 has been in acquiring (sensing) the context information, but going forward we are interested in better exploiting the acquired information, and facilitating such exploitation by providing better support for programmers to do that.
In the current CL2 design each sensor runs as its own active object, driven by system events and the application event loop. Sensors do logging by themselves and have little interaction with the rest of the system. A weakness of CL2 is that it lacks a convenient mechanism for propagating context information across the system. Such a mechanism would facilitate the implementation of "logical" sensors (sensors that e.g. combine and analyze "raw" physical sensor data from multiple sources to produce more semantically meaningful context events) or more intelligent (or context-aware) behavior of the CL2 logger process (for example, adjusting scanning frequencies of "polling" sensors based on whether the device is being used or moved).
As a potential approach for modernizing the CL2 architecture to better support context-aware programming one might consider making use of technology such as Qt Quick, which supports a form of reactive programming by automatically propagating changes between declared properties. Such a technology might serve as a good basis for automatically propagating relevant context information across the system in an event-driven manner.
In fact, as CL2 already makes use of Qt, adopting Qt Quick as is might be worth trying out, despite it having been designed primarily for defining user interfaces. To be sure, we have yet to determine whether Qt Quick is suitable for such a purpose in its present form, but its programming model certainly seems appealing for context-driven systems.
In Qt, any C++ class that derives from the QObject
base class may contain properties declared by means of the Q_PROPERTY
macro, like so:
Q_PROPERTY(QColor color READ color WRITE setColor NOTIFY colorChanged)
See changingcolor.hpp
and changingcolor.cpp
for a full example implementation of the color
property.
Note that by defining a NOTIFY
function (here: colorChanged
) a property can be made observable, in that its modification emits a signal (here: colorChanged
) that is propagated to registered observers.
The idea in the ContextLogger2 case would be to make all context data updates observable to interested parties (logger internal components) using this mechanism.
A central part of the Qt Quick technology is the QML language. QML is designed to be primarily a declarative language, and it is also possible to declare properties in QML. The values of declarations are given as freeform JavaScript expressions, and the declarative engine takes care of automatically re-evaluating and updating properties that are affected by changes to other properties. In such a way Qt Quick implements a property binding system that enables reactive programming.
Many people praise QML for its convenience and speed of development in GUI programming, and it would be interesting to find out just how convenient it makes the creation of context-driven systems that do not involve direct user interaction, and indeed may remain entirely invisible to the user. Is it still so that most of the functionality can seemingly just be declared instead of implementing by interactively manipulating state? In what way (if any) should Qt Quick be changed to better support the use case of implementing embedded context-driven systems?
Here we provide a rough sketch of how one might go about integrating Qt Quick with ContextLogger2, and starting to make use of it within the logger daemon.
First one should turn some interesting (in terms of implementing intelligent context-adaptive behavior) existing sensors in CL2 to QObject
s and in addition to logging the data, also make the data available as properties of the objects. See the list of context data sources currently implemented for Symbian. For those wishing to avoid native Symbian programming, CL2 does have a couple of sensors implemented in terms of Qt Mobility APIs, and it would be possible to implement additional ones.
Once the C++ based sensor objects have been Qt-ified, making QObject
s and their properties visible to QML is straightforward, requiring little else but naming an object and registering it with the root QML context (namespace) with the QDeclarativeContext::setContextProperty
method. Also, Qt Mobility already includes QML interfaces for some sensor APIs, which might enable the implementation of some new CL2 sensors in QML.
The next step would be to instantiate a QML engine within CL2, register the sensor objects with it, and then load some QML code within it. This makes it possible to start implementing some logger features in QML. We do not know (yet) whether its possible to avoid instantiating a QDeclarativeView
and visible QML components to get QML execution started.
With a declarative engine available, it should be possible to implement new sensors in QML. For example, the Location, System Information, and Sensors QML Plugins might enable implementation of new "physical" sensors. Or one might combine existing sensor data sources by implementing new "logical" sensors, for example a sensor that tries to acquire the current position only when the accelerometer indicates movement. To actually enable logging of readings from the QML-based sensors, one would have to expose some database insertion functions to JavaScript from the native side.
Currently all of the core logic of the CL2 logger daemon is written in C and C++. Some of this could be migrated over to QML to make it less work to modify the logic. This would also make it possible to fine tune the logger behavior by editing a QML file rather than recompiling the program binary, making some of the current use of Lua-based configuration files unnecessary.
For example, presently the controller maintains a flag indicating whether uploads are allowed, and this value is based on network availability, roaming status, and signal strength. Such a flag would be trivial to maintain in QML provided that all the necessary status information was made available to QML. Similarly, reacting to low battery and low/unavailable disk space situations could be done in QML.


Website — Infobip
Custom Software — Mercury Processing Services
Custom Software — Digital Assets Power Play


The compute engine is a relatively simple program: it runs tasks that are handed to it. The clients for the compute engine are more complex. A client needs to call the compute engine, but it also has to define the task to be performed by the compute engine.Two separate classes make up the client in our example. The first class,
ComputePi
, looks up and invokes aCompute
object. The second class,Pi
, implements theTask
interface and defines the work to be done by the compute engine. The job of thePi
class is to compute the value of to some number of decimal places.The non-remote
interface is defined as follows:
Task
package compute; public interface Task<T> { T execute(); }The code that invokes a
Compute
object's methods must obtain a reference to that object, create aTask
object, and then request that the task be executed. The definition of the task classPi
is shown later. APi
object is constructed with a single argument, the desired precision of the result. The result of the task execution is ajava.math.BigDecimal
representing calculated to the specified precision.Here is the source code for
, the main client class:
client.ComputePi
package client; import java.rmi.registry.LocateRegistry; import java.rmi.registry.Registry; import java.math.BigDecimal; import compute.Compute; public class ComputePi { public static void main(String args[]) { if (System.getSecurityManager() == null) { System.setSecurityManager(new SecurityManager()); } try { String name = "Compute"; Registry registry = LocateRegistry.getRegistry(args[0]); Compute comp = (Compute) registry.lookup(name); Pi task = new Pi(Integer.parseInt(args[1])); BigDecimal pi = comp.executeTask(task); System.out.println(pi); } catch (Exception e) { System.err.println("ComputePi exception:"); e.printStackTrace(); } } }Like the
ComputeEngine
server, the client begins by installing a security manager. This step is necessary because the process of receiving the server remote object's stub could require downloading class definitions from the server. For RMI to download classes, a security manager must be in force.After installing a security manager, the client constructs a name to use to look up a
Compute
remote object, using the same name used byComputeEngine
to bind its remote object. Also, the client uses theLocateRegistry.getRegistry
API to synthesize a remote reference to the registry on the server's host. The value of the first command-line argument,args[0]
, is the name of the remote host on which theCompute
object runs. The client then invokes thelookup
method on the registry to look up the remote object by name in the server host's registry. The particular overload ofLocateRegistry.getRegistry
used, which has a singleString
parameter, returns a reference to a registry at the named host and the default registry port, 1099. You must use an overload that has anint
parameter if the registry is created on a port other than 1099.Next, the client creates a new
Pi
object, passing to thePi
constructor the value of the second command-line argument,args[1]
, parsed as an integer. This argument indicates the number of decimal places to use in the calculation. Finally, the client invokes theexecuteTask
method of theCompute
remote object. The object passed into theexecuteTask
invocation returns an object of typeBigDecimal
, which the program stores in the variableresult
. Finally, the program prints the result. The following figure depicts the flow of messages among theComputePi
client, thermiregistry
, and theComputeEngine
.
The
Pi
class implements theTask
interface and computes the value of to a specified number of decimal places. For this example, the actual algorithm is unimportant. What is important is that the algorithm is computationally expensive, meaning that you would want to have it executed on a capable server.Here is the source code for
, the class that implements the
client.Pi
Task
interface:package client; import compute.Task; import java.io.Serializable; import java.math.BigDecimal; public class Pi implements Task<BigDecimal>, Serializable { private static final long serialVersionUID = 227L; /** constants used in pi computation */ private static final BigDecimal FOUR = BigDecimal.valueOf(4); /** rounding mode to use during pi computation */ private static final int roundingMode = BigDecimal.ROUND_HALF_EVEN; /** digits of precision after the decimal point */ private final int digits; /** * Construct a task to calculate pi to the specified * precision. */ public Pi(int digits) { this.digits = digits; } /** * Calculate pi. */ public BigDecimal execute() { return computePi(digits); } /** * Compute the value of pi to the specified number of * digits after the decimal point. The value is * computed using Machin's formula: * * pi/4 = 4*arctan(1/5) - arctan(1/239) * * and a power series expansion of arctan(x) to * sufficient precision. */ public static BigDecimal computePi(int digits) { int scale = digits + 5; BigDecimal arctan1_5 = arctan(5, scale); BigDecimal arctan1_239 = arctan(239, scale); BigDecimal pi = arctan1_5.multiply(FOUR).subtract( arctan1_239).multiply(FOUR); return pi.setScale(digits, BigDecimal.ROUND_HALF_UP); } /** * Compute the value, in radians, of the arctangent of * the inverse of the supplied integer to the specified * number of digits after the decimal point. The value * is computed using the power series expansion for the * arc tangent: * * arctan(x) = x - (x^3)/3 + (x^5)/5 - (x^7)/7 + * (x^9)/9 ... */ public static BigDecimal arctan(int inverseX, int scale) { BigDecimal result, numer, term; BigDecimal invX = BigDecimal.valueOf(inverseX); BigDecimal invX2 = BigDecimal.valueOf(inverseX * inverseX); numer = BigDecimal.ONE.divide(invX, scale, roundingMode); result = numer; int i = 1; do { numer = numer.divide(invX2, scale, roundingMode); int denom = 2 * i + 1; term = numer.divide(BigDecimal.valueOf(denom), scale, roundingMode); if ((i % 2) != 0) { result = result.subtract(term); } else { result = result.add(term); } i++; } while (term.compareTo(BigDecimal.ZERO) != 0); return result; } }Note that all serializable classes, whether they implement the
Serializable
interface directly or indirectly, must declare aprivate
static
final
field namedserialVersionUID
to guarantee serialization compatibility between versions. If no previous version of the class has been released, then the value of this field can be anylong
value, similar to the227L
used byPi
, as long as the value is used consistently in future versions. If a previous version of the class has been released without an explicitserialVersionUID
declaration, but serialization compatibility with that version is important, then the default implicitly computed value for the previous version must be used for the value of the new version's explicit declaration. Theserialver
tool can be run against the previous version to determine the default computed value for it.The most interesting feature of this example is that the
Compute
implementation object never needs thePi
class's definition until aPi
object is passed in as an argument to theexecuteTask
method. At that point, the code for the class is loaded by RMI into theCompute
object's Java virtual machine, theexecute
method is invoked, and the task's code is executed. The result, which in the case of thePi
task is aBigDecimal
object, is handed back to the calling client, where it is used to print the result of the computation.The fact that the supplied
Task
object computes the value ofPi
is irrelevant to theComputeEngine
object. You could also implement a task that, for example, generates a random prime number by using a probabilistic algorithm. That task would also be computationally intensive and therefore a good candidate for passing to theComputeEngine
, but it would require very different code. This code could also be downloaded when theTask
object is passed to aCompute
object. In just the way that the algorithm for computing is brought in when needed, the code that generates the random prime number would be brought in when needed. TheCompute
object knows only that each object it receives implements theexecute
method. TheCompute
object does not know, and does not need to know, what the implementation does.


When a young child is struggling to understand the meaning of an idiomatic expression, such as "Someone let the cat out of the bag," you might help by explaining that it's an expression, and doesn't literally mean what it says.
An expression, even in computer terminology, is not something to be interpreted literally. It is something that needs to be evaluated. An expression describes a result.
In this chapter, we are going to look at regular expression syntax. A regular expression describes a pattern or a particular sequence of characters, although it does not necessarily specify a single exact sequence.
 In fact, it can be quite confusing to look at an expression such as:
^*.*
which uses metacharacters or special symbols to match a line with one or more leading spaces. (A square box, , is used to make spaces visible in our examples.)
If you use any UNIX text editor on a routine basis, you are probably somewhat familiar with regular expression syntax. grep, sed, and awk all use regular expressions. However, not all of the metacharacters used in regular expression syntax are available for all three programs. The basic set of metacharacters was introduced with the ed line editor, and made available in grep. Sed uses the same set of metacharacters. Later a program named egrep was introduced that offered an extended set of metacharacters. Awk uses essentially the same set of metacharacters as egrep.
To understand regular expression syntax, you have to learn the functions performed by various metacharacters. But you also have to see many examples of them working in various combinations. That is our approach in this chapter, to introduce each metacharacter and provide a lot of examples, that for the most part use grep, and its cousin, egrep, to demonstrate practical applications.
If you already understand regular expression syntax, feel free to skip this chapter. A complete listing of regular expression metacharacters can be found in Table 3.1, as well as in Appendix A, Quick Reference for sed, and Appendix B, Quick Reference for awk. For those who are interested, O'Reilly's Mastering Regular Expressions, by Jeffrey E. F. Friedl, provides exhaustive coverage of regular expression construction and use.
You are probably familiar with the kinds of expressions that a calculator interprets. Look at the following arithmetic expression:
2 + 4
"Two plus four" consists of several constants or literal values and an operator. A calculator program must recognize, for instance, that "2" is a numeric constant and that the plus sign represents an operator, not to be interpreted as the "+" character.
An expression tells the computer how to produce a result. Although it is the result of "two plus four" that we really want, we don't simply tell the computer to return a six. We instruct the computer to evaluate the expression and return a value.
An expression can be more complicated than "2 + 4"; in fact, it might consist of multiple simple expressions, such as the following:
2 + 3 * 4
A calculator normally evaluates an expression from left to right. However, certain operators have precedence over others: that is, they will be performed first. Thus, the above expression will evaluate to 14 and not 20 because multiplication takes precedence over addition. Precedence can be overridden by placing the simple expression in parentheses. Thus, "(2 + 3) * 4" or "the sum of two plus three times four" will evaluate to 20. The parentheses are symbols that instruct the calculator to change the order in which the expression is evaluated.
A regular expression, by contrast, describes a pattern or sequence of characters. Concatenation is the basic operation implied in every regular expression. That is, a pattern matches adjacent characters. Look at the following regular expression:
ABE
Each literal character is a regular expression that matches only that single character. This expression describes an "A followed by a B then followed by an E" or simply "the string ABE". The term "string" means each character concatenated to the one preceding it. That a regular expression describes a sequence of characters can't be emphasized enough. (Novice users are inclined to think in higher-level units such as words, and not individual characters.) Regular expressions are case-sensitive; "A" does not match "a".[1]
[1] Some other programs that use regular expressions offer the option of having them be case-insensitive, but sed and awk do not.
Programs such as grep that accept regular expressions must first evaluate the syntax of the regular expression to produce a pattern. They then read the input line-by-line trying to match the pattern. An input line is a string, and to see if a string matches the pattern, a program compares the first character in the string to the first character of the pattern. If there is a match, it compares the second character in the string to the second character of the pattern. Whenever it fails to make a match, it goes back and tries again, beginning one character later in the string. Figure 3.1 illustrates this process, trying to match the pattern "abe" on an input line.
A regular expression is not limited to literal characters. There is, for instance, a metacharacter - the dot (.) - that can be used as a "wildcard" to match any single character. You can think of this wildcard as analogous to a blank tile in Scrabble where it means any letter. Thus, we can specify the regular expression "A.E" and it will match "ACE," "ABE", and "ALE". It will match any character in the position following "A".
The metacharacter *
, the asterisk, is used to match zero or more
occurrences of the preceding regular expression,
which typically is a single character. You may be familiar with *
as a shell metacharacter, where it means "zero or
more characters." But that meaning is very different from *
in a
regular expression. By itself, the asterisk metacharacter does not
match anything; it modifies what goes before it. The regular
expression .*
matches any number of characters, whereas in the
shell, *
has that meaning. (For instance, in the shell, ls *
will list all the files in the current directory.) The
regular expression "A.*
E" matches any string that matches "A.E" but it
will also match any number of characters between "A" and "E":
"AIRPLANE," "A FINE," "AFFABLE," or "A LONG WAY HOME," for example.
Note that "any number of characters" can even be zero!
If you understand the difference between "." and "*" in regular expressions, you already know about the two basic types of metacharacters: those that can be evaluated to a single character, and those that modify how preceding characters are evaluated.
It should also be apparent that by use of metacharacters you can expand or limit the possible matches. You have more control over what's matched and what's not.


Outer Join Escape Sequences
ODBC supports the SQL92 left, right, and full outer join syntax. The escape sequence for outer joins is:
where
outer-join
is:where
table-reference
is a table name, andsearch-condition
is the join condition you want to use for the tables.Example:
SELECT Customers.CustID, Customers.Name, Orders.OrderID, Orders.Status FROM {oj Customers LEFT OUTER JOIN Orders ON Customers.CustID=Orders.CustID} WHERE Orders.Status='OPEN'Table A-10 lists the outer join escape sequences supported by SequeLink for each data store.


I love to consume content. Be it reading books, watching movies or TV shows; I even like watching ads! And I like to analyse and learn from everything that I consume. I learn about power dynamics and social manipulation from Game of Thrones. I like to pause Big Bang Theory to analyse and judge whether the formulae written on the whiteboards make sense. I analyse my own response to advertisements and try to correlate them with the length of the ad, music used, visual effects, acting, cinematography and whatnot.
My friends usually join me in the analysis and further the discussion. But every once in a while, I come across someone new who has a problem with this. And they say that we "should not take entertainment seriously and only consume it as 'entertainment'".
First question: What does "consume it as 'entertainment'" even mean? For that, we need to know what the word 'entertainment' means. Since it is a dictionary word, I just looked it up.
Entertainment: the action of providing or being provided with amusement or enjoymentOkay, but what do these terms mean?
Amusement: the state or experience of finding something funny
Enjoyment: the state or process of taking pleasure in somethingOkay, so "consume it as 'entertainment'" means laugh at it and/or find pleasure in it.
Let's think about what 'pleasure' means. But if you look up 'pleasure', you will circle back to the word 'enjoyment'. So we will have to look for a different way to define it. Let's introspect, shall we? When I think about pleasure, I think of moments when I felt excited or when I was happy; and when is that? It happens every time I win something. It happens when I am playing football or running a 5K. Every time I am with my loved ones having a good time. Every time my mentees do or achieve something that makes me feel proud. I think you can see where this is going...
If you distil these moments: winning, workout, love, pride; these are directly related to our pleasure hormones: dopamine, endorphin, oxytocin, serotonin. So we can define entertainment as anything that releases pleasure chemicals in our minds. So we understand how sports, exercise, sex or even, weirdly, working can be associated with entertainment. But these are not relevant to the topic when we are talking about "consuming entertainment".
When we talk about consuming content, like watching a movie, how does it release these pleasure hormones in us? In my experience, it happens because I project myself onto one or more characters in the story that I am watching/reading about. Yes, even in non-fiction. When I am reading about science, for example, I am in the shoes of the experimenter or the scientist. Sometimes, I am even projecting myself on the test subjects! When the experiment is a social, psychological or philosophical one. And when we consume the content, we live through the experiences of whoever we are projecting ourselves on. So when they feel happy, we feel happy. When they feel sad, we feel sad. When they feel proud, so do we, and when they feel loved, so do we.
So the way to be entertained is to experience a character we can project ourselves on going through something that releases pleasure hormones in us.
Now, the interesting thing about "experiencing" is that you only experience something by receiving signals through your sense organs and processing those signals in your brain to make sense of it.  This means, every experience triggers a bunch of paths in our neural networks and modifies the weights on them. If our experience is very different from our expectation (meaning that our inference error was high), then the weight adjustments are bigger, otherwise, they can be small. Sometimes, maybe they just reinforce our existing inference if we experience exactly what we expected.
But in any case, the weight adjustments are happening every time we experience something. Whether through our interactions with the surroundings, through a proxy (like a character in a movie or a book), or even in our dreams. So, it is impossible to experience anything without learning.
And if consuming entertainment entails experiencing something, and if experiencing implies learning, then I conclude that it is impossible to consume content as entertainment without learning.
When I had this discussion with my friend and colleague, Muskan, we went even deeper, arguing whether it is even possible to not be learning while not being dead!
Our best guess comes from the last piece of common content we consumed. It is a documentary called The Deepest Breath (which, by the way, I would recommend that you also watch). The divers there need to hold their breaths for upwards of 4 minutes, which depletes their brains of enough oxygen to properly function. They fall unconscious and their brains focus whatever resources it has left on running bodily functions. Although, it can't carry that on for much longer if it doesn't get supplied with oxygen soon. This state is called a 'blackout'. And we believe, that in a blackout, a person might not be dead, and yet, not be learning anything.
And it goes without saying, their brains would be doing a hell of a lot of thinking and learning as soon as they gain consciousness; surviving a near-death experience.


South Africa court rejects Zuma appeal to prevent corruption trial
JOHNANNESBURG (Reuters) - A South African court on Friday rejected an appeal by former president Jacob Zuma that sought to prevent his prosecution on corruption charges over a $2 billion arms deal.
The ruling paves the way for Zuma’s long-awaited trial to start in February 2020.
Zuma, in office from 2009-2018, had previously applied for a permanent stay of prosecution on 18 charges of fraud, racketeering and money laundering relating to an arms deal with French defense firm Thales in the 1990s.
In mid-October, the Pietermaritzburg High Court dismissed an application by Zuma and Thales for a permanent stay of prosecution. Zuma appealed against it, but on Friday the court struck out his appeal.
Zuma is accused of accepting 500,000 rand ($34,000) annually from Thales in 1999, in exchange for protecting the company from an investigation into the deal. He rejects the allegations as a politically motivated “witch-hunt” against him.
Thales, known as Thompson-CSF in 1999, has said it had no knowledge of any transgressions by any of its employees in relation to the awarding of the contracts.
The National Prosecuting Authority initially filed the charges against Zuma a decade ago, but set them aside shortly before Zuma successfully ran for president in 2009. Following appeals and lobbying by opposition parties, the NPA reinstated the charges in March 2018.


Amdocs Project Forms Registeration Form Feedback Form Contact Form Course Form Course Enrollment Courses Feedbacks Users Conatct


This file is only temporarily used to reproduce issues.
Using doctype HTML 4.01 Strict.
jquery.dynatree.js


Canesrae is a deposit for HTML projects.
It includes JS transpiler which is very noobish, HTML pages examples, and simple functions sheet to build your own pages.


Dear {{ user.username }},
Here are the latest episodes in your ToWatchList:
Sincerely,
ToWatchList
Note: replies to this email address are not monitored.


A basic LRU (least recently used) cache implementation. Also supports a custom callback for when an item is removed.
More...
#include <LRUCache.hpp>
|
|
typedef std::pair< Key, Value > | KeyValuePair |
| |
|
typedef std::list< KeyValuePair >::iterator | ListIterator |
| |
|
|
| LRUCache () |
| | Default constructor initializes a cache of size 100 and no callback.
|
| |
| | LRUCache (const unsigned int size, const std::function< void(const Key &, const Value &)> &func=nullptr) |
| | Create a LRU Cache with the given size. More...
|
| |
| void | addData (const Key &key, const Value &data) |
| | Add data to the cache using the given key. More...
|
| |
| Value | getData (const Key &key) |
| | Returns the cached value associated with the given key. More...
|
| |
| bool | hasKey (const Key &key) |
| | Returns if the given key has a cached value. More...
|
| |
| unsigned int | size () |
| | Returns the number of items in the cache. More...
|
| |
|
| ~LRUCache () |
| | Calls callback function on each stored item when deleted.
|
| |
template<typename Key, typename Value>
class Aether::LRUCache< Key, Value >
A basic LRU (least recently used) cache implementation. Also supports a custom callback for when an item is removed.
◆ LRUCache()
template<typename Key, typename Value>
| Aether::LRUCache< Key, Value >::LRUCache |
( |
const unsigned int |
size, |
|
|
const std::function< void(const Key &, const Value &)> & |
func = nullptr |
|
) |
| |
|
inline |
Create a LRU Cache with the given size.
- Parameters
-
| size | Maximum number of elements to cache. |
| func | Callback to invoke when an element is removed (optional) |
◆ addData()
template<typename Key, typename Value>
| void Aether::LRUCache< Key, Value >::addData |
( |
const Key & |
key, |
|
|
const Value & |
data |
|
) |
| |
|
inline |
Add data to the cache using the given key.
- Parameters
-
| key | Key to use for looking up the data. |
| data | Data associated with key. |
◆ getData()
template<typename Key, typename Value>
Returns the cached value associated with the given key.
- Note
- The returned value is undefined if the key is not cached, please use hasKey() first to check that it is in the cache!
- Parameters
-
| key | Key to search for matching value with |
- Returns
- Value/data associated with key
◆ hasKey()
template<typename Key, typename Value>
Returns if the given key has a cached value.
- Parameters
-
- Returns
- true if key has cached value, false otherwise.
◆ size()
template<typename Key, typename Value>
Returns the number of items in the cache.
- Returns
- Number of items in cache.
The documentation for this class was generated from the following file:


Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s.
Some Ave, 987,
23890, New York,
United States.
Email<EMAIL_ADDRESS>Tel: +34 8493-4893
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s.


Each task on this page can be performed with only the techniques we've gone
over so far in class.
Create a new bootstrap-based form with a button that says “Click Me!” Instead of a div, use text inputs to keep track of session clicks and lifetime clicks.
Once the button is clicked, the counter should increment by 1.
Add an additional button that increases the count by 5.
Every button click should increment session and lifetime clicks by the appropriate amount. Be sure to save numbers, not strings.


| Time (s) | - |
| Error | - |
| State of system | - |
First Order System
Fluid flowing in: ${q_i (t)}$
Fluid flowing out: ${q_o (t)}$
Volume of fluid in the tank: ${v(t)}$
The system can be represented as:
$${d v(t) \over dt}= q_i (t) - q_o (t)$$
$${d v(t) \over dt}= q_i (t) -A v(t)$$
Time domain: $${d v(t) \over dt }+ A v(t) = q_i (t)$$
s domain: $$s V(s) + A V(s) =Q_i (s)$$
rearrange: $$H(s) = {V \over Q_i}= {1 \over s+A} $$
In canonical form, the process can be written as: $$H(s) = {Y(s) \over U(s) }= {K \over 1 + \tau s}$$


This technical manual will cover the system architecture of Easy Design,
explain which features from the specification have been implemented
and the tools, technologies and techniques that have been used throughout
development.
Contents
Overview
Introduction
Easy Design is a new startup company launching a service to enable
customers such as charities and organisations to quickly produce well
designed logos, posters and flyers based on user generated content.
Implemented User Stories
1. Upload Templates
Content creators upload their created design templates to the site. They
must first register with the site before being able to upload content.
2. Discover Templates
Customers can search and browse the site to discover content. They
can browse by content type (e.g. logos, posters, flyers)
or by search term.
Newly uploaded templates, those with a high number of downloads
and those with high ratings are displayed on the Discover page.
Templates are also recommended to customers based on their previous
downloads.
3. Download Templates
When a customer finds a design they like, they can download a high quality
version of the design which they can then edit for their own use.
A customer must register with the site to be able to download designs.
4. Review Templates
When a customer has downloaded a design, they gain permission to rate
and review it.
5. System Management
Administrators are able to perform additional actions to normal users such as
editing or deleting templates and adding or editing categories.
Architecture and Design
Chosen Technologies
Ruby on Rails was chosen as the
development platform for the system because the developer had an interest
to learn Ruby and the Rails framework.
MySQL was chosen at the Database Management System (DBMS) because of
its familiarity to the developer as well as supporting more features and
being easier to interface with than a lighter solution such as
SQLite.
Database Design
An Entity Relationship Diagram is shown below based on the final
schema of the database. It shows the different tables in the database
and their foreign key relations.
System Structure
The system is structured using the Model–view–controller (MVC) software
pattern. The diagram below shows the different MVC components. Each model
has an accompanying controller and in most cases one or more views.
Site Structure
The Site Map below shows the design of the site by showing the main pages
and the routes between them.
Implemented Features
This section details the features that have been implemented in Easy Design
along with a brief explanation, the part of the specification the feature
meets and accompanying evidence.
Template Catalogue
Items (eg products) are stored in a dynamic and editable hierarchy,
which can easily be browsed and searched
Each template in the database is assigned a category. Users can browse
templates by category or search for a template by name or description.
Searching is provided using Thinking Sphinx,
a Ruby gem (library) that connects to the Sphinx
search server.
Thinking Sphinx provides a search method that can be used
on the database models. An indexing file, /app/indices/template_index.rb (shown below), is required so
Sphinx knows what properties of the models to index.
Searching can be done from the Discover page or from the home page.
Administrators can add or edit categories by visiting /categories.
The code snippet below shows the create method in
/app/controllers/categories_controller.rb.
Easy Design provides a recommendation system for users through a list of
possible recommendations shown on the home page. The algorithm
works in three steps:
Get all templates the user has downloaded
For each template, get other users who have downloaded that template
For each of these users, get all other templates they have downloaded
Recommend those templates to the user
The full source for the algorithm can be found in the home
method in /app/controllers/pages_controller.rb.
Template Management
Display and update work items involving multiple users and roles
A list of all templates can be found through /discover or
/templates. Individual templates can be viewed through
the /templates/{template_id} endpoint. Administrators can
update or delete a template using the provided buttons.
The code snippet below shows the controller method for deleting a
template, see /app/controllers/templates_controller.rb.
def destroy
# Only delete if adminif current_user.admin?
@template = Template.find(params[:id]).destroy
render status: 200, json: true
endend
Review System
Users can post comments or messages to selected roles, view them, rate, filter and sort them appropriately.
Users can review a template and give it a rating. They are only able
to post one review per template.
The create review method from /app/controllers/reviews_controller.rb
is shown below.
def create
# Check user hasn't already reviewed the template, or not downloaded it@template = Template.find(params[:template_id])
<EMAIL_ADDRESS>current_user or<EMAIL_ADDRESS>current_user
returnend@review = Review.new(review_params)
@review.user = current_user
@review.save
respond_with@reviewend
The reviewing system contains advanced JavaScript. When a user clicks
'Add review' they can enter a textual review and rate the item by
clicking on the number of stars they feel the template deserves. When they
submit their review the system converts the number of selected stars into
an integer value before sending an HTTP POST request to the server.
The snippet below shows some of this JavaScript code, see
/app/assets/javascripts/show.js for the full source.
Dynamic generation of images (eg visualisation of business objects or statistics) and multimedia manipulation (eg scaling or compression).
For each template image uploaded to Easy Design, the system generates
a preview image and a smaller thumbnail image. The preview image is shown
on the template page (e.g. /templates/1) and the thumbnail
is shown on the Discover page. The size of the generated images can be
set in /config/application.rb.
The system uses ImageMagick
to generate the preview and thumbnail images. A snippet from
the create method in /app/controllers/templates_controller.rb
below shows the image generation code.
# Upload image file
# From http://guides.rubyonrails.org/form_helpers.html#uploading-files
uploaded_io = params[:template][:image]
@template.filename = SecureRandom.uuid
File.open(Rails.root.join('public', 'uploads', @template.filename), 'wb') do |file|
# Create full size file, preview and thumbnail versions
file.write(uploaded_io.read)
system"convert #{file.path} -resize #{Rails.configuration.preview_size} #{file.path}#{Rails.configuration.preview_extension}"system"convert #{file.path} -resize #{Rails.configuration.thumbnail_size} #{file.path}#{Rails.configuration.thumbnail_extension}"end
Data Export
Export of internally stored business data for use in external sites, using XML formatted data.
Easy Design has a public ATOM feed of all the templates in the system
available at /feed.
This allows other developers to make use of the templates uploaded
to Easy Design and include them as part of their own web applications.
The feed method from /app/controllers/templates_controller.rb,
shown below, demonstrates this.
Professional appearance with logo, master pages, style sheets, site menus, breadcrumbs, login status and multi-part forms.
Twitter Bootstrap has been used
throughout the site to give a consistent and professional look and feel.
Individual stylesheets have been used for the different sections of the
site to prevent the browser requesting unnecessary styles.
The site menu is displayed in the top navigation bar and the login
status to the right of the navigation bar. Breadcrumbs are not required
because the only nested navigation occurs when viewing a template.
multipart/form-data is used in the upload form. The code
snippet below shows the HTML that is generated by the form found in
/app/views/templates/new.html.erb.
Professional IDE, including WYSIWYG or syntax-highlighting HTML editor, database administration, and on-the fly display and debugging of web pages and code.
The NetBeans IDE with the
Ruby plugin was used to
develop Easy Design. The screen shot below shows the syntax-highlighting
for both HTML and Ruby syntax.
Database administration was provided through the high level
Active Record Query Interface and at a lower level through
HeidiSQL. Active Record also
provided object relational mapping and database/schema generation.
Easy Design was tested in the Google Chrome 31
web browser. Debugging was provided through the Chrome Developer tools
and debugging messages provided by Rails.
The screen shot of the NetBeans IDE also shows form markup generation.
There was no need to manually write the HTML for the form elements.
For example, <%= form_for :template, url: templates_path do |f| >
produces <form accept-charset="UTF-8" action="/templates" enctype="multipart/form-data" method="post">.
External Libraries
External libraries and web services.
The following external libraries were used in the project:
Bootbox.js - Make using Twitter Bootstrap modals easier
Testing and Accessibility
Automated unit testing. Scalability and security testing. Accessibility & (X)HTML validation.
Automated Unit Testing
Some unit testing was carried out on the models to test the creation
and deletion of different objects. The snippet below from
/test/models/category_test.rb shows the tests for
categories.
Accessibility testing was peformed using PowerMapper's SortSite, an
accessibility checker and validator. Several changes were made to pages
based on recommendations from the service. For example, it was ensured
that each page had an HTML title element and specified
that the language of the page was English. Some errors such as the lack
of privacy and cookie policies were not
addressed as the system is a prototype. They would need to be solved
if Easy Design was made public.
Clear separation of layers or tiers (eg MVC); maintainable code. Enterprise / web architecture patterns.
Rails forces developers to use the Model-view-controller (MVC) software pattern. I strove
to write well-designed code that would be readable, extensible and
maintainable.
Advanced Web Controls
Web controls or widgets eg rich text editor.
Automated validation of entered data.
Easy Design automatically validates entered data. For example,
when uploading a new template, Rails checks that all the fields have been
supplied. If they have not, the template fails to upload and an error
message is displayed. The template_params function below from
/controllers/templates_controller.rb shows the logic that
ensures all the correct parameters are included in the POST request.
Sessions or cookies. Secure access, authentication, roles.
devise was used
to handle sessions and user authentication. An admin field
was added to the User model to store if the user was an administrator.
The code below from /db/migrate/20131029132534_create_users.rb
shows the database schema for the users table, before
the additional devise fields are added.
Data integrity and consistency. Database constraints, triggers, referential integrity, prepared statements, transactions. BLOBs. Database exception handling.
Active Record maintained data integrity and managed all interactions
with the database.
HTML5
Parts of HTML5 have been used in the system such as the HTML5 DOCTYPE
declaration, the absence of the type attribute in the
script tag and the use of the video and
source tags in the user manual, see snippet below.
The system makes excellent use of JavaScript and AJAX, allowing for
instant updates to pages. The snippet below from /app/assets/javascripts/show.js
shows the action taken when the button to download a template is clicked. An AJAX
call is made to the server to see if the download counter should be increased
or not.
Another example of JavaScript within the project is in this manual and the
user manual. The contents section with hyperlinks to each part, is
dynamically generated by JavaScript. See script.js in the
manuals directory for the source code.
Video Capture
Video capture.
Video capture, using CamStudio, was used in the user manual to help explain and illustrate
the functionality of Easy Design.
Code overview
Software metric tools (lines of code).
The table below shows all the source files that were either written,
or edited as part of Easy Design. The total lines of code for the project
was 993, just under the 1000 lines limit.
Overall the project was a success. It was completed in time and
to a high standard. The initial plan was to submit on December 9th, however
due to the Group Design Project requiring more resources than estimated,
the project was delayed by several weeks.
Development Platform
Using Ruby on Rails as the development platform worked well. The Ruby
on Rails web site states that Rails 'lets you write beautiful code
by favouring convention over configuration'. This principle was visible
throughout development and was very helpful. For example, if no code is
placed in the controller, Rails simply renders the view. As well as saving
time, it also helped to keep the project within the 1000 lines of code
limit set by the specification.
Object-Orientated PHP was an alternative development platform. Whilst
it was familiar to the developer and is often seen as simpler than an
MVC framework such as Rails, the developer was keen to learn a new
technology.
Database Management System and Database Design
SQLite was originally used at the DBMS, however it did not interface
well with the Sphinx search engine. MySQL was chosen as a replacement
because it interfaced better with Sphinx, was familiar to the
developer and supported more features, as mentioned in Chosen Technologies.
In addition, more sophisticated database administration solutions exist for MySQL
than SQLite. The only drawback of using MySQL was that it was initially
harder to set up with Rails than SQLite.
The database design was produced by using tables to represent real world
objects in the system. The initial design
represented ratings and comments as separate tables, however during development
these tables were merged together into reviews, see
Database Design. A separate downloads
table was also added to allow for more detailed information about template
downloads to be recorded.
The image files associated
with templates were initially designed to be stored as binary large objects
(BLOBs) in the database. In the final system this has changed to storing them in a directory
structure. This enables different image sizes to be created more quickly as
it is faster for the image processing to work on files in a directory
than accessing the database. In addition, delivering the image files directly to
the browser is faster than creating temporary images from the database
each time the page is requested.
System Structure and Site Structure
As mentioned in System Structure, the MVC
software pattern was used. MVC forces developers to structure their code
in a certain way. Whilst this can be frustrating at times, it is useful
overall as it produces code that is more logical and maintainable than
code that follows no structural pattern.
The site was designed to have as few pages as possible to make it
easy for users to navigate.
Site Functionality
Discover Templates
The home page and the Discover page help users to access the site's content.
Recommendations are provided on the home page and a list of the three most popular,
top rated and newest templates for each category are shown on the Discover page.
Templates can also be found using the search bar from both the Discover
and home pages. The ease and speed of discovering new content is one of Easy Design's
greatest strengths.
These methods of discovering content were designed to help users find
the content they want with minimal effort. The highlights from each
category, displayed on the Discover page, were key to this and prevented users
from needing to read through hundreds of template summaries.
The searching feature, provided by the Sphinx search engine is powerful.
It allows users to quickly search for templates based on keywords
in the title and description. This is also a limitation, as it cannot
search by other fields such as date created.
Users can also browse all the templates in a category through the 'All'
section in the Discover page. However, there is no support for
pagination or filtering. These features
would need to be added to the system to help users conduct specific
queries, for example the 10 most recent uploaded posters.
The recommendation system is powerful and can help users discover
templates that are similar to those they like. However currently there
is no limit to the number of recommendations that can be displayed on the
page, or the removal of repetitions. In addition, the search algorithm
branches over three loops and the execution time could
grow rapidly as more templates are downloaded by users.
These missing features were not added to the system due to time constraints
and the 1000 lines of code limit.
Download Templates
Customers can download high quality versions of templates. If they have
not downloaded a template before, the downloads counter on the page
is increased immediately. If they have already downloaded
it, the download counter does not increase. The downloads data is essential
to the recommendation system and the 'most popular' templates shown on the
Discover page. Originally a simple field was used to count the number
of downloads for each template, however in the final implementation a
separate downloads table was made to allow for more detailed records to
be kept such as who downloaded the template and when.
Review Templates
Users who have downloaded a template are able to rate and review it.
The reviewing system was designed in this way to prevent inaccurate reviews
from users who had not downloaded the template. Users were also prevented from
leaving multiple reviews for a single template to stop one user having a stronger
voice than another. The system was designed to make reviewing quick and easy
through the use of a clickable star rating and immediate display of the
review when submitted. A limitation of the review system is that reviews
cannot be filtered or themselves rated by users.
System Management
Easy Design provides a powerful administration system for selected
users to vet the uploaded templates and add or update template categories.
It was decided that categories could not be removed as this would cause
existing templates in that category to be deleted.
The template editing system is intuitive and simple to use, however it
lacks support for changing the uploaded image. It is also not currently
possible for a user to edit their own template.
Development Tools
NetBeans was chosen as the IDE because of its excellent support for
HTML5 and JavaScript, as well as its familiarity to the developer. A
syntax-highlighting HTML editor such as Notepad++
could have been used instead, however an IDE is better suited as it supports features
such as syntax error detection.
Google Chrome
was used as the web browser as it supports advanced
debugging tools, superior in the developer's opinion to those offered
by alternative such as Firefox and
Internet Explorer.
External Libraries and Tools
Image Manipulation
ImageMagick was used to generate the different sized versions of each
template image. VIPS
is an alternative image manipulation program that the developer had used
before, however it is far easier to resize an image in ImageMagick through
the convert
command line function.
Search Engine
The Thinking Sphinx
Ruby gem, which uses the Sphinx search engine was
chosen to provide the search functionality for Easy Design. It was selected
from a list
of available Ruby search gems because of its support for full-text search.
User Authentication
devise was
chosen to provide user authentication for the system because
it is
by far the most popular authentication gem.
JavaScript Library
jQuery was used to make the writing
of the client side JavaScript quicker
and easier through its HTML document traversal, AJAX handler and other
features. Prototype and
MooTools are other
JavaScript libraries that provides similar functionality to jQuery. However
they are both less popular
meaning there is less general support available. In addition, the developer
was already familiar with jQuery.
UI Framework
Twitter Bootstrap was used
as the visual front-end framework. It was
chosen because of its familiarity and responsive nature. Foundation
is another front-end framework that provides similar functionality,
however it had not been used by the developer. Due to the time that
learning Foundation would take, Bootstrap was chosen.


Lying to the east of Patmos, this island has a small harbour on the south side.
Port police and customs are based here.
There are several options for berthing here. The inner harbour has been dredged to 3 to 5m but the holding is bad in a mixture of sand, mud and weed.
There is a pontoon in the NW corner and also, maybe, room off the new quay on the SE side, near the water boat.
In strong meltemis
, anchoring in the southern part of the bay in 3 to 4m is a more sheltered option. Also, the northside of the entrance to the bay, by the chapel, offers good shelter.
Last updated November 2009.


CrimPapers
Articles published on 18 January 2017
On 18 January 2017, 5 new articles were published in 4 journals.
A Meta-Analysis of the Association Between Mental Health Disorders and Juvenile Recidivism
Exposure to Fetal Testosterone, Aggression, and Violent Behavior: A Meta-Analysis of the 2d:4d Digit Ratio
Law Enforcement Views on Sex Offender Compliance With Registration Mandates
Searching For Signs of Extremism on the Web: An Introduction to Sentiment-Based Identification of Radical Authors by Ryan Scrivens, Garth Davies, Richard Frank
Impossibility of A “Reverse Racism” Effect by Aaron Roussell, Kathryn Henne, Karen S. Glover, Dale Willits


Launching Spark on YARN
Support for running on YARN (Hadoop NextGen) was added to Spark in version 0.6.0, and improved in 0.7.0 and 0.8.0.
Building a YARN-Enabled Assembly JAR
We need a consolidated Spark JAR (which bundles all the required dependencies) to run Spark jobs on a YARN cluster.
This can be built by setting the Hadoop version and SPARK_YARN
environment variable, as follows:
SPARK_HADOOP_VERSION=2.0.5-alpha SPARK_YARN=true ./sbt/sbt assembly
The assembled JAR will be something like this:
./assembly/target/scala-2.9.3/spark-assembly_0.8.0-incubating-hadoop2.0.5.jar
.
Preparations
- Building a YARN-enabled assembly (see above).
- Your application code must be packaged into a separate JAR file.
If you want to test out the YARN deployment mode, you can use the current Spark examples. A spark-examples_2.9.3-0.8.0-incubating
file can be generated by running sbt/sbt assembly
. NOTE: since the documentation you’re reading is for Spark version 0.8.0-incubating, we are assuming here that you have downloaded Spark 0.8.0-incubating or checked it out of source control. If you are using a different version of Spark, the version numbers in the jar generated by the sbt package command will obviously be different.
Configuration
Most of the configs are the same for Spark on YARN as other deploys. See the Configuration page for more information on those. These are configs that are specific to SPARK on YARN.
Environment variables:
* SPARK_YARN_USER_ENV
, to add environment variables to the Spark processes launched on YARN. This can be a comma separated list of environment variables, e.g. SPARK_YARN_USER_ENV="JAVA_HOME=/jdk64,FOO=bar"
.
System Properties: * ‘spark.yarn.applicationMaster.waitTries’, property to set the number of times the ApplicationMaster waits for the the spark master and then also the number of tries it waits for the Spark Context to be intialized. Default is 10.
Launching Spark on YARN
Ensure that HADOOP_CONF_DIR or YARN_CONF_DIR points to the directory which contains the (client side) configuration files for the hadoop cluster. This would be used to connect to the cluster, write to the dfs and submit jobs to the resource manager.
The command to launch the YARN Client is as follows:
SPARK_JAR=<SPARK_ASSEMBLY_JAR_FILE> ./spark-class org.apache.spark.deploy.yarn.Client \
--jar <YOUR_APP_JAR_FILE> \
--class <APP_MAIN_CLASS> \
--args <APP_MAIN_ARGUMENTS> \
--num-workers <NUMBER_OF_WORKER_MACHINES> \
--master-memory <MEMORY_FOR_MASTER> \
--worker-memory <MEMORY_PER_WORKER> \
--worker-cores <CORES_PER_WORKER> \
--queue <queue_name>
For example:
# Build the Spark assembly JAR and the Spark examples JAR
$ SPARK_HADOOP_VERSION=2.0.5-alpha SPARK_YARN=true ./sbt/sbt assembly
# Configure logging
$ cp conf/log4j.properties.template conf/log4j.properties
# Submit Spark's ApplicationMaster to YARN's ResourceManager, and instruct Spark to run the SparkPi example
$ SPARK_JAR=./assembly/target/scala-2.9.3/spark-assembly-0.8.0-incubating-hadoop2.0.5-alpha.jar \
./spark-class org.apache.spark.deploy.yarn.Client \
--jar examples/target/scala-2.9.3/spark-examples-assembly-0.8.0-incubating.jar \
--class org.apache.spark.examples.SparkPi \
--args yarn-standalone \
--num-workers 3 \
--master-memory 4g \
--worker-memory 2g \
--worker-cores 1
# Examine the output (replace $YARN_APP_ID in the following with the "application identifier" output by the previous command)
# (Note: YARN_APP_LOGS_DIR is usually /tmp/logs or $HADOOP_HOME/logs/userlogs depending on the Hadoop version.)
$ cat $YARN_APP_LOGS_DIR/$YARN_APP_ID/container*_000001/stdout
Pi is roughly 3.13794
The above starts a YARN Client programs which periodically polls the Application Master for status updates and displays them in the console. The client will exit once your application has finished running.
Important Notes
- When your application instantiates a Spark context it must use a special “yarn-standalone” master url. This starts the scheduler without forcing it to connect to a cluster. A good way to handle this is to pass “yarn-standalone” as an argument to your program, as shown in the example above.
- We do not requesting container resources based on the number of cores. Thus the numbers of cores given via command line arguments cannot be guaranteed.
- The local directories used for spark will be the local directories configured for YARN (Hadoop Yarn config yarn.nodemanager.local-dirs). If the user specifies spark.local.dir, it will be ignored.


no op should need to see this and its not for testnet.
And dafuq happens a moth from now when you have the job?
Greer17-Apr-19 04:00 AM
@webworker01 thanks, thats is a great resource that I didnt' see until now.
1
ComputerGenie 👴👴👴17-Apr-19 04:01 AM
>this wasn't part of test net so I didn't learn it; meh sux to be waiting on me for securing your currency
Greer17-Apr-19 04:03 AM
I'm concerned what happens in a month from now when a bunch of guys that know a little c but nothing about best practices or running a modern reliable and secure linux server get the job. Servers kept running by bash scripts borrowed form others, running other bash scripts from different people, calling unnecessary python scripts.
@Deleted User You want your doctor to start learning before you are in the patient waiting area? or during?(edited)
Greer17-Apr-19 04:06 AM
I have been surprised by how simple all of this has been, its just made out to be so complicated, seemingly on purpose.
1
ComputerGenie 👴👴👴17-Apr-19 04:07 AM
its just made out to be so complicated, seemingly on purpose.
Besides you and Lumbi, no one has made it out to be complicated
More people starting studies means better doctors at the end of the years.
Yes, but we're not talking about end of years, if @VoskCoin gets elected @Greer starts doing his job for him in a few weeks(edited)
Greer17-Apr-19 04:08 AM
accept that there are things that others know that you may not. Then consider that those people, instead of sharing what they know, obfuscate it because they believe you not worthy. Now apply it to this and tell me how that is good for Komodo.
1
smk762 - dracocanis ominator17-Apr-19 04:08 AM
./beNN.sh
1
ComputerGenie 👴👴👴17-Apr-19 04:09 AM
I left that bit out of the analogy, your doctor isn't going to see you, he's sending in an intern that hasn't made it to grade 6 yet
Greer17-Apr-19 04:09 AM
I learned more from BeNN.sh than I did all of the documentation that I found. Its that simple
ComputerGenie 👴👴👴17-Apr-19 04:09 AM
this is why i think that testnet should have started long ago.
Because you have to wait for testnet to exist before learning and asking questions?
Alright17-Apr-19 04:10 AM
I started the testnet long before it needed to enter
Exist*
ComputerGenie 👴👴👴17-Apr-19 04:10 AM
i think so, testnet is important
but it's not because he wants the docs for functions and whys
again, you can't have it both ways
smk762 - dracocanis ominator17-Apr-19 04:10 AM
the code is the docs
Greer17-Apr-19 04:10 AM
benn.sh deconstructed should be the start of the testnet readme, let the ops set it up how they want. I dont use the script, I have each in a container, but couldn't have done that without simply seeing that the coins are all copies of the same daemon with the ac param creating new chains.
Alright17-Apr-19 04:11 AM
Testnet is year round if you're competent
ComputerGenie 👴👴👴17-Apr-19 04:11 AM
2 PCs and a little boredom
Greer17-Apr-19 04:11 AM
the code is the docs means you'll only ever have devs running servers. I want my racecar driven by a race car driver not a mechanic.
ComputerGenie 👴👴👴17-Apr-19 04:11 AM
isn't a dev
ComputerGenie 👴👴👴17-Apr-19 04:20 AM
because this is tech, not windows
Greer17-Apr-19 04:20 AM
your problem is you know a few nuggets of information that you are taking for granted and while anyone with half a brain could understand these nuggets, Satoshi Nakamoto himself couldn't be expected to just understand without either an explaination or wasting a lot of time in discovering what could just be explained/documented.
1
Alright17-Apr-19 04:20 AM
@Greer run for your own node.
1
2
1
ComputerGenie 👴👴👴17-Apr-19 04:21 AM
@Deleted User You've been involved far longer than I, why haven't you documented it
I know you've seen every dumb thing every one of us has typed and done....
Greer17-Apr-19 04:21 AM
@Alright You should write a bash script that calls another bash script that calls a python script to generate some json with my name in an array of all names from this server to pass to another bash script to use jq to select my name to keep running that statement every 10 minutes here.
ComputerGenie 👴👴👴17-Apr-19 04:22 AM
It's not an ad hom, it's a valid question(edited)
Bryan_Beus17-Apr-19 04:22 AM
Nope, all changes on that site are @gcharang.
He'll be glad that you enjoy the new look.
Alright17-Apr-19 04:22 AM
Ask here, learn how it works(or how to improve it)
ComputerGenie 👴👴👴17-Apr-19 04:23 AM
Better documentation would be nice, that's all i'm saying.
Start writing it, that's all I'm saying.
Bryan_Beus17-Apr-19 04:23 AM
The design is made by @808. I only did the CSS.
Greer17-Apr-19 04:23 AM
btw, while I've been distracting you here, I'm coming for you on the 6hr, last place up to 14 just while in this chat
Alright17-Apr-19 04:23 AM
Vosk*
ComputerGenie 👴👴👴17-Apr-19 04:24 AM
doesn't burst bubbles by saying that certain nodes have been offline 6-12 hrs a day for the last 3 days
Greer17-Apr-19 04:25 AM
mine where while I tried to figure out the change from iguana splitting to scripting the splitting. Didn't need to be, but I need to break some stuff in order to learn what 30 others already knew
8hrs I'd have like to have spent working on container management for mainnet
Bryan_Beus17-Apr-19 04:26 AM
@Deleted User
To my knowledge, no one on the internal team will be spending a lot of time improving Notary Node documentation, for several reasons. I received instructions from management early on to leave them alone.
Gcharang deals with them the most, and I don't believe he's making changes.
If a notary node were to get elected on the campaign promise of improving the docs, that would be something to look at.
Anyhow, have a good night, all.
1
1
ComputerGenie 👴👴👴17-Apr-19 04:26 AM
Didn't need to be, but I need to break some stuff in order to learn what 30 others already knew
Or you could have just read the 4 times @Alright posted the exact line in the code that he also documented in the code
Greer17-Apr-19 04:27 AM
I dont copy/paste code, I need to know why not how
1
1
Alright17-Apr-19 04:27 AM
Ask
We've shown you all we can
if you don't understand, ask
Greer17-Apr-19 04:28 AM
tried asking, was met with resistance many times, until a couple of days ago it was clear the barrier was intentional.
Alright17-Apr-19 04:28 AM
more peers, less utxso
that's it
ComputerGenie 👴👴👴17-Apr-19 04:28 AM
I need to know why He literally put why and linked to it 4 times in this channel
and 6 times in the other channel
Greer17-Apr-19 04:29 AM
you told me that yesterday and the two lines from you is why I'm running a much better node now.
Alright17-Apr-19 04:29 AM
Do you understand why?
Greer17-Apr-19 04:29 AM
I do understand that part now, yes
Alright17-Apr-19 04:30 AM
@Greer run for your own node.
You're a competent op
Greer17-Apr-19 04:31 AM
my point is it took me 2 weeks to get here. I'm not that dumb, I could have had a much better understanding in 2hrs but my point isn't about me. My point is about what I believe is lacking here
1
Alright17-Apr-19 04:31 AM
2 weeks, try 2 years
1
ComputerGenie 👴👴👴17-Apr-19 04:31 AM
maybe the problem is that it's expected that ops understand that efficiency is important and implicit
Alright17-Apr-19 04:31 AM
How do i Linxus?(edited)
Greer17-Apr-19 04:31 AM
yes, you spent 2yrs, I'm sure others spent many months/years. I will share what I have learned whether vosk is elected or not
Alright17-Apr-19 04:32 AM
@Greer run for your own node.
Greer17-Apr-19 04:32 AM
and if he is elected, his server will out perform all of yours, just so I can you all next year
ComputerGenie 👴👴👴17-Apr-19 04:32 AM
my point is it took me 2 weeks to get here.
You have no clue how much that aggravates some folks that have spent years of sleepless nights and 40 hr days to get here
To have it handed to you and you still complain
Greer17-Apr-19 04:33 AM
I'm all for a barrier, even a high ish barrier, just make it the correct kind of barrier
ComputerGenie 👴👴👴17-Apr-19 04:33 AM
knowledge is the barrier
either you have it or you don't
Alright17-Apr-19 04:34 AM
We've told you over and over what we know
ComputerGenie 👴👴👴17-Apr-19 04:34 AM
has literally given blood, sweat, and tears to this project
Greer17-Apr-19 04:34 AM
I've been using *nix since SCO Unix in the late 80's. I have knowledge there. Notary nodes? brand new to me.
if you think that makes me a poor op, I disagree. the NN part is way easier to learn than keeping a secure reliable server
and yes, again, credit where it is due, it is clear that CG has given a lot, as has BJ and WW.
ComputerGenie 👴👴👴17-Apr-19 04:37 AM
I think that not knowing what it entails makes you a poor op, and to that extent, I'm not entirely sure I'd make a good op
The difference is I'm willing to put in the work and accept every scrap of information everyone is willing to give me and not complain that I have to work for it
1
Greer17-Apr-19 04:37 AM
I see, you think this is complaining.
this is intended as constructive criticism for the betterment of the project. I've been pretty quiet for two weeks.
ComputerGenie 👴👴👴17-Apr-19 04:38 AM
honestly I've sucked at this, too many secrets not shared to create a barrier to entry
If that's not complaining, then you need a new dictionary
I've been pretty quiet for two weeks.
So have I
Greer17-Apr-19 04:39 AM
I'm past not knowing how it all works. I think I get it now. Not enough that I'd be confident writing docs for future ops, but well on my way. I still stand by everything I said
Alright17-Apr-19 04:39 AM
@Greer run for your own node.
1
1
2
1
Greer17-Apr-19 04:40 AM
I'll just take 43 votes from vosk and have to use the 50 I put to CG for myself. nobody benefits
Alright17-Apr-19 04:41 AM
show you're competent and willing to further KMD development and people will elect you
ComputerGenie 👴👴👴17-Apr-19 04:41 AM
is still stuck on @Deleted User saying that the docs for bdex aren't docs
Greer17-Apr-19 04:41 AM
that is the plan
1
his node will be 100% run by me and others I enlist for help if needed. His job will be to pimp his bags
Mylo17-Apr-19 04:42 AM
@Bryan_Beus@Deleted User
Cakeshop can fill the gap with the iguana-in-a-box turnkey solution for other reasons
https://cakeshop.dev/iguana-in-a-box/


"In the future I will return to England"
by BeSoccerRafa Benitez isn't hiding his desire to return to the Premier League. Benitez wants to return to England because he wants to be close to his family and because it is a league that he likes a lot".
He is currently the manager of Dalian Yifang in the Chinese Super League and despite being happy at the club, he is clear that his future lies in the Premier League again.
Featured links
- Ballon d'Or winner already been decided
- The latest football transfers news and rumours
- Possible 'Clasico' in the Spanish Supercup final
- Who has the most free-kicks goals: Messi or Cristiano?
During a chat with 'BBC', Benitez made known his intentions. "I will return to England". The ex Inter and Madrid manager isn't hiding it, and also declares himself a "follower of the Premier League".
Finally, the Spanish manager has not overlooked some of the peculiarities of Chinese football. He said he had to use ping pong as a metaphor to "show the players how to kick the ball".


|
Move the slider to rotate: |
Select the series type: |
|
Move the slider to change the radius: |
Select color scheme: |
|
Auto-rotate labels
|
Ticks between values
|


Tap the quadratic equation to hear the math described.
Tap the math below to hear it described.
Tap the math (underlying MathML contains semantic and content presentation).
Tap the math (underlying MathML contains semantic and content presentation).
Tap the math (underlying MathML contains semantic and content presentation).
msline
example. (This should fail...)


A Business Actor is defined as an entity that performs behaviour in an organisation such as business processes or functions.
Typically, a Business Actor performs the behaviour assigned to one or more Business Roles. It's important to separate the actor from the role because a Business Actor can perform more than one Business Role, and a Business Role can be performed by more than one Business Actor.
Business Actors are humans, departments, and business units. They may be individuals or groups.
The name of a Business Actor should preferably be a noun.
Business. Active Structure.
A Customer, Marketing & Communications department, Director of Finance, Secretary, Admissions Department, Product Development.


|
Perl Weekly
Issue #84 - 2013-03-04 - YAPC::NA Training classes announced
latest | archive | by Yanick Champoux
|
|
Hi,
Most of this issue was put together by Yanick, (thanks man!), I only added a few entries and this opening. - I have been waiting for the announcement and I am glad it is out. There are going to be a number of training classes before and after YAPC::NA in the beginning of June. I am responsible for two of the classes. I hope to see many of the Perl Weekly readers at the conference and maybe even in the course.
In the meantime, enjoy the articles!
|
|
|
|
Sponsors
|
|
|
MediaMath is hiring Perl Developers: Are you tired of Perl 'scripting'?
Come join an innovative talented engineering department where you can do some serious Perl programming in a great development environment with clean codebase that is not slapped together. If interested in learning more please contact Marc Spinowitz, Recruiter at MediaMath at<EMAIL_ADDRESS>or<PHONE_NUMBER>
|
|
Announcements
|
Dancer and Dancer2 both available on CPAN
YES! To get the ball rolling, Dancer2 now has its own namespace, and has been released on CPAN. Dancer1 also saw its first release of 2013, and has new maintenance stewards.
|
|
|
|
|
|
|
|
|
|
Testing
|
Alternative to Test::NoWarnings
Test::NoWarnings: useful, but flawed. David Golden: pragmatic, but impatient. Say hello to his latest module, Test::FailWarnings.
|
|
Code
|
Showing Off Template::Caribou
Timmy had Lassie. What's-her-name had Flipper, and What's-his-face had Skippy. Yanick, it seems, has a pet caribou.
|
|
|
|
|
|
Pod to HTML
A new Pod to HTML converter is born (Toby Inkster being the happy dad).
|
|
|
|
|
|
|
|
stop shipping MYMETA to CPAN
Sometimes, miyagawa reminds us, local crud (like the MYMETA* files) gets bundled in CPAN distributions, something that could easily be prevented by a few judicious lines in the distribution's MANIFEST.SKIP.
|
|
More on constants in perl
Eduardo Arino de la Rubia continues his quest to find which constant module to use. He's been told that Const::Fast is faster, so he benchmarked it.
|
|
SDL2 C library API is stabilized
Rejoice, game makers, for Kartik Thakore lets us know that the SDL2 API is stabilizing, and that the work on its Perl bindings is under way.
|
|
|
|
Fun
|
Catalyst Backlog for Next Release on Play Perl
The title pretty much says it all. Thanks for John Napiorkowski, the list of features for the next Catalyst release is on Play Perl, all ready for your voting and commenting pleasure.
|
|
Videos
|
Introducing cpanm 1.6
A video introduction of cpanm 1.6 by miyagawa. Brace yourself for an onslaught of awesomeness.
|
|
|
|
Perl 6
|
|
|
Weekly collections
|
|
|
|
|
|
|
Perl Maven Tutorial
|
|
|
Events
I usually list the next 3-4 events here. The list of all the events can be found on the web site. If your Perl event is not listed there, please let me know.
|
|
|
|
|
|
|
|
|
You know, you could get the Perl Weekly right in your mailbox. Every Week. Free of charge!
|


>
This is part of the old website. New website begins at fontforge.github.io
Are you a web developer? Help us migrate this page on Github
Not really any, any more. Except that FontForge supports much of the syntax which adobe documents but does not support. Adobe continues to reserve the right to change the syntax of anything they do not currently support.
In November 2008 Adobe made radical changes to the feature file format. This meant that my extensions were no longer needed. It also as an incompatible change from the earlier format. FontForge should (still) be able to parse files written in the earlier format, as well as files written in the new format. It will only produce files in the new format now (actually there is a compile time flag which will revert output to the old format, but I haven't tested it).
Use File->Merge Feature Info
(formerly File->Merge Kern Info
)
Use Element->Font
Info->Lookups
, then right click on any lookup (to produce a
popup menu) and select Save Feature File
You can also generate a feature file containing a single lookup by selecting
that lookup, producing the popup menu and selecting Save Lookup


--- layout: post title: Wheels of the Past date: 2009-12-28 20:39:13.000000000 +05:30 categories: - kiranoncemore - S3 IS tags: - retro - sepia - wheel status: publish type: post published: true meta: _edit_last: '2' author: login: kiranoncemore email<EMAIL_ADDRESS>display_name: kiranoncemore first_name: Kiran last_name: '' ---
Av: F/2.7; Tv:1/100s; f:6mm(35mm-equiv: 38mm)
This photograph was shot at Rheinfalls, an hour north of Zurich in Switzerland. This wheel was probably used in pre-industrial era to fetch water from a well or river.
I liked the mood of this one; and also the angle, the framing and the background. The white board in the top-left corner does seem out of place but it was a great spot to put my signature!
I shot this snap in Sepia. The reason I put up this snap on the blog is to get feedback or any pointers on when to use Sepia and when not to. Almost any snap that I take in Sepia; it always looks better when I desturate it and turn in into B&W. It was no different with this one - I post-processed the photo and made it B&W - and that looked better than the one you are seeing here.
Any links to Sepia-flavored snaps which you have taken are greatly appreciated!


Section 3 Descriptive statistics
This section will give you a brief overview of how to generate descriptive statistics in R.
Note: Throughout this tutorial, use
?
in front of a function name to retrieve help files on this function (e.g.?mean
).
3.1 Inspect the dataframe
To see variable names of the dataframes we just created, use the colnames()
function:
# See variable names
# GLOBE study
colnames(globe_data)
# RECORD study
colnames(record_data)
The head()
function gives you the variable names, variable types, and the 6 first lines of values in a dataset.
# Inspect GLOBE and RECORD datasets
# GLOBE
head(globe_data)
# RECORD
head(record_data)
3.2 Measures of central tendancy and variability
Basic R functions for computing descriptive statistics include:
mean()
- returns the mean of a numeric variablesd()
- returns the standard deviation of a numeric variablevar()
- returns de variance of a numeric variablesmin()
- returns de minimum of a numeric variablesmaximum()
- returns de maximum of a numeric variablesmedian()
- returns de median of a numeric variablesrange()
- returns the range of values of a numeric variables (minimum and maximum)IQR()
- returns the interquartile range of a numeric variables
Let’s try retreiving the mean age for each study. The na.rm = argument in the scripts below removes NULL values before calculating the mean.
# Mean age for GLOBE baseline collection wave
mean(globe_data$sdc_age_0, na.rm = TRUE)
# Mean age for RECORD baseline collection wave
mean(record_data$sdc_age_0, na.rm = TRUE)
Note: The
$
operator refers to a specific column relative to a specific dataframe (i.e. collumn sdc_age_0 in dataframe globe_data).
The summary()
command returns several desciptive statistics summaries for numeric variables. You can either run this command for a single variable or for an entire dataframe. For one variable, this function return the mean, median, 25th and 75th quartiles, minimum and maximum values. When applied to a dataframe, this command generates these statistics for all collumns in this dataframe.
# Summary of the GLOBE baseline collection wave age variable
summary(globe_data$sdc_age_0)
# Summary of the entire GLOBE dataframe
summary(globe_data)
The summ()
function from the epiDisplay
package is also quite usefull. In addition to the number of observations, mean, median, standard deviation, minimum, and maximum, it also generates number of missing values and a plot showing the distribution of a given variable.
3.3 Categorical variables
For factor variables (i.e. categorical variables), the table()
function returns the number of observation per category.
# Number of Males/Females in GLOBE
table(globe_data$sdc_gender_0)
# Number of Males/Females in RECORD
table(record_data$sdc_gender_0)
Wrapping this function in prop.table() give the proportion of Males and Females in each study.
# Proportion of Males (coded as 0) and Females (coded as 1) in GLOBE
prop.table(table(globe_data$sdc_gender_0))
# Proporion of Males (coded as 0) and Females (coded as 1) in RECORD
prop.table(table(record_data$sdc_gender_0))
Again, the epiDisplay
package provides a useful function to summarise categorical data. Running the tab1()
function from this package gives you the frequency and proportion for each category and generates a histogram for a variable. Using tab1()
also displays missing data in tables and histograms.
# Proportion of Males/Females in GLOBE
tab1(globe_data$sdc_gender_0)
# Proporion of Males/Females in RECORD
tab1(record_data$sdc_gender_0)
3.4 Graphs and plots
R also allows you to generate graphics and plots to visualise harmonized data. For example, you can create a box plot using the boxplot()
function or a histogram using the hist()
function.
# Box plot and histogram of age at baseline for GLOBE Study
boxplot(globe_data$sdc_age_0)
hist(globe_data$sdc_age_0)
# Box plot and histogram of age at baseline for RECORD
boxplot(record_data$sdc_age_0)
hist(record_data$sdc_age_0)
Note: Access the help files using
?boxplot
and?hist
to learn how to format your box plot or histogram, including how to create a title for your graph, label axes, add colour, subset observations or apply breaks to numerical data.
3.5 Pooled statistics
For pooled analyses, we will need a study indicator variable that will adjust for study effect in regression models (Section 5) . The following script creates a new collumn in each dataset called study and gives it a value of ‘GLOBE’ for all observations in globe_data and a value of ‘RECORD’ for all observations in record_data.
# Create a new column called study and assign values of GLOBE (for GLOBE study) and RECORD (for RECORD study)
globe_data['study']= "GLOBE"
record_data['study']= "RECORD"
Next, we use the rbind()
command to combine globe_data and record_data into a single pooled dataset.
# Combine dataframes into a pooled dataset using the rbind command
pooled_data <- rbind(globe_data, record_data)
You can play around with the functions outlined in this section to get descriptive statistics for the pooled dataset.


Preparation time
less than 30 mins
Cooking time
over 2 hours
Serves
8
For the beef, heat the oil in a heavy-based pan over a medium heat. Add the bacon and fry for 6-8 minutes, or until crisp and golden-brown.
Sprinkle the flour onto a plate and season with salt and freshly ground black pepper. Dredge the cubes of beef in the seasoned flour until coated.
Add the coated beef cubes to the pan with the bacon in it and fry for 4-5 minutes, turning regularly, until browned.
Add the onions and continue to fry for 3-4 minutes, or until softened but not coloured.
Add the wine, stock, bouquet garni, Worcestershire sauce and brandy and stir to combine. Cover the pan with a lid and bring the mixture to a simmer. Continue to simmer until the meat is tender and falling apart (about two hours if using braising steak, or three hours if using shin).
When the meat is tender, increase the heat and bring the cooking liquid to the boil. Continue to cook for 25-30 minutes, or until the volume of liquid has reduced by about half. Remove from the heat and set aside to cool.
Meanwhile, for the suet puddings, grease eight small pudding basins with butter.
In a bowl, mix together the flour, suet, thyme, sage and salt until well combined.
Gradually add just enough water until the mixture comes together as a firm dough (you may not need to use all of the water).
Add the egg yolk and knead it into the dough until well combined. Cover the bowl and chill the dough in the fridge for at least 30 minutes.
When the dough has chilled, pinch off eight equal portions of the dough.
Roll the first portion of dough into a ball and pinch off about a quarter of it. Roll the larger ball of dough out onto a lightly floured work surface into a large thin circle (set the smaller portion aside).
Line one of the prepared pudding basins with the suet pastry disc.
Fill the lined pudding basin with some of the beef and red wine sauce until it is three-quarters full.
Roll out the smaller portion of suet pastry onto a lightly floured work surface until it is just larger than the top of the pudding basin.
Brush the rim of the lined pudding basin with a little of the beaten egg. Cover the pudding basin with this pastry 'lid', pressing the edges of the pastry together to seal. Trim off any excess.
Brush the pastry 'lid' all over with a little more of the beaten egg.
Repeat the process with the remaining suet pastry and filling mixture until you have prepared eight individual puddings and all of the beef has been used up (reserve any leftover red wine sauce).
Wrap each pudding basin tightly in two sheets of aluminium foil.
Prepare a steamer large enough to hold all of the pudding basins (alternatively, cook the puddings in batches). Steam the puddings for 25-30 minutes, or until cooked through.
Meanwhile, for the parmentier potatoes, boil the potatoes, whole and in their skins, in a large pan of salted water for 18-20 minutes, or until tender. Drain well and set aside to cool. Once cool, peel away the skins and cut the potatoes into 1cm/½in cubes. Set aside to cool, then chill in the fridge.
Heat the butter in a frying pan over a medium heat. Add the cold diced potatoes and fry for 3-4 minutes, or until golden-brown on all sides. Remove from the heat and set aside.
Meanwhile, for the kidneys, heat one tablespoon of the oil in a frying pan over a medium heat. Add the onion, celery and carrot and fry for 4-5 minutes, or until softened.
Add the garlic and thyme and fry for a further 1-2 minutes.
In a separate frying pan, heat the remaining tablespoon of olive oil over a medium heat. Add the kidneys and cook for 5-6 minutes, or until just browned.
Add the browned kidneys to the pan with the vegetables in it.
Add the sherry to the pan the kidneys were cooked in and bring to a simmer, scraping up any browned bits from the bottom of the pan using a wooden spoon to deglaze. Add the sherry and pan juices to the vegetables and kidneys and stir well to combine. Continue to cook for a further 1-2 minutes.
Stir in the crème fraîche and heat through. Season, to taste, with salt and freshly ground black pepper. Stir in the parsley. Keep warm.
For the cauliflower cheese, boil the cauliflower florets in a pan for 4-5 minutes, or until tender. Drain well and pat dry with kitchen paper.
Transfer the cauliflower florets to a food processor. Add the cream and blend to a purée. Season, to taste, with salt and freshly ground black pepper.
Return the mixture to a clean pan and warm over a low heat. Stir in the cheese until melted.
For the peas, boil the peas in a pan of boiling water until tender. Drain well and return the peas to the pan. Stir in the oregano and butter. Season, to taste, with salt and freshly ground black pepper. Crush lightly with a potato masher. Set aside and keep warm.
Just before serving, heat the remaining red wine sauce in a pan until warmed through.
Strain the sauce through a fine sieve. Add a knob of butter to the strained liquid and stir until melted.
To serve, unwrap one beef suet pudding and turn it out of its mould and onto a serving plate. Spoon some of the kidneys alongside. Press a portion of the crushed peas into a chefs' ring and remove the ring. Spoon the cauliflower cheese purée and parmentier potatoes alongside. Drizzle over the red wine sauce.


A reasoner is a piece of software that examines an ontology and infers links that have not been explicitly stated by a curator. The structure and relationships of the ontology encode knowledge. Each relationship type has specific relations, and a reasoner uses these to deduce further information about the ontology.
The OBO-Edit reasoner is a very simple (but relatively fast) reasoning tool that relies on a small set of rules to make inferences about the ontology.
The reasoner deduces every single implied fact in an ontology. Every non-redundant ontology encodes a lot of implicit information, so the reasoner can use a lot of memory as it makes this implicit information explicit. See The Configuration Plugin for information about how to increase the memory available to OBO-Edit.
This section documents all the rules OBO-Edit uses for reasoning. Realize that all these rules interact. If an implied link is discovered, that implied link may be used to discover yet other implied links.
A transitive relation is one where if there is a link "A -transitive_relation-> B" and "B -transitive_relation-> C", then "A -transitive_relation-> C". part_of is a transitive relation, so if "finger -part_of-> hand" and "hand -part_of-> arm", then it is implied that "finger -part_of-> arm". Transitive relationships are always preserved over is_a links, so if "A -transitive_relation-> B" and "B -is_a-> C" then "A -transitive_relation-> C". See An Introduction to OBO Ontologies for more information.
The OBO-Edit reasoner infers all the relationships in an ontology that are implied by transitivity but not explicitly stated. Consider the following simple ontology:
is_a and part_of are transitive relations, so the reasoner will deduce the following implied links:
This is an extremely simple rule. It says that if a term has a cross product definition, the relationships in that definition hold true for the term itself at all times.
For example, let's say the following cross-product is defined for "cell development":
The reasoner will determine that "cell differentiation" has an implied affects relationship to "cell", because of the cross product definition. It will also assume that "cell differentiation" has an implied is_a relationship to "development" because of the genus section of the cross product definition.
This rule infers is_a links implied by cross product definitions. One way of understanding this is to say that some terms in an ontology may "match" some other term's cross product defintion. If a term matches another term's cross product defintion, an is_a link is created between the terms.
A term matches a cross product definition when:
Recall that once the reasoner is running, implied links can be used by reasoner rules to discover new implied links. Therefore, this reasoner rule has access to all the links that were generated by the transitivity rule. These extra links can lead to useful (and sometimes unexpected) implications from the reasoner.
Every time the reasoner discovers a new link, that discovery is based on some supporting links in the ontology. These supporting links are called the evidence or explanation for the new implied link.
Link evidence consists of two parts: The rule that was used to discover the implied link, and the links that were used to support the discovery. Implied links can be used as evidence for other implied links, so the evidence for one link might have its own evidence.
Every link in an ontology has evidence, even non-implied links. Links that were explicitly created by a human user are explained with the special evidence GIVEN. This piece of evidence means that the link was made by a human, not the reasoner.
It is possible for a link to have more than one explanation. A link may be implied by transitivity, and multiple collections of links can be used to support that implication. The reasoner records every possible explanation for an implied link.
See The Explanation Plugin to learn how to see the evidence for implied links.
The reasoner has the capability to check the ontology for certain kinds of problems. In the future, the reasoner will support many different checks, but right now the reasoner only checks for:
Redundant links are links that were explicitly created by a human but are unncessary because that link is implied by other facts in the ontology. Consider this version of our elephant ontology:
The link "tusk -part_of-> animal" is redundant, because that relationship is already implied by transitivity.
Formally, a redundant link is any link with multiple explanations, one of which is GIVEN. This definition works because if a link has multiple explanations, the reasoner must have discovered at least one of them, and if one of the explanations is GIVEN, a human must have created the link. Therefore, a human has created a link that the reasoner was able to infer automatically, making the link redundant.
By default, redundant links are shown with a red arrow. It is possible to create special searches, filters and renderers for redundant links. See Link Filters for more information.
The OBO-Edit reasoner is very limited at the moment. Things that it currently cannot do include:
These capabilities will be slowly added in future versions of OBO-Edit.


THE GINGERBREAD MAN
Reviewed by Harvey Karten, Ph.D. PolyGram Filmed Entertainment/Island Pictures Director: Robert Altman Writer: John Grisham and Robert Altman (Al Hayes, pseudonym) Cast: Kenneth Branagh, Embeth Davidtz, Robert Duvall, Tom Berenger, Daryl Hannah, Famke Janssen, Robert Downey, Jr.
"The Gingerbread Man" may not imitate the daily headlines as much as "Wag the Dog," but it does show into what troubles a man can be dragged if he thinks with a part of his body other than his head.  In this movie, in which John Grisham bypassed the book and scripted directly for the screen, a lawyer who has never lost a case in eight years becomes careless and forfeits the one litigation that would hurt him the most. "The Gingerbread Man" takes Grisham somewhat afield of his usual tales: this time his film is directed by Robert Altman, who is known to forego structure for atmosphere: who does just that in adeptly capturing the shadowy, sinewy, and stormy surroundings of Savannah. But Altman forgoes the laid-back, discontinuous structure of his most famous film, "Nashville" in favor of a taut, suspenseful, and occasionally violent work with a surprisingly effective twist in its concluding quarter hour.
Backed up by a team of major performers like Kenneth Branagh, Tom Berenger, Robert Duvall and the upcoming Embert Davidtz, Altman's film opens with his signature scene, a large, catered party--a surprise to celebrate lawyer Rick Magruder's big victory in gaining the release of a man who shot a cop. It's the sort of case that does not make lawyers into the heroes of police precincts and prompts even a private investigator hired by Magruder to quip (about an attorney who committed suicide) that at least one guy in the profession has a conscience.
During the party, Magruder's speech slurs over as he sloshes down some drinks and, when on a stormy night he witnesses a car theft at the expense of its owner, Mallory Doss (who served as part of the catering staff), he drives her home in his chic red Mercedes. After a tempestuous night of lovemaking, the divorced Magruder takes a liking to his new friend and decides to help her out, having learned that the alleged car thief is her own, insane father--who has been stalking her for years. His efforts to get the nutty father, Dixon Doss (Robert Duvall) locked up include his hiring of a laid-back private investigator, Clyde (Robert Downey jr.), the subpoena-forced testimony of Mallory's hostile ex-husband, peter Randall (Tom Berenger), and the witnessing of several fires including the blowing up of Mallory's car.
Altman's direction, however taut, takes its time in exposing the lives of his characters, particularly the dilemmas faced by the rich and successful lawyer whose problems do not allow him to enjoy his position to the fullest.  Unwisely, he rejects the advice of his associate in the law firm, the statuesque Lois (Daryl Hannah), who warns him regularly about his activities with bimbos and obviously cares quite a bit for him.
Branagh, it turns out, can enjoy slumming. The English actor takes a breaks from his usual Shakespearean roles to adopt a southern American accent and a goatee, and appears in virtually every one of photographer Changwei Gu's scenes. While Mr.Changwei expertly capitalizes on Savannah's old- world beauty, too many vistas take place in poorly-lit indoor locations, including Magruder's pine-panelled law office and the bar which constitutes Clyde's hangout and pick-up spot for bimbettes. Daryl Hannah plays well against type as the bespectacled lawyer's aide as does the lovely, slim Embeth Davidtz who may not be quite the angel she was with Denzel Washington in "Fallen."
The first part is the more interesting one: the picture turns increasingly melodramatic and difficult to accept. Far too often the heavy rain and routine, melodramatic actions remind us of the cloudburst-soaked film, "Hard Rain," and we lose the wit and clever dialogue that make the initial scenes particularly Altmanesque and thereby compelling. Mark Isham's music is most effective, becoming menacing as the movie progresses into the dark Savannah night. Rated R. Running Time: 115 minutes. (C) 1998 Harvey Karten
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


---
layout: default
id: Portfolio
title: Projects
description: The following are recent projects I've worked on that I feel are worth sharing. Additionally my Resume can be found Here
---
{% for post in site.categories.Project %}
{{ post.title }}
{{ post.content }}
{% if post.burl %}
I wrote a blog post about this project, you can read it here!
{% endif %}
{% if post.purl %}
You can also see the GitHub repository for this project here!


{% extends '_layouts/layout_2-3_1-3_v4.html' %}
{% block page_title %}
Page per GP - NHS.UK
{% endblock page_title %}
{% block pageTitle %}
Meanwood Group Practice
{% endblock pageTitle %}
{% block surgeryInfo %}
{% include '_includes/archive/v4/contact-details.html' %}
{% include '_includes/archive/v4/open-emergency-same-day-appointments.html' %}
{% include '_includes/archive/v4/bank-holiday-times.html' %}
{% endblock %}
{% block content %}
{% include '_includes/archive/v4/things-you-can-do-online.html' %}
{% endblock content %}


World Train Station
Life is a train, Get on board!
Current Train Schedule
Train name
Destination
Frequency (mins)
Next Arrival
Minutes away
Add Train
Train Name
Destination
First Train Time (HH:mm - military time)
Frequency (min)
Submit