Interprets parsed frames from the peer, and packs and writes frames.
TODO: Multiplex by RSV.
TODO: Stream writing.
Protected Properties | |
| string | $buffer = '' |
| The message buffer for data frames. More... | |
| WebSocketClient | $client |
| int null | $continue |
Resume opCode for the CONTINUATION handler. More... | |
| int | $fragmentSize = 128 * 1024 |
| Max outgoing fragment size. More... | |
| int | $maxLength = 10 * 1024 * 1024 |
| Maximum inbound message length (complete payload). More... | |
| FrameReader | $reader |
| bool | $stream = false |
| Whether binary I/O should bypass buffers. More... | |
Public Methods | |
| __construct (WebSocketClient $client) | |
| int | getFragmentSize () |
| int | getMaxLength () |
| bool | isStream () |
| void | onFrame (Frame $frame) |
| Called by WebSocketClient when a complete frame has been received. More... | |
| void | onReadable () |
| Uses FrameReader to read frames and passes them off to onFrame(). More... | |
| $this | setFragmentSize (int $bytes) |
| $this | setMaxLength (int $bytes) |
| $this | setStream (bool $stream) |
| void | write (int $opCode, string $payload) |
| Sends a complete message to the peer, fragmenting if needed. More... | |
| void | writeBinary (string $payload) |
| void | writeClose (int $code=Frame::CLOSE_NORMAL, string $reason='') |
| void | writePing (string $payload='') |
| void | writePong (string $payload='') |
| void | writeText (string $payload) |
Protected Methods | |
| void | onBinary (Frame $frame) |
Progressively receives BINARY data into the buffer until the payload is complete. More... | |
| void | onClose (Frame $frame) |
When a CLOSE frame is received. More... | |
| void | onContinuation (Frame $frame) |
When a CONTINUATION frame (data fragment) is received. More... | |
| void | onControl (Frame $frame) |
| When a control frame is received. More... | |
| void | onData (Frame $frame) |
When an initial data frame (not CONTINUATION ) is received. More... | |
| void | onData_CheckLength (Frame $frame) |
| Validates the message length, but only when the buffer is in use. More... | |
| void | onPing (Frame $frame) |
When a PING is received. More... | |
| void | onPong (Frame $frame) |
When a PONG is received. More... | |
| void | onText (Frame $frame) |
Progressively receives TEXT data until the payload is complete. More... | |
| void | writeFrame (bool $final, int $opCode, string $payload) |
| Writes a single frame. More... | |
|
protected |
The message buffer for data frames.
|
protected |
Resume opCode for the CONTINUATION
handler.
|
protected |
Max outgoing fragment size.
Each browser has its own standard, so this is generalized.
Defaults to 128 KiB.
|
protected |
Maximum inbound message length (complete payload).
Defaults to 10 MiB.
|
protected |
Whether binary I/O should bypass buffers.
| __construct | ( | WebSocketClient | $client | ) |
| WebSocketClient | $client |
| int getFragmentSize | ( | ) |
| int getMaxLength | ( | ) |
| bool isStream | ( | ) |
|
protected |
Progressively receives BINARY
data into the buffer until the payload is complete.
Passes the complete payload up to WebSocketClient::onBinary()
When $stream is true
, this bypasses the buffer.
| Frame | $frame |
| WebSocketError |
|
protected |
When a CLOSE
frame is received.
Calls WebSocketClient::onClose()
https://tools.ietf.org/html/rfc6455#section-5.5.1
If an endpoint receives a Close frame and did not previously send a Close frame, the endpoint MUST send a Close frame in response. (When sending a Close frame in response, the endpoint typically echos the status code it received.)
| Frame | $frame |
|
protected |
When a CONTINUATION
frame (data fragment) is received.
| Frame | $frame |
| WebSocketError |
|
protected |
When a control frame is received.
https://tools.ietf.org/html/rfc6455#section-5.4
Control frames (see Section 5.5) MAY be injected in the middle of a fragmented message.
| Frame | $frame |
|
protected |
When an initial data frame (not CONTINUATION
) is received.
| Frame | $frame |
|
protected |
Validates the message length, but only when the buffer is in use.
| Frame | $frame |
| WebSocketError |
| void onFrame | ( | Frame | $frame | ) |
Called by WebSocketClient when a complete frame has been received.
Delegates to the other handler methods using the program logic outlined in the RFC.
Eventually calls back to the WebSocketClient when payloads are complete.
| Frame | $frame |
|
protected |
|
protected |
| void onReadable | ( | ) |
Uses FrameReader to read frames and passes them off to onFrame().
|
protected |
Progressively receives TEXT
data until the payload is complete.
Validates the complete payload as UTF-8 and passes it up to WebSocketClient::onText()
| Frame | $frame |
| WebSocketError |
| $this setFragmentSize | ( | int | $bytes | ) |
| int | $bytes |
| $this setMaxLength | ( | int | $bytes | ) |
| int | $bytes |
| $this setStream | ( | bool | $stream | ) |
| bool | $stream |
| void write | ( | int | $opCode, |
| string | $payload | ||
| ) |
Sends a complete message to the peer, fragmenting if needed.
| int | $opCode | |
| string | $payload |
| void writeBinary | ( | string | $payload | ) |
| string | $payload |
| void writeClose | ( | int | $code = Frame::CLOSE_NORMAL , |
| string | $reason = '' |
||
| ) |
| int | $code | |
| string | $reason |
|
protected |
Writes a single frame.
| bool | $final | |
| int | $opCode | |
| string | $payload |
| void writePing | ( | string | $payload = '' | ) |
| string | $payload |
| void writePong | ( | string | $payload = '' | ) |
| string | $payload |
| void writeText | ( | string | $payload | ) |
| string | $payload |


s6-portable-utils
Software
skarnet.org
The s6-seq program
s6-seq prints a sequence of numbers.
Interface
s6-seq [ -w ] [ -s separator ] limits
- limits can be one, two or three arguments.
- Three arguments are interpreted as first,
increment and last, in this order.
- Two arguments are interpreted as first and
last, and increment defaults to 1.
- One argument is interpreted as last, and
first and increment both default to 1.
- s6-seq prints all unsigned integers from first
to last inclusive, with a step of increment,
with a newline after each integer.
It then exits 0.
Options
- -w : fixed width. The numbers will all be printed
with the same width; smaller numbers will have leading 0
characters.
- -s sep : print sep after
each number. Default is a newline. If sep
is the empty string, a null character will be printed.
Notes
s6-seq is similar to the GNU seq program. However, it
does not handle negative numbers, floating point numbers or
printf-style formatting.


It is often claimed that an important aspect of expert systems is the ability to explain their behavior. This means the user can ask the system for justification of conclusions or questions at any point in a consultation with an expert system. The system usually responds with the rules that were used for the conclusion, or the rules being considered which led to a question to the user.
The importance of this feature is probably overestimated for the user. Typically the user just wants the answer. Furthermore, when the user does want an explanation, the explanation is not always useful. This is due to the nature of the "intelligence" in an expert system.
The rules typically reflect empirical, or "compiled" knowledge. They are codifications of an expert's rules of thumb, not the expert's deeper understanding which led to the rules of thumb. For example, consider the following dialog with an expert system designed to give advice on car problems:
Does the car start? no.
Does the engine turn over? yes.

