Notebooks
Story: Words and sentences: given by Tamme
Words and sentences: given by Tamme
Title
Words and sentences: given by Tamme
Collection
Summary
Tamme contributes words and sentences relating to everyday life in his country. The list includes !kun terms for weapons (especially arrows and arrow-making), parts of the body, plants and animals, cooking utensils, colours, numbers, weather, relations and words gained from contact with Europeans (such as tinderboxes and whipping). The names of !nanni's four brothers and sisters are noted and there are other references to the boys' personal experiences, including a fragment of a song !nanni sings when weeding, an occasional mention of the boys' parents, how |han≠kass'o 'takes' Tamme to 'sleep', how Tamme's father is dead and so on. |han≠kass'o has provided |xam equivalents for some of the !kun vocabulary and some of the notes on the verso pages are made by !nanni.
Comments
1) Loose inserts on the insideof the front cover of Book XI & XII-2 include: a note about a man who says that !nanni's parents are living whereas Tamme's were killed by the Ovambo, and that Erickson at Ohlssons Wiederberg brought 'them' out; another note features their names, 2) Date on p.9051: 2 September, 3) p.9137v: see The Moon, the Sun and the stars, 4) This story is found in Book XI & XII-2
Contributors
Date
2 – 29 September 1879
Categories
Words and sentences, History (personal), Custom and daily life, Plants and animals, Artefact and dress, Poetry
Keywords
vocabulary (!kun) , vocabulary (!kun-|xam) , words and sentences (!kun) , words and sentences (given by Tamme) , words and sentences (given by |han≠kass'o) , Tamme (his personal history) , Tamme (his relations) , Tamme (his mother's hut) , Tamme (how |han≠kass'o takes him to sleep in Mowbray) , !nanni (the names of his siblings) , !nanni (his personal history) , !nanni (about his parents and siblings) , personal history (of !nanni and Tamme) , personal history (!nanni and Tamme's experiences) , personal history (about !nanni and Tamme's parents) , names (of !nanni's relations) , names (of !nanni's brothers and sisters) , names (!kun, of weapons) , names (!kun, of plants) , names (!kun, of animals) , names (!kun, of everyday things in !nanni and Tamme's country) , song (sung by !nanni) , |han≠kass'o (takes Tamme to sleep in Mowbray)
Story Pages
9051-9140 and 6 loose inserts inside the front of Book XI & XII-2


fun setUsername(username: String?, password: String?): Builder
Set the username and password used to connect to the server and channel


{% extends 'base_templates/flask_wide_base.html' %} {% block content %} {% from "base_templates/form_macros.html" import render_field, render_file_field, render_submit_field with context %}
{{ word('Please wait. System is restarting.') }}
{% endblock %}


|
HE_Mesh
6.0.1
|
Private Member Functions | |
| void | clearPrev () |
Private Attributes | |
| HE_Halfedge | _he |
| HE_PathHalfedge | _next |
| HE_PathHalfedge | _prev |
Additional Inherited Members | |
| Protected Member Functions inherited from wblut.hemesh.HE_MeshElement | |
| abstract void | clear () |
| Protected Member Functions inherited from wblut.hemesh.HE_Element | |
| final void | setInternalLabel (final int label) |
| abstract void | clear () |
| abstract void | clearPrecomputed () |
| Protected Attributes inherited from wblut.hemesh.HE_MeshElement | |
| volatile boolean | visited |
| boolean | visible |
| int | color |
| Protected Attributes inherited from wblut.hemesh.HE_Element | |
| final long | key |
| int | internalLabel |
| int | userLabel |
| Static Protected Attributes inherited from wblut.hemesh.HE_MeshElement | |
| static final WB_GeometryFactory | gf = new WB_GeometryFactory() |
| static final WB_ProgressTracker | tracker = WB_ProgressTracker.instance() |
| Static Protected Attributes inherited from wblut.hemesh.HE_Element | |
| static AtomicLong | currentKey = new AtomicLong(0) |
| wblut.hemesh.HE_PathHalfedge.HE_PathHalfedge | ( | ) |
| wblut.hemesh.HE_PathHalfedge.HE_PathHalfedge | ( | final HE_Halfedge | he | ) |
| he |
| void wblut.hemesh.HE_PathHalfedge.clear | ( | ) |
| void wblut.hemesh.HE_PathHalfedge.clearNext | ( | ) |
References wblut.hemesh.HE_PathHalfedge.clearPrev().
| void wblut.hemesh.HE_PathHalfedge.clearPrecomputed | ( | ) |
|
private |
| HE_Vertex wblut.hemesh.HE_PathHalfedge.getEndVertex | ( | ) |
References wblut.hemesh.HE_Halfedge.getEndVertex().
| HE_Halfedge wblut.hemesh.HE_PathHalfedge.getHalfedge | ( | ) |
References wblut.hemesh.HE_PathHalfedge._he.
| HE_PathHalfedge wblut.hemesh.HE_PathHalfedge.getNextInPath | ( | ) |
References wblut.hemesh.HE_PathHalfedge._next.
| HE_PathHalfedge wblut.hemesh.HE_PathHalfedge.getPrevInPath | ( | ) |
References wblut.hemesh.HE_PathHalfedge._prev.
| HE_Vertex wblut.hemesh.HE_PathHalfedge.getStartVertex | ( | ) |
References wblut.hemesh.HE_Halfedge.getVertex().
| HE_Vertex wblut.hemesh.HE_PathHalfedge.getVertex | ( | ) |
References wblut.hemesh.HE_Halfedge.getVertex().
| Long wblut.hemesh.HE_PathHalfedge.key | ( | ) |
| void wblut.hemesh.HE_PathHalfedge.setHalfedge | ( | final HE_Halfedge | he | ) |
| he |
| void wblut.hemesh.HE_PathHalfedge.setNext | ( | final HE_PathHalfedge | he | ) |
| he |
| void wblut.hemesh.HE_PathHalfedge.setPrev | ( | final HE_PathHalfedge | he | ) |
| he |
| String wblut.hemesh.HE_PathHalfedge.toString | ( | ) |
References wblut.hemesh.HE_PathHalfedge.key().
|
private |
|
private |
|
private |


This is a two-part test that will determine whether or not you have ADHD. Please note that this will not provide definitive results, it will simply help you identify aspects of your life that are associated with ADHD. The first part of this test will ask 15 questions. The second part will test your ability to focus. In the end, you will be provided with results. Good Luck!


For those of you who are serious about having more, doing more, giving more and being more, success is achievable with some understanding of what to do, some discipline around planning and execution of those plans and belief that you can achieve your desires.
The first thing to remember about success is that it is a process – nothing more, nothing less. There is really no magic to it and it’s not reserved only for a select few people. As such, success really has nothing to do with luck, coincidence or fate. It really comes down to understanding the steps in the process and then executing on those steps.
days
hours
minutes
seconds
Positive pleasure-oriented goals are much more powerful motivators than negative fear-based ones. Although each is successful separately, the right combination of both is the most powerful motivational force known to humankind the natural product of your desire to achieve something.


rotten > Library > Crime > Pirates
Pirates
Just as one man's "guerrilla" is another's "freedom fighter," so it is with "pirate" and "privateer." It all depends on whether the individual is killing and stealing against you, or on your behalf.
For all practical purposes, what is now known about the history of piracy dates back to March 1967, when Pirates of the Caribbean opened in Disneyland. Historians working for Disney gave people a true taste of what life was like back then. Pirates sang a lot. They commonly said "Arrr!" and "Avast ye, mateys!" and they hurled scathing epithets such as "Bloomin' cockroaches!" when particularly riled.
First of all, get it out of your head that pirate ships were these massive, sail-laden monstrosities, loaded over with nooks, crannies and a grand and spectacular Captain's quarters. The fact is, they were small and built for speed, because on the high seas, it's pretty damn easy to spot a ship coming your way.
- Stede Bonnet
- Sir Francis Drake
- Jean Lafitte
- Sir Henry Morgan
- Calico Jack Rackham
Timeline
| 28 Jan 1596 |
On board the Defiance, Sir Francis Drake dies of dysentery in Nombre de Dios Bay, off the coast of Panama. Drake's body is placed inside a lead coffin and shoved overboard. |
| 25 Aug 1688 |
Henry Morgan dies from disease in Jamaica. |
| 23 May 1701 |
Captain William Kidd is hanged in London. Afrer the first attempt fails when the rope snaps, Kidd is brought right back to the gallows and the process repeated. After death, the body is slathered in tar, chained up, and suspended over the Thames where it remains for years as an example to others considering a life of piracy. |
| 22 Nov 1718 |
Captain Edward "Blackbeard" Teach is killed in battle on Ocracoke Island, North Carolina. |
| 19 Nov 1720 |
Captain John "Calico Jack" Rackham is hanged in Port Royal, Jamaica for piracy. Reportedly, Rackham's lover and fellow pirate Anne Bonny told him earlier that day "she was sorry to see him there, but if he had fought like a Man, he need not have been hang'd like a Dog." |
| 10 Feb 1722 |
Captain Bartholomew "Black Bart" Roberts is shot to death during a skirmish with a British ship off the coast of Guinea. |
| 1920 |
Gabriele D'Annunzio employs piracy on trade routes on the Adriatic Sea to support the city of Fiume (present-day Rijeka in Croatia), which he has captured. He will hold the city until the end of the year. |
Pornopolis |
Rotten |
Faces of Death |
Famous Nudes
|


Exploration 1.1.1.
We'll now work on Exploration P.B. Recall that links to the applets and datasets can be found at the textbook website.
We'll now work on Exploration P.B. Recall that links to the applets and datasets can be found at the textbook website.


