Requirements
of Human-Graphs Interface
Etienne Saliez, version 2021-09-01 /
- Introduction:
- There is a need of bridges between:
- Humans graphs:
- At one side the human mind works as a large graph of
neurons with about 10**12 neurons i.e. nodes and 10**15
synapses i.e. relationships.
- Medical users need very easy interface to edit graphs.
Technical formulations like "cypher statements" would
absolutely not be accepted.
- Humans are excellent at visual pattern recognition i.e.
graphs.
- People should be encouraged at providing more structured
information. May be still free text but at least in small
dedicated boxes. The idea is here to reduce the need of very
unstructured "natural language" analysis with all its
complexity.
- Computers graphs:
- At the other side computers need also graphs in order to
manage complex information.
- Computer should provide very flexible and interactive
graph presentations in order to be easily understood by
people.
- In order to be trusted, computers must be very
transparent, explaining recommended decisions step by step.
- Main intended uses:
- Knowledge base:
- Builders and maintainers of medical knowledge graphs which
require many relationships between concepts.
- Even if Natural Language Processing of textbooks can
provide a good start for knowledge bases, medical experts
will remain very necessary for review and corrections.
- Teachers of medicine have to explain to their students
multiple relations between concepts. They could like to use
graphs in the preparation of their courses. Also expected to
be useful in traing sessions.
- A knowledge base is intended to contain generic knowledge
about symptoms, problems, actions, ... For example knowledge
about the meaning of a lab test appear only once in the
knowledge base.
- Patient record:
- During contacts with patients notes must always be
registered immediately. Rather than doing that typing
completely free text the idea is to try to do it in a more
structured way as a graph. Of course this option require a
very ergonomic interface. Some NLP could help but the goal
is anyhow to create graphs.
- The expected benefit is to get instantly Assisted
Intelligence from the medical knowledge base.
- A task oriented approach in order to try to solve the
problems of the patient. Problems have a central role with
links to symptoms and recommended actions. This according to
the "Problem Oriented Medical Record" according of L. Weed
philosophy.
- Shared overview of patient's problems and related
information will be also very useful for the coordination
between the members of the "care team" in charge of a common
patient.
- A patient record is intended to contain instances of
information related to a particular patient, as problems,
symptoms, treatments, .... These instances are in principle
always linked to the corresponding generic knowledge. For
example there may be any number of instances of lab test
results found by many different patients, at different
times.
- General remarks:
- This document is intended to define the desirable
functionalities while a separate note will look at software
resources.
- Real time interactivity is essential in patient care.
- Graphs must contain the complete information even if some
fields are not yet well structured. Anyhow graphs are seen as
backbone or as a "kind of table of content" at the top level,
paying much attention to relations between main concepts
represented by nodes. That said nodes may contain any kind of a
mittle less structured information including free text comments,
images, or links to external documents.
- Screen:
- Visual graphs should be the backbone of this man-machine
interface.
- A secondary screen space is intended to present and to update the
attributes of a nodes or a relations.
- Main menu:
- A persistent specific small group of nodes on fixed location on
top of the screen.
- Main commands, like seek a patient, get the problems,
predefined selections, get agenda, user preferences, etc...
- The main menu should always be available. At least one node
which can be expanded to a larger set of less frequent commands.
- Possibility to go back to the previous transactions.
- User preferences:
- Selection of certain types of relationships.
- Default selection at the opening of a patient record.
- Preferred style of presentation.
- ...
- Selections:
- Selection of a subset of the large databases. For example
selection in the knowledge base of one disease, of related symptoms,
recommended actions, ..., or in case of a patient record selection
of one problem with directly related information.
- Zoom or un-zoom should provide more or less, from a large overview
to the details.
- By default the active node or relation is presented with most of
his directly related nodes. However users may define preferences
about types of relations and number of levels.
- Current object:
- Introduction:
- The current active object may be a node or a relation,
presented as highlighted.
- Remark: access and updates of objects will depend on the
current user profile and of the transaction type. The exact
rules will be specified in a separate document according to
"Role Based Access Control" principles. Typically the current
"care team" of the patient need access to work. For example a
nurse need to read the prescriptions but not to create new ones.
- Flying over:
- Show temporarily the content of the node or relation in the
secondary window. Intended to make very easy to see quickly the
essential of the content.
- Activation:
- Presentation of the content as above, but in a more persistent
way, until a save or a close.
- ...
- Actions on a node:
- Navigation to a new selection.
- For example a new specific selection to related nodes
starting from the current node,.
- Access to previous versions of the same node, if any.
- Access to the full content of the node:
- The content of node begin with a few standard information
as type, date-time, responsible author, etc... and may
include any kind of document, discharge letters , images,
etc...
- If necessary a cursor in order to see more of a long
screen page.
- Possibility to jump to related pages, even on an external
server. i.e. hypertext facilities, with later come back.
- Possibility to edit the content:
- A set of fields can be proposed:
- Some field could accept expression in natural
language. Or even maybe voice converted immediately to
text.
- Some standard fields may be mandatory while additional
fields are optional.
- Procedures and rules:
- In a medical knowledge base, it must be possible to
install procedures inside nodes.
- The specification of these procedures will be discussed in
an other chapter about decision procedures.
- Activation:
- Manual in the edit window, in function of predefined
changes in the attributes, by "events" coming from other
procedures, ...
- Consequences:
- Possibility to activate new selections, to create new
nodes and relations, to broadcast new events, ...
- Save:
- If a previous version exist of the same object exist,
generate a new version.
- Previous versions should remain available on request.
Indeed it must be possible to retrieve the situation as it
was at a given point in time in the past. Important in the
context of a team of several actors who may sometimes have
different opinions. Moreover a legal requirement in order to
justify a decision based on available information at that
time.
- Changes in nodes could activate evaluation procedures.
- Deprecation:
- In principle delete should never be allowed
immediately.
- Relations to a nodes must have already been
deprecated.
- Close:
- ...
- Actions on a Relation:
- Similar to nodes here above.
- Also flyover for quick inspection.
- Standardization of the types of relations. A set of relations
types will be defined, pay
- ing much attention to the difference between causal or only
co-occurence relations.
- Weight of relations:
- Very important in evaluation procedures; In patient care
uncertainties are very common and many things are never
completely "yes" or "no".
- Weight representation:
- Inside the database weights should be normalized in a
scale from 0 to 1. Indeed decision procedures should be
based on the best possible values.
- On visual graph by means of the thickness of arrows.
- In traditional reports the score should be rounded to
adjectives, like "weak" or "strong", "not to exclude" or
"certain", ...
- Weight could have several factors having each their own
weight. For example "degree of belief" is different from
"probability". "Importance" can be seen from different point
of view as life expectancy and comfort.
- Relations are to be seen as independent objects. For example
the author or a Relation may be different from the authors of
the 2 related nodes.
- The same 2 nodes may have multiple relations. For example when
2 authors have different vision on a relation.
- Relations have a direction, but traversal can be in both
directions.
- As above changes in relations should be propagated to
concerned evaluation procedures.
- Save or deprecate as above.
- Creation of a Node:
- May be created in an empty space, again depending on the
authorization profile of the current user.
- Any new node must immediately be edited, at least with a type and
the mandatory attributes.
- Creation of a Relation:
- Drag an arrow from one node to an other one, again depending on
the authorizations of the user.
- Any new relation must immediately be edited, at least with the
mandatory attributes.
- Dragging an arrow to an empty location will create a new node.
- Visual presentation:
- Introduction:
- In order to make a very intuitive visual interface the most
important types and attributes should appear in a visual way, or
style.
- The choice of a particular style will depend on user profile
and preferences.
- Logical options, as:
- Type,
- Weight, intensity,
- Probability
- Degree of belief,
- Author, moreover possibility of endorsement by others,
- Importance,
- Decay in time,
- New information, novelty:
- In function of a predefined delay
- In function of what is new for the current user.
- ...
- Visual options, as:
- In general:
- Color
- Intensity or darkness
- Text color,
- Background color,
- Text size
- Blinking:
- Background,
- Blinking,
- Halo,
- Movements or oscillations,
- For Node:
- Size
- Shape (round, oval, square, ..)
- Border:
- Position in the graph, attraction or repulsion to other
types of nodes. The current active node could be moved to
the center of the screen.
- Inversed text and background colors,
- Moving nodes and associated relations
- Position in a virtual 3D space,
- For Relation:
- Thickness
- Direction,
- Dashed style,
- ...
- ...
- ..


The "Turing" machine was invented in 1936 by Alan Turing. The Turing machine is not intended as practical computing technology, but rather as a hypothetical device representing a computing machine. Turing machines help computer scientists understand the limits of mechanical computation.
Turing gave a succinct definition of the experiment in his 1948 essay, Intelligent Machinery. Referring to his 1936 publication, Turing wrote that the Turing machine, here called a Logical Computing Machine, consisted of:
...an unlimited memory capacity obtained in the form of an infinite tape marked out into squares, on each of which a symbol could be printed. At any moment there is one symbol in the machine; it is called the scanned symbol. The machine can alter the scanned symbol and its behavior is in part determined by that symbol, but the symbols on the tape elsewhere do not affect the behavior of the machine . However, the tape can be moved back and forth through the machine, this being one of the elementary operations of the machine. Any symbol on the tape may therefore eventually have an innings.


About the author
Hi there! welcome to Machine Intelligence Blog! I’m Stern Semasuka, and I’m an aspiring machine learning engineer based in Calgary. I’m learning machine learning to solve humankind challenges. The act of writing posts helps to explain complex topics in simple words using the Feynman Technique.
I firmly believe that anyone, with enough commitment and perseverance (gonna need a lot of it!), can learn and understand machine learning and start using it right away to solve challenges and make earth a better place.
Why another machine learning blog?
This one is different. This blog helps anyone who is interested in Machine Learning but doesn’t have a clue where to start because many blogs out there assume that you already a bad*ss data scientist. I said to myself why not create a resource that show case what I am learning.
I write on topics ranging from programming, a little bit of maths used in machine learning, SQL, data analysis to model optimization used in machine learning through easy to understand projects. The post starts from the beginner level of machine learning to more advanced topic.
About the blog
This blog is ranked among the top Machine Learning blogs online. The blog itself is built using Jekyll.
If you wish to use this blog as a template to create your own blog or to contribute to this project (as I am a strong believer that knowledge should be shared), do a pull request on GitHub here.
Contact the author
Do you want to share a comment, a constructive critic, a correction, or a question related to machine learning? or work with me on an interesting project? Do not hesitate, get in touch with me through e-mail or LinkedIn.
Donate
Do you enjoy the content of this blog? kindly consider supporting the blog 😃