Recommendation - Wait 5 minutes and try again.
why?
I used the rule:
If not start, and
engine_turn_over, and
smell_gas
Then recommend is 'Wait 5 minutes and try again.'.
The rule gives the correct advice for a flooded car, and knows the questions to ask to determine if the car is flooded, but it does not contain the knowledge of what a flooded car is and why waiting will help. If the user really wanted to understand what was happening, he/she would need a short dissertation on carburetors, how they behave, and their relationship to the gas pedal.
For a system such as this to have useful explanations, it would need to do more than parrot the rules used. One approach is to annotate the rules with deeper explanations. This is illustrated in chapter 10. Another approach being actively researched is to encode the deeper knowledge into the system and use it to drive both the inference and the explanations.
On the other hand, there are some systems in which the expert's knowledge is just empirical knowledge. In this case, the system's explanation is useful to the user. Classification systems such as the bird identification system fall in this category. The Bird system would explain an identification of a laysan albatross with the rule used to identify it. There is no underlying theory as to why a white albatross is a laysan albatross and a dark one is a black footed albatross. That is simply the rule used to classify them.
While an explanation feature might be of questionable value to the user of the system, it is invaluable to the developer of the system. It serves the same diagnostic purpose as program tracing for conventional programs. When the system is not behaving correctly, the expert can use the explanations to find the rules which are in error. The knowledge engineer uses the explanations to better tune the knowledge base to have more realistic dialogs with the user.
There are four types of explanations commonly used in expert systems. We will implement most of these in both the Clam shell and the Native shell:
• a rule trace which reports on the progress of a consultation;
• explanation of how the system reached a given conclusion;
• explanation of why the system is asking a question;
• explanation of why not a given conclusion.
Since we wrote the inference engine for Clam it will not be difficult to modify it to include these features. The Native system currently uses Prolog's inference engine. In order to add explanation it will be necessary to write our own Prolog inference engine. Fortunately it is not difficult to write Prolog in Prolog.
First, let's look at some examples of the explanation features of Clam using the Car system. Here is how the user turns on tracing for the consultation, and the results. The new trace information is in bold. It shows the sequence of rule firings as they are expected.  The user would ask why and get the inference chain that led to the question. For example:
...
Is the radio weak?
: why
rule 3
If
radio_weak
Then
battery_bad 50
rule 1
If
not turn_over
battery_bad
Then
problem is battery 100
goal problem
...
Notice that the why explanation gives the chain of rules, in reverse order, that led to the question. In this case the goal problem led to rule 1 which led to rule 3.
The how explanations start with answers. For example, the system has just reported that the problem is the battery. The user wants to know how this result was derived.
...
problem-battery-cf-75
done with problem
consult, restart, load, list, trace, how, exit
:how
Goal? problem is battery
problem is battery was derived from rules: 1
rule 1
If
not turn_over
battery_bad
Then
problem is battery 100
In this case the rule(s) which directly supported the result are listed. Next the user wants to know how battery_bad was derived.
consult, restart, load, list, trace, how, exit
:how
Goal? battery_bad
battery_bad was derived from rules: 3 2
rule 3
If
radio_weak
Then
battery_bad 50
rule 2
If
lights_weak
Then
battery_bad 50
In this case there were two rules which supported the goal, and the system lists them both.
Figure 4.1 shows the difference between how and why questions. The why questions occur at the bottom of an inference chain, and the how questions occur at the top.
Figure 4.1. Difference between how and why questions
The first explanation addition to Clam will be the rule tracing facility. It will behave similarly to the Prolog box model traces, and inform the user when a rule is "call"ed, "exit"ed, or "fail"ed. It will use a special predicate bugdisp to communicate trace information with the user. It will take as an argument a list of terms to be written on a line.
|
To make it a user option, bugdisp will only write if ruletrace is true. The user will have a new high level command to turn tracing on or off which will assert or retract ruletrace. We can then use bugdisp to add any diagnostics printout we like to the program. |
bugdisp(L)
:-
ruletrace,
write_line(L), !.
bugdisp(_).
write_line([]) :- nl.
write_line([H|T])
:-
write(H),
tab(1),
write_line(T).
Here is the new command added to the do predicate called by the command loop predicate, go. It allows the user to turn tracing on or off by issuing the command trace(on) or trace(off).
do( trace(X) ) :- set_trace(X), !.
set_trace(off)
:-
ruletrace,
retract( ruletrace ).
set_trace(on)
:-
not ruletrace,
asserta( ruletrace ).
set_trace(_).
Now
that we have the tools for displaying trace information, we need to add bugdisp
calls in the predicate which recursively tries rules, fg. It is easy
to determine in fg when a rule is called and when it has been successful.
After the call to rule succeeds, the rule has been called. After the
call to prove, the rule has been successfully fired. The new code for
the predicate is added in bold.
fg(Goal, CurCF)
:-
rule(N, lhs(IfList), rhs(Goal, CF)),
bugdisp(['call rule', N]),
prove(N, IfList, Tally),
bugdisp(['exit rule', N]),
adjust(CF, Tally, NewCF),
update(Goal, NewCF, CurCF, N),
CurCF == 100, !.
fg(Goal, CF) :- fact(Goal, CF).
All that remains is to capture rules that fail after being called. The place to do this is in a second clause to prove, which is called when the first clause fails. The second clause informs the user of the failure, and continues to fail.
prove(N, IfList,
Tally) :-
prov(IfList, 100, Tally), !.
prove(N, _,
_) :-
bugdisp(['fail rule', N]),
fail.
The next explanation feature to implement is how. The how question is asked by the user to see the proof of some conclusion the system has reached. The proof can be generated by either rederiving the result with extra tracing, or by having the original derivation stored in working storage. Clam uses the second option and stores derivation information with the fact in working storage. Each fact might have been derived from multiple rules, all concluding the same attribute value pair and combining certainty factors. For this reason, a list of rule numbers is stored as the third argument to fact. This is not the entire proof tree, but just those rules which conclude the fact directly.
fact(AV, CF, RuleList)
A fact is updated by update, so this is where the derivation is captured. A new argument is added to update which is the rule number that caused the update. Note that the first clause of update adds the new rule number to the list of existing derivation rule numbers for the fact. The second clause merely creates a new list with a single element.
update(Goal,
NewCF, CF, RuleN) :-
fact(Goal, OldCF, _),
combine(NewCF, OldCF, CF),
retract( fact(Goal, OldCF, OldRules) ),
asserta( fact(Goal, CF, [RuleN | OldRules]) ), !.
update(Goal,
CF, CF, RuleN) :-
asserta( fact(Goal, CF, [RuleN]) ).
The call to update from fg is modified to fill in the new argument with a rule number:
fg(Goal, CurCF)
:-
rule(N, lhs(IfList), rhs(Goal, CF)),
...
update(Goal, NewCF, CurCF, N),
...
Now that the supporting rules for each derived fact are in working storage we can answer a user's question about how a fact was derived. The simplest thing to do is to have how simply write the list of rules used. It is probably of more interest to the user to actually display the rules as well. The predicate list_rules does that.
how(Goal)
:-
fact(Goal, CF, Rules),
CF > 20,
pretty(Goal, PG),
write_line([PG, was, derived, from, 'rules: '|Rules]),
nl,
list_rules(Rules),
fail.
how(_).
The how predicate for negated goals is similar and uses the fact that negation is represented by a negative CF.
how(not Goal)
:-
fact(Goal, CF, Rules),
CF < -20,
pretty(not Goal, PG),
write_line([PG, was, derived, from, 'rules: '|Rules]),
nl,
list_rules(Rules),
fail.
The pretty predicate is used to convert av structures into a more readable list and visa versa.
pretty(av(A, yes), [A]) :- !.
pretty(not av(A, yes), [not, A]) :- !.
pretty(av(A, no), [not, A]) :- !.
pretty(not av(A, V), [not, A, is, V]).
pretty(av(A, V), [A, is, V]).
The list_rules predicate writes a formatted listing of each rule used in deriving a given fact.
list_rules([]).
list_rules([R|X])
:-
list_rule(R),
list_rules(X).
list_rule(N)
:-
rule(N, lhs(Iflist), rhs(Goal, CF)),
write_line(['rule ', N]),
write_line(['If']),
write_ifs(Iflist),
write_line(['Then']),
pretty(Goal, PG),
write_line([' ', PG, CF]), nl.
write_ifs([]).
write_ifs([H|T])
:-
pretty(H, HP),
tab(5), write_line(HP),
write_ifs(T).
We can use pretty in reverse, along with a predicate that reads a list of tokens from a line to provide a nicer interface to the user for how questions. In this way the user doesn't have to specify the internal form of the fact.
how :-
write('Goal? '), read_line(X), nl,
pretty(Goal, X),
how(Goal).
The how command can now be added as part of the top level user interface:
do(how) :- how, !.
The full how command as coded above just displays for the user the rules directly responsible for a fact. These rules themselves are likely based on other facts which were derived as well. There are two ways of presenting this information:
• let the user ask further hows of the various rules' left hand side goals to delve deeper into the proof tree;
• have how automatically display the entire proof tree.
So far we have chosen the first. In order to implement the second choice, a predicate how_lhs needs to be written which will trace the full tree by recursively calling how for each of the goals in the Iflist of the rule.
list_rules([]).
list_rules([R|X])
:-
list_rule(R),
how_lhs(R),
list_rules(X).
how_lhs(N)
:-
rule(N, lhs(Iflist), _),
!, how_ifs(Iflist).
how_ifs([]).
how_ifs([Goal|X])
:-
how(Goal),
how_ifs(X).
The three choices of user interface for hows (just rule numbers, listings of direct rules, list of full proof tree) shows some of the problems with shells and the advantages of a toolbox approach. In a customized expert system, the options which makes the most sense for the application can be used. In a generalized system the designer is faced with two unpleasant choices. One is to keep the system easy to use and pick one option for all users. The other is to give the flexibility to the user and provide all three, thus making the product more complex for the user to learn.
The how question is asked from the top level of an inference, after the inference has been completed. The why question is asked at the bottom of a chain of rules when there are no more rules and it is time to ask the user. The user wants to know why the question is being asked.
|
In order to be able to answer this type of question, we must keep track of the inference chain that led to the question to the user. One way to do this is to keep an extra argument in the inference predicates that contains the chain of rules above it in the inference. This is done in findgoal and prove. Each keeps a separate argument Hist which is the desired list of rules. The list is initially the empty list at the top call to findgoal. |
findgoal(Goal,
CurCF, Hist) :-
fg(Goal, CurCF, Hist).
fg(Goal, CurCF,
Hist) :-
...
prove(N, IfList, Tally, Hist),
...
The prove predicate maintains the list by adding the current rule number on the head of the list before a recursive call to findgoal. The calls further down the recursion have this new rule number available for answers to why questions. Notice that both Prolog's recursive behavior and backtracking assure that the history is correct at any level of call.
prove(N, IfList,
Tally, Hist) :-
prov(IfList, 100, Tally, [N|Hist]), !.
prove(N, _,
_) :-
bugdisp(['fail rule', N]),
fail.
prov([], Tally, Tally, Hist).
prov([H|T], CurTal,
Tally, Hist) :-
findgoal(H, CF, Hist),
min(CurTal, CF, Tal),
Tal >= 20,
prov(T, Tal, Tally, Hist).
Finally, we need to give the user the ability to ask the why question without disturbing the dialog. This means replacing the old reads of user input with a new predicate, get_user which gets an answer from the user and processes it as a why command if necessary. Hist is of course passed down as an argument and is available for get_user to process. Also, rather than just displaying rule numbers, we can list the rules for the user as well.
The process_ans predicate first looks for command patterns and behaves accordingly. If it is a command, the command is executed and then failure is invoked causing the system to backtrack and reask the user for an answer.
Note that now that we are capturing and interpreting the user's response with more intelligence, we can give the user more options. For example, at the question level he/she can turn tracing on or off for the duration of the session, ask a how question, or request help. These are all easily added options for the implementer.
get_user(X,
Hist) :-
repeat,
write(': '),
read_line(X),
process_ans(X, Hist).
process_ans([why], Hist) :- nl, write_hist(Hist), !, fail.
process_ans([trace, X], _) :- set_trace(X), !, fail.
process_ans([help], _) :- help, !, fail.
process_ans(X, _). % just return user's answer
write_hist([]) :- nl.
write_hist([goal(X)|T])
:-
write_line([goal, X]),
!, write_hist(T).
write_hist([N|T])
:-
list_rule(N),
!, write_hist(T).
Since we wrote the inference engine for Clam, it was easy to modify it to add the code for explanations. However, when we use pure Prolog, we don't have access to the inference engine.
This problem is easily solved. We simply write a Prolog inference engine in Prolog. Then, having written the inference engine, we can modify it to handle explanations.
An inference engine has to have access to the rules. In Prolog, the clauses are themselves just Prolog terms. The built-in predicate clause gives us access to the rules. It has two arguments which unify with the head of a clause and its body. A fact has a body with just the goal true.
Predicates which manipulate Prolog clauses are confusing to read due to the ambiguous use of the comma in Prolog. It can be either: an operator used to separate the subgoals in a clause; or a syntactic separator of functor arguments. Prolog clauses are just Prolog terms with functors of ":-" and ",". Just for now, pretend Prolog used an "&" operator to separate goals rather than a "," operator. Then a clause would look like:
a :- b & c & d.
Without the operator definitions it would look like:
:-(a, &(b, &(c, d))).
The clause built-in predicate picks up the first and second arguments of the ":-" functor. It will find the entire Prolog database on backtracking. If patterns are specified in either argument, then only clauses which unify with the patterns are found. For the above clause:
?- clause(Head, Body).
Head = a
Body = b & c & d
A recursive predicate working through the goals in Body would look like:
recurse(FirstGoal
& RemainingGoals) :-
process(FirstGoal),
recurse(RemainingGoals).
recurse(SingleGoal)
:-
process(SingleGoal).
The use of "&" was just to distinguish between the two commas in Prolog. To resolve ambiguous references to commas as in the first line of the above code, parenthesis are used. The first line should really be written:
recurse( (FirstGoal,
RemainingGoals) ) :-
...
See Clocksin & Mellish Section 2.3, Operators for a full discussion of operators.
Given the means to access and manipulate the Prolog database of facts and rules, a simple Prolog interpreter that proves a list of goals (goals separated by the "," operator) would look like:
prove(true) :- !.
prove((Goal,
Rest)) :-
clause(Goal, Body),
prove(Body),
prove(Rest).
prove(Goal)
:-
clause(Goal, Body),
prove(Body).
Notice that prove mimics precisely Prolog's behavior. First it finds a clause whose head matches the first goal. Then it proves the list of goals in the Body of the clause. Notice that unification automatically occurs between the Goal for the head of the clause and the Body. This is because the Prolog clause is just a Prolog term. If it succeeds, it continues with the rest of the goals in the list. It it fails, it backtracks and finds the next clause whose head unifies with the Goal.
This interpreter will only handle pure Prolog whose clauses are asserted in the database. It has no provisions for built-in predicates. These could be included by adding a final catchall clause:
prove(X) :- call(X).
For Native we do not intend to have Prolog built-in predicates, but we do intend to call ask and menuask. For the Native shell these are our own built-in predicates.
We will make some basic modifications to our Prolog interpreter to allow it to handle our own built-in predicates and record information for explanations. First, we write an intermediate predicate prov that calls clause. It can also check for built-in predicates such as ask and menuask in the system. If the goal is either of these, they are just called with real Prolog.
Next we add an extra argument, just as we did for Clam. The extra argument keeps track of the level of nesting of a particular goal. By passing this history along to the ask predicates, the ask predicates can now respond to why questions.
prove(true, _) :- !.
prove((Goal,
Rest), Hist) :-
prov(Goal, (Goal, Rest)),
prove(Rest, Hist).
prov(true, _) :- !.
prov(menuask(X, Y, Z), Hist) :- menuask(X, Y, Z, Hist), !.
prov(ask(X, Y), Hist) :- ask(X, Y, Hist), !.
prov(Goal,
Hist) :-
clause(Goal, List),
prove(List, [Goal|Hist]).
Notice that the history is a list of goals, and not the full rules as saved in Clam.
The next step is to modify the top level predicate which looks for birds. First add an empty history list as an argument to the top call of prove:
solve :-
abolish(known, 3),
define(known, 3),
prove(top_goal(X), []),
write('The answer is '), write(X), nl.
solve :-
write('No answer found'), nl.
The processing of why questions is the same as in Clam.
get_user(X,
Hist) :-
repeat,
read(X),
process_ans(X, Hist), !.
process_ans(why,
Hist) :-
write(Hist), !, fail.
process_ans(X, _).
The dialog with the user would look like:
?- identify.
nostrils : external_tubular? why.
[nostrils(external_tubular), order(tubenose), family(albatross), bird(laysan_albatross)]
nostrils : external_tubular?
We can further use clause to answer how questions. In Clam we chose to save the derivations in the database. For native Prolog it is easier just to rederive the answer.
how(Goal)
:-
clause(Goal, List),
prove(List, []),
write(List).
It is also possible to ask whynot questions which determine why an expected result was not reached. This also uses clause to find the clauses which might have proved the goals, and goes through the list of goals looking for the first one that failed. It is reported, and then backtracking causes any other clauses which might have helped to be explained as well.
whynot(Goal)
:-
clause(Goal, List),
write_line([Goal, 'fails because: ']),
explain(List).
whynot(_).
explain( (H,
T) ) :-
check(H),
explain(T).
explain(H)
:-
check(H).
check(H) :- prove(H, _), write_line([H, succeeds]), !.
check(H) :- write_line([H, fails]), fail.
The whynot predicate has the same design problems as how. Do we automatically recurse through a whole failure tree, or do we let the user ask successive whynot's to delve deeper into the mystery. This version just gives the first level. By adding a recursive call to whynot in the second clause of check, it would print the whole story.
4.1 - Implement whynot for Clam.
4.2 - Have whynot give a full failure history.
4.3 - Make sure the explanation facility can handle attribute object value triples in both Clam and Native.
4.4 - Decide whether you like the full rules presented in answer to why questions as in Clam, or just the goals as in Native. Make both systems behave the same way.
4.5 - Enhance the trace function so it displays the goals currently being sought by the system. Have various levels of trace information that can be controlled by the trace command.
4.6 - Using prove, implement a Prolog trace function.
4.7 - Add a pretty printing predicate for Native to use when displaying Prolog rules.
Copyright ©1989,2000 Amzi! inc. All Rights Reserved.


