Rules occupy a hazy area between data and procedure. Like data, each rule in a rule base is independent, and can be linked to other rules dynamically based on common values. Like procedures, each rule has multiple substatements specifying conditions and/or actions related to the execution or firing of the rule.
Looking at it another way, both databases and procedures can be thought of as degenerate cases of rule bases. A database is a collection of rules that have no action statements and only one set of conditions. A procedure is one big rule with many statements. Figure 1 illustrates the relationship between data, procedure and rules.
Figure 1: The relationship between data, procedure and rules.
Because most programming tools are designed for either data or procedures, when confronted with a specification written as a collection of rules, the developer is faced with a tricky problem. The rules cannot be expressed in data, and coding them procedurally leads to spaghetti code for even the best of programmers. Further the original rules get lost in the code, become difficult to debug, and almost impossible to update if necessary.
Ironically, this difficult part of an application is often its heart, and, to make matters worse, the piece most likely to change.
Consider a billing application for a phone company. Most of the application is cleanly coded using data for calls and customers, and procedures for processing the data. But pricing the call is the tricky part, based on a collection of rules derived from marketing concerns, local regulations, various sub-carriers, and special arrangements with large customers, all on top of the expected rules based on time-of-day, physical distance of call, length of call, and whether it was a credit card, collect or directly billed call.
All you need to do to understand the importance of phone call pricing is listen to the large phone company's ads. Each claims to have better pricing rules. The volatility of the rules derives from the competitive environment, evolving technology and changing government regulations.
The phenomena of a difficult rule-based component being the heart and soul of an otherwise straight-forward application occurs over and over. Consider the underwriting rules for insurance companies, the scheduling rules for an airline, the configuration rules for manufacturing, the diagnostic rules in a help desk, loan approval rules in banking, and exception handling rules in process control.
So what's a programmer to do? There are tools for coding rules directly, but there are two major problems with them, one related to environment and the other to the rule language itself.
The environment issue is simply one of integration. Most of an application can be implementented using conventional database and programming tools. To be practical, the rule-based component must easily become a part of the full application architecture.
The rule language issue is a more difficult one. The sad truth is the rules for one problem domain are not really very much like the rules for another. It is simply not clear what a universal rule language should like. If a rule language is easy to use, then the chances are it doesn't have the power or expressibility necessary for very many application areas. If a rule language has all of the bells and whistles necessary for multiple application areas, it becomes very difficult to use.
Because of these difficulties, most programmers simply roll up their sleeves and start forcing the rules into procedural code. It is for this reason that few applications really have any heart.
There is another option, and that is to build a custom rule-engine for the application. The custom rule-engine uses a rule syntax that mates well with the problem domain, provides integration tools directly related to the application, and processes the rules in the most sensible manner.
The design issues with rule engines are not dissimilar from the issues with data engines. That is, for a program to access data two things need to happen. One, a format for the data needs to be designed, and two, software that accesses the data needs to be designed.
This is true for both external data bases, which range from simple flat files to full relational systems, and internal data that can be represented in arrays, structures, linked lists or arbitrarily complex combinations of all three. In each case the programmer picks a representation and uses either canned software or writes some new code to handle the data.
Rules present the same technical challenges. A format for the rules needs to be designed, and software that provides accesses to the rules needs to be provided. As with data, there are many possibilities, depending on the situation.
The format of the rules is, of course, the rule language. It typically has rules expressed in an 'if-then' syntax, but because the way the 'if' side of the rule relates to the 'then' side of the rule, the more general terms 'left hand side (LHS)' and 'right hand side (RHS)' are often used.
The rules refer to data represented in some manner. The rule engine decides, based on the data, which rules to activate and in what order. The results of picking one rule will dictate which rule follows. Thus the execution order of the rules is determined dynamically, and is a function of the data fed to the rule base.
Three key technologies are needed for implementing a rule engine.
While these tools can be developed in any language, they are an integral part of the Prolog language. For this reason Prolog is used for the sample code in this article. The design ideas, however, are not language dependent and can be implemented in any language. (I've seen rule languages implemented in C, Smalltalk, Pascal, Lisp, and even COBOL.) But, given an efficient implementation of Prolog that can also be embedded in other languages, Prolog becomes an excellent tool for implementing customized rule engines designed to be components of larger systems.
Given that rule-based components of applications often need to be easily read and maintained, a major goal of rule design is to reduce the 'semantic gap' between the expression of the rules in the problem domain and the code for the rules.
One of the biggest problems with coding rules procedurally is the code no longer looks like the rules. It is difficult to see the rules in the code, and more difficult to modify or add new rules to the code. (The situation is very similar to that encountered years ago when programmers were forced to code scientific equations in assembler. The large semantic gap between the specification of an equation and the code that implemented it made the code unreadable in terms of the application's purpose. Languages such as FORTRAN narrowed the semantic gap making it much easier to build and maintain programs with equations in them.)
For example, we implemented a system that set the myriad installation parameters required for installing a large complex IBM mainframe software product. The field support people were used to working with printed documentation that specified the relationships between components of the software, and the settings for various parameters. That documentation looked very much like the following rule from the automated system.
quest loadunit default @ diskunit edit none prompt [‘What is the unit for the load library?’].
What is of interest here is the @ sign. For the installers it had a specific meaning, which is that this parameter defaults to the same value as another parameter. Using a generic rule language, the information in this rule would probably require using if-then syntax rules, something like this.
if parameter = loadunit and no_value_specified then get_value(diskunit, X) and set_value(loadunit, X).
The custom rule engine, by contrast, supports a rule language that is very close to the way the engineers think of the rules, and automatically applies the rules as expected. The result is a rule language that is much more readily accessible to both the designers of the rules and the users of the rules.
That same application also required reasoning about the interrelationship between products. Again, a custom representation was used that did not require an if-then syntax. The following rule specifies the relationship between products, and the rule engine applies these rules in the correct way.
product ‘ADS Batch 10.1’ password [adsb] corequisites [‘IDMS DB’, ‘IDD’].
There were some if-then rules as well in this application, but a large percentage of the potential rules were eliminated through the use of a customized syntax for expressing the rules and a customized rule engine that applied the rules.
Rules always express relationships between data elements. One key design question is how is the data represented? The simplest approach is attribute value pairs, as shown in the automobile driving advisor in Example 1. It uses, for example, the attribute 'traffic_light' which can have various color values.
if traffic_light is green then action is proceed. if traffic_light is red then action is stop. if traffic_light is yellow and driving is crazy then action is accelerate. if traffic_light is yellow and driving is sane then action is stop. if city is 'Boston' then driving is crazy. if city is not 'Boston' then driving is sane.
Example 1: Rules advising an automobile driver.
Attributes and their values can be easily represented using Prolog's built-in database tools. For example, if the color of the traffic light was determined to be red, this Prolog statement would execute:
assert( known(traffic_light, red) ).
The pattern-matcher, when deciding if a rule should fire, poses Prolog queries, such as:
known(traffic_light, green).
The simple attribute-value idea can be extended to allow attribute-value pairs to be associated with objects, as in 'car_1 color is red'. That idea can be further expanded into more complex data representations, such as frames. Frames are a very powerful way of representing data that incorporates many of the same ideas as OOP, including the ability to set default values, inherit from other frames, and transparently contain procedures for calculating values. They can also contain deamon procedures that are triggered by changes to frame attributes or slots.
The data representation in the installation application described in the previous section is a simple frame-like representation. Each frame contains 'slots', that, in the example, represent the name of the object, the default value, the edit criteria, and the prompt to be given to the user if necessary.
Some applications benefit from these more complex schemes and others have no need for them. The installation system needed more complex data representation because much of the knowledge in the system was more naturally expressed as data relationships.
In many cases the rules depend on data that is acquired from the user, by asking. In this case the rule engine needs to remember the answers to questions and only ask the first time a rule needs to know something from the user. For example, four of the driving advisor rules in Example 1, need to check the color of the light. The user would get aggravated if the system asked the user each time it tested a rule.
The Prolog code in Example 2 can be used by an engine to ask and remember. It uses two Prolog rules. The first checks to see if an attribute already has a known value, and, if so compares it to the required value and either succeeds or fails. If there is no previous known value, then the second rule fires, asking the user, saving the answer and again checking to see if the answer was as expected.
(Prolog note: terms beginning with upper case letters are variables.)
ask(Attr, Val) :- known(Attr, X), !, X = Val. ask(Attr, Val) :- write(‘What is the value of ‘), write(Attr), read(X), assert( known( Attr, X ) ), X = Val.
Example 2: Prolog code that 'ask's a user for the value of an attribute, and remembers the answer for future queries.
As the rule engine starts to look for rules it will need to ask the user about the color of the light. It will only ask once, and when testing other rules will use the remembered answer to the question. The value of city will only be asked for if it is needed. That is, unless the user indicates the light is yellow, the rule engine will never need to find out the value of city.
This type of user interaction is particularly important for diagnostic systems, where the system is trying to determine the cause of a problem based on a dialog with the user. By using a predicate such as 'ask' a system can be designed to only ask questions that are triggered by pertinent rules, and only ask when the data is actually needed.
Stand-alone rule-based systems have the luxury of having their own self-contained data representation. Component rule-base systems, on the other hand, might need to gather data outside of the rule base.
In this case the system can be designed so that data external to the rule base is gathered to populate internal data, or it can be designed so that the rules directly reference external data. In the first case, the system is designed so that the caller provides the required information. In the second case the rule engine must be designed to provide the rule base with access to external information.
For example, a system that prices telephone calls has no need for user interaction. Instead, it must gather its data from the database, getting particulars on the call, the customer, the carrier, and other relevant information.
A component rule-base might also need to gather information from external procedures. A rule-base concerned with monitoring physical processes or hardware needs to access functions that provide information about the process or hardware in question.
For each of these cases, a predicate similar to 'ask' is written that either goes to the database or some external function to get the information required for the rules.
Different types of problem domains require different types of reasoning support. For example a system that is concerned with monitoring physical processes needs to be able to include rules that reason over time. The concepts of before and after need to be part of the rule language. The same is true of scheduling systems.
Similarly, systems that configure physical components, such as laying out circuit boards, need to be able to express spatial relationships.
The same considerations apply to smaller details that can make a rule language more accessible. Consider the telephone call pricing system. It needs to have a clear and easy way of representing just the area code and/or exchange of a phone number, for use in various rules and database queries. This is not a difficult feature to add, but one that makes the coded rules that much easier to read for those non-programmers that make the rules.
The defining aspect of any rule engine is the way it dynamically links rules together. There are two fundamentally different approaches, goal-driven, sometimes called backward-chaining, and data-driven, sometimes called forward-chaining.
Goal-driven rules are more common. They are written with the idea that each rule defines a goal to be satisfied, and the subgoals that make it true. This approach is typically used for diagnostic-type systems and identification systems.
The call pricing system falls in this category. There are rules that determine call price which are dependent on sub-rules that determine the carriers used, the local regulations, etc. etc.
The Example 1 driving advisor is the same. The system starts with the goal of determining the action to take, and then proceeds to the subgoals of finding the color of the light, and if necessary the city.
Because goal driven rules can be neatly organized according to goals and subgoals, and because people often think of problems in those terms, goal-driven rules are popular for many applications.
Prolog is itself a goal-driven rule-based language. A basic Prolog rule is of the form:
goal(X, Y) :- sub_goal_one(X), sub_goal_two(Y).
Because Prolog is a rule-based language, it can be used directly for many rule-based applications. Often pure Prolog rules with a few helper predicates, such as 'ask' introduced earlier, will be adequate for building a rule-based component.
Example 3 shows the driving advisor written in pure Prolog, with the help of 'ask'. To use it, one simply poses the Prolog query 'action(X)'. After 'ask'ing one or two questions, X will be bound to the answer.
action(stop) :- traffic_light(red). action(proceed) :- traffic_light(green). action(accelerate) :- traffic_light(yellow), driving(crazy). action(stop) :- traffic_light(yellow), driving(sane). driving(crazy) :- city('Boston'). driving(sane) :- not city('Boston'). traffic_light(X) :- ask(traffic_light, X). city(X) :- ask(city, X).
Example 3: The driving advisor in pure Prolog.
Because this article is about building rule engines, Example 4 shows a four-rule Prolog program that implements a basic Prolog interpreter in Prolog, as well as supports the special predicate 'ask'. It can be used with the rules in Example 3 as easily as the real Prolog interpreter. Simply pose the Prolog query 'prove(action(X))' to get the value of X.
prove(true) :- !. prove(ask(A,V)) :- !, ask(A,V). prove((Goal,Rest)) :- prove(Goal), prove(Rest). prove(Goal) :- clause(Goal, Body), prove(Body).
Example 4: A Prolog interpreter in Prolog.
The four Prolog rules in Example 4 say:
1) If the goal is the atom true, then we've reached the end of the proof. (Facts, rules with no bodies, always end in true. For example, the fact 'sky(blue).' is really stored as the degenerate rule 'sky(blue) :- true.')
2) If the goal is 'ask', then call ask directly. This is needed as a special case because usually the rules for the rule engine, including 'ask', will be compiled, and not dynamically stored.
3) If the goal is a comma-delimited list, prove the first goal in the list and then prove the rest of the list.
4) If the goal is a single goal, then see if there is a rule (clause) in the database who's head unifies with the goal, and if so, get its body. Then prove the body.
Prolog unification automatically takes care of pattern-matching between goals and the subgoals of rules. Prolog search will cause all of the rules (clauses) to be tried in an effort to prove a goal true or false. Prolog recursion will carry the search to whatever depth of nesting is required.
Given this template, it is easy to modify this scheme to come up with custom variations on both Prolog inferencing and rule representation. Consider again the rules in Example 1. The Prolog code in Example 5 will interpret those rules exactly as they are written.
The operator definitions in Example 5, starting with ':- op', tell Prolog to accept terms such as 'pred(arg1, arg2)' when written as 'arg1 pred arg2'. This is how Prolog accepts the natural looking rule syntax of Example 1.
:- op(790, fx, if). :- op(780, xfx, then). :- op(770, xfy, and). :- op(700, xfx, is). :- op(690, fx, not). prove( Attr is Value and Rest ) :- getav(Attr, Value), prove(Rest). prove( Attr is not Value) :- atomic(Value), not(ask(Attr, Value)). prove( Attr is Value) :- getav(Attr, Value). getav( Attr, Value ) :- if Conditions then Attr is Value, prove( Conditions ). getav( Attr, Value) :- not(if _ then Attr is _), ask( Attr, Value ).
Example 5: Rule engine for Example 1 rules.
The rules of 'prove' cover three cases. 1) If there is a list of subgoals to prove, separated by 'and's, then call getav to see if the first attribute value pair is true, and, if so, prove the rest. 2) If there is a single negated goal, simply ask for the value and negate it. 3) If there is a single goal, call getav to see if its true.
The rules of 'getav' cover two cases. 1) If the attribute is defined in the 'then' side of a rule, try to prove the 'if' conditions of the rule. 2) If the attribute is not on the 'then' side of any rule, its OK to ask the user.
Again, Prolog recursion, unification and backtracking do most of the work. To use this rule engine, simply pose the Prolog query 'prove(action is X)', and, just as in the other cases, X will wind bound to the answer.
Data-driven rules are often called production or rewrite rules. The 'if' side of the rule refers to data that is known to the system. If the data in the system matches the pattern on the 'if' side, then the rule is said to be fireable. Firing the rule means the actions on the 'then' side of the rule are taken. These actions change the state of the known data, often adding assertions, thus making other rules eligible to fire, and the cycle continues.
Data-driven rules can be more difficult to work with, but they allow for rule-based expressions of complex configuration-type applications that cannot be easily implemented with goal-driven rules. They start with the initial data of the system to be configured, transform it to a new state which is further transformed until a final configuration is reached.
This type of problem does not code well with goal-driven rules because the final goals cannot be easily ennumerated. For example a scheduling system can produce an infinite variety of schedules, depending on the input data. Contrast this to a diagnostic system, which will always be diagnosing the same finite set of problems.
Even though Prolog is a goal-driven language, it can be used to implement a data-driven rule engine as easily as it implements a goal-driven one.
Example 6 shows one rule from a sample data-driven system that configures living room furniture. The system starts by asking the user the dimensions of the room and the list of furniture to be configured. The rules gradually transform that data until no more furniture can be placed in the room.
The rule shown places the TV opposite the couch. It will only fire when a couch is already in position, there is a TV that has not been placed, and there is enough room on the wall opposite the couch to hold the TV. (Note the use of the spacial predicate, opposite.)
When it does fire it removes the TV from the unplaced list, positions the TV on the opposite wall from the couch, and updates the space available on that wall.
rule f3: [1: furniture(tv,LenTV), 2: position(couch, CW), 3: opposite(CW, W), 4: wall(W, LenW), LenW >= LenTV] ==> [retract(furniture(tv, LenTV)), assert(position(tv, W)), retract(wall(W,LenW)), NewSpace = LenW - LenTV, assert(wall(W, NewSpace))].
Example 6: A sample data-driven configuration rule.
Example 7 shows the essential parts of a rule engine that interprets data-driven rules. It uses Prolog operators, like the goal-driven rule engine, to allow for a readable presentation of the rules.
The main predicate, 'go', finds a rule, tests to see if the left hand side of the rule matches the known facts at the time, and, if so performs the actions on the right hand side. It then repeats the cycle by recursively calling itself.
The 'match' predicate walks the list of conditions, either comparing each with the known facts or performing indicated tests. The 'process' predicate walks the list of actions, taking each in its turn.
go :- rule ID: LHS ==> RHS, match(LHS), process(LHS, RHS), !, go. go. match([]) :- !. match([N:Prem|Rest]) :- (fact(Prem); test(Prem)), match(Rest). test(X>Y) :- X>Y,!. test(X>=Y) :- X>=Y,!. process([],_) :- !. process([Action|Rest],LHS) :- take(Action,LHS), !, process(Rest,LHS). take(retract(X)) :- retract(fact(X)), !. take(assert(X)) :- asserta(fact(X)), !. take(X = Y) :- X is Y, !. take(write(X)) :- write(X),!.
Example 7: A data-driven rule engine.
This basic program can be modified and expanded to handle any degree of added sophistication one might want to add to the rule-engine, and there are plenty of wrinkles that can be added to a data-driven rule engine, including full frame-based representation of knowledge and various rule indexing schemes to improve search performance for large rule bases.
Some rule-based systems produce definitive results. Phone call pricing is one example. Others deal with fuzzier situations and need to quantify the probability of the possible answers. Diagnostic systems sometimes fall into this category.
In these cases the rule engine must be designed to carry probabilities along with various conclusions, and propagate those probabilities through linked rules and data.
This type of extension can be added to the rule engines shown so far by simply carrying an extra argument representing uncertainty. The formula for propagating that uncertainty becomes part of the rule engine, as does some criteria of minimum certainty required to continue a proof.
Example 8 shows some automobile diagnostic rules that include 'certainty factors', represented by cf. These are a simple, pseudo-probabilistic way of representing certainty on a scale of 0 to 100.
rule 1 if not turn_over and battery_bad then problem is battery cf 100. rule 2 if lights_weak then battery_bad cf 50. rule 3 if radio_weak then battery_bad cf 50. rule 4 if turn_over and smell_gas then problem is flooded cf 80.
Example 8: Rules with uncertainty.
Most rule-based systems are simply required to produce an answer, but some systems are required to explain themselves as well. This might be because the system is providing advice that may or may not be taken by the user, or it might be because the system is used in a training capacity as well. Explanations are also invaluable for the system developers to use as a debugging aid.
Explanations are usually presented in the form of rule traces, but other more complex schemes can be implemented as well. In any case, the explanation facility is just one more extention that can be added to the rule engines presented so far.
In the preceding examples rules were represented as Prolog terms, made more readable through the use of Prolog operators. Sometimes, however, a more general purpose syntax is required.
Prolog provides for this with a built-in parser called Definite Clause Grammar (DCG). It allows you to specify language rules, and also translate the language into pure Prolog terms.
For example, the rules in Example 8 are not defined with operators, but are translated by DCG rules into formal Prolog syntax. The formal representation of the fourth rule of Example 8 is:
rule(4, lhs([av(turn_over,yes), av(smell_gas,yes)]), rhs(av(problem, flooded))).
The rule engine uses this formal syntax. Some of the DCG rules that transform the rules are shown in Example 9. Note that the grammar rules allow multiple ways of representing an attribute value pair. Either 'is' or 'are' can be used, and if only a single word is encountered, it is assumed to mean the attribute only has a yes or no value.
The grammar rules assume that each rule was first read into a Prolog list of words, such as [rule, 3, if, radio_weak, then, battery_bad, cf, 50]. (The bracketed items in the grammar rules are picking out the reserved words in the diagnostic rules. As always, an initial upper case letter indicates a variable.)