Portfolio
Rositsa Kostova
Nature, femininity and tradition are the cheered subjects in my creative artwork. I seek to combine old traditions with modern techniques and ideas. Capturing the beauty and elegance in even everyday objects reminds me that femininity is everywhere and it is so powerful. I use Illustration, painting, drawing and often mixed media to express the emotions and clarity in the simplest moments. My goal is to capture the little moments in life that seem so insignificant and show that they are more valuable and beautiful than we think.
Artworks:
Web Design:


# Easter Egg Lab
--- # Easter Egg Lab ## Team Structure * Split into groups of no more than 5. ## Requirements * Each egg needs to be colored by at least two people * Two different colors must be used and different colors can’t be used in the same area (within edges). ## Resources * http://www.360pmo.com/docs/download/eggs.gif --- # Waterfall Round ## Requirement * Label the back with an 'W' ## Timing * 2 minutes - planning * 2 minutes - execution * 3 minutes - learning/qa - write down major lesson learned ## Roles - 1 person per role * Cutters - cut out the eggs * Painters - paint the eggs * QA - access the correctness --- # Agile Round ## Requirement * Label the back with an 'A' ## Timing * 1 minute - planning * 2 minute - execution * 1 minute - retrospective (learning) - write down major lesson learned ## Roles - no defined roles --- # Scoring * Count your eggs from Waterfall and Agile and between the rounds --- # Lessons Learned * Teaches the value of teams autonomy to self organize and the advantage of iterative delivery process over waterfall approach * Provides a clear evidence on how productivity can radically increase when better work methodology is applied * Highest impact on organizations & teams which are deeply rooted in waterfall mindset * Showcases the strength of the lean approach in responding to change


UITestScreen
open class UITestScreen : UITestScreenProtocol, Equatable, UITestScreenInitialisableProtocol
Undocumented
-
Declaration
Swift
public static func == (lhs: UITestScreen, rhs: UITestScreen) -> Bool
-
Undocumented
Declaration
Swift
required public init()
-
Undocumented
Declaration
Swift
public var isCurrentScreen: Bool { get }
-
Undocumented
Declaration
Swift
public var app: XCUIApplication { get }
-
Declaration
Swift
open var screenIdentifierPrefix: String { get }
-
Declaration
Swift
open var screenTraitStrategy: TraitStrategy
-
trait strategy setter for screen
Declaration
Swift
public func setScreenTraitStrategy(_ traitStrategy: TraitStrategy)
Parameters
traitStrategy
strategy best describing state where current screen is loaded
-
Returns string representing current screen object
Declaration
Swift
public var screenName: String { get }
-
Sets connection between current screen and target screen
Usage Example:
func navigationStepsToScreenA(){} self.connectTo(screen: UITestScreenA.self, transition: navigationStepsToScreenA)
Declaration
Swift
public func connectTo(screen: UITestScreen.Type, transition: @escaping () -> Void, postTransition: (() -> Void)? = nil)
Parameters
screen
target screen
transition
closure containing steps to make transition from current screen ot target screen
postTransition
optional steps to be performed after getting to target screen


| Variables | ||
| data | static | |
| dgppars | static const | |
| EM | static | |
| HM | static | |
| Enumerations | ||
| Anonymous enum 1 |
| Public methods | ||
| Run | static | Setup and solve the model. |
| Utility | The one period return. |
| Public fields | ||
| inlabs | static const | |
| lnlk | const | |
| mle | const | |
| Public methods | ||
| BruteForce | ||
| ZPanel | ||
| Enumerations | ||
| Anonymous enum 1 |
| Enumerations | ||
| Anonymous enum 1 | MCSampleSize, PanelLength, AMNX |
U = dRC+(1-d)θ1mx + n
| Enumerations | ||
| Anonymous enum 1 | id, xc, ic, Ncols |


| Package | Description |
|---|---|
| com.tyrlib2.ai.steering | |
| com.tyrlib2.game | |
| com.tyrlib2.graphics.animation | |
| com.tyrlib2.graphics.particles | |
| com.tyrlib2.graphics.renderables | |
| com.tyrlib2.gui | |
| com.tyrlib2.input |
| Modifier and Type | Interface and Description |
|---|---|
interface |
IVehicle
An interface for vehicles which will receive steer commands from
the Behaviour layer.
|
| Modifier and Type | Class and Description |
|---|---|
class |
PointMass
A very simple vehicle model made up simply by a point mass.
|
class |
Steerer
Main class for steering.
|
| Modifier and Type | Class and Description |
|---|---|
class |
Movement
This class takes care of guiding an object to a series
of targets
|
class |
SteeredMovement
This class uses a steerer to move an object to the desired
locations.
|
| Modifier and Type | Method and Description |
|---|---|
void |
Updater.addItem(IUpdateable item) |
boolean |
Updater.hasItem(IUpdateable item) |
void |
Updater.removeItem(IUpdateable item) |
| Constructor and Description |
|---|
Updater(java.util.concurrent.BlockingQueue<IUpdateable> queue) |
| Modifier and Type | Class and Description |
|---|---|
class |
Animation
This class represents an animation by manipulating a skeleton.
|
class |
Skeleton
This class manages skeletal animations by using bones.
|
| Modifier and Type | Class and Description |
|---|---|
class |
Emitter
This represents an emitter of particles
|
class |
Particle
This represents a single particle
|
class |
ParticleSystem
Manages a system of particles.
|
| Modifier and Type | Class and Description |
|---|---|
class |
Entity
This class represents an Entity object.
|
| Modifier and Type | Class and Description |
|---|---|
class |
Window
Basic window class
|
| Modifier and Type | Class and Description |
|---|---|
class |
Controller
A class for something controlled by Input
|


Design
- walkthrough / steps to make your own design system
- how to use this as an example?
- http://setproduct.com/5-steps-of-design-system
- design docs as notes/sketches; sketching and thinking with words
- sketch on PAPER to support your thoughts
- fast and dirty
Clarity is VERY good — use theirs as a base: Clarity - cool tracking list feature - patterns vs. components — use industry lingo!! - good demo, and menu system under each component - good way of navigating within components - like the sidebar design better than mine
Mobbin design patterns: https://mobbin.design/
design product system helps you focus on what matters
Design / Research / DesignOps
** rename to StyleCore?
Nothing here yet but it's planned for the future. Here's a bunch of notes for right now.
Design Systems Handbook
architecture/info arch/business requirements/planning phase: - sketching for thinking, IA - wireframes for communicating ideas
- deliberately hide information
- toggle-able wireframes
- "sketchframes" "webframes"
- https://blog.prototypr.io/why-you-shouldnt-skip-your-wireframing-1f7a70d5c125
- "comp frames" — dribbble-pretty comps
- as deliverables — ok if you have design system in place
- save time, each component named correctly
- develop new components needs more added info
-
good starter / quotes for research and IA https://uxplanet.org/get-professional-useful-habits-for-ux-designers-dceb1481e6ac
- "object-driven design" — https://uxplanet.org/how-to-save-ui-designers-front-end-developers-up-to-50-of-their-time-39a30254ec05
- "DRY" in design — don't repeat yourself
- create once, apply everywhere
- one source of truth
- truth re-use
- bridge the design and development knowledge gap
- use a single language for design specifications
- in this case it's SASS
- use a single language for design specifications
- should designers code?
- they should share the same language as the developers
- whether code, or their own spec language where everyone can always be on board
- symbols in sketch
- whatever
- they should share the same language as the developers
- single name for everything; single "dictionary" that make up that language
- cascading changes
- change one place, change everywhere
- breaking changes / testing for problems, alignment, etc.
-
both designers and devs should think in terms of building blocks
- checklist for creating a new element / object
- Establish reason/need for the element
- are the needs solved in other, simpler ways?
- Does it already exist?
- can an existing one be re-used or modified?
- can existing modules be combined?
- Establish reason/need for the element
- macro design / business intentions / business-driven design vs. micro-design
- when to do what
- what's more important?
- always think of the big picture
- ocd…
- informaiton hand-off between designer and developer
- what is the fidelity of these designs?
- what are EXACT and need to be this EXACTLY?
- what are approximations and the developer has freedom to do his own thing within the scope of design?
- are there important reasons behind these design?
- user research or feedback, or business-design goals
- keep requirements and changes updated on both designer and dev side
- what is the fidelity of these designs?
Technical + Design + Change Debt = System Debt - design notes - comments - reasons - change debt - tracking changes - test changes (breaking changes?) - logging + commenting changes - do work now, save time in future
- Ownership
- who owns what? whose words count?
- design from information
-
sketches / wireframes are the NARRATIVE of the information
- outline to style guide
- color
- typography
- core screens
- basic page IA — same regardless of what the site looks like
- identify "main" screens: landing page, signup, price comparison, etc.
- identify components on them, and design the components
- nav, header, footer, buttons, charts, marketing areas
- naming the objects / symbols
- index the pages, objects, symbols for later
** stylecoeur: generalize a framework for ALL of this - style guide OF style guides - for wireframing, prototyping, and building new style guides
- design system-system
- how to manage the design system
- notes, logs, reducing debt
- using github to track changes, diff
- continuous design cycle
- brainstorm
- establish / build
- design review — what's new, what's changed; can be a meeting or just a document of changes
- this is important because it emits the newest "version"
- can all just be one person, but cycle still very important, to keep track of everything
- reduce system debt
"Remember: However busy you are, working as fast as possible in the short-term will build up long-term technical debt."
airBnB Notes
- one-off solutions: not inherently bad, but if they aren’t built upon a solid foundation, we eventually find ourselves having to pay back accrued technical and design debts.
- Design is about systems, and creating products in a scalable and repeatable way.
- A unified design system is essential to building better and faster; better because a cohesive experience is more easily understood by our users, and faster because it gives us a common language to work with.
- too few constraints - leads to disjointed user experiences
- multiple designers and stakeholders - new solutions and styles causes divergence and incoherence
- multiple platforms - repeated work required to keep things synchronized
- software as a continuum - years-old code and designs will still stick around, even after product has shifted, requiring maintnenance and upgrades
- faster development: product engineers can focus more on writing the feature logic rather than the view code; share a common language w/ design
- patterns need to be fundamentally simple
airBnB Design Language System / Design Ops
- auditing and printing out many of our designs, both old and new; Laying the flows side by side on a board, we could see where and how the experiences were breaking and where we needed to start making changes
- Design Principles:
- Unified: Each piece is part of a greater whole and should contribute positively to the system at scale. There should be no isolated features or outliers.
- Universal: Airbnb is used around the world by a wide global community. Our products and visual language should be welcoming and accessible.
- Iconic: We’re focused when it comes to both design and functionality. Our work should speak boldly and clearly to this focus.
- Conversational: Our use of motion breathes life into our products, and allows us to communicate with users in easily understood ways.
- Foundation
- typography
- title 1 44/56, title 2 32/36, title 3 24/28, large 19/24, regular 17/22, small 14/18, micro 8/8
- colors
- accessibility (a11y) compliant w/ websafe scores
- icons
- spacing / grids
- they use blocks of tiny:8 / small:16 / base:24/ large:48 / x-large:64 instead of baseline
- information architecture
- typography
- atoms and molecule guides opens door for disjointed experiences, difficult maintainability
- redefine components w/ personality, not just rules; evolving ecosystem
- end use of a component (e.g. avatar) can take on hundreds of permutations
- each component and variations are diligently recorded in the library; some elements can be turned on / off depending on need
- library:
- framework + library helps prototyping speed; based on needs
- content component artboards like Navigation, Marquees, Content, Image and Speciality: group similar components
- different sets for iOS, Android, and responsively adapted
- simple layout concepts called Views for diff. devices: combined components, focuses on content and jobs to be done, rather than building components themselves
- built on top of their own technical framework
Learnings
- Some patterns / subcomponents repeat often across many components; think about how these can be extracted into their own, w/ their own patterns (e.g. rows, table-cells)
- Sketch as a master component library is hard to maintain
- Documentation system - should be done soon, take into account design process/decisions, will help future decision-making and review
airBnB Design and Culture
- Fuse Engineering, Product and Design from the start: engineering, product and design teams are hitched and commonly referred to as EPD. By design, each function is involved and aligned from a product’s inception to its launch. For example, a working group for a new feature, product marketing or user feedback will involve at least one member from each of the three teams. This coalition not only assembles the key builders of the product, but, as a byproduct, it also formalizes the professional pathways that a person who wants to create a product can consider
- Design lead to focus design-work
- Grow designers w/ product and engineering hires; every project needs a designer to keep tabs on things / design responsibility
- Three elements define a product: the business, the code and the pixels. Give each a voice in all product decisions
- Retention. In craft-based disciplines like design or engineering, you can allow people to continue to hone their core competency, rather than manage the development of others. Many people leave when this transition is forced, and there should be checkpoints for individual contributors who want to try on management.
- Concurrent cohort growth. By allowing ICs to work on high-priority projects and make bigger decisions, they can keep advancing with their engineering and product counterparts, rather than be left to work on projects that don’t flex their full skill set. They can continue to build, bond and grow with their cross-functional peers.
- Mobility. Level titles and on-the-job exposure facilitates more opportunities for expertise by osmosis — or the diffusion of knowledge — across functions. As a designer becomes more senior, she picks up more and different expertise from her engineering and product counterparts. With a greater working knowledge, designers have the option to move to “other legs of the stool” based on past projects, interest level and skill set.
Content Strategy / Voice and Tone
https://airbnb.design/content-strategy-at-airbnb/ voiceandtone.com - Our voice is the extension of our brand and personality within the product, and it’s the foundation of everything we write. - In the end, we decided our voice is straightforward, inclusive, thoughtful, and spirited.