{% extends "layout/base.html" %} {% block content %}
Select furniture items:
Choose condition of item:
Choose brand of item:
Choose material of item:
Choose color of item:


We buy infrastructure!
- grow out-of-the-box vortals
- repurpose synergistic deliverables
- reintermediate revolutionary metrics
- morph sexy networks
- envisioneer impactful functionalities
- syndicate seamless models
- deliver innovative bandwidth
- benchmark cross-platform paradigms
- e-enable holistic initiatives
- morph proactive relationships


Is taxation just?
Taxation is defined to be the government taking some material thing from a citizen of that government, often money,regularly.
Yes, taxation is just.
No, taxation is unjust.
Back


READY TO EXPLORE?
Click on any icon to find its place on the map.
CORKTOWN
WOODBRIDGE
EASTERN MARKET
MEXICAN TOWN
MIDTOWN
RESET


Sam Nabi
— Carina C. Zona, Schemas for the real world
"Machine-learning systems often reflect biases in the real world."
– Vivienne Ming, artificial intelligence expert
"Blocking functionality must be part of any social network’s minimum viable product. Because without a block button, social networks are essentially unusable — not viable — for many marginalized people." — Eva Gantz
David Heinemeier Hansson, Reconsider
Executive teams with women are more likely to receive later-stage funding.
... but all-male teams are 3x more likely to receive funding in the first place.
techworker.coop
gojuno.com
|<EMAIL_ADDRESS>| |
| @samnabi | |
| Github | samnabi |
| Website | samnabi.com |


Loopy
Form a single closed loop out of the grid edges, in such a way that every numbered square has exactly that many of its edges included in the loop.
Click on a grid edge to mark it as part of the loop (black), and again to return to marking it as undecided (yellow). Right-click on a grid edge to mark it as definitely not part of the loop (faint grey), and again to mark it as undecided again.
When you have mastered the square grid, look in the Type menu for many other types of tiling!


Technical Documentation JS
Introduction
JavaScript is a cross-platform, object-oriented scripting language. It is a small and lightweight language. Inside a host environment (for example, a web browser), JavaScript can be connected to the objects of its environment to provide
programmatic control over them.
JavaScript contains a standard library of objects, such as Array, Date, and Math, and a core set of language elements such as operators, control structures, and statements. Core JavaScript can
be extended for a variety of purposes by supplementing it with additional objects; for example:
-
Client-side JavaScript extends the core language by supplying objects to control a browser and its Document Object Model (DOM). For example, client-side extensions allow an application to place elements on an HTML form and respond to user events such as mouse clicks, form input, and page navigation.
-
Server-side JavaScript extends the core language by supplying objects relevant to running JavaScript on a server. For example, server-side extensions allow an application to communicate with a database, provide continuity of information from one invocation to another of the application, or perform file manipulations on a server.
what should you already know
This guide assumes you have the following basic background:
-
A general understanding of the Internet and the World Wide Web (WWW).
-
Good working knowledge of HyperText Markup Language (HTML).
-
Some programming experience. If you are new to programming, try one of the tutorials linked on the main page about JavaScript.
Hello world
To get started with writing JavaScript, open the Scratchpad and write your first "Hello world" JavaScript code:
function greetMe(yourName) { alert("Hello " + yourName); }
greetMe("World");
Select the code in the pad and hit Ctrl+R to watch it unfold in your browser!
Javascript and Java
JavaScript and Java are similar in some ways but fundamentally different in some others. The JavaScript language resembles Java but does not have Java's static typing and strong type checking. JavaScript follows most Java expression
syntax, naming conventions and basic control-flow constructs which was the reason why it was renamed from LiveScript to JavaScript.
In contrast to Java's compile-time system of classes built by declarations, JavaScript
supports a runtime system based on a small number of data types representing numeric, Boolean, and string values. JavaScript has a prototype-based object model instead of the more common class-based object model. The prototype-based
model provides dynamic inheritance; that is, what is inherited can vary for individual objects. JavaScript also supports functions without any special declarative requirements. Functions can be properties of objects, executing
as loosely typed methods.
JavaScript is a very free-form language compared to Java. You do not have to declare all variables, classes, and methods. You do not have to be concerned with whether methods are public, private, or protected, and you
do not have to implement interfaces. Variables, parameters, and function return types are not explicitly typed.
Variables
You use variables as symbolic names for values in your application. The names of variables, called identifiers, conform to certain rules.
A JavaScript identifier must start with a letter, underscore (_), or dollar sign ($); subsequent
characters can also be digits (0-9). Because JavaScript is case sensitive, letters include the characters "A" through "Z" (uppercase) and the characters "a" through "z" (lowercase).
You can use ISO 8859-1 or Unicode letters such as å and ü in identifiers. You can also use the Unicode escape sequences as characters in identifiers. Some examples of legal names are Number_hits, temp99, and _name.
Declaring-Variables
You can declare a variable in three ways:
With the keyword var. For example,
var x = 42.
This syntax can be used to declare both local and global variables.
By simply assigning it a value. For example,
x = 42
.
This always declares a global variable. It generates a strict JavaScript warning. You shouldn't use this variant.
With the keyword let. For example,
let y = 13.
This syntax can be used to declare a block scope local variable. See Variable scope below.
Variable scope
When you declare a variable outside of any function, it is called a global variable, because it is available to any other code in the current document. When you declare a variable within a function, it is called a local variable, because
it is available only within that function.
JavaScript before ECMAScript 2015 does not have block statement scope; rather, a variable declared within a block is local to the function (or global scope) that the block resides within. For example the following code will
log 5, because the scope of x is the function (or global context) within which x is declared, not the block, which in this case is an if statement.
if (true) { var x = 5; } console.log(x);
// 5 This behavior changes, when using the let declaration introduced in ECMAScript 2015.
if (true) { let y = 5; } console.log(y);
// ReferenceError: y is not defined
Global variables
Global variables are in fact properties of the global object. In web pages the global object is window, so you can set and access global variables using the window.variable syntax.
Consequently, you can access global variables declared in one window or frame from another window or frame by specifying the window or frame name. For example, if a variable called phoneNumber is declared in a document, you
can refer to this variable from an iframe as parent.phoneNumber.
Constants
You can create a read-only, named constant with the const keyword. The syntax of a constant identifier is the same as for a variable identifier: it must start with a letter, underscore or dollar sign and can contain alphabetic, numeric,
or underscore characters.
const PI = 3.14;
A constant cannot change value through assignment or be re-declared while the script is running. It has to be initialized to a value.
The scope rules for constants are the same as those for let block scope variables. If the const keyword is omitted, the identifier is assumed to represent a variable.
You cannot declare a constant with the same name as
a function or variable in the same scope. For example:
// THIS WILL CAUSE AN ERROR function
f() {}; const f = 5;
// THIS WILL CAUSE AN ERROR ALSO function f() { const g = 5; var g; //statements
}
However, object attributes are not protected, so the following statement is executed without problems.
const MY_OBJECT = {"key": "value"}; MY_OBJECT.key = "otherValue";


