Build a solution specific to your needs and skip the rest. StoreCat's modular nature makes your system unique to you.
Keep all your products and images in one place. Simple import tools make getting started a snap, so you can focus on selling.
Easily connect your web store, ERP, suppliers' catalogs, and other tools to manage your entire market from a central command post.
With products and pricing that update automatically, your team can focus on keeping customers happy, and selling more.


Mga Passive Scan Rules
General Configuration
Trusted Domains
You can specify a comma separated list of URL regex patterns using the rules.domains.trusted
parameter via the Options 'Rule configuration' panel.
Any link URL that matches one of these patterns will be considered to be in a trusted domain and will therefore not be reported.
Following rules supports Trusted Domains :
- Cross Domain Script Inclusion
- Reverse Tabnabbing
The following release status passive scan rules are included in this add-on:
Anti-clickjacking Header
This scan rule checks for the existence and validity of the X-Frame-Options header, or Content-Security-Policy 'frame-ancestors' directive.
At MEDIUM and HIGH thresholds this only looks at non-error or non-redirect HTML responses.
At LOW threshold it looks at all text responses including errors and redirects.
The following conditions may result in an alert:
- Missing Anti-clickjacking Header: If the X-Frame-Options header is missing from the response completely.
- Multiple X-Frame-Options Header Entries: When more than one X-Frame-Options header is detected on the response.
- X-Frame-Options Defined via META (Non-compliant with Spec): A "http-equiv" entry was found in the response that attempts to define X-Frame-Options, which is not supported by the specification.
- X-Frame-Options Setting Malformed: The header is present with no value, or the value is not as expected (i.e.: other than "DENY", or "SAMEORIGIN").
By default no alerts will be raised in the response includes a Content-Security-Policy 'frame-ancestors' element as this take precedence over the X-Frame-Options header.
However at LOW threshold the above issues will still be reported but at a LOW risk.
Latest code: AntiClickjackingScanRule.java
Application Errors
Check server responses for HTTP 500 - Internal Server Error type responses or those that contain a known error string.
Note: Matches made within script blocks or files are against the entire content not only comments.
At HIGH Threshold don’t alert on HTTP 500 (but do for other error patterns). Also, such known error strings are much less likely to be relevant in static pages like JS / CSS so these files are only scanned at LOW threshold.
For Internal Server Error (HTTP 500) the Alert is set to Low risk and in other case it is set to Medium risk.
Note: If the Custom Payloads addon is installed you can add your own Application Error strings (payloads) in the Custom Payloads options panel.
They will also be searched for in responses as they're passively scanned. Keep in mind that the greater the number of payloads the greater the
amount of time needed to passively scan.
It is also possible to add patterns to the xml/application_errors.xml
file in ZAP's user directory.
Latest code: ApplicationErrorScanRule.java
Big Redirect Detected (Potential Sensitive Information Leak)
This check predicts the size of various redirect type responses and generates an alert if the response is greater than the predicted size.
A large redirect response may indicate that although a redirect has taken place the page actually contained content (which may reveal sensitive information, PII, etc.).
Latest code: BigRedirectsScanRule.java
Cache Control
Checks "Cache-Control" response headers against general industry best practice settings for protection of sensitive content.
At MEDIUM and HIGH thresholds only non-error or non-redirect text responses (excluding JavaScript and CSS) are considered.
At LOW threshold all responses are considered including errors and redirects.
Latest code: CacheControlScanRule.java
Charset Mismatch
This check identifies responses where the HTTP Content-Type header declares a charset different from the charset defined by the body of the HTML or XML. When there's a charset mismatch between the HTTP header and content body Web browsers can be forced into an undesirable content-sniffing mode to determine the content's correct character set.
The scan rule handles various conditions depending on the Threshold set for the rule, as follows:
- All Thresholds:
- Header Versus Meta Content-Type Charset - The declaration in the HTTP Content-Type header doesn't match what is declared in a META Content-Type tag.
- Header Versus Meta Charset - The declaration in the HTTP Content-Type header doesn't match what is declared in a META Charset tag.
- Low Threshold:
- Meta Content-Type Charset Missing - The response doesn't contain a META Content-Type declaration, which may overlook older clients.
- Meta Charset Versus Meta Content-Type Charset - The response contains both a META Content-Type declaration and a META Charset declaration, and they don't match.
Further reference:
http://www.w3.org/TR/html401/charset.html#h-5.2.2
http://www.w3.org/TR/html5/document-metadata.html#charset
Latest code: CharsetMismatchScanRule.java
Content Security Policy (CSP) Header Not Set
This checks HTML response headers for the presence of a Content Security Policy header, or the response body for CSP specified via META tag.
By default this rule checks for the presence of the "Content-Security-Policy", "X-Content-Security-Policy",
and "X-WebKit-CSP" headers. Redirects and non-HTML responses are ignored except at the Low threshold.
If a "Content-Security-Policy" header is not found, an alert is raised.
If an "X-Content-Security-Policy" or "X-WebKit-CSP" header is found, an INFO alert is raised. This may represent an outdated enforcement implementation.
If a "Content-Security-Policy-Report-Only" header is found on a response an INFO alert is raised. This may represent an enforcement effort
that is actively being refined or developed, or one which is only partially implemented.
Note: This rule does not perform any actual analysis of the specified policy, for that please ensure the CSP scan rule is enabled.
Latest code: ContentSecurityPolicyMissingScanRule.java
Content Type Missing
Raises an alert if the response is lacking a Content-Type header or if the header exists but the value is empty.
Latest code: ContentTypeMissingScanRule.java
Cookie HttpOnly
Ensures that as cookies are set they are flagged HttpOnly. The HttpOnly flag indicates to browsers that the cookie
being set should not be acted upon by client side script (such as JavaScript).
Latest code: CookieHttpOnlyScanRule.java
Cookie - Loosely Scoped
Cookies can be scoped by domain or path. This check is only concerned with domain scope.The domain scope applied to a cookie determines which domains can access it. For example, a cookie can be scoped strictly to a subdomain e.g. www.nottrusted.com
, or loosely scoped to a parent domain e.g. nottrusted.com
. In the latter case, any subdomain of nottrusted.com
can access the cookie. Loosely scoped cookies are common in mega-applications like google.com
and live.com
.
Latest code: CookieLooselyScopedScanRule.java
Cookie Poisoning
This check looks at user-supplied input in query string parameters and POST data to identify where cookie parameters might be controlled.
This is called a cookie poisoning attack, and becomes exploitable when an attacker can manipulate the cookie in various ways. In some cases this will not be exploitable, however, allowing URL parameters to set cookie values is generally considered a bug.
Latest code: UserControlledCookieScanRule.java
Cookie Secure Flag
Looks for cookies set during HTTPS sessions, raises an alert for those that are set but do not include the secure flag.
A cookie set with the secure flag will not be sent during a plain HTTP session.
Latest code: CookieSecureFlagScanRule.java
Cookie Without SameSite Attribute
This reports any cookies that:
- do not have the SameSite attribute
- have the attribute set to "None" (ignored at HIGH Threshold)
- do not have a recognised valid value for that attribute
Latest code: CookieSameSiteScanRule.java
Cross Domain Script Inclusion
Validates whether or not scripts are included from domains other than the domain hosting the content.
By looking at the "src" attributes of "script" tags in HTML responses.
Allowed Cross-Domain scripts:
- Any script with a non-empty "integrity" attribute is ignored - the integrity value is not checked as this will be checked by the browser
- At MEDIUM and HIGH thresholds if a script URL falls within a context that also includes the URL of the base message no alerts will be raised.
- This rule supports Trusted Domains, check "General Configuration" for more information.
Latest code: CrossDomainScriptInclusionScanRule.java
Cross Domain Misconfiguration
Passively scan responses for Cross Domain MisConfigurations, which relax the Same Origin Policy in the web browser, for instance.
The current implementation looks at excessively permissive CORS headers.
Latest code: CrossDomainMisconfigurationScanRule.java
CSP (Content Security Policy)
The Content Security Policy (CSP) passive scan rule parses and analyzes CSP headers and META definitions for potential misconfiguration
or weakness. This rule leverages Shape Security's Salvation
library to perform it's parsing and assessment of CSPs.
If a response has multiple CSPs they are analyzed individually, as there is no sure way to intersect/merge the policies and further different browsers have varying levels of CSP support and enforcement.
Latest code: ContentSecurityPolicyScanRule.java
CSRF Countermeasures
This rule identifies "potential" vulnerabilities with the lack of known CSRF
countermeasures in pages with forms.
At HIGH alert threshold only scans messages which are in scope.
Post 2.5.0 you can specify a comma separated list of identifiers in the
rules.csrf.ignorelist
parameter via the Options 'Rule configuration' panel.
Any FORMs with a name or ID that matches one of these identifiers will be ignored when scanning for missing Anti-CSRF tokens.
Only use this feature to ignore FORMs that you know are safe, for example search forms.
Form element names are sorted and de-duplicated when they are printed in the Zap Report.
Latest code: CsrfCountermeasuresScanRule.java
Directory Browsing
Passively scans responses for signatures that are indicative that Directory Browsing is possible.
Latest code: DirectoryBrowsingScanRule.java
Hash Disclosure
Passively scans for password hashes disclosed by the web server.
Various formats are including, including some formats such as MD4, MD5, and SHA*, which are sometimes used for purposes other than to contain password hashes.
Note: This scan rule will only analyze JavaScript responses on LOW Threshold.
Latest code: HashDisclosureScanRule.java
Heartbleed OpenSSL Vulnerability (Indicative)
Passively scans for HTTP header responses that may indicate that the server is vulnerable to the critical HeartBleed OpenSSL vulnerability.
Latest code: HeartBleedScanRule.java
HTTP Server Response Header
This checks response headers for the presence of a server header that contains version details.
At LOW Threshold will raise an alert based on presence of the header field whether or not a version string is detected.
Latest code: ServerHeaderInfoLeakScanRule.java
HTTP to HTTPS Insecure Transition in Form Post
This check looks for insecure HTTP pages that host HTTPS forms. The issue is that an insecure HTTP page can easily be hijacked through MITM and the secure HTTPS form can be replaced or spoofed.
Latest code: InsecureFormLoadScanRule.java
HTTPS to HTTP Insecure Transition in Form Post
This check identifies secure HTTPS pages that host insecure HTTP forms. The issue is that a secure page is transitioning to an insecure page when data is uploaded through a form. The user may think they're submitting data to a secure page when in fact they are not.
Latest code: InsecureFormPostScanRule.java
Information Disclosure: Debug Errors
This passive scan rule checks the content of web responses for known Debug Error message fragments.
Access to such details may provide a malicious individual with means by which to further abuse the web site.
They may also leak data not specifically meant for end user consumption.
Note: Javascript responses are only assessed at LOW threshold.
Latest code: InformationDisclosureDebugErrorsScanRule.java
Information Disclosure: In URL
Attempts to identify the existence of sensitive details within the visited URIs themselves
(this may include parameters, document names, directory names, etc.).
Latest code: InformationDisclosureInUrlScanRule.java
Information Disclosure: Referrer
Identifies the existence of sensitive details within the Referrer header field of HTTP requests
(this may include parameters, document names, directory names, etc.).
Note: In the case of suspected credit card identifiers in the Referrer value, the potential credit card numbers are looked up against a Bank Identification
Number List (BINList). If a match is found the alert is raised at High confidence and additional details are added to the 'Other Information' field in the alert,
otherwise the alerts will have Medium confidence.
See: binlist-data for more information.
Latest code: InformationDisclosureReferrerScanRule.java
Information Disclosure: Suspicious Comments
Analyzes web content to identify comments which contain potentially sensitive details. Which may lead to
further attack or exposure of unintended data.
Note: The strings to look for can be extended by using the Custom Payloads addon.
Latest code: InformationDisclosureSuspiciousCommentsScanRule.java
Insecure Authentication
HTTP basic or digest authentication has been used over an unsecured connection. The credentials can be read and then reused by someone with access to the network.
Latest code: InsecureAuthenticationScanRule.java
Insecure JSF ViewState
The response contains a Java Server Faces (JSF) ViewState value that has no cryptographic protections.
Latest code: InsecureJsfViewStatePassiveScanRule.java
Mixed Content
For content served via HTTPS analyse all the src attributes in the response looking for those sourced
via plain HTTP.
Latest code: MixedContentScanRule.java
Modern Web Application
This raises an informational alert if a site appears to be a modern web application.
It does not indicate any potential vulnerabilities but it could indicate that the ajax spider might be more effective at exploring this site compared to the traditional spider.
Latest code: ModernAppDetectionScanRule.java
Open Redirect
This check looks at user-supplied input in query string parameters and POST data to identify where open redirects might be possible. Open redirects occur when an application allows user-supplied input (e.g. http://nottrusted.com) to control an offsite redirect. This is generally a pretty accurate way to find where 301 or 302 redirects could be exploited by spammers or phishing attacks.
Latest code: UserControlledOpenRedirectScanRule.java
PII Disclosure
PII is information like credit card number, SSN etc. This check currently reports only numbers which match credit card numbers and pass Luhn checksum, which gives high confidence, that this is a credit card number (images and CSS are ignored).
At MEDIUM and HIGH threshold it attempts to use three characters of context on each side of potential matches to exclude matches within decimal like content.
At LOW threshold, alerts will be raised for such matches.
PDFs are only evaluated at LOW threshold.
Note: In the case of suspected credit card values, the potential credit card numbers are looked up against a Bank Identification Number List
(BINList). If a match is found the alert is raised at High confidence and additional details are added to the 'Other Information' field in the
alert, otherwise the alerts will have Medium confidence.
See: binlist-data for more information.
Latest code: PiiScanRule.java
Private Address Disclosure
Checks the response content for inclusion of RFC 1918 IPv4 addresses as well as
Amazon EC2 private hostnames (for example, ip-10-0-56-78). This information can give an attacker
useful information about the IP address scheme of the internal network, and might be helpful for
further attacks targeting internal systems.
This passive scan rule may generate false positives in the case of larger dotted numeric strings,
such as vp<IP_ADDRESS>.01.09.16, where the latter 4 octets appear to be a RFC 1918 IPv4 address.
After review an analyst can mark such alerts as False Positives in ZAP. For handling during
repeated scans the "Context Alert Filters" add-on could be leveraged.
Latest code: InfoPrivateAddressDisclosureScanRule.java
Retrieved from Cache
This scan rule detects content that has been served from a shared cache.
Latest code: RetrievedFromCacheScanRule.java
Reverse Tabnabbing
This checks to see if any links use a target attribute using "opener" keyword in the "rel" attribute, as this may allow target pages to take over the page that opens them.
By default this rule will ignore all links that are in the same context as the page. At the LOW threshold it will only ignore links that are on the same host.
At HIGH threshold it will only report links that use the "_blank" target.
This rule supports Trusted Domains, check "General Configuration" for more information.
Latest code: LinkTargetScanRule.java
Server Leaks Information via "X-Powered-By" HTTP Response Header Field(s)
This checks response headers for the presence of X-Powered-By details.
Latest code: XPoweredByHeaderInfoLeakScanRule.java
Session ID in URL Rewrite
This scan rule checks for the existence of session token type parameters being rewritten to the URL.
To help reduce false positives the rule checks the length of the token value, if the value of the parameter
is not greater than 8 characters in length then the parameter is ignored
(i.e.: survey?sId=5 would not be flagged as vulnerable).
Latest code: InfoSessionIdUrlScanRule.java
Strict Transport Security Header
This rule checks HTTPS responses for the presence of a HTTP Strict Transport Security (HSTS) header and tests for various implementation concerns,
alerting if they're found.
Alerts generated:
- Strict-Transport-Security Header Not Set: If the response is HTTPS and the header is completely missing.
- Strict-Transport-Security Disabled: If the response is HTTPS and the max-age value is set to zero, thus resetting the browser's HSTS information for the site.
- Strict-Transport-Security Multiple Header Entries (Non-compliant with Spec): If the response is HTTPS and there is more than one HSTS header on the response.
- Strict-Transport-Security Missing Max-Age (Non-compliant with Spec): If the response is HTTPS, a HSTS header is specified but the max-age value does not contain a number.
- Strict-Transport-Security Defined via META (Non-compliant with Spec): If the response body includes a META tag which attempts to define HSTS.
- Strict-Transport-Security Header on Plain HTTP Response: If the response is HTTP and the HSTS header is present.
- Strict-Transport-Security Max-Age Malformed (Non-compliant with Spec): If the response is HTTPS and the HSTS header is present, but there are quotes preceding the max-age directive (quotes are allowed around the max-age value, but not around the directive itself).
- Strict-Transport-Security Malformed Content (Non-compliant with Spec): If the response is HTTPS and a HSTS header is present, but there is some unexpected content (such as curly quotes). The expectation is that the content be printable ASCII.
Redirects to HTTPS URLs on the same domain will only be reported at Low threshold.
Latest code: StrictTransportSecurityScanRule.java
Timestamp Disclosure
A timestamp was disclosed by the application/web server.
At HIGH threshold this rule does not alert on potential timestamps that are not within a range of plus or minus one year.
At MEDIUM threshold this rule does not alert on potential timestamps beyond 10 years.
At all thresholds, this rule will not alert on timestamps beyond the Y2038 epoch edge.
Latest code: TimestampDisclosureScanRule.java
User Controllable Charset
This check looks at user-supplied input in query string parameters and POST data to identify where Content-Type or meta tag charset declarations might be user-controlled. Such charset declarations should always be declared by the application. If an attacker can control the response charset, they could manipulate the HTML to perform XSS or other attacks.
Latest code: UserControlledCharsetScanRule.java
User Controllable HTML Element Attribute (Potential XSS)
This check looks at user-supplied input in query string parameters and POST data to identify where certain HTML attribute values might be controlled. This provides hot-spot detection for XSS (cross-site scripting) that will require further review by a security analyst to determine exploitability.
Latest code: UserControlledHTMLAttributesScanRule.java
User Controllable Javascript Event (XSS)
This check looks at user-supplied input in query string parameters and POST data to identify where certain HTML attribute values might be controlled. This provides hot-spot detection for XSS (cross-site scripting) that will require further review by a security analyst to determine exploitability.
Latest code: UserControlledJavascriptEventScanRule.java
Username Hash Found
If any context contains defined users this scan rule checks all responses for the presence of hashed values representing those usernames.
Note: If the Custom Payloads addon is installed you can add your own Username strings (payloads) in the Custom Payloads options panel.
They will also be hashed and searched for in responses as they're passively scanned. Keep in mind that the greater the number of payloads the greater the
amount of time needed to passively scan. (The default payloads are "Admin" and "admin".)
Discovery of any such value may represent an Insecure Direct Object Reference (IDOR) vulnerability. Alerts are only raised as informational items as further manual testing is required in order to confirm and assess impact.
Latest code: UsernameIdorScanRule.java
VIEWSTATE
Attempts to identify VIEWSTATE parameters and analyze said parameters for various best practices or protective
measures such as:
- Those based on ASP.NET 1.0 and 1.1.
- VIEWSTATE Lacking signature.
- Split VIEWSTATE.
- VIEWSTATE containing email or IP patterns.
The "Viewstate without MAC Signature (Unsure)" alert will only be raised at LOW threshold.
Latest code: ViewstateScanRule.java
X-AspNet-Version Response Header
This checks response headers for the presence of X-AspNet-Version/X-AspNetMvc-Version details.
Latest code: XAspNetVersionScanRule.java
X-Backend-Server Header Information Leak
This checks response headers for the presence of X-Backend-Server details.
Latest code: XBackendServerInformationLeak.java
X-ChromeLogger-Data Header Information Leak
This checks response headers for the presence of X-ChromeLogger-Data or X-ChromePhp-Data details.
Latest code: XChromeLoggerDataInfoLeakScanRule.java
X-Content-Type-Options
This scan rule check for the Anti-MIME-Sniffing header X-Content-Type-Options and ensures it is set to 'nosniff'.
At MEDIUM and HIGH thresholds this rule does not alert on client or server error responses or redirects.
At LOW threshold it will alert on all responses including errors and redirects.
Latest code: XContentTypeOptionsScanRule.java
X-Debug-Token Information Leak
This checks response headers for the presence of X-Debug-Token and X-Debug-Token-Link details.
Which indicates the use/exposure of Symfony's Profiler. Symfony's Profiler provides access to a significant amount of information of interest to malicious individuals and Security Testers.
Latest code: XDebugTokenScanRule.java


public class LangDetect
extends java.lang.Object
| Modifier and Type | Class and Description |
|---|---|
private class |
LangDetect.ProfileDistance
This class is a simple data structure that represents a profile together
with its out-of-place measure to another profile.
|
| Modifier and Type | Field and Description |
|---|---|
private java.util.Scanner |
input
Command line input
|
private java.util.Collection<Profile> |
langProfiles
Frequency profiles of known languages
|
private Tokenizer |
tok
Tokenizer to create n-grams
|
private static java.lang.String |
trainingFolder
Folder containing training texts for languages
|
| Constructor and Description |
|---|
LangDetect(java.lang.String trainingFolder)
Creates a new language detector that is initialized by reading the
provided training texts.
|
| Modifier and Type | Method and Description |
|---|---|
private Profile |
findBestProfile(Profile queryProfile)
Calculates out-of-place measures with all language profiles and returns
the closest profile.
|
private java.lang.String |
getQuery()
Reads the next query string from the command line.
|
private java.lang.String |
initProfiles(java.io.File folder)
Reads training texts from the given folder and calculates the
corresponding frequency profiles.
|
static void |
main(java.lang.String[] args)
Instantiates a new language detector and starts a query session.
|
void |
startQuerySession()
Starts a query session in the command line.
|
private static final java.lang.String trainingFolder
private Tokenizer tok
private java.util.Collection<Profile> langProfiles
private java.util.Scanner input
public LangDetect(java.lang.String trainingFolder) throws java.lang.IllegalArgumentException
java.lang.IllegalArgumentException
- if no valid training data path is foundpublic static void main(java.lang.String[] args)
args
- as a parameter, a folder containing the training texts can be
passedpublic void startQuerySession()
private java.lang.String initProfiles(java.io.File folder)
folder
- Folder with training textsprivate java.lang.String getQuery()


The exercise below will test your newly acquired knowledge of Horner's Method, which is used in the Rabin-Karp algorithm. You will be provided with values for Q, C, and a random string. Please use the text field to fill in the 'Magic Number' of the given string. When you are finished hit Check Answer to see if you are correct. Use the provided pseudo code to help you find your answer. (A calculator may be necessary.)
Your solution:
[started]
if (!checkAnswer() && !guess[0])
return "";
else return checkAnswer();


TAMOC - Texas A&M Oilspill Calculator¶
TAMOC is a Python package with Fortran extension modules that provides various functionality for simulating a subsea oil spill. This includes methods to compute equations of state of gas and oil, dissolution, transport of single bubbles and/or droplets, and simulations of blowout plumes, including the development of subsurface intrusions, and estimation of initial bubble/droplet size distributions from source flow conditions.
For typical usage, please see the ./bin directory of the source distribution for various example scripts.
- Version 2.0.0: Updated the complete model system for compatibility with both
Python 2.7 and Python 3.8+. Updated the ambient.Profile object so that netCDF files do not have to be created, including the ability to create a default profile for the world-ocean average profile. Create new modules for particle size distributions and for simulating a blowout, including a new Blowout object.
- Version 1.2.1: Corrected minor errors in translating between NetCDF objects
and Numpy arrays to avoid a masked-array error and updated the dbm_phys.f95 function for the mass transfer rate by Kumar and Hartland so that the Reynolds number is defined before it is used.
- Version 1.2.0: Added biodegradation to the fate processes considered in the
discrete bubble model (DBM).
- Version 1.1.1: Updated the ambient module interpolation method to be
compatible with newer versions of numpy, updated a few of the ./bin examples to only read data provided with TAMOC, and updated all test cases to be compatible with slight changes in the dbm module that were done in Version 1.1.0.
- Version 1.1.0: Updated various modules to be compatible with Anaconda
Python, including Scipy version 0.17.0 and higher. Fixed a couple bugs in the test cases where output files are not created correctly. Updated the documentation with some missing new variables.
- Version 1.0.0: Finalized the validation cases and tested the model for
release. This is the first non-beta version of the model, and is the version for which journal publications have been prepared. Most of the changes going forward are expected to be new capabilities and improvements in the user interface: the model solutions are not expected to change appreciably.
Beta versions of the model:
- Version 0.1.17: Updated the modeling suite so that all of the save/load
functions are consistent with the present model variables and attributes. Modified the bent plume model so that ambient currents can come from any direction (three- dimensional). Added a new test file for the bent plume model. Changed the convergence criteria for the stratified plume model.
- Version 0.1.16: Updated the bent plume model so that post processing is
fully consistent with the simulation results. Also, added the capability for the bent plume model to stop at the neutral buoyancy level in the intrusion for a stratified case. Updated the equilibrium calculations in the dbm module so that it does not crash when the first few elements of the mixture disappear (go to zero) and to speed up the calculation when successive substitution indicates the mixture may be single phase, but is slowly converging: stability analysis is initiated early, which greatly improves performance for difficult cases.
- Version 0.1.15: Moved the particle tracking in the bent plume model inside
the main integration loop, which then removes tp and sp from the model attributes and includes then in the model state space instead. Updated the bent plume model state space so that particle mass is the state variables instead of particle mass flux and so that the dissovled phase constituents are modeled as total mass in the Lagrangian element instead of concentration times mass of the element. Made a small update to the hydrate formation time equations.
- Version 0.1.14: Updated several aspects of the calibration after comparing
to available data in Milgram (1983), Jirka (2004), Socolofsky and Adams (2002, 2003, 2005), Socolofs et al. (2008), and Socolofsky et al. (2013). The most significant change is an updated shear entrainment coefficient for the stratified plume model. Also, added a buoyant force reduction as bubbles drift away from the centerline in a crossflow.
- Version 0.1.13: Updated the temperature output for the bent plume model so
that the correct temperature is saved when heat transfer ends. Added the particle time to the state space of the stratified plume model and added the hydrate formation model of Jun et al. (2015) to the particle objects in the dispersed phases module. The hydrate formation time is set at the start of a simulation and is properly implemented for all three simulation modules in the
TAMOC
suite. To compute the hydrate formation time using the equations from Jun et al. (2015), use the function dispersed_phases.hydrate_formation_time.- Version 0.1.12: Replaced methods for equilibrium and viscosity with better
algorithms. Fixed small inconsistencies in the dbm.py module for clean bubbles, and updated the seawater equations of state with better methods for heat capacity and air/water surface tension. Updated values for the Setschenow constant in ./data/ChemData.csv, and added a mass transfer equation for Re < 1.
- Version 0.1.11: Replaced some of the -9999 values in the ./data/ChemData.csv
file with literature values and updated the units of the calcualtion of Vb in dbm.py when data are not available. Also, updated the parameter values for the stratified plume model with the values recommended in Socolofsky et al. (2008).
- Version 0.1.10: Updated the values for Vb in the ./data/ChemData.csv file
with their correct values. Improves computation of diffusivity and mass transfer over Version 0.1.9, and gives results similar to Version 0.1.8 and older that used a different method to estimate diffusivity.
- Version 0.1.9Made several minor changes to the equations of state per the
guidance of Jonas Gros. These changes make the model much more robust for hydrocarbon mixtures. The updates are minor in that the results do not change markedly for the test cases already in previous versions of the model. However, the changes provide major advantages for more difficult cases, not demonstrated in the simple ./bin examples.
- Version 0.1.8Added print capability to the params.py module and upgraded
the shear entrainment model in the bent_plume_model.py to the entrainment equations in Jirka 2004.
- Version 0.1.7Added the capability for the bent_plume_model.py to continue
to track particles outside the plume using the single_bubble_model.py. Fixed a bug where particles outside the plume continued to dissolve and add mass to the bent_plume_model.
- Version 0.1.6Added a new simulation module for plumes in crossflow: the
bent_plume_model.py. Refactored some of the code for the original model suite to make it more general and to reuse it in the bent_plume_model. Added example files and unit tests for the new modules, and updated the documentation to reflect all model changes.
- Version 0.1.5Fixed a small bug in the way the bubble force is handled
after the particle dissolves. Fixed a bug to retain mass conservation for a bubble size distribution using the sintef.rosin_rammler() function.
- Version 0.1.4Added script for the the sintef and params modules to the
./bin examples directory and the /test unit tests. Improved the stability of the model by added a few new checks during and before calculation. Updated the unit tests to make them more platform and numpy-version independent.
- Version 0.1.3Removed some of the debugging catches in the iteration so that
solutions always fully converge and fixed a few bugs. See CHANGES.txt for full details. Added the sintef.py module for computing initial bubble/droplet size distributions.
- Version 0.1.2Refined the test suite for compatibility with multiple
versions of numpy and scipy. Corrected a few more minor bugs.
- Version 0.1.1Full modeling suite with small bug fixes and complete test
suite..
- Version 0.1.0First full modeling suite release, including the stratified
plume module.
- Version 0.0.3Updated to include the single bubble model and the ambient
module for handling ambient CTD data. Includes input and output using netCDF files and a complete set of tests in ./tamoc/test
- Version 0.0.2First model release, including the discrete bubble model
(dmb.py)
Version 0.0.1 : Initial template of files using setup.py
Requirements¶
This package requires:
Python 2.3 or higher and is now compatible with both Python 2.7 and Python 3.8+
Numpy version 1.6.1 or higher
Scipy version 0.17.0 or higher
A modern Fortran compiler
The Python netCDF4 package
For interaction with ROMS output, TAMOC also requires:
octant: download from https://github.com/hetland/octant
mpl_toolkits.basemap: download from http://sourceforge.net/projects/matplotlib/files/matplotlib-toolkits/
- NOTE: While this still works, octant has been deprecated and is now
replaced by the xarray package. TAMOC has not yet been updated to use xarray.
If profile data are available from ROMS, write a script to read the data into a numpy array and pass this data to the ambient.Profile object.
Code development and testing for this package was conducted in the Mac OS X environment, Version 10.13.6. The Python environments were created using miniconda. The Python 3 environment used Python 3.8.2; the Python 2 environment used Python 2.7.15. All scripts are tested in iPython with the –pylab flag.
Fortran files are written in modern Fortran style and are fully compatible with gfortran 4.6.2 20111019 (prerelease). They have been compiled and tested by the author using f2py Version 2.
Quick Start¶
Edit setup.cfg to select the appropriate C/C++ and Fortran compilers
Run ‘python setup.py build’ followed by ‘python setup.py install’ (with sudo if necessary).
Test the installation by opening a Python session and executing import tamoc from the Python prompt. Be sure that you are not in the same directory as the setup.py file so that Python will look for tamoc in the main Python package repository on your system.
To run all the tests, cd to the ./test directory and execute ‘py.test’ from a command prompt. If pytest is not installed, follow the instructions here: http://pytest.org/latest/getting-started.html
Platforms¶
Windows 7¶
The following method has been tested for installation on Windows 7.
Install a complete Python distribution that includes Python, Numpy, and Scipy with versions compatible with the above list. Testing has been completed by the author using a 32-bit Python installation. The Python distribution will have to be compatible with your C/C++ and Fortran compiler. The free compilers available from MinGW that work with Python f2py are typically 32 bit. There are work-arounds, but the instructions here were all tested on 32-bit installations.
Download and install the MinGW compiler suite. During installation, be sure to select a C, C++, and Fortran compiler. See, http://sourceforge.net/projects/mingw/files/
Edit the Windows > System > Environment Variables so that the PATH can find your Python and MinGW installation.
Open a command prompt from Start > Run > Command Prompt and follow the steps in the Quick Start section above to complete installation.
Mac OS X / Unix¶
The following method has been tested for installation on Mac OS X 10.7.
Install a complete Python distribution that includes Python, Numpy, and Scipy with versions compatible with the above list. Testing has been completed by the author using a 32-bit and 64-bit Python installations. The Python distribution will have to be compatible with your C/C++ and Fortran compiler.
Install the free XCode app in order to provide C/C++ compiler capability. Be sure to install the command-line tools.
Download and install the gfortran binary. See, http://gcc.gnu.org/wiki/GFortranBinaries
Follow the steps in the Quick Start section above to complete installation.


Edit the ConceptCollection below, or paste in an existing ConceptCollection on the right hand side. Alternatively load a file using the "Choose file" button below.
When you've finished, make sure you save your changes using the "Download" button.
The live URL where this ConceptCollection is located, e.g. https://sportengland-jointhemovement.github.io/collections/boxing-fitness.jsonld
The name of this ConceptCollection, e.g. Boxing Fitness
The documented purpose of this ConceptCollection, e.g. Activity types that fit under the 'Boxing Fitness' drop down filter on the Join the Movement virtual timetable.


Load and play Dashboard Cam GPS file from local computer. File are located at the Dashboard Cam app record folders. File extension is ".gps". (ex: Rec-2013-06-26-14-30.gps)


A website that offers multiple choice questions to students. Students get to test their understanding of the content that they have covered.
The student should ensure that they answer all the qusetions.
On completion, click on the submit button upon which you'll receive your results.


Do not include any personal information, like your name or email address. We will delete any personal information you do include.
We are unable to respond to any feedback you leave here. For a response, fill out the support form.


Check out some of my Projects!
A Python program in which a sudoku board solves itself by using a backtracking algorithim.
A MATLAB school project that utilizes data masking to maniuplate images and their RGB values.
A GitHub repository with all the work I did during Google's 11 week SPS program.


ScatterPlot3DDemo3
Scatter plots showing different combinations of the Iris dataset. A feature of these charts is that they read JSON formatted data from a text file.


Intrinsic
the sky is the limit
Opportunity is missed by most people because it is dressed in overalls and looks like hard work. – Thomas Edison
Opportunity is missed by most people because it is dressed in overalls and looks like hard work. – Thomas Edison
Sometimes when you innovate, you make mistakes. It is best to admit them quickly and get on with improving your other innovations.
– Steve Jobs
To think is easy. To act is difficult. To act as one thinks is the most difficult.
– Johann Wolfgang Von Goeth
Yesterday’s home runs don’t win today’s games.
– Babe Ruth
The only way around is through.
– Robert Frost


wildignore in macvim
-
Nick Carter
So I've tried setting this to both a quote-delimited string and without delimiters, but it doesn't seem to be excluding the directory I've specified.
In this case I'm running :set wildignore+=out/**
This should remove all files from the out directory (relative to the cwd at the moment) correct? I still see matches under out after running this.
-
Nick Carter
Seems I needed to add this to an autocommand, which I've done. I do see out/ results, but they're further down the list which is good enough for now.
-
Greg Hurrell
Yep,
:set wildignore+=out/**
should definitely work.Can you post the contents of your
~/.vimrc
and also the output of:set wildignore?
-
Nick Carter
Contents follow. This is from my work machine, which is slightly different from the one at home and which I haven't gotten CommandT working on yet:
color vilight set ic set hls is set si set foldmethod=indent set foldnestmax=10 set nofoldenable set foldlevel=1 set nu set backspace=indent,eol,start set noro set nowrap set tabstop=2 set shiftwidth=2 set autoindent set wildignore+=out/** filetype plugin on syntax on set guifont=Lucida_Console:h14:cANSI set guioptions=""
"this wildignore should also affect :vim searches is my understanding, and they are still coming back with results from out/
-
Greg Hurrell
Not sure if
'wildignore'
affects:vim
searches or not. Perhaps it does.In any case, You can test the effect of your
'wildignore'
setting by calling theexpand()
function.For example, just say your
'wildignore'
contains 'foo' and you're in a directory with files "foo" and "bar":-
:echo expand("foo")
will echo nothing at all, because the "foo" file in the current directory is filtered out by the'wildignore'
setting -
:echo expand("bar")
will echo "bar", because "bar" is not filtered out -
:echo expand("baz")
will echo "baz", because even though "baz" doesn't exist in the current directory, neither does it get filtered out
So, if your settings are correct, then
:echo expand("out/foo/bar")
should echo nothing at all. -
Reply
This topic is now closed.


Name:
Length: Type:
Starting Point: Ending Point:
Segment/Edge ID:
Refresh
Network Segments:
Center: {{center.lat | number:5}}, {{center.lng | number:5}}


Talk to Sobert!
Connect
Name:
-
Status:
disconnected
Online users:
-
Talk to me on:
Telegram
Discord
Second Life
Source:
Github


Competitive Analysis
Flow
I conducted heuristic evaluations on different music applications (Spotify, SoundCloud, Apple Music, YouTube Red, Amazon Music). I compared the user flow for different aspects of Creating, Managing, and Sorting Playlists.
We wanted to make creating a playlist to be accessible as soon as the user opened the playlist option. In addition, we wanted users to be able to group playlists by topic or mood. Making the button icons more intuitive was another thing we worked on.
We also wanted to make editing songs in a playlist easier, whether it be re-ordering them or adding/deleting songs.


XPath uses path expressions to select nodes in an XML document. The node is selected by following a path or steps. The most useful path expressions are listed below:
| Expression | Description |
|---|---|
| nodename | Selects all nodes with the name "nodename" |
| / | Selects from the root node |
| // | Selects nodes in the document from the current node that match the selection no matter where they are |
| . | Selects the current node |
| .. | Selects the parent of the current node |
| @ | Selects attributes |
Predicates are used to find a specific node or a node that contains a
specific value.
Predicates are always embedded in square
brackets.
In the table below we have listed some path
expressions with predicates and the result of the expressions:
| Path Expression | Result |
|---|---|
| /bookstore/book[1] | Selects the first book element that is the child of the bookstore element. Index in xpath starts from 1 (not from zero). |
| /bookstore/book[last()] | Selects the last book element that is the child of the bookstore element |
| /bookstore/book[last()-1] | Selects the last but one book element that is the child of the bookstore element |
| /bookstore/book[position()<3] | Selects the first two book elements that are children of the bookstore element |
| //title[@lang] | Selects all the title elements that have an attribute named lang |
| //title[@lang='en'] | Selects all the title elements that have a "lang" attribute with a value of "en" |
| /bookstore/book[price>35.00] | Selects all the book elements of the bookstore element that have a price element with a value greater than 35.00 |
| /bookstore/book[price>35.00]/title | Selects all the title elements of the book elements of the bookstore element that have a price element with a value greater than 35.00 |
| /lst[contains(.,'two')] | Used to point to an element in list of elements. Eg: ["one", "two", "three"] |
XPath wildcards can be used to select unknown XML nodes.
| Wildcard | Description |
|---|---|
| * | Matches any element node |
| @* | Matches any attribute node |
| node() | Matches any node of any kind |
| Path Expression | Result |
|---|---|
| /bookstore/* | Selects all the child element nodes of the bookstore element |
| //* | Selects all elements in the document |
| //title[@*] | Selects all title elements which have at least one attribute of any kind |
By using the | operator in an XPath expression you can select several
paths.
In the table below we have listed some path expressions
and the result of the expressions:
| Path Expression | Result |
|---|---|
| //book/title | //book/price | Selects all the title AND price elements of all book elements |
| //title | //price | Selects all the title AND price elements in the document |
| /bookstore/book/title | //price | Selects all the title elements of the book element of the bookstore element AND all the price elements in the document |
In jxpath in a map, value of a key can :
| Use Case | Description | Solution |
|---|---|---|
| Accessing bean property "name" in attribute conditions like [@name='xyz'] will not work |
@name in jxpath is used to specify a key to access an element in a map. Eg: map[@name='key1'] will access map-element with key "key1" |
In order to access "name" property of a bean, use ./name instead of @name, as shown below /attr/workflowSteps/steps[./name='Step1'] |


class: left, middle, inverse, title-slide # An Introduction to R ## ED 217 B Week 2 ### Daniel Katz ### 1/12/2021 --- class: middle class: middle ### General Strategy + My goal is to get us up and running - doing is the best learning + Provide you with some quality resources for continuing to learn via links like [_**this**_](https://stackoverflow.com/tags/r/info) + I won't emphasize code-style best practices except in a few cases (but these will only be for cases that make life easier) + I think it's important to focus on ideas and functions + For more on style/best practices, [_**click here**_](http://adv-r.had.co.nz/Style.html) + Learning how to trouble shoot is important --- class: middle ## General Outline for Today .pull-left[ 1. What is the relationship between probability, odds, and log odd (logits)? 1. Intro: How should I think about and use R and Rstudio? 1. R Basics 1. Reading in data, subsetting, intro to dplyr (and piping) ] --- ## Next few weeks 1. Next week - more on plotting, more on working with data frames. 1. Using `Rmarkdown` 1. Getting introduced to TAM -- .pull-right[There's a **TON** to R. I don't expect expertise after this session, but I hope you know where to start!  ] --- class: middle # What is R? + R is a software and scripting language + Like any other language it has syntax (for now think, "rules" of language) + R comes with a variety of built-in functions + R is desiged for statistics, but you can do lots with it + build websites + write documents in Latex + Create slides for presentations, etc. --- class: middle # You can learn R! + It is quickly becoming the statistical language of choice in academic and non-academic circles -- + `R Packages` are making tasks more accessible to non-programmers like me -- + R allows for sharing code: we won't cover Github, but please [_**check it out**_](https://happygitwithr.com/rstudio-git-github.html) -- + Scripting forces us to slow down and think -- + We can do everything in one place (data cleaning, plotting, modeling, etc) --- # It makes really (fairly?) cool visualizations  ---  --- class: middle # Probability, odds, logits + In this class, we'll be operating a lot with probability, odds, and log odds -- + As mentioned in course slides, the link function in logistic regression (and the Rasch model is a special case) is the logit link -- - We still want to work in the linear model framework - we do this with the log of the odds `$$\log(\frac{p_i}{1-p_i}) = \beta_0 + \sum_{n=1}^N \beta_n x_{in}$$` --- class: middle # Solving for `\(p_i\)` Writing, `\(\beta_0 + \sum_{n=1}^N \beta_n x_{in}\)` as `\(\theta\)` so `$$\log(\frac{p_i}{1-p_i}) = \theta$$` .pull-left[ 1. Exponentiate both sides. 2. Multiply both sides by `\({1-p_i}\)` 3. Distribut the left side 4. Add `\(e^\theta*p_i\)` 5. Factor out `\(p_i\)` on the left 6. Divide both sides by `\(1+e^\theta\)` ] .pull-right[ 1. `\(\frac{p_i}{1-p_i} =e^\theta\)` 2. `\(p_i = e^\theta(1-p_i)\)` 3. `\(p_i = e^\theta-e^\theta*p_i\)` 4. `\(p_i + e^\theta*p_i = e^\theta\)` 5. `\(p_i(1+e^\theta)= e^\theta\)` 6. `\(p_i = \frac{e^\theta}{1+e^\theta}\)` ] --- class: middle Probability + Perhaps the most basic defintion (frequency/long run frequency) + proportion of times an event occurs given a number of trials + Often not that simple to interpret + Cannot be outside the range, [0,1] -- + `p` is the probability of an event occurring + `1-p` is the probability of an even not occurring -- + What does it mean to say a coin has a 50% chance of landing heads? Or a student has a 30% chance of answering an item correctly? -- + Usually invoking the long run ---  --- class: middle # Odds + Odds are basically the ratio of an event happening to an event not happening -- + Formally `odds = p/(1-p)` + If `p = .6` + Odds are `1.5 (.6/.4)` - the event (a candidate winning an election) is 1.5 times more likely to happen than not -- + What are the odds if the probability is .5? --- class: middle # Log of the odds -logits + Take the natural log (ln) of the odds + `\(log_{e}(odds)\)` or `\(ln(odds)\)` + Most commonly (and in R): `\(log(odds)\)` + Odds range from `\((0, \infty)\)` not great for linear modeling + log odds range from `\((-\infty, \infty)\)` --- class: middle # Formulas for going the other way: logits to probability 1. Exponentiate - `$$e^{logit} = e^{log_e(odds)} = odds$$` 2. Get the probability `$$\frac{odds}{1+odds}$$` --- ## Open Up RStudio --- background-image: url(introconsole.png) background-size: contain background-position: center --- background-image: url(scriptconsole.png) background-size: contain background-position: center --- class: middle ## Introducing "Scripts" + Scripts are (essentially) RStudio's text editor. **Work in Scripts**. They're saved text that you _can_ edit + Code in the console doesn't get saved and you _cannot_ edit -- + The primary aim of working in scripts is reproducability, transparency, being able to run code from start-to-finish without intervening -- + Rely on being able to re-run your script as if you have no memory of what you had done before when you return to the script the next day (or whatever) --- # Running the code in a script  --- ## Creating a new script in RStudio .pull-left[ 1. File > New File > R Script + Or, ctrl+shft+N + Or, below file, hit the icon that looks like:  2. To run a line of code in a script + put your cursor on that line, + run it, via ctrl/cmd + enter. + Or the `run` button in the top right of the script ] -- .pull-right[Make sure it works: 3. Type `1+1` in a script and run it. + What happens? Where does it output? 4. There are multiple ways to run more than one line of code at a time + Highlight the relevant code, run + Or select the various options under "Run"] -- .center[Write two lines of code (such as `1+1` and `2+2`)] -- --- class: middle ## Commenting *Commenting is essential.* + R will recognize any line after `#` as a comment For instance: ```r # I ran this to see what would happen factorial(4) ``` ``` ## [1] 24 ``` + Add more comments than you think you need --- # Vocabulary | R Word | Translation |----------|------------------ | Script | Document containing code to be run | Console | Output Window/Printer (but you can also run code here) | Environment| The place where things you create in R, live (metaphorically) | Working Directory| The folder where your current R session lives, where output files go --- class: middle ## Working Directory (We'll return to this in more detail later) + The notion of the working directory isn't unique to R + Directories are just folders on your computer with a certain `path` + For instance, your `desktop` is a directory + A folder within `Documents` is a directory + A `working directory` is just where you tell `R` that you'll be working + when you load files, it knows to look to a certain folder + When you export files, `R` exports automatically to the working directory --- class: middle ## File paths + A path to a Word doc on my desktop looks like: `C:/Users/katzd/Desktop/myfile.docx` + A path to a file in a folder called, `thesis` in the `Documents directory` looks like `C:/Users/katzd/Documents/thesis/myfile.docx` + But these are long! + Instead, we'll tell `R` where to read files from, where to export, etc, via `projects` --- class: middle ## File Paths: Getting the Wd... + To see the currect working directory, simply run the code `getwd()` + To set the working directory `setwd("filepath")` (the filepath has to be in quotes) + It's often useful to set the working directory at the top of your script **via menu options**: Session ➡ Set Working Directory ➡ Choose Directory (copy and paste outputted code to the top of your script) + Some people don't like this practice: [**Link**](https://whattheyforgot.org/safe-paths.html) + Run: `getwd()` --- .middle[### If you've made any comments or would like to save your current script, please go ahead an do-so now (file ➡ save ➡ where you want to save it ➡ name)] --- ## Creating RStudio Projects ### Projects are an RStudio staple .pull-left[1. Once open, click File (top left) ➡ New Project 2. New Directory ➡ New Project ➡ Create Project as a Subdirectory of: click `browse`. 3. Choose where you'd like to put this session's R work (for instance, on your desktop in a folder called, `ED217B Lab 1`) - or even one level down in a new folder within `ED217B Lab 1`) 4. `Directory Name` ➡ Name this R project - `IntroR` (no spaces; It'll make your life easier) ➡ Create Project.] .pull-right[  ] --- # Setting up a nice working directory -- 1. There are various philosophies about setting up your working directory. Within your working directory... 1. Set up a folder called "scripts" or similar -- 1. Set up a folder called "data" -- 1. Set up a folder called "output" or similar Finally...time to get our feet wet... --- # Getting set up. 1. Download the R script `Intro_to_R1.R` 1. Place `Intro_to_R1.R` in your `scripts` subdirectory. --- ## Variable Assignment 1. One of the most fundamental aspects of R (really any language) is assigning `variables` or `objects`, + giving something a name so you can + store it + work with it in R. + R uses `<-` (you can also use for Windows: "alt" and "-" or on a Mac: "option" and "-") 2. Now, we can store objects in R and work with the objects! 3. Note, none of this requires an external package, just through `base R`. For a nice base R cheat sheet, [_**Click**_](https://paulvanderlaken.files.wordpress.com/2017/08/base-r-cheetsheat.pdf) -- 4. When we start assigning variables, note what changes in your R session (where do you see the variables go?) --- class: middle ### For instance, run the code below: ```r x <- 2 ``` ```r #What's the value of y? y <- x+2 ``` 1. What is in your Global Environment, now? 2. What was outputted in the console? 3. Now run `x <- 3`. What is the value of x? What is the value of `x+2` 4. Just type `x` and run --- class: middle ## The Environment + In the right corner, under `Global Environment`, you should now see where R is "storing" `x` and `y` and their values. + The environment is also where we'll see what datasets, in R speak, `dataframes` that we have loaded or created, or other objects + If you don't assign something to a variable, it won't be stored --- class: middle --- # R and Packages + Think of `packages` as very specialized bundles of software. + They're collections of functions developed by the "community" -- + These packages have documentation if they're on `CRAN: The Comprehensive R Archive Network` (and even sometimes if they're not) -- + You don't need all the packages! -- + Packages add functions to base R -- + For instance, the `psych` package is built with tools commonly needed in the social sciences --- class: middle ## Packages, cont'd + When you `install.packages()`, R will search for a package on `CRAN` and download it to your computer (have to be connected to the internet) + To see where it's downloaded, run `.libpaths()` + Each time you start a new R session, you have to load a package via `library()` but you don't have to install each time --- ## Getting help + First and foremost, you can see installed packages in the bottom-right pane:  + Click on a package to see the documentation --- ## Other Help + You can also type `?packagename` such as `?dplyr` + To get help with a base R function, you can type ?function + To get help with a package function, you can type: `?packagename::function` such as `?dplyr::select` where select is a particular function in R. + Under the Help tab in R studio (next to `Tools` at the top), exists a few resources as well, including "cheat sheets" + Also, Google (we'll talk about this more)! --- # Run the examples in documentation, usually at the bottom of the section to see how something works!  --- # Operators in R |Operation|Operator in R |Example| |---------|------|-------|-------| |Addition |`+` |`4+3` |Subtraction|`-`| `4-3` |Multiplication|`*`| `4*3` |Exponentiation | `**`| `4**3` |Division | `/`| `12/4` |Matrix multiplication|`%*%`| `a %*% b`| **Challenge: Aside from the matrix multiplication, make sure all of these work in `R`** (use a script!) --- ## Output + R `returns a value` in the `console` + It'll look like this:  ***Challenge***: Order of operations: Run `(4+3)*(4-3)` and then `4+3*4-3` in the console (for experimentation). What happens? ### This is one of those necessary evils, so you know how R works - To select individual elements in a vector, use `[2]` and the numeric position that you would like to extract. - For instance, run: `v6 <- v5[c(2,3)]` - This is also how one may pull out individual columns, rows, or specific rows and columns in a dataframe in R using base R - We can also get descriptives or compute across a vector, or specific vector elements - Working with datasets or matrices, we can subset rows, columns or both --- class: middle #### Rows: `df[1, ]` (gets just the first row) #### Columnn `df[,1]` or `df[1]` (gets just the first column) #### Both `df[1,1]` #### Can Select multiple `df[1:5, 1:6]` or `df[c(1,3, 8), c(1, 9, 2)]` ---


SharkApp
WebAPP that collects the most used applications in IOS / JailBreak. It is a creation of Shark-Design to provide a more native experience in ios and you do not have to visit different sites to find your APP, we work for you.
SharkApp
WebAPP that collects the most used applications in IOS / JailBreak. It is a creation of Shark-Design to provide a more native experience in ios and you do not have to visit different sites to find your APP, we work for you.


“Everything you can imagine is real.” ― Pablo Picasso
“A life spent making mistakes is not only more honorable, but more useful than a life spent doing nothing.” ― George Bernard Shaw.
“You must have chaos within you to give birth to a dancing star.” ― Friedrich Nietzsche
“Painting is poetry that is seen rather than felt, and poetry is painting that is felt rather than seen.” ― Leonardo da Vinci
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Rem nihil alias amet dolores fuga totam sequi a cupiditate ipsa voluptas id facilis nobis.
“Art and love are the same thing: It’s the process of seeing yourself in things that are not you.” ― Chuck Klosterman
“Art enables us to find ourselves and lose ourselves at the same time.” ― Thomas Merton
“A painter should begin every canvas with a wash of black, because all things in nature are dark except where exposed by the light.” ― Leonardo da Vinc
“The most beautiful experience we can have is the mysterious. It is the fundamental emotion that stands at the cradle of true art and true science.” ― Albert Einstein
Lorem ipsum dolor sit.
“Any fool can be happy. It takes a man with real heart to make beauty out of the stuff that makes us weep.” ― Clive Barker.
“If you ask me what I came to do in this world, I, an artist, will answer you: I am here to live out loud.” ― Émile Zola


Welcome to the most delicious food blog on the planet. Here you'll find information on the best pizzas and the code to where to find them!
It's the Windy City's prized pizza offering, is it a pie or a pizza? One can argue both, this thick crusted, inverted, cheese, meats/veggies, and sauce creation is not only a sight to behold but also a belly buster.


Justin Kane
About Me
My name is Justin Kane. I am a father of two, husband and musician.I work full time at a company that fabricates fork truck forks and attachments. I do a lot of work forecasting orders with our current ERP as well as helping with programming around the production area. We have an oxy table, as well as CNC machine and a robotic weld arm that I am in charge of programming and trouble shooting. I am looking to find a job programming full time, all the time.


PubSubErrorResponse
open class PubSubErrorResponse: PubSubResponsible
Invalid format response (malformed JSON, bad attributes or types, etc.)
-
Response action.
Declaration
Swift
open let action: String
-
Response code.
Declaration
Swift
open let code: Int
-
Response message.
Declaration
Swift
open let message: String
-
Response details.
Declaration
Swift
open let details: String
-
Response sequence number.
Declaration
Swift
open let sequence: Int?
-
Response matching request.
Declaration
Swift
open let request: [String: Any]?
-
Initializes
PubSubErrorResponse
object with JSON.Throws
The error value thrown when occures.Declaration
Swift
public required init(json: JSON) throws
Parameters
json
The received JSON.
-
Initializes
PubSubErrorResponse
object with code and message during the validation.Declaration
Swift
public init(code: Int, message: String)
Parameters
code
The error response code.
message
The error message.


Profile Friends Additional Information
Student at Sofia University
Born in Burgas
Living in Sofia
Working at telerik


Results of the Susceptible-Exposed-Infected-Recovered-Dead model for mass infection. ( A) λ I = −6.3 days for Daegu was obtained by the difference between the actual epidemic peak d I.a = 25 days and the modeled epidemic peak d I.m = 31.3 days. ( B) λ I = −5.3 days for Gyeongbuk was obtained by the difference between the actual epidemic peak d I.a = 24 and the modeled epidemic peak d I.m = 29.3 days.


Privacy Terms
Buy a kit
Log In
Sign Up
Log in
Sign in
Privacy terms
Buy a kit
Sign in to iMicro
Username
Password
SIGN IN
By clicking Sign In, you agree to our
Privacy Statement
and
Terms and Conditions
Already have an account?
Login


Program 4: Boundary Conditions
Magnetization:
Local Correlation:
3.00
Temperature
Run
Step
Reset
Boundary
wraparound
all up
all down
random
zero
sampled
underdog
twisted
Algorithm
Metropolis
Glauber
Dotted Swiss


Cli
Extends:
Handles the command-line integration based on docopt specification.
It enables the execution of actions triggered as command-line applications. The args are parsed using the reader CliArgs and the output is provided by writer CliOutput.
Using cli handler:
Creating an action that can be executed through command-line
@Mebo.grant('cli')
@Mebo.register('myAction')
class MyAction extends Mebo.Action{
constructor(){
super();
this.setMeta('description', 'Welcome!');
this.createInput('myArgument: text', {elementType: 'argument', description: 'my argument'});
this.createInput('myOption: bool', {description: 'my option'});
}
async _perform(data){
const result = {
myArgument: data.myArgument,
myOption: data.myOption,
};
return result;
}
}
The command-line support can be invoked in two ways:
1) Multiple commands (recommended): Used to provide multiple granted actions through command-line
if (require.main === module) {
const cli = Mebo.Handler.get('cli');
if (cli.isSupported()){
cli.init();
}
}
When this method is used the command-line help (-h
or --help
)
provides a list of commands:
node mycli.js --help
__ __ _
| \/ | ___| |__ ___
| |\/| |/ _ \ '_ \ / _ \_
| | | | __/ |_) | (_) |
|_| |_|\___|_.__/ \___/
Available commands:
myAction
In order to access the help for each command you need to provide
the command name before the help flag (-h
or --help
)
node . myAction --help
Welcome.
Usage: node mycli.js myAction [options] <my-argument>
Arguments:
my-argument my argument (text type).
Options:
--my-option my option (bool type).
A complete example about providing multiple commands through command-line can be found at: https://github.com/meboHQ/example-cli
2) Single command: Used to provide just a single granted action through command-line
if (require.main === module) {
// creating an cli handler which is used to load the arguments
// arguments to the action and to output the result back to the stream
const cli = Mebo.Handler.create('cli');
// loading the parsed information to the action
cli.runAction('myAction').then((result) => {
// success output
cli.output(result);
// error output
}).catch((err) => {
cli.output(err);
});
}
When using the single command the help flag (-h
or --help
)
provides the help about the command directly:
node mycli.js --help
Welcome.
Usage: node mycli.js [options] <my-argument>
Arguments:
my-argument my argument (text type).
Options:
--my-option my option (bool type).
Static Method Summary
| Static Public Methods | ||
| public static |
Initializes a registered action as cli. |
|
| public static |
isSupported(argv: Array<string>): boolean Returns a boolean telling if cli support can be initialized based on the input argv. |
| Static Protected Methods | ||
| protected static |
_grantingAction(handlerName: string, actionName: string, options: object) This method can be re-implemented by derived classes to hook when an Action is granted for a handler (Handler.grantAction) |
|
| protected static |
actionCommands(actionName: string): Array<string> Return a list of commands mapped to the action name. |
Constructor Summary
| Public Constructor | ||
| public |
constructor(argv: Array<string>, stdout: stream, stderr: stream) Creates an cli handler |
Method Summary
| Public Methods | ||
| public |
Returns a list of argument values used by the reader, by default it uses
|
|
| public |
Sets a list of argument values used by the reader. |
|
| public |
setStderr(value: stream) Sets the stderr stream |
|
| public |
setStdout(value: stream) Sets the stdout stream |
|
| public |
stderr(): stream Returns the stream used as stderr |
|
| public |
stdout(): stream Returns the stream used as stdout |
| Protected Methods | ||
| protected |
_createReader(action: Action, options: Object): Reader Creates an instance of a reader for the current handler. |
|
| protected |
_createWriter(value: *, options: Object): Writer Creates an instance of a writer for the current handler |
Inherited Summary
| From class Handler | ||
| public static |
Removes all listeners connected to the signal emitted through Handler.onErrorDuringOutput. |
|
| public static |
Creates a handler based on the registered name |
|
| public static |
Returns the registered handler |
|
| public static |
grantAction(handlerName: string, actionName: string, args: ...args) Grants the execution of the action through the handler |
|
| public static |
grantedActionNames(handlerName: string): Array<string> Returns a list granted actions for the input handler |
|
| public static |
onErrorDuringOutput(listener: function) Adds a listener to an exception raised during the Handler.output process. |
|
| public static |
Register an Handler type to the available handlers |
|
| public static |
registerReader(readerClass: Reader, handlerName: string, handlerMask: string) Register a Reader for the handler |
|
| public static |
registerWriter(writerClass: Writer, handlerName: string, handlerMask: string) Register a Writer for the handler |
|
| public static |
registeredHandler(handlerName: string, handlerMask: string): Handler Returns the registered handler |
|
| public static |
registeredHandlerMasks(handlerName: string): Array<string> Returns a list of registered handler makers for the input handler name |
|
| public static |
Returns a list containing the names of the registered handler types |
|
| public static |
registeredReader(handlerName: string, handlerMask: string): Reader Returns the reader registered for the handler |
|
| public static |
registeredWriter(handlerName: string, handlerMask: string): Writer Returns the writer registered for the handler |
|
| protected static |
_grantingAction(handlerName: string, actionName: string, args: ...args) This method can be re-implemented by derived classes to hook when an Action is granted for a handler (Handler.grantAction) |
|
| public |
Returns a value under the handler's metadata. |
|
| public |
Results a value through the handler. |
|
| public |
Executes an action through the handler. |
|
| public |
Returns the session |
|
| public |
Sets a value to the handler's metadata. Detailed information about the metadata support can be found at Metadata. |
|
| public |
setSession(session: Session) Associates a Session with the handler. |
|
| protected |
_createReader(action: Action, options: Object, additionalArgs: ...additionalArgs): Reader Creates an instance of a reader for the current handler |
|
| protected |
_createWriter(value: *, options: Object, additionalArgs: ...additionalArgs): Writer Creates an instance of a writer for the current handler |
Static Public Methods
public static init(options: Object) source
Initializes a registered action as cli.
CliActions/Default.js
: defining an action as cli:
const Mebo = require('mebo');
@Mebo.grant('cli', 'cli.default', {command: 'default'})
@Mebo.register('cli.default')
class Default extends Mebo.Action{
constructor(){
super();
this.createInput('name: text');
this.createInput('myOtherInput?: numeric');
}
async _perform(data){
// ...
}
}
index.js
:
const Mebo = require('mebo');
require('Clis/Default.js');
// ...
const cli = Mebo.Handler.get('cli');
if (cli.isSupported()){
cli.init();
}
Listing available actions:
node myFile.js --help
Showing help from the app:
node myFile.js myCli --help
Executing an cli by specifying custom args:
node myFile.js myCli --arg-a=1 --arg-b=2
Params:
| Name | Type | Attribute | Description |
| options | Object | plain object containing custom options |
|
| options.argv | Array<string> |
|
custom list of arguments, if not specified
it uses the |
| options.stdout | stream |
|
custom writable stream, if not specified it uses
|
| options.stderr | stream |
|
custom writable stream, if not specified it uses
|
| options.finalizeCallback | function |
|
callback executed after the output. (The value the output value is passed as argument) |
public static isSupported(argv: Array<string>): boolean source
Returns a boolean telling if cli support can be initialized based on the input argv.
Static Protected Methods
protected static _grantingAction(handlerName: string, actionName: string, options: object) source
This method can be re-implemented by derived classes to hook when an Action is granted for a handler (Handler.grantAction)
Override:
Handler#_grantingActionParams:
| Name | Type | Attribute | Description |
| handlerName | string | registered handler name |
|
| actionName | string | registered action name |
|
| options | object | custom options passed during Handler.grantAction |
|
| options.command | string |
|
command name used to initialize the cli, otherwise if not defined the actionName is used instead |
Public Constructors
Public Methods
public args(): Array<string> source
Returns a list of argument values used by the reader, by default it uses
process.argv
.
public setArgs(value: Array<string>) source
Sets a list of argument values used by the reader. It must follow
the same pattern found at process.argv
public setStderr(value: stream) source
Sets the stderr stream
Params:
| Name | Type | Attribute | Description |
| value | stream | stream used as stderr |
public setStdout(value: stream) source
Sets the stdout stream
Params:
| Name | Type | Attribute | Description |
| value | stream | stream used as stdout |
Protected Methods
protected _createReader(action: Action, options: Object): Reader source
Creates an instance of a reader for the current handler. This passes the Cli.args to the reader.
Override:
Handler#_createReaderprotected _createWriter(value: *, options: Object): Writer source
Creates an instance of a writer for the current handler
This passes the Cli.stdout and Cli.stderr to the writer.
Override:
Handler#_createWriterParams:
| Name | Type | Attribute | Description |
| value | * | arbitrary value passed to the writer |
|
| options | Object | plain object containing the options passed to the writer |


⇐ Jonathan
Blog
Power consumption in California
09 Jan 2016
This post aims to provide a fast look into Californian's net load The data is collected through the Pyiso API, the data can also be fetched on CAISO How is power generation evolving ? A couple of plots from making the parallel coordinate plot.
Example content
09 Aug 2015
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nulla ullamcorper est in imperdiet molestie. Curabitur aliquet sem in ante venenatis.


Karla started her career in insurance over 16 years ago. In 2015 she started her own firm, Miller Insurance Team.
 Most weekends she can be found site seeing in the camper or doing photography.
DeAnn has worked in the Insurance industry for 14 years. 12 years at a life/health insurance company and now over two at years Miller Insurance Team. Helping individuals has always been important to DeAnn.
When not at work, DeAnn loves to entertain and have company. Relaxation is working in the yard or scrapbooking. General, DeAnn’s labradoodle service dog, has been a constant presence since June 2012. His job is to detect peanuts and when not working, running around like a normal energetic dog.
Leah and Kricket, are sisters and always together and have kept Karla company for over 8 years now.
General has been with DeAnn for 8 years and is her Service Dog to detect peanuts. At 10 years young he is DeAnn's constant help and companion.


s6-linux-init
Software
skarnet.org
The s6-linux-init-shutdownd program
s6-linux-init-shutdownd is the daemon that manages the shutdown
procedure for an s6-linux-init installation. It is not meant to be called
directly by the user.
Interface
s6-linux-init-shutdownd [ -d notif ] [ -c basedir ] [ -g gracetime ] [ -C ] [ -B ]
- s6-linux-init-shutdownd opens a named pipe in its current
directory and listens to it. This fifo has a fixed, internal, name: this is
a rendezvous point where programs such as
s6-linux-init-shutdown send their
commands when they are told to trigger the shutdown procedure.
- When it receives a command to shut down, s6-linux-init-shutdownd
first spawns the rc.shutdown script defined by the
s6-linux-init-maker invocation that
created the shutdownd service.
- When this script exits, s6-linux-init-shutdownd kills all
processes, first with a SIGTERM, then (after the grace time specified by
the shutdown command) with a SIGKILL.
- It then runs an automatically-generated script (called stage 4),
which unmounts the file systems and halts, powers off or reboots the
machine.
Options
- -d notif : when ready
(actually listening to its named pipe),
write a newline to file descriptor notif then close it.
This allows s6-linux-init-shutdownd to use the
s6 mechanism to notify
readiness. notif cannot be lesser than 3.
If this option is not given, no readiness notification is sent.
- -c basedir : look for the
rc.shutdown script in the basedir/scripts
directory. Default is /etc/s6-linux-init/current.
- -g gracetime : if the shutdown command
does not specify a grace time between the SIGTERM and the SIGKILL, use
gracetime milliseconds. Default is 3000.
- -C : inform the shutdown daemon that it is running
in a container. This changes the nature of stage 4, since
exiting a container is slightly different from rebooting a real machine
(in particular, pid 1 has to exit, and great care must be given not to
leave any zombie hanging around).
- -B : inform the shutdown daemon that no catch-all
logger is running. This also changes the shutdown procedure slightly,
since some operations are specific to the existence of a catch-all
logger.
Notes


0
1
1
0
0
1
1
0
Junior Front-end Developer
Sofia, Bulgaria
+359895754098
<EMAIL_ADDRESS>I am a very creative person, passionate about anything i start doing in life. I want to acquire knowledge and develop skills and experience in the field of Front End development. I like experiencing and learning the new. I am responsible and self-organized person who is not afraid of changes and enjoys challenging himself, because in my opinion that is the way to improve one's skills.
Front End course, Swift Academy
September 2018 – December 2018
Installer of metal constructions and plastic modelling at Partners Media Group EOOD, Varna
January 2008 – January 2017
Producing and installing of advertising equipment, electrical installation
Technical University of Gabrovo, Gabrovo
September 2004 – June 2007
Degree: Hydraulic and pneumatics
"Christo Botev" High School, Popovo
September 1992 – May 2004
Degree: High School
HTML5, CSS3, LESS, JavaScript, JQuery, JSON, XML, AJAX, Basic Knowledge of AngularJS, Adobe Photoshop, Corel Draw, Detail Oriented, Teamwork Skills, Adaptive, Fast Learner, Deadline Oriented, Loyal
In my spare time I enjoy reading, mountain hiking and camping. Also I am keen on playing volleyball and guitar playing
English


Star Notary Contract
Input is not a number!
Input is not a number!
Input is not a number!
Star not found!


HSP : Hot Soup Processor ver3.6 / onion software 1997-2021(c)
An error occurred during HSP execution due to a script writing error or a specified error. When it is found, the error code and error line number are displayed.
This document is intended to be used to investigate the cause of an error when it occurs. Also, please refer to the following sites.
The error number and its contents are as follows.
This error is not normally displayed. If the file is corrupted or Displayed when something unexpected happens.
When the description method of functions and instructions is wrong, or Displayed when the variable name or label name is incorrect.
Displayed when the value of the parameter is out of tolerance.
Trying to write a calculation formula incorrectly, or try to use a symbol or operation that cannot be used It will be displayed when you do.
Displayed when the part where the parameter cannot be omitted is omitted.
The type specified in the parameter (string type, numeric type, etc.) is not specified It is displayed at times. If a variable is specified, the variable type is incorrect.
The value specified as an array element is the number set by the dim, sdim instruction, etc. It is displayed when it is exceeded.
If the parameter to be specified as a label is incorrect, or It is displayed when there is nothing after the "*" that indicates the label.
It is displayed when the gosub instruction and repeat instruction are executed too many times.
It is displayed when the return instruction is executed even though it is not called by the gosub instruction.
It is displayed when the loop instruction is executed even though there is no repeat instruction.
Did the specified file not be found when performing a file operation? Or it is displayed when the file is inaccessible.
Displayed when the image file to be loaded by the picload command cannot be found.
When something goes wrong when calling an external file with the exec instruction It shows.
The format of the parentheses "(,)" used in the calculation formula is incorrect, or the correspondence is incorrect. It is displayed when something is wrong.
Displayed when the number of parameters specified in the instruction is too large.
It is displayed when the allowable amount for handling character strings is exceeded.
Displayed when trying to assign to a system variable or reserved keyword.
Displayed when trying to divide by 0.
When the size secured by the sdim instruction or the dim instruction is exceeded due to a character string variable, Displayed when trying to access beyond the variable buffer.
When trying to execute a semi-transparent copy in palette mode with the gcopy command, etc. Displayed when settings that are not supported as a function are made.
If the formula is too complicated and stackover occurs during evaluation It is displayed when the calculation is not performed correctly for some reason. Normally, it is not displayed. If you see this, Indicates that the system has encountered a fatal error.
If there is an incorrect description in the place where the variable name should be specified as a parameter It shows.
When another type is found where only integers should be specified for the parameter It shows.
If the array element is written incorrectly, or if the array element is written It is displayed when it is written in a bad place.
Displayed when the physical memory of the system could not be secured. If this is displayed, it is a fatal error.
It is displayed when the initialization of the standard type and the extended type by the plug-in fails. If you see this, it means that your system has a fatal error. is showing.
Displayed when function parameters are not written correctly.
The stack was corrupted during a subroutine call or expression evaluation process Will be displayed if. Normally, it is not displayed. If you see this, it means that your system has encountered a fatal error. is showing.
Displayed when an invalid name is used as a parameter. It is also displayed when an alias or local variable that does not exist is referenced. You may.
When you try to assign a value of a type different from the initialized type to the array It shows.
When the parameter format of the function is incorrect or when the parentheses are missing It shows.
The object placed in the window has exceeded the set limit Will be displayed if.
If you specify an array with a type that does not support arrays, or Displayed when trying to use a non-function keyword as a function.
Wrong content where module variables should be specified for parameters Displayed if written.
The module variable specified in the parameter is the wrong module Displayed if initialized. Normally, it is not displayed. If you see this, Indicates that the system has encountered a fatal error.
Unable to convert variable or value type or not supported Will be displayed if.
Displayed when the address of the function call destination of the external DLL fails to be obtained.
Displayed when an error occurs while calling a COM object.
In the script defined as a user function, with the return instruction Displayed when the return value has not been set.
Displayed when the keyword defined as a function is described in the instruction format. Wrongly written instruction name or wrong functioned name from HSP2 You may be using it.
Displayed when an instruction that cannot be used while executing a callback routine such as interrupt or termination processing is described. See the programming manual for more information on callback routines.


{% extends "reviews/base.html" %} {% block title %}{{ review.title }}{% endblock %} {% block content %}
Published {{ review.publish }} by {{ review.author }}


Fishermen's Guild Member O'Fulle:
You haven't recovered the
lost bait materials
from the
fettered souls
at the Death Pass in northern Giran yet? Go on! They're no use to those beasts, anyway!


{% block content %}
{% endblock %}
serious
Do You Find anything Fishy??
Report It To Me @ Tibinsunny95


Certifications
Thank you to all of the organizations and companies that helped and/or sponsored me for these certificates!
2020 Hazwoper 8-Hour Refresher
OSHA 29 CFR 1910.120/1926.65 - 8 Hours
June 29, 2020 Certificate Number: 146682
www.etraintoday.com
2019 8-Hour HAZWOPER Supervisor Refresher
In Accordance with Federal OSHA Regulation 29 CFR 1910.120(e)(8)
And all State OSHA/EPA Regulations as well including 29 CFR 1926.65 for Construction.
July 15, 2019 Certificate Number:<PHONE_NUMBER>433
Safety Unlimited, Inc. OSHA Compliant Safety Training Since 1993
2018 40-Hour Training Course
Hazardous Waste Operations and Emergency Response
OSHA 29 CFR 1910.120
May 7, 2018 Certificate Number: 2018S-00025
Rutgers University, the State University of New Jersey - New Brunswick
By continuing to learn, I have expanded my perspective, sharpened my
skills, and made myself even more in demand.
Master GIS for Data Science
Learning Path completed on Sep 1, 2020 • 23 hours 8 min
Top skills covered:
Data Visualization, ArcGIS Products, Geographic Information Systems (GIS)
Learning ArcGIS
Course completed on Aug 29, 2020 • 3 hours 13 min
Top skills covered:
Data Visualization, ArcGIS Products, Geographic Information Systems (GIS)
Learning QGIS
Course completed on Aug 27, 2020 • 2 hours 57 min
Top skills covered:
Data Visualization, ArcGIS Products, Geographic Information Systems (GIS)
Learning MapGuide Open Source
Course completed on Sep 1, 2020 • 1 hour 31 min
Top skills covered:
Data Visualization, ArcGIS Products, Geographic Information Systems (GIS)
ArcGIS Essential Training
Course completed on Aug 20, 2020 • 5 hours 31 min
Top skills covered:
Data Visualization, ArcGIS Products, Geographic Information Systems (GIS)
ArcGIS Pro Essential Training
Course completed on Aug 26, 2020 • 4 hours 25 min
Top skills covered:
Data Visualization, ArcGIS Products, Geographic Information Systems (GIS)
Excel Essential Training (Office 365)
Course completed on Aug 18, 2020 • 2 hours 10 min
Top skills covered:
Data Visualization, Data Entry, Functions
GIS on the Web
Course completed on Aug 27, 2020 • 2 hours 8 min
Top skills covered:
Data Visualization, ArcGIS Products, Geographic Information Systems (GIS)
Real-World GIS
Course completed on Aug 27, 2020 • 2 hours 43 min
Top skills covered:
Data Visualization, ArcGIS Products, Geographic Information Systems (GIS)
Visualizing Geospatial Data with Power Map in Excel
Course completed on Aug 27, 2020 • 37 min
Top skills covered:
Data Visualization, ArcGIS Products, Geographic Information Systems (GIS)
By continuing to learn, I have expanded my perspective, sharpened my
skills, and made myself even more in demand.
What to Do When There's Too Much to Do (getAbstract Summary)
Course completed on Aug 10, 2020 • 8 min
Top skills covered:
Mental Health, Organization, Time Management
Start with Why: How Great Leaders Inspire Everyone to Take Action (Blinkist Summary)
Course completed on Aug 10, 2020 • 13 min
Top skills covered:
Leadership, Teamwork, Inspiration
Making Quick Decisions
Course completed on Aug 10, 2020 • 21 min
Top skills covered:
Leadership, Decision-Making, Fast-Thinking
The Six Morning Habits of High Performers
Course completed on Aug 10, 2020 • 23 min
Top skills covered:
Self-Care, Productivity, Good Habits


Selleck is a tool for generating user documentation from Mustache-based templates. It was created to generate documentation for the YUI Library. At the moment this document and Selleck itself are pretty YUI-specific, but over time Selleck will become a more generic tool, and the YUI-specific parts of the workflow (and this document) will be broken out.
Requirements
Selleck requires Node.js 0.4.0 or greater. It also requires a few third-party dependencies, but these will be installed automatically by npm.
Installation
Install Selleck using npm:
$ npm install selleck -g
The current stable version of Selleck is: 0.1.18
Or clone the GitHub repo to install the latest development version:
$ git clone git://github.com/yui/selleck.git $ cd selleck && npm install -g
Running the tests
Selleck tests are written in vows.
$ git clone git://github.com/yui/selleck.git $ cd selleck && npm install $ npm test
Developing with Selleck can be done easily with npm link
.
$ git clone git://github.com/yui/selleck.git $ cd selleck $ sudo npm link
After linking, you can edit the code in the repo and use the global selleck
command on other projects for testing.
Build Status
Each push to Github results in a Travis-CI build. Current build status:
Overview
Selleck pages are .mustache
files that can contain HTML markup, Mustache templating tags, and Selleck-specific markup (described below).
The Mustache Manual describes the Mustache template language. If you haven't used Mustache before, you may want to read the manual before continuing.
Projects & Components
Selleck documentation typically takes the form of one top-level project with zero or more components. These are represented by directories containing various files and subdirectories that follow a few conventions.
Pages
Each project or component may have multiple pages. An index.mustache page is required, and any number of other .mustache pages may also be provided in the same directory. These will be transformed into .html files in the generated output.
Partials & Layouts
Partials and layouts are special Mustache templates that live in the partials/ and layouts/ directories under a project or component directory.
A partial can be included in any page simply by referring to it by name using a special Mustache tag. For example, the tag {{>footer}}
would include a partial named footer.mustache.
A layout is like a wrapper for other pages. A layout named main.mustache will be used by default to wrap all pages, if it exists. A layout named component.mustache will be used to wrap all component pages; if no component layout exists, then component pages will use the main layout. Inside the layout, the special partial tag {{>layout_content}}
will be replaced with the page content.
Components will automatically inherit any available partials and layouts from their parent project. If both a project and a component have a partial or layout with the same name, the component's will take precedence at the component level, while the project's will take precedence at the project level.
Metadata
Projects and components have metadata files (project.json for projects, component.json for components) containing data that will be made available to page templates.
Project metadata files must contain a projectName
property, and component metadata files must contain a name
property; otherwise, the contents of these files are freeform. You can use these files to provide data to your templates, which you can then refer to using Mustache tags like {{projectName}}
.
project.json
sample
{ "projectName": "YUI 3", "yuiVersion" : "3.3.0", "yuiSeedUrl" : "http://yui.yahooapis.com/combo?3.3.0/build/yui/yui-min.js&3.3.0/build/loader/loader-min.js" }
component.json
sample
{ "name" : "autocomplete", "displayName": "AutoComplete", "description": "Provides automatic input completion or suggestions for text input fields and textareas.", "author" : "rgrove", "tags": ["widget", "autocomplete"], "use" : ["autocomplete"] }
Static Assets
Finally, projects and components may provide an assets/ directory containing static assets such as CSS and JavaScript. The assets directory will be copied directly to the output folder for the project or component in question, so its assets can be referenced via relative URLs.
Directory Structure
The following table describes the required and optional contents and structure of a project or component documentation directory.
| File/Directory | Description |
|---|---|
| assets/ |
Optional. Directory containing static assets (such as images, JavaScript, and CSS) used by the documentation. This directory and its contents will be copied to the output directory. If an assets/ directory already exists under the output directory, it will be deleted to make way for the new one.
Component assets are copied to subdirectories of the main assets directory, named according to the value of the |
| layouts/ |
Optional. Directory containing layouts. A layout is a template that will be wrapped around other pages. A layout named main.mustache will be used for all pages, while a layout named component.mustache will be used for components (components will fall back to main.mustache if component.mustache is not found). Inside a layout, the tag |
| partials/ |
Optional. Directory containing partials. A partial is a .mustache file that can be included in another documentation page using a directive like |
| component.json |
Required for components. JSON file containing metadata which will be made available to documentation templates.
The metadata is freeform, but must contain at least a |
| project.json |
Required for projects. Works just like component metadata; the only difference is that the project metadata must contain a |
| index.mustache |
Required. Main Mustache template for the project or component. This will be parsed and generated as index.html in the output directory. |
In addition to the files listed here, the documentation directory may contain any number of .mustache files. These will be parsed and generated as .html files in the output directory.
Automatic Table of Contents Generation
If a Selleck template includes the placeholder {{toc}}
, Selleck will automatically parse HTML headings at level 2 and up (

,

, etc.) in the page and will replace the {{toc}}
placeholder with a generated table of contents. The table of contents on this very page was generated this way.
Headings that don't already have id
attributes will be given generated ids based on the heading text, so
Sample Heading

would become
Sample Heading

.
To exclude a heading from the table of contents, add the class name no-toc
, like this:

Secret Heading

Markup Reference
In addition to Mustache templating tags, Selleck provides some markup syntax of its own to make things like escaping code blocks and creating links easier. The following markup is supported in all Selleck pages, layouts, and partials.
| Name | Example | Description |
|---|---|---|
| Code block |
``` YUI().use('node', function (Y) { // Sample code }); ``` |
Three backticks on a line by themselves indicate the beginning or end of a block of code. Text inside the block will be HTML-escaped, syntax-highlighted, and wrapped in a The wrapped text is automatically unindented to match the indentation level of the first line, so you're free to indent the containing block itself however you want.
You may optionally explicitly specify a language to use for the syntax highlighting immediately after the opening triple-backticks. For example: |
| Code (inline) |
`<code>` |
Text between |
| Link (internal) |
[[#Heading Name]] [[#Heading Name|Optional Link Text]] |
Creates a link to the specified heading (where By default, the heading name is used as the link text. If optional custom link text is provided, that will be used instead. |
| Literal delimiters |
\{{foo\}} |
Escape a Mustache left or right delimiter with a |
| Preformatted block (no highlighting) |
```nohighlight This is just a normal preformatted text block with no highlighting. ``` |
Just like a code block, but without any syntax highlighting. |
| Terminal block |
```terminal $ sudo -i # rm -rf / ``` |
Like a code block, but for displaying sample input and output for a command line terminal. Shell
prompts at the beginnings of lines ( |
Command Line Usage
After installation, you'll have a new command line application named selleck. Run selleck -h for a summary of the options Selleck supports.
If no options are given, Selleck will search the current directory and all its subdirectories recursively, looking for documentation directories (it does this by searching for project.json and component.json files). It will generate HTML documentation from all the docs
directories it finds, and will write the generated docs to ./docs by default.
$ cd ~/src/yui/yui3 $ selleck [info] Generating project docs for /Users/rgrove/src/yui/yui3/src/common/docs [info] Generating component docs for /Users/rgrove/src/yui/yui3/src/autocomplete/docs [info] Generating component docs for /Users/rgrove/src/yui/yui3/src/history/docs [info] Done! Docs were written to: ./docs
To generate documentation from a directory other than the current directory, pass the directory as an argument.
$ selleck ~/src/yui/yui3
You may also optionally specify an output directory for the generated docs.
$ selleck ~/src/yui/yui3 --out ~/src/yui/yui3/docs
To specify a documentation theme other than Selleck's default theme, use the --theme option/
$ selleck ~/src/yui/yui3 --theme /path/to/theme
To generate documentation for an explicit project rather than searching for the project, use the --project option.
$ selleck --project /path/to/project
Finally, the --server option will start a web server that you can use to preview your documentation in real time as you make changes, so that you don't need to regenerate after every change. It can be used in combination with any of the other options.
$ selleck ~/src/yui/yui3 --server
[info] Selleck is now giving Ferrari rides at http://localhost:3000
Other Stuff
Selleck isn't finished yet, and there's still more to document here. For now, poke around the default template and some of the component doc directories in the YUI 3 source tree to see what's possible.
License
Copyright © 2011 Yahoo! Inc.
All rights reserved.
Redistribution and use of this software in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
- Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
- Neither the name of Yahoo! Inc. nor the names of Selleck's contributors may be used to endorse or promote products derived from this software without specific prior written permission of Yahoo! Inc.