Linear Algebra
Solve a System of Equations
Find Eigenvalues and Eigenvectors
Single Variable Calculus
Differentiate function f(x)
Plot y = f(x)
Here we will find the eigenvalues of a matrix of a given size $n.$
Enter the size of the matrix:
Go!


Warning the below file contains private data. Be very cerful how you store it.
CSV Key FileDGB was in UTXO that can not yet be spent(or Assets where present). To send that part of the balance you will have to try again later. The rest can be sent now.


{% from "components/big-number.html" import big_number %} {% from "components/pill.html" import pill %}


Toggle navigation
Home
Sync Mobile App
×
Mobile Sign In
Scan the following code with your mobile device to sign in.
Today's Schedule (click to navigate)
{% for cls in classes %}
{{cls.type}} - {{cls.class_name}} - {{cls.where}}
{{cls.timestamp}}-{{cls.timeend}}
{% endfor %}
Buildings on Campus (click to highlight)


---
title: "IRRIGATION - SWITCH TO DRIP"
date: "2000-01-01 20:03:10 -06:00"
categories:
- adult
subtitle: ""
layout: "events"
event-image: "irrigation-switch-to-drip.jpg"
event-dates: "TUESDAYS, MARCH 10 - 31"
event-location: "Lifelong Learning, 540 Arapeen, Room 242"
button-type: "register"
tickets-link: "https://continue.utah.edu/lifelong/class/llhg_908_irrigation___switch_to_drip"
registration-info: "Phone Registration Available:
801-587-5433
Lifelong Learning: LLHG 908"
instructor-info: "Catherine Casson"
member-cost: "$109"
public-cost: "$119"
event-notes: ""
tickets-button: ""
published: false
---
TUESDAYS, MARCH 10 - 31
6-8PM
REGISTRATION REQUIRED
A step by step guide on how to change your sprinklers from spray to drip. We will take you through how to retrofit an existing sprinkler zone to drip or add another zone for drip. Topics covered include how to decide where Drip Irrigation is better than Spray watering, understanding the basic principles of drip applied water, and how to design and layout a drip system. Get a jump on this gardening season by retrofitting your sprinkler system early spring while plants are still dormant. Special fee covers drip tool and some emitters. Co-sponsored with Lifelong Learning. Members pay $89 + sp fee; register for section 002.


{% extends "public/base2.html" %} {% block title %}Folio{% endblock %} {% block css %} {% endblock %} {% block favicon %}{% endblock %} {% block content %}
“A map tells you where you’ve been, where you are, and where you’re going in a sense, it’s three tenses in one”
Peter Greenaway
Tomorrow River Brown Trout Nelsonville, Wisconsin Zoom
Upper Chaffee Creek State Fishery Area Dakota, Wisconsin Zoom
Upper Mill Creek Early Spring Beadhead Brown Trout Zoom
Bois Brule River Lake Superior Fall Run Steelhead Zoom
Little Carp River, Porcupine Mountains, U.P. LINK HERE
Oconto River Lake Michigan Fall Run Brown Zoom
Brown Trout Upper Tomorrow River Nelsonville, Wisconsin LINK HERE
Headwaters Upper West Branch of the White River LINK HERE
Kewaunee River Lake Michigan Spring Run Steelhead LINK HERE
Bois Brule River Lake Superior Spring Run Steelhead LINK HERE
LINK HERE


I am the insignificant nibble on the almighty servers of GitHub!
Java - 3 years; HTML - 2 years; C - 8 months; x64 NASM - 12 days; English - whole life; Japanese - 6 months.


will_deutsch_judaism_jews_jewish_sukkah_sukkot.jpg http://store.notesfromthetribe.com/product/jewish-art-8-5-x11-sukkah-print
According to Ariela Pelaia, professional Jewish Educator and ‘Judaism Guide’ on About.com:
‘A sukkah usually has at least two and a half sides, which can be constructed of any material so long as the sides are secure and don’t flap in the wind. The roof must be made of natural, unprocessed materials that have grown in the ground - such as tree branches, bamboo poles or even wood that’s been shaped into planks. In addition, the roof should be left open so that people inside the sukkah can see the sky.’
This also describes at least half of the apartments I’ve rented in Los Angeles.
At least they were rent controlled…..


CURLOPT_SSL_VERIFYPEER explained
NAME
CURLOPT_SSL_VERIFYPEER - verify the peer's SSL certificate
SYNOPSIS
#include <curl/curl.h>
CURLcode curl_easy_setopt(CURL *handle, CURLOPT_SSL_VERIFYPEER, long verify);
DESCRIPTION
Pass a long as parameter to enable or disable.
This option determines whether curl verifies the authenticity of the peer's certificate. A value of 1 means curl verifies; 0 (zero) means it doesn't.
When negotiating a TLS or SSL connection, the server sends a certificate indicating its identity. Curl verifies whether the certificate is authentic, i.e. that you can trust that the server is who the certificate says it is. This trust is based on a chain of digital signatures, rooted in certification authority (CA) certificates you supply. curl uses a default bundle of CA certificates (the path for that is determined at build time) and you can specify alternate certificates with the CURLOPT_CAINFO option or the CURLOPT_CAPATH option.
When CURLOPT_SSL_VERIFYPEER is enabled, and the verification fails to prove that the certificate is authentic, the connection fails. When the option is zero, the peer certificate verification succeeds regardless.
Authenticating the certificate is not enough to be sure about the server. You typically also want to ensure that the server is the server you mean to be talking to. Use CURLOPT_SSL_VERIFYHOST for that. The check that the host name in the certificate is valid for the host name you're connecting to is done independently of the CURLOPT_SSL_VERIFYPEER option.
WARNING: disabling verification of the certificate allows bad guys to man-in-the-middle the communication without you knowing it. Disabling verification makes the communication insecure. Just having encryption on a transfer is not enough as you cannot be sure that you are communicating with the correct end-point.
NOTE: even when this option is disabled, depending on the used TLS backend, curl may still load the certificate file specified in CURLOPT_CAINFO. curl default settings in some distributions might use quite a large file as a default setting for CURLOPT_CAINFO, so loading the file can be quite expensive, especially when dealing with many connections. Thus, in some situations, you might want to disable verification fully to save resources by setting CURLOPT_CAINFO to NULL - but please also consider the warning above!
DEFAULT
By default, curl assumes a value of 1.
PROTOCOLS
All TLS based protocols: HTTPS, FTPS, IMAPS, POP3S, SMTPS etc.
EXAMPLE
CURL *curl = curl_easy_init(); if(curl) { curl_easy_setopt(curl, CURLOPT_URL, "https://example.com"); /* Set the default value: strict certificate check please */ curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L); curl_easy_perform(curl); }
AVAILABILITY
RETURN VALUE
Returns CURLE_OK if the option is supported, and CURLE_UNKNOWN_OPTION if not.
SEE ALSO
CURLOPT_SSL_VERIFYHOST, CURLOPT_PROXY_SSL_VERIFYPEER, CURLOPT_PROXY_SSL_VERIFYHOST, CURLOPT_CAINFO
This HTML page was made with roffit.