@@include('partials/header.html')
@@include('partials/cover.html') @@include('partials/about-me.html') @@include('partials/portfolio.html') @@include('partials/skills.html')
@@include('partials/footer.html')


IA Criterion B
#TomsProjects
Diagrams:
Database structure:
User registration:
User account activation
User login
Upload episode
Post comment:
Reply:
Discussions


AsyncProxy Examples
AsyncProxy is a simple helper library enables migrating a whole javascript class to a web-worker. The library supports some simple use cases which will be detailed in this page.
AsyncProxy Hello world!
The most simple use of AsyncProxy is to instantiate a class in a web worker and call its functions. For that the AsyncProxy should be provided the following data:
- The script(s) including the required code in the Web Worker (absolute path only).
- Class name to instantiate.
- Class's relevant method description.
Assume we have a class named Callee in a script '/scripts/callee.js', that has a simple method helloWorld. In order to create a Proxy class for the Callee class you only need to provide the above information by using the following lines:
(One way to get an absolute path is using the getEntryUrl() function, which returns the absolute path of the source page.)
The AsyncProxy library may be added to your page by:
<script src="http://MaMazav.github.io/cdn/async-proxy.dev.js"></script>
Let's demonstrate this basic usage by the following Callee class. The below Callee class will be used also in the rest of this page. For now, notice only the helloWorld() function which may take a lot of time:
Instantiating the Proxy and calling the helloWorld() from remote is easy as:
var proxy = new AsyncProxyHelloWorld({ helloWorldCtorArgument: 10000 });
proxy.helloWorld(50000);
Instantiating the AsyncProxyHelloWorld class will spawn an underlying Web Worker and call the Callee constructor there. Then, the call to proxy.helloWorld will activate the Callee.helloWorld method on the Web Worker.
An alternative way to manage the imported scripts will be described in the section about ScriptsToImportPool class.
Another equivalent way is to define the method by custom way:
This code is equivalent to the one defined in async-proxy-hello-world, unless it is more customable. It may be useful for complex features that will be shown later.
Sub-Worker emulation for Chrome
But what if the class already uses workers internally? It should be able to spawn its sub-workers although not supported at Chrome.
Using AsyncProxy that's not a problem. The AsyncProxy library emulates sub-workers for Chrome seamlessly. Notice, however, that those workers are actually spawned from the main thread context, thus a communication overhead affects the UI also.
Particularly, the proxied class can spawn sub-workers indirectly by using AsyncProxy library by itself, as in the callSubWorker() function of the Callee class above. The SubWorkerProxy class below defines the proxy method - by the same way we defined the simple hello world function: The sub-worker is supported transparently.
Passing special arguments and results
If the arguments and method result passed to and from the Web Worker are trivial, then defining method as above by "helloWorld: [ ]" is OK. However, in several cases a special treatment is needed for the arguments to be passed to or from the Web Worker:
- One-time callback argument - a function is not serializable. Special bookkeeping is required in order to pass callback calls from the Web Worker. Fortunately the async-proxy.js library can do that for you behind the scene. (see Custom Callback section for details about customizing callbacks for multiple calls).
- Promise return value - Similarly to function arguments, the async-proxy.js library can simulate returning Promise by special bookkeeping.
- Transferables - To avoid copying of heavy objects when passing arguments to Web Worker proxied function, transferables (also known as ports) can be used. Transferables are supported both in arguments and in a Promise result.
- Change call order - Sometimes massive function calls on Web Worker may take too long and block later function calls. If the later function calls are more important, they can be marked to be called immediately to bypass the earlier calls.
AsyncProxyHelloWorldCustom class below demonstrates the above features API:
The following code demonstrate calling these functions:
The custom equivalent way to define the above methods is below:
Manual termination
Terminating the underlying Web Worker is as easy as calling to terminate() function. Notice that if you need to do some release operations on the worker side when terminating the class (e.g. release resources, send information to server, etc.), you should wait for these operations to finish before calling to terminate(). In some use-cases Promise may be useful here.
Function terminate() also closes all sub-workers (including those were spawned using Chrome sub-workers emulation as explained above).
Custom callback options
We previously demonstrated a simple callback. The callbacks require the AsyncProxy library to save bookkeeping information in the Web Worker side in order to identify the original callback. By default this bookkeeping information is released after the first call to it, as stated above. If you would like to call the callback more than once you may change this behavior by customizing it as shown below:
Slave-side features
On all the cases mentioned above we didn't write any slave-side code (a code that is executed on the Web Worker), except of the proxied class itself. One may want to inject a slave-side code without changing the slave class implementation. The features in this section allows you to do so.
Custom creation of slave side instance
Until now we've seen a simple way to control the instance created on the slave side. The creation was done by passing a string indicates the class constructor name, and arguments array. If you would like to execute some logic in the slave side before creating the instance you need an additional
The setSlaveSideCreator allows you to do that - instead of defining a class which its instance will be created, you can provide a factory function which will create your instance using any logic you would like to and actually enables to define any way you would like to instantiate the class.
The slave-side script should call the setSlaveSideCreator function:
The master-side proxy definition should indicate that the above script is needed to be imported on the slave side:
Sending user data from slave to master
Until now, the only option to send data from slave to master is by using callback arguments sent by the master or by Promises.
It means that the master should initiate an action to allow the slave to send data. The sendUserDataToMaster
overcomes it.
The slave only need to send the data whenever he would like to:
The master can listen and receive the sent data by setting a handler for this:
setBeforeOperationListener
The slave is able to listen events happen on its side. It is done by providing a listener function to
setBeforeOperationListener
method.
The this
argument of the function is the slave side instance (either created automatically or by setSlaveSideCreator function).
The first argument that the listener function accepts is the event type. Currently the only possible event type is 'callback', and it will
be called before any time a callback is called by the slave instance. In case of callback the second argument of the listener function is
the callback name as was defined by the call to wrapCallback, and the third argument is the arguments passed
to the callback.
Contribution is welcome - it is easy to extends the AsyncProxy.js implementation to support more types of events.
ScriptsToImportPool class
An alternative of passing the absolute paths of each imported script is using the ScriptsToImportPool class. This approach is useful if the
imported scripts are already used in the master side. You can instantiate this class and call the addScriptFromErrorWithStackTrace
method from each script you would like to import. Then use the getScriptsForWorkerImport
method to get the list of scripts you
would like to import.
The addScriptFromErrorWithStackTrace
method is implemented according to an approach described
here. This approach requires an instance of Error
class, contains
which the stack trace when instantiating Error
. Thus this function requires an argument of the Error
class which
was instantiated in the correct script.
Practically, to use the ScriptsToImportPool, add two lines in the file contains the proxied class implementation:
Then you can use it when implementing the proxy:


{% include head.html %}
{% include header.html %} {% include body.html %} {% include form_contact_popup.html %}


Before Change
def whitespace_nlp_with_sentences(doc, entity_type=None, tag_type=None):
pat = re.compile(r"([A-Z][^\.!?]*[\.!?])", re.M)
sents = []
for sent in pat.findall(doc):
toks = []
for tok in re.split(r"(\W)", sent):
pos = "WORD"
After Change
def whitespace_nlp_with_sentences(doc, entity_type=None, tag_type=None):
pat = re.compile(r"([^\.!?]*?[\.!?$])", re.M)
sents = []
raw_sents = pat.findall(doc)
if len(raw_sents) == 0:
raw_sents = [doc]
for sent in raw_sents:
toks = []
for tok in re.split(r"(\W)", sent):
if len(tok) > 0:


--- layout: post title: Episode 013 | Carl Franklin - Just Be Awesome link: http://traffic.libsyn.com/developeronfire/DeveloperOnFire-Episode13-CarlFranklin.mp3 length: 37748736 speaker: Dave Rael duration: '40:09' subtitle: 'Developer On Fire: Carl Franklin' guest_name: Carl Franklin image: /assets/images/CarlFranklin.jpg guest_blog: http://carlfranklin.net/ guest_twitter: carlfranklin disqus_url: http://developeronfire.com/Podcast/Episodes/carl-franklin-just-be-awesome episode_number: 13 book_recommendations: - { url: "http://www.amazon.com/dp/0735619670/?tag=devonfir-20", title: "Code Complete: A Practical Handbook of Software Construction", author: "Steve McConnell"} tags: - { url: "http://www.amazon.com/dp/0735619670/?tag=devonfir-20", title: "Code Complete: A Practical Handbook of Software Construction", author: "Steve McConnell"} redirect_from: - "/13/" - "/013/" - "/0013/" - "/carl-franklin-just-be-awesome/" - "/Carl-Franklin/" - "/CarlFranklin/" - "/Podcast/Episodes/13/" - "/Podcast/Episodes/013/" - "/Podcast/Episodes/0013/" - "/Podcast/Episodes/carl-franklin-just-be-awesome/" - "/Podcast/Episodes/Carl-Franklin/" - "/Podcast/Episodes/CarlFranklin/" guid: http://developeronfire.com:80/Podcast/Episodes/carl-franklin-just-be-awesome ---


