Returns the position of the marker in the current buffer. An error is displayed if the marker is not set.
See also:
(match-wild candidate pattern)
match-wild performs MSDOS shell style wildcard matching. The pattern support * and ? as wildcard chars.
match-wild returns 1 if the candidate string matches the pattern.
Example:
(match-wild ~file "*.txt") ; return true if ~file is a .txt fileSee also:
Concatenates its string arguments and displays them in the Mini-buffer at the bottom of the screen the next time the screen is updated.
The screen is only updated when an input request needs to pause to obtain characters, or the sit-for function is executed. If you want to display a message then use (sit-for 0) to force a screen update.
See also:
Provides for quick single-digit prefix arguments. It is bound to all the numeric keys but prefixed with ESC. So to get a prefix of 5, type ESC-5 followed by the command.
See also:
Converts a meta-collected digit to a negative prefix argument.
See also:
This keymap is used to read commands in the Mini-buffer when spaces are command terminators. For example: reading a command name with expand-mlisp-word.
The following keys are bound in the keymap:
Binding Function ^G error-and-exit ESC expand-and-exit ? help-and-exit ^C exit-emacs <CR> exit-emacs <LF> exit-emacs ^\ ESC-prefix See also:
This keymap is used to read commands in the mini-buffer when spaces are not command terminators.
The following keys are bound in the keymap:
Binding Function ^G error-and-exit ESC expand-and-exit ^C exit-emacs <CR> exit-emacs <LF> exit-emacs ^\ ESC-prefix <Space> expand-and-exit <Tab> expand-and-exit See also:
This command is bound to the minus key after the argument-prefix command has been executed. It is used to negate the prefix argument.
See also:
(modify-syntax-entry syntax-string)
This function is provided for compatibility with old MLisp code only. Use modify-syntax-table for all new MLisp code.
Modifies a set of entries in the syntax table associated with the current buffer. See the Barry's Emacs Programmer's Guide for more information on how to alter syntax tables.
See also:
(modify-syntax-table type args...)
Modifies a set of entries in the syntax table associated with the current buffer. See the Barry's Emacs Programmer's Guide for more information on how to alter syntax tables.
Syntax tables are associated with buffers by using the use-syntax-table command. Syntax tables are used by commands like forward-paren to do a limited form of parsing for language-dependent routines. They define such things as which characters are parts of words, which quote strings, and which delimit comments.
Syntax colouring and regular expression searches depend on the information in the syntax table.
modify-syntax-table can be called in one of the following ways:
Action Command Define the characters in charset as word characters, as used by such commands as forward-word and case-word-capitalize. (modify-syntax-table "word" charset)Define the characters in charset as having no special meaning. (modify-syntax-table "dull" charset)Define a comment that starts with comment-start-string and ends with comment-end-string. (modify-syntax-table "comment" comment-start-string comment-end-string)Define a matching pair of parentheses. (modify-syntax-table "paren" open-paren close-paren)Define the characters in charset as being a prefix that prevents the following character being interpreted as a string introducer. (modify-syntax-table "prefix" charset)Define the characters in charset as delimiting a string. (modify-syntax-table "string" charset)Define string as an exact case keyword type 1. (modify-syntax-table "keyword-1" string)Define string as an exact case keyword type 2. (modify-syntax-table "keyword-2" string)Define string as an exact case keyword type 3. (modify-syntax-table "keyword-3" string)Define string as a case blind keyword type 1. (modify-syntax-table "keyword-1,case-fold" string)Define string as a case blind keyword type 2. (modify-syntax-table "keyword-2,case-fold" string)Define string as a case blind keyword type 3. (modify-syntax-table "keyword-3,case-fold" string)charset is a string that contains a list of characters. Ranges of characters can be conveniently entered by giving the first and last characters of the range separated by a "-".
See also:
Inserts enough spaces and tabs to move the cursor to the comment column.
See also:
- comment-column variable
- default-comment-column variable


|
Steam Audio API
2.0-beta.18
|
Specifies the kind of acoustic responses to save in the baked data. More...
Data Fields | |
| IPLbool | bakeParametric |
| Enables the generation of I3DL2-compliant parametric reverb. More... | |
| IPLbool | bakeConvolution |
| Enables the generation of detailed impulse responses for convolution reverb. More... | |
| IPLfloat32 | irDurationForBake |
Must be set to the same value as irDuration in IPLSimulationSettings . More... | |
Specifies the kind of acoustic responses to save in the baked data.
| IPLbool bakeParametric |
Enables the generation of I3DL2-compliant parametric reverb.
This is most suited for calculating reverb in relatively enclosed spaces. It is less suitable for open spaces, or source-to-listener propagation. It consumes very little memory per probe.
| IPLbool bakeConvolution |
Enables the generation of detailed impulse responses for convolution reverb.
This is suited for all kinds of spaces, and for reverb as well as source-to-listener propagation. However, it consumes significantly more memory per probe.
| IPLfloat32 irDurationForBake |
Must be set to the same value as irDuration
in IPLSimulationSettings
.