CROOKLYN A film review by Joan Ellis Copyright 1996 Nebbadoon Syndicate
"Crooklyn" is a startling departure for Spike Lee. His earlier work has been a primal scream that forces us, from whatever perspective we inhabit, to recognize the rage around us. He has explored the problems of class, race, and gender while shooting from all angles at persistent myths and stereotypes. This movie is a breather, a moment of reprieve and reflection for a front-line warrior. With his brother and sister he has made a collective reminiscence that is surprisingly gentle for a man who has his finger on the pulse of contemporary anger.
In Crooklyn, children invent variations on the games of urban childhood, which fit the confines of the stoops that are the boundaries of their lives. They rag each other mercilessly, but they are safe. There is no violence on Spike Lee's block.
They may be safe, but they are not quiet. The movie is a mad, marvelous verbal war, an uninterrupted battle of comic insults, and it starts with a grandiloquent verbal explosion. Carolyn Carmichael (Alfre Woodard) commands her five children to have the kitchen spotless by bedtime. When she returns at four a.m. to sloth and slop, she routs every last one of them out of bed in the middle of the night, lines them up against the wall, and delivers her lecture. She's Patton at Bastogne, spewing bombast at her children, who are corporals in this mom's army.
Getting the troops to eat right is a lost cause. The dinner table establishes the rhythm for the entire movie: conversational combat without pause. The trouble always starts with a minor clash and escalates to the full boil perfect pitch of the Carmichaels' dialogue. This family argues to a rap rhythm. Insult is the language of love.
Dad is a blues musician in eclipse. Unnoticed in the shadow of rock, he is sure the sun will shine on his music again, but he feels very sorry for himself as he waits. Cradling his children's heads in his huge, gentle hands, Woody (Delroy Lindo) gives them love as their anchor. Meanwhile, Mom carries the load and gradually begins to buckle under the weight of it. As Woody and Carolyn, Delroy Lindo and Alfre Woodard are a deeply touching pair.  On the downside, the movie is overlong because it lacks focus. Lee is a provocateur, not a storyteller. Once he has painted the culture of his family and their block, he has no place to go. In a burst of self-indulgent temper, he sends Troy, the eldest daughter, off to visit relatives in an appallingly sterile version of southern suburbia. Slap, slap, Suburbia, take that.
This movie is about the author's nostalgia, and Spike Lee's nostalgia turns everything shimmery right. It's his childhood, and don't let anybody mess with how he remembers it. On most counts, his memory is our reward.
Film Critic: JOAN ELLIS Word Count: 500 Studio: Universal Studios Rating: PG-13
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