Gecode::Int::BoolView Class Reference
[Integer views]
Inherits Gecode::Int::IntView.
Detailed Description
Boolean view for integer variables.Provides convenient and efficient operations for Boolean views.
Definition at line 886 of file view.icc.
Constructors and initialization | |
| BoolView (void) | |
| Default constructor. | |
| BoolView (const BoolVar &b) | |
| Initialize from Boolean variable b. | |
| BoolView (const IntView &x) | |
| Initialize from integer variable x. | |
Boolean domain tests | |
| bool | zero (void) const |
| Test whether view is assigned to be zero. | |
| bool | one (void) const |
| Test whether view is assigned to be one. | |
| bool | none (void) const |
| Test whether view is not yet assigned. | |
Boolean assignment operations | |
| ModEvent | t_one (Space *home) |
| Try to assign view to one. | |
| ModEvent | t_zero (Space *home) |
| Try to assign view to zero. | |
| void | t_one_none (Space *home) |
| Assign not yet assigned view to one. | |
| void | t_zero_none (Space *home) |
| Assign not yet assigned view to zero. | |
Cloning | |
| void | update (Space *home, bool share, BoolView &x) |
| Update this view to be a clone of view x. | |
Test sharing between Boolean and negated Boolean views | |
| NegBoolView | |
| BoolTest | bool_test (const BoolView &b0, const BoolView &b1) |
| Test whether views b0 and b1 are the same. | |
| BoolTest | bool_test (const BoolView &b0, const NegBoolView &b1) |
| Test whether views b0 and b1 are complementary. | |
| BoolTest | bool_test (const NegBoolView &b0, const BoolView &b1) |
| Test whether views b0 and b1 are complementary. | |
| BoolTest | bool_test (const NegBoolView &b0, const NegBoolView &b1) |
| Test whether views b0 and b1 are the same. |
Constructor & Destructor Documentation
|
|
Default constructor.
|
|
|
Initialize from Boolean variable b.
|
|
|
Initialize from integer variable x.
|
Member Function Documentation
|
|
Test whether view is assigned to be zero.
|
|
|
Test whether view is assigned to be one.
|
|
|
Test whether view is not yet assigned.
|
|
|
Try to assign view to one.
|
|
|
Try to assign view to zero.
|
|
|
Assign not yet assigned view to one.
|
|
|
Assign not yet assigned view to zero.
|
|
|
Update this view to be a clone of view x.
|
Friends And Related Function Documentation
|
|
Test whether views b0 and b1 are the same.
|
|
|
Test whether views b0 and b1 are complementary.
|
|
|
Test whether views b0 and b1 are complementary.
|
|
|
Test whether views b0 and b1 are the same.
|
The documentation for this class was generated from the following files:
- gecode/int/view.icc (Revision: 3559)
- gecode/int/view/bool.icc (Revision: 3559)


Privacy Policy
Note on translation - This Privacy Policy Statement may have been translated into various languages for the convenience of 'Blazing Trader' Users. While the translation is correct to the best of 'Blazing Trader’s' knowledge, 'Blazing Trader' is not responsible or liable in the event of an inaccuracy. English is the controlling language of this Privacy Policy Statement, and any translation has been prepared for you as a courtesy only. In the event of a conflict between the English-language version of this Privacy Policy Statement and a version that has been translated into another language, the English-language version shall prevail.
Important - This Privacy Policy Statement outlines the use of all identifying personal information submitted and collected on http://www.blazingtrader.bz (the "Site"). This privacy notice does not encompass other websites or third-party links referenced to or by 'Blazing Trader' in any way, including but not limited to print, online, or in e-mail. 'Blazing Trader', its affiliates, clients and all of their respective authorized representatives, officers, directors, employees, agents, shareholders, licensors, attorneys, successors, and assigns ("Blazing Trader"), is firmly committed to protecting personal and financial information. This Privacy Policy statement embodies our commitment to its protection through adherence to fair electronic information practices.
Acknowledgement and acceptance of terms
'Blazing Trader' is committed to protecting its users' privacy. This Privacy Policy Statement sets forth our current privacy practices with regard to the information we collect when you or your computer interact with our Site. By accessing our Site, you acknowledge and fully understand the Privacy Statement and freely consent to the information collection and use practices described in this Site Privacy Policy Statement.
Information we collect and how we use it
When you use or connect to our Site through your computer or a mobile device, the owners and publishers of the Site collect certain information from and about its users in a few ways, directly from our web server logs, from you, with the aid of cookies, with web beacons, and through the use of website analytics through a third-party service provider. We may collect personally identifiable information necessary for internal marketing purposes based on user activity, registration and billing from customers who purchase our products and services online.
'Blazing Trader’s' proxy is a gateway for the user's network, and is set for the purposes of retrieving such information, and base marketing material on it. We do not collect any sensitive information.
Visitors to our Site can register to create an account, access the Site, download Software, and possibly purchase services. When you register, we will request some personal information such as your name, address, e-mail, telephone number or facsimile number, location, account number and other relevant information. We also collect your IP computer address. If you are purchasing a service, we will request financial information. Any financial information we collect is used only to bill you for the services you purchased. If you purchase by credit card, this information may be forwarded to your credit card provider. For other types of registrations, we will ask for the relevant information. You may also be asked to disclose personal information to us so that we can provide assistance and information to you. For example, such data may be warranted in order to provide online technical support and troubleshooting.
Web server logs
When you visit our Site, we may track information through web server logs to better administer the Site and analyze its usage. Examples of information we may track include but is not limited to your Internet Protocol address ("IP"), the type of bw-rowser or computer you use, the number of links you click within the Site, the geographical location from which you accessed the Site, the date and time of your visit, the name of your Internet service provider, any web pages you linked to our Site from, and pages you viewed on the Site.
Use of cookies
'Blazing Trader' may use cookies to personalize or enhance your user experience. A cookie is a small text file that is placed on your hard disk by a Web page server to identify that specific user the next time he or she visits the website. Cookies cannot be used to run programs or deliver viruses to your computer. Cookies are uniquely assigned to you, and can only be read by a Web Server in the domain that issued the cookie to you.
One of the primary purposes of cookies is to provide a convenience feature to save you time. For example, if you personalize a web page, or navigate within a site, a cookie helps the site to recall your specific information on subsequent visits. Hence, this simplifies the process of delivering relevant content and eases site navigation by providing and saving your preferences and login information as well as providing personalized functionality.
We do not allow other companies on our Site to place cookies, unless there is a temporary overriding of a part in the Site (such as integrating another site that relies on third-party cookies, into the existing website).
Modifying cookie settings
You have the ability to accept or decline cookies. Most Web bw-rowsers automatically accept cookies, but you can usually modify your bw-rowser setting to delete or decline cookies. If you reject cookies by changing your bw-rowser settings then be aware that this may disable some of the functionality on our Site.
Use of web beacons or GIF files
This Site may contain electronic images known as "Web Beacons" (also called single-pixel GIFs) that allow the owners and publishers of the Site to count users who have visited those pages and to deliver certain services. The owners and publishers of the Site may include Web Beacons in promotional e-mail messages or newsletters in order to determine whether messages have been opened and acted upon.
Some Web Beacons may be placed by third-party service providers to help us determine the effectiveness of our advertising campaigns or e-mail communications. These Web Beacons may be used by these service providers to place a persistent cookie on your computer, for the benefit of 'Blazing Trader'. This allows the service provider to recognize your computer each time you visit certain pages or e-mails and compiles anonymous information in relation to those page views, which in turn enables us and our service providers to learn which advertisements and e-mails bring you to our website and how you use the Site. 'Blazing Trader's' Web Beacons are not used to collect or access your identifying personal information.
Notice on Disclosure of user personal information
'Blazing Trader' reserves the right to share aggregated site statistics with partner companies, sites and affiliates, including brokers, to help enhance its service offerings, but does not sell or forward identifying personal information to third-party companies. Personal User information collected by or submitted to 'Blazing Trader' shall not be disclosed to any third-parties without your permission, unless such information: (i) to fulfill your service requests; (ii) is required to be disclosed by law, regulation, legal process, law enforcement or government regulatory authorities, in which case we shall give you as much advance notice as is reasonably practicable in order to allow you to limit or restrict to such disclosure; or (iii) is required to be disclosed in order for us to protect our legal rights or defend against liability; or (iv) in connection with a merger, acquisition, or liquidation of 'Blazing Trader'.
Opting out
If you wish, you may choose not to receive emails, newsletters or other communications from 'Blazing Trader' by clicking the "Unsubscribe" link in the email communication sent to your email account registered with the Site.
Accessing and changing personal information
You can ensure that your identifying personal information in your web account file is correct and up to date by contacting our support attendants via our support desk at [email protected]
Internet based data transfer
Given that the Internet is a global environment, using the Internet to collect and process personal data necessarily involves the transmission of data on an international basis. Therefore, by browsing this Site and communicating electronically with us, you acknowledge and agree to our processing of personal data in this manner.
Changes to this Statement
The owners and publishers of the Site have the discretion to periodically update this Privacy Policy Statement. We encourage you to periodically review this Privacy Policy statement to stay informed about how we are helping to protect the personal information we collect. Your continued use of the service constitutes your agreement to this Privacy Policy statement and any updates.
Contact us
If you have questions regarding the security of the Site, our Privacy Policy Statement, its implementation, and/or our information collection and dissemination practices, please contact us via our support desk at [email protected]
'Blazing Trader' © 2017 All rights reserved


be close to the nature
Here you can do that you want to do.
Getting job is now fun
be close to the nature
Here you can do that you want to do.
Getting job is now fun
be close to the nature
Here you can do that you want to do.
Getting job is now fun
Staple is a fun and easy way to create interactive experiance directly in your photo
Bring your photo live with the people places,and details that tell the whole story
Upload photos
Add content
Share everywhere
See interactions
Easly share your photos in the Facebook News Feed,and on Twitter, Pinterest and Google+
Have a Blog? Your readers will experience your photos, not just look at them. It is simple tolink your blog to stipple and easly tag your
pics right from your site
Get Started »