Collaborations
Exciting side quests
Eco-evolutionary dynamics in the mutant game
Principal collaborators: Dr. Hye Jin Park, Dr. Weini Huang, Dr. Arne Traulsen.
In evolutionary game theory, the fitness of the individual is determined by a payoff from a game with other members of the population. The mutant game starts with a population made of a single species (and hence a 1-by-1 payoff matrix). New species are allowed to emerge as a result of mutation. At each such event, the payoff matrix gets extended with new payoff elements derived from corresponding matrix elements describing the interactions of the parent species. Whenever a species goes extinct, the matrix shrink, as the corresponding elements get discarded. The mutant game creates an open-ended dynamical population, in which not only the population composition but also the rules of interaction between its members are subjected to natural selection.
Papers
Population size changes and extinction risk of populations driven by mutant interactors. Park, H.-J., Pichugin, Y., Huang, W., and Traulsen, A. Phys. Rev. E, 2019. (link)
Why is cyclic dominance so rare? Park, H.-J., Pichugin, Y., and Traulsen, A. eLife, 2020. (link)
Stochastic dynamics of ecDNA in cancer tumors
Principal collaborators: Dr. Benjamin Werner, Dr. Weini Huang.
Besides the chromosomes, cancer cells also contain extrachromosomal DNA. These ecDNA pieces are replicated at every round of cell division but unlike chromosomes, their distribution to the daughter cells is not controlled by the centromeres. As a result, the dynamics of ecDNA copy numbers distribution is stochastic.
Papers
The evolutionary dynamics of extrachromosomal DNA in human cancers. Joshua T. Lange, John C. Rose, Celine Y. Chen, Yuriy Pichugin, Liangqi Xie, Jun Tang, King L. Hung, Kathryn E. Yost, Quanming Shi, Marcella L. Erb, Utkrisht Rajkumar, Sihan Wu, Sabine Taschner-Mandl, Marie Bernkopf, Charles Swanton, Zhe Liu, Weini Huang, Howard Y. Chang, Vineet Bafna, Anton G. Henssen, Benjamin Werner & Paul S. Mischel. Nature Genetics, 2022. (link)
Stochastic dynamics of extra-chromosomal DNA. Pichugin, Y., Huang, W., and Werner, B. bioRxiv, 2019. (link)
Legless lizards and their skulls
Principal collaborator: Dr. Oleksandr Yaryhin
Lizards and snakes form a monophyletic group called squamates. Among them, a large number of species have their limbs reduced or absent. On a seemingly unrelated note, the squamates’ head features a structure called chondrocranium: a structural frame made of cartilage - it supplements the skull made of bone. The chondrocranium is also found to be reduced in several species across squamates. It turns out that reductions in limbs and chondrocranium are, for some reason, correlated.
Paper
Limb reduction in squamate reptiles correlates with the reduction of the chondrocranium: a case study on serpentiform anguids. Yaryhin, O., Klembara, J., Pichugin, Y., Kaucka, M., and Werneburg, I. Developmental Dynamics, 2021. (link)


Add new alias
Enter URL to save here
Add new alias
Modify or delete current alias
URL to modify
Alias to modify
Modify current alias
Delete current alias
Delete current user
New user's name
New user's password
Add new user
List users
LOGOUT
Data


Since 1976, Rocket Elevators started from a family business and grew to one of the largest elevator company in America.
Last updated: April 4, 2019
Please read these Terms of Use (“Terms”, “Terms of Use”) carefully before using the website (the “Service”) operated by Rocket Elevators Company (“us”, “we”, or “our”).
Your access to and use of the Service is conditioned on your acceptance of and compliance with these Terms. These Terms apply to all visitors, users and others who access or use the Service.
By accessing or using the Service you agree to be bound by these Terms. If you disagree with any part of the terms then you may not access the Service.
Intellectual Property
The Service and its original content, features and functionality are and will remain the exclusive property of Rocket Elevators Company and its licensors.
Links To Other Web Sites
Our Service may contain links to third-party web sites or services that are not owned or controlled by Rocket Elevators Company.
Rocket Elevators Company has no control over, and assumes no responsibility for, the content, privacy policies, or practices of any third party web sites or services. You further acknowledge and agree that Rocket Elevators Company shall not be responsible or liable, directly or indirectly, for any damage or loss caused or alleged to be caused by or in connection with use of or reliance on any such content, goods or services available on or through any such web sites or services.
We strongly advise you to read the terms and conditions and privacy policies of any third-party web sites or services that you visit.
Termination
We may terminate or suspend access to our Service immediately, without prior notice or liability, for any reason whatsoever, including without limitation if you breach the Terms.
All provisions of the Terms which by their nature should survive termination shall survive termination, including, without limitation, ownership provisions, warranty disclaimers, indemnity and limitations of liability.
Disclaimer
Your use of the Service is at your sole risk. The Service is provided on an “AS IS” and “AS AVAILABLE” basis. The Service is provided without warranties of any kind, whether express or implied, including, but not limited to, implied warranties of merchantability, fitness for a particular purpose, non-infringement or course of performance.
Governing Law
These Terms shall be governed and construed in accordance with the laws of United States without regard to its conflict of law provisions.
Our failure to enforce any right or provision of these Terms will not be considered a waiver of those rights. If any provision of these Terms is held to be invalid or unenforceable by a court, the remaining provisions of these Terms will remain in effect. These Terms constitute the entire agreement between us regarding our Service, and supersede and replace any prior agreements we might have between us regarding the Service.
Changes
We reserve the right, at our sole discretion, to modify or replace these Terms at any time. If a revision is material we will try to provide at least 30 days notice prior to any new terms taking effect. What constitutes a material change will be determined at our sole discretion.
By continuing to access or use our Service after those revisions become effective, you agree to be bound by the revised terms. If you do not agree to the new terms, please stop using the Service.
Contact Us
If you have any questions about these Terms, please contact us.
We truly care about our users and our product.
CONTACT US NOW


{% extends "base.html" %} {% block title %}Evan Porter{% endblock title %} {% block content %}
Evan Porter is a {{ age }}-year-old comic geek / professional web developer from Saint John, New Brunswick (or so he claims).
He graduated from UNB with a BCS in 2003, likes long walks on the beach and makes self-bios snippets sound like classified ads since he hates writing them.
These days, Evan lives in PEI and works doing computer stuff.
{% endblock content %}


Welcome to Veeznutz
I finally figured out where the files changed button was, haha
offerup.com
My fave site is
Offer Up
!
google.com
My second fave site is
Google
!
apple.com
My third fave site is
Apple
!


|
FloatingMeasure
class API for phyiscal calculations
|
CSimpleMeasure: represents a pre measure combined with a base measure like "mV".
This class offers:
More...
#include <SimpleMeasure.h>
Public Member Functions | |
| CSimpleMeasure () | |
| Default constructor: calls CSimpleMeasure::_Init() More... | |
| CSimpleMeasure (const CSimpleMeasure &other) | |
| Copy constructor: calls CSimpleMeasure::_Init() and CSimpleMeasure::SetByID. More... | |
| CSimpleMeasure (const CSimpleMeasure *other) | |
| Copy constructor: calls CSimpleMeasure::_Init() and CSimpleMeasure::SetByID. More... | |
| ~CSimpleMeasure () | |
| Destructor. More... | |
| CSimpleMeasure & | operator= (const CSimpleMeasure &other) |
| Assignment operator: calls CSimpleMeasure::_Init() and CSimpleMeasure::SetByID. More... | |
| bool const | operator== (const CSimpleMeasure &other) const |
| operator ==: compares More... | |
| bool | operator!= (const CSimpleMeasure &other) const |
| operator !=: calls inverted CSimpleMeasure::operator== More... | |
| void | SetByID (const ePreMeasure PreMeasureEnum, const eBaseMeasure BaseMeasureEnum) |
| sets the CSimpleMeasure::PreIndex and CSimpleMeasure::BaseIndex and adapts the depending members More... | |
| void | SetByShort (const string &strPreLabelShort, const string &strBaseLabelShort) |
| calls CSimpleMeasure::SetByID with the indices defined by the corresponding short labels More... | |
| void | SetByLong (const string &strPreLabelLong, const string &strBaseLabelLong) |
| calls CSimpleMeasure::SetByID with the indices defined by the corresponding long labels More... | |
| bool | Valid () |
| checks if CSimpleMeasure::PreIndex and CSimpleMeasure::BaseIndex are valid indices defined in ePreMeasure and eBaseMeasure More... | |
| const string | DebugOut () |
| prints all members as string for debugging. More... | |
| bool | Compatible (const CSimpleMeasure &other) |
| check compatiblity with other CSimpleMeasure: compatibility is given if the CSimpleMeasure::eBaseMeasure have the same SI measure. More... | |
| const double | SIFactor (void) |
| getter of CSimpleMeasure::dSIFactor More... | |
| const double | SIOffset (void) |
| getter of CSimpleMeasure::dSIOffset More... | |
| const string & | Short (void) |
| getter of CSimpleMeasure::strShort More... | |
| const string & | Long (void) |
| getter of CSimpleMeasure::strLong More... | |
| const eBaseMeasure | BaseID () const |
| getter of CSimpleMeasure::BaseIndex More... | |
| const ePreMeasure | PreID () const |
| getter of CSimpleMeasure::PreIndex More... | |
Protected Member Functions | |
| void | _Init () |
| sets CSimpleMeasure::BaseIndex to eBaseMeasure::bmUnknown and CSimpleMeasure::PreIndex to CPreMeasure::pmUnknown More... | |
Protected Attributes | |
| eBaseMeasure | BaseIndex |
| index of type eBaseMeasure: used to get elements from the vectors of BASE: More... | |
| ePreMeasure | PreIndex |
| index of type ePreMeasure: used to get elements from the vectors of PRE: More... | |
| double | dSIFactor |
| factor which must be applied this CSimpleMeasure to achieve SI measure (e.g. mV : SIFactor = 1000). This factor must be applied in combination with CSimpleMeasure::dSIOffset: SIMeasure = SIFactor * Measure + SIOffset More... | |
| double | dSIOffset |
| offset (SI measure) which must added to this CSimpleMeasure to achieve the corresponding SI measure E.g. °C: SIOffset = +273.15°K This offset must be applied in combination with CSimpleMeasure::dSIFactor: SIMeasure = SIFactor * Measure + SIOffset More... | |
| string * | strShort |
| short label of this CSimpleMeasure: combination of the pre-measure short label (see PRE::Short) and the base-measure short label (see BASE::Short) More... | |
| string * | strLong |
| long label of this CSimpleMeasure: combination of the pre-measure long label (see PRE::Long) and the base-measure long label (see BASE::Long) More... | |
Friends | |
| class | CPreMeasure |
| class | CBaseMeasure |
| class | CSingleton< CPreMeasure > |
| class | CSingleton< CBaseMeasure > |
CSimpleMeasure: represents a pre measure combined with a base measure like "mV".
This class offers:
Definition at line 39 of file SimpleMeasure.h.
| CSimpleMeasure::CSimpleMeasure | ( | ) |
Default constructor: calls CSimpleMeasure::_Init()
Definition at line 28 of file SimpleMeasure.cpp.
References _Init().
| CSimpleMeasure::CSimpleMeasure | ( | const CSimpleMeasure & | other | ) |
Copy constructor: calls CSimpleMeasure::_Init() and CSimpleMeasure::SetByID.
| other | instance to copy from |
Definition at line 33 of file SimpleMeasure.cpp.
| CSimpleMeasure::CSimpleMeasure | ( | const CSimpleMeasure * | other | ) |
Copy constructor: calls CSimpleMeasure::_Init() and CSimpleMeasure::SetByID.
| other | instance to copy from |
Definition at line 38 of file SimpleMeasure.cpp.
| CSimpleMeasure::~CSimpleMeasure | ( | ) |
Destructor.
Definition at line 43 of file SimpleMeasure.cpp.
References SecureDeleteObjectPointer(), strLong, and strShort.
|
protected |
sets CSimpleMeasure::BaseIndex to eBaseMeasure::bmUnknown and CSimpleMeasure::PreIndex to CPreMeasure::pmUnknown
Definition at line 100 of file SimpleMeasure.cpp.
References BaseIndex, bmUnknown, pmUnknown, PreIndex, strLong, and strShort.
|
inline |
getter of CSimpleMeasure::BaseIndex
Definition at line 184 of file SimpleMeasure.h.
|
inline |
check compatiblity with other CSimpleMeasure:
compatibility is given if the CSimpleMeasure::eBaseMeasure have the same SI measure.
| other | CSimpleMeasure to check for compatibility |
Definition at line 150 of file SimpleMeasure.h.
| const string CSimpleMeasure::DebugOut | ( | ) |
prints all members as string for debugging.
Definition at line 88 of file SimpleMeasure.cpp.
References BASE, BaseID(), Long(), PRE, PreID(), Short(), SIFactor(), and SIOffset().
|
inline |
getter of CSimpleMeasure::strLong
Definition at line 178 of file SimpleMeasure.h.
| bool CSimpleMeasure::operator!= | ( | const CSimpleMeasure & | other | ) | const |
operator !=:
calls inverted CSimpleMeasure::operator==
| other | CSimpleMeasure to compare |
Definition at line 64 of file SimpleMeasure.cpp.
| CSimpleMeasure & CSimpleMeasure::operator= | ( | const CSimpleMeasure & | other | ) |
Assignment operator: calls CSimpleMeasure::_Init() and CSimpleMeasure::SetByID.
| other | instance to assign from |
Definition at line 49 of file SimpleMeasure.cpp.
| bool const CSimpleMeasure::operator== | ( | const CSimpleMeasure & | other | ) | const |
operator ==:
compares
| other | CSimpleMeasure to compare |
Definition at line 57 of file SimpleMeasure.cpp.
|
inline |
getter of CSimpleMeasure::PreIndex
Definition at line 190 of file SimpleMeasure.h.
| void CSimpleMeasure::SetByID | ( | const ePreMeasure | PreMeasureEnum, |
| const eBaseMeasure | BaseMeasureEnum | ||
| ) |
sets the CSimpleMeasure::PreIndex and CSimpleMeasure::BaseIndex
and adapts the depending members
| PreMeasureEnum | index of ePreMeasure |
| BaseMeasureEnum | index of eBaseMeasure |
Definition at line 69 of file SimpleMeasure.cpp.
References BASE, BaseID(), BaseIndex, dSIFactor, dSIOffset, PRE, PreID(), PreIndex, strLong, and strShort.
| void CSimpleMeasure::SetByLong | ( | const string & | strPreLabelLong, |
| const string & | strBaseLabelLong | ||
| ) |
calls CSimpleMeasure::SetByID with the indices defined by the corresponding long labels
| strPreLabelLong | long label searched in CPreMeasure::vstrLong in PRE |
| strBaseLabelLong | long label searched in CPreMeasure::vstrLong in BASE |
Definition at line 83 of file SimpleMeasure.cpp.
| void CSimpleMeasure::SetByShort | ( | const string & | strPreLabelShort, |
| const string & | strBaseLabelShort | ||
| ) |
calls CSimpleMeasure::SetByID with the indices defined by the corresponding short labels
| strPreLabelShort | short label searched in CPreMeasure::vstrShort in PRE |
| strBaseLabelShort | short label searchedin CBaseMeasure::vstrShort in BASE |
Definition at line 79 of file SimpleMeasure.cpp.
|
inline |
getter of CSimpleMeasure::strShort
Definition at line 172 of file SimpleMeasure.h.
|
inline |
getter of CSimpleMeasure::dSIFactor
Definition at line 160 of file SimpleMeasure.h.
|
inline |
getter of CSimpleMeasure::dSIOffset
Definition at line 166 of file SimpleMeasure.h.
|
inline |
checks if CSimpleMeasure::PreIndex and CSimpleMeasure::BaseIndex are valid indices
defined in ePreMeasure and eBaseMeasure
Definition at line 135 of file SimpleMeasure.h.
|
friend |
Definition at line 46 of file SimpleMeasure.h.
|
friend |
Definition at line 45 of file SimpleMeasure.h.
|
friend |
Definition at line 48 of file SimpleMeasure.h.
|
friend |
Definition at line 47 of file SimpleMeasure.h.
|
protected |
index of type eBaseMeasure:
used to get elements from the vectors of BASE:
Definition at line 216 of file SimpleMeasure.h.
|
protected |
factor which must be applied this CSimpleMeasure to achieve SI measure (e.g. mV : SIFactor = 1000).
This factor must be applied in combination with CSimpleMeasure::dSIOffset:
SIMeasure = SIFactor * Measure + SIOffset
Definition at line 235 of file SimpleMeasure.h.
|
protected |
offset (SI measure) which must added to this CSimpleMeasure to achieve the corresponding SI measure
E.g. °C: SIOffset = +273.15°K
This offset must be applied in combination with CSimpleMeasure::dSIFactor:
SIMeasure = SIFactor * Measure + SIOffset
Definition at line 244 of file SimpleMeasure.h.
|
protected |
index of type ePreMeasure:
used to get elements from the vectors of PRE:
Definition at line 227 of file SimpleMeasure.h.
|
protected |
long label of this CSimpleMeasure:
combination of the pre-measure long label (see PRE::Long)
and the base-measure long label (see BASE::Long)
Definition at line 260 of file SimpleMeasure.h.
|
protected |
short label of this CSimpleMeasure:
combination of the pre-measure short label (see PRE::Short)
and the base-measure short label (see BASE::Short)
Definition at line 252 of file SimpleMeasure.h.