| Author | Eur van Andel, Copyright © 2003..2008, all rights reserved. |
| Adapted-by | Rob Hamerling |
| Compiler | 2.4l |
This Interrupt Service Routine updates the variable seconds about once per second. The precision is 0.2 ppm, the accuracy depends on the Xtal used.
http://www.romanblack.com/one_sec.htm http://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm
This is the Bresenham Line Algorithm, invented at IBM in 1962, which gets an accurate end result by summing the small errors resulting of taking discrete steps and correcting when the error gets too large. This means that individual second lengths may show some jitter, but that long-term timekeeping is accurate. Original assembler by Roman Black. . At 20 MHz, so 200ns/clock, so 5 000 000 clocks/second Rhe RTC has three bytes: bres_hi, bres_mid, bres_lo timer 0 runs on internal clock speed and interrupts on overflow every timer 0 interrupt decreases bres_mid by one. The 5 000 000 value is added when bres_hi en bres_mid are zero note that remainder is added to bres_lo, which can overflow in bres_mid this keeps clock count accurate, although interrupts happen every 256 clock counts the ISR subtracts 1 from the mid byte. It first checks the mid byte for zero and borrows a bit from bres_hi if needed. . Required PIC settings: T0CON_PSA = 1 T0CON_PS = 0 T0CON_T0CS = 0 -- Timer0 on instruction cycle clock
No dependency found
const _rtc_cycles_per_second = (target_clock / 4)
const byte _rtc_mid = _rtc_cycles_per_second % 65536 / 256
var volatile byte _rtc_bres_hi = _rtc_hi
var volatile byte seconds
var volatile byte _rtc_bres_lo = _rtc_lo
const byte _rtc_lo = _rtc_cycles_per_second % 256
var volatile byte _rtc_bres_mid = _rtc_mid
const byte _rtc_hi = _rtc_cycles_per_second / 65536
const _rtc_cycles_per_second = (target_clock / 4)
No documentation found
const byte _rtc_mid = _rtc_cycles_per_second % 65536 / 256
No documentation found
var volatile byte _rtc_bres_hi = _rtc_hi
\
var volatile byte seconds
global variable updated by ISR
var volatile byte _rtc_bres_lo = _rtc_lo
/
const byte _rtc_lo = _rtc_cycles_per_second % 256
No documentation found
var volatile byte _rtc_bres_mid = _rtc_mid
> init 3-byte counter
const byte _rtc_hi = _rtc_cycles_per_second / 65536
No documentation found
RTC()
No documentation found
| 16f876a | 16f876a_rtc_lcd.jal |
| 16f876a | 16f876a_rtc_timeset.jal |
| 16f877a | 16f877a_rtc_timeset.jal |
| 16f877a | 16f877a_rtc_lcd.jal |
| 16f886 | 16f886_rtc_lcd_20mhz.jal |
| 16f886 | 16f886_rtc_lcd_4mhz.jal |
| 16f886 | 16f886_rtc_lcd_125khz.jal |


We're sorry, but the client doesn't work properly without JavaScript enabled. Please enable it to continue.


ID
Time Since
Winner
Game Mode
Radiant
Dire
{{match.match_id}}
{{match.start_time | timeSince}}
{{match.winner}}
Ranked
{{match.game_mode}}
Matches are updated approximately every 5 minutes.


{% extends "public/templates/public_template.html" %} {% block title %}Book Summarization{% endblock %} {% block main %} Book Summarization (β) Created by: Shanay Ghag and Saarth Deshpande
Created by: Shanay Ghag and Saarth Deshpande
Upload the PDF of a book to summarize. A ZIP file containing the chapter-wise summaries will be mailed to you within 30 minutes.


Seattle HQ
Street Address
City State Country
Tokyo HQ
Street Address
City State Country
Dubai HQ
Street Address
City State Country
Paris HQ
Street Address
City State Country
Lima HQ
Street Address
City State Country
Street Address
City State Country
Street Address
City State Country
Street Address
City State Country
Street Address
City State Country
Street Address
City State Country


pymatgen.util.convergence module¶
-
determine_convergence
(xs, ys, name, tol=0.0001, extra='', verbose=False, mode='extra', plots=True)[source]¶ test it and at which x_value dy(x)/dx < tol for all x >= x_value, conv is true is such a x_value exists.
-
extrapolate_reciprocal
(xs, ys, n, noise)[source]¶ return the parameters such that a + b / x^n hits the last two data points
-
get_derivatives
(xs, ys, fd=False)[source]¶ return the derivatives of y(x) at the points x if scipy is available a spline is generated to calculate the derivatives if scipy is not available the left and right slopes are calculated, if both exist the average is returned putting fd to zero always returns the finite difference slopes
-
multi_curve_fit
(xs, ys, verbose)[source]¶ fit multiple functions to the x, y data, return the best fit
-
multi_reciprocal_extra
(xs, ys, noise=False)[source]¶ Calculates for a series of powers ns the parameters for which the last two points are at the curve. With these parameters measure how well the other data points fit. return the best fit.


Few interestings infos (if these screenshots are reals?!)
https://fbcdn-sphotos-b-a.akamaihd.net/hphotos-ak-prn1/942040_554375621270298_1514012494_n.jpg
5 soldiers in a squad
https://fbcdn-sphotos-c-a.akamaihd.net/hphotos-ak-ash4/999373_554375697936957_835782061_n.jpg
https://fbcdn-sphotos-f-a.akamaihd.net/hphotos-ak-prn1/10765_554376017936925_1158532277_n.jpg
Battlepacks and challenges ?
https://fbcdn-sphotos-e-a.akamaihd.net/hphotos-ak-frc1/1004425_554375711270289_1833414386_n.jpg
https://fbcdn-sphotos-c-a.akamaihd.net/hphotos-ak-prn1/935915_554375791270281_364654304_n.jpg
"Grenades" with "s"...for more choice ?
"Mobility" characteristic for a weapon : each soldier will have a different speed ? depending of the weapon ?


This console was branded by Achille Franzetti. Access only for ACME Corp. employees.
EXCEPT FOR THE EXPRESS WARRANTIES SET FORTH IN SECTIONS 11.1, 11.2 AND 11.3, ACMEDEMO MAKE NO REPRESENTATIONS AND GRANT NO WARRANTIES, EXPRESS OR IMPLIED, EITHER IN FACT OR BY OPERATION OF LAW, BY STATUTE OR OTHERWISE, AND ACMEDEMO EACH SPECIFICALLY DISCLAIM ANY OTHER WARRANTIES, WHETHER WRITTEN OR ORAL, OR EXPRESS OR IMPLIED, INCLUDING ANY WARRANTY OF QUALITY, MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE OR PURPOSE OR ANY WARRANTY AS TO THE VALIDITY OF ANY PATENTS OR THE NON-INFRINGEMENT OF ANY INTELLECTUAL PROPERTY RIGHTS OF THIRD PARTIES.


{% set toctree = toctree(maxdepth=theme_globaltoc_depth|toint, collapse=theme_globaltoc_collapse|tobool, includehidden=theme_globaltoc_includehidden|tobool) %} {% if toctree and sidebars and 'globaltoc.html' in sidebars %} {% set toctree_nodes = derender_toc(toctree, False) %}


{{< layout}} {{$pageTitle}}You need another photo{{/pageTitle}} {{$header}}
Your photo has been automatically checked for common mistakes.
We’ll still check it manually and we could still ask for another if something doesn't look right.
If you're not happy with your photo, upload a new one now.


 I have never really been big into smoking but I have done it plenty of times in moderation and have always had positive 'happy' effects, but since I'm a light weight its always kind of a risk for me to do too much. I had one experience prior where I had seizure like symptoms and swore from that point on never to touch the stuff again.