|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
public interface MeshConnectionModel
This interface declares basic functionality for geometrically connecting two
Finite Element Model meshes. This includes the ability to compute the nodal
geometric connection between two JMeshPanel
objects, import the
connection data from different file types, and export the connection data
to different file types. The only criterion that must be given is the
maximum tolerance between any two connected nodes.
This MeshConnectionModel
should also be Renderable
, meaning
that a Java3D scene should be created from the stored data. Ideally, the
First Mesh
and the Last Mesh
should be rendered in the same
scene. Then the connected nodal geometry should overlap both of the models,
essentially, highlighting them.
This MeshConnectionModel
should also be Loggable
, meaning
that for important user-controlled events, log messages should be fired so
that the user can have a command history and be able to view the current
status of the stored data. There must be methods to access the data for
calculations or output. Before output data can be made, queries must be
available to check if the data is already stored.
| Method Summary | |
|---|---|
void |
connectNodes(double tolerance)
Computes and stores the nodal connection between the First Mesh
and the Last Mesh . |
void |
exportNodeConnections(java.lang.String fileName)
Selects the appropriate MeshConnectionWriter for the given file
and exports all stored node connections. |
javax.swing.ComboBoxModel |
getConnectionColorModel()
Returns the ComboBoxModel of the connection colors
that can be rendered in Java3D. |
java.io.File |
getConnectionFile()
Returns the file where the connection data was last imported. |
javax.swing.ComboBoxModel |
getConnectionTypeModel()
Returns the ComboBoxModel of the connection type. |
JMeshPanel |
getFirstMesh()
Returns the First Mesh . |
javax.swing.ComboBoxModel |
getIndependentMeshModel()
Returns the ComboBoxModel of the independent mesh. |
JMeshPanel |
getLastMesh()
Returns the Last Mesh . |
NodeConnectionMatrix |
getNodeConnections()
Returns the currently stored node connections. |
boolean |
hasNodeKeys()
Tests if the First Mesh and the Last Mesh are both
storing any groups of node subsets. |
boolean |
hasNodes()
Tests if the First Mesh and the Last Mesh are both
storing any nodes. |
void |
importNodeConnections(java.lang.String fileName)
Selects the appropriate MeshConnectionReader for the given file
and imports all the available node connections contained in the file. |
boolean |
isConnected()
Tests if this MeshConnectionModel is storing any connections
between the First Mesh and the Last Mesh . |
boolean |
isConsistent()
Tests if the First Mesh and Last Mesh are both
consistent. |
void |
setConnectionDegreesOfFreedom(java.lang.String connectionDOF)
Sets the connected degrees of freedom. |
void |
setConnectionIdentifier(int connectionIdentifier)
Sets the connection identifier. |
| Methods inherited from interface de.iabg.swing.Loggable |
|---|
addLogListener, fireLogChanged, removeLogListener |
| Methods inherited from interface de.iabg.j3d.Renderable |
|---|
addSceneListener, fireScene2DChanged, fireScene3DChanged, getBoundingRadius2D, getBoundingRadius3D, getScene2D, getScene3D, removeSceneListener |
| Method Detail |
|---|
void connectNodes(double tolerance)
First Mesh
and the Last Mesh
.
tolerance
- the maximum tolerance between any two connected
nodesvoid exportNodeConnections(java.lang.String fileName) throws java.io.IOException
MeshConnectionWriter
for the given file
and exports all stored node connections.
fileName
- the file to be exported
java.io.IOException
- if the file could not be writtenjavax.swing.ComboBoxModel getConnectionColorModel()
ComboBoxModel
of the connection colors
that can be rendered in Java3D.
ComboBoxModel
of the connection colorsjava.io.File getConnectionFile()
javax.swing.ComboBoxModel getConnectionTypeModel()
ComboBoxModel
of the connection type.
ComboBoxModel
of the connection typeJMeshPanel getFirstMesh()
First Mesh
.
JMeshPanel
of the First Mesh
javax.swing.ComboBoxModel getIndependentMeshModel()
ComboBoxModel
of the independent mesh.
ComboBoxModel
of the independent meshJMeshPanel getLastMesh()
Last Mesh
.
JMeshPanel
of the Last Mesh
NodeConnectionMatrix getNodeConnections()
NodeConnectionMatrix
storing the node connectionsboolean hasNodeKeys()
First Mesh
and the Last Mesh
are both
storing any groups of node subsets.
true
if the First Mesh
and the Last Mesh
both store any groups of node subsets; false
otherwiseboolean hasNodes()
First Mesh
and the Last Mesh
are both
storing any nodes.
true
if the First Mesh
and the Last Mesh
both store any nodes; false
otherwisevoid importNodeConnections(java.lang.String fileName) throws java.io.FileNotFoundException, java.io.IOException
MeshConnectionReader
for the given file
and imports all the available node connections contained in the file.
fileName
- the file to be imported
java.io.FileNotFoundException
- if the file could not be found
java.io.IOException
- if the file could not be readboolean isConnected()
MeshConnectionModel
is storing any connections
between the First Mesh
and the Last Mesh
.
true
if this MeshConnectionModel
stores any node
connections; false
otherwiseboolean isConsistent()
First Mesh
and Last Mesh
are both
consistent.
true
if the First Mesh
and Last Mesh
are
both consistent; false
otherwisevoid setConnectionDegreesOfFreedom(java.lang.String connectionDOF)
connectionDOF
- the currently connected degrees of freedomvoid setConnectionIdentifier(int connectionIdentifier)
connectionIdentifier
- the current connection identifier
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


Using on the basic template you created in the Module 02 course project, select ONE navigation bar style, and add it to the home page. Create associated pages that are linked in the navigation, so that when the user clicks on a menu item, the site navigates to a new page.


Since I am new, I do not know if idea has been posted, but here it goes:
When you look at you gun on the stats page for example:
http://battlelog.battlefield.com/bf3/soldier/FUZZCOOKIE/iteminfo/m1014/391149167/pc/
There should also be a stat under accuracy that states what was your highest kill streak with that gun. That could be a very useful statistic. I think bf3stats has this statistic on every weapon. It must just be implemented with Better Battlelog.


Jonathan Grudin
Introduces the notion of placing the user at the centre of computer systems design as if it was new (which the paper claims it is at the time).
"[Boehm's] proposal, a "spiral model" of software development, incorporates user involvement, prototyping and iterative design."
"the multiplicity of computer industries...share a need to examine current practices and search for new ones to meet hte challenge of developing usable, useful interactive software..[to] adapt the hard-earned lessons of one development context and apply them in others. The potential benefits are new techniques, processes and organizational structures for development".
Suchman 'Designing with the User'


FitFreadRadarScan
| Syntax | ||
int FitFreadRadarScan(FILE *fp,int *state, struct RadarScan * ptr, struct RadarParm *prm, struct FitData *fit, int tlen, int lock,int chn); | ||
| Header | ||
| superdarn/fitscan.h | ||
| Library | ||
| fit | ||
| Description | ||
The The data is read from the stream pointed to by the argument fp. The argument state is a pointer to an integer that is used internally by the function to track progress through the The scan data is written to the structure pointed to by the argument ptr. Memory is automatically allocated within this structure to store the beam data. In order for the function to correctly identify a scan boundary, it must read the first beam from the subsequent scan. This data must be preserved so that it can be included in the next block of scan data returned by the next call to the function. This is done by providing storage for the radar parameter block and the fit data pointed to by the arguments prm and fit. If the argument tlen has a non-zero value then the function will ignore the scan flag and instead assume the the scan has a length of tlen seconds. If the argument lock has a non-zero value it is also assumed that the scan boundaries are fixed relative to the start of the day. If the final argument chn, is compared against the channel number recorded in the radar parameter block, if the two numbers do not match then the data record is excludef from the scan. | ||
| Returns | ||
| Returns zero on success, or (1) if the end of file was reached. On error, (-1) is returned. | ||
| Errors | ||
| On error, (-1) is returned. | ||
| Example | ||
|


Get Involved!
The Denver Post invites you to join us in our All in PINK effort to raise awareness of breast cancer, support early detection and treatment.
Share your experience or read some of the many touching stories contributed by Coloradans who have had their lives changed by this disease. Find out how to help through research, donations and events or learn how to get yourself proper care and screening. Just click the menu in the top right corner for more.


Super Uub announced for Dragon Ball Xenoverse 2
by My Nintendo News Admin
There’s yet another paid DLC character coming to Dragon Ball Xenoverse 2 and this time it is Super Uub. Super Uub will be coming to the hit Dragon Ball game this winter as part of the Ultra DLC Pack 2. There’s also a big update coming to Dragon Ball Xenoverse 2 this winter with Photo Mode having a revamp and also Master Raid will soon feature a two-versus-four mode. Here’s Super Uub’s attacks:
- Flash Chaser – A ki blast that can change trajectory with additional input.
- Dragon Quick Attack – A knee kick followed by consecutive kick attacks, which can connect to a punch or heel drop with additional input.
- Inside Buster (Evasive Skill) – Charges and releases ki. Its power can be increased through repeated button pressing while charging.
- Lightning Force (Ultimate Attack) – Charges ki in an invicible state, then scatter shoots the it at his surroundings. Its power can be increased through repeated button pressing while charging.


[gecode-users] svn: bug in sudoku.cc
Guido Tack
tack at ps.uni-sb.de
Mon Nov 26 16:05:10 CET 2007
Filip Konvička wrote:
> trying to compile trunk with MSVC 9, I got an error compiling
> sudoku.cc,
> can be probably fixed with [...]
You checked out the trunk while it was in an inconsistent state, it
should be fixed now.
> Otherwise, compilation went extremely smooth with a fresh install of
> MSVC 9 Express Edition, with the following commands under cygwin:
>
> export PATH="/cygdrive/c/Program Files/Microsoft Visual Studio
> 9.0/Common7/IDE:$PATH"
> export PATH="/cygdrive/c/Program Files/Microsoft Visual Studio
> 9.0/VC/bin:$PATH"
> export INCLUDE='C:\Program Files\Microsoft Visual Studio
> 9.0\VC\include;C:\Program Files\Microsoft SDKs\Windows\v6.0A\include'
> export LIB='C:\Program Files\Microsoft Visual Studio
> 9.0\VC\lib;C:\Program Files\Microsoft SDKs\Windows\v6.0A\lib'
> ./configure CC=cl CXX=cl
> make
>
> Trying to build outside of the source tree failed somehow, though.
Again, this might have been due to the bogus state of the svn, it
currently compiles without problems for me (using MSVC 2005, though).
> Nevermind, excellent!
It will get even better :-) We're currently integrating Gist, our Qt-
based visual search tool, into the main Gecode tree - you may have
seen the check-ins in the trunk.
Cheers,
Guido
-------------- next part --------------
A non-text attachment was scrubbed...
Name: smime.p7s
Type: application/pkcs7-signature
Size: 2436 bytes
Desc: not available
URL: <http://www.ps.uni-sb.de/pipermail/users/attachments/20071126/5dfa3c7d/attachment.bin>
More information about the gecode-users
mailing list


Events can now be moved between calendars using the Google Calendar app
by Usman Khan LodhiGoogle Calendar is adding the ability to move events between different calendars in a server-side update. Before this, moving events could only be done through the web app where users were able to migrate events between the added accounts. If users wanted to move events using the mobile app, they had to copy or duplicate event details to the other calendar and delete the original event later.
This feature can be accessed by clicking on a new option that appears below the appointment title in the app. Once selected, events can be moved to any accounts currently signed in on users' devices. The screenshots below show the steps involved in moving events between calendars.
As per folks over at Android Police, this feature can be forced to show up by force quitting the Calendar app and clearing its cache. Since this appears to be a server-side update, it does not require updating the app.
Source: Android Police


# File shoulda_macros/paperclip.rb, line 98 def paperclip_fixture(model, attachment, extension) stub_paperclip_s3(model, attachment, extension) base_path = File.join(File.dirname(__FILE__), "..", "..", "features", "support", "paperclip") File.new(File.join(base_path, model, "#{attachment}.#{extension}")) end


BITSHack provides a brilliant opportunity for you and your team to forge professional contacts and make new friends. With over hundreds of developers and designers gathering from all over the country in Goa, grab your chance of connecting with people to discuss ideas and opportunities.
Hackathons are a great way to give back to the community. Mentoring beginners is always helpful for them and rewarding for us. We’re going to have mentors from a number of different organizations present at the venue. Whenever you’re stuck on a problem or need suggestions they'll always be within a hand’s reach.
This year we are inviting not just students but everyone to build on ideas of their choice. Watching software materialize from pure thought, part by part is the closest to experiencing magic we have ever got to. And we’re excited to see that magic happen all over again!