Tour
Login
Menu
Services
Brand
Web Apps
Mobile Apps
Products
Product 1
Product 2
Product 3
Product 4
Product 5
Stockists
London
New York
Milan
Paris
Tour
Login
Register
Pricing
Support
Journal
FAQ
Terms & Conditions
Careers
Students
Twitter
Git Hub
Facebook
Google Plus


Pretty please
tags:I’ve been making a thing to solve some problems I always face while building web APIs. Curl is lovely but it’s a bit too flexible.
Also, web services generally spit out one of a fairly common set of formats: (json, xml, html) and I often just want to grab a value from the response and use it in a script - maybe to make the next call in a workflow.
So I made please which makes it super simple to do things like making a web request and grabbing a particular value from the response.
For example, here’s how you’d get the page title from this site:
Or getting a value out of the json returned by jsontest.com’s IP address API:
The parse
part of please
is the most fun; it can convert between a few different formats. Something I do quite often is grabbing a json response from an API and spitting it out as yaml so I can read it easily. For example:
(alright so that’s a poor example but the difference is huge when it’s a complicated bit of json)
Also handy for turning an unreadable mess of xml into yaml (I love yaml for its readability):
As an example, of the kinds of things you can play with, I made this tool for generating graphs from json.
I’m still working on please
; there will be bugs; let me know about them.


Directing a hackathon has been one of the most rewarding experiences of my life so far. Hackathons have always held a special spot for me, because they are what piqued my interest in thegot me into the entrepreneurial elementside of Computer Science. I attended to my first hackathon, Bitcamp, as a high school senior, not at all knowing what to expect. I came away from this experience mesmerized by all the amazing things people could accomplish in just a weekend, like a pong robot!
But what drew me to Bitcamp specifically was how inviting and beginner friendly it was. I was immediately drawn to the campfire theme and even as a high school senior at a college level event, I felt welcome. The following year as a UMD freshman, I joined the Bitcamp organizing team (of ~60 members) to help inspire more students, and this past year, I was the co-executive director of Bitcamp 2018. This article is a journey through the process and a few lessons I learned about motivating teams at scale.
Leadership Styles
I was fortunate to have co-directed Bitcamp with my friend Tim, who is an amazing person. While we got along well, Tim and I had very different leadership styles. Tim was very tactical and detail-oriented: he honed in on the logistical details, working closely with the Logistics teams to hash out details such as A/V, bugs in our registration app, etc. Meanwhile, I focused more on higher level details such as setting the overall theme, communicating with higher ups from the University, arranging speakers, etc.
Tim and I also had different risk-tolerances, which balanced out well: I definitely had some crazy ideas that Tim helped ground into reality (I went to a talk over the summer with Ben Horowitz saying that the best founders are the ones that drive you crazy in the best way, and I definitely felt that between Tim and I).
Shared Vision
During my first year on the Bitcamp organizing team, I did not feel a strong sense of cohesion. Most of the team hadn't really interacted until the week of the event and there was no central vision tying us all together. A personal goal was to create a sense of family among the team: I strongly believe that you work best when you are surrounded with people you care deeply about, all rallied under a unifying cause.
As a sophomore, I was still relatively new to the team compared to many others. I initially felt a strong desire to establish a deep connection with each member on the team, but with over 60 members, I quickly realized that that wasn't feasible. What was more important was ensuring everyone on the team had robust relationships with each other, not just me. If everyone had at least 3 good friends, then each member would have the support network they need to feel welcome.
To accomplish this, I proposed Bitcamp Retreat: a weekend focused on getting to know one another and setting goals for the upcoming year. During retreat, we all gathered around the living room of our Airbnb to discuss our goals, giving everyone an opportunity to contribute. It really felt like a family meeting (and the living room environment definitely helped, with everyone sitting on a big couch). The familiar culture and goals that were set at Retreat shaped how the team executed for the rest of the year.
Cultivating Relationships
After the success of Retreat, Tim and I went all in on community oriented events: ramen nights, camping trips and even a New Years Card that we sent to our sponsors. With each event, I could feel the overall team morale improving and a greater sense of accountability as people did not want to let their friends on the team down.
Culture of Feedback and Acknowledgement
Halfway through the year, Tim and I released an anonymous feedback form regarding our performance and how the organizers felt about their experience on the team. Some key takeaways were that people did not know what was going on within other subteams, so we introduced weekly team updates during our meetings. Positive feedback is also super valuable, and fortunately, many organizers felt they were learning valuable skills and making great friends. We also began spending five minutes at the beginning of weekly meetings opening the floor for shoutouts to team members who had been a huge help over the past week.
Sustainability
I have seen so many great college organizations dissolve because the leaders did not consider what would happen after they graduate. We made it a point to encourage the directors to actively provide more responsibility to members of their sub-team and think about their successors. The idea of shifting responsibilities and thinking about successors so far in advance was foreign to me, but it made the transition process at the end of the year much smoother and efficient.
Biggest Regret
My biggest regret was getting so caught up in execution mode that I didn't devote the time to ask why. While we did make significant changes for Bitcamp 2018, I felt that I devoted so much time to keeping the ship afloat (things like ensuring we had enough money to run the event) that I had little time to think about why we did things a certain way. Ideas for reimagining the hackathon model became clear to me after the event had passed, and I really wish I had devoted time purely to reimagine Bitcamp as a new experience and not as the 5th iteration of an event. For future projects, I want to ensure that I give myself the time to break out of execution mode and start from the basics.
Looking Ahead
I haven't quite felt that same high as when I sat on the top bleachers of the Xfinity Center and saw over a thousand people exploring the possibilities of technology, as I did just two years ago as a high school senior. I remember at that moment, I couldn't help but get a bit sentimental, saying something along the lines of “we did this”. That high was likely the closest I have ever felt to the highs of running a startup. And there were definitely lows leading up to the event, but the highs made it all worthwhile.
Thank You
I would like to thank the entire Bitcamp team for teaching me so much and being amazing friends as well as teammates. Although my time at UMD is slowly wrapping up, I hope I can find a similar family to work with after graduation.
Leadership