"I may be Irish but I'm not stupid" — Joe Biden's latest gaffe
by IrishCentral Staff“I may be Irish but I’m not stupid.”
Former Vice President Joe Biden, who is well known for his off-the-cuff remarks and slips of the tongue, recently made a controversial comment about his Irish heritage.
The Irish American 2020 Democrat candidate reportedly made the cringe-worthy remark to a crowd in Iowa, JOE.ie reports.
Read More: Trump beats Biden when it comes to mangling his words
According to John Mulholland, Editor of The Guardian US, Biden told the audience: "I may be Irish, but I'm not stupid."
Mulholland, who is originally from Dublin, noted in his tweet: "Wonder what Irish people (like me) would make of that."
Unfortunately, it’s not the first time Biden has committed this verbal gaffe. He made the same exact comment while speaking to Senator Lindsey Graham in 2015.
Read More: Joe Biden is a touchy-feely, old-style Irish politician - get used to him
Biden, who can trace his Irish roots back to Louth and Derry on his mother’s side and also has Irish lineage on his father’s side, has previously made comments expressing pride in his Irish heritage.
The 77-year-old Irish American has adopted the slogan “No Malarkey!” for his campaign. The word malarkey, meaning “nonsense”, is thought to be of Irish origin but etymologists disagree on its true origin.


Curated replications of the Reproducibility Project: Psychology have now been integrated into our searchable table on our home page (search "RPP" [100 replications]).
Newsletter Sign Up
Please sign up below to receive the Curate Science Newsletter to be automatically notifed about news and updates. See past announcements.
Contact:
<EMAIL_ADDRESS>Western University
1151 Richmond St
London, Ontario, CANADA, N6A 3K7
*Thanks to Felix Schönbrodt who is currently hosting CurateScience.org


Most of the time itchiness has an obvious explanation, such as dry skin. But seemingly unwarranted itching can be an early sign of cancer, including lymphoma and leukemia, particularly when associated with a low-grade fever. A diffuse itching, caused by the accumulation of substances normally broken down in the liver, may also be the first sign of liver disease.
Therefore itching all over your skin may indicate the need for a thorough medical checkup. If it is a sudden onset, particularly after you begin a new medicine, notify your doctor immediately before continuing to take it. The itching may be an early sign of an allergic reaction. If this is the case, a second dose could be life-threatening.


Saint Lucian named captain of Windies U19 cricket team
by SNO Staff(SNO) – Kimani Melius of Saint Lucia has been named the captain of the West Indies U19 team for the ICC 2020 Cricket World Cup in South Africa.
Cricket West Indies announced the 15-member squad on Monday.
Sixteen Teams from around the globe will participate in ICC U19 World Cup.
The West Indies team will aim to recapture the ICC U19 World Cup trophy that it won in 2016.
The ICC U19 Cricket World Cup which will take place from January 17 to February 9.
Head coach of West Indies U19 Head Coach Graeme West congratulated the team.
“I would like to congratulate the fifteen players selected to represent the West Indies in both the upcoming U19 Tri-Series and the ICC U19 Cricket World Cup,” he said. “Everything we have been working on over the last twelve months has been designed to prepare the team for the opening World Cup games against Australia and England on January 18 and 20.”
Melius is a right-hand batsman.
He has played for West Indies B, West Indies Under-19s, Windward Islands and Windward Islands Under-19s.
He was named in the West Indies squad for the 2018 Under-19 Cricket World Cup.
The full squad consists of Kevlon Anderson, Daniel Beckford, Mathew Forde, Joshua James, Naeem Young, Antonio Morris,Ashmead Nedd,Mbeki Joseph, Leonardo Julian, Avinash Mahabirsingh, Kirk McKenzi, Ramon Simmods, Mathew Patrick, Jayden Seales- Captain Kimani Melius.
Headline News
-
Castries Mayor wants citizens to exercise their powers of arrest November 25, 2019 2:15 PM
-
Saint Lucian artiste, MonCherie reported missing in Alaska November 25, 2019 10:13 AM
-
Saint Lucia ambassador to OAS says parties in Dominica must act within rule of law November 25, 2019 9:21 AM
-
Classes resume on Monday, November 25th for schools in city center November 25, 2019 8:49 AM
-
Mayor Francis commends emergency personnel for heroic response to Thursday’s city fire November 22, 2019 1:12 PM
-
Minister discusses health financing at Global Fund meeting November 22, 2019 1:05 PM
-
Temporary closure of affected Gov’t Departments due to recent fire November 22, 2019 10:25 AM
-
Voyager building entirely gutted by massive blaze says PM Chastanet November 22, 2019 9:38 AM
-
Final phase of Sandals to Choc Road Widening Project November 22, 2019 7:12 AM


topotools module for working with topography data¶
Warning
This describes new tools to be added in Clawpack 5.2.1
This IPython notebook illustrates how to use some of the tools.
The file $CLAW/geoclaw/tests/test_topotools.py contains some tests of these tools. Looking at these test routines may also give some ideas on how to use them.
Documentation auto-generated from the module docstrings¶
GeoClaw topotools Module $CLAW/geoclaw/src/python/geoclaw/topotools.py
Module provides several functions for reading, writing and manipulating topography (bathymetry) files.
| Classes: |
|
|---|---|
| Functions: |
|
| TODO: |
|
- class clawpack.geoclaw.topotools.Topography(path=None, topo_func=None, topo_type=None, unstructured=False)¶
Base topography class.
A class representing a single topography file.
Properties: Initialization: Examples: >>> import clawpack.geoclaw.topotools as topo >>> topo_file = topo.Topography('./topo.tt3') >>> topo_file.plot()
- X¶
Two dimensional coordinate array in x direction.
- Y¶
Two dimensional coordinate array in y direction.
- Z¶
A representation of the data as a 2d array.
- crop(filter_region)¶
Crop region to filter_region
Create a new Topography object that is identical to this one but cropped to the region specified by filter_region
TODO: - Currently this does not work for unstructured data, could in principle
- This could be a special case of in_poly although that routine could leave the resulting topography as unstructured effectively.
- delta¶
Spacing of data points.
- extent¶
Extent of the topography.
- generate_2d_coordinates(mask=True)¶
Generate 2d coordinate arrays.
- generate_2d_topo(mask=True)¶
Generate a 2d array of the topo.
- in_poly(polygon)¶
Mask points (x,y) that are not in the specified polygon.
Uses simple ray casting algorithm for speed so beware of corner cases!
Input: - polygon (list) List of points that comprise the polygon. Note that order of the points will effect if this works (positive versus negative winding order). Points should be in counter-clockwise arrangement.
Returns: - X_mask (numpy.ma.MaskedArray) Masked array of X coordinates where those points outside of the polygon have been masked.
- Y (numpy.ndarray) Coordinates in y direction in a meshgrid type of configuration.
- interp_unstructured(fill_topo, extent=None, method='nearest', delta=None, delta_limit=20.0, no_data_value=-9999, buffer_length=100.0, proximity_radius=100.0, resolution_limit=2000)¶
Interpolate unstructured data on to regular grid.
Function to interpolate the unstructured data in the topo object onto a structured grid. Utilizes a bounding box plus a buffer of size buffer_length (meters) containing all data unless extent is not None is True. Then uses the fill topography fill_topo to fill in the gaps in the unstructured data. By default this is done by masking the fill data with the extents, the value no_data_value and if proximity_radius (meters) is not 0, by a radius of proximity_radius from all grid points in the object. Stores the result in the self.X, self.Y and self.Z object attributes. The resolution of the final grid is determined by calculating the minimum distance between all x and y data with a hard lower limit of delta_limit (meters).
Note that the function scipy.interpolate.griddata does not respect masks so a call to numpy.ma.MaskedArray.compressed() must be made to remove the masked data.
Input: - fill_topo (list) - List of Topography objects to use as fill data in the projection.
- extent (tuple) - A tuple defining the rectangle of the sub-section. Must be in the form (x lower,x upper,y lower, y upper).
- method (string) - Method used for interpolation, valid methods are found in scipy.interpolate.griddata. Default is nearest.
- delta (float) - Directly set the grid spacing of the interpolation rather than determining it from the data itself. Defaults to None which causes the method to determine this value itself.
- delta_limit (float) - Limit of finest horizontal resolution, default is 20 meters.
- no_data_value (float) - Value to use if no data was found to fill in a missing value, ignored if method = ‘nearest’. Default is -9999.
- buffer_length (float) - Buffer around bounding box, only applicable when extent is None. Default is 100.0 meters.
- proximity_radius (float) - Radius every unstructured data point used to mask the fill data with. Default is 100.0 meters.
- resolution_limit (int) - Limit the number of grid points in a single dimension. Raises a ValueError if the limit is violated. Default value is 2000.
Sets this object’s unstructured attribute to False if successful.
- make_shoreline_xy(sea_level=0)¶
Returns an array shoreline_xy with 2 columns containing x and y values for all segements of the shoreline (defined to be the contour where self.z = sea_level) separated by [nan,nan] pairs. This allows all shorelines to be quickly plotted via:
>>> plot(shoreline_xy[:,0], shoreline_xy[:,1])
The shoreline can be saved as a binary .npy file via:
>>> numpy.save(filename, shoreline_xy)
which is much smaller than the original topography file. Reload via:
>>> shoreline_xy = numpy.load(filename)
- plot(axes=None, region_extent=None, contours=None, coastlines=True, limits=None, cmap=None, add_colorbar=True, fig_kwargs={})¶
Plot the topography.