December 2 - 3, 2021
A virtual conference
Nowadays, effective access to and use of information is a key enabler for progress. Driven by the incresing demands for knowledge-based applications and the unprecedented availability of information on the Web, the study of knowledge capture is of crucial importance. Knowledge capture involves the extraction of useful knowledge from vast and diverse online sources as well as its acquisition directly from human experts.
The Eleventh International Conference on Knowledge Capture aimed at attracting researchers from diverse areas of Artificial Intelligence, including knowledge representation, knowledge acquisition, intelligent user interfaces, problem-solving and reasoning, planning, agents, text extraction, and machine learning, information enrichment and visualization, as well as researchers interested in cyber-infrastructures to foster the publication, retrieval, reuse, and integration of data.
Today these data come from an increasingly heterogeneous set of resources that differ with regards to their domain, media format, quality, coverage, viewpoint, bias, and so on. More than the sheer amount of these data, their heterogeneity allows us to arrive at better models and answer complex questions that cannot be addressed in isolation but require the interaction of different scientific fields or perspectives.
If you are a student interested in attending K-CAP 2021, you may be eligible to apply for a support grant. This year, grants are funded by the ACM SIGAI. Please take a look at SIGAI's student support opportunities.
Student Travel Support is also supported by the AIJ. Please apply at the following form: https://forms.gle/vZ5Bdvg7Vj12RaUq9.


The brief introduction of myself
Coder Senior Front-End Developer Proffesional
Senior Front-end developer with focus on React.js
As a professional developer with strong background featuring a master degree in Computer Science I am completely committed for quality, with passion to explore new tools (like Vue, React) and to upgrade 'old' ones, like Webpack, Gulp, Bootstrap... Also love exploring new technologies and follow cool people.
But most off all I like to travel and enjoy in every day with my family!


Available routes :
/index
(generated)
/my
(generated)
/my/route
(fixed)
/my/route/two
(fixed)
/my/route/two/with_a_custom_parameter
(fixed)


Play a distractingly irregular tick-tock sound that mimics Vetinari’s clock from Terry Pratchett’s Discworld series.
You can read more about this project and see its source code on GitHub.
Warning: ticking may sound excessively irregular on slow devices.
The clock in Lord Vetinari’s anteroom didn’t tick right. Sometimes the tick was just a fraction late, sometimes the tock was early. Occasionally, one or the other didn’t happen at all. This wasn’t really noticeable until you’d been in there for five minutes, by which time small but significant parts of the brain were going crazy.
—Going Postal by Terry Pratchett, page 321
Someone very clever—certainly someone much cleverer than whoever had trained that imp—must have made the clock for the Patrician’s waiting room. It went tick-tock like any other clock. But somehow, and against all usual horological practice, the tick and the tock were irregular. Tick tock tick…and then the merest fraction of a second longer before…tock tick tock…and then a tick a fraction of a second earlier than the mind’s ear was now prepared for. The effect was enough, after ten minutes, to reduce the thinking processes of even the best-prepared to a sort of porridge. The Patrician must have paid the clockmaker quite highly.
—Feet of Clay by Terry Pratchett, page 91


--- layout: documentation title: X509NonStandardExtensionsType ---
The NonStandardX509ExtensionsType captures some non-standard or deprecated X509 extensions that may be useful. Based on the OpenSSL "Deprecated Extensions" documentation: https://www.openssl.org/docs/apps/x509v3_config.html#Deprecated_Extensions. Also based on the Alvestrand certificateExtension reference: http://www.alvestrand.no/objectid/2.5.29.html.
| Field Name | Type | Description |
|---|---|---|
| Netscape_Comment0..1 | StringObjectPropertyType |
The Netscape_Comment field captures a comment which may be displayed when the certificate is viewed in some browsers. |
| Netscape_Certificate_Type0..1 | StringObjectPropertyType |
The Netscape_Certificate_Type field captures a list of flags which indicate the purposes for which a certificate could be used. |
| Old_Authority_Key_Identifier0..1 | StringObjectPropertyType |
The Old_Authority_Key_Identifier captures the old version of the authority key identifier, equivalent to the object ID (OID) value of <IP_ADDRESS>. |
| Old_Primary_Key_Attributes0..1 | StringObjectPropertyType |
The Old_Primary_Key_Attributes field captures the old version of the primary key attributes, equivalent to the object ID (OID) value of <IP_ADDRESS>. |


Toggle navigation
Start Bootstrap
Themes
All Templates & Themes
Most Popular
Buy Bootstrap Templates
Template & Theme Categories:
Admin and Dashboard
Full Websites
Landing Pages
One Page Websites
Portfolios
Blogs
Ecommerce
Unstyled Starter Templates
Navigation and Navbars
Blog
Resources
Bootstrap Resources List
Start Bootstrap Showcase
Help
Contact
Premium
Custom Bootstrap Design Services
WrapBootstrap - Premium Bootstrap Themes
Fellow ID
SchoolID
Fellow Name
Password
Program Manager
Standard


Toggle navigation
Menu
Home
Home
About
Featured Books
Contact
Featured Books
Here are some other books that I love to share with you.
The Last Boy and Girl in the World
“Obviously, we're hoping that the weather forecasters are wrong, the way they tend to be about ninety-eight percent of the time A few adults chuckled at that lameness. I remember thinking, hoping, that I would never turn into the kind of person who though weather jokes were funny.”

By Andrea Portes
Looking for Alaska
“Thomas Edison's last words were "It's very beautiful over there". I don't know where there is, but I believe it's somewhere, and I hope it's beautiful.”
By John Green
The Notebook
“I am nothing special, of this I am sure. I am a common man with common thoughts and I've led a common life. There are no monuments dedicated to me and my name will soon be forgotten, but I've loved another with all my heart and soul, and to me, this has always been enough..”
By Nicholas Sparks
More Books →


30 Foreign Key Constraints
| Constraint Name | Child Column | Parent Column | Delete Rule | ||
|---|---|---|---|---|---|
| backup_role_user_id_fkey |
|
|
Cascade on delete | ||
| timestamp_state_state_type_id_fkey |
|
|
Restrict delete | ||
| nomination_berth_berth_id_fkey |
|
|
Cascade on delete | ||
| nomination_berth_nomination_id_fkey |
|
|
Cascade on delete | ||
| vis_voyage_plan_rtz_state_fkey |
|
|
Restrict delete | ||
| berth_reservation_berth_reservation_type_id_fkey |
|
|
Restrict delete | ||
| berth_reservation_slot_reservation_id_fkey |
|
|
Cascade on delete | ||
| berth_reservation_berth_id_fkey |
|
|
Restrict delete | ||
| timestamp_definition_time_type_id_fkey |
|
|
Cascade on delete | ||
| timestamp_definition_state_id_fkey |
|
|
Cascade on delete | ||
| nomination_nomination_status_id_fkey |
|
|
Restrict delete | ||
| api_key_bound_user_id_fkey |
|
|
Restrict delete | ||
| port_call_slot_reservation_id_fkey |
|
|
Null on delete | ||
| port_call_imo_fkey |
|
|
Restrict delete | ||
| role_permission_role_id_fkey |
|
|
Cascade on delete | ||
| role_permission_permission_id_fkey |
|
|
Cascade on delete | ||
| timestamp_port_call_id_fkey |
|
|
Restrict delete | ||
| timestamp_state_id_fkey |
|
|
Restrict delete | ||
| timestamp_time_type_id_fkey |
|
|
Restrict delete | ||
| slot_reservation_slot_reservation_status_id_fkey |
|
|
Restrict delete | ||
| slot_reservation_nomination_id_fkey |
|
|
Null on delete | ||
| slot_reservation_port_call_id_fkey |
|
|
Null on delete | ||
| slot_reservation_berth_id_fkey |
|
|
Restrict delete | ||
| public_role_id_fkey |
|
|
Cascade on delete | ||
| user_registration_code_id_fkey |
|
|
Null on delete | ||
| pushnotificationtoken_user_id_fkey |
|
|
Cascade on delete | ||
| pinned_vessel_user_id_fkey |
|
|
Cascade on delete | ||
| timestamp_api_key_weight_timestamp_state_id_fkey |
|
|
Cascade on delete | ||
| timestamp_api_key_weight_api_key_id_fkey |
|
|
Cascade on delete | ||
| timestamp_api_key_weight_timestamp_time_type_id_fkey |
|
|
Cascade on delete |
Check Constraints
| Table | Constraint Name | Constraint |
|---|


Tarzan And The Lost City A review by Joe Chamberlain
Starring Casper Van Dien; Jane March; Steven Waddington; Winston Ntshona & Rapulana Seiphemo
The only two really good things that I can say about Tarzan And The Lost City are as follows: Jane March was very cute as Jane, and the movie was thankfully under 90 minutes in length. If you haven't already figured it out, I didn't like this movie very much.
The plot was boring and contrived to the extreme. Tarzan (Casper Van Dien) has now left the jungle and living in civilized society. He is just days away from his impending marriage to Jane, played by the aptly named Jane March. Back in his former home of Africa, a group of looters has found the key to locating a lost city. (Mind you I never really figured out why they actually wanted to find this city.) Anyway, Tarzan's old jungle friend appears to him in a vision. Tarzan realizes that he must return to Africa to help stop the bad guys from finding the lost city. He leaves Jane (his first mistake, in my opinion) and travels to Africa. Of course, Jane is hot on her ape man's heals. The two of them are reunited in Africa where they do battle with the bad guys.  It's actually an improvement over the real thing.
The acting is just plain awful. I'm not quite sure what Casper Van Dien was doing in this film, but it wasn't acting. Jane March wasn't a heck of a lot better, but at least she is easy on the eyes. Compounding the bad acting was the fact that in many places the dialogue had obviously been re-recorded, and I've seen better dubbing in some old Bruce Lee movies. Added to the sound problems was the cinematography. This film was filled with beautiful African scenery. But the panoramic scenery shots looked overexposed to me. Quite frankly, I think you could probably do a better job capturing the beauty of Africa with a camcorder than this bunch did with professional film equipment.
Then we have the special effects. "Special effects in a Tarzan movie?" you are no doubt asking yourself? Yes friends, the writers injected some very out of place supernatural elements into the story. Probably for the sake of using CGI, since it did nothing but hurt the story. In most parts, they weren't bad, just nothing special. But, they were more than a little on the hokey side. Except of course, when we got to the ridiculous climax of this movie. The grand finale's special effects went right into the toilet at that point. It almost looked like they had run out of money. These effects were of noticeably lower quality than those in the rest of the film and looked like something in an amateur video production.
I took one lesson away from watching Tarzan And The Lost city -- ape men and bones that morph into skeletal warriors don't mix. Stay far away from this version of Tarzan.
4/10
Visit The Movie Guy http://movieguy.tripod.com
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