[§188F-6] Rules. The department shall adopt rules to effectuate the purposes of this chapter in accordance with chapter 91. [L 1998, c 306, pt of §2]


--- title: Getting started! short: Intro id: 1 layout: page color: green kind: page ---
| Time | Difficulty | Step |
| 00:07 | * | Introduction |
| 00:42 | * | What you will learn |
| 01:40 | * | Help out and feedback |
| 02:01 | * | Donate |
| 02:30 | * | Share it around |
Hi! Awesome to see you are interested in recycling plastic. We made a series of videos to share all the most crucial things we learned over the last years about recycling plastic. We will teach you all the basic to get started, how to separate different plastic types, build your own machines, best ways to collect plastic, templates to download and much more. Once you’ve watched them you are ready to start a little recycle factory. Good luck!
Got questions, need more information or something is just not fully clear? Please visit our support page, or directly visit our forums. This is the best place to get in touch with the community and to get an answer to your questions.


vania module
from .fair_distributor import FairDistributor
__all__ = ['FairDistributor']
Classes
class FairDistributor
This class represents a general fair distributor. Objects of this class allow solving fair distribution problems.
class FairDistributor:
"""
This class represents a general fair distributor.
Objects of this class allow solving fair distribution problems.
"""
def __init__(self, targets=[], objects=[], weights=[]):
"""
This constructor is simply a way to simplify the flow of solving a problem.
"""
self.set_data(targets, objects, weights)
def set_data(self, targets, objects, weights):
"""
This method is a general setter for the data associated with the problem.
Data is being validated by the validator method.
"""
self._targets = targets
self._objects = objects
self._weights = weights
def validate(self):
"""
This method validates the current data.
"""
try:
self._validate()
return True
except ValueError:
return False
def _validate(self):
if len(self._weights) != len(self._targets):
raise ValueError(
"The amount of weight lines should match the amount of targets")
# All values should be positive
s = list(
dropwhile(lambda x: len(x) == len(self._objects), self._weights))
if len(s) != 0:
raise ValueError(
"The amount of weight columns should match the amount of objects")
for lines in self._weights:
for i in lines:
if i < 0:
raise ValueError(
"All weights must be positive")
def distribute(self, fairness=True, output=None):
"""
This method is responsible for actually solving the linear programming problem.
It uses the data in the instance variables.
The optional parameter **fairness** indicates if the solution should minimize individual effort. By default the solution will enforce this condition.
An error will be raised in case the data has inconsistencies.
"""
# Validate the problem variables
self._validate()
# State problem
problem = pulp.LpProblem("Fair Distribution Problem", pulp.LpMinimize)
# Prepare variables
targets_objects = {}
for (t, target) in enumerate(self._targets):
for (o, object) in enumerate(self._objects):
variable = pulp.LpVariable(
'x' + str(t) + str(o), lowBound=0, cat='Binary')
position = {'target': t, 'object': o}
targets_objects['x' + str(t) + str(o)] = (variable, position)
# Generate linear expression for self._weights (Summation #1)
weights = [(variable, self._weights[weight_position['target']][weight_position['object']])
for (variable, weight_position) in targets_objects.values()]
weight_expression = pulp.LpAffineExpression(weights)
# Generate linear expression for effort distribution (Summation #2)
weight_diff_vars = []
if fairness:
total_targets = len(self._targets)
for (t, target) in enumerate(self._targets):
weight_diff_aux_variable = pulp.LpVariable(
'weight_diff_'+str(t), lowBound=0)
weight_diff_vars.append(weight_diff_aux_variable)
negative_effort_diff_weights = []
positive_effort_diff_weights = []
negative_factor = -1 * total_targets
positive_factor = 1 * total_targets
for (o, object) in enumerate(self._objects):
id = 'x' + str(t) + str(o)
negative_effort_diff_weights.append(
(targets_objects[id][0], negative_factor * self._weights[t][o]))
positive_effort_diff_weights.append(
(targets_objects[id][0], positive_factor * self._weights[t][o]))
negative_effort_diff = pulp.LpAffineExpression(
negative_effort_diff_weights) + weight_expression
positive_effort_diff = pulp.LpAffineExpression(
positive_effort_diff_weights) - weight_expression
problem += negative_effort_diff <= weight_diff_aux_variable, 'abs negative effort diff ' + \
str(t)
problem += positive_effort_diff <= weight_diff_aux_variable, 'abs positive effort diff ' + \
str(t)
# Constraints - Each task must be done
for (o, object) in enumerate(self._objects):
constraints = []
for (t, target) in enumerate(self._targets):
constraints.append(targets_objects['x' + str(t) + str(o)][0])
problem += pulp.lpSum(constraints) == 1, 'Task ' + \
str(o) + ' must be done'
# Set objective function
problem += weight_expression + \
pulp.lpSum(weight_diff_vars), "obj"
if output:
problem.writeLP(output)
problem.solve()
# Build output
data = {}
for v in filter(lambda x: x.varValue > 0, problem.variables()):
if v.name not in targets_objects:
continue
position = targets_objects[v.name][1]
target = self._targets[position['target']]
object = self._objects[position['object']]
if target not in data:
data[target] = []
data[target].append(object)
return data
Ancestors (in MRO)
- FairDistributor
- builtins.object
Static methods
def __init__(
self, targets=[], objects=[], weights=[])
This constructor is simply a way to simplify the flow of solving a problem.
def __init__(self, targets=[], objects=[], weights=[]):
"""
This constructor is simply a way to simplify the flow of solving a problem.
"""
self.set_data(targets, objects, weights)
def distribute(
self, fairness=True, output=None)
This method is responsible for actually solving the linear programming problem. It uses the data in the instance variables. The optional parameter fairness indicates if the solution should minimize individual effort. By default the solution will enforce this condition. An error will be raised in case the data has inconsistencies.
def distribute(self, fairness=True, output=None):
"""
This method is responsible for actually solving the linear programming problem.
It uses the data in the instance variables.
The optional parameter **fairness** indicates if the solution should minimize individual effort. By default the solution will enforce this condition.
An error will be raised in case the data has inconsistencies.
"""
# Validate the problem variables
self._validate()
# State problem
problem = pulp.LpProblem("Fair Distribution Problem", pulp.LpMinimize)
# Prepare variables
targets_objects = {}
for (t, target) in enumerate(self._targets):
for (o, object) in enumerate(self._objects):
variable = pulp.LpVariable(
'x' + str(t) + str(o), lowBound=0, cat='Binary')
position = {'target': t, 'object': o}
targets_objects['x' + str(t) + str(o)] = (variable, position)
# Generate linear expression for self._weights (Summation #1)
weights = [(variable, self._weights[weight_position['target']][weight_position['object']])
for (variable, weight_position) in targets_objects.values()]
weight_expression = pulp.LpAffineExpression(weights)
# Generate linear expression for effort distribution (Summation #2)
weight_diff_vars = []
if fairness:
total_targets = len(self._targets)
for (t, target) in enumerate(self._targets):
weight_diff_aux_variable = pulp.LpVariable(
'weight_diff_'+str(t), lowBound=0)
weight_diff_vars.append(weight_diff_aux_variable)
negative_effort_diff_weights = []
positive_effort_diff_weights = []
negative_factor = -1 * total_targets
positive_factor = 1 * total_targets
for (o, object) in enumerate(self._objects):
id = 'x' + str(t) + str(o)
negative_effort_diff_weights.append(
(targets_objects[id][0], negative_factor * self._weights[t][o]))
positive_effort_diff_weights.append(
(targets_objects[id][0], positive_factor * self._weights[t][o]))
negative_effort_diff = pulp.LpAffineExpression(
negative_effort_diff_weights) + weight_expression
positive_effort_diff = pulp.LpAffineExpression(
positive_effort_diff_weights) - weight_expression
problem += negative_effort_diff <= weight_diff_aux_variable, 'abs negative effort diff ' + \
str(t)
problem += positive_effort_diff <= weight_diff_aux_variable, 'abs positive effort diff ' + \
str(t)
# Constraints - Each task must be done
for (o, object) in enumerate(self._objects):
constraints = []
for (t, target) in enumerate(self._targets):
constraints.append(targets_objects['x' + str(t) + str(o)][0])
problem += pulp.lpSum(constraints) == 1, 'Task ' + \
str(o) + ' must be done'
# Set objective function
problem += weight_expression + \
pulp.lpSum(weight_diff_vars), "obj"
if output:
problem.writeLP(output)
problem.solve()
# Build output
data = {}
for v in filter(lambda x: x.varValue > 0, problem.variables()):
if v.name not in targets_objects:
continue
position = targets_objects[v.name][1]
target = self._targets[position['target']]
object = self._objects[position['object']]
if target not in data:
data[target] = []
data[target].append(object)
return data
def set_data(
self, targets, objects, weights)
This method is a general setter for the data associated with the problem. Data is being validated by the validator method.
def set_data(self, targets, objects, weights):
"""
This method is a general setter for the data associated with the problem.
Data is being validated by the validator method.
"""
self._targets = targets
self._objects = objects
self._weights = weights
def validate(
self)
This method validates the current data.
def validate(self):
"""
This method validates the current data.
"""
try:
self._validate()
return True
except ValueError:
return False


iLoveLAMP was last updated .
Allowing the use of cookies enables iLL to remember your server choice, among other things, between page refreshes. Without cookies, iLL will revert to the default server, if one is chosen when the page is refreshed. If there is no default server, the app will open a dialog and let you choose.
| File Type | Open With |
|---|---|
| Hidden Files |
|
| Images (PNG, JPEG, GIF) |
|
| HTML (HTML, HTM, XHTML) |
|
| PHP |
|
| Javascript |
|
| CSS |
|
| Plaintext |
|
|
|
|
| Anything else |
|