Stores the resulting data in one of the sets of x, y, and z or X, Y, and Z.
Input: - path (str) file to read, or url
- topo_type (int)
- unstructured (bool)
- mask (bool)
- filter_region (tuple)
The first three might have already been set when instatiating object.
- read_header()¶
Read in header of topography file at path.
If a value returns numpy.nan then the value was not retrievable. Note that this routine can read in headers whose values and labels are swapped.
- replace_no_data_values(method='fill')¶
Replace no_data_value with other values as specified by method.
self.no_data_value
Input: method can be one of:
- fill - Fill in all no_data_value locations with value
- nearest - Fill in no_data_value locations with average of nearest neighbors.
- replace_values(indices, value=nan, method='fill')¶
Replace the values at indices by the specified method
Methods: - “fill”
- “nearest”
- smooth_data(indices, r=1)¶
Filter topo data at indices by averaging surrounding data.
Surrounding data is considered within the ball of radius r in the inf-norm. Acts as a low-band pass filter and removes oscillatory data.
Input: - indices (list)
- r (int)
Output: None
- write(path, no_data_value=None, topo_type=None, masked=True)¶
Write out a topography file to path of type topo_type.
Writes out a topography file of topo type specified with topo_type or inferred from the output file’s extension, defaulting to 3, to path from data in Z. The rest of the arguments are used to write the header data.
- x¶
One dimensional coorindate array in x direction.
- y¶
One dimensional coordinate array in y direction.
- z¶
A representation of the data as an 1d array.
- clawpack.geoclaw.topotools.create_topo_func(loc, verbose=False)¶
Given a 1-dimensional topography profile specfied by a set of (x,z) values, create a lambda function that when evaluated will give the topgraphy at the point (x,y). (The resulting function is constant in y.)
Example: >>> f = create_topo_func(loc) >>> b = f(x, y)
Input: loc (list) - Create a topography file with the profile denoted by the tuples inside of loc. A sample set of points are shown below. Note that the first value of the list is the x location and the second is the height of the topography.
This figure doesn’t show up properly in Sphinx docs...
- clawpack.geoclaw.topotools.determine_topo_type(path, default=None)¶
Using the file suffix of path, attempt to deterimine the topo type.
Input: - path (string) - Path to the file. Can include archive extensions (they will be stripped off).
- default (object) - Value returned if no suitable topo type was determined. Default is None.
returns integer between 1-3 or default if nothing matches.
- clawpack.geoclaw.topotools.fetch_topo_url(url, local_fname=None, force=None, verbose=False, ask_user=False)¶
DEPRECATED: Use clawpack.geoclaw.util.get_remote_file instead (see note below).
Replaces get_topo function.
Download a topo file from the web, provided the file does not already exist locally.
Input: - url (str) URL including file name
- local_fname (str) name of local file to create. If local_fname == None, take file name from URL
- force (bool) If False, prompt user before downloading.
For GeoClaw examples, some topo files can be found in `http://www.geoclaw.org/topo`_ See that website for a list of archived topo datasets.
If force==False then prompt the user to make sure it’s ok to download,
If force==None then check for environment variable CLAW_TOPO_DOWNLOAD and if this exists use its value. This is useful for the script python/run_examples.py that runs all examples so it won’t stop to prompt.
This routine has been deprecated in favor of clawpack.geoclaw.util.get_remote_file. All the functionality should be the same but calls the other routine internally.
- clawpack.geoclaw.topotools.get_topo(topo_fname, remote_directory, force=None)¶
DEPRECATED: Use clawpack.geoclaw.util.get_remote_file instead
Download a topo file from the web, provided the file does not already exist locally.
remote_directory should be a URL. For GeoClaw data it may be a subdirectory of http://www.clawpack.org/geoclaw/topo See that website for a list of archived topo datasets.
If force==False then prompt the user to make sure it’s ok to download, with option to first get small file of metadata.
If force==None then check for environment variable CLAW_TOPO_DOWNLOAD and if this exists use its value. This is useful for the script python/run_examples.py that runs all examples so it won’t stop to prompt.
- clawpack.geoclaw.topotools.swapheader(inputfile, outputfile)¶
Swap the order of key and value in header to value first.
Note that this is a wrapper around functionality in the Topography class.
- clawpack.geoclaw.topotools.topo1writer(outfile, topo, xlower, xupper, ylower, yupper, nxpoints, nypoints)¶
Function topo1writer will write out the topofiles by evaluating the function topo on the grid specified by the other parameters.
Assumes topo can be called on arrays X,Y produced by numpy.meshgrid.
Output file is of “topotype1,” which we use to refer to a file with (x,y,z) values on each line, progressing from upper left corner across rows, then down.
- clawpack.geoclaw.topotools.topo2writer(outfile, topo, xlower, xupper, ylower, yupper, nxpoints, nypoints, nodata_value=-99999)¶
Write out a topo type 2 file by evaluating the function topo.
This routine is here for backwards compatibility and simply creates a new topography object and writes it out.
- clawpack.geoclaw.topotools.topo3writer(outfile, topo, xlower, xupper, ylower, yupper, nxpoints, nypoints, nodata_value=-99999)¶
Write out a topo type 3 file by evaluating the function topo.
This routine is here for backwards compatibility and simply creates a new topography object and writes it out.


Road accidents caused by road users – police 21 Nov 2019, 06:54 by Staff Reporter Home \ National \ Road accidents caused by road users – police - New Era Live


FAQ
General Questions
Questions about how to use Eyebrowse
What is Eyebrowse?
Eyebrowse is a social web browsing tool. It allows you to pick websites that you consider like
public spaces in real life and makes you publicly visible on them. Just like in real life,
you can bump into friends, chat with others, and see what others are doing while browsing the web.
The tool is made up of a website where you have a profile and you can view other people's eyebrowse history,
as well as a Chrome browser plugin where you can see, while you're browsing the parts of the web
you consider public, the other people
that are on the same webpage as you and chat or leave comments on any pages.
Why would I use Eyebrowse?
There are a lot of fun and interesting uses and opportunities that Eyebrowse can provide.
First, you can now have discussions and leave notes on any webpage, not just the ones that have
those features enabled. You can get a picture of your own browsing habits as well as how other people
in the world are browsing the web, all in real time. For instance, you could discover where crowds are
congregating on the web or find some well-trodden paths. There are so many possibilities, which is why
we have released an
API for you to use if you are interested.
You can download your own data or the
entire Firehose and uncover interesting findings or build cool visualizations. You can even build a new app
that connects to the Eyebrowse API. An additional benefit to contributing your own data is that you
help researchers working on important problems related to information retrieval, social
computing, and human-computer interaction.
What's your motivation for building Eyebrowse?
We have built Eyebrowse for many reasons.
First, we're really interested in the possibilities for social
interaction, sharing, and content discovery that Eyebrowse can provide.
We also think that there is a lot of opportunity in being able to visualize the paths and ebbs and flows of
traffic on the web.
Second, in building this system, we wish to demonstrate that it is possible to have a system
that asks users permission before tracking them instead of indiscriminately tracking all websites
that users go to, including the ones that they prefer to keep private. We believe that there are some
websites that users do not mind being tracked on and others where they do mind, but it is currently cumbersome
or difficult for users to take control. This system is a proof-of-concept to show that browser tracking can be
permission-based without being annoying or tiresome for users.
Finally, we hope by releasing the data that Eyebrowse collects, we can help researchers, data scientists, software engineers,
and designers learn and create interesting and useful things. We think that areas like quantified self,
information retrieval, social computing, human-computer interaction, and many more could benefit from the data we collect.
How much of my browsing data does Eyebrowse collect?
Eyebrowse only collects data from the domains that you give it permission to collect. You give
Eyebrowse permission when you add a domain to your sharelist. After you've done that, anytime you
visit a webpage that is a part of that domain, you will show up as present on that domain within
the Eyebrowse Chrome plugin, and your Eyebrowse feed will register a visit to that webpage.
Is the data I put on my Eyebrowse feed public?
Yes. At this moment, all the data that goes to your Eyebrowse is publicly available, as in any person
can create an Eyebrowse account and see it. Likewise, your data will show up in the public API
and in the link to the Eyebrowse firehose from your home page. Only add domains to your sharelist
that you are comfortable sharing publicly.
Exactly what fields are collected with each visit?
From every visit that is collected from Eyebrowse, we collect the time you entered the page and the time
you leave the page. From the webpage, we store the url, the domain,
the title, and the favIcon of the domain. Finally, the visit is associated with your Eyebrowse account.
We don't store any other information such as IP address or referrer. We also don't track the clicks that you
make while on a shared domain.
Is it possible for me to use Eyebrowse anonymously?
It is possible for you to create an account and not use a username or profile image that links back to you or reveal
your email. However, it is often easy to reveal your identity from your online traces without realizing it.
Therefore, we can not guarantee that your anonymity will be preserved if you are sharing any domains.
We recommend that you only share the domains that you are comfortable associating with yourself.
Can I delete my data on Eyebrowse?
If you ever want to delete your entire account or remove certain Eyebrowse history items from your Eyebrowse
feed, you can do so from the Eyebrowse website. Just click on the down arrow to the right of the visit on your feed
and one of the options will be deletion.
Once you do that, there is no undo-ing.
The data will be permanently removed from Eyebrowse
and will not be on the Eyebrowse website or appear in the API.
However, we cannot guarantee that your data will be entirely gone as any people collecting information
in real-time from our API could have potentially already downloaded that data before we went ahead and deleted it.
How do I add a website to my sharelist?
There are several ways you can add a website to your sharelist. The first way is by simply browsing the
web with the Eyebrowse Chrome extension on. Occasionally, the plugin will ask you via a small window in the top
right of your browser window whether you would like to add the current domain you are on to your sharelist
If you click yes, that current visit and future visits to webpages within that domain will be logged to
Eyebrowse. If you click no, the extension will not ask you about that domain again.
If at any time you want to share the domain you are currently on but you didn't receive a prompt,
you can click on the Eyebrowse extension logo and then click "Share this domain".
Finally, you can go to Settings in the top right corner of the Eyebrowse website and then click on Sharelist.
From here, you can add and delete items that are on your sharelist.
How do I delete a website from my sharelist?
If you go to Settings in the top right corner of the Eyebrowse website and then click on Sharelist, you
can see all the websites that are currently in your sharelist. Click the red X button in order to
remove an item from your sharelist.
Can I mark a visit to a webpage without putting it on my sharelist
Yes, you can. If you are currently on a webpage that's not on your sharelist, but you want to mark your
current visit just this one time without putting the webpage onto your sharelist, simply click "Mark a
visit to this page" from within the Eyebrowse Chrome extension.
How do I temporarily turn off Eyebrowse?
If, while you're browsing the web, decide that you want to go incognito and stop Eyebrowse
from logging any of your shared domains or showing you as online on Eyebrowse or any webpage,
you can go incognito. Simply click the "Eyebrowse: On" link from the Chrome
extension to toggle Eyebrowse on or off. When incognito mode is on, the eye in the Chrome extension icon should look
closed. You can still mark a visit to a particular site, publish a Note, or post a Chat message
while you're incognito.
Don't forget to toggle Eyebrowse back on when you're ready to join the public!
What's the difference between a Note and a Chat message and how do I post one?
You can post either a Note or a Chat message anytime you are browsing the web. Simply click on the Eyebrowse
Chrome extension icon, and there are input text fields for both. You can also see the previous Notes
on the Bulletin Board and
Chat messages in the Chat Room that were posted to that page before you.

