--- layout: presentation title: "The Blame Game - Tech Talk Tuesday" --- The Blame Game Tech Talk Tuesday November 20th, 2018 Blameless Postmortems Coined by John Allspaw Assume people are doing the best they can with the information they have. Create an environment where people can explain why the action made sense to them at the time. See human error as an effect of deeper systematic vulnerabilities within the organization. Dig deeper into what caused the problem. Use the 5 Whys technique. Celebrate that organizations can only improve by constantly seeking out their systematic vulnerabilities. What is Root Cause? Words matter ITIL Definition The underlying or original cause of an incident or problem. Discussion Can you we ever know "root cause"? How can we make changes that improve the future? How do we make sure we never stop learning and improving?
Tech Talk Tuesday November 20th, 2018
The underlying or original cause of an incident or problem.
Can you we ever know "root cause"?
How can we make changes that improve the future?
How do we make sure we never stop learning and improving?


{% extends "polls/base.html" %} {% block titile %}The current time{% endblock %} {% block content %}
It is now {{ current_date|date:"F j, Y" }}.


4 min read
This website was born out of my desire to try something new: web development.
Make no mistake, there is no shortage of tools that make it easy and simple to create a website, like Squarespace, Weebly, and Wordpress. I immediately discounted these as it defeated the whole point of delving into web development.
I was initially daunted by the prospect of writing an entire website, CSS and all, from scratch. After expressing these concerns to a friend, I was introduced to the notion of 'static site generation', something I have started to (possibly inaccurately) refer to as a 'templating system'. Although there are many of these services already in existence, I wanted to make my own.
This site is (at the moment) built by just one file, my build.py. I chose Python for this simply because I thought it would be the quickest to set up, and easiest to maintain.
When I write a blog post (as I'm doing right now), I write it in Markdown, as it is easily translated into HTML later, and I don't want to deal with writing HTML as I create a blog post. At the top of these Markdown files, I have some metadata in the form of JSON, with information such as the post title, summary, date, tags, etc.
Although my build.py has become more and more complicated over the past few weeks, this is an oversimplified view of how it works:
Build.py finds all of the Markdown files in a certain directory (in my case, the 'content' folder)
The contents of each Markdown file are processed as strings, and then turned into HTML through a Python Markdown library
These strings of newly-created HTML are then added into template HTML files I've created.
This is still the basic function of build.py, but I've found myself adding more features I would never have thought of even a week ago. Among these is a 'tags' system, which I saw as an interesting problem to work on.
Python's weird mix of being part functional, part object-oriented has been useful in the creation of this site. For instance, every blog post is turned into what I call a 'PostObject', that has information such as post length, link, and author (which will likely always be me).
Part of the beauty of this site (in my eyes) is its quick performance, which is something I've put a lot of effort into. This is what influenced me to do (almost) all the design from scratch, rather than use something like Bootstrap (which could significantly slow down load times).
Apart from my style sheets and compressed images, this website doesn't need a whole lot to run, which I find helpful. This is also helped by the fact that the site is hosted on GitHub pages, meaning it's GitHub's CDN being used, which is without a doubt more powerful than anything I could host myself.
Cloudflare (the reason this site has HTTPS) is both a godsend and an annoyance. While it does provide a great set of tools for monitoring the site, and changing DNS settings, I've spend far, far more time than I would like to admit on trying to diagnose CSS errors that were simply due to Cloudflare having cached old versions
Previously, I had been worried about the viability of having one file process every website-related HTML file (as it also generated the home page, the "projects" view, the "all posts" view, etc), but it really just comes down to simple file I/O and string manipulation, so even when I run build.py with 50,000 Markdown files, it still takes less than a second to run. If I ever organically get to that many posts, something good must have happened along the way.
I set up the 'tags' system I mentioned before with the goal of filling this personal site with not only traditional 'blog' posts about things that are important to me, but to also write articles to help people understand how things work (such as this article). I'm doing this because although I find StackOverflow to be an invaluable resource when I'm working on something, one can sometimes be inundated with too many conflicting answers, whereas one article written by one person is normally much easier to follow, and, in my experience, slightly more likely to work. Using tags will help me differentiate between 'blog' posts, and tutorials (which will be tagged by the related programming languages and concepts used).
I hope this article was helpful in explaining the way in which I've chosen to build this website. It took a little while for me to wrap my head around the concept of not hand-coding every HTML page, but it's definitely a terrific time-saver, with changes to the template being reflected in a fraction of a second throughout the entire website


Status: Passed, Jan 89 X3J13Issue: PEEK-CHAR-READ-CHAR-ECHO
References: READ-CHAR (p379), UNREAD-CHAR (p379), PEEK-CHAR (p379),
MAKE-ECHO-STREAM (p330), Streams (p327-328),
READ-PRESERVING-WHITESPACE (p376),
READ-DELIMITED-LIST (p377)
Category: CLARIFICATION/CHANGE
Edit history: 06-Mar-87, Version 1 by Pitman
23-Jun-88, Version 2 by Pitman (remove interactive stuff)
8-Oct-88, Version 3 by Pitman & Masinter
Problem Description:
The interaction between PEEK-CHAR, READ-CHAR and streams made by
MAKE-ECHO-STREAM is not made adequately clear about how many times
a particular character may be echoed and at what time such echo
is permissible.
For example, given:
(WITH-INPUT-FROM-STRING (STRING-STREAM "A")
(LET ((*STANDARD-INPUT* (MAKE-ECHO-STREAM STRING-STREAM
(SETQ CHAR (READ-CHAR)) (PRIN1 '---)
(UNREAD-CHAR CHAR) (PRIN1 '---)
(READ-CHAR))))
what is seen on the terminal? There are at least these possibilities:
[1] PEEK-CHAR is implemented by READ-CHAR/UNREAD-CHAR. The first time
a char is seen by READ-CHAR it's echoed, UNREAD-CHAR does not echo,
re-fetching the char by READ-CHAR doesn't echo.
A------------
[2] Characters are echoed whenever seen by PEEK-CHAR or READ-CHAR.
Characters are not unechoed by UNREAD-CHAR.
A---A---A---A---
[3] Characters are not echoed by PEEK-CHAR but are echoed by READ-CHAR.
No `unecho' action is done by UNREAD-CHAR.
------A------A
[4] PEEK-CHAR is implemented by READ-CHAR/UNREAD-CHAR. READ-CHAR echoes
but UNREAD-CHAR does not `unecho'.
A---A---A------A
[5] PEEK-CHAR is implemented by READ-CHAR/UNREAD-CHAR. READ-CHAR echoes
but UNREAD-CHAR unechoes (a magic Erase character must be
presupposed for display terminals, a file stream that can randomly
access during output and/or back up must be presupposed for files,
paper terminals just lose):
A<Erase>---A<Erase>---A---<Erase>---A
[6] PEEK-CHAR is implemented by peeking and does not echo. The first
time a char is seen by READ-CHAR it's echoed, UNREAD-CHAR does not
echo, re-fetching the char by READ-CHAR doesn't echo:
------A------
This list is not believed to be exhaustive. It is only to illustrate
of the variety of possible ways in which the current specification can
be implemented without technically being in conflict with the written
word of CLtL. Obviously not all of these interpretations are considered
useful by all people, but usefulness has not been determined to be
criterial in satisfying the specification.
The description of streams (p327-328) is also [probably deliberately]
fuzzy on this issue as it relates to operating systems on which echoing
is done by the operating system. That is, some systems are line-at-a-time
and all READ-CHAR and PEEK-CHAR operations happen after issues of echo
have long since been resolved by a system call that reads and echoes input
a line at a time. Other systems are character-at-a-time and these issues
hit home in a different way. It will probably be necessary to continue
leaving things slightly unspecified in order to accomodate the native
style of the variety of operating systems now trying to support Common
Lisp, but we should be more up front about the game we are playing. (For
example, code which must port between character-at-a-time and
line-at-a-time systems must be more careful about whether it does
newline-preceded or newline-terminated output than many CL programmers
might realize given the current wording.) Additionally, though, we should
be on the lookout for less ambitious goals involving only partial
compatibility to improve the situation wherever we can find a way to.
Abstract functions READ-PRESERVING-WHITESPACE and READ-DELIMITED-LIST
are implicitly affected by any decisions made on this issue since their
descriptions involve the use of UNREAD-CHAR and PEEK-CHAR, respectively.
Proposal (PEEK-CHAR-READ-CHAR-ECHO:FIRST-READ-CHAR):
Ammend the description of READ-CHAR to say that when the stream is
an echo stream (a stream created by MAKE-ECHO-STREAM), the character
will be echoed on the stream the first time those characters are seen.
(Characters which are not echoed by READ-CHAR are those which were
put there by UNREAD-CHAR and hence are assumed to have been echoed
already by a previous call to READ-CHAR.)
Ammend the description of UNREAD-CHAR to say that when the stream
is an echo stream (a stream created by MAKE-ECHO-STREAM), no attempt
will be made to undo any echoing of the character which might already
have been done on the stream. However, characters placed on the
stream by UNREAD-CHAR will be marked in such as way as to inhibit
later re-echo by READ-CHAR.
Ammend the description of PEEK-CHAR to say that when the stream is
an echo stream (a stream created by MAKE-ECHO-STREAM), characters
which are only peeked at are not echoed. Note however that in the
case that the PEEK-TYPE argument is not NIL, the characters which
are passed by PEEK-CHAR are treated as if by READ-CHAR, and so are
echoed unless they have been marked otherwise by READ-CHAR.
Ammend the description of abstract input functions
READ-PRESERVING-WHITESPACE and READ-DELIMITED-LIST to acknowledge
that they are implicitly affected by these new echoing rules of
READ-CHAR, UNREAD-CHAR, and PEEK-CHAR.
Note: This is consistent with behavior [6] in the problem description.
Clarify that the echo behavior of interactive streams such as
*TERMINAL-IO* continues to be implementation dependent.
Rationale:
Although this is not known to be in use in any particular system,
nothing prevents its use. It proposes a more rational interpretation
of the echoing behavior of UNREAD-CHAR which might make it possible
for programmers concerned about echo behavior not to have to shy
away from UNREAD-CHAR. (It would probably also improve the behavior
of READ-PRESERVING-WHITESPACE with regard to echoing, since its
description mentions using UNREAD-CHAR.)
Correct echoing behavior is important to programs which do batch
processing, parsing, etc. Allowing multiple or premature echoing
is clearly unsatisfactory.
Current Practice:
A wide variety of behaviors are in use.
Cost to Implementors:
Unknown.
The code to implement the proposed change itself is probably fairly
localized.
In some operating systems, there may be echoing constraints which
are overlooked here.
In some cases, there may be second order effects in the system
itself which would also require a somewhat less predictable amount
of work to fix.
Cost to Users:
Any change is effectively upward compatible since the previous
behavior is so ill-specified.
Most users probably naively expect (perhaps even without realizing
it explicitly) that echoing will take care of itself. That is, they
probably expect that echoing will occur at the time of the
READ-CHAR and probably do not give a lot of thought to the effect
of PEEK-CHAR. As such, FIRST-READ-CHAR probably best supports most
of their naive intuitions.
Cost of Non-Adoption:
The streams returned by MAKE-ECHO-STREAM would continue to be
significantly hard to use portably.
Benefits:
A number of applications involving of parsers, batch script
interpreters, and such would be possible to implement
straightforwardly and portably.
Aesthetics:
?
Discussion:
Pitman supports PEEK-CHAR-READ-CHAR-ECHO:FIRST-READ-CHAR because
he feels it is more practically coherent. However, he says he has
only mental exercises and no actual personal experience upon which
to base that belief.
Version 1 of this proposal treated interactive streams on par
with echo streams, but while people agreed that this issue is
a severe portability problem, some considered that the treatment
of interactive streams got involved in operating system issues
that were beyond the scope of the standard, so that part of the
text was removed.


First I appologize for not being able to be particularly scientific here. You see, it's been a sort of harrowing ride. I only hope that the editors that be will overlook my lack of science and tell my story just the same, as I think it may benefit some (feel free to edit if that gets my story out there).
I started GBL because I needed sleep. I was up commuting and working 16 hours a day. When I finally got home, I could not wind down. I started drinking Jack Daniels and Coke - about 2 to 3 drinks, before bed. This was ok, but even then I would have the shakes the next morning. I searched the internet, and found a product called Renewtrient - GBL - 1.82g per oz.. I thought, 'Wow!, this stuff is awesome.' I thought I'd been reborn. Sleep was no longer a problem. I was estatic.
Over the next 3 months, I graduated from Renewtrient to a stronger product - one containing 2.25g GBL/oz.. I started taking it in the car on my commutes - it took the stress out my 100 mile drive and my 20 mile sub-way ride. I took it at work.
I graduated from the 2.25g/oz. to a product containing 3g GBL/oz. I was hooked. If I stopped getting my regular 15 to 25 grams of GBL per day I was in deep trouble. When the effects wore off, I became like an advanced Parkinson's Disease patient. I had much *less* than no fine motor control. I was like an animation that skipped 4 or 5 pictures between movements (this is, unfortunately, no exageration). If I smoked a cigarette - a dopamine stimulate - I could hardly walk.
I know now, that my problems were caused by the heavy build up of dopamine that results from taking too much GBL - you sleep so deeply that the normal re-charge of dopamine is exaggerated beyond your body's ability to cope. And I firmly believe that this is, in the pathetic words of who ever that infamous happy home-maker is (who's name I can't, at the moment remember), 'a good thing.' But I just wish there would have been some sort of warning about this aspect. I guess I shouldn't be too upset over it though - phenalalanine, the over-the-counter supplement, comes with no more warning than a suggested daily dosage.
Bottom line is, this stuff is great (GBL). But if you take it, take the recommended dosage seriously - 5 days on, 2 days off at (and here's the kicker, depending on your constitution) 1.82g/oz. of the active ingredient, GBL. And get some exercise!
I have not had any GBL in about 3 months (can't afford it), and I'm still feeling the effects - intense neck tension (dopaminergic stimulation in the basal ganglia) and mild Parkinson's like symptons (too little dopaminergic stimulation in the frontal lobe) after smoking a cigarette (some may crticize this article by noting that dopamine stimulation should curb Parkinson's symptoms. However, in human biological systems, 'too much of a good thing' often leads to the oposite of that which it's indicated for).
Thanks for listening. Hope I help.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object atg.deployment.server.AgentRef
The server-side reference to a remote deployment agent. The server agent-ref has key information about the deployment for the server and houses the actual transport implementation for communicating with the agent. Though the Target object will most likely be all that is required, the AgentRef reveals a finer granularity of information about the target.
The AgentRef contains information from the topology definition file for this agent:
The methods getState() and getStatus() provide information on the specific agent whereas Target.getStatus() combines the statuses returned from a list of agents.
| Field Summary | |
static java.lang.String |
CLASS_VERSION
Class version string |
| Method Summary | |
Status |
abortApply(java.lang.String pDeploymentID)
Tells the agent to abort the manifest application. |
Status |
applyManifest(java.lang.String pDeploymentID,
boolean pFirstApply,
java.util.Map pAssetDestinations)
Tells the agent to deploy the prepared manifest. Note that this method will return before the deployment is finished. |
Status |
deleteManifest(java.lang.String pManifestID)
Deletes the manifest from the agent. |
java.lang.String[] |
getExcludeAssetDestinations()
Specific asset destinations this agent is not to deploy. |
java.lang.String[] |
getIncludeAssetDestinations()
Specific asset destinations this agent is to deploy. |
java.lang.String |
getName()
Name of this deployment agent. |
java.lang.String[] |
getPrincipalAssets()
Asset types which this agent is responsible for deploying. |
int |
getState()
Wrapper call to the AgentTransport for this agent. |
Status |
getStatus()
Wrapper call to the AgentTransport for this agent. |
int |
getTransactionSize()
The number of transactions to batch together during the agent's apply phase. |
java.lang.String |
getTransportType()
Returns the transport type used by this agent, the same type used in the XML topology definition file. |
java.lang.String |
getTransportURI()
|
boolean |
hasDeploymentResponsibilities()
Returns whether or not this Agent has deployment responsibilities. |
boolean |
initializeTransport()
If the transport failed to start up properly more attempts can be made until the transport starts. |
Status |
installManifest(java.lang.String pDeploymentID,
atg.deployment.manifest.Manifest pManifest)
Transfers the given manifest to the remote deployment agent. |
Status |
loadManifest(java.lang.String pDeploymentID,
java.lang.String pManifestID)
Loads the specified manifest into the agent for the deployment operation. |
Status |
recoverAgent(java.lang.String pDeploymentID,
java.util.Map pRecoverInfo)
Recover the agent for the deployment. |
boolean |
reinitializeTransport()
Destroys the current transport and initializes a new one. |
boolean |
reinitializeTransport(Status pErrorStatus)
Destroys the current transport and initializes a new one. |
Status |
setAgentStatus(java.lang.String pDeploymentID,
java.util.Map pToStatus)
Sets the agent's Status remotely from the Publishing server to the specified Status |
void |
setTransactionSize(int pTransactionSize)
The number of transactions to batch together during the agent's apply phase. |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
public static java.lang.String CLASS_VERSION
| Method Detail |
public java.lang.String getName()
public java.lang.String[] getPrincipalAssets()
public java.lang.String[] getExcludeAssetDestinations()
public java.lang.String[] getIncludeAssetDestinations()
public java.lang.String getTransportType()
If the transport could not be initialized, the String BAD is returned.
public void setTransactionSize(int pTransactionSize)
During the deployment application phase many operations will be
performed, e.g. each repository addItem(), udpateItem(), and
removeItem() count as an operation. For those operations that
are transactional the size of the transaction could get large.
This value specifies the maximum number of operations to batch
into a single transaction before committing and starting a new
transaction. Setting this value to zero or less will make the
deployment application use a single transaction. The default
value can be found in
atg.deployment.Constants.APPLY_TRANSACTION_SIZE
.
pTransactionSize
- new value to setpublic int getTransactionSize()
During the deployment application phase many operations will be
performed, e.g. each repository addItem(), udpateItem(), and
removeItem() count as an operation. For those operations that
are transactional the size of the transaction could get large.
This value specifies the maximum number of operations to batch
into a single transaction before commiting and starting a new
transaction. Setting this value to zero or less will make the
deployment application use a single transaction. The default
value can be found in
atg.deployment.Constants.APPLY_TRANSACTION_SIZE
.
public boolean initializeTransport()
Note: This method only tries to start the transport if it did not initially start. To change an agent's transport that is already running the topology XML file needs to be changed and the entire topology re-initialized.
public boolean reinitializeTransport()
public boolean reinitializeTransport(Status pErrorStatus)
public boolean hasDeploymentResponsibilities()
public int getState()
AgentTransport
public Status getStatus()
AgentTransport
public java.lang.String getTransportURI() throws DeploymentException
DeploymentException
public Status loadManifest(java.lang.String pDeploymentID, java.lang.String pManifestID)
pDeploymentID
- current deployment identifierpManifestID
- identifier for the manifest to be loaded
public Status installManifest(java.lang.String pDeploymentID, atg.deployment.manifest.Manifest pManifest)
The specfic means of transfer are up to the transport implementation, so the manifest is given here on a whole (i.e. the manifest object itself which contains references to the deployment data internally).
pDeploymentID
- identifier for this deploymentpManifest
- the manifest being sent to the agent
public Status applyManifest(java.lang.String pDeploymentID, boolean pFirstApply, java.util.Map pAssetDestinations)
pDeploymentID
- identifier for this deployment
public Status abortApply(java.lang.String pDeploymentID)
This usually happens because another agent in the target has failed.
public Status recoverAgent(java.lang.String pDeploymentID, java.util.Map pRecoverInfo)
public Status deleteManifest(java.lang.String pManifestID)
pManifestID
- the ID of the manifest to delete from the agent
public Status setAgentStatus(java.lang.String pDeploymentID, java.util.Map pToStatus)
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


NOTE : Children are actually added and removed dynamically. U can check it by inspecting web page in UR browser.
This is para. text.
This is heading5 style text.


Register below with your phone number or email address
Your email or phone will only be used to contact you if you’re a winner.


Challenge a Penalty Charge Notice
Your exemption certificate was not valid at the time you claimed
This may have been because your certificate had expired or you didn't get the certificate in time.
What to do next
You have the following options:
-
Send us proof to show that you were entitled to free NHS prescriptions or had a valid prescription prepayment certificate between 1 December and 31 December 2018.
-
Pay the total amount of £68.60.
If you were not entitled to free prescriptions but have an exceptional reason why you made the claim, you can ask us to review your Penalty Charge Notice. Find out if you can ask for a review.


|
BitShares-Core
6.1.0
BitShares blockchain implementation and command-line interface software
|
#include <api_objects.hpp>
Public Attributes | |
| bool | balances = false |
| bool | vesting_balances = false |
| bool | limit_orders = false |
| bool | call_orders = false |
| bool | settle_orders = false |
| bool | proposals = false |
| bool | assets = false |
| bool | withdraws_from = false |
| bool | withdraws_to = false |
| bool | htlcs_from = false |
| bool | htlcs_to = false |
Definition at line 44 of file api_objects.hpp.
| bool graphene::app::more_data::assets = false |
Definition at line 52 of file api_objects.hpp.
| bool graphene::app::more_data::balances = false |
Definition at line 46 of file api_objects.hpp.
| bool graphene::app::more_data::call_orders = false |
Definition at line 49 of file api_objects.hpp.
| bool graphene::app::more_data::htlcs_from = false |
Definition at line 55 of file api_objects.hpp.
| bool graphene::app::more_data::htlcs_to = false |
Definition at line 56 of file api_objects.hpp.
| bool graphene::app::more_data::limit_orders = false |
Definition at line 48 of file api_objects.hpp.
| bool graphene::app::more_data::proposals = false |
Definition at line 51 of file api_objects.hpp.
| bool graphene::app::more_data::settle_orders = false |
Definition at line 50 of file api_objects.hpp.
| bool graphene::app::more_data::vesting_balances = false |
Definition at line 47 of file api_objects.hpp.
| bool graphene::app::more_data::withdraws_from = false |
Definition at line 53 of file api_objects.hpp.
| bool graphene::app::more_data::withdraws_to = false |
Definition at line 54 of file api_objects.hpp.


[![Build Status](https://travis-ci.org/ForbesLindesay/transformers.png?branch=master)](https://travis-ci.org/ForbesLindesay/transformers) # transformers
String/Data transformations for use in templating libraries, static site generators and web frameworks. This gathers the most useful transformations you can apply to text or data into one library with a consistent API. Transformations can be pretty much anything but most are either compilers or templating engines.
## Supported transforms
To use each of these transforms you will also need to install the associated npm module for that transformer.
### Template engines
- [atpl](http://documentup.com/soywiz/atpl.js) - Compatible with twig templates
- [coffeecup](http://documentup.com/gradus/coffeecup) - pure coffee-script templates (fork of coffeekup)
- [dot](http://documentup.com/olado/doT) [(website)](https://github.com/Katahdin/dot-packer) - focused on speed
- [dust](http://documentup.com/akdubya/dustjs) [(website)](http://akdubya.github.com/dustjs/) - asyncronous templates
- [eco](http://documentup.com/sstephenson/eco) - Embedded CoffeeScript templates
- [ect](http://documentup.com/baryshev/ect) [(website)](http://ectjs.com/) - Embedded CoffeeScript templates
- [ejs](http://documentup.com/visionmedia/ejs) - Embedded JavaScript templates
- [haml](http://documentup.com/visionmedia/haml.js) [(website)](http://haml-lang.com/) - dry indented markup
- [haml-coffee](http://documentup.com/netzpirat/haml-coffee/) [(website)](http://haml-lang.com/) - haml with embedded CoffeeScript
- [handlebars](http://documentup.com/wycats/handlebars.js/) [(website)](http://handlebarsjs.com/) - extension of mustache templates
- [hogan](http://documentup.com/twitter/hogan.js) [(website)](http://twitter.github.com/hogan.js/) - Mustache templates
- [jade](http://documentup.com/visionmedia/jade) [(website)](http://jade-lang.com/) - robust, elegant, feature rich template engine
- [jazz](http://documentup.com/shinetech/jazz)
- [jqtpl](http://documentup.com/kof/jqtpl) [(website)](http://api.jquery.com/category/plugins/templates/) - extensible logic-less templates
- [JUST](http://documentup.com/baryshev/just) - EJS style template with some special syntax for layouts/partials etc.
- [liquor](http://documentup.com/chjj/liquor) - extended EJS with significant white space
- [mustache](http://documentup.com/janl/mustache.js) - logic less templates
- [QEJS](http://documentup.com/jepso/QEJS) - Promises + EJS for async templating
- [swig](http://documentup.com/paularmstrong/swig) [(website)](http://paularmstrong.github.com/swig/) - Django-like templating engine
- [templayed](http://documentup.com/archan937/templayed.js/) [(website)](http://archan937.github.com/templayed.js/) - Mustache focused on performance
- [toffee](http://documentup.com/malgorithms/toffee) - templating language based on coffeescript
- [underscore](http://documentup.com/documentcloud/underscore) [(website)](http://documentcloud.github.com/underscore/)
- [walrus](http://documentup.com/jeremyruppel/walrus) - A bolder kind of mustache
- [whiskers](http://documentup.com/gsf/whiskers.js/tree/) - logic-less focused on readability
### Stylesheet Languages
- [less](http://documentup.com/cloudhead/less.js) [(website)](http://lesscss.org/) - LESS extends CSS with dynamic behavior such as variables, mixins, operations and functions.
- [stylus](http://documentup.com/learnboost/stylus) [(website)](http://learnboost.github.com/stylus/) - revolutionary CSS generator making braces optional
- [sass](http://documentup.com/visionmedia/sass.js) [(website)](http://sass-lang.com/) - Sassy CSS
### Minifiers
- [uglify-js](http://documentup.com/mishoo/UglifyJS2) - No need to install anything, just minifies/beautifies JavaScript
- [uglify-css](https://github.com/visionmedia/css) - No need to install anything, just minifies/beautifies CSS
- ugilify-json - No need to install anything, just minifies/beautifies JSON
### Other
- cdata - No need to install anything, just wraps input as <![CDATA[${INPUT_STRING]]> with the standard escape for ]]> (]]]]><![CDATA[>).
- cdata-js - as cdata, but with surrounding comments suitable for inclusion into a HTML/JavaScript <script> block: //<![CDATA[n${INPUT_STRINGn//]]>.
- cdata-css - as cdata, but with surrounding comments suitable for inclusion into a HTML/CSS <style> block: /*<![CDATA[*/n${INPUT_STRINGn/*]]>*/.
- verbatim - No need to install anything, acts as a verbatim passthrough ${INPUT_STRING}
- [coffee-script](http://coffeescript.org/) - npm install coffee-script
- [cson](https://github.com/bevry/cson) - coffee-script based JSON format
- markdown - You can use marked, supermarked, markdown-js or markdown
- [component-js](http://documentup.com/component/component) [(website)](http://component.io) - npm install component-builder options: {development: false}
- [component-css](http://documentup.com/component/component) [(website)](http://component.io) - npm install component-builder options: {development: false}
- [html2jade](http://documentup.com/donpark/html2jade) [(website)](http://html2jade.aaron-powell.com/) - npm install html2jade - Converts HTML back into jade
Pull requests to add more transforms will always be accepted providing they are open-source, come with unit tests, and don’t cause any of the tests to fail.
## API
The exported object transformers is a collection of named transformers. To access an individual transformer just do:
`javascript var transformer = require('transformers')['transformer-name'] `
### Transformer
The following options are given special meaning by transformers:
- filename is set by transformers automatically if using the renderFile APIs. It is used if cache is enabled.
- cache if true, the template function will be cached where possible (templates are still updated if you provide new options, so this can be used in most live applications).
- sudoSync used internally to put some asyncronous transformers into “sudo syncronous” mode. Don’t touch this.
- minify if set to true on a transformer that isn’t a minifier, it will cause the output to be minified. e.g. coffeeScript.renderSync(str, {minify: true}) will result in minified JavaScript.
#### Transformer.engines
Returns an array of engines that can be used to power this transformer. The first of these that’s installed will be used for the transformation.
To enable a transformation just take [engine] = Transformer.engines[0] and then do npm install [engine]. If [engine] is . there is no need to install an engine from npm to use the transformer.
#### Transformer.render(str, options, cb)
Tranform the string str using the Transformer with the provided options and call the callback cb(err, res).
If no cb is provided, this method returns a [promises/A+](http://promises-aplus.github.com/promises-spec/) promise.
#### Transformer.renderSync(str, options)
Synchronous version of Transformer.render
#### Transformer.renderFile(filename, options, cb)
Reads the file at filename into str and sets options.filename = filename then calls Transform.render(str, options, cb).
If no cb is provided, this method returns a [promises/A+](http://promises-aplus.github.com/promises-spec/) promise.
#### Tranformer.renderFileSync(filename, options)
Synchronous version of Tranformer.renderFile
#### Transformer.outputFormat
A string, one of:
- ‘xml’
- ‘css’
- ‘js’
- ‘json’
- ‘text’
Adding to this list will not result in a major version change, so you should handle unexpected types gracefully (I’d suggest default to assuming ‘text’).
#### Transformer.sync
true if the transformer can be used syncronously, false otherwise.
 If you are not doing the things that cause them to fail then they are consistently safe to use syncronously.
- jade (only when using then-jade instead of jade)
- less (when @import is used with a url instead of a filename)
- jazz (When one of the functions passed as locals is asyncronous)
The following libraries look like they might sometimes throw exceptions when used syncronously (if you read the source) but they never actually do so:
- just
- ect
- stylus


Severity Statistics
Level severity statistics
Open
Bounce
Unsubscribe
Campaign sent 2 days ago
Tasks
Backend development
-
{% for task, checked in (('Sign contract for "What are conference organizers afraid
of?',
True), ('Lines From Great Russian Literature? Or E-mails From My Boss?', False),
('Flooded: One year later, assessing what was lost and what was found when a
ravaging rain swept through metro Detroit', False), ('Create 4 Invisible User
Experiences you Never Knew About', True), ('Read "Following makes Medium better"',
True)) %}
-
{{ task }}
{% endfor %}


Post Title
Description
Post Content
Loading image
Upload Image
Loading image
Upload Cover Image
Remove
Post video URL
Categories
{{x.title}}
Tags
Submit for approval


{% extends "layout.html" %} {% block title %} Confirm login {% endblock %} {% block main %}
The transaction was a succes!


Levenberg-Marquardt
Context: Data Fitting
Problem: Slow convergence, getting lost on the plateau
- The Natural gradient is preferred near the best fit
- Far from the best fit, the natural gradient becomes stuck at the boundary
- Not originally motivated by information geometry.
- Information geometry helps explain why it is effective
Transtrum, Mark K., Benjamin B. Machta, and James P. Sethna. "Geometry of nonlinear least squares with applications to sloppy models and optimization." Physical Review E 83.3 (2011): 036701.
Original Derivation: Trust Region
Approximate the cost near the current guess:
$$ C(\theta) = \frac{1}{2} \sum_m r_m(\theta)^2 \approx \frac{1}{2} \sum_m \left( r_{m0} + J_{m\mu} (\theta^\mu - \theta^\mu_0\right)^2 $$
Minimize the approximate $C(\theta)$ subject to the constraint:
$$ \delta \theta^T \left( D^T D \right) \theta < \Delta $$
Leads to the step:
$$ \delta \theta = -\left(J^T J + \lambda D^T D\right)^{-1} \nabla C $$
where $\lambda$ is a Lagrange Multiplier (damping parameter).
$D^TD$ is usually taken to be the identity.
Understanding LM
Large $\lambda$:
$$ \delta \theta \rightarrow -\frac{1}{\lambda} \left( D^TD \right)^{-1} \nabla C $$
- Steps become arbitrarily small
- Directed in the parameter space gradient
- For sufficiently large $\lambda$, there will always be a step that moves downhill
Small $\lambda$:
$$ \delta \theta \rightarrow -\left( J^TJ \right)^{-1} \nabla C $$
- Steps become the Natural Gradient
Understanding LM
A typical optimization procedure:
- Far from best fit, large $\lambda$
- Algorithm moves downhill into a canyon and near the best fit.
- $\lambda$ is slowly decreased, rotating the step in the natural gradient
- Rapid convergence near the best fit
Model Graph
- The term $J^TJ + \lambda D^TD$ looks like a modified metric.
- It is the metric on the model graph
- Plot model output against parameters
- $N$ dimensional manifold embedded in an $M+N$ dimensional space
- The model graph stretches the model manifold so that there are no more boundaries.
Transtrum, Mark K., Benjamin B. Machta, and James P. Sethna. "Geometry of nonlinear least squares with applications to sloppy models and optimization." Physical Review E 83.3 (2011): 036701.
Natural Gradient of Model Graph
Transtrum, Mark K., Benjamin B. Machta, and James P. Sethna. "Geometry of nonlinear least squares with applications to sloppy models and optimization." Physical Review E 83.3 (2011): 036701.
Geodesic Coordinates on Model Graph
Transtrum, Mark K., Benjamin B. Machta, and James P. Sethna. "Geometry of nonlinear least squares with applications to sloppy models and optimization." Physical Review E 83.3 (2011): 036701.
Geodesic Levenberg-Marquardt
Context: Data Fitting
Problem: Slow convergence, getting lost on the plateau
- Levenberg-Marquardt is generally effective, but can become slow when the canyon is narrow and curves.
- Geodesic coordinates suggest a way of straightening out the canyon.
- Sometimes $\lambda$ is decreased too quickly, LM becomes lost.
Transtrum, Mark K., Benjamin B. Machta, and James P. Sethna. "Why are nonlinear fits to data so challenging?." Physical review letters 104.6 (2010): 060201.
Optimziation and Geometry
- A recurring theme: Algorithms should exploit the natural geometric structure of the problem.
- Rather than stepping in straight lines in parameter space, take straight lines in data space: Geodesics
$$ \delta \theta = v \tau + \frac{1}{2} a \tau^2 + \dots $$
- The first order term is the traditional LM step.
- The second order term is the geodesic acceleration on the model graph:
$$ \frac{1}{2}a \tau^2 = -\frac{1}{2} \left( J^TJ + \lambda D^TD \right)^{-1} J^T \left( v^\mu v^\nu \partial_\mu \partial_\nu \mathbf{y}
\right)$$
Geodesic Acceleration
Transtrum, Mark K., Benjamin B. Machta, and James P. Sethna. "Geometry of nonlinear least squares with applications to sloppy models and optimization." Physical Review E 83.3 (2011): 036701.
Comparing Algorithms
- Derivatives are generally expensive to calculate.
- Each Jacobian is equal to roughly $N$ function evaluations.
- For large models, calculating Jacobian is the botleneck.
- Calculating all second derivatives would be $N^2$ function evaluations.
- The geodesic acceleration requires a direction second derivative, estimable with 1 extra function evaluation.
- Comparison Strategy:
- Test on small problems
- Count number of Jacobian Evaluations
- Extrapolate performance to large problems where Jacobian evaluations dominate.
Results
Transtrum, Mark K., Benjamin B. Machta, and James P. Sethna. "Geometry of nonlinear least squares with applications to sloppy models and optimization." Physical Review E 83.3 (2011): 036701.
Improving the trust region
Levenberg-Marquardt adjusts $\lambda$ by gauging the cost at the proposed step.
- If $C_{new} < C$, decrease $\lambda$ and accept step
- If $C_{new} > C$, increase $\lambda$ and reject step
- Generally effective, but not always.
Geodesic Acceleration suggests an additional check:
- Only accept steps if $|a| < |v|$
In practice, geodesic acceleration is much more adept at avoiding manifold boundaries with this criterion.


{% load static %} {% load django_xsession %} {% get_static_prefix as STATIC %}
The UQ Anthropology Museum respects the rights of artists and copyright holders. Every effort is made to trace the copyright holders and gain permission for use of the images within this collection. We would be grateful to receive any information concerning copyright of images.
No image or information displayed on this site may be reproduced, transmitted or copied other than for the purpose of fair dealing (e.g. for research and study) as permitted under the Copyright Act 1968 and subsequent amendments, without the permission of the copyright holders and the UQ Anthropology Museum.


@import com.gitpitch.views.html.frags._ @(rndr: com.gitpitch.utils.GitRepoRenderer, deps: com.gitpitch.policies.Dependencies, offline: Boolean, userAgentIsChrome: Boolean)
| User: |
@rndr.user()
|
| Repo: |
@rndr.repo()
|
| Branch: |
@rndr.branch()
|
| Slides: |
@rndr.pitchme()
|
| @rndr.stargazers() | @rndr.forks() |
Promote, Pitch, Or Present
Absolutely Anything.


---
layout: post
title: Paraskavedekatriaphobia
date: '2009-03-13T16:01:00.003+10:00'
author: Jamie Teh
tags:
- trivia
modified_time: '2009-03-13T16:09:39.830+10:00'
blogger_id: tag:blogger.com,1999:blog-5419412965543098028.post-7297753216002782374
permalink: /2009/03/paraskavedekatriaphobia.html
---
The new Bazaar 1.13rc1 release is codenamed paraskavedekatriaphobia. Having no idea what the hell that was, I decided to look it up, and as usual, Wikipedia furnished me with the answer: the fear of Friday the 13th. If I knew the smiley for rolling eyes, I'd be using it here...
Well, you learn something new every day.


Area 51 Scramble!
Collect as many E.T. Atari Cartridges as you can!
Please use an HTML 5 browser
Use WASD or Arrow Keys to move.
Use Space to Jump.
Press B to Enable/Disable Debug Mode.


NL
Section: User Commands (1)Updated: June 2012
Index Return to Main Contents
NAME
nl - number lines of filesSYNOPSIS
nl [OPTION]... [FILE]...DESCRIPTION
Write each FILE to standard output, with line numbers added. With no FILE, or when FILE is -, read standard input.
Mandatory arguments to long options are mandatory for short options too.
- -b, --body-numbering=STYLE
- use STYLE for numbering body lines
- -d, --section-delimiter=CC
- use CC for separating logical pages
- -f, --footer-numbering=STYLE
- use STYLE for numbering footer lines
- -h, --header-numbering=STYLE
- use STYLE for numbering header lines
- -i, --line-increment=NUMBER
- line number increment at each line
- -l, --join-blank-lines=NUMBER
- group of NUMBER empty lines counted as one
- -n, --number-format=FORMAT
- insert line numbers according to FORMAT
- -p, --no-renumber
- do not reset line numbers at logical pages
- -s, --number-separator=STRING
- add STRING after (possible) line number
- -v, --starting-line-number=NUMBER
- first line number on each logical page
- -w, --number-width=NUMBER
- use NUMBER columns for line numbers
- --help
- display this help and exit
- --version
- output version information and exit
By default, selects -v1 -i1 -l1 -sTAB -w6 -nrn -hn -bt -fn. CC are two delimiter characters for separating logical pages, a missing second character implies :. Type \\ for \. STYLE is one of:
- a
- number all lines
- t
- number only nonempty lines
- n
- number no lines
- pBRE
- number only lines that contain a match for the basic regular expression, BRE
FORMAT is one of:
- ln
- left justified, no leading zeros
- rn
- right justified, no leading zeros
- rz
- right justified, leading zeros
AUTHOR
Written by Scott Bartram and David MacKenzie.REPORTING BUGS
Report nl bugs to<EMAIL_ADDRESS>coreutils home page: <http://www.gnu.org/software/coreutils/>
General help using GNU software: <http://www.gnu.org/gethelp/>
Report nl translation bugs to <http://translationproject.org/team/>
COPYRIGHT
Copyright © 2010 Free Software Foundation, Inc. License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>.This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law.
SEE ALSO
The full documentation for nl is maintained as a Texinfo manual. If the info and nl programs are properly installed at your site, the command- info coreutils aqnl invocationaq
should give you access to the complete manual.
Index
This document was created by man2html, using the manual pages.
Time: 05:29:06 GMT, December 24, 2015


Some Title here
Option 1
arrow_drop_down
Sub option 1
Sub option 2
Sub option 3
arrow_right
3rd Menu option 1
3rd Menu option 2
3rd Menu option 3
Option 2
Option 3


For users that want to browse and execute workflows that are already pre-defined in the system by others. We give you an easy overview of Wings based on a public ''Portal'' (a place to play around). You can also create your own workflows using components that others have already pre-defined. Wings works in the browser, so there is no software to install if you use our web site and you can get started right away.
To set up a local portal: Installation Instructions
This tutorial provides a walkthough of unique capabilities in Wings. Wings uses semantic constraints to reason about workflows and as a result it can assist the user to create valid workflows. You can try out for yourself all the examples mentioned in this tutorial. This site is set up with a simple set of workflows and datasets that you can use to test the capabilities of Wings.
This web site will allow you to experience semantic workflow reasoning first hand through a simple user interface. The site uses Wings, a semantic workflow system with the following capabilities:
It is easy to try things out! You begin by selecting a simple workflow available in our catalog. We have sample datasets that you can use to try out this simple workflow. Once you see how to do that, you can upload your own data and run workflows with it. Skip to the next section if this is all you want to do!
To learn about the unique capabilities of Wings, you will need to use more complex workflows. In the following section of this tutorial, we will walk you through these capabilities with examples:
You can skip this section if you are already familiar with workflow terms. There is a glossary at the end of this document.
The running examples of this tutorial are simple manipulations of data contained in files. There are already workflows and datasets in the site that you can use, so you can quickly get familiar with the system. The workflows process the data for example by counting the number of lines in a file, removing duplicate lines, etc etc.
There are four simple workflows pre-defined in the site, each uses a slightly different approach to count the number of occurrences of words in various files in order to compare the files regarding their topic. The software components that are used as workflow steps are implemented using standard UNIX tools, python, and perl. Intuitively, we use one or more HTML and/or PDF files in a similar topic to generate a simple "topic model" and then apply a distance measure to compare this model to a newly given file.
Workflows manipulate datasets contained in files. In this case, files can be of one of these types: a formatted file (which can be an HTML file or a PDF file), a pattern file (which can be a file containing common words or containing special characters), etc.
Each dataset has associated metadata properties that describe its contents or anything else that is important about the dataset. For example, an HTML file has a size and a language properties.
To view the data and corresponding metadata properties that are used in this site, you can select "Manage Data" under the "Advanced" tab:
We have uploaded a few sample datasets. In the figure above, the "en_Los_Angeles.html" dataset has been selected, which shows that its language is "english", its size is 411610, and its topic is "city". We will see later on how Wings reasons about these properties when the datasets are used in the workflows.
NOTE: Behind the scenes, Wings uses a Data Catalog that contains all this information, and it represents types and properties as OWL ontologies and RDF statements. You will not see any of these ontologies in the interface, but the system uses them to reason about workflows.
We have pre-defined several kinds of workflow components or steps, which are software components that can be executed to process the datasets. Each component has input datasets that it processes, it has input parameters that can configure its function, and outputs that result from its execution. An example is countDuplicates, which takes as input a file of type WordListFile and a parameter that determines a threshold for a minimum set of occurences to be included, and outputs a file of type wordCountFile.
Each constituent of the workflow (i.e., each component, each dataset, and each parameter) has an associated variable, and the semantic constraints refer to these variables to qualify their properties or to state their relationships.
NOTE: Wings accesses a Component Catalog that contains descriptions of all these sofware components that form the workflow steps, their input and output datasets, their input parameters, and how to invoke the code that executes those operations. The descriptions are defined in OWL ontologies and RDF statements. You will not see any of these ontologies in the interface, but the system uses them to reason about workflows.
It will take you seconds to run a workflow in Wings and get results. Just follow the guidance in this section.
You can browse and run workflows that are pre-defined in the system. You do this by selecting "Run Workflows" under the Analysis Tab. There are several workflows that, as we will explain, are different but they all output an assessment of whether a dataset is similar to a given corpus by comparing the amount of words that appear in both. We will look into these workflows in more detail throughout the tutorial.
You can view a workflow by selecting it. If you select the workflow named "English Words" you will see its semantic constraints:
This table shows the semantic constraints on the data variables of the workflow. For example, Words1 has to be of type WordListFile. It also shows that the Words1 should also haveLanguage 'english'.
You will also see a diagram that shows the dataflow among components:
You can find a description of what the workflow does under the "Documentation" tab:
The workflow diagram shows the dataflow among the steps of the workflow. These steps are shown as light orange rectangles. For example, there is a step called html2text, it takes an HTML file as input and it generates a file in plain text without the HTML markup. Each dataset in the workflow has a variable associated with it that is unique within the workflow. For example, one of the input files is called Words1. Datasets in the workflow are shown in blue ovals. Input Datasets are shown in green ovals. Workflow steps can have parameters that control their behavior. For example the countDuplicates step has a Doc1MinLimitOccurances parameter that does not list words in the output that appear less times than the value of that threshold. Parameters also have unique variables associated with them, and are shown as orange ovals.
NOTE: The workflow representations used internally in Wings are more complex than what is shown in the user interface. They are used by the system but we do not explain them in this introductory guide. Please consult our Advanced Tutorial to learn more.
When you are viewing a workflow, you will see a set of menus at the top. For each dataset that is input to the workflow, Wings will show you a pull down menu with all the datasets that are of an appropriate type. For each input parameter, it will allow you to specify a value and it will indicate the type expected. If you select an input dataset, it will be highlighted in the workflow view in bright yellow. The constraints associated with it will also be highlighted.
For our example workflow, you will see the following:
Notice that Wings is already helping you by giving you only options for input files that might be appropriate for this workflow by reasoning about types. In this case only html files are offered for selection.
As shown below, Complete all inputs by Selecting from the menus of input files offered. Enter some value for the two parameters, a good value to provide is 3
NOTE: We will see in a later section how Wings can validate your workflow by alerting you of inappropriate parameter settings, and help you by suggesting correct parameters values.
That's it!
Once you have selected input datasets and parameter values, you can select "Plan Workflow" to submit your workflow for execution. To execute the workflow, select the desired workflow you would like to run and select "Run Selected Workflow":
The workflow will run in the background.
You can view the results by selecting the "Access Runs" in the "Analysis" tab. The workflow takes a few minutes to execute. You can refresh the page, and see a report of its progress:
NOTE: Behind the scenes, the workflows in the portal can be executed by a variety of execution engines. For the purposes of the sandbox, they are converted into and executed as a shell script.
You can view execution results at any time by selecting "Access Runs" in the "Analysis" tab. All the workflows that you have successfully submitted for execution are shown there. For each workflow execution, you can view the results, the logging output, and the workflow used.
In the "Data" tab, you can click on any intermediate and final datasets and view them. You can also see a report of how many times each component was invoked, and how long it took.
In addition, you can save any generated output files back into the data store for later use. To do so click the "Save" link next to the file name. You will be asked to give a more appropriate name to the file. Note that the file will be stored with all the meta-data that Wings has inferred about it! This is one of the distinguishing features of Wings, possible due to the use of semantic annotations and propagation of meta-data properties. So for instance, after executing a very simple workflow that creates a WordCountFile from a TextFile, and saving it back into the data store, when we go back to "Manage Data" (under 'Advanced' tab), we can see the newly created file in the appropriate semantic "folder", "WordCountFile". Note that its meta-data properties are already filled in, as they were inferred by Wings.
So far we have shown how simple workflows can be easily run. What is unique about Wings is that it can represent semantic constraints of workflows and reason about them to assist a user. This section of the tutorial shows several scenarios where you can see these capabilities at work.
Wings can propose parameter values for a workflow once you have selected what datasets you want to use. To do this, Wings reasons about semantic constraints that determine the best values of parameters based on metadata properties of the datasets you have selected. Once you have selected the input datasets for your workflow, you can select the "Suggest Parameters"button:
A pop up window shows you suggested parameter values. In this case, there is a constraint that the threshold parameters should be set depending on the metadata property size of the input. If you select a different input dataset, then the system will suggest different values for these parameters. The pop up window offers this explanation highlighted in blue. The explanation also contains other inferences that Wings has made based on propagating constraints throughout the workflow. The suggestions for parameter values often depend on these inferences, which are not part of the semantic constraints table that you see for the workflow.
You can also ask Wings for suggestions on what datasets to use. Here, we can select input files and ask for suggestions for pattern files by selecting the "Suggest Data"button:
Using a constraint that states that the pattern files must have the same language as the input files, Wings suggests appropriate pattern files from all those available. An explanation is shown to justify why the particular datasets suggested are appropriate. This explanation consists of semantic constraints that have been propagated through the workflow by Wings and that are not part of the semantic constraints table of your workflow description.
Wings can reason about a collection of datasets so that it is processed in parallel by the workflow. For example, if you select the Words Coll workflow you will see:
A multi-layered oval in the workflow diagram indicates that it is a data collection. When you select inputs for this variable, the drop down menu will allow you to select several files at a time. You can see at the bottom of the screen a comment that it is a collection.
Try for example selecting multiple html files, and submit the workflow for execution. When you Plan Workflow, you can see that multiple html2text components are created (in this case we selected 4 files so the component was executed once for each of the 4 files):
NOTE: In this case, the collection of html files is one-dimensional, as it is a list of files. Wings can handle multi-dimensional collections of datasets, as well as collections of workflow components.
If you select input files and parameter settings that are inconsistent with the semantic constraints that are defined in the system, Wings will detect that and let you know that your workflow is invalid. For example, in the English_Words workspace, we mentioned earlier a constraint that the language of the input files and the language of the pattern files has to be the same. If we select files with disparate languages and then we submit this workflow for execution, Wings will inform us that we have an invalid workflow:
Wings can also alert a user if no workflow is possible for the selected input data. In the following example, the file selected in French and there are no pattern files available in that language that could be used:
Wings figures this out based on the semantic constraint for removePattern that its input pattern files have to be in the same language as the input word list files.
This validation capability is very helpful, as Wings is keeping track for the user of all the constraints that are defined in the domain and ensuring that any workflow that a user creates is valid.
In Wings, workflows can have abstract components that represent a class of executable components. Select for example the "Words Abs" workflow:
The component removeMarkup is a class of components that includes two executables: html2text and pdf2text. Depending on what kind of data is input to the workflow, the appropriate executable will be selected.
Note that this workflow is similar to the Words workflow except it is more general, as it can take in any formatted file (i.e., either an HTML or a PDF File). The "removeMarkup"component is an abstract step, and the system will specialize it automatically as an html Markup removal step or a pdf markup removal step depending upon the type of the input that is given to it.
Try for example an html file and a pdf file, and submit the workflow for execution. When you access the computation results you can see that the html2text component was used for the html file and pdf2text was used for the pdf file
You can also specify components when running a workflow. On the workflow running page, select the abstract component you want to specify. A dropdown will pop up at the bottom of the page that allows you to select the specific component you want to use for the run.
Suppose that we want to process a collection of files, some are in html format and some in pdf. We would like the workflow system to select the right workflow component for removing markup for each of the files according to their format. Wings can do exactly that. For this we need to use the Words_Coll_Abs workflow, and what we want is for the removeMarkup step to be specialized for each component of the collection.
As shown above, try for example an html file and a pdf file as inputs to FormattedFileSet1, an html file as input to FormattedFile2, and submit the workflow for execution. When you access the computation results you can see that the 2 html2text components were used, and 1 pdf2text component was used:
Wings can generate automatically metadata properties for new datasets. In order to do this, the input datasets for the workflow must have their metadata properties specified. You can easily upload your own datasets and specify their properties. To do that, select "Manage Data" under "Advanced". Select the type of data that you have, and then select "Upload Files":
Now you can specify the metadata of your dataset. Wings will only ask for metadata properties defined for the type you had selected. For example, for a csv file it will ask for delimiter, language and size:
You can set the properties and click "Save Metadata" to save them
Next, you can write rules for components to generate metadata for outputs. See Advanced Semantic Constraints of Components for examples.
If you go and select a workflow to run, your new dataset will show up when you select input datasets for workflows. Wings will use them to create metadata properties of new datasets, and also for tailoring its assistance to those properties of your dataset.
Besides running preexisting workflows, you can also create new workflows for you and other users to run.
The various tabs for the component type are shown below:
Now this component's IO can be described.
One can also right-click on the component type
On Line 11, . $BASEDIR/io.sh 1 1 1 "$@" indicates that there is 1 Input, 1 Parameter, 1 Output. It reads the inputs and outputs and then finally calls htmltagcount.pl.
It could read differently for a different component, depending on how many inputs (including input parameters) and outputs there are. For example, if there are 2 inputs and 1 output (no input parameters), the file would contain the following code:
If the file is named differently than "htmltagcount.pl", make sure to replace the file name on Line 17, directly after $BASEDIR/".
Examples of line 17 for code in different languages:
In this example, this code is written in a programming language called Perl, so it has the file extension ".pl" The process of uploading and managing components in Wings is the same regardless of the programming language your code is in. Only the file extension and the code in the file created in this step and the file name on Line 17 in Step 6 will change based on the programming language and the code being used.
If you will be a workflow system administrator and would like to set up Wings on your site (either on a single machine such as a laptop, or on a grid, cluster, or cloud) go to: Installation Instructions
Another example for Matlab:
Or for Matlab:
This is a brief glossary that describes the terms used in Wings manuals and tutorials. Note that the same terms may be used differently in other systems.
Abstract Workflow -
A workflow whose computations are not fully specified. An abstract workflow 1) may contain abstract steps (i.e., some steps may represent a class of components), 2) may be missing steps and dataflow links (i.e., only specify some of the steps in the workflow), 3) may contain descriptions of the types of data products desired. An abstract workflow can be used as a starting point to automatically generate an execution-ready workflow through workflow elaboration.
Component - See workflow component.
Component Catalog -
A catalog that contains unique identifiers of executable software components or component classes available to the workflow system as workflow steps, together with descriptions of each component in terms of semantic constraints that restrict 1) the characteristics of its input datasets, 2) the appropriate values of parameters for given input data, 3) the required characteristics of input datasets given specific parameter values, 4) the required characteristics of input datasets and appropriate parameter values to generate a required kind of result.
Component collection -
A collection of computations grouped according to some property or criterion and to be processed either within a workflow through parallel computations or by several workflows each processing one item of the collection.
Data Catalog -
A catalog that contains unique identifiers of datasets available to the workflow system, together with descriptions of each dataset in terms of its metadata properties.
Data Types -
Data types have to be made in order to add properties to data. After assigning properties to data types, property values can then be assigned to the data under it. Components must input and output certain data types. Properties of data describe the content of the data file, and examples include size, date, and format (i.e. integer, float, string, etc.).
Dataset -
A file that contains data to be processed by workflow components.
Input datasets are input to a workflow, final datasets are the final results of a workflow, and intermediate datasets are any datasets obtained during workflow execution that are not final results sought by the user. Datasets have associated metadata properties.
Data collection - A collection of individual datasets grouped according to some property or criterion and to be processed by a workflow through parallel computations when possible. Data collections may be nested, so can parallel execution paths in a workflow.
Dimensionality - Data can have characteristics such as length, width, depth, and time, all of which give the dataset dimensionality. Each of these elements gives a dataset an additional dimension. Although colloquial English suggests that there is a specifically numbered dimension that corresponds with each of the examples listed above (e.g., time is the 4th dimension), this is not the case in data science. For example, if you have measurements from a sensor over time but do not have the longitude, latitude, and altitude of the sensor, the data is only one-dimensional because it extends in only one direction (time).
A common application of dimensionality in WINGS is for split components. Split components take larger dataset and split it into smaller datasets based either on size or some other element. If the input data is 0-D before the split, the output is now 1-D. Splitting the data extends the data in another direction, thus increasing its dimensionality.
Domain - Domains serve as workspaces in which you can organize your projects. Creating different domains for various tasks helps to prevent confusing components and makes elements of the workflow easier to find. Domains can be thought of as analogous to windows within a web browser and related templates are like related tabs within a window.
Executable component - See workflow component.
Execution-ready workflow -
A workflow that is fully specified at the application level and can be submitted to a workflow mapping and execution engine. To be fully specified at the application level the workflow must have: 1) all input datasets bound to an existing dataset, 2) all parameters bound to a specific value, 3) all workflow steps must be executable components.
Metadata property -
A property of a dataset, which is represented explicitly and separately from the data itself. Examples of metadata properties may be the type of data, the size of a dataset, statements about the methods used to obtain a dataset, and accuracy measurements.
Parameter -
An input to a software component that enables configuring it to obtain different results. Examples of parameters include a threshold value, the number of iterations within the component, and filtering criteria. Parameters are treated differently from datasets as the nature of the input datasets to the component often determines what parameter values are more appropriate.
Parameter Type -
The parameter type specifies what values are possible for the parameter. The paramter types available in WINGS include string, boolean, int, float, and date.
Port -
Ports describe the inputs and outputs of components. In a valid workflow they are linked to data variables. In the editor, input (resp. output) ports appear as little boxes above (resp. underneath) the component.
Variable - See workflow variable.
Workflow -
A workflow represents a complex computation declaratively as a set of software components and their data flow dependencies. In some cases a workflow also contains control flow dependencies. Workflows are often diagrammed as a graph whose nodes are the computations (the software components) and the links reflect the dataflow. See workflow template, execution-ready workflow, and abstract workflow.
Workflow component - A workflow component can be used as a step in the workflow. It is either 1) an executable software component that is encapsulated and can be directly executed, or 2) a class of software components (also called an abstract component) whose instances are executable software components.
Workflow elaboration -
The process of taking an abstract workflow and generating an execution-ready workflow.
Workflow step - See workflow component.
Workflow system -
Workflow systems exploit workflow representations in order to manage the elaboration and execution of
workflows that process very large datasets in a distributed environment.
Workflow template -
A workflow that has one or more unspecified inputs and therefore is has more generality than a fully specified workflow that only applies to its defined inputs. Workflow templates are more reusable than fully specified workflows. To execute a workflow, a user can take a pre-defined reusable workflow template from a library and then specify the inputs of interest.
Workflow variable -
Wings assigns a unique variable to each component, dataset, and parameter of a workflow. These variables are used to assert semantic constraints. A data variable is a variable associated with a dataset. A parameter variable is a variable associated with an input parameter of a component of the workflow.


Create your own character and progress through your career in an attempt to dominate the tennis world.


“Kiṁme katā rājagahe manussā,
Madhuṁ pītāva acchare;
Ye sukkaṁ na upāsanti,
Desentiṁ buddhasāsanaṁ.
“What’s up with these people in Rājagaha?
They sprawl like they’ve been drinking mead!
They don’t attend on Sukkā
as she teaches the Buddha’s instructions.
Tañca appaṭivānīyaṁ,
asecanakamojavaṁ;
Pivanti maññe sappaññā,
valāhakamivaddhagū.
But the wise—
it’s as if they drink it up,
so irresistible, delicious and nutritious,
like travelers enjoying a cool cloud.”
Sukkā sukkehi dhammehi,
vītarāgā samāhitā;
Dhāreti antimaṁ dehaṁ,
jetvā māraṁ savāhinin”ti.
“She’s known as Sukkā because of her bright qualities,
free of greed, serene.
She bears her final body,
having vanquished Māra and his mount.”
… Sukkā therī ….


How To Beat Your Company’s “Batterygate”
How To Beat Your Company’s “Batterygate”
In this weekly series, I opine on how language and content affect the way we understand the products and services around us. I do this for your entertainment and education (and, of course, to remind you that if you’re looking for a freelance copy, content, product, or technical writer… yada yada, hire me).
After working in product and tech comms for 10 years, there’s still tons I don’t know. That said, I have learned a few things:
- A good product in market is better than a perfect product in development.
- No one knows the customer’s pain better than customers.
- Prospects (active and passive) are just as important as customers — if and only if you know how, and when, to listen to them.
- A feature list is not a roadmap.
- An exit is not a vision.
I could go on (and I probably will in another post at some point), but above all else, the lesson I’ve learned most painfully is that a product company is not smarter than its customers.
There are many reasons why this is true, but if you approach your business like this, you’re eventually going to have something blow up on you.  And you’re going to do so because you act from a place of feeling you’re smarter than your customers.
When you do? You end up, like Apple, with your own Batterygate.
Wait, What Happened?
Late last year, a fervor broke out on Reddit when evidence surfaced that seemed to confirm what many had long believed: Apple had built software to limit performance on older phones. It had planned obsolescence.
To get to the bottom of this issue, Primate Labs’ John Poole performed a deep analysis on the battery life of various iPhone models.
Sure enough, he validated what appeared to be true. Apple was throttling performance on old phones.
What Followed
Every blogger, critic, and mainstream new outlet jumped on the story. Tech companies are the new banks, after all, and villainy that simply could not stand was afoot.
Within 10 days, Apple conceeded with a (rare) formal apology about the matter.
The reality behind the hysteria is, as usual, more complex than the bubbling conspiracy suggested.
The lithium ion batteries employed in virtually every rechargeable device today have one fatal flaw (aside from exploding): they degrade over time. This is as true for Samsung phones as it is for Apple phones as it is for your crappy wireless speaker that you take to the beach. Eventually, all of our rechargable devices will be unable to hold a charge.
The Result
Unfortunately for Apple, because it had never addressed this issue with its consumers, and given its position as a market leadaer, the company was left open to the absolute assault on it that followed the story’s break.
Apple had to make a number of major corrective actions:
- It lowered the price of its battery replacement program (which is already a lot more generous and easy to make use of than similar programs from other smartphone providers)
- It published a slab of content detailing how to maximize battery performance, direct from its brand (as opposed to via Support)
- It committed to investing further R&D dollars towards improving the way that iOS exposes, and allows for configuration of, its battery management features.
In spite of these actions, the company almost immediately came under formal investigation by a number of governments alongside its major rival Samsung,
In parallel, it failed to stem the tide of negative consumer sentiment which rivaled Antennagate — and at a time when the competition has been poking at Apple’s approach to battery tech pretty visibly.
The Takeaway
You might argue that Apple took the brunt of the battery blowback simply because it’s “the biggest brand”.
Sure, Apple has been trying to ignore the whole planned obselence thing for years (the iPod was a famous perpetrator, as an example), and even had a major previous “batterygate” event in 2011.
Yet, it has never before been hit so hard, so fast, with so much fervor about the issue, and that’s why I believe Apple could have avoided this.
How Apple Failed
Apple’s big failure here was rooted, perhaps ironically, in the same behaviour that has made it successful in its product marketing and advertising efforts previously.
Apple’s go-to-market approach is aimed towards, and predominantly messages to, a consumer-base that it considers largely uneducated about tech.
Indeed, somewhere buried within a Keynote presentation at the Cupertino campus exists a group of personas ranging from the “average preteen in middle America” to the “New York Wall Street hedgefund manager”.
The tie that binds these personas? A fundamental belief (born from Apple’s understanding of user pain) that their device “should just work”, with the underlying assumptive corrollary of “…and I don’t care how it does”.
But that deck must be dated 2010, stagnant and unrepresentative of the market now shifted — and that corrollary is where the issue stems.
As the prices of personal technology have climbed, so too has consumers’ general, literal, and emotional investment in the devices that line their person.
As phones have gotten faster, thinner, bigger, lighter, only one major area of innovation remains largely untapped: the battery. Batteries haven’t gotten much better, and our expectations of battery life reflect that.
We’ve all felt the pang of the red battery icon. And that’s a pain that Apple missed on its lean canvases. That’s why batterygate is so triggering.
The idea that Apple is not only not solving for but rather actively hindering the lifespan of a phone’s battery is something any consumer will have a kneejerk reaction to, and understandably at that.
So, how could this have been avoided?
What Would PMM Do
There’s a well-worn idiom in the world of product development for when something goes wrong in a somewhat useful way: we like to say “it’s not a bug; it’s a feature”.
I’ve always considered that statement to be a perfect example of why product marketing is so important: it’s all in how you position your features.
Apple chose a very deliberate positioning for battery management in iOS, particularly in the last few releases: it deemed the topic too “unsexy” to discuss or build around. Wireless charging is way cooler and a more “sellable” problem to the battery issue, the company thought.
But with an understanding for a user’s pain (“my battery sucks and as my phone gets older, it keeps randomly dying on me”) and with respect for a user’s interest in the matter (as well as their high-level understanding of the tech in their phone), the company’s go-to-market for its new battery tech should’ve looked more like this:
By working the battery tech into a “feature”, rather than having it manifest to user as a “bug”, the company could have shaped the story from the get-go. People would have been aware of, and expecting, those new capabilities.
Would they have still been critical about them? Absolutely. But the mea culpa from “it doesn’t work quite as we’d hoped” is a patch, not a PR campaign.
In Apple’s underestimation of its consumer base, and what they find important, Apple created a huge problem that a little bit of smart product marketing on a website could’ve solved — for far less money.
TL;DR
Know your audience, know their pains, and don’t underestimate them. The more you try to hide, the more likely your attempt to outsmart your customer will come back to bite you.
What about you? Any lessons you’ve drawn from this? Respond away. And if you’d like to learn more about me or my business, visit www.frankcaron.com.


3 Basic operators
In the previous chapter, we saw Elixir provides +
, -
, *
, /
as arithmetic operators, plus the functions div/2
and rem/2
for integer division and remainder.
Elixir also provides ++
and --
to manipulate lists:
iex> [1,2,3] ++ [4,5,6]
[1,2,3,4,5,6]
iex> [1,2,3] -- [2]
[1,3]
String concatenation is done with <>
:
iex> "foo" <> "bar"
"foobar"
Elixir also provides three boolean operators: or
, and
and not
. These operators are strict in the sense that they expect a boolean (true
or false
) as their first argument:
iex> true and true
true
iex> false or is_atom(:example)
true
Providing a non-boolean will raise an exception:
iex> 1 and true
** (ArgumentError) argument error
or
and and
are short-circuit operators. They only execute the right side if the left side is not enough to determine the result:
iex> false and error("This error will never be raised")
false
iex> true or error("This error will never be raised")
true
Note: If you are an Erlang developer,
and
andor
in Elixir actually map to theandalso
andorelse
operators in Erlang.
Besides these boolean operators, Elixir also provides ||
, &&
and !
which accept arguments of any type. For these operators, all values except false
and nil
will evaluate to true:
# or
iex> 1 || true
1
iex> false || 11
11
# and
iex> nil && 13
nil
iex> true && 17
17
# !
iex> !true
false
iex> !1
false
iex> !nil
true
As a rule of thumb, use and
, or
and not
when you are expecting booleans. If any of the arguments are non-boolean, use &&
, ||
and !
.
Elixir also provides ==
, !=
, ===
, !==
, <=
, >=
, <
and >
as comparison operators:
iex> 1 == 1
true
iex> 1 != 2
true
iex> 1 < 2
true
The difference between ==
and ===
is that the latter is more strict when comparing integers and floats:
iex> 1 == 1.0
true
iex> 1 === 1.0
false
In Elixir, we can compare two different data types:
iex> 1 < :atom
true
The reason we can compare different data types is pragmatism. Sorting algorithms don't need to worry about different data types in order to sort. The overall sorting order is defined below:
number < atom < reference < functions < port < pid < tuple < maps < list < bitstring
You don't actually need to memorize this ordering, but it is important just to know an order exists.
Well, that is it for the introduction. In the next chapter, we are going to discuss some basic functions, data type conversions and a bit of control-flow.