This package contains a Chain Of Responsibility (CoR) pattern implementation
which offers a great deal of flexibility. Note that this implementation
IS NOT web-specific, that is, you can use it outside a webapp without any
problem.
As defined by the Gang Of Four (GoF - Gamma, Helm, Johnson, and Vlissides),
the CoR pattern can be described like so:
"Avoid coupling the sender of a request to its receiver by giving more than
one object a chance to handle the request. Chain the receiving objects and
pass the request along the chain until an object handles it."
Yeah, whatever :) In short, we're talking about defining a series of atomic
operations that are "chained" together and executed in sequence, giving
each step the opportunity to do something or not.
As an example, take the simple mathematical equation:
1 + 2 + 3 + 4 = 10
We can break this into a series of individual steps. In this description,
the letter A represents the accumulation of the result after each step:
Step 1. A = 1 + 2
Step 2. A = A + 3
Step 3. A = A + 4
Now, imagine you defined each of those steps as a unique Java class. Further
imagine that you declared that those three steps, done in sequence, is called
a Chain, and this Chain represents the larger operation of the equation.
In short, that's the CoR pattern.
Now, on to the details of this implenentation...
Simply put, you will create an XML file something like the following:
<chainConfig>
<catalog id="myCatalog">
<chain id="myChain">
<command id="step1"
className="my.app.Step1" />
<command id="step2"
className="my.app.Step2" />
<command id="step3"
className="my.app.Step3" />
</chain>
</catalog>
</chainConfig>
The config file must be in the classpath accessible to the ChainManager
class! In a webapp, the easiest way to do this is to place the file in
WEB-INF/classes. By default, the name of the file MUST be chain_config.xml.
You can override this in two ways: (a) pass the filename (which is
technically a path) to the ChainManager's constructor, or (b) set an
environment variable named JWP_CHAIN_CONFIG_FILE_NAME to the value you
desire. If you have any question about how to set this value, look up the
getResourceAsStream() method of the Class class in the Java SDK. The rules
enumerated there are what you must follow.
The config file defines three elements: Catalogs, Chains and Commands.
Catalogs are nothing but collections of Chains who's sole purpose is to
allow you to organize things better when you are defining multiple Chains,
and a Chain is of course an ordered series of Commands to be executed.
The thing you as a developer will be primarily concerned with are the
Commands. These define individual steps in a Chain, and this is what you will
implement in code. Let's take a look at the three Commands above, which
correspond to the three steps in that equation from before:
package my.app;
import javawebparts.misc.chain.ChainContext;
import javawebparts.misc.chain.Command;
import javawebparts.misc.chain.Result;
public class Step1 implements Command {
public Result init(ChainContext chainContext) {
return new Result(Result.SUCCESS);
}
public Result execute(ChainContext chainContext) {
int a = 1 + 2;
chainContext.setAttribute("a", new Integer(a));
return new Result(Result.SUCCESS);
}
public Result cleanup(ChainContext chainContext) {
return new Result(Result.SUCCESS);
}
}
Every Command you write will implement the Command interface, which defines
three methods: init(), execute() and cleanup().
You can think of init() exactly like you do a constructor in that it will
always be called before anything else. You can do whatever you like here...
grab a database connection, call some remote system, initialize some fields,
etc. Note that Commands do not have to be thread-safe because a new
instance of it is instantiated every time it is needed. Of course, this
means you cannot store things in the instance between Command executions.
You can however store them between the execution of these three
methods, you don't have to resort to static fields unless you want to.
The cleanup() method can be thought of like finalize() except that it is more
deterministic in that it will always be called as the last thing done,
regardless of what happens elsewhere in the Command (well, except for
exceptions, which could cause it to not execute).
The execute() method is where the actual work of your Command should go.
Each of the three methods receives a reference to a ChainContext object.
The ChainContext is how information is communicated between Commands of the
Chain. Conceptually it is just like an HttpRequest object. In fact, you
work with it in the same way via setAttribute() and getAttribute() methods,
which takes a key and an Object value to store. You can put whatever you
like in the context, at any time (i.e., from any of the three methods, and/or
before and after the Chain executes). You can also find some standard pieces
of information in the context, such as the last Result that was produced by a
Command (or a Chain, if a Command is a subchain... more on this later) as well
as the ID of the Catalog and Chain the Command belongs to.
Each of the three methods returns an instance of the Result class. This
defines what happened within the Command. You cnn construct a Result object
in one of three ways:
Result r = new Result(Result.xxxx);
In this case, you are just returning one of the allowed result codes as
defined by the static fields in the Result class, represented by the xxxx
above. Those values are:
- SUCCESS - Return this when everything went according to plan and
the chain should continue normally.
- FAIL - Return this when an unexpected failure occurs. In
general, your Commands should never throw exceptions! You should
handle any exception that could happen and return this code if it is
something the Command cannot handle and the Chain should be stopped.
- ABORT - This is returned when the chain should be stopped. This
is not the same as FAIL because FAIL indicates conditions that
should really never happen, where ABORT are conditions that you
expect could reasonably happen.
- RESTART_CHAIN - As you would think, the Chain is restarted from
the beginning. Note however that the ChainContext is not reset!
Also note that this is can lead to an infinite loop, so you have to
take care to ensure that can never happen!!
- REDO_COMMAND - Re-executes the Command. Note that this too is a
prime candidate for causing an infinite loop, so be careful!!
- JUMP_TO_COMMAND - This acts like a GOTO statement in BASIC.
Result r = new Result(Result.xxxx, "yyyy");
The result code is the first parameter and is still as described above. The
"yyyy" parasmeter is any arbitrary extra info you would like to return. This
can be helpful if the next Command should do something in a variable way
based on what the result of the previous Command was. Note that if your
intention is to return some extra info to the caller executing the Chain,
the extra info can only be returned by the last Command in the Chain because
subsequent Commands would effectively overwrite any previous extra info.
Alternatively, each Command in your Chain would have to replicate the
extra info along the Chain so it is always present for the last Command to
return.
Result r = new Result(Result.xxxx, "yyyy", "zzzz");
The result code and extra info parameters are still as described above. The
"zzzz" parameter is the ID of a Command. This is only applicable when the
return code is JUMP_TO_COMMAND.
Let's look at the next Command in the chain:
package my.app;
import javawebparts.misc.chain.ChainContext;
import javawebparts.misc.chain.Command;
import javawebparts.misc.chain.Result;
public class Step2 implements Command {
public Result init(ChainContext chainContext) {
return new Result(Result.SUCCESS);
}
public Result execute(ChainContext chainContext) {
Integer a = (Integer)chainContext.getAttribute("a");
a = new Integer(a.intValue() + 3);
chainContext.setAttribute("a", a);
return new Result(Result.SUCCESS);
}
public Result cleanup(ChainContext chainContext) {
return new Result(Result.SUCCESS);
}
}
Still very straight-forward. No sense wasting the space to show the third
Command, it's the same except we're adding 4 to A in it.
So, at this point we've coded up the Commands, defined them to form a Chain
in the config file, and added the Chain to a Catalog. All that's left is
using it. Very simple:
ChainManager cm = new ChainManager();
ChainContext ct = cm.createContext();
cm.executeChain("myCatalog/myChain, ct);
Result cr = ct.getResult();
if (cr.getCode() == Result.SUCCESS) {
System.out.println(ct.getAttribute("a"));
} else {
System.out.println("Chain FAIL or ABORT");
}
All interaction with Chains are done through the ChainManager. So, we need
to instantiate one. The first time a ChainManager is instantiated, the config
file will be read and static objects created to represent it. Subsequent
ChainMaager instantiations will not incur this overhead. Once we
have a ChainManager, we ask it for a new ChainContext object. You can at
this point add whatever initial data to it tha your Chain needs. Then, we
simply ask it to execute a given Chain in a given Catalog, handing it the
ChainContext. Once it completes, we interrogate the ChainContext to see
what the result of the execution was, and act accordingly.
And that, in a nutshell, is the Chain implementation in Java Web Parts!
Ok, so that's the basic. How about the more advanced stuff?
- Commands can themselves be Chains (AKA, Subchains)
Take the standard Command definition in the config file:
<command id="step2" className="my.app.Step2" />
Let's say that instead of doing A=A+3 as the second step, we instead
wanted to do (A=A+6)*2. We could of course just break that into two
Commands and add them to the Chain, but another approach is to create
those Commands and make them their own Chain, then make the second step
of the original Chain be that new Chain. The Commands would be exactly
as before, no change whatsoever. The config file is different though,
and here's what it would now look like:
<chainConfig>

<catalog id="myCatalog">
<chain id="myChain">
<command id="step1"
className="my.app.Step1" />
<command id="step2"
chain="myChain2" />
<command id="step3"
className="my.app.Step3" />
</chain>
<chain id="myChain2">
<command id="step2a"
className="my.app.Step2a" />
<command id="step2b"
className="my.app.Step2b" />
</chain>
</catalog>
</chainConfig>
Let's assume that Comamnd Step2a does A=A+6 and Step2b does A=A*2. Now,
as defined, myChain2 will be executed when myChain hits step 2. When
myChain2 completes, myChain will continue at step 3. That's all there is
to it! Of course, you can execute myChain2 on its own if you need to,
it's just another Chain in the Catalog.
- Chains can extend other Chains
You can do this in the config file:
<chain id="myChain2" extends="myCatalog/myChain">
You will always specify extends in the form xxxx/yyyy where xxxx is the
Catalog ID and yyyy is the Chain ID. When you do this, the contents of
the base Chain is copied into the extended Chain, before any new
Commands are added. So, if you had this config file:
<chainConfig>

<catalog id="myCatalog">
<chain id="myChain">
<command id="step1"
className="my.app.Step1" />
<command id="step2"
className="my.app.Step2" />
<command id="step3"
className="my.app.Step3" />
</chain>
<chain id="myChain2"
extends="myCatalog/myChain">
<command
id="step4" className="my.app.Step4" />
<command
id="step5" className="my.app.Step5" />
</chain>
</catalog>
</chainConfig>
...Then the sequence of Commands in myChain2 would be step1,step2,step3,
step4,step5. Note that these are COPIES! In other words, it is as if you
defined the three Commands from myChain directly in myChain2. At runtime,
there is essentially two instance of step1 floating around, one tied to
each of the two Chains.
- Commands can be replaced when extending a Chain
If we replace the above line:
<command id="step4" className="my.app.Step4" />
...with...
<command id="step4" className="my.app.Step4" replaceid="step2"/>
...then the final sequence of Commands in myChain2 would be step1,step4,
step3,step5. The step4 Command replaces the step2 Command. But again,
remember these are COPIES, so the sequence of Commands in myChain is
STILL step1,step2,step3. This provides something very much like the
ability to override methods in a class you extend within the Chain
paradigm.
- Catalogs can extend other Catalogs
There is an extends attribute on the Catalog element, just like on the Chain
element (except that it is in the form "yyyy" where yyyy is the ID of the
Catalog you wish to extend), that serves the exact same purpose. All the
Chains in the base Catalog are copied to the extended Catalog. Any Chain
then defined in the extended catalog with an ID that matches a Chain copied
over will override the copied Chain. Note that for a Catalog to exend
another, the base Catalog must have been defined prior to the extends
attribute appearing in the config file! In other words, if you have
three Catalogs defined named Catalog1,Catalog2,Catalog3 and they are defined
in that order, than Catalog2 or Catalog3 could extend Catalog1, but Catalog1
could not extend anything, and things will blow up if you try it!
That about covers it. I hope you find the CoR implementation useful! There
is some further advanced functionality I intend to add, but for now, this
is it. Enjoy!
This package depends on the following extra packages to compile and run: None.


Howto Upgrade to Zipkin2
Background
Java Chassis uses zipkin as the default tracing implementation.
Zipkin introduced v2 http api in version 1.31 which simplifies data types. There are also various other improvements and new features added to the zipkin libraries, so it seems a good time for us to follow the upstream and upgrade to zipkin2.
Version matrix
| module | current | target | supports v2 since |
|---|---|---|---|
| zipkin | 1.24.0 | 2.4.2 | 2.0.0 |
| brave | 4.13.1 | 4.13.1 | 4.7.1 |
| reporter | 0.10.0 | 2.2.2 | 2.0.0 |
What’s changed
Zipkin did a very good job on maintaining backward compatibility. All the changes that breaks compatiblity are packaged into a new group(io.zipkin.java
-> io.zipkin.zipkin2
, io.zipkin.reporter
-> io.zipkin.reporter2
). And v1/v2 libraries can coexist.
The zipkin2 library can use both v1 and v2 api to communicate with server.
The zipkin2.Span
class changed a bit from the old zipkin.Span
class. The public fields are refactored to methods. And the BinaryAnnotation
class is removed along with zipkin.Span.binaryAnnotaions
field. It’s functionality is replaced by zipkin2.Span.tags()
method which return a Map<String,String>
.
Upgrade to zipkin2 for Java Chassis
Modify the maven dependencies to use the target version of related libraries.
Change the group io.zipkin.java
and io.zipkin.reporter
to io.zipkin.zipkin2
and io.zipkin.reporter2
respectively.
java-chassis-dependencies/pom.xml
@@ -50,8 +50,8 @@
<cxf.version>3.1.6</cxf.version>
<logback.version>1.1.7</logback.version>
<brave.version>4.13.1</brave.version>
- <zipkin.version>1.24.0</zipkin.version>
- <zipkin-reporter.version>0.10.0</zipkin-reporter.version>
+ <zipkin.version>2.4.2</zipkin.version>
+ <zipkin-reporter.version>2.2.2</zipkin-reporter.version>
</properties>
<dependencyManagement>
@@ -646,7 +646,7 @@
<!-- zipkin dependencies -->
<dependency>
- <groupId>io.zipkin.java</groupId>
+ <groupId>io.zipkin.zipkin2</groupId>
<artifactId>zipkin</artifactId>
<version>${zipkin.version}</version>
</dependency>
@@ -661,7 +661,7 @@
<version>${brave.version}</version>
</dependency>
<dependency>
- <groupId>io.zipkin.reporter</groupId>
+ <groupId>io.zipkin.reporter2</groupId>
<artifactId>zipkin-sender-okhttp3</artifactId>
<version>${zipkin-reporter.version}</version>
</dependency>
handlers/handler-tracing-zipkin/pom.xml
@@ -50,7 +50,7 @@
<artifactId>brave</artifactId>
</dependency>
<dependency>
- <groupId>io.zipkin.reporter</groupId>
+ <groupId>io.zipkin.reporter2</groupId>
<artifactId>zipkin-sender-okhttp3</artifactId>
</dependency>
<dependency>
Make brave to use zipkin2 instead of zipkin
Change the zipkin.xxx import to zipkin2.xxx on imports, and most importantly, use spanReporter()
instead of reporter()
for generating reporter for brave, change the api path to /api/v2/xxx when creating sender.
handlers/handler-tracing-zipkin/src/main/java/org/apache/servicecomb/tracing/zipkin/TracingConfiguration.java
@@ -31,11 +31,11 @@
import brave.http.HttpTracing;
import brave.propagation.CurrentTraceContext;
import org.apache.servicecomb.config.DynamicProperties;
-import zipkin.Span;
-import zipkin.reporter.AsyncReporter;
-import zipkin.reporter.Reporter;
-import zipkin.reporter.Sender;
-import zipkin.reporter.okhttp3.OkHttpSender;
+import zipkin2.Span;
+import zipkin2.reporter.AsyncReporter;
+import zipkin2.reporter.Reporter;
+import zipkin2.reporter.Sender;
+import zipkin2.reporter.okhttp3.OkHttpSender;
@Configuration
class TracingConfiguration {
@@ -56,14 +56,15 @@ Sender sender(DynamicProperties dynamicProperties) {
return AsyncReporter.builder(sender).build();
}
+
@Bean
Tracing tracing(Reporter<Span> reporter, DynamicProperties dynamicProperties,
CurrentTraceContext currentTraceContext) {
return Tracing.newBuilder()
.localServiceName(dynamicProperties.getStringProperty(CONFIG_QUALIFIED_MICROSERVICE_NAME_KEY,
DEFAULT_MICROSERVICE_NAME))
.currentTraceContext(currentTraceContext) // puts trace IDs into logs
- .reporter(reporter)
+ .spanReporter(reporter)
.build();
}
Note:
In the brave release notes, it’s stated that we need to use create()
instead of builder()
/** Configuration for how to buffer spans into messages for Zipkin */
- @Bean Reporter<Span> reporter() {
- return AsyncReporter.builder(sender()).build();
+ @Bean Reporter<Span> spanReporter() {
+ return AsyncReporter.create(sender()).build();
}
But this will not work. In zipkin2.Reporter
, the create(sender)
is actually equivalent to builder(sender).build()
public static AsyncReporter<Span> create(Sender sender) {
return (new AsyncReporter.Builder(sender)).build();
}
public static AsyncReporter.Builder builder(Sender sender) {
return new AsyncReporter.Builder(sender);
}
Make changes according to the changes of zipkin.Span and zipkin2.Span.
We do not use zipkin.Span in our production code, but we do use it in our tests. Those changes are quite straight forward, we just change the accessing of fields to calling methods as described in the What’s Changed section.
tracing/tracing-zipkin/src/test/java/org/apache/servicecomb/tracing/zipkin/ZipkinSpanAspectTest.java
@@ -45,7 +45,7 @@
import org.apache.servicecomb.tracing.zipkin.app.ZipkinSpanTestApplication;
import org.apache.servicecomb.tracing.zipkin.app.ZipkinSpanTestApplication.CustomSpanTask;
import org.apache.servicecomb.tracing.zipkin.app.ZipkinSpanTestApplication.SomeSlowTask;
-import zipkin.Span;
+import zipkin2.Span;
@RunWith(SpringRunner.class)
@SpringBootTest(classes = {ZipkinSpanTestApplication.class, TracingConfig.class})
@@ -74,8 +74,8 @@ public void reportedSpanContainsAnnotatedMethodInfo() throws Exception {
await().atMost(2, SECONDS).until(() -> !spans.isEmpty());
- zipkin.Span span = spans.poll();
- assertThat(span.name, is("crawl"));
+ zipkin2.Span span = spans.poll();
+ assertThat(span.name(), is("crawl"));
assertThat(tracedValues(span), contains(SomeSlowTask.class.getMethod("crawl").toString()));
}
@@ -84,17 +84,17 @@ public void reportCustomSpanInfomation() throws Exception {
customSpanTask.invoke();
await().atMost(2, SECONDS).until(() -> !spans.isEmpty());
- zipkin.Span span = spans.poll();
- assertThat(span.name, is("transaction1"));
+ zipkin2.Span span = spans.poll();
+ assertThat(span.name(), is("transaction1"));
assertThat(tracedValues(span), contains("startA"));
}
- private List<String> tracedValues(zipkin.Span spans) {
- return spans.binaryAnnotations.stream()
- .filter(span -> CALL_PATH.equals(span.key) || "error".equals(span.key))
- .filter(span -> span.value != null)
- .map(annotation -> new String(annotation.value))
+ private List<String> tracedValues(zipkin2.Span spans) {
+ return spans.tags().entrySet().stream()
+ .filter(span -> CALL_PATH.equals(span.getKey()) || "error".equals(span.getKey()))
+ .filter(span -> span.getValue() != null)
+ .map(annotation -> new String(annotation.getValue()))
.distinct()
.collect(Collectors.toList());
}
@@ -110,7 +110,7 @@ public void reportCustomSpanInfomation() throws Exception {
Tracing tracing(Queue<Span> spans) {
return Tracing.newBuilder()
.currentTraceContext(new StrictCurrentTraceContext())
- .reporter(spans::add)
+ .spanReporter(spans::add)
.build();
}
}
Support both v1 and v2 api of zipkin server.
Our customers may be still running a zipkin server prior to 1.31 which does not support the v2 http api. So we added an option to let them specify the server api version.
Supporting v1 api is built into zipkin2, so we do not need to rely on the v1 libraries. Just use the SpanBytesEncoder.JSON_V1
when building reporter and change the sender api path.
sender = URLConnectionSender.create("http://localhost:9411/api/v1/spans")
reporter = AsyncReporter.builder(sender)
.build(SpanBytesEncoder.JSON_V1);
That’s all, for the complete changes, please refer the pull request for the complete changes.
Leave a Comment
Your email address will not be published. Required fields are marked *


Remarkable
×
Close
Remarkable
Markdown Slideshow Editor
Empty slideshow
Code samples
RemarkJS sample slideshow


Copyright © {{ .Year }} quatroLABS.
Space is a user credentials/authentication management system designed to be as secure and confidential as possible.


The raspberry is the edible fruit of a multitude of plant species in the genus Rubus of the rose family, most of which are in the subgenus Idaeobatus; the name also applies to these plants themselves. Raspberries are perennial with woody stems.
Price = {{ price | currency : "Rs."}}


Home
Products
Sprayer Bot
Picker Bot
Weeder Bot
Contact
Gallery
☰
GALLERY
MoU(memorandum of understanding) is signed between Enjen Technologies and Perambalur KVK(krishi vigyan kendra).
Copyright © 2017.All Rights Reserved By Enjen


| Number of Classes | Line Coverage | Mutation Coverage |
|---|---|---|
| 5 | 93% | 68% |
| Name | Line Coverage | Mutation Coverage |
|---|---|---|
| BitsToByteInputStream.java | 80% |
21% |
| MyBitInputStream.java | 79% |
73% |
| MyBitOutputStream.java | 93% |
41% |
| MyLzwCompressor.java | 97% |
75% |
| MyLzwDecompressor.java | 95% |
84% |


the and respiratory {background COVIDâ€� for with SARSâ€�CoVâ€� that coronavirus ;:â€�. virus margin {border-style The al. has infection px;} #ffffff;} patients SARSâ€�CoV human acute infected novel have not Virol. are brain Med neuroinvasive syndrome disease from may more outbreak pneumonia px; reported severe studies this was {font-family ;():â€�. also been can font-size like mice showed were Indeed, Res. SARS SARSâ€�CoVâ€�. Wuhan, all cerebrospinal double; encephalomyelitis failure health important infectious patients. spread symptoms ACE CNS COVIDâ€�. CoV MERSâ€�CoV Vet border-color border-width causes evidence fluid hemagglutinating neurological pathogenesis potential role solid; these which {font-style {font-weight (SARSâ€�CoVâ€�) BaiWZ, China. However, Med. Yashavantha affect after angiotensin between bold cases cells central clinical control courier; death em; encephalitis further host illness including indicate invade invasion nervous neurons patient pt;} public route shown system their through where


You'll miss a lot on this web site unless you enable Javascript
in your browser.
Introduction [show]
It's hard to find out about the use of TLA+ in industry.
Companies usually don't talk about their engineering process, and any
specifications they write are almost always proprietary. I
happened to have contacts at Intel and Amazon who were willing to
describe how they used TLA+, and Amazon even published a couple of
papers about it. And of course, I know about much of the TLA+ use
at Microsoft. I learned about its use in building OpenComRTOS
after its developers published a book about it. The
Other Use
section below describes a few smaller examples of TLA+ use that I've learned
about.
Intel [show]
TLA+ was first used in industry to model hardware. Hardware engineers
are highly motivated to eliminate bugs, and they understand that this
requires thinking hard about what they're building before they begin
implementing it in silicon.
The early use of TLA+ at Intel is described in this section of a paper, written in 2002. It provides an excellent account of how TLA+ fit into their design process. A picture of TLA+ use in 2008 is provided by the paper: Pre-RTL formal Verification: An Intel ExperienceIt explains how a formal verification (FV) team used TLA+ in a project to design and implement a new cache-coherence protocol for a processor chip. The team validated the protocol and parts of the register transfer language (RTL) implementation. Here is an excerpt from that paper that describes the results of the pre-RTL FV effort. The FV team filed 45TLA+ was still being used at Intel in 2014, but I have no information about what has happened there since then.issuesthat the project used before RTL to track engineering problems requiring special attention to solve. A design lead for one of the verified microarchitectures, when asked for about the FV work, said,They found hundreds of bugs before RTL and played an important role in creating a stable microarchitecture.This microarchitecture had the lowest ratio of bugs per line of RTL even though the unit was new. On RTL and silicon there have been no coherence protocol or architecture feature bugs. In the areas covered by pre-RTL FV, only one microarchitecture bug has been found on silicon, attributed to accepting an unfounded claim that the affected logic would never interact with particular microarchitecture protocols. Amazon [show]
Amazon Web Services (AWS) has been using TLA+ since 2011. In April,
2015, six engineers published an article describing how it was introduced
to AWS and how it was being used there. Here are the
key insightslisted in the article.
Here is what Chris Newcombe, the lead author of the articles, has written elsewhere: TLA+ is the most valuable thing that I've learned in my professional career. It has changed how I work, by giving me an immensely powerful tool to find subtle flaws in system designs. It has changed how I think, by giving me a framework for constructing new kinds of mental-models, by revealing the precise relationship between correctness properties and system designs, and by allowing me to move from `plausible prose' to precise statements much earlier in the software development process. Microsoft [show]
TLA+ was used sporadically at Microsoft beginning around 2004.
Here is one of those uses as reported by the late
Chuck
Thacker.
During the development of the Xbox 360, I was working with the engineering group on the memory coherence protocol. Working with an intern, we were developing a TLA+ model for the protocol. In the course of this, we discovered a very subtle bug. We reported it to IBM, and they told us it couldn't happen. A couple of weeks later, they relented and told us that not only was the bug real, but that their regression tests wouldn't have found it. Had they not fixed it, they would have shipped us chips that would have deadlocked after about four hours of use. Had this [occurred], the schedule for a Christmas launch would almost certainly have been missed.Starting around 2015, use at Microsoft increased—especially in Azure, Microsoft's cloud service. Here are some abridged and lightly edited descriptions of TLA+ use written by members of the Azure team. Some of the TLA+ specifications mentioned were actually written in PlusCal. Albert Greenberg, Corporate Vice President of Azure Networking, writes: Our engineering process moves validation as early as possible in the engineering lifecycle — we strive to detect errors sooner to reduce risk, increase agility, and provide fast feedback to developers. Among the key tools we use is the TLA+ specification language — enabling us to describe our components formally with simple mathematics, with as little overhead as possible beyond what is needed to write the mathematics precisely.Dharma Shukla, Microsoft Technical Fellow, writes this about TLA+ use in Azure Cosmos DB, Microsoft's globally distributed database service: The Cosmos DB engineering team have been using TLA+ for specifying and validating the correctness of the core algorithms as well as the high-level specifications of the five consistency models that the system offers to our customers. We have found TLA+ extremely useful in two fundamental ways:Cheng Huang, Principle Software Engineer Manager, writes: TLA+ uncovered a safety violation even in our most confident implementation. We had a lock-free data structure implementation which was carefully design & implemented, went through thorough code review, and was tested under stress for many days. As a result, we had high confidence about the implementation. We eventually decided to write a TLA+ spec, not to verify correctness, but to allow team members to learn and practice PlusCal. So, when the model checker reported a safety violation, it really caught us by surprise. This experience has become the aha moment for many team members and their de facto testimonial about TLA+. OpenComRTOS [show]
The European Space Agency's Rosetta
spacecraft, which flew to a comet, used a real-time operating system
called Virtuoso to control some of its instruments.
The next version of that operating system, called
OpenComRTOS, was developed using TLA+ as described in this book:
Formal Development of a Network-Centric RTOSEric Verhulst, the head of the group that developed OpenComRTOS, wrote this in an email to me: The [TLA+] abstraction helped a lot in coming to a much cleaner architecture (we witnessed first hand the brain washing done by years of C programming). One of the results was that the code size is about 10x less than [in Virtuoso]. Other Use [show]
I have seen a number of reports of TLA+ (and PlusCal) being used
in real life. Some have been sent to me; some I found by simply
searching the web for
TLA+. Here are a few of them. A web posting titled Model Checking for the Working Man (m/f) by a programmer identified only as Rico describes how he was led to try TLA+ for the first time, and his experience using it. Here is a brief extract. What I was expecting was to wrestle with this for a good couple of days, but actually this tool chain is so easy to get started with, I got our algorith[m] modeled, the problem detected and the solution verified, all within half a day!By TLA+he meant PlusCal. It's not as easy to solve a real problem with TLA+ when you start by knowing nothing about it, and he found TLA+ to be cumbersome. But it's worth learning TLA+ if you're building a complex distributed system. Hacker News has a web page about TLA+. Here is part of a posting on it from 8 July 2015: One of my coworkers fleshed out an important and complex component that absolutely had to be logically correct, by using TLA+ modelling. It was the first time he'd used TLA+ ... at all, and it took a bit of experimenting to get used to it, but he soon generated a solid logical model and exposed a number of fringe flaws in the original proposed solution.In November, 2016, Bogdan Munteanu sent me email describing TLA+ use at Dropbox. Here is an extract from that email. [An] engineer decided to learn/experiment with [TLA+], so I provided some guidance and feedback. He wrote the formal spec for one of our two-phase commit protocols that we knew would fail in certain real-world situations. His spec found the issue ... and the engineer found the process extremely valuable. He mentioned that learning TLA+ was not at all a steep curve — it took him longer to understand the actual protocol.In a TLA+ Google group posting, Hillel Wayne reports this story of a bug in Elastic Search (ES):
|
||


THE LOSS OF SEXUAL INNOCENCE
Reviewed by Harvey Karten, Ph.D. Sony Pictures Classics/Red Mullet film Director: Mike Figgis Writer: Mike Figgis Cast: Julian Sands, Saffron Burrows, Stefano Dionisi, Kelly MacDonald, Jonathan Rhys-Meyers, Rossy De Palma, Femi Ogumbanjo, Hanne Klintoe
What makes us adults the way we are? Freud gave considerable importance to our upbringing by our parents during the first five years of our lives, with particular emphasis on the emotional (and unconscious sexual) connection from the moment of birth. Very recent studies have downgraded the responsibility of parents for the way we turn out, resting the culpability almost exclusively with our peer groups and our attempts to conform to their standards. As with other issues that get tossed around by intellectuals, the truth is somewhere between. But one thing most people agree upon is the singnificance to many adults of their sexual thoughts and relationships. For all the joys that sex has brought us, it gets us as well into heaps of trouble, as Nic (Mike Figgis's stand-in for "The Loss of Sexual Innocence"), discovers all too well.
Mike Figgis, whose principal claim to directorial fame is his stunning "Leaving Las Vegas"--about a man (Nicolas Cage) determined to drink himself to death and a prostitute (Elisabeth Shue) who demeans herself on a nightly basis--does not simply contemplate his past quite a bit in his latest film. He wants to make sure that folks out there in his movie audience share his recollections. Since 1982 he has planned the making of "The Loss of Sexual Innocence," but until recently did not have the money to pull it off. With the revenue he drew from the success of "Vegas," he now unfolds a picture which is difficult, challenging, and like so many other movies that make demands on audience attention, it rewards those who let the sounds and images of its non-linear structure flow about them. "The Loss of Sexual Innocence" takes as its thesis the view that who we are is determined largely by our sexual proclivities, thoughts, and actions. Figgis pushes his postulate by taking us first (via a fictional character) to his own boyhood days in Kenya, where he remained with his folks until he moved to northern England at the age of eight.
This is no documentary but actually a series of sharply edited vignettes of varying intensity and a striking soundtrack--which offers insights into the filmmaker's principal influences, including the power that music played in his life (he had played trumpet and guitar in rock and roll bands) and the leverage that his stage experience bears on this film. (He was a member of England's foremost avant-garde theatre group, "The People Show," which toured the world and apparently gave him the geographical breadth he puts to such good use in this movie.)
Serving up a series of short stories which exhibits the principal character of Nic (Julian Sands--who appeared as well in "Leaving Las Vegas") at the age of five, at twelve, at sixteen, and as a fully grown man--Figgis frequently cuts for allegorical purpose to biblical scenes of Adam (Femi Ogumbanjo) and Eve (Hanne Klintoe) both at the time of their sexual innocence and after they accepted that offer from a notorious snake.
 The first of the surreal images in the story--essentially highlighting a father's guarding his daughter's or granddaughter's innocence--prefigures an incident that occurs in Nic's teen years, when he makes out with his girl friend Susan (Kelly MacDonald) only to be interrupted by the gruff presence of Susan's father (Bernard Hill).
 At one point he sexually embraces his wife when he is interrupted by an important phone call, while we imagine that many other hugs will be intruded upon by the demands of their child. Sexual thoughts dominate dreams as well. The wife dreams of performing a strip tease to the beats of a jazz piano while Nic conjures up a flirtation with an Italian woman (Saffron Burrows) and as she, her boy friend Luca (Stefano Dionisi) and Nic travel across the Tunisian desert to do a film.
The connection between Adam and Eve's loss of sexual innocence after their partaking of the fruit offered by the snake and the deprivation of Nic's own chastity does not exactly strike us in the face. The Bible is a book of enormous literary value, offering not simply lessons to guide our modern lives but parallels as well. Demonstrating that correlation is a difficult job at best, but Figgis has broken new ground in his original film, one which is filled with a dramatic soundtrack (recorded by Figgis himself), startling and beautiful imagery (particularly of the Blue People of Tunisia), and a compelling cast led by the handsome and magnetic Julian Sands.
Photographer Benoit Delhomme has done a remarkable job of capturing the desolation of southern Tunisia's Saharan region, Italy's Umbria region and the northern English city of Newcastle which is, not surprisingly in the region of the town of Carlisle which was Mike Figgis's birthplace.
Rated R. Running Time: 106 minutes. (C) 1999 Harvey Karten
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


We redefine dogs!
- monetize compelling e-markets
- reinvent integrated niches
- iterate magnetic functionalities
- recontextualize world-class convergence
- expedite 24/365 paradigms
- scale visionary niches
- enable killer architectures
- maximize innovative interfaces


 Also tacos.
Slick some Tables Out
Gunk a Table
Your Name
Email
Phone
Submit The Gunk


MetaAvatar is meta-learned model that represents generalizable and controllable neural signed distance fields (SDFs) for clothed humans. It can be fast fine-tuned to represent unseen subjects given as few as 8 depth images.
Inspired by recent advances in meta-learned initializations for neural implicit representations, we propose to use meta-learning to effectively incorporate cloth-deformation priors for clothed humans, thus enabling fast fine-tuning (few minutes) for generating new avatars given only a few monocular depth images of unseen clothed humans as inputs
We follow the same pipeline of recently proposed SCANimate, which learns dynamic neural SDFs from dense full-body scans to represent subject/cloth-type specific avatars of of clothed humans. Instead of learning subject/cloth-type specific models from scratch, we propose to meta-learn a prior model which can be fast fine-tune to represent any subject/cloth-type specific neural avatars given only depth frames.
Our key contribution is a meta-learned hypernetwork that can be fine-tuned to represent subject/cloth-type specific neural SDFs given only a few depth frames. In practice, we decompose the training into two stages 1) meta-learn a static neural SDF 2) meta-learn a hypernetwork which predicts residuals to the parameters of the previously meta-learned static neural SDF.
Comparison to baselines
Learning with reduced data
Learning with depth from raw scans


Kaboom
What is this?
This is a cruel, but fair Minesweeper game:
- The mines are not placed beforehand, but determined as you play.
- If you try to guess, the game will always choose the worst scenario.
- Except when you are forced to guess (there are no safe cells).
Have fun!
See also
Simon Tatham's Mines - guaranteed solvable without guessing


When I first started using Pandas, I loved how much easier it was to stick a plot method on a DataFrame or Series to get a better sense of what was going on. However, I was not very impressed with what the plots looked like. Any time I wanted to do something slightly different from the “Plotting” documentation on the pydata site, I found myself arm deep in MPL code that did not make any damn sense to me. This was a problem for me, as I ended up spending way too much time trying to make small edits and not enough time working on the code I was trying to visualize.
One thing in particular bugged me. I could find no easy to understand tutorial on annotating a bar chart on StackOverflow or any other site. MPL had some documentation, but it was too confusing for me at the time. I spent a lot of time trying to figure out how to put some text right above my bars. Since I would have loved to see a snippet of code to help me in my journey, I thought I would throw it together in a brief post so others could use my workaround.
I warn you, it is not the most elegent solution, I am sure, but it worked for me when I needed to demonstrate the insight I had gained from a Healthcare Access and Utilization Survey (made up mostly of CHIS questions) to people in my department, my director, and her bosses. Since I cannot share any of that data, I will use the War of the Five Kings Dataset that Chris Albon made. I love this data set because I am in the middle of book five of Game of Thrones, which provides a good amount of domain familiarity to enable jumping in easier.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
plt.style.use('ggplot')
%matplotlib inline
# set jupyter's max row display
pd.set_option('display.max_row', 1000)
# set jupyter's max column width to 50
pd.set_option('display.max_columns', 50)
# Load the dataset
data = pd.read_csv('site_content/data/5kings_battles_v1.csv')
ax = data['region'].value_counts().plot(kind='barh', figsize=(10,7),
color="coral", fontsize=13);
ax.set_alpha(0.8)
ax.set_title("Where were the battles fought?", fontsize=18)
ax.set_xlabel("Number of Battles", fontsize=18);
ax.set_xticks([0, 5, 10, 15, 20])
# create a list to collect the plt.patches data
totals = []
# find the values and append to list
for i in ax.patches:
totals.append(i.get_width())
# set individual bar lables using above list
total = sum(totals)
# set individual bar lables using above list
for i in ax.patches:
# get_width pulls left or right; get_y pushes up or down
ax.text(i.get_width()+.3, i.get_y()+.38, \
str(round((i.get_width()/total)*100, 2))+'%', fontsize=15,
color='dimgrey')
# invert for largest on top
ax.invert_yaxis()
The image above is the output from the Jupyter notebook. I think it is super clear and gives a lot of information about where the battles were fought. However, I am very parital to horizontal bar charts, as I really think they are easier to read, however, I understand that a lot of people would rather see this chart implemented in a regular bar chart. So, here is the code to do that; you will notice that a few things have changed in order to create the annotation.
ax = data['region'].value_counts().plot(kind='bar', figsize=(10,7),
color="coral", fontsize=13);
ax.set_alpha(0.8)
ax.set_title("Where were the battles fought?", fontsize=18)
ax.set_ylabel("Number of Battles", fontsize=18);
ax.set_yticks([0, 5, 10, 15, 20])
# create a list to collect the plt.patches data
totals = []
# find the values and append to list
for i in ax.patches:
totals.append(i.get_height())
# set individual bar lables using above list
total = sum(totals)
# set individual bar lables using above list
for i in ax.patches:
# get_x pulls left or right; get_height pushes up or down
ax.text(i.get_x()-.03, i.get_height()+.5, \
str(round((i.get_height()/total)*100, 2))+'%', fontsize=15,
color='dimgrey')
I play around with the mpl.text() numbers for almost each chart. They are never exactly where they need to be, which often means moving thigs around a hair here and .03 there. You can add or subtract, which means you can also do this:
ax = data['attacker_outcome'].value_counts().plot(kind='bar', figsize=(10,7),
color="indigo", fontsize=13);
ax.set_alpha(0.8)
ax.set_title("Do attackers usually win or loose?", fontsize=18)
ax.set_ylabel("Number of Battles", fontsize=18);
ax.set_yticks([0, 5, 10, 15, 20, 25, 30, 35, 40])
# create a list to collect the plt.patches data
totals = []
# find the values and append to list
for i in ax.patches:
totals.append(i.get_height())
# set individual bar lables using above list
total = sum(totals)
# set individual bar lables using above list
for i in ax.patches:
# get_x pulls left or right; get_height pushes up or down
ax.text(i.get_x()+.12, i.get_height()-3, \
str(round((i.get_height()/total)*100, 2))+'%', fontsize=22,
color='white')
If you are like me, often you like to isolate a categorical value in one column and see what the rest of the dataframe looks like in light of that. It is a simply way of drilling down, but a percentage really would not be as appropriate as a count. Here is an example of using a count rather than a percentage:
losses = data[data['attacker_outcome'].str.contains("loss", na=False)]
ax = losses['attacker_king'].value_counts().plot(kind='barh', figsize=(10,7),
color="slateblue", fontsize=13);
ax.set_alpha(0.8)
ax.set_title("Who were the attackers who lost?", fontsize=18)
ax.set_xlabel("Number of Battles", fontsize=18);
ax.set_xticks([0, 5])
# set individual bar lables using above list
for i in ax.patches:
# get_width pulls left or right; get_y pushes up or down
ax.text(i.get_width()+.1, i.get_y()+.31, \
str(round((i.get_width()), 2)), fontsize=15, color='dimgrey')
# invert for largest on top
ax.invert_yaxis()
You can also just project a couple columns from those that lost to compare a couple of values; I think bar charts are great for this purpose. I am not sure what the best way would be do accomplish this, but here is my implementation:
ax = losses[['attacker_size', 'defender_size']].plot(kind='bar',
figsize=(15,7), color=['dodgerblue', 'slategray'], fontsize=13);
ax.set_alpha(0.8)
ax.set_title("For Attacker Losses, What was the Difference in Size?",
fontsize=18)
ax.set_ylabel("Number of Troops", fontsize=18);
ax.set_yticks([0, 20000, 40000, 60000, 80000, 100000, 120000, 140000])
ax.set_xticklabels(["Robb v Joff/Tommen", "Joff/Tommen v Robb",
"Stannis v Joff/Tommen", "Robb v Joff/Tommen",
"Stannis v Mance"], rotation=0, fontsize=11)
# set individual bar lables using above list
for i in ax.patches:
# get_x pulls left or right; get_height pushes up or down
ax.text(i.get_x()+.04, i.get_height()+12000, \
str(round((i.get_height()), 2)), fontsize=11, color='dimgrey',
rotation=45)
There is a handy ‘rotation’ option for the MPL plots that you can use that I feel works well when using a regular bar chart. I really dislike tilting my head to one side to try and read what it says! Also, it is easy to rename the columns! I did not realize how simple it was, which makes me feel silly.
Here is the chart done horizontally, which I prefer:
ax = losses[['attacker_size', 'defender_size']].plot(kind='barh',
figsize=(10,7), color=['dodgerblue', 'slategray'], fontsize=13);
ax.set_alpha(0.8)
ax.set_title("For Attacker Losses, What was the Difference in Size?",
fontsize=18)
ax.set_xlabel("Number of Troops", fontsize=18)
ax.set_ylabel("First Name is Attacker", fontsize=18)
ax.set_xticks([0, 20000, 40000, 60000, 80000, 100000, 120000, 140000])
ax.set_yticklabels(["Robb v Joff/Tommen", "Joff/Tommen v Robb",
"Stannis v Joff/Tommen", "Robb v Joff/Tommen",
"Stannis v Mance"])
# set individual bar lables using above list
for i in ax.patches:
# get_width pulls left or right; get_y pushes up or down
ax.text(i.get_width()+700, i.get_y()+.18, \
str(round((i.get_width()), 2)), fontsize=11, color='dimgrey')
# invert for largest on top
ax.invert_yaxis()
I hope this is helpful for anyone out there trying to create little annotations for their visualizations. I feel like this is just a little bit of extra work but it keeps me from having to write JavaScript, which is worth a little copy paste action. When I have time, I would like to create a class with methods so I do not have to keep doing a copy/paste job in my Jupyter notebook.
Let me know if there is an easier way to do this, I would be grateful!
Here is a link to the notebook on my GitHub if you are interested in playing with it a bit more. I stopped when I was trying to figure out how to turn the dates into a Pandas ‘period_range’.