#include <Registry.h>
Used to lock the Registry for iteration in a multi-threaded env
§ RegistryLock() [1/3]
| RegistryLock::RegistryLock |
( |
| ) |
|
Lock registry or block if already locked
§ RegistryLock() [2/3]
| RegistryLock::RegistryLock |
( |
int |
ntimes, |
|
|
long |
sleepms = 0.0 |
|
) |
| |
Try to lock registry ntimes with sleep ms between. Raises exception if lock not acquired
§ RegistryLock() [3/3]
template<class Rep , class Period >
| RegistryLock::RegistryLock |
( |
int |
ntimes, |
|
|
std::chrono::duration< Rep, Period > |
sleepduration |
|
) |
| |
Try to lock registry ntimes with sleep sleepduration between. Raises exception if lock not acquired
§ ~RegistryLock()
| RegistryLock::~RegistryLock |
( |
| ) |
|
§ testLock()
| static bool theoria::core::RegistryLock::testLock |
( |
| ) |
|
|
static |
Return true if not locked. Not particularly useful outside of unit test
The documentation for this struct was generated from the following files:
- include/theoria/core/Registry.h
- src/core/Registry.cpp


@@include( '../includes/messages.tpl', { "site": "cew" } )
@@include( '../includes/sendTx.tpl', { "site": "cew" } )
@@include( '../includes/cold-staking-startStaking-modal.tpl', { "site": "cew" } )
@@include( '../includes/cold-staking-withdraw-modal.tpl', { "site": "cew" } )
@@include( '../includes/cold-staking-claimReward-modal.tpl', { "site": "cew" } )
@@include( '../includes/broadcast-tx.tpl', { "site": "cew" } )
@@include( '../includes/re-encrypt.tpl', { "site": "cew" } )
@@include( '../includes/generateWallet.tpl', { "site": "cew" } )
@@include( '../includes/swap.tpl', { "site": "cew" } )
@@include( '../includes/offlineTx.tpl', { "site": "cew" } )
@@include( '../includes/contracts.tpl', { "site": "cew" } )
@@include( '../includes/ens.tpl', { "site": "cew" } )
@@include( '../includes/dexns.tpl', { "site": "cew" } )
@@include( '../includes/viewWalletInfo.tpl', { "site": "cew" } )
@@include( '../includes/txStatus.tpl', { "site": "cew" } )
@@include( '../includes/bulkGenerate.tpl', { "site": "cew" } )
@@include( '../includes/bulkGenerate.tpl', { "site": "cew" } )
@@include( '../includes/print.tpl', { "site": "cew" } )
@@include('../includes/alerts.tpl')


Okay, this was a long time ago, but it was still utterly unforgettable. Coming after a number of positive LSD, Mescaline, and Mushroom experiences, the MDA experience - which had been described beforehand as similar, but somewhat shorter and with a more pronounced burnout afterward - was fascinating.
After taking the MDA at around 4:30 on a midsummer day, we - myself, a female relative, and a couple of male friends - had a 40-minute drive across a spectactular bridge to a lovely nature preserve. Onset of the effects began during the drive (which was accompanied by an excellent live Grateful Dead tape), as a feeling of euphoria, enthusiasm, and a general heightening of all the senses. I don't recall any stomach churning, but I suppose there was some, and the same sense of your body's ordinary functions shutting down as at the start of an LSD trip.
Sitting by a pristine woodland lake another hour later, we were into full-blown effects. For the most part, they were quite similar to an LSD experience, but with some interesting differences:
Extremely heightened closeness and intimacy. It was different from the sense of being swallowed by something greater than onseself that you often have in an LSD experience. I was still me, in control, and very verbal. Personality differences fell away, and I loved my companions intensely at that moment, thinking them the greatest friends I ever had.
(Unfortunately, I did get to try a sexual experience, but I can attest to those who say that MDA is wonderful for it. This was certainly the closest thing to an aphrodesiac drug I have ever personally experienced. I should point out that coke and 'ludes never worked for me: I'm far more into mind drugs, not body drugs.)
Part of this was do to a stunning auditory difference: Whereas on LSD you hear the entire universe in a great cacaphony - the wind in the trees, the dog barking a mile away, the planes flying by, the water rushing down the stream - on MDA, there was silence. The person you are speaking with is all you hear over a slight background hum, and their words are the central fact in the universe.
My response to LSD was always that it was a spiritual, mystical experience that included a chance to view oneself at a distance - I never did it just for the special effects. MDA seemed of a piece with this, if somewhat less intense. The mystery was present.
Hallucinations of a different type: In addition to heightened colors and an 'angular' sense of things seeming rather like a fisheye lens, there wasn't any of the usual 'melting' or 'strobing' effects. What there was - that I had never seen on LSD - was polka-dots. Floating before me in all different colors, uniform spots of about fist-size-at-arm's-length. Whoa...
We had plenty of energy (this is an amphetamine, after all), and had a pleasant walk. The visual effects remained strong, but there was never a loss of control or a difficulty in speaking (either technically, as in forming coherent sentences, or expressively, as in making myself understood).
After about six hours, we were well into the downward slide. Went home, drank a little wine and smoked a little pot to ease down. Eventually managed to eat something light. Was up most of the night, but eventually slept pretty well. I wasn't aware of being all that more burnt out the next day than I would have been after a full-blown LSD trip. (This was shorter, and a bit less intense, but thoroughly enjoyable.)
I never did MDA a second time - it never came my way again - but I treasure this memory as a very special experience. Truly, it seemed another wonder-drug, as worthy in its own way as the other powerful psychoactive drugs I have used.
In reading about the increasing use of MDMA (Ecstasy) in recent times, I have wondered how it compares to this MDA experience. (From what I have read here, it seems that MDMA is a somewhat less full-blown experience.) Despite my current middle-aged parent status, I can certainly see why the kids of today would enjoy such a thing, and how it could aid is partying and coupling... My MDA trip was one of the (you should excuse the term!) peak experiences of my youth...
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


First name Last name Enter fisrt name Enter last name
Username Choose a gmail address
Password Confirm Password 8 character long Enter a Confirm password
One account. All of Google working for you.


--- layout: default ---
COVID update: For the sake of everyone's health and wellbeing, we are postponing our wedding arrangements until travel is safe and border restrictions have been lifted.


I have been using 1,4 Butanediol for the past year as a thereaputic agent. I never intended for it to be used as this, I just was looking for something new to try that was similar to alcohol which I had given up for numerous reasons. However, at the time I received it I had severe depression (w/ suicidal ideation), was socially reclusive and had some situational anxiety. The 1st dose of 1,4 Butanediol completely stopped all the preceding symptoms. I took 2.25ml, forgot I had even done so, started doing some other activity, and it occured to me, 'hey I feel pretty damned good'. For the next month or so I took 2-3 2.25ml doses a day and the positive effects continued. I then had to stop for a month while I was trying to locate a new supplier. My symptoms went back to normal but I never experienced any withdrawal symptoms. After I located a new supplier I started right back in.
Since then, I have been using 'starter' doses ranging between 1.2ml to 3.5ml. I say starter doses because regardless of the dosage used, I always redose in an hour or two with the starter dose divided by 5-6. 1.2ml's is very mild, a good antianxiety amount. 1.8ml (current) is very pleasant, kinda a detached happy with the world feeling. I can be around otherwise irritating people indefinitely without them really getting on my nerves. Music is more fun as well, as is pretty much everything. Sex drive doesn't go up, however, sexual ability and relationship drive/love for someone I'm in a relationship with goes up a lot. I can't imagine a couple ever getting into detrimental arguments if they were both on this. Indeeed, it increases the desire for intimate communication (note that this can make people not on the substance feel uncomfortable if you're ready to become their soulmate and yet you just met them).
At this dosage, academic abilities are very mildly impaired, enough so that taking the ACT test probably wouldn't be a good idea, but going to class and taking/remembering notes, etc. is still just fine. At this dosage it is also an enjoyable socializer, feel like talking to people a lot more and am more extroverted. This dosage also allows me to go to sleep if I'm still too wired to or have too many thoughts going on in my mind when I go to bed. 2.25ml's is slightly more enjoyable, but it causes more foggy thinking than 1.8ml. There is no hangover effect the next day from these doses.
3ml I was taking for a while after some bad things happened in my life. It caused me to sleep excessively and feel dulled down most of the time (which is what I needed), memory and verbal abilities are definitely affected at this dosage. This is also the only time I ever became identifiably addicted to the substance, redosing it every few hours, because if I didn't I'd start getting very jittery, wired, and anxious. It only took about 4 hours completely off the substance (10 hours total since previous dose) for this to go away. I still usually felt dulled down the day after taking this dose before bed.
All these doses are taken on an empty stomach or very close to empty (at least 2 hrs since a large meal, I usually only eat 1-2 meals a day so its not too bad for me). If my stomach is not empty the effects are greatly attenuated and it seems to take longer to get out of my system. Tolerance to this substance has never occured except when I was addicted (see above).
Respect is needed for this substance. I've had two friends who 'eyed' a dose of this substance and took about 4ml's+ I believe and both wound up in the hospital because someone else saw them and thought that they were in a coma because they couldn't wake them up. Please, if you're going to 'eye' a dose, take it, go to somewhere secluded for 15-20 minutes, and if you aren't passed out or very close by that time then go back to where you were. If that's not an option, try to inform at least one person you're going to be around that you've taken some of this substance or just tell them that you have narcolepsy and sometimes pass out for a few hrs at a time, and not to worry if it happens. This will save a lot of problems down the road.
The amount you can take without passing out varies by your environment and many other factors. I knew one guy who took 6ml frequently and it took 12ml for him to pass out, and he'd never done it before. The amount isn't generally very dependant upon weight. In any case, I've found the most fun doses are not the just barely below passing out doses, the best doses are about half what a pass out dose would be. Syringes only cost about 10 cents so do yourself a big favor if you're going to use this and buy one so you know exactly how much you're taking.
People wishing to combine this drug should avoid alcohol (especially) and other depressants. 1,4 Butanediol is a GABA-B agonist and as such can cause absence seizures on its own in high (for most ppl, very high, but some people can get seizures with normal doses) doses. Combine that with something else that acts on the GABA system like benzodiazapines, tranquilizers, etc. and you have a recipe for seizures. On the other hand, this substance does work well with stimulants, takes the edge off them and makes them more enjoyable. I've seen people using LSD that were having a bad trip, and a relatively high amount of this substance was able to make it a good trip for them (in general, what would normally have been a passout dose). On LSD, oe's passout dose could increase twofold due to LSD's powerful stimulant properties.
It's a shame that this substance has been banned in some states despite its safety if one uses a little common sense. The media has a way of taking the smallest occurances of problems about a drug and amplifying them to sound like the plague. So try to use this substance (I should say carbohydrate) with care and common sense lest more states make it illegal. Thanks.
Peace.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.