When you publish a Note to a webpage, it will appear both in
your feed on the Eyebrowse website as well as in the browser extension when you are on that webpage.
When you post a Chat message, it only posts to the webpage.
So when you are have a conversation, for instance in real-time with other people on a webpage, it would make
more sense to post Chat messages. When you want to broadcast a statement to your followers about a webpage
like you would a Twitter or Facebook post, it would make more sense to publish a Note.
Is it possible to delete or edit Notes or Chat messages?
Yes! If there are some Eyebrowse visits or Notes you would really like to be deleted, there is a down-arrow to the right of
items in your feed on the website. Click and from there you can delete anything from a particular link or entire domain.
However, as explained
here, we cannot guarantee that your data is
completely gone. Currently there is no way to delete Chat messages.
Still have questions? Send an email to<EMAIL_ADDRESS>{% endblock %}


Next: ensure-directories-exist, Previous: directory, Up: Files Dictionary
probe-file
pathspec ⇒ truename
pathspec—a pathname designator.
truename—a physical pathname or nil.
probe-file tests whether a file exists.
probe-file returns false if there is no file named pathspec, and otherwise returns the truename of pathspec.
If the pathspec designator is an open stream, then probe-file produces the truename of its associated file.
If pathspec is a stream, whether open or closed, it is coerced to a pathname as if by the function pathname.
The host computer’s file system.
An error of type file-error is signaled if pathspec is wild.
An error of type file-error is signaled if the file system cannot perform the requested operation.
truename, open, ensure-directories-exist, pathname,
File System Concepts, File Operations on Open and Closed Streams,


This class represents a Method call, and has a reference to the Method to be called and the parameters to supply It's sent to the ActorRef backing the TypedActor and can be serialized and deserialized
Mix this into your TypedActor to be able to hook into its lifecycle
Mix this into your TypedActor to be able to hook into its lifecycle
Mix this into your TypedActor to be able to hook into its lifecycle
Mix this into your TypedActor to be able to intercept Terminated messages
Mix this into your TypedActor to be able to define supervisor strategy
Returns a contextual TypedActorFactory of this extension, this means that any TypedActors created by this TypedActorExtension will be children to the specified context, this allows for creating hierarchies of TypedActors.
Returns a contextual TypedActorFactory of this extension, this means that any TypedActors created by this TypedActorExtension will be children to the specified context, this allows for creating hierarchies of TypedActors. Do _not_ let this instance escape the TypedActor since that will not be thread-safe.
Returns an instance of the extension identified by this ExtensionId instance.
Returns an instance of the extension identified by this ExtensionId instance.
Returns the ActorContext (for a TypedActor) when inside a method call in a TypedActor.
Is used by Akka to instantiate the Extension identified by this ExtensionId, internal use only.
Is used by Akka to instantiate the Extension identified by this ExtensionId, internal use only.
Returns the default dispatcher (for a TypedActor) when inside a method call in a TypedActor.
Returns a contextual TypedActorFactory of this extension, this means that any TypedActors created by this TypedActorExtension will be children to the specified context, this allows for creating hierarchies of TypedActors.
Returns a contextual TypedActorFactory of this extension, this means that any TypedActors created by this TypedActorExtension will be children to the specified context, this allows for creating hierarchies of TypedActors. Do _not_ let this instance escape the TypedActor since that will not be thread-safe.
Java API
Returns an instance of the extension identified by this ExtensionId instance.
Returns an instance of the extension identified by this ExtensionId instance. Java API For extensions written in Scala that are to be used used from Java also, this method should be overridden to get correct return type.
override def get(system: ActorSystem): TheExtension = super.get(system)
Returns the canonical ExtensionId for this Extension
Returns the canonical ExtensionId for this Extension
Returns the reference to the proxy when called inside a method call in a TypedActor
Returns the reference to the proxy when called inside a method call in a TypedActor
Example:
class FooImpl extends Foo { def doFoo { val myself = TypedActor.self[Foo] } }
Useful when you want to send a reference to this TypedActor to someone else.
NEVER EXPOSE "this" to someone else, always use "self[TypeOfInterface(s)]"
Throws IllegalStateException if called outside of the scope of a method on this TypedActor.
Throws ClassCastException if the supplied type T isn't the type of the proxy associated with this TypedActor.
This represents the TypedActor Akka Extension, access to the functionality is done through a given ActorSystem.


{% extends "base.html" %} {% load compress humanize staticfiles hc_extras %} {% block title %}Add HealthWealth - healthchecks.io{% endblock %} {% block content %}
Add your custom integrations with third party services
{% if external_checks %} {% include "integrations/custom_integration_input.html" %} {% endif %}


In Steyerl’s piece, the poor image is fast and low quality. The relevance of the poor image is transient - perhaps I’m wrong, but my understanding is that memes are the most modern version of the poor image. Memes don’t last long - they’re always refreshing, always shifting, always being reedited, recirculated, reinterpretted. Memes circulate at a high speed across the globe, and they gain and lose popularity in quick flashes. Digital images with high resolution are usually considered “slow” speeds. This doesn’t always mean that they’re longer in time, but perhaps that they last longer. Feature films, for example, tend to stay within cultural memory for longer than one specific meme.


Fritillaria messanensis is a European species of flowering plant in the lily family,
native to southeastern Europe: Italy (Sicily, Calabria), Greece (incl. Crete), Albania, former Yugoslavia.
• Fritillaria messanensis subsp. gracilis (Ebel) Rix - Ionian Islands of Greece, Albania, Serbia, Croatia, Montenegro, Bosnia, Macedonia, Kosovo
• Fritillaria messanensis subsp. messanensis - Greece, Sicily, Calabria
• Fritillaria messanensis subsp. neglecta (Parl.) Nyman - Croatia, Macedonia
• Fritillaria messanensis subsp. sphaciotica (Gand.) Kamari & Phitos - Crete
Fritillaria messanensis s.l. inhabits various habitats in the Balkans:
from Submediterranean forests and scrub communities along the Adriatic coast of Dalmatia and Montenegro,
to high-mountain pastures and rocky grounds in the Dinaric Alps facing the Adriatic. It prefers limestone
occasionally ophiolitic geological substrate. In Greece, it occupies stony places Fritillaria messanensis s.l.
inhabits various habitats in the Balkans: from Submediterranean forests and scrub communities along the
Adriatic coast of Dalmatia and Montenegro, to high-mountain pastures and rocky grounds in the Dinaric Alps
facing the Adriatic. It prefers limestone, occasionally ophiolitic geological substrate. In Greece,
it occupies stony places under a dense scrub canopy, woodlands, and occasionally clearings of Pinus
or Fagus forests, usually on calcareous substrate (Kamari & Phitos 2006).
It grows on limestone and serpentinite rocks and pastures in Albania, reaching altitudes
as high as 1800 m (Jávorka 1926). In Serbia, F. gracilis grows on high-mountain limestone
rocks, rocky grounds and pastures in the Prokletije Mts, at an altitude above 1300 m.
Some significant differences in the species habitats, ranging from warm Submediterranean
to cold high-mountain, require further detailed taxonomic and molecular investigations of F.
gracilis populations in the Dinaric Alps.


bowline
Bowline is a framework for making cross platform desktop applications in Ruby, HTML and JavaScript.
If you’ve ever wished creating a desktop application was as simple as creating a Rails website, Bowline’s for you.
Bowline respects MVC, you can design your views in HTML5/CSS3 - then bind them to your Ruby models. There’s no request/response cycle - any changes in models automatically get reflected in the view.
See : http://bowlineapp.com/
Experiment on this framework:
Requirements:
* Mac OSX >=10.5 or Ubuntu —–> [I am on Ubuntu 9.04]
* Ruby 1.9 —————————–> [I use RVM to switch ruby between different version]
* Bowline gem ———————–> sudo gem install bowline
RVM
* Install RVM to manage Ruby easily, then you decide which version you will use.
OK, Now create an application in an easy...
......


public class ServiceAccountant
extends java.lang.Object
ServiceAccountant
class acts as an accountant for metrics
extracted from the request and response from a SOAP call. From
DfpHttpSender
, the method handleRequest(Message)
, or
handleResponse(String, OperationDesc, String, Message, String)
are called.| Constructor and Description |
|---|
ServiceAccountant(DfpUser user)
Constructor to set the
user of the service accountant which will
be used to record properties such as the effective client and the
environment that the request went against. |
| Modifier and Type | Method and Description |
|---|---|
long |
getLastOperationCount()
Returns the number of operations executed by the last request issued
through this service instance or
null if the last number
of operations not recorded successfully. |
java.lang.String |
getLastRequestId()
Returns the unique ID that identifies last request issued through this
service instance or
null if the last number request ID was
not recorded successfully. |
long |
getLastResponseTime()
Returns the time it took to execute the last request issued through this
service instance or
null if the last request time was not
recorded successfully. |
ServiceAccountantRecord |
getLastServiceAccountantRecord()
Returns the last
ServiceAccountantRecord handled by this
accountant. |
long |
getTotalOperationCount()
Returns the total number of operations executed by all requests issued
through this service instance.
|
long |
getTotalResponseTime()
Returns the total time it took to execute all requests issued through
this service instance.
|
long |
getTotalUnitCount()
Returns the total number of API units consumed by all requests issued
through this service instance.
|
void |
handleRequest(org.apache.axis.Message soapMessage)
Handles the request from the SOAP call by extracting the sanitized
XML from the
Message . |
ServiceAccountantRecord |
handleResponse(java.lang.String service,
org.apache.axis.description.OperationDesc operation,
java.lang.String server,
org.apache.axis.Message soapMessage,
java.lang.String faultMessage)
Handles the XML response by extracting metrics from the SOAP header,
recording those metrics to the
DfpServiceLogger.REQUEST_INFO_LOG and writing the response XML
to the DfpServiceLogger.SOAP_XML_LOG . |
void |
resetCounters()
Resets the header counters including operations, units, time, and request
Id.
|
public void resetCounters()
public long getLastResponseTime()
null
if the last request time was not
recorded successfully.public long getTotalResponseTime()
public long getLastOperationCount()
null
if the last number
of operations not recorded successfully.public long getTotalOperationCount()
public long getTotalUnitCount()
public java.lang.String getLastRequestId()
null
if the last number request ID was
not recorded successfully.public ServiceAccountantRecord getLastServiceAccountantRecord()
ServiceAccountantRecord
handled by this
accountant.ServiceAccountantRecord
public void handleRequest(org.apache.axis.Message soapMessage)
Message
. Logs the sanitized SOAP XML to the
DfpServiceLogger.SOAP_XML_LOG
logger. If the SOAP XML could
not be sanitized because of an AxisFault
or
ServiceException
thrown while being processed, it is omitted from
the logs.soapMessage
- the message from the SOAP callpublic ServiceAccountantRecord handleResponse(java.lang.String service, org.apache.axis.description.OperationDesc operation, java.lang.String server, org.apache.axis.Message soapMessage, java.lang.String faultMessage) throws javax.xml.soap.SOAPException, org.apache.axis.AxisFault
DfpServiceLogger.REQUEST_INFO_LOG
and writing the response XML
to the DfpServiceLogger.SOAP_XML_LOG
. If the XML cannot
be processed or the header map could not be extracted, this method
fails gracefully by not throwing the exceptions, but logging them in the
DfpServiceLogger.DFP_API_LIB_LOG
and returning a null
.service
- the DFP service that was reachedoperation
- the operation that Axis is currently handlingserver
- the server the call was made againstsoapMessage
- the XML response messagefaultMessage
- the fault messageServiceAccountantRecord
of the response or null
if the message could not be processed.javax.xml.soap.SOAPException
- if the SOAP XML could not be extracted to a stringorg.apache.axis.AxisFault
- if the SOAP header could not be extracted