So the story begins. I was hanging out with friends and consumed about 3 beers (woo hoo) and asked to hit the bong (which I've never smoked other than joints and bowls so I don’t know if that gives any explanation) just for old times sake. I hit it what I believe to be only 2 or 3 more times when I finally started feeling very happy. I went up to my friends mom and hugged her and told her I loved her which everyone got a big kick out of. Then sitting down on my friends lap I started feeling that things weren’t quite right. I wanted to slip away from everyone but I kept thinking “no they’ll be like what the hell are you doing and start laughing at me” but I kept being pulled away. Then everyone started looking at me which I definitely didn’t want which put me into a deep sense of paranoia. I then slipped off my friends lap feeling like a ton of lead and laid on the ground.
At first I didn’t know what to think. What was going on? Then a voice deep in my consciousness kept telling me “its ok don’t listen to them.” Which was everyone trying to get me to snap out of it. Then their voices kept sounding further and further away from me and I thought oh God where am I going? But then the voice kept telling me “its ok just let go.”  No no no not from smoking weed! But it just seemed like it wasn’t up to me and that I needed to stop fighting it.  So what way should I go? Did I even have the power to choose?
I was told that I was saying random things over and over again very loudly. I told my friends brother that I loved him and looked to everyone around me when in fact I didn’t even see them. To me they were all the significant people in my life who made me who I was today and it was okay to leave now because I was a good person because of these people. It seemed at this time to me that I was recalling everything that had ever happened in my life and the people that had touched my life had all been there for a reason and now I was seeing why. But I was getting closer and closer to the ultimate answer to WHY? When I'd then start to slip back to reality or away from what I was suppose to follow. I saw myself go back into creation before I was born.
The week before all this had happened I had finally decided that I wanted to go to college to be an ultra sound tech and now realized the reason I was going to do that because I was going backwards into my mothers womb. Weird! All these realizations were occurring in a split second. I remembered my first thoughts of being alive and then dying and how now was the time and how I just had to let go. But it was so hard. Had I done everything I was suppose to in life? Then the worst part came. Where would I go heaven or hell? The devil seemed to bring up all my bad characteristics while it seemed like god was on my fighting side since I had always turned to him in my life.
In between these strange pullings on my soul I happened to call my mom and tell her I needed her and I was sorry but she didn’t understand.  They were all out to get me in my mind when I reality they were trying to get me out of my soaked clothes and off the street I was walking on. I barely remember this piece of time because it all seemed like one big dream. Somewhere in this mess I had come upon the conclusion that this earth was hell and I had no where lower to go so I needed to get back to that state of mind where I could just “let go”. That’s why all my friends were trying to help me because they were workers of the devil trying to keep me from my eternal happiness.
Meanwhile I tried to eat the light bulb in my friends room saying “I need the light” and when her mom finally called the ambulance I asked for “the lights” so they dimmed them for me assuming that’s what I was asking for. I freaked out and screamed for them to turn then up. It seemed like everyone was against me and I was not suppose to be here on earth with them. I remember hearing the EMT’s talking about how I had to be on some other kind of drugs and there was no way I only smoked weed I was covering up but in reality it was the damn truth! During all of this I remained to slip in and out of what was now I silent darkness and the blurry reality.
Next all I remember is waking up in the hospital bed. My parents looked at me with disappointment and all I could feel was this uneasy feeling of misplacement, like I wasn’t suppose to be alive. I told my mom this and how I thought I was suppose to die and she responded “God had bigger plans then you did.” My mom is an amazing person but that’s a different story. So the blood test showed a blood alcohol count of less than a beer and no drugs other than marijuana but I still felt like I had been in a car wreck.
To this day I feel very uneasy about what occurred that night and plan on seeing a psychiatrist to talk about it. I have that sense of misplacement still and cant understand why I'm here. I see this occurrence as much more than just a “bad trip” and have come to some conclusion as I've read other stories trying to make it all make sense. Just as Eve ate the apple, what happened that night was some phenomenon that was trying to open my eyes to a greater understanding and knowledge beyond this world. My take on it is keep it I don’t want to know. I believe that if I would have acquired something form that night that I was not meant to have, I would never be happy again. But now that I'm on the road to recovery and trying to gain back my self-worth, I can go back to the fun loving blonde girl I use to be, but it's going to take some time.
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.


Create a short description or engaging message to motivate your audience to take action
Create a short description or engaging message to motivate your audience to take action
Create a short description or engaging message to motivate your audience to take action
This section could provide testimonials, links to training or documentation, or introduce other actions your audience may want to take.
This section can be used to offer supporting information or introduce a new idea. It's best to keep it relevant to the contents of the page so it doesn't feel out of place.


New York
London
Poznań
Chicago
Golden Gate
photography
home
photography
moving_image
interactive
audio
publications


There is a lot that you can do with the provided API. The Desktop UI is flexible to suit to various kind of industry-level applications that are really user-friendly. Have a look at our extremely friendly documentation.
Let us take a simple example. Here we see how to open another icon located on the desktop via the provided API. This could be needed anytime when one window wants to open another icon/module/window.
Click to open the Games folder.
Click to minimize the Games folder.
Click to close the Games folder.
You can also open a completely new window that does not exist within your modules already.


You can turn them off (the new generation of viruses doesn't bother using MAPI anyway--it uses SMTP). Go to Outlook Express Tools menu and click on Options, then select the Security tab. Deselect the box "Warn me when other applications try to send mail as me." (See picture below.)


Camping
The camp consists of nine guest tents each with accommodation for two people. Each tent has its own toilet and shower, so you can enjoy the luxury of en-suite living 'safaris style', with hot water heated over a log fire and brought to your shower when you're ready.
The meals at Nairobi Tented Camp are crafted to complement the authenticity of the safari experience. All meals are served on a set menu basis, with warming hearty breakfast in the morning, light invigorating lunches served under the shade of an olive tree and dinners of soufflés and tender beef fillet served under the star filled sky. Everything at Nairobi Tented Camp is homemade and cooked with special care and attention. If you have any special dietary requirements please let us know at the time of booking. Ice cold drinks are available from the fully stocked bar in the central mess tent.
Low watt LED lighting in each of the tents runs off rechargeable batteries and solar panels, and for dining, guests can enjoy the romance of candles and lanterns - a truly authentic tented camp experience.
Accommodation
- Twin or double bed
- Bedside tables
- Wardrobe for hanging your clothes
- En-suite toilet with bucket shower and basin
- Writing desk with lamp
- LED lighting
- Chairs and table on veranda for relaxing
- Luggage rack
- View into the valley and forest
Activities
Your day in Nairobi Tented Camp starts with a freshly brewed hot drink brought to your tent before setting off for that famous safari tradition – an early morning game drive. Be lucky enough to catch the first rays of early morning sun as they burn off the night dust of dew stirring the plains game gently to life.
After a morning potentially filled with sightings of lion, buffalo and leopard, return to camp for more warming cups of tea and coffee, freshly baked bread and a hearty cooked breakfast. The camp is made up of nine guest tents and a central mess and dining tent from which meals will be served. In the afternoon, guests can relax in the lounge area or in the privacy of their own tent. There is nothing more blissful than sleeping off your three course lunch in a swaying hammock under the shade of an olive tree.
As the day cools and the sun starts its journey west, it will be time for another game drive – a chance to catch that evasive moment where a lion might decide it is time to feast. Return to camp for drinks and exchange stories around the campfire before dinner under the vast African star-lit sky, ultimately retreating to the comfort of your bed in your cozy tent.


Demo: Project Planning for YouTrack
Reconstruct past project schedule from YouTrack activity log, and compute future schedule from YouTrack issue data plus a list of available contributors.
This web app is deliberately bare-bones to demonstrate the API provided by this package. All data is retrieved through the YouTrack REST API. Authorization happens through OAuth 2.0. This web app never comes in touch with your password.


| I l@ve RuBoard |
11.6 The tabnanny Module(New in 2.0) The tabnanny module checks Python source files for ambigous indentation. If a file mixes tabs and spaces in a way that throws off indentation, no matter what tab size you're using, the nanny complains. In the badtabs.py file used in the following examples, the first line after the if statement uses four spaces followed by a tab. The second uses spaces only. $ tabnanny.py -v samples/badtabs.py ';samples/badtabs.py': *** Line 3: trouble in tab city! *** offending line: print "world" indent not equal e.g. at tab sizes 1, 2, 3, 5, 6, 7, 9 Since the Python interpreter reads a tab as eight spaces, the script will run correctly. It will also display correctly in any editor that assumes that a tab is either eight or four spaces. That's not enough to fool the tab nanny, of course. Example 11-6 shows how you can also use tabnanny from your own programs. Example 11-6. Using the tabnanny ModuleFile: tabnanny-example-1.py import tabnanny FILE = "samples/badtabs.py" file = open(FILE) for line in file.readlines(): print repr(line) # let tabnanny look at it tabnanny.check(FILE) 'if 1:\012' ' \011print "hello"\012' ' print "world"\012' samples/badtabs.py 3 ' print "world"'\012' To capture the output, you can redirect sys.stdout to a StringIO object. |
| I l@ve RuBoard |


By making this selection, you will be redirected to the homepage of the chosen country.
( Requireddot indicates required)


Volume 32 · Number 2 · Spring 2015
Features
Still alive
New courses on horror literature are breathing life into English enrollments. |
From pines to pixels
A computer scientist’s simulations of nature could play a key role in protecting the world’s forests and balancing the global carbon budget. |
Pandemic busters
A UC Davis-led program, funded with $100 million from a federal agency, is working with partners in 31 countries to detect viruses before they spread. |
Sports: Fan makers
Never mind March Madness. The Aggie men’s basketball craze lasted all year long, with the cheers of ecstatic fans still echoing well beyond The Pavilion.
Video: "Inside the UC Davis Men's Basketball Championship Season" |


This section describes GrADS gridded data sets -- their structure and format, how to create them, and how to instruct GrADS to interpret them properly. Here are some quick links for skipping through this section:
In GrADS, the raw binary data and the meta data (information about the
binary data) are stored in separate files. The meta data file contains
a complete description of the binary data as well as instructions for
GrADS on where to find the data and how to read it. The binary data
file is purely data with no space or time identifiers. The meta data
file is the one you open in GrADS -- it is called the data
descriptor file. The data descriptor file has a default file extension of .ctl
and is therefore also referred to as a control file.
ga-> open filename.ctl
The data descriptor file contains a complete description of the binary data as well as instructions for GrADS on where to find the data and how to read it. The descriptor file is an ascii file that can be created easily with a text editor. The general contents of a gridded data descriptor file are as follows:
The individual components of data descriptor files are discussed in detail in the section Elements of a Data Descriptor File.
The data descriptor file is free format, which means the components of each record (line of text) are blank delimited. Leading blanks at the beginning of each record are removed before parsing. Comment records must start with an asterisk (*). Individual records may not be more than 255 characters long. Here is an example of a basic data descriptor file:
DSET ^gridded_data_sample.dat TITLE Gridded Data Sample UNDEF -9.99E33 XDEF 180 LINEAR 0.0 2.0 YDEF 90 LINEAR -90 2.0 ZDEF 10 LEVELS 1000 850 700 500 400 300 250 200 150 100 TDEF 4 LINEAR 0Z10apr1991 12hr VARS 4 slp 0 99 sea level pressure hgt 10 99 heights temp 10 99 temperature shum 6 99 specific humidity ENDVARS
In this example, the binary data set is named
gridded_data_sample.dat
and is located in the same
directory as the descriptor file. This is specified by the caret (^) in
front of the data filename. The undefined or missing data value is
-9.99e33, there are 180 grid points in the X direction, 90 grid points
in the Y direction, 10 vertical levels, 4 time steps, and 4
variables. The variable "slp" is a surface variable -- it has no
vertical levels, but is assigned a default vertical coordinate of
Z=1. The variables "hgt" and "temp" have 10 vertical levels, and the
variable "shum" has 6 vertical levels (the first six listed, 1000 to
300).
The binary data file is purely data with no space or time identifiers. The data descriptor specifies the data's grid dimensions, but it is up to the user to make sure that the binary data have been written to file in the proper order so GrADS will interpret them correctly.
GrADS views gridded data sets as multi-dimensional arrays varying in longitude, latitude, vertical level, variable, and time. In version 2.0, a fifth grid dimension was added. The fifth grid dimension is assumed to be used for ensembles, and so it is given the name E (or ens), but because it is generally implemented, it may be used for other grid dimensions such as EOFs. The default size of the E dimension is 1 -- if no E dimension exists, it is not necessary to explicity declare it the descriptor file.
It is helpful to think of a gridded binary data file as a sequence of "building blocks", where each building block is a horizonal grid of data varying in the X and Y dimensions. The first dimension (X) always varies from west to east; the second dimension (Y) varies from south to north (by default). One horizontal grid represents a particular variable at a particular height and time. Each horizontal grid in a GrADS binary data file must be the same size. If you have two variables with different horizontal grids, you must create two separate data sets.
The structure of a 3-D, 4-D, or 5-D data set is determined by the order in which the horizonal grids are written to file. The building blocks are stacked in a sequence according to dimension. The sequence goes in the following order starting from the fastest varying dimension to the slowest varying dimension: longitude (X), latitude (Y), vertical level (Z), variable (VAR), time (T), and ensemble (E).
For example, suppose you want to create a 4-D binary data set containing four variables. The horizonal grids would be written to the data set in the following order:
Time 1, Variable 1, Each vertical level from bottom to top Time 1, Variable 2, Each vertical level from bottom to top Time 1, Variable 3, Each vertical level from bottom to top Time 1, Variable 4, Each vertical level from bottom to top Time 2, Variable 1, Each vertical level from bottom to top Time 2, Variable 2, Each vertical level from bottom to top Time 2, Variable 3, Each vertical level from bottom to top Time 2, Variable 4, Each vertical level from bottom to top etc.
5-D ensemble data sets are created by concatenating 4-D data sets together -- the ensemble dimension varies outside of all the others. To extend the previous example, suppose you are creating a data set that has 3 ensembles (but only 2 variables) :
Ensemble 1, Time 1, Variable 1, Each vertical level from bottom to top Ensemble 1, Time 1, Variable 2, Each vertical level from bottom to top Ensemble 1, Time 2, Variable 1, Each vertical level from bottom to top Ensemble 1, Time 2, Variable 2, Each vertical level from bottom to top <...> Ensemble 1, Time N, Variable 1, Each vertical level from bottom to top Ensemble 1, Time N, Variable 2, Each vertical level from bottom to top Ensemble 2, Time 1, Variable 1, Each vertical level from bottom to top Ensemble 2, Time 1, Variable 2, Each vertical level from bottom to top Ensemble 2, Time 2, Variable 1, Each vertical level from bottom to top Ensemble 2, Time 2, Variable 2, Each vertical level from bottom to top <...> Ensemble 2, Time N, Variable 1, Each vertical level from bottom to top Ensemble 2, Time N, Variable 2, Each vertical level from bottom to top Ensemble 3, Time 1, Variable 1, Each vertical level from bottom to top Ensemble 3, Time 1, Variable 2, Each vertical level from bottom to top Ensemble 3, Time 2, Variable 1, Each vertical level from bottom to top Ensemble 3, Time 2, Variable 2, Each vertical level from bottom to top <...> Ensemble 3, Time N, Variable 1, Each vertical level from bottom to top Ensemble 3, Time N, Variable 2, Each vertical level from bottom to top
GrADS can read binary data that are formatted with or without FORTRAN record length headers. Files containing record length headers are called "sequential" and those without embedded record length information are called "direct access" or "stream" files. Unless otherwise specified, GrADS will assume the data file does not contain the record length headers.
GrADS can also directly read GRIB formatted data -- one of GrADS most powerful and unique features! See the section on Creating Data Descriptor Files for GRIB Data for more information.
A third category of data formats that GrADS can read are "self-describing files" such as NetCDF or HDF-SDS. For more information, see the references pages for reading NetCDF or HDF-SDS files.
The default format for GrADS gridded binary data files is "stream" or "direct access". If you want to read FORTRAN "sequential" unformatted binary data files, you must include the following additional record in the data descriptor file:
OPTIONS sequential
Following are three examples of how to create gridded binary data files with simple FORTRAN programs.
parameter (ni=144,nj=91,nk=8,nt=4) dimension u(ni,nj,nk),v(ni,nj,nk),dum(ni,nj) do n=1,nk call load(u,ni,nj,nk,n,dum) write(10) dum end do do n=1,nk call load(v,ni,nj,nk,n,dum) write(10) dum end do subroutine load(a,ni,nj,nk,n,dum) dimension a(ni,nj,nk),dum(ni,nj) do i=1,ni do j=1,nj dum(i,j)=a(i,j,n) end do end do return
The data descriptor file would look something like:
DSET ^model.dat TITLE Sample Model Data UNDEF 0.10000E+16 XDEF 144 linear 0 2.5 YDEF 91 linear -90 2.0 ZDEF 8 levels 1000 900 800 700 500 300 100 50 TDEF 4 linear 00z01apr85 6hr VARS 2 u 8 99 U component v 8 99 V component ENDVARS
REAL Z(72,46,16) .... OPEN(8,FILE='grads.dat',FORM='UNFORMATTED', & ACCESS='DIRECT',RECL=72*46) .... IREC=1 DO 10 I=1,16 WRITE (8,REC=IREC) ((Z(J,K,I),J=1,72),K=1,46) IREC=IREC+1 10 CONTINUE
REAL X(100) DO 10 I=1,100 X(I)=I 10 CONTINUE OPEN (8,FILE='samp.dat',FORM='UNFORMATTED',ACCESS='DIRECT', &RECL=100) WRITE (8,REC=1) X STOP END
The associated descriptor file:
DSET samp.dat TITLE Sample Data Set UNDEF -9.99E33 XDEF 100 LINEAR 1 1 YDEF 1 LINEAR 1 1 ZDEF 1 LINEAR 1 1 TDEF 1 LINEAR 1JAN2000 1DY VARS 1 x 0 99 100 Data Points ENDVARS
Once created, you can use this data set to experiment with GrADS data functions, such as:


Pindar Wong
Transcript By: Bryan Bishop
Category: Conference
Pindar Wong
Forked to Death: What Internet governance can learn from Bitcoin
So, the last talk today is going to be from Pindar Wong. He’s been involved with Internet in Hong Kong. He also helped organize the Scaling Bitcoin workshops. It’s my pleasure to have him speaking today.
Okay. Thank you very much for staying until the bitter end. My topic today is forked to death, what Internet governance can learn from Bitcoin. I do mean this, and I would like to explain why. This is a fork. I am holding a fork.
In Internet governance, we don’t talk about forks, we talk about fragmentation. The title here should be fragmentation to death, what Internet governance can learn from bitcoin. Fragmentation from the internet is a real and present danger. This morning we heard we have an internet one behind China and one behind the United States…. I am from Hong Kong. We had some views this morning about the miners in China. As you also know, I was honored to finally meet many of you through the process of Scaling Bitcoin.
Bryan Bishop at the end of Phase 2, why not post to the -dev mailing list about reflections about the event? Phase 1 was one of the times when many developers got together. And phase 2 was when all of the hash power got together for the first time. Looking back on that, this presentation is looking back on those two recent events, as well as the recent Satoshi Roundtable and also the Hong Kong meeting.
First I would like to thank the students from MIT who came up to Montreal to help up with this seminal events. MIT DCI was one of the core underwriters for this event. Jeremy Rubin was the chair for phase 1. So thank you so much for that.
So what can Internet governance learn from Bitcoin? The first point is that the Bitcoin community is very careful about attempts to externalize cost. This is really smart.  This group is really sensitive to the notions of externalizing costs. BGP attacks were mentioned earlier. Spam is another example. We did not do that cost externalization analysis, and I think this community does that really well, we should really learn from Bitcoin about when to externalize cost in a shared system.
The second one is that it’s about meritocracy, we don’t care who you are, it’s rather about your ideas. We see past race, gender, orientations, prejudices, it’s a technical meritocracy for proof-of-work of hard work. To see people get on planes and come to the event for Scaling Bitcoin and have really deep civilized respectful technical conversations, was wonderful to see.
The other thing that I have learned… I still use email. I don’t use chat. I have only tweeted maybe 40 times. This community has discovered something faster than light, and that’s rumor. It’s real-time media audit. The use of reddit and the use of IRC and all the different chats, it seems 24 hours per day. That’s something to recognize, because to me that’s something really different. Cory and I had an interesting exchange, he said, would the internet have occurred if it was constantly under the media spotlight that current internet provides? I think the answer is no, but it’s ust my hypothesis, we can’t check this.
I think this community is develping an immune system. I don’t think it’s about governance. Let me explain why. Let’s look at the Internet today. I started the first ISP in Hong Kong in 1993. That was 23 years ago? How many of you are under 23? So technically, before you were born, geeze I feel old. July 5th, 1993, there was a famous comic in the New Yorker, which said that on the internet nobody knows you are a dog. That resonated with me because the internet was the first time at a societal level that mainstream can talk about the internet and say whatever it wanted. This year we see mainstream talking about Bitcoin. So keep this in mind.
The reality is that, right now, despite the Internet, what we have is that people doing metadata analysis, doing data surveillance and making accusations and allegations. The metadata these days is the message. We have developed this Internet which was supposed to be free and open, and in terms of previous governance, we have failed.
Also in terms of governance, before text, we had a wonderful word which I am going to describe. It was before images. The people who were at the cusp, like Joi Ito, who run the MIT Media Lab, who feel strongly about Bitcoin so that we don’t make technical compromises that jeopardize interoperation of the Bitcoin blockchain.
Today I was supposed to be in Morocco for an ICANN meeting. The internet kind of just works. Well, there’s a lot of engineering that makes the Internet work. The closest thing I could say for consensus protocols is like BGP. All of the routers have this algorithm, and the packets end up where they should. On the internet, you need a hierarchical numbering system of IP addresses, like for IPv4. I was also the device chair of the IP name assignment for the agency. This meeting is important, I think, because it’s the 55th meeting. Scaling Bitcoin has only had 2. This has had 55 minutes since 1998. It’s supposed to decide if the US government lets go of the car keys, and lets ICANN self-administer. This was supposed to happen on September 30th, 2000. So we are 16 years later. Perhaps better late than never?
This is as close to Internet governance as you will probably get. You all remember that in Bitcoin, on the front page of The Economist, was “the trust machine”. If you look at today’s Economist, there was an article about Internet governance. This topic is about Internet governance and what it can learn from Bitcoin.
So what is Internet governance? It’s blah blah blah blah. It took several years to negotiate the text. “Internet governance is the development and application by governments, the private sector and civil society, in their respective roles, of shared principles, norms, rules, decision-making procedures, and programmes that shape the evolution and use the internet.”
Guys like me show up in jeans, and then they ask who am I? The difference is that engineers are willing to solve it no matter who the engineers are, but then the Internet governance discussion becomes “who are you?”. I think that’s the wrong model.
We heard this morning that you can escape government but you still need governance. I think what we have right now with Bitcoin is actually working, though. Governance is the wrong model. If you talk about governance, you are talking about control, centralization, you’re talking about aligning different interests, whereas if we changed that model, from this afternoon’s presentation, if at any time after this time forward and hear someone saying “Bitcoin governance” ask them to stop and ask about health instead. It’s about Bitcoin ecosystem health.
Anything that you do, should improve the Bitcoin ecosystem health, however you perceive that to be. Don’t talk about governance, talk about ecosystem health. What I mean by Bitcoin health is that we are building a healthy industry with all of the different players, including academia. Everyone has different interests, but what aligns us all is that we are an ecosystem of interdependent almost by design, and in so doing, we need to think carefully about the health of the whole ecosystem and your own individual.
Yes, we’re dealing with issues of technical scalability, like the block size discussion and debate, the drama that has happened over the past year and a half, but sorry that’s absolutely normal. Maybe it’s your first time going through the mill, but this is sort of the strength of Bitcoin itself.
Beyond technically scalable, which is something that I think we can solve, but is the whole thing economically sustainable? I think that’s an open question. The subsidy and the cost of operating the system, like CPU time, like unspent transactions, and calculating the total cost of the system so that the whole thing is economically sustainable in addition to technically sustainable. For an ecosystem like this, what would you consider to be pollution? What is normal? What is UTXO pollution? What would you consider to be normal? What would you consider to be a normal functioning Bitcoin ecosystem? That’s the imagine that I hope we can define.
In the Internet ecosystem, we talk about evolution. There are no permanent favorites. In regards to the recent events in 2013, such as the Snowden revolutions, and NIST compromised recommendations, and the IETF engineering task-force has classified that as an attack. Previously they recognized censorship as an attack that the Internet routes around, that’s an evolutionary process. We admit that we make mistakes, we learn from it, and we evolve. In an ecosystem health model, also look at an evolutionary health model, things that don’t evolve will die. So we think about balance and that kind of thing.
So that’s the whole concept of stimulus and response, such as stimulating your immune system, and having it adapt and evolve. This is used in Japan for kaizen for continuous improvement. I believe Bitcoin should have the best tech, the best people, evolving the system to meet higher goals.
How many of you remember this? Yeah, the mosaic browser. Okay you are all geeks. a16z before he was a VC, he actually wrote code, like Mosaic (NCSA). This was around 1993. There was an era before that, which was a magical era, which was the era of pure text, pure imagination, no graphics, no distractions.
In that era, we had a timeline, we had the academic networks up to 1993 more or less, we had our trade association from 1991 for the commercial Internet exchange, which my ISP joined as a member. This National Science Foundation network was designed to survive nuclear attacks. There was a whole bunch of 20 more years of research and development that ended around 1993. The commercial guys, I dropped out of university, I was 23 or 24 at the time, had a PhD, co-founded an ISP, and obviously ISPs were commercial they had the goal of making money.  This was built into our blood in Hong Kong.
There was a huge culture clash between those who were purists versus those who are commercial. There were culture clashes there which we sort of see now in Bitcoin, those who are interested in making money, and then a bunch of Bitcoin Core developers who are flag bearers for Bitcoin principles. At that point in time, for those who want to double check, look at the reports at the time. There was lots of drama. Nothing particularly new, when you have a difference of culture.
Right now where we are in Bitcoin, in some sense we have this backwards. We have gone commercial, and as Arvind said is that academia is good at scaling knowledge, but it’s still warming up. Some of us are good at building Internet, which I will talk about.
I think that the Bitcoin community is super sensitive to externalizing cost. The ISP system was my community connects to your network. There are 60 or 70,000 right now. There are 70,000 different autonomous systems that comprise the Internet. When you are commercial, your goal is to make money. So you either keep your costs low or you shift those costs on someone else, you externalize your costs.
I think the Bitcoin ecosystem is very clever in identifying where costs are being externalized. That’s really good in this stage of development.
Let’s take a trip down the memory bus, and this is to highlight that these big debates are perhaps nothing new. Get used to them. These won’t be the last. If you look at Rick Adams, who has a long history, he also funded USENET, which was eventually acquired. In the old days of text, there was a peer-to-peer network called USENET news. It had a technical limitation. The USENET newsgroups could only have 14 character naming limitations. That was the constraint. Some people wanted to have newsgroups with more characters. There was a big revolt. They said usually these original 7 groups, they were just chat boards, these people who were interested in a certain subject would gather together and talk about those 7 big categories. They were all based on hierarchies.
And then there was a revolution, there was an “alt” hierarchy, pretty much anything went. That’s when I got introduced to the internet. Looking at these USENET newsgroups, you had to go stitch things together and it was very weird, you get really exposed to humanity at its rawest. It was absolutely wonderful. It was absolutely diverse. You could find anyone and everyone interested in one particular esoteric subject. At the time, I was into…. and that’s the internet I falled in love with thing, it was borderless and nobody knew if you were a dog. It was all text, no graphics.
Around that point of time, there was a book, someone wrote a book which was a guide to this space, by Ed Kroi called Hitchhikers Guide to the Internet (RFC 1118). Andreas' book is sort of like the first guide to this space. And then there was the usenet wars. And then there was another one, for the domain name system. This came from the US government funded NSF network. The meeting today will hopefully decide that it’s time to end US government involvement.
The backbone network, there were about 4000 nodes in the network and that’s all they wanted. In 1992, when the government said this is government-paid infrastructure, there were commercial players on the line, a lot of people dropped out of school and joined companies instead. Commercial was about making money, and the academic thinking was entirely different and it was a culture clash.
Great coders like Marc Andreessen originally wrote Mosaic and Netscape and the rest was history. The domain name system at the time was something about translation from text strings to IP addresses… again that had only 7 top-level nodes, was that a technical limitation, or was that a historical accident? We have spent over 20 years trying to answer that question through these 55 meetings.
At the time, registering a domain name was just $50. People started to complain and they said it should be market priced. What’s the fee market? What’s the market price of a domain name? Nobody knew. So we took this “wait and see” attitude, and we have seen this price drop to $5 or less, and now we have ICANN. I was involved when I was appointed to…..
So from that perspective, if we look at how the Internet has not been too graceful or strategic as the Bitcoin community, there are three examples. BGP is one example, how networks exchange routing information with one another. And yes you can attack it and redirect someone else’s traffic, but when you are an ISP, your basic cost is that you are renting these communication lines. So if the traffic you receive off of the network is not related to you, you get rid of it as soon as possible, it’s hot potato, you send it to someone else, you don’t want to incur that cost, so chunk it out a window as fast as possible.
Another example is email spam, sort of perhaps it is a design flaw in the protocol. That’s the way the protocol behaves, perhaps exploit it. The very existence of email spam caused many people to run mail servers. How many of you run mail servers? Huh weird all the Bitcoin Core developers in the audience raised their hands…. and nobody else. Well anyway.
Spammers can send millions of emails, and the rest of us have to bear that cost, or we have centralization. This is an unintended consequence of a design process in a protocol. It didn’t forbid such behavior. So the few spammers exploited that.
Are there equivalents for example with spam on Bitcoin able to inflate the UTXO set? Sure. The transition that was supposed to happen between IPv4 and IPv6…. Right? Which we just heard from IBM today. We are facing not an Internet of things, but an Internet of threats.
Who knows what kind of software is in all these sensors? One of the reasons I am here today instead of at ICANN, is because I think that Bitcoin is building the foundation of trust. I don’t actually know what Bitcoin is. I think I know what it is. But it’s going to evolve. In the days of text, back in 1993, if someone said you are going to be doing real livestreaming of video, I would have said what on earth are you smoking because I want so.
There’s a DNS root, which gets attacked every now and then. There’s an incident, like the Luke-Jr fork, the community responded within an hour, because they all knew each other, they agreed to downgrade. There’s an Internet equivalent, which is when the DNS servers fell over. And then we realized we needed a backup system, or rather that we had to keep the initial servers working. So that community held everything together in times of crisis.
Events like Scaling Bitcoin helps build the community equity.  That’s great. The whole point being here is that externalizing costs of a shared system, shared systems such as DNS. If the protocol needs to evolve and your software if oyu are running wallet software, sorry but you are going to have to write some code. It’s cheaper for me as a business to not absorb any costs of changing any code, if I can just change a parameter that’s great. But writing wallet software for a fee market, sure that’s a little complicated, then I need to get that working. It’s extra complexity. As a business you don’t want to do that, but then what’s the cost to the ecosystem if that player externalizes their cost to us?
I think this group, this brain trust, is quite amazing on answering that question so far. So Internet governance is the wrong model. Bitcoin governance, well just stop them right there, it’s not about governance, it’s about ecosystem health. I think to have a productive discussion about hwat your vision is of what that ecosystem looks like when it’s healthy. Furthermore, I think in recent discussions, by example of the Internet, you end up healithier afterwards. Bitcoin Core has a very clear website now, that’s evolved. Stimulus and response.
So it’s not really about governance, it’s about health. And taking from theory and putting things into practice. Some of the research is just now happening, and we all want the best tech for Bitcoin.
What is the role of universities? We had NSFnet, we had commercialization over 20 years. I was at FC 97, which was probably the first one. So having interest in Bitcoin, universities really act as a neutral platform. As you heard from Arvind, academia scales better. Universities over a long time, serve as trust actors for society. As we move from analog to digital, I think universities can serve as an early warning device for societies.
Universities should run Bitcoin nodes on the network. They should operate fully-validating nodes on the Bitcoin network. The MIT bitcoin club should be running at least one fully-validating node. Could they act as seed nodes for the rest of the network? Can you add telemetry on this, to do research on Bitcoin?
It’s also empowering students, like the MIT Bitcoin project, it’s quite helpful, like working on documentation or reading documentation and thinking about the ethics of the ecosystem. If you found a fundamental flaw in Bitcoin, as a researcher you could make money from that, right? What would you do? What is the ethical thing to do? If you publish yourself as a researcher, would you put yourself at personal risk because it could be market moving? Why? Because currencies are a very clear representation of societal trust and value.
So right now in terms of current participants in the network, this is it, one in the BSafe.Network that I would like to announce, is the first fully backwards-compatible network. There is MIT, Boston, UC Irvine, University of Maryland, and in Erupe t’s TU Darumshladt, University of Cambridge UK, New Castle University UK, …. slide went away. I want to stimulate discussion in blockchain research.
Do we need an NSFnet for Bitcoin? I say yes. We need to make this area a safe space for legitimate serious research. We want the best minds. This is an attempt to do that. There’s a slight tweak in here, which is that it should not be universities only, but also enthusiasts or outsiders who should not be excluded from collaborating with the people who would be otherwise operating on the “NSFnet” research project.
So with that, I will close and say that everything is going to be OK. ((applause))
See you tomorrow morning.


Utils
Generic utils
Static Method Summary
| Static Public Methods | ||
| public static |
createBuffer(gl: *, data: *, numElements: *, bufferType: *, components: *, srcStart: *, attribType: *, js_type: *): * Create a new GPU buffer, keep in mind that some extra attributes are being set on the returned GLBuffer object |
|
| public static |
createEmptyBuffer(gl: *, numElements: *, bufferType: *, components: *, attribType: *, js_type: *): * Create a new GPU empty buffer, keep in mind that some extra attributes are being set on the returned GLBuffer object. |
|
| public static |
createIndexBuffer(gl: *, data: *, n: *): * |
|
| public static |
emptyAabb(): * |
|
| public static |
glTypeToTypedArray(glType: *): * |
|
| public static |
hash(input: *): * |
|
| public static |
toArray(matrix: *): * Converts the given 4x4 mat4 to an array |
|
| public static |
typedArrayToGlType(typedArrayType: *): * |
|
| public static |
unionAabb(a: *, b: *): * |
|
| public static |
updateBuffer(gl: *, targetGlBuffer: *, data: *, pos: *, numElements: *) Update a GPU buffer |
Static Public Methods
public static createBuffer(gl: *, data: *, numElements: *, bufferType: *, components: *, srcStart: *, attribType: *, js_type: *): * source
Create a new GPU buffer, keep in mind that some extra attributes are being set on the returned GLBuffer object
Params:
| Name | Type | Attribute | Description |
| gl | * | ||
| data | * | ||
| numElements | * | ||
| bufferType | * | ||
| components | * | ||
| srcStart | * | ||
| attribType | * | ||
| js_type | * |
Return:
| * |
public static createEmptyBuffer(gl: *, numElements: *, bufferType: *, components: *, attribType: *, js_type: *): * source
Create a new GPU empty buffer, keep in mind that some extra attributes are being set on the returned GLBuffer object. This method is usually used in order to create buffers that will be later be filled by calls to bufferSubData (via Utils.updateBuffer)
Params:
| Name | Type | Attribute | Description |
| gl | * | ||
| numElements | * | ||
| bufferType | * | ||
| components | * | ||
| attribType | * | ||
| js_type | * |
Return:
| * |
public static createIndexBuffer(gl: *, data: *, n: *): * source
Params:
| Name | Type | Attribute | Description |
| gl | * | ||
| data | * | ||
| n | * |
Return:
| * |
public static glTypeToTypedArray(glType: *): * source
Params:
| Name | Type | Attribute | Description |
| glType | * |
Return:
| * |
public static toArray(matrix: *): * source
Converts the given 4x4 mat4 to an array
Params:
| Name | Type | Attribute | Description |
| matrix | * |
Return:
| * |
public static typedArrayToGlType(typedArrayType: *): * source
Params:
| Name | Type | Attribute | Description |
| typedArrayType | * |
Return:
| * |
public static unionAabb(a: *, b: *): * source
Params:
| Name | Type | Attribute | Description |
| a | * | ||
| b | * |
Return:
| * |
public static updateBuffer(gl: *, targetGlBuffer: *, data: *, pos: *, numElements: *) source
Update a GPU buffer
Params:
| Name | Type | Attribute | Description |
| gl | * | ||
| targetGlBuffer | * | ||
| data | * | ||
| pos | * | ||
| numElements | * |


The world is digitally connected, but how can we change and adapt to this new API reality, built on openness, integration, and ecosystems?
We as an organization commit ourselves to these 7 API First Principles:
1. Scale
APIs are the central nervous system of our organization, both internally and to our customers and partners. Every cent we earn flows through our APIs.
2. Self-Service
Every service in our organization, either internal or external, is consumed through documented, versioned, and managed APIs with common identity, security and operations policies, and with automatic self-service onboarding. No exceptions.
3. Transparency
Our API Products are contracts between our internal teams, our customers and our partners, and are documented and curated in professional API Product Portals, where anyone can check any detail or change anytime.
4. Innovation
API Products are the stable core of our business, and enable flexible and dynamic client and backend innovation both internally and externally.
5. Improvement
We leverage API telemetry data to measure our success, and base our future business planning on how our API Products are actually used.
6. Change
All of our API Products have lifecycles, and API Products that no longer deliver business value are put on a path to deprecation with transparency, honesty, and a realistic migration path to better performing APIs.
7. Value
Ecosystems are more important than any single product or API, and API Products help us create ecosystems of value that benefit our customers, our partners, and ourselves (in that order).


This section of privatesky.xyz contains common APIs required by programmers using the PrivateSky platform. The APIs Table of contents are mostly node.js functions and not web services.
Swarm specific APIsInteractionsBlockchainBARs (Brick Archives)DSUs


Record
Build new lexical entries, record audio and collaborate live on an interactive digital chalkboard. Store snapshots of the collaboration process.
Analyze
Analyze, update and edit existing lexical entries.
Collaborate
Join the live chalkboard to collaborate with other project members.


--- layout: pattern summary: "Create a simple Toggle switches using the built in icon font (matching Icon glyphs must be included). When ommitting the `close` or `menu` classes you must provided your own icon." --- Toggle Text Close


Can't use =~
in [ ]
. Use [[..]]
instead.
[ "$input" =~ DOC[0-9]*\.txt ] && echo "match"
[[ "$input" =~ DOC[0-9]*\.txt ]] && echo "match"
=~
only works in [[ .. ]]
tests. It does not work with test
or [
in any shell.
If you're targeting POSIX sh
, rewrite in terms of case
or grep
instead.
None.


{{Use dmy dates|date=January 2014}} {{Infobox prepared food | name = Tapioca pudding | image = | caption = | alternate_name = | country = | region = | creator = | course = | type = Pudding | served = | main_ingredient = Tapioca, milk or cream or coconut milk | variations = | calories = | other = }} {{refimprove|date=October 2010}} Tapioca pudding (similar to sago pudding) is a sweet pudding made with tapioca and either milk or cream. Coconut milk is also used in cases in which the flavor is preferred or in areas in which it is a commonplace ingredient for cooking. It is made in many cultures with equally varying styles, and may be produced in a variety of ways.<ref name="christinesrecipes">It's one of the popular desserts or "Tong Shui" of Chinese culture. It is believed to have derived from the Mayan culture and was brought to China in the late 17th century. {{cite web |url=http://en.christinesrecipes.com/2010/01/mango-tapioca-pearls-dessert-happy.html#.UEixKPI6eio |title=Mango & Tapioca Pearls Dessert |author= |work=christinesrecipes.com |date=27 January 2010 |accessdate=6 September 2012 }}</ref> Its consistency ranges from thin (runny), to thick, to firm enough to eat with a fork.
The pudding can be made from scratch using tapioca in a variety of forms: flakes, coarse meal, sticks, and pearls. Many commercial packaged mixes are also available.
British schoolchildren have traditionally nicknamed the dish frog spawn, due to its appearance.<ref>"School Dinners: Top Of The Slops", Sky News, London, 5 August 2003. Retrieved on 6 November 2011.</ref>
{{reflist}}
{{Puddings}} {{African cuisine}}
{{dessert-stub}}


Video:
Playlist
History
Favs
Search
No videos on list
No videos on list
Show all channel favs
Search youtube
You are:
-----


EBD - Easton Bible DIctionary
Geder
GEDER
"GEDER "a walled place, (
Joshua 12:13
), perhaps the same as Gederah or Gedor (
15:58
).
"GEDER "a walled place, (Joshua 12:13), perhaps the same as Gederah or Gedor (15:58).


Table of Contents - SEEK Technical Guide
Pages
ADMINISTRATION
Administration of SEEK
Creating a Project and Institution
Configuring Email
Configuring BioPortal
Configuring DOI and PubMed search
BACKUPS
Backing Up
Backing up the database
Backing up files
Restoring
Incremental Backups
CONTACTING_US
Contacting us
CONTRIBUTING_TO_SEEK
Contributing to SEEK
CREDITS
Credits
Related Projects
External Services we use
Javascript tools
Icons and themes
EARLIER-UPGRADES
Upgrades to 0.16.x and earlier
Steps to upgrade from 0.15.x to 0.16.x
Steps to upgrade from 0.14.x to 0.15.x
Steps to upgrade from 0.13.x to 0.14.x
Steps to upgrade from 0.11.x to 0.13.x
INSTALL
Installing SEEK
Introduction
Installing packages
Development or Production?
Setting up Ruby and RubyGems with RVM
Getting SEEK
Setting up the Database
Starting the SEEK services
Starting and Stopping the Search Service
Starting and Stopping the Background Service
Starting and Stopping the SOFFICE service
Starting SEEK
Creating an Administrator
Final steps
INSTALL-PRODUCTION
Installing SEEK in a production environment
Before you install SEEK
After you have installed SEEK
Compiling Assets ==
Serving SEEK through Apache
Setting up the services
Search Service
Delayed Job Background Service
The LibreOffice Soffice service
OTHER-DISTRIBUTIONS
Installing SEEK for other Linux distributions
Ubuntu 14.04 (LTS) and Linux Mint 16
Fedora 20 / RHEL / CentOS
Packages
Installing RVM
Installing Gems
Setting up the database
Setting up for production with Passenger Phusion
Ubuntu 10.04 (LTS)
Debian
README
SYSMO-SEEK
Installation
Backups
Upgrading
Credits
SETTING-UP-VIRTUOSO
Configuring SEEK for Virtuoso
Installing Virtuoso
Configuring SEEK
UPGRADING
Upgrading SEEK
Identifying your version
General notes about versions and upgrading
Steps to upgrade from 0.19.x to 0.20.x
Steps to upgrade from 0.18.x to 0.19.x
Steps to upgrade from 0.17.x to 0.18.x
Steps to upgrade from 0.16.x to 0.17.x
Steps to upgrade between patches (e.g. between 0.16.0 to 0.16.3)
Earlier upgrade notes
UPGRADING-TO-0-18
Upgrading to SEEK 0.18
Backing up
Upgrading a Production SEEK
Stopping Services
Installating Package dependencies
Installing Ruby 1.9.3 with RVM
Fetching and Updating SEEK
Converting the database
Updating the init.d scripts
Starting up SEEK and the Services
Updating Passenger Phusion
Classes/Modules
Seek
Seek::Rdf
Seek::Rdf::RdfFileStorage
Seek::Rdf::RdfGeneration
Seek::Rdf::RdfRepository
Seek::Rdf::RdfRepositoryStorage
Seek::Rdf::VirtuosoRepository
Seek::Rdf::VirtuosoRepository::Config
Methods
::included — Seek::Rdf::RdfGeneration
::instance — Seek::Rdf::RdfRepository
#additional_triples — Seek::Rdf::RdfGeneration
#configured? — Seek::Rdf::RdfRepository
#create_rdf_generation_job — Seek::Rdf::RdfGeneration
#delete — Seek::Rdf::RdfRepository
#delete_rdf_file — Seek::Rdf::RdfFileStorage
#dependent_items — Seek::Rdf::RdfGeneration
#describe_type — Seek::Rdf::RdfGeneration
#generate_from_csv_definitions — Seek::Rdf::RdfGeneration
#generate_triples — Seek::Rdf::RdfGeneration
#get_configuration — Seek::Rdf::RdfRepository
#get_configuration — Seek::Rdf::VirtuosoRepository
#get_query_object — Seek::Rdf::VirtuosoRepository
#get_query_object — Seek::Rdf::RdfRepository
#get_repository_object — Seek::Rdf::RdfRepository
#get_repository_object — Seek::Rdf::VirtuosoRepository
#handle_rightfield_contents — Seek::Rdf::RdfGeneration
#insert — Seek::Rdf::RdfRepository
#ns_prefixes — Seek::Rdf::RdfGeneration
#private_rdf_storage_path — Seek::Rdf::RdfFileStorage
#public_rdf_storage_path — Seek::Rdf::RdfFileStorage
#query — Seek::Rdf::RdfRepository
#rdf_repository_configured? — Seek::Rdf::RdfRepositoryStorage
#rdf_resource — Seek::Rdf::RdfGeneration
#rdf_storage_filename — Seek::Rdf::RdfFileStorage
#rdf_storage_path — Seek::Rdf::RdfFileStorage
#refresh_dependents_rdf — Seek::Rdf::RdfGeneration
#refresh_rdf — Seek::Rdf::RdfGeneration
#related_items_from_sparql — Seek::Rdf::RdfRepositoryStorage
#remove_rdf — Seek::Rdf::RdfGeneration
#remove_rdf — Seek::Rdf::RdfRepository
#remove_rdf_from_repository — Seek::Rdf::RdfRepositoryStorage
#save_rdf_file — Seek::Rdf::RdfFileStorage
#select — Seek::Rdf::RdfRepository
#send_rdf — Seek::Rdf::RdfRepository
#send_rdf_to_repository — Seek::Rdf::RdfRepositoryStorage
#to_rdf — Seek::Rdf::RdfGeneration
#to_rdf_graph — Seek::Rdf::RdfGeneration
#update_rdf — Seek::Rdf::RdfRepository
#update_repository_rdf — Seek::Rdf::RdfRepositoryStorage
#uris_of_items_related_to — Seek::Rdf::RdfRepository


NSPasteboard
Reading
A set of methods that defines the interface for initializing an object from a pasteboard.


DESIGN WEEK
DAY 2
Find inspiration
30 minutes
Show and tell
30 minutes
Silent note taking
15 minutes
Ideate
15 minutes
Crazy Eights
20 minutes
One solution in three frames
25 minutes
LUNCH!
Enjoy & please be back on time!
Art museum & heat map
10 minutes
Speed critique
40 minutes
Straw poll
10 minutes
RUMBLE!!!
15 minutes
Storyboard
2.5 hours


Reading The Futility of Adding Types to a Dynamic Language (via), I realize we may already have all the mechanisms we need in Python. (Peter Lount seems to have a bunch of apropos articles there, but no syndication feed...?)
Anyway, I haven't read through them all, but this made me think:
Validations, all forms of them, are really a form of "meta data" about the program. "Meta data" are program statements (using a special syntax or using the general purpose language syntax) about the program itself. As Smalltalk has demonstrated the most powerful and general method of having meta data in a language is to have that meta data written in the general purpose syntax of the language itself. In this way meta data programming is the same as regular programming and many more programmers will be able to access this powerful dynamic capability. In Smalltalk style languages the "meta data" are first class objects. The impact of this is that much of the added meta data functionality can be written in the language itself and added as a group of "classes" (or objects) otherwise known as a Framework.
OK, well... I don't like Frameworks. But we have something else; everyone's favorite: decorators!
Everyone knows (or should know) about the type-checking decorators. These are simple, work right now, and really don't look bad at all:
@require(int, int) def gcd(a, b): ...
It's rather simplistic, but the nice part is that it's easily implemented and easily reimplemented. If it was to become Part Of Python (i.e., included in the standard library, not in the syntax) then no doubt there's be a lot of debate and work on it, with respect to interfaces, sequences, adapters, etc., as well as extensibility.
We also want inspectable metadata as well, not just imperative validation at runtime. require can be modified to set known attributes on the function (e.g., __argspec__), or maybe something more sophisticated. Things like auto-completion would still have to load modules (and execute those decorators) to infer types and signatures, but I think that's okay.
Even better, you could start with a stdlib module before you went to the builtin. I've always cringed at the thought of a "decorators" module as some have proposed (which seems to me about as meaningful as a module called "functions" or "objects"). But a module to collect type-checking techniques would be ideal. You could then provide the same tools for earlier versions of Python (pre-decorators, pre-unified-types, etc.). Various names present themselves. Perhaps it should be a submodule of pychecker? >:)# Robert Brewer
Maybe the decorators could be part of the module that implemented interfaces, since we sure should get interfaces into the standard library before we start thinking about type declarations anyway.
Using decorators for type signatures for callable arguments has an important benefit: because of the extra typing involved, and being a separate line from the 'def' statement line, the 'syntax' alone would suggest to Python 'newbies' to only use them if really needed.
I like everything about optional argument type signatures for callables, except the idea of reading the code from Java programmers beginning to use Python. They would use it on every darn thing under the sun.
As a separate line, at least it is trivial to 're-factor' the code to remove unnecessary type signatures: just delete the line.
Kudos on using "restructured text" as the markup mechanism! Great stuff!
# Manuel Garcia


First, let me begin by saying that I really enjoyed Shereef's Fireside Chat. I wasn't planning on watching the whole thing, but I stayed entranced all the way through. And! - the Q&A section was actually really informative: a good mix of questions about the curriculum, job prospects, what it means to be a developer, and Dev Bootcamp itself.
Overall, I thought the video gave a good impression of Dev Bootcamp's spirit, mentality....and 'feel,' for lack of a better word. Although it might give some people pause, I was not at all turned off by the knowledge that Dev Bootcamp is still very much a work in progress - an experiment, as Shereef said. In fact, I think better of it, knowing that it is not stuck in place, not coagulated into some dry curriculum, but changes and evolves over time. That is exactly the kind of attitude I expect from the tech industry.
That said, I was not really surprised by the video at all. Making the decision to switch careers and invest in Dev Bootcamp was a long time coming for me. I did a lot of research into the tech industry and the kinds of companies/attitudes/people that I could expect to find there. I tried a number of different online programs and courses, like CodeAcademy, Treehouse, Code School, Harvard's CS50, to see if the work was something I would enjoy.
My dad is a career software engineer in New York. My brother is a self-taught computer engineer and Bitcoin enthusiast. My best friend's long-time boyfriend works for Microsoft (actually, just quit to open a startup in San Francisco). Another friend works for ThoughtWorks - where I actually applied once upon a time (and if you don't know about their interview process, let me just say 'whew!'). I grilled all of them about their experiences and recommendations, picking their brains about the state of the industry, their work culture, the work itself, and my suitability for such a career.
I also worked as a web designer and sudo(not that sudo)-developer for three years on the side, familiarizing myself with Wordpress, Ghost, Squarespace, Webhook, etc. And then, once I decided to pursue web development seriously, I did a lot of research into the different bootcamp programs available.
Long story short - it took me two years to apply to Dev Bootcamp, and by the time I did, I had a pretty good idea about what I was getting into. Dev Bootcamp has a reputation for rigorous education and for having the type of culture that assimilates well into the creme de la creme of the tech world. That is what I expected. That is what I was looking for.
And the DIY mindset? Well, let's just say that, as someone who was homeschooled and classically educated from 7 to 18 by a born scholar (my mother, one of the most brilliant and organizationally-challenged women I've ever met), I am very familiar with being thrown in the deep end and forced to swim. I thrive under such circumstances, and amongst people with similar thinking. That is why I am drawn to the tech world - where people are not afraid to take control, get their hands dirty, and build what they want to see in the world. So...anyway, I'm really looking forward to DBC Phase 1.