Phibro: Fiscal 1Q Earnings Snapshot
TEANECK, N.J. (AP) _ Phibro Animal Health Corp. (PAHC) on Monday reported fiscal first-quarter profit of $2.5 million.
The Teaneck, New Jersey-based company said it had profit of 6 cents per share. Earnings, adjusted for non-recurring costs, were 19 cents per share.
The maker of animal health products and nutritional supplements posted revenue of $189.7 million in the period.
Phibro shares have dropped 25% since the beginning of the year. In the final minutes of trading on Monday, shares hit $24.06, a decline of 43% in the last 12 months.
This story was generated by Automated Insights (http://automatedinsights.com/ap) using data from Zacks Investment Research. Access a Zacks stock report on PAHC at https://www.zacks.com/ap/PAHC
Sign up for Daily Newsletters
Copyright © 2019 The Washington Times, LLC.
Please read our comment policy before commenting.


Chat with educators, ask questions, answer live polls, and get your doubts cleared - all while the class is going on
Learning isn't just limited to classes with our practice section, mock tests and lecture notes shared as PDFs for your revision
One subscription gets you access to all our live and recorded classes to watch from the comfort of any of your devices
Access to quality education anytime anywhere
Unlimited access to video solution
This is a wider card with supporting text below as a natural lead-in to additional content. This content is a little bit longer.
This is a wider card with supporting text below as a natural lead-in to additional content. This content is a little bit longer.
This is a wider card with supporting text below as a natural lead-in to additional content. This content is a little bit longer.
This is a wider card with supporting text below as a natural lead-in to additional content. This content is a little bit longer.
This is a wider card with supporting text below as a natural lead-in to additional content. This content is a little bit longer.


G.I. JANE
*** (out of ****)
Hollywood / 1997 / 2:08 / R Cast: Demi Moore; Viggo Mortensen; Jason Beghe; Anne Bancroft; Lucinda Jenny; David Vadim; Morris Chestnut; Scott Wilson; Josh Hopkins Director: Ridley Scott Screenplay: Danielle Alexandra; David Twohy
A buff, tawny Demi Moore shaves her head and goes Navy in "G.I. Jane," and the unanticipated result is a well-crafted drama that will do more for strong women's roles than her turn as Hester Prynne in 1995's "The Scarlet Letter" ever did. "Jane"'ll likely win her audience raves (and she deserves them), thus covering up the box office sting started by "Letter" and continued by last summer's "Striptease."
Moore's "G.I. Jane" role is that of Lieutenant Jordan O'Neil. Gutsy Senator Lillian DeHaven (Anne Bancroft) handpicks her to play a major part in a study that will hopefully reform the military's guidelines of restricting women in combat. The trial she faces is to pass the rigorous Navy SEAL training, a task that more than half of the men who attempt to succeed end up dropping out of. But O'Neil faces her challenge with optimism, telling DeHaven, "I expect a certain amount of pain" from the proceedings.
Upon her arrival at Catalano Naval Base in Florida, her statement is put to the test. Her drill instructor for the duration, Master Chief John Urgayle (Viggo Mortensen), immediately tells her what the best thing about pain is -- "It lets you know you're not dead yet." Ouch. Her presence is immediately met with prejudice not only from Urgayle and all of the SEALs-in-training, but also from the base commander (Scott Wilson). Even her boyfriend (Ed Harris-lookalike Jason Beghe), also in the military, doesn't think she'll last long. But last she does, and upon learning that she has been given a certain amount of leeway because of her sex, O'Neil demands equal treatment, no matter how rough things get. And things do get rough.
Rather than hop on a preachy feminist bandwagon, "G.I. Jane" stays extremely accessible. Because O'Neil is a strong part -- and because Moore compensates with strong acting -- there's no problem in rooting for her. Director Ridley Scott knows a thing or two about female heroines -- his "Alien" turned Sigourney Weaver into one of filmdom's first and finest -- and thus Jordan O'Neil is as convincing and potent as either one of the leads from his "Thelma & Louise."
A solid supporting cast backs Moore up. Mortensen makes his mark by fleshing out a role that could have been the embodiment of evil chauvinism. The sequences he and Moore share -- especially a shockingly violent episode that comes late in O'Neil's training -- are among the movie's most riveting. Bancroft is exceptional as a powerful political figure who may or may not be using the press surrounding the controversy to her advantage. The actors who make up O'Neil's squadron are uniformly good even though none of them are really allowed to develop a personality, and Beghe, although eventually a plot convenience, creates an interesting character.
As it stands, "G.I. Jane" is a good movie, but what keeps it from being a better one is a problematic undoing it shares with "Air Force One" -- it's allowed to play on for about 25 minutes too long. Had "Jane" stuck to its cerebral battle-of-wills, it could have achieved greatness (and another half-star). But it feels the need to add on a silly, shakily-shot action climax for no other reason than to disprove a sexist remark made to O'Neil by Urgayle. The jiggling camera work is well-utilized during earlier parts of the film, but in the finale becomes headache-inducing.
"G.I. Jane" has its flaws, but I don't mean to suggest by any means that it is an ineffective movie. It provides a fine showcase for Moore, who gives a daring, noble performance, and a distinctly change-of-pace project for Scott, who's most well known for his deep impact on the science fiction genre. Executed with intelligence and importance, "G.I. Jane" is thought-provoking, bold and one of the summer's best surprises.
© 1997 Jamie Peck E-mail<EMAIL_ADDRESS>Website: www.gl.umbc.edu/~jpeck1/
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


| Issue 4: | RMI security class not found exception | |
| 1 person starred this issue and may be notified of changes. | Back to list |
We had 2 different machines experience a strange issue with the location server starting up. The rmiregistry is running, but the location service will abort at startup with a unmarshalling exception, stating that the class loader could not be started. I could not figure out what the problem is. Have you ever seen this?
Nov 6, 2011
#1
<EMAIL_ADDRESS>Nov 8, 2011
It might be that policy.all file is not in action. Are you running the service via startup script ? And check whether you specified the correct path to installation directory in startup scripts under bin/ folder.
Aug 27, 2013
(No comment was entered for this change.)
Status:
Done
|
|
| ► Sign in to add a comment |


Module: ByteObject::ByteAttributes
- Defined in:
- lib/ByteObject.rb
Overview
Whenever ByteObject is included into a class, it also extends that class with the ByteAttributes module. This is the module that bestows the byte-specific attribute methods.
Instance Method Summary collapse
-
#attr_byte(key, size, signed) ⇒ void
This method creates an ordinary attribute reader and a specialized attribute writer for the given key.
-
#attr_s16bit(*keys) ⇒ Object
Creates an 16-bit signed attribute reader and writer.
-
#attr_s32bit(*keys) ⇒ Object
Creates an 32-bit signed attribute reader and writer.
-
#attr_s64bit(*keys) ⇒ Object
Creates an 64-bit signed attribute reader and writer.
-
#attr_s8bit(*keys) ⇒ Object
Creates an 8-bit signed attribute reader and writer.
-
#attr_u16bit(*keys) ⇒ Object
Creates a 16-bit unsigned attribute reader and writer.
-
#attr_u32bit(*keys) ⇒ Object
Creates an 32-bit unsigned attribute reader and writer.
-
#attr_u64bit(*keys) ⇒ Object
Creates an 64-bit unsigned attribute reader and writer.
-
#attr_u8bit(*keys) ⇒ Object
Creates an 8-bit unsigned attribute reader and writer.
Instance Method Details
#attr_byte(key, size, signed) ⇒ void
This method returns an undefined value.
This method creates an ordinary attribute reader and a specialized attribute writer for the given key. The writer will clamp any values passed to the new attribute based on its size and whether or not it is signed. Under normal circumstances, you will not need to call this method yourself. It is used by this module to generate the attribute methods given to any extended classes.
50 51 52 53 54 55 56 57 58 59 60 |
# File 'lib/ByteObject.rb', line 50 def attr_byte(key, size, signed) attr_reader(key) bytesize = (2**size) min = signed ? -bytesize/2 : 0 max = signed ? (bytesize/2) - 1 : bytesize - 1 define_method("#{key}=") do |val| instance_variable_set("@#{key}", val.clamp(min, max)) end end |
#attr_s16bit(*keys) ⇒ Object
Creates an 16-bit signed attribute reader and writer.
|
|
# File 'lib/ByteObject.rb', line 26
|
#attr_s32bit(*keys) ⇒ Object
Creates an 32-bit signed attribute reader and writer.
|
|
# File 'lib/ByteObject.rb', line 32
|
#attr_s64bit(*keys) ⇒ Object
Creates an 64-bit signed attribute reader and writer.
|
|
# File 'lib/ByteObject.rb', line 38
|
#attr_s8bit(*keys) ⇒ Object
Creates an 8-bit signed attribute reader and writer.
|
|
# File 'lib/ByteObject.rb', line 20
|
#attr_u16bit(*keys) ⇒ Object
Creates a 16-bit unsigned attribute reader and writer.
|
|
# File 'lib/ByteObject.rb', line 23
|
#attr_u32bit(*keys) ⇒ Object
Creates an 32-bit unsigned attribute reader and writer.
|
|
# File 'lib/ByteObject.rb', line 29
|
#attr_u64bit(*keys) ⇒ Object
Creates an 64-bit unsigned attribute reader and writer.
|
|
# File 'lib/ByteObject.rb', line 35
|
#attr_u8bit(*keys) ⇒ Object
Creates an 8-bit unsigned attribute reader and writer.
|
|
# File 'lib/ByteObject.rb', line 16
|


1.0.0-alpha.4
methods to load the configuration object.
var config = require('istanbul').config,
configObj = config.loadFile();
console.log(configObj.reporting.reports());
adds a report to be generated. Must be one of the entries returned
by Report.getReportList()
String
fmt
:
the format of the report to generate
adds an array of report formats to be generated
Array
fmts
:
an array of report formats
writes all reports added
returns a list of reports that should be generated at the end of a run. Used
by the cover
and report
commands.
Array
:
an array of reports that should be produced
returns if comments should be preserved in the generated JS. Used by the
cover
and instrument
commands.
Boolean
:
true if comments should be preserved in the generated JS
Sets the baseline coverage filename. Used by the instrument
command.
String
:
the name of the baseline coverage file.
returns if comments the JS to instrument contains es6 Module syntax.
Boolean
:
true if code contains es6 import/export statements.
returns if the coverage filename should include the PID. Used by the instrument
command.
Boolean
:
true to include pid in coverage filename.
returns if the output should be compact JS. Used by the instrument
command.
Boolean
:
true if the output should be compact
returns if non-JS files should be copied during instrumentation. Used by the
instrument
command.
Boolean
:
true if non-JS files should be copied
returns the kind of information to be printed on the console. May be one
of summary
, detail
, both
or none
. Used by the
cover
command.
String
:
the kind of information to print to the console at the end
of the cover
command execution.
returns if a zero-coverage baseline file should be written as part of
instrumentation. This allows reporting to display numbers for files that have
no tests. Used by the instrument
command.
Boolean
:
true if a baseline coverage file should be written.
returns the directory under which reports should be generated. Used by the
cover
and report
commands.
String
:
the directory under which reports should be generated.
returns an object that has keys that are report format names and values that are objects
containing detailed configuration for each format. Running istanbul help config
will give you all the keys per report format that can be overridden.
Used by the cover
and report
commands.
Object
:
detailed report configuration per report format.
the coverage variable name to use. Used by the instrument
command.
String
:
the coverage variable name to use
returns if default excludes should be turned on. Used by the cover
command.
Boolean
:
true if default excludes should be turned on
returns if vm.runInThisContext
needs to be hooked, in addition to the standard
require
hooks added by istanbul. This should be true for code that uses
RequireJS for example. Used by the cover
command.
Boolean
:
true if vm.runInThisContext
needs to be hooked for coverage
returns a path to JS file or a dependent module that should be used for
post-processing files after they have been required. See the yui-istanbul
module for
an example of a post-require hook. This particular hook modifies the yui loader when
that file is required to add istanbul interceptors. Use by the cover
command
String
:
a path to a JS file or the name of a node module that needs
to be used as a require
post-processor
returns if istanbul needs to add a SIGINT (control-c, usually) handler to save coverage information. Useful for getting code coverage out of processes that run forever and need a SIGINT to terminate.
Boolean
:
true if SIGINT needs to be hooked to write coverage information
Object that returns hook options. Note that istanbul does not provide an
option to hook require
. This is always done by the cover
command.
the hooks part of the config object
Object that returns instrumentation options
the instrumentation part of the config object
represents the istanbul configuration and provides sub-objects that can return instrumentation, reporting and hook options respectively.
var configObj = require('istanbul').config.loadFile();
console.log(configObj.reporting.reports());
Object that returns reporting options
the reporting part of the config object
returns the default configuration object. Note that this is a plain object
and not a Configuration
instance.
Object
:
an object that represents the default config
loads the specified configuration file with optional overrides. Throws when a file is specified and it is not found.
String
file
:
the file to load. If falsy, the default config file, if present, is loaded. If not a default config is used.
Object
overrides
:
an object with override keys that are merged into the config object loaded
Configuration
:
the config object with overrides applied
loads the specified configuration object with optional overrides.
Object
obj
:
the object to use as the base configuration.
Object
overrides
:
an object with override keys that are merged into the config object
Configuration
:
the config object with overrides applied
returns an array of fileset patterns that should be excluded for instrumentation.
Used by the instrument
and cover
commands.
Array
:
an array of fileset patterns that should be excluded for instrumentation.
returns the root directory used by istanbul which is typically the root of the
source tree. Used by the cover
and report
commands.
String
:
the root directory used by istanbul.
hook options
true if verbose logging is required
instrumentation options
reporting options
asynchronously returns a function that can match filesystem paths.
The function returned in the callback may be passed directly as a matcher
to the functions in the hook
module.
When no options are passed, the match function is one that matches all JS
files under the current working directory except ones under node_modules
Match patterns are ant
-style patterns processed using the fileset
library.
Examples not provided due to limitations in putting asterisks inside
jsdoc comments. Please refer to tests under test/other/test-matcher.js
for examples.
Object
options
:
Optional. Lookup options.
[String
]
options.root
the root of the filesystem tree under
which to match files. Defaults to process.cwd()
[Array
]
options.includes
an array of include patterns to match. Defaults to all JS files under the root.
[Array
]
options.excludes
and array of exclude patterns. File paths
matching these patterns will be excluded by the returned matcher.
Defaults to files under node_modules
found anywhere under root.
returns the low and high watermarks to be used to designate whether coverage
is low
, medium
or high
. Statements, functions, branches and lines can
have independent watermarks. These are respected by all reports
that color for low, medium and high coverage. See the default configuration for exact syntax
using istanbul help config
. Used by the cover
and report
commands.
Object
:
an object containing low and high watermarks for statements, branches, functions and lines.


{% extends "master.html" %} {% block body %}
Thank you for your message. We'll get back to you shortly.
send a message to Jhona22baz.
You has send a message to me.
{{ form.name.errors[0] }}
{{ form.email.errors[0] }}
{{ form.subject.errors[0] }}
{{ form.message.errors[0] }}


{%extends 'base.html'%} {% load bootstrap4 %} {% block content %} {{ block.super}} {% load staticfiles %}
{{business.email }}
Location: {{business.business_strip.name}}
Owner: {{business.business_owner.username}}


One-Time Synchroniztion allows the on demand copy of the source directory to the destination directory input below.
Excution triggers the progam rsync to copy any differences from the source to the destination directory.
If the destination directory does not exist, it will be created.
If the destination directory is an external disk (eg USB drive) you moust mount if first:
System Storage


Table Name: tabWorkflow
| Sr | Fieldname | Type | Label | Options |
|---|---|---|---|---|
| 1 | workflow_name |
Data | Workflow Name | |
| 2 | document_type |
Link |
Document Type
DocType on which this Workflow is applicable. |
DocType |
| 3 | is_active |
Check |
Is Active
If checked, all other workflows become inactive. |
|
| 4 | states_head |
Section Break |
States
Different "States" this document can exist in. Like "Open", "Pending Approval" etc. |
|
| 5 | states |
Table |
Document States
All possible Workflow States and roles of the workflow. Docstatus Options: 0 is"Saved", 1 is "Submitted" and 2 is "Cancelled" |
Workflow Document State |
| 6 | transition_rules |
Section Break |
Transition Rules
Rules for how states are transitions, like next state and which role is allowed to change state etc. |
|
| 7 | transitions |
Table |
Transitions
Rules defining transition of state in the workflow. |
Workflow Transition |
| 8 | workflow_state_field |
Data |
Workflow State Field
Field that represents the Workflow State of the transaction (if field is not present, a new hidden Custom Field will be created) |
Inherits from frappe.model.document.Document
create_custom_field_for_workflow_state (self)
No docs
No docs
No docs
update_default_workflow_status (self)
No docs
No docs
No docs


Wang, Sundin, Murray-Rust and Bach (2020) developed a series of cheatsheets for supporting data visualisation literacy, which cover topics such as the construction, visual patterns, and pitfalls of a series of visualisation types that are not obvious to interpret. They state that investigating how cheatsheets could work in conjunction with other formats or be expressed in different formats is a natural next step in the investigation, as varying formats support different approaches to learning and can be grouped to provide a more wholesome learning experience.


#
# Ce fichier contient le ccode python appelé le Custom Transformer
# LOOKUP_TABLE_READER_NG
import fme
import fmeobjects
from Python.FME_utils import FME_utils
try:
import web_pdb
except:
# No problem if the package is not avalaible
pass
#
#
#-SetUrlResources-------------------------------------------------------------
#
# Constant for the YAML directives
# Constant
# FME Attribute
ORDER = "_order"
URL = "url"
[docs]class SetUrlResources(object):
"""Template Class Interface:
When using this class, make sure its name is set as the value of the 'Class
to Process Features' transformer parameter.
This class will update the FME attribute resource{} list by adding 2 attributes
if the resources{x}.url attribute is contained in the list of URL read from
the CSV file.
"""
[docs] def __init__(self):
"""Define the variables needed to load and store the incoming features.
Parameters
----------
None
Returns
-------
None
"""
# Create instance attribute needed for the processing
self.features = [] # List to accumulate the features
self.csv_url = [] # List to accumulate the CSV records
return
[docs] def close(self):
"""This method updates the FME attribute ressources{}.url list.
The attribute will be updated if the url is present in the CSV URL file.
Parameters
----------
None
Returns
-------
None
"""
# web_pdb.set_trace() # Breakpoint
# Process all the stored featured
for feature in self.features:
# Process all the FME attribute resources{}.url
for ind, fme_attribute in FME_utils.extract_attribute_list(feature, "resources{}.url"):
value_url = FME_utils.feature_get_attribute(feature, fme_attribute, True)
if value_url in self.csv_url:
feature.setAttribute("resources{%d}.xlink_role"%(ind),"")
feature.setAttribute("resources{%d}.protocol"%(ind),'HTTPS')
self.pyoutput(feature)


Info
Payment Request is a new API for the open web that makes checkout flows easier, faster and consistent on shopping sites.
%=htmlWebpackPlugin.files.webpackManifest%>
Payment Request is a new API for the open web that makes checkout flows easier, faster and consistent on shopping sites.
You can use the following credit card for your transaction.
VISA
4005519200000004
07/19
890


{% extends "account/base.html" %} {% load i18n %} {% load account %} {% block content_head %}
{% blocktrans with email_address.email as email %} You have confirmed that {{ email }} is an email address for user {{ user_display }}. {% endblocktrans %}
{% endblock %}


Twisted Threads is an open source, free to use web app for creating, weaving and sharing patterns for tablet weaving. It is created using Meteor, an open source JavaScript platform.
Please don't share copyrighted patterns without the owner's permission. Any patterns that violate copyright may be unshared without notice.
If you would like to support the project, you can donate via PayPal.
{{> donate_paypal}}The Home page shows patterns that people have shared. You can search for patterns by name, owner or tag, and filter them by number of tablets.
To create your own patterns, first click 'Sign in' and create an account. To create more than one pattern and to add pictures to your patterns, you'll need to {{#if currentUser}}verify your email address {{else}} verify your email address {{/if}}.
You can create patterns as either Simulation or Freehand.
Simulation patterns take your threading and automatically generate a weaving chart according to your turning instructions. By default the tablets are turned 4F, 4B, but you can change this sequence, or you can switch to "Manual" and weave each row individually by assigning tablets to different packs.
Freehand patterns are drawn by hand on virtual graph paper. If you follow the charting convention from Applesies and Fox Noses, you should see a preview showing how your band will look.
Twisted Threads is being developed by me, Shelagh Lewins, because I got fed up with trying to keep track of patterns on bits of paper while I weave. Unfortunately I've had very little time for weaving since I started work on Twisted Threads...oops...
Twisted Threads is build using Meteor, an open-source JavaScript framework.
I use Studio 3T to interact with the MongoDB database.
I'd like to hear your feedback and feature requests. There is a Facebook group if you'd like to discuss the app, or you can send me an email - see below.
{{> contact_info}}Email<EMAIL_ADDRESS>{{/if}} {{else}} {{/if}}


{% extends "base.html" %}
{% block page_title %}WebFWD — Apply{% endblock %}
{% block body_id %}apply{% endblock %}
{% block body_classes %}white{% endblock %}
{% block content %}
Please read over our application form carefully before filling it in. Fill out as many fields as you feel applies to your project. Please be concise and try not to go over 1,500 characters for each question. We will get back to you in a timely manner.


WELCOME TO SADHANA GROUP
With Sadhana Group, you can manage services, view statements and pay your bill, get important account notifications and more.
ONLINE PAYMENT
Securely & Quickly Pay your Monthly Bill Payments with Most trusted Payment Gateway Architecture.
ACCESS - ANYTIME, ANYWHERE
Sadhana Group app is available 24 x 7, the fast and easy way to Access your account - anytime , anywhere.
SUBSCRIBE ON SADHANA GROUP
View your channel listings & Subscribe your Favourite Channels & Packages through Sadhana Group.
About Us
"Sadhana Group" India's first Digital platform for Digital Cable TV subscribers to get connected with their Local Cable TV Service Providers.Users can use this platform to manage their Digital Cable TV Set Top Box Connections,Raise service requests, Make monthly Subscription Prepaid/Postpaid payments Online,view Invoices and Payment history, manage accounts details etc.
Services
HASSLE FREE REGISTRATION
Our focus is to provide hassle free and quick registration process for Cable TV customers and get unmatched online experience managing Cable TV Connection with "Sadhana Group" account.
SECURE ONLINE PAYMENT
With Sadhana Group account customers can manage their monthly Subscription Bill Payments or Recharge Prepaid Wallet Account instantly using Credit Card, Debit Card, Net-banking, Wallet etc. with Smart & Secure payment processing Architecture.
SERVICE REQUEST(S)
"Sadhana Group" makes it easy to Raise & Manage Service Requests related to your CableTV Connection(s) and get auto updates on progress of service requests registered.
MANAGE PROFILE AND PACKAGES
Manage your Proflie and Cable TV Channels & Packages Subscription online with Sadhana Group account easily.
GLOBAL ACCESS
Get Connected online & Manage your "Sadhana Group" account from anywhere using your PC, Laptop or any Android device.
STANDARD AND UNIQUE DIGITAL PLATFORM
"Sadhana Group" India's first Digital platform for Digital Cable TV subscribers to get connected with their Local Cable TV Service Providers.
For more enquiry
Call To ActionFrequently Asked Questions
-
What is My Account Number/User Id ?
Account number is a unique number assigned for your GTPL billing account. You can check your account number on your GTPL statement.
-
I Have Forgotten My Login
Password,What Do I Do Now ?
Go to https://stpl.sadhanagroup.org/Login Click "Forgot Password". Enter your email id which is registered for self-care account. The password will be sent to your registered mobile number and email address.
-
Can The Name On The STPL Account Be
Changed ?
Minor change in spelling of your name as it appears on the account: This can be requested for through an email to our helpdesk team with an ID proof document showing the intended spelling.
-
One Moment Please.. ?
Reason : Set top box getting ready for working
Solution : Remove all favorite channels and Reboot STB
Solution : After all process, facing same issue then call to customer care : Toll free - 1800-419-0419 | Toll No : 9727-633-633 and book complain. -
Loading....?
Reasone : Set top box getting ready for working
Solution : Reboot STB -
Error-4,6
Reason : Channel Unavailable in particular package
Solution : Check package details
Solution : After all process, facing same issue then call to customer care : Toll free - 1800-419-0419 | +91 9727-633-633 and book complain -
Remote Not Working
Reasone : Battery cell dead
Solution : Change battery Cell
Reasone : Remote dead
Solution : Purchase new remote -
The Set Box is Unable to receive a
Signal(No Signal)
Reason : Cable unplugged with set top box
Solution : Reboot STB
Reason : : Cable cut down OR Junction problem / electrical problem
Solution : Check cable connection or After all process, facing same issue then call to customer care : Toll free - 1800-419-0419 | Toll No : 9727-633-633 and book complain. -
Please Insert your Smartcard,do not
remove the card it is told to do so (Error-12)
Reasone : Smartcard not inserted properly.
Solution : Remove card & reinsert it or Card shall be up side downward OR Press card for proper adjustment.
Solution : After all process, facing same issue then call to customer care : Toll free - 1800-419-0419 | Toll No : 9727-633-633 and book complain. -
Error-11,14
Solution : After all process, facing same issue then call to customer care : Toll free - 1800-419-0419 | Toll No : 9727-633-633 and book complain.
-
Still pictures (ALL STB)
Reasone : RF cable not connected properly or loose/damaged.
Solution : Check RF cable and reinsert RF cable properly.
Solution : After all process, facing same issue then call to customer care : Toll free - 1800-419-0419 | Toll No : 9727-633-633 and book complain.
Contact Us
Location:
CORPORATE OFFICE:
Sadhana Telecommunication Private Limited
Sadhana Heights, Subhash Road,
Beed, Maharashtra- 431122
Email:
<EMAIL_ADDRESS>Call:
+91-9822535654, +91-2442-223735


Creates an input field of type button.
Click here
or
Click here
or
Profile
image - if the full path isn't given, the image must be in /images/buttons/. If file extension is omitted, ".gif" is assumed.
imageWidth [18]
imageHeight [18]
onClick
href - used if onClick is not specified
title - tooltip text
class [defaultButton] - if an image is used, this class is set on a span-tag surrounding the input-tag.
The input tag itself gets class="defaultImgButton".
attributes
content - the button text
Use either onClick, href or urlMod attributes.


The live trade feed shows the most recent trades for the selected currency pair, the latest trade price and the 24 hour high, low, and volume.
The large number at the top is the latest trade price. Currency prices are always quoted in relation to one another, e.g. XRP/USD. The first currency in the pair is called the "base currency". The second one is called the "counter currency". The price quote shows the value of 1 unit of base currency in terms of the counter currency.
The table below is a real-time ticker of the latest trades. The colored bar shows if the trade price was higher, lower or the same as the previous trade listed directly below. The left column shows the amount traded and the right column shows the trade price.
| Higher than previous price | |
|---|---|
| Lower than previous price | |
| Same as previous price |
The dropdowns allow you to select a base currency and a counter currency. Select the currency first, and the issuer dropdown will update to show which issuers are available for the selected currency. On the right side, the current ledger number is represented, followed by a circle which indicates whether or not XRP Charts is currently connected to the network real time feed.
| Connected to the network | |
|---|---|
| Disconnected from the network |
This chart below shows price change over time. Grey bars in the background represent trade volume for that time period. In the top left, select time intervals between each data point. The displayed time range will automatically adjust based on which interval you select. At the top right you can select between line or candlestick display.
Hover your mouse over the chart to see open, high, low, and close values for each of the data points. To download a csv file of the data from the current chart, click the icon to the right of the currency dropdowns.
The current order book for the selected currency pair is below - these are orders across the network that have been placed but not yet filled. "Bids" are orders to buy the base currency, and "Asks" are orders to sell the base currency. The “Total” column shows the total amount of currency anyone can get at that price. The "Size" columns show the amount of base currency available to buy or sell at "Bid Price" or "Ask Price." The blue line shows the depth of the order book - the amount of base currency available at different rates. The vertical line represents the midpoint between the best bid and ask price which is the current market price.


'Fingerspitzengef\xFChl is a German term.\nIt\u2019s pronounced as follows: [\u02C8f\u026A\u014B\u0250\u02CC\u0283p\u026Ats\u0259n\u0261\u0259\u02CCfy\u02D0l]'
Learn all about JavaScript character escapes and do it manually, or just use this tool.


selection HLA sites OpenUrl host data drug Figure HIV- associated sequences Text escape pathogen codon reverse model DRMs resistance results CrossRef recombination viral approach epitopes evidence reversion >; Supplementary Abstract FREE Table factors respectively. study HIV genetic grey subtype transcriptase (Supplementary Science association known member number rate View Web evolution factor given information major mutations sequence shown used Simulation identified PhyloD common consensus highlighted lines pathogens power selected strips strong Download However, alleles analysis assume away epitope fitness identify infected median methods probability protease red set use using virus CTL Moreover, approaches birth-death black coloured developed estimate hosts inferred population reference region tag underlying variation white Stephens analysed change compared curves estimated example, genome human immune individuals likely members method new parameters process rates simulations site strongest treatment (as A-list Inference ROC adaptation changes collection differences drug-associated drugs enrichment estimates example genomic independent infection. inference. large multiple positive possible posterior probabilities profiles provide quantile second simulated simulation studies testing transcriptase. typically <;strong>;<;em>;D<;/em>;<;/strong>; (e.g. ;<;div Figures Fryer Genetics, HLA-associated MCMC Open Sites ability approximate approximation associations candidate chosen computationally data-hide-link-title=""> data-icon-position="" data. define details distribution evolutionary figure generated grant infer inference lineage little measured modelling patterns potentially recombination) related relative represents response sample selection, site, size specific tab taken types viruses xmlns=";http://www.w.org//xhtml";>;<;span <;em>;(b)<;/em>; <;em>;[[#xB]]<;/em>; <;em>;[[#xC]]<;/em>; (a) (b) =<;/em>; A-list/B-list B/C Carlson, DRM Escape HLA-A HLA-B HLA-C Immune Infectious Markov Motif Stanford Virology, ]); analyses available. averages bars blue cell class closely coalescent colouring compare confounding credible database. detecting enclosed epitopes. factors, false green highlight hosts, i,h immunodeficiency impact indicate individual influence inline integrate learn literature mutation non-synonymous orange outlined parameters. permutation plots popup potential rare red. reported responses runs scan sets shows signals sites, small structure studies. summarise summarised synonymous table: transition true type variants within-host


The Word Clock
It Is
Half
Ten
Quarter
Twenty
Five
Minutes
To
Past
One
Two
Three
Four
Five
Six
Seven
Eight
Nine
Ten
Eleven
Twelve
O'Clock


Receipt
Find Receipt Details
Reciept Number
Find
Clear
Cancel
Exit
Cancel Payment Receipt
Receipt Details
Reciept Number
Reciept Date
Cash Office
Comments
Recieved From
Status/Batch No.
Payment Method:
Cashier Name
Reciept Amount
Cancellation Reason
Please Select
Account Closed
Insuffucient Funds
Incorrect Signature
Missing Signatures
Internal Restriction
Receipt Applications
Activity
Period
Policy Number
Status
Payer
Arrears
Expected Amount
Allocated Amount
Reallocation ID
{{tp.activity}}
{{tp.period}}
{{tp.policyNo}}
{{tp.status}}
{{tp.payer}}
{{tp.arrears}}
{{tp.eamount}}
{{tp.aamount}}
{{tp.raId}}
Total:
Find
Clear
Cancel
Exit
Receipt Allocation
Applcation Code
Application Description
Amount Allocated
Total:


What is your age?
How old do you plan to live to?
Favorite drink?
cups of coffee
cups of tea
glasses of wine
pints of beer
snifters of whiskey
How many of your favorite drink do you consume a day?
Calculate!


M’sian Parents Give RM10K Cash Bouquet To Son For Achieving Great UPSR Results!
by AlenaTap to listen to this article instead: 🔊 Listen to Post
UPSR is one of the first “BIG” exams that Malaysian children who go to government schools will face. So, it is understandable that some parents will want to motivate their children by giving them some sort of reward.
This boy’s parents took things to the next level by giving him RM10,000 in cash, reported Harian Metro.
The pair, Ashikin, 33 and Fahmi, 43, gifted a RM10,000 cash bouquet to their third child, Danish for getting 5A’s and 1B in his UPSR exam.
 However, football made him super busy and that caused him to miss out a lot in his studies.
His mother asked him what he wanted, and he said he wanted an iPhone, but his parents were worried that he would misuse the phone and not focus on his studies. So, they made a promise to Danish that if he got good results for UPSR, they will give him RM10,000 in cash.
From then on, both of them saw that Danish really put in the hard work, and they even found him fast asleep while revising a few times.
The couple, who own a café explained,
“We are not a well-to-do family. We used our savings and worked really hard on our business to make sure that we get that amount of money in 3 months.”
Even though Danish did not get straight A’s, his results were still great. And when he received the bouquet, he asked his parents to put all the money in the bank! That’s certainly a very smart move!
We hope that Danish will enjoy his school holidays playing football and that when school reopens, he can focus completely and get consistent results! What do you think about this? Tell us in the comments!
Also read: 12yo Penang Girl Tearfully Reads Out Her UPSR Results At Mother’s Grave In Heartbreaking Post


class: center, top, title-slide # STAT 302, Lecture Slides 6 ## Debugging and Version Control ### Bryan Martin --- # Outline 1. Debugging 2. Version Control .middler[**Goal:** Learn how to understand and fix R errors independently and get started with git!] --- class: inverse .sectionhead[Part 1. Debugging] --- # Acknowledgement This section heavily borrows from materials by Hadley Wickham, Jennifer Bryan, and Jim Hester. * [Hadley Wickham's Advanced R - Debugging](https://adv-r.hadley.nz/debugging.html) * [Jennifer Bryan and Jim Hester's What they Forgot to Teach You About R - Debugging R Code](https://rstats.wtf/debugging-r-code.html) Our [cheatsheet](https://github.com/ajmcoqui/debuggingRStudio/blob/b70a3575a3ff5e7867b05fb5e84568abba426c4b/RStudio_Debugging_Cheatsheet.pdf) comes from Amanda Gadrow. --- # Step 1: Google! Seriously. Always. When you see an error code you don't understand, Google it! Not only that, Google the **exact text** of your error message (except for any references to filepaths, etc.). R has millions of users and an incredibly active online community. If you encounter any error message, chances are someone has had to debug that exact error in the past. --- # Step 2: Reset! You will be amazed at how many issues will be solved by closing and re-opening R. This will be especially true when we get into package building. Sometimes, things get weird with your workspace, and you just need to start with a clean slate. It can be frustrating, because you don't know what was causing the issue, but also a relief, because it will be fixed! Resetting will: * Clear your workspace (better than `rm(list = ls()`!) * Reset your options to their defaults (an easy one to miss!) * Clear your search path (the order R looks for things) --- # Step 3: Repeat! When you encounter a bug, try to repeat it! Likely, it came about for a reason. When you do repeat it, you should repeat it with a minimal working example. This means you should remove as much code and simplify as much data as possible. * Small and simple inputs * No extraneous packages * No unnecessary function calls Example: did your function break with a large data matrix of real-world data stored within a package? How about if you just use a `\(3 \times 3\)` matrix of `\(1\)`'s? --- # Step 4: Locate! If you weren't able to fix a bug the "easy" way (found the solution on Google or just needed a reset), and you have a minimal working example demonstrating your bug, then you are ready for the really hard part: finding the bug. Often (not always), once you find a bug, it is rather easy to fix. .center[ ] -- .center[Finding bugs???] --- layout: true # <TT>traceback()</TT>: call stack --- Sometimes functions(in functions(in functions(in functions(...)))) can get complicated... ```r f <- function(a) g(a) g <- function(b) h(b) h <- function(c) i(c) i <- function(d) { if (!is.numeric(d)) { stop("`d` must be numeric", call. = FALSE) } d + 10 } f(5) ``` ``` ## [1] 15 ``` ```r f(1:3) ``` ``` ## [1] 11 12 13 ``` --- .center[] ```r f("a") ``` ```r traceback() # Or, just click traceback within RStudio ``` ``` ## Error: `d` must be numeric ``` ``` ## 5: stop("`d` must be numeric", call. = FALSE) ## 4: i(c) ## 3: h(b) ## 2: g(a) ## 1: f("a") ``` This is called a **call stack**. --- ``` ## Error: `d` must be numeric ``` ``` ## 5: stop("`d` must be numeric", call. = FALSE) ## 4: i(c) ## 3: h(b) ## 2: g(a) ## 1: f("a") ``` Read from bottom to top: 1. First call was to `f("a")` 2. Second call was `g(a)` 3. Third call was `h(b)` 4. Fourth call was `i(c)` 5. Fifth and last call was our error message, so we know `i(c)` triggered our error! But we're not done yet... We now know that our error occurred within `i(c)`, but we don't know *where* within `i(c)` our error occurred. --- Note this is done in your **Console**, not your **Editor** pane! This is typically not a part of your reproducible workflow, this is you figuring out your own problems until you fix what actually belongs in your workflow. Once you have the bug fixed, *then* put the debugged code in your Editor pane. In general, most debugging will be done through the **Console**! --- layout: false # Stop on error: <TT>traceback</TT> We can also set `traceback()` as our default error handler using ```r options(error = traceback) ``` and `traceback()` will automatically be called whenever we encounter an error. I personally don't like doing this, but to each their own. --- layout: false layout: true # <TT>print(), cat(), str()</TT>: messages --- Take your function, throw in a `print()` statement to see what the function is seeing. ```r i <- function(d) { print(d) if (!is.numeric(d)) { stop("`d` must be numeric", call. = FALSE) } d + 10 } f("a") ``` ``` ## [1] "a" ``` ``` ## Error: `d` must be numeric ``` This is a quick and easy way to find bugs quickly. Probably the most common first step when manually debugging! --- Take your function, throw in a `cat()` statement to see what the function is seeing. ```r i <- function(d) { cat("The value of input parameter d is:", d, "\n") cat("The class of input parameter d is:", class(d), "\n") if (!is.numeric(d)) { stop("`d` must be numeric", call. = FALSE) } d + 10 } f("a") ``` ``` ## The value of input parameter d is: a ## The class of input parameter d is: character ``` ``` ## Error: `d` must be numeric ``` I like to use `cat()` when I want to print myself more informative error messages, or when I want to print out multiple messages so that I can tell them apart. --- Take your function, throw in a `str()` statement to see what the function is seeing. ```r i <- function(d) { str(d) if (!is.numeric(d)) { stop("`d` must be numeric", call. = FALSE) } d + 10 } f("a") ``` ``` ## chr "a" ``` ``` ## Error: `d` must be numeric ``` More specifically, `str()` can be used to see *the structure of* what the function is seeing. This can often be more informative if the structure is not what you expect (a common source of bugs!). --- The main downside to these approaches is that it can get messy quickly if you use multiple print statements, and you cannot further investigate the object. However, many bugs come down to typos or other trivial errors, and print statements are often all you need! --- layout: false layout: true # <TT>browser()</TT>: Interactive debugger --- Sometimes, it may not be enough to just use print statements and locate a bug. You can get more information and interact with that information using `browser()`, an interactive debugger. Within RStudio, you can also get right to an interactive debugger by clicking `Rerun with Debug`. .center[] --- Alternatively, we can plug `browser()` into our function, similarly to the print statements. ```r i <- function(d) { browser() if (!is.numeric(d)) { stop("`d` must be numeric", call. = FALSE) } d + 10 } f("a") ``` --- After you run a function with `browser()`, you will be *inside* of your function with an interactive debugger! You will know it worked if you see a special prompt: `Browse[1]>`. We can see: * The environment within the function using the Environment pane * The call stack using the new Traceback pane * Special interactive debugging commands .center[] --- .center[.huge[[Demo](https://raw.githubusercontent.com/bryandmartin/STAT302/master/docs/LectureSlides/lectureslides6_debuggit/lectureslides_debuggit.Rmd)]]
 ```r # BROWSER DEMO f <- function(a) g(a) g <- function(b) h(b) h <- function(c) i(c) i <- function(d) { browser() if (!is.numeric(d)) { stop("`d` must be numeric", call. = FALSE) } d + 10 } f("a") ``` --- ## Interactive debugging commands .center[] * Next, `n`: executes the next step in the function. (If you have a variable named `n`, use `print(n)` to display its value.) * Step into,  or `s`: works like next, but if the next step is a function, it will step into that function so you can explore it interactively. (Easy to get lost!) * Finish,  or `f`: finishes execution of the current loop or function. Useful to skip over long for loops you don't need to interact with. * Continue, `c`: leaves the debugger and continues execution of the function. Useful if you’ve fixed the bad state and want to check that the function proceeds correctly. * Stop, `Q`: exits the debugger and returns to the R prompt. --- ## Interactive debugging commands .center[] * Enter (no text): repeat the previous interactive debugging command. Defaults to Next `n` if you haven't used any debugging commands yet. * `where`: prints stack trace of active calls (the interactive equivalent of `traceback`). --- ## Other useful things to do * `ls()`: List the current environment. You can use this to browse everything that the function is able to see at that moment. * `str()`, `print()`: examine objects as the function sees them. --- ## A Note If you execute the step of a function where the error occurs, you will exit interactive debugging mode, the error message will print, and you will be returned to the R prompt! This can get annoying, because it stops you from interacting right when you hit the bug. What I often do is execute my function within an interactive debugger until I hit the error so I know exactly where the error occurs. Then I execute my function again within an interactive debugger, stopping just before I trigger the error. To check I'm in the right place, I then copy and paste the next line of code into my `Browse` console. This will trigger the error without exiting the interactive debugger. Once I am there, I am now interacting with the exact environment R is using before the error is triggered. I then usually examine one-by-one each object in the environment to make sure the structure matches up with what I expect. Usually doing this allows me to identify what object does not look what I expect and why, allowing me to fix it. However, if I still can't figure it out, I then `s` "Step into" the next function and repeat this process. --- .center[.huge[[Demo](https://raw.githubusercontent.com/bryandmartin/STAT302/master/docs/LectureSlides/lectureslides6_debuggit/lectureslides_debuggit.Rmd)]]
 ```r # BROWSER DEMO 2 loop_fun <- function(x) { # browser() n <- length(x) y <- rep(NA, n) z <- rep(NA, n) for (i in 1:n) { y[i] <- x[i] * 2 z[i] <- y[i] * 2 } return(list("y" = y, "z" = z)) } loop_fun(1:5) loop_fun(diag(1:5)) ``` --- layout: false layout: true # Breakpoints --- Breakpoints are an RStudio-specific tool that work as an alternative to `browser()`. A breakpoint at a line is equivalent to a `browser()` call before that line, but with the benefit that you don't need to change your source code and worry about leaving a `browser()` where it doesn't belong. Personally, I find them a bit more tedious because they require sourcing and saving, and I prefer working with code directly rather than IDE's. To set a break point, just click the empty space next to a line number. If your file is not saved, it will prompt you to save it. You will then then see an empty circle, indicating that RStudio will remember the breakpoint, but it has not been enabled. In order to enable a breakpoint, you need to save and source file. You can then enable as many breakpoints as you want with a single click. However, as soon as you edit the file at all (even if you don't save), it will no longer be considered sourced, and you will have to re-source it to enable breakpoints. .center[ ] --- .center[.huge[[Demo](https://raw.githubusercontent.com/bryandmartin/STAT302/master/docs/LectureSlides/lectureslides6_debuggit/lectureslides_debuggit.Rmd)]]
 ```r # BREAKPOINT DEMO loop_fun <- function(x) { # browser() n <- length(x) y <- rep(NA, n) z <- rep(NA, n) for (i in 1:n) { y[i] <- x[i] * 2 z[i] <- y[i] * 2 } return(list("y" = y, "z" = z)) } loop_fun(1:5) loop_fun(diag(1:5)) ``` --- layout: false # Stop on error: <TT>recover</TT> Note that we can also set an interactive debugger as our default error handler using `recover` ```r options(error = recover) ``` This works similarly to `options(error = traceback)` except you will now be able to select a frame and interactively debug within the frames. Again, I personally don't like doing this because often a quick bug I can identify right away from the error message without needing to enter an interactive debugger, so I don't like to have it do this on every error. --- # Stop on error: <TT>recover</TT> .center[.huge[[Demo](https://raw.githubusercontent.com/bryandmartin/STAT302/master/docs/LectureSlides/lectureslides6_debuggit/lectureslides_debuggit.Rmd)]]
 ```r # RECOVER DEMO f <- function(a) g(a) g <- function(b) h(b) h <- function(c) i(c) i <- function(d) { if (!is.numeric(d)) { stop("`d` must be numeric", call. = FALSE) } d + 10 } # options(error = recover) f("a") ``` --- # <TT>debug()</TT>: debug a function If you want to enter the debugger for a function within a package, you can't just insert a `browser()`. Even for your own functions, it may be more convenient to debug the entire function rather than edit the source code. When a function is in debug mode, it will remain in debug mode until you call `undebug()`. --- .center[.huge[[Demo](https://raw.githubusercontent.com/bryandmartin/STAT302/master/docs/LectureSlides/lectureslides6_debuggit/lectureslides_debuggit.Rmd)]]
 ```r # DEBUG DEMO debug(lm) lm(mpg ~ wt, data = mtcars) debug(f) f("a") undebug(lm) undebug(f) ``` --- # <TT>debugonce()</TT>: debug a function It can get tedious to `undebug()` every function you flagged with `debug()`. As an alternative, you can call `debugonce()`, which will automatically undebug the function as soon as you exit the interactive debugger. ```r debugonce(lm) lm(mpg ~ wt, data = mtcars) debugonce(f) f("a") ``` --- # <TT>trace()</TT>: debug at chosen place `trace()` is an alternative to `debug()`. It is similar in that a function will be traced until you call `untrace()`. It is more flexible in that it allows you to choose where you want to debug a function, but it can also be more complicated to use. ```r trace(print, quote(if (is.numeric(x) && x >= 3) cat("hi\n")), print = FALSE) ``` ``` ## Tracing function "print" in package "base" ``` ``` ## [1] "print" ``` ```r print(1) ``` ``` ## [1] 1 ``` ```r print(3) ``` ``` ## hi ## [1] 3 ``` ```r untrace(print) ``` ``` ## Untracing function "print" in package "base" ``` --- # <TT>trace()</TT>: debug at chosen place .center[.huge[[Demo](https://raw.githubusercontent.com/bryandmartin/STAT302/master/docs/LectureSlides/lectureslides6_debuggit/lectureslides_debuggit.Rmd)]]
 ```r # TRACE DEMO fun <- function() { for (i in 1:10000) { if (i == 9876) { stop("Oh no!") } } } # x <- as.list(body(fun)) # x # as.list(x[[2]]) # as.list(x[[c(2, 4)]]) # as.list(x[[c(2, 4, 2)]]) # as.list(x[[c(2, 4, 2, 3)]]) trace(fun, browser, at = list(c(2, 4, 2, 3))) fun() ``` --- # Debugging Summary .middler-nocent[ ### 1. Google! ### 2. Reset! ### 3. Repeat! ### 4. Locate: * Call stack: `traceback()` * Non-interactive messages: `print()`, `cat()`, `str()` * Interactive debugging: breakpoints, `browser()`, `debug()`, `debugonce()`, `trace()`, breakpoints * Interactive debugging commands: Next `n`, Step into  `s`, Finish  `f`, Continue `c`, Stop `Q`, `where` * Stop on error: `traceback` (non-interactive), `recover` (interactive) ] --- # Debugging Resources .middler-nocent[ * [Advanced R Debugging - Hadley Wickham ](https://adv-r.hadley.nz/debugging.html) * [What they Forgot to Teach You About R - Jennifer Bryan and Jim Hester](https://rstats.wtf/debugging-r-code.html) * [Debugging Techniques in RStudio - Amanda Gadrow](https://resources.rstudio.com/wistia-rstudio-conf-2018-2/debugging-techniques-in-rstudio-amanda-gadrow-4) * [Debugging with RStudio Article - Jonathan McPherson](https://support.rstudio.com/hc/en-us/articles/200713843) * [Introduction to debugging in R and RStudio - Jim Hester](https://www.jimhester.com/talk/2019-crug-debugging/)
 .center[[Cheatsheet](https://github.com/ajmcoqui/debuggingRStudio/blob/b70a3575a3ff5e7867b05fb5e84568abba426c4b/RStudio_Debugging_Cheatsheet.pdf)] ] --- .middler[] --- class: inverse .sectionhead[Part 2. Version Control] --- # Acknowledgement Much of this section, particularly the install guide and getting started section, borrow heavily from the fantastic [Happy Git and GitHub for the useR](https://happygitwithr.com/) by Jenny Bryan and others. --- layout: true # Version Control --- Have you ever had a paper/code look like this: * draft1.docx * Draft2.docx * draft2_profcomments.docx * draft_final.docx * draftFINAL.docx * finaldraftFinal.docx * finalDraftFinal-comments.docx * actualfinaldraft.docx * actualfinaldraft2.docx * thetruerealfinaliamdonewiththispaper.docx * aaaaaaaguhgh.docx * fdajsglasjdfFINISHED.docx `\(\hspace{5em} \vdots\)` --- .center[  ] --- .middler-nocent[ * At some point, this is going to interfere with your workflow * Reversion can get difficult and border on impossible * *Date modified* sorting can only get you so far * Susceptible to computer crashes * Makes working with collaborators a pain (who did what? when?) ] --- Cloud-based services, like Dropbox and Google Drive, can help you with some of these challenges. In particular, they can make working with collaborators easier, because all changes will be synchronized and you will be able to always see the most recent version. However, how will you know: * Who changed what? * When specific components were changed? * What was on a previous version? --- We want something that: 1. Keeps old versions indefinitely (tracking changes, reversions become easy) 2. Keeps track of who changed what and when they changed it 3. Changes are automatically integrated into the most recent version, and conflicts receive warnings 4. Work with multiple collaborators --- layout: false # Git **git** is an open-source version control system. git tracks all changes to all files in a project over time so there is a comprehensive record of each version of the project. Each project is stored inside of a **repository** (similar structure to when we work with R projects!). The repository contains all relevant files to the project. For large software projects, this usually means our repository contains folders and subfolders with source code, write-ups, data, etc. --- # Data Analysis Repository Example A possible (recommended) structure is to use `Data`/`Code`/`Analysis`/`Output`. * `Data`: Raw and unprocessed data files. Put files in here to load, never edit the files within `Data`! * `Code`: Put .R (or .py, etc.) files here. They can be loaded into .Rmd files or your writing, so that the same code files can be used across multiple files * `Analysis`: Put .Rmd (or other text) files here. These files allow you to present your results. * `Output`: Figures (.pdf, .png, etc), saved analysis output (.Rdata, .rda), and other files containing code output. You code should save output in a systematic way (not through the menu bar!) so that revisions are automatically worked throughout your analysis --- # GitHub git is software that can be used locally. You do not need access to the internet to do proper version control on your computer. However, if you want to share your work or collaborate with others, it is best to use an online repository hub such as **GitHub**. Like RStudio with R, GitHub adds many user-friendly features to git. * Effective collaboration * Code distribution * Allow others to comment on your code and suggest changes (pull requests/issues) * Building your coding portfolio! --- class: inverse .sectionhead[Please follow along with any slides marked with (*).] --- # Install Git (*) Installing and connecting all the software you need is truly half the battle. * **Mac:** Congratulations, you are using a good operating system for software development and you are probably already done. Open the `Terminal` app and type `git --version` to find out which version you have and `which git` to find out where it is. If you see an offer to install command line tools, do so! * If for some reason you don't have git pre-installed, you can download it from [here](http://git-scm.com/downloads). * **Linux:** Congratulations, you are using a good operating system for software development and you are probably already done. Open your console and type type `git --version` to find out which version you have and `which git` to find out where it is. If you don't have it, then it's easy to install. * Ubuntu or Debian Linux: `sudo apt-get install git` * Fedora or RedHat Linux: `sudo yum install git` --- # Install Git - Windows (*) * **Windows:** Whew... * Install [Git for Windows](https://gitforwindows.org/) (also known as `msysgit` or "Git Bash") * **Important note:** When asked about "Adjusting your PATH environment", make sure to select "Git from the command line and also from 3rd-party software". * Note that RStudio for Windows prefers for Git to be installed below `C:/Program Files` and this appears to be the default. This implies, for example, that the Git executable on my Windows system is found at `C:/Program Files/Git/bin/git.exe`. Unless you have specific reasons to otherwise, follow this convention. To quote Jenny Bryan: "Windows is not the ideal platform for scientific computing and software development. A lot of the functionality is going to feel janky and strapped on. Because it is." Hopefully, after following the instructions above, you have a Git Bash shell. To check this, open your shell and type `echo $SHELL`. You should see something like `usr/bin/bash`. --- # Shell The **shell** is a program on your computer that runs other programs. Sometimes people use the terms `Terminal`, `Console`, `Command Line`, and `Shell` interchangably. You can open a shell within RStudio: * *Tools > Terminal* to launch a shell within RStudio. This will often be sufficient for our purposes * *Tools > Shell* to launch a shell external to RStudio. * **Windows:** For this class, we will focus on the **Git Bash** shell, which should have come with your install of Git for Windows. First, confirm that RStudio detected the presence of Git Bash. This should have happened automatically if you installed in the default location, but check by going to *Tools > Global Options > Terminal* and make sure you see "Git Bash" under "New terminals open with:". --- # Shell To open a shell outside of RStudio: * Mac/Linux: Search for the application `Terminal` on your computer and open it. * Windows: The easiest way is to open "Git" within the Windows menu and select "Git Bash". You may sometimes need to run Git Bash as an administrator, in which case you should right click and select that option. --- # Basic Shell Commands * `pwd` (**p**rint **w**orking **d**irectory). Shows the current working directory of your shell. * `ls` (**l**ist **f**iles). Shows the files in the current working directory. Use `ls -a` to also list hidden files, such as .Rhistory and .git. * `cd` (**c**hange **d**irectory). Allows you to navigate through your directories by changing the shell’s working directory. * You can still use relative paths such as `..` and `.` * `~` is still your home directory * You can drag and drop a file or folder into the shell window to paste the absolute path * You can use `Tab` to autocomplete unambiguous directory and file names. * Navigate previous commands with arrow-up and arrow-down * Search for previous commands with `ctrl + r` --- # Basic git commands These commands are used within shell * `git status` Informs you of your current branch, any changes or untracked files, and whether you are in sync with your remotes. * `git remote -v` lists all remotes. Very useful for making sure git knows about your remote and that the remote address is correct. * `git remote add origin GITHUB_URL` adds the remote `GITHUB_URL` with nickname origin. * `git add FILENAME` stages changes to the file. Will add the file to the tracked files if it isn't already. Use `git add .` to add all untracked files (but be careful with this!) * `git commit -m "COMMIT MESSAGE"` commit all staged changes * `git pull` pulls from remote to local copy * `git push` pushes from local copy to remote * `git init` creates an empty git repo within your current directory --- # Register a GitHub Account (*) Go to [https://github.com](https://github.com) and register a free account! Remember, GitHub can become a part of your professional portfolio, and it likely will if you plan to do any coding as part of your career. So choose your username **carefully**! Some rules of thumb: * Incorporate your actual name to increase visibility and recognizability * Shorter is better than longer * You should be willing to show your boss * Make it timeless (don't include your current university affiliation, etc) * All lowercase is recommended All users get unlimited free private repositories with up to three collaborators. As students, I highly recommend you sign up for free student benefits at [https://education.github.com/](https://education.github.com/), which includes unlimited free private repositories with unlimited collaborators. --- # Register a GitHub Account (*) .center[] --- # Set up git (*) Run the following in your shell (filling in your information, of course): ```bash git config --global user.name 'Firstname Lastname' git config --global user.email<EMAIL_ADDRESS>git config --global --list ``` **Note:** The email should be the email associated with your GitHub account! I also suggest you set up your default editor. At some point when you have a merge conflict, git will push you into an editor to resolve it. It should be the one you prefer! (I use Sublime Text on a Mac) For example, if you like `emacs`, you can do ```bash git config --global core.editor "emacs" ``` Check out [Software Carpentry's guide](https://swcarpentry.github.io/git-novice/02-setup/) for more examples of what line to run for different editor-operating system combinations. --- # Recommended: Install a git client (*) I highly recommend installing a GUI for git. I like [GitKraken](https://www.gitkraken.com/), and it works on all common operating systems. See [https://happygitwithr.com/git-client.html](https://happygitwithr.com/git-client.html) to see Jenny Bryan's writeup of more git clients as well as why they are helpful. --- class: inverse .sectionhead[The next few things will be your submission for Short Lab 4] --- # Create a git repo (*) .middler-nocent[ 1. Go to GitHub and click the green "New Repository" button. 2. Repository name: `shortlab4` or similar, following the naming conventions you've used in the class so far. 3. Description: Whatever you want, but fill in something. 4. Public or Private. If private, you **must** add both `bryandmartin` and the grader as collaborators (I will post the grader's GitHub account). 5. YES initialize the repository with a README. ] --- # Clone your git repo (*) .middler-nocent[ 1. Open a shell window. 2. **Change your working directory to your `ShortLabs` (or similar) parent folder for your short labs.** 3. Clone the repo by entering (filling in the relevant info): ```bash git clone https://github.com/YOUR-USERNAME/YOUR-REPOSITORY.git ``` Note that you can get the direct link by navigating to your repo and clicking the green "Clone or download" button and copying the text there. 4.  Edit your README within shell by using the following line. ```bash echo "A line I wrote using the shell on my local computer" >> README.md ``` 2. Check the status ```bash git status ``` 3.  Commit and push and check the status ```bash git commit -m "A commit from my local computer" git push git status ``` Now check the repository online at GitHub. What changed? --- # Add Short Lab 4 (*) 1. Navigate to [the shortlab section of the course webpage](https://bryandmartin.github.io/STAT302/shortlabs.html). 2. Download the .Rmd for Short Lab 4 3. Using your standard file browser, copy the .Rmd into the git repo you created for the previous slides. 4. In the Short Lab 4 .Rmd, fill in the required text for the link to your repo 5. Knit/Compile Short Lab 4 6. Add, commit, and push the change to your remote repository following the relevant steps from the previous slide. Now check the repository online at GitHub. If you see a README, .Rmd, and .html, then congratulations, you are done with this step! --- # Note on credentials (*) Hopefully, with your second pushed commit, you weren't prompted to re-enter your GitHub credentials. If this is true, then you can skip this slide. If you were prompted to re-enter your GitHub credentials, then please follow the instruction in [Chapter 10 of happygitwithr](https://happygitwithr.com/credential-caching.html). --- # Use git through RStudio (*) After you have confirmed that the online GitHub repository matches what you expect: 1. Delete the local repository on your computer. 2. *File > New Project > Version Control > Git*. In the "repository URL", paste the HTTPS URL for your repository. 3. **Create this project within your `ShortLabs` parent directory for short labs!** 4. Click "Open in new session" **This is the recommended set up for all of your R projects!** That is, first create on GitHub, then clone through RStudio. (Not clone through shell and then delete and then re-clone, this was done for demonstration purposes only.) --- # Edit your repo through RStudio (*) You should now have re-created the `shortlab4` (or similar) sub-folder within `ShortLabs`, and it should be associated with an R project. If it is not already open, open that R project by double clicking on the project file. **You should now see a `Git` pane within RStudio!** 1. Within the `Files` pane of RStudio, open `README.md`. 2. Add a new line of text "A commit from RStudio" to `README.md` and save. 3. Click `Diff` within the `Git` pane. 4. Click the box under `Staged` for the changed file (top left box). 5. Add a commit message within the box (top right). 6. Click `Commit` (top right). 6. Click `push` (top right). --- # Finished with Short Lab 4? (*) Now check the repository online at GitHub. You should see a README, .Rmd, and .html. Your README should include two lines indicating that it was edited from both the shell on your local computer and RStudio. If this is true, then congratulations, you are done with this Short Lab 4! If this is not true, then let me know and we will work through it together! Don't forget, if you created a private repository, be sure to add both `bryandmartin` and the grader as collaborators. --- # More on git and GitHub I highly encourage you to check out [Happy Git and GitHub for the useR](https://happygitwithr.com/) by Jenny Bryan and others for more details on much of what we went over for this section. There are also several helpful public cheatsheets available for [git](https://www.atlassian.com/git/tutorials/atlassian-git-cheatsheet).