|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
public interface IoRelativeReader
Provides relative read access to a sequence of bytes.
| Method Summary | |
|---|---|
byte |
get()
Gets a byte and advances the reader. |
void |
get(IoBuffer bb)
Gets enough bytes to fill the IoBuffer and advances the reader. |
char |
getChar()
Gets a char and advances the reader. |
double |
getDouble()
Gets a double and advances the reader. |
float |
getFloat()
Gets a float and advances the reader. |
int |
getInt()
Gets an int and advances the reader. |
long |
getLong()
Gets a long and advances the reader. |
int |
getRemaining()
Gets the number of remaining bytes that can be read. |
short |
getShort()
Gets a short and advances the reader. |
boolean |
hasRemaining()
Checks if there are any remaining bytes that can be read. |
ByteOrder |
order()
Gets the order of the bytes. |
void |
skip(int length)
Advances the reader by the given number of bytes. |
ByteArray |
slice(int length)
Creates an array with a view of part of this array. |
| Method Detail |
|---|
int getRemaining()
boolean hasRemaining()
void skip(int length)
ByteArray slice(int length)
ByteOrder order()
byte get()
byte
and advances the reader.
void get(IoBuffer bb)
IoBuffer
and advances the reader.
short getShort()
short
and advances the reader.
int getInt()
int
and advances the reader.
long getLong()
long
and advances the reader.
float getFloat()
float
and advances the reader.
double getDouble()
double
and advances the reader.
char getChar()
char
and advances the reader.
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


Health and Safety - Postit note saver
Health and Safety - Postit note saver
Health
How well do you belive the last iteration went?
Safety
How safe do you feel in this meeting place?
5 – No Problem, I’ll talk about anything
4 – I’ll talk about almost anything; a few things might be hard
3 – I’ll talk about some things, but others will be hard to say
2 – I’m not going to say much, I’ll let others bring up issues
1 – I’m really not comfortable
Login anonymously


About
This is some random stuff to fill up for article 1 This is some random stuff to fill up for article 1
This is some random stuff to fill up for article 1 This is some random stuff to fill up for article 1
This is some random stuff to fill up for article 1 This is some random stuff to fill up for article 1
This is some random stuff to fill up for article 1 This is some random stuff to fill up for article 1
This is some random stuff to fill up for article 1 This is some random stuff to fill up for article 1
Products
This is some random stuff to fill up for article 1 This is some random stuff to fill up for article 1
This is some random stuff to fill up for article 1 This is some random stuff to fill up for article 1
This is some random stuff to fill up for article 1 This is some random stuff to fill up for article 1
This is some random stuff to fill up for article 1 This is some random stuff to fill up for article 1
This is some random stuff to fill up for article 1 This is some random stuff to fill up for article 1
Portfolio
This is some random stuff to fill up for article 1 This is some random stuff to fill up for article 1
This is some random stuff to fill up for article 1 This is some random stuff to fill up for article 1
This is some random stuff to fill up for article 1 This is some random stuff to fill up for article 1
This is some random stuff to fill up for article 1 This is some random stuff to fill up for article 1
This is some random stuff to fill up for article 1 This is some random stuff to fill up for article 1
Portfolio
Tables
Random attribute
Random


This page contains some notes on the expected functionality that will be included in future iterations of Slug. Bear in mind that development is a part-time activity, with a priority set by what problems/features I either find interesting or necessary for my own projects.
Nagging is a good way to get features implemented. If I know someone is using the code, that's good motivation.
Of course an even better way to move things forward is to code it yourself and then share! If there's enough interest, perhaps the project can be moved to Sourceforge.
alpha-3
"The Behaviour Release"Slug isn't very well behaved. It needs to:
User-Agent
header
The following additional features will be useful:
rdfs:seeAlso
links to find data, by
allowing pluggable link discoveryalpha-4
"For Control Freaks"Slug needs to be easier to control. The Monitor component should be made pluggable to allow for a GUI or Web Application to be used to control the Scutter.
beta-1
"Testing, Testing"Concentrate on additional unit and functional testing. Aim to have stabilised APIs, particular around the component model to aim for a stable 1.0 release.


{% extends "base.html" %} {% load staticfiles i18n %} {% block title %} Run FAE {% endblock %} {% block content %}
The Functional Accessibility Evaluator (FAE) evaluates a website or a single web page based on the W3C Web Content Accessibility Guidelines external link (opens in new window) (WCAG) 2.0 Level A and AA requirements.
FAE runs a browser emulator that runs automated checks for known accessibility issues (violations of WCAG standards. FAE can check and monitor the compliance of multiple pages (crawl a website) automatically by following links from a starting page skip to #check-website (requires login). Or it can audit a single web page skip to #check-url (for users that don't want to login).
Compliance with WCAG 2 Level AA is required by most accessibility laws (Section 508, the European Accessibility Act, the EU Web Accessibility Directive, the Equality Act of 2010 in the UK, etc.) and has been used as the de facto standard by U.S. Federal Courts when determining compliance with the ADA, the FHA, ACA and similar laws requiring digital accessibility of websites and applications.
You must have a user account to evaluate a website.
{% if self_registration_enabled %}Register for a free user account to gain access to these additional features:
{% endif %}Use the following form or AInspector WCAG external link (opens in new window) to evaluate a single web page without creating an account:
Warning: No automated tool can detect all known acessibility issues. In testing of automated accessibility auditing tools by the UK Government's Accessibility Team external link (opens in new window), FAE was found to detect more barriers and potential barriers than any other tool tested but even then it only detected 50%. Additionaly, there can be multiple ways to address barriers that this tool may not be able to detect. FAE should be used in conjunction with human and manual auditing and remediation efforts, not as a substitute for them.
{% comment %}{% include "accounts/support_information.html" %}{% endcomment %} {% endblock %} {% block javascript %} {% endblock %}


January 2018 Coordinated Project @ ILLC
Scroll down for a detailed description of this project's motivation and structure.
If you are interested in this project, please contact the instructor -- Shane Steinert-Threlkeld -- by e-mail: S.N.M.Steinert-Threlkeld (at) uva.nl.
In this project, students will develop tools and run (computational) experiments to test the hypothesis that semantic universals arise because expressions satisfying them are easier to learn than those that do not.
A semantic universal is a property of meaning shared by (almost) all natural languages (possibly conditional on the languages having additional properties). Because languages vary quite a bit, when one finds a universal, one naturally wonders whether there's an explanation for it. Why do all languages have this semantic property? We are interested in exploring the following hypothesis.
Hypothesis: Semantic universals arise because they make meaning systems easier to learn.
Of course, the hypothesis can only be supported or refuted when a model of learning a semantic system has been specified. Thus, the hypothesis naturally gives rise to a challenge.
Challenge: Provide a model of learning which makes good on the Hypothesis (at least, for some semantic universals).
In recent work, Steinert-Threlkeld and Szymanik attempt to meet the Challenge by training recurrent neural networks to learn the meanings of quantifiers, a domain where many semantic universals have been posited. They use this framework to explain universals like monotonicity and quantity. The monotonicity universal works as follows. Consider the following two sentences.
Sentence (1) entails sentence (2): the former cannot be true without the latter being true. Notice that all we have done is replaced the term "smoke cigarettes" with the strictly more general term "smoke". Also notice that the inference pattern holds for any choice of the restrictor (not just "French people") and pairs of nuclear scope that stand in the same specific-general relation. Because of this, we say that the quantifier "many" is upward monotone. If "many" is replaced by "few", the inference pattern reverses. "few" is downward monotone. The proposed universal then states:
Monotonicity: All simple determiners are monotone.
In the paper, neural networks are trained to learn monotone and non-monotone quantifiers and it is shown that the former are learned significantly faster than the latter. We also show that this pattern holds for another universal called Quantity, which states that quantifiers only care about the sizes of sets, and not the identity of objects or their position in a structure. (This is related to a conception of logicality.)
In this project, students will develop new tools and run more experiments in order to further develop the explanation of semantic universals in terms of learnability. They will be doing original research that could become (part of) publications. Existing code as well as access to computing infrastructure will be provided. Possible topics that can be addressed are:
The class will meet 3 times a week in the four weeks from January 8 to February 2. We will provide necessary background in the first two weeks, then transition into coding / experimenting sessions in the last two weeks. The course should be mostly self-contained, though some pre-requisites are listed.
Week 1: theoretical background on semantic universals and quantifiers (possibly color as well)
Week 2: background on training neural networks, tutorials on how to run your own experiments by modifying provided code
Week 3: run experiments! We will have in-class coding sessions for support and question answering.
Week 4: finish experiments; write up the results and deliver short presentation
Working knowledge of Python will be very valuable. Knowledge of specific libraries (Numpy, TensorFlow/Keras) will be helpful, but can be learned on the fly. While we will cover neural networks and their training and evaluation in the second week, familiarity with those topics will also help.
Students will be conducting their own (computational) experiments. They will be expected to produce a short write-up (~5 pages) of at least one experimental result, explaining the motivation for their experiment and what they found. On the final day of class, there will be short presentations of results and discussion.
Here we include both reading and coding resources.


tablelist::addDateMentry
Commandtablelist::addTimeMentry
Commandtablelist::addDateTimeMentry
Commandtablelist::addFixedPointMentry
Commandtablelist::addIPAddrMentry
Commandtablelist::addIPv6AddrMentry
CommandThe multi-entry package Mentry is a library extension for Tcl/Tk version 8.0 or higher, written in pure Tcl/Tk code. Its download location is
http://www.nemethi.de
Starting with version 3.0, the Mentry distribution provides not only the package Mentry, but also its tile-based equivalent Mentry_tile, which enables the theme-specific appearance of mentry widgets; this package requires Tcl/Tk 8.4 or higher and tile 0.6 or higher.
Tablelist supports interactive cell editing with the aid of the mentry
widgets of type "Date"
, "Time"
,
"DateTime
, "FixedPoint"
,
"IPAddr"
, and "IPv6Addr"
. The steps needed
for using one of these widgets for editing the cells of a given column are as
follows:
columnconfigure
subcommand to set the given column's -editable
option to true
and its -editwindow
option to
the value returned by the command mentioned above. (These options are
supported at cell level, too, with the aid of the cellconfigure
subcommand.)tablelist::addDateMentry
Commandtablelist::addDateMentry
- Register the mentry widget of
type "Date"
for interactive cell editingtablelist::addDateMentry format separator ?-gmt? ?name?
mentry::dateMentry
command from the Mentry (or
Mentry_tile) package for interactive cell editing in tablelist
widgets. The format
and
separator
arguments have the same meanings as in the
mentry::dateMentry
command. If the
-gmt
argument is present then both the internal clock
value and its external date representation in the mentry widget will be
viewed as Greenwich Mean Time, otherwise as local time. The second
optional argument specifies the name to be used for the mentry widget as
the value of the -editwindow
column or
cell configuration option. It may be any string that is different
from entry
, text
,
spinbox
, checkbutton
,
ttk::entry
, ttk::spinbox
,
ttk::combobox
, and
ttk::checkbutton
. The default is
dateMentry
. The command returns its
name
argument.name
as the value
of its -editwindow
option must contain as internal cell
values date information in seconds (displayed with the aid of a command
given by the -formatcommand
column configuration option). The finishediting
subcommand of the Tcl command associated with the tablelist widget will
retrieve the contents of the embedded window used for interactive cell
editing by invoking the mentry::getClockVal
command. The value returned by this command (a clock value in seconds
or one of the error strings "EMPTY"
, "BAD"
,
"BAD_DATE"
, or "BAD_YEAR"
) will be passed to the
script corresponding to the -editendcommand
tablelist configuration option (if any), as its last argument. If
this value is one of the above error strings then the script should reject
the mentry's contents by invoking the rejectinput
subcommand.tablelist::addTimeMentry
Commandtablelist::addTimeMentry
- Register the mentry widget of
type "Time"
for interactive cell editingtablelist::addTimeMentry format separator ?-gmt? ?name?
mentry::timeMentry
command from the Mentry (or
Mentry_tile) package for interactive cell editing in tablelist
widgets. The format
and
separator
arguments have the same meanings as in the
mentry::timeMentry
command. If the
-gmt
argument is present then both the internal clock
value and its external time representation in the mentry widget will be
viewed as Greenwich Mean Time, otherwise as local time. The second
optional argument specifies the name to be used for the mentry widget as
the value of the -editwindow
column or
cell configuration option. It may be any string that is different
from entry
, text
,
spinbox
, checkbutton
,
ttk::entry
, ttk::spinbox
,
ttk::combobox
, and
ttk::checkbutton
. The default is
timeMentry
. The command returns its
name
argument.name
as the value
of its -editwindow
option must contain as internal cell
values time information in seconds (displayed with the aid of a command
given by the -formatcommand
column configuration option). The finishediting
subcommand of the Tcl command associated with the tablelist widget will
retrieve the contents of the embedded window used for interactive cell
editing by invoking the mentry::getClockVal
command. The value returned by this command (a clock value in seconds
or one of the error strings "EMPTY"
or "BAD"
)
will be passed to the script corresponding to the -editendcommand
tablelist configuration option (if any), as its last argument. If
this value is one of the above error strings then the script should reject
the mentry's contents by invoking the rejectinput
subcommand.tablelist::addDateTimeMentry
Commandtablelist::addDateTimeMentry
- Register the mentry widget
of type "DateTime"
for interactive cell editingtablelist::addDateTimeMentry format dateSeparator timeSeparator ?-gmt? ?name?
mentry::dateTimeMentry
command from the Mentry (or
Mentry_tile) package for interactive cell editing in tablelist
widgets. The format
,
dateSeparator
, and timeSeparator
arguments have the same meanings as in the
mentry::dateTimeMentry
command. If the
-gmt
argument is present then both the internal clock
value and its external date & time representation in the mentry widget
will be viewed as Greenwich Mean Time, otherwise as local time. The
second optional argument specifies the name to be used for the mentry
widget as the value of the -editwindow
column or
cell configuration option. It may be any string that is different
from entry
, text
,
spinbox
, checkbutton
,
ttk::entry
, ttk::spinbox
,
ttk::combobox
, and
ttk::checkbutton
. The default is
dateTimeMentry
. The command returns its
name
argument.name
as the value
of its -editwindow
option must contain as internal cell
values date & time information in seconds (displayed with the aid of a
command given by the -formatcommand
column configuration option). The finishediting
subcommand of the Tcl command associated with the tablelist widget will
retrieve the contents of the embedded window used for interactive cell
editing by invoking the mentry::getClockVal
command. The value returned by this command (a clock value in seconds
or one of the error strings "EMPTY"
, "BAD"
,
"BAD_DATE"
, or "BAD_YEAR"
) will be passed to the
script corresponding to the -editendcommand
tablelist configuration option (if any), as its last argument. If
this value is one of the above error strings then the script should reject
the mentry's contents by invoking the rejectinput
subcommand.tablelist::addFixedPointMentry
Commandtablelist::addFixedPointMentry
- Register the mentry
widget of type "FixedPoint"
for interactive cell editingtablelist::addFixedPointMentry count1 count2 ?-comma? ?name?
mentry::fixedPointMentry
command from the Mentry (or
Mentry_tile) package for interactive cell editing in tablelist
widgets. The count1
, count2
,
and -comma
arguments have the same meanings as in the
mentry::fixedPointMentry
command. The second
optional argument specifies the name to be used for the mentry widget as
the value of the -editwindow
column or
cell configuration option. It may be any string that is different
from entry
, text
,
spinbox
, checkbutton
,
ttk::entry
, ttk::spinbox
,
ttk::combobox
, and
ttk::checkbutton
. The default is
fixedPointMentry_count1.count2
(e.g., fixedPointMentry_6.2
) or
fixedPointMentry_count1,count2
(e.g., fixedPointMentry_6,2
), depending on the presence
of the optional -comma
argument. The command
returns its name
argument.name
as the value
of its -editwindow
option must contain real numbers as
internal cell values. The finishediting
subcommand of the Tcl command associated with the tablelist widget will
retrieve the contents of the embedded window used for interactive cell
editing by invoking the mentry::getReal
command.
The value returned by this command (a real number or the error string
"EMPTY"
) will be passed to the script corresponding to the
-editendcommand
tablelist configuration option (if any), as its last argument. If
this value is the above error string then the script should reject the
mentry's contents by invoking the rejectinput
subcommand.tablelist::addIPAddrMentry
Commandtablelist::addIPAddrMentry
- Register the mentry widget of
type "IPAddr"
for interactive cell editingtablelist::addIPAddrMentry ?name?
mentry::ipAddrMentry
command from the Mentry (or
Mentry_tile) package for interactive cell editing in tablelist
widgets. The optional argument specifies the name to be used for the
mentry widget as the value of the -editwindow
column or
cell configuration option. It may be any string that is different
from entry
, text
,
spinbox
, checkbutton
,
ttk::entry
, ttk::spinbox
,
ttk::combobox
, and
ttk::checkbutton
. The default is
ipAddrMentry
. The command returns its
name
argument.name
as the value
of its -editwindow
option must contain IP addresses as
internal cell values. The finishediting
subcommand of the Tcl command associated with the tablelist widget will
retrieve the contents of the embedded window used for interactive cell
editing by invoking the mentry::getIPAddr
command. The value returned by this command (an IP address or the
error string "EMPTY"
) will be passed to the script
corresponding to the -editendcommand
tablelist configuration option (if any), as its last argument. If
this value is the above error string then the script should reject the
mentry's contents by invoking the rejectinput
subcommand.tablelist::addIPv6AddrMentry
Commandtablelist::addIPv6AddrMentry
- Register the mentry widget
of type "IPv6Addr"
for interactive cell editingtablelist::addIPv6AddrMentry ?name?
mentry::ipv6AddrMentry
command from the Mentry (or
Mentry_tile) package for interactive cell editing in tablelist
widgets. The optional argument specifies the name to be used for the
mentry widget as the value of the -editwindow
column or
cell configuration option. It may be any string that is different
from entry
, text
,
spinbox
, checkbutton
,
ttk::entry
, ttk::spinbox
,
ttk::combobox
, and
ttk::checkbutton
. The default is
ipv6AddrMentry
. The command returns its
name
argument.name
as the value
of its -editwindow
option must contain IPv6 addresses
as internal cell values. The finishediting
subcommand of the Tcl command associated with the tablelist widget will
retrieve the contents of the embedded window used for interactive cell
editing by invoking the mentry::getIPv6Addr
command. The value returned by this command (an IPv6 address or the
error string "EMPTY"
) will be passed to the script
corresponding to the -editendcommand
tablelist configuration option (if any), as its last argument. If
this value is the above error string then the script should reject the
mentry's contents by invoking the rejectinput
subcommand.


Files and directories can be added anywhere in the Storyteller project directory. When Storyteller is active it records these file system events and then plays them back during a playback to indicate when they occurred.
Tip: VS Code has a file explorer view of an open folder.
It is preferable to use this interface to create new files and directories than using the File
menu.
A file created using File -> New File
(or the equivalent ctrl/cmd + N
command) is not automatically added
to the Storyteller project directory and therefore isn't tracked until is is saved to the project directory. Once the new file is
saved in the Storyteller project directory (ctrl/cmd + S
) then the file contents will be added and any new changes
will be tracked.
Storyteller also tracks the moving, renaming, and deleting of files and directories. It creates events for each of these file operations that will be displayed in a playback.
Tip: The current view of the file system is always available during a playback.


Nature Can Sooth
Your Soul Easier than
You Think
Our Survival Depends
Upon Nature
Patterns in Nature