Bootstrap is the most popular HTL, CSS, and JS fraework for developin responsive, mobile first projects on the web


Last announcement posted at 4:13 am, February 7, 2015
Toggle nav
View Submission Guidelines
Download HDR File
Homework 2 has been posted!
Homework 1 has been posted!
Class Syllabus has been posted!


Your browser does not support JavaScript or scripts are being blocked.
Some of the features on my website may not work properly (e.g. navigation bar on mobile devices, or the
theme switcher). Consider switching to a modern browser that supports JavaScript,
or disable your script blocking software.


Add a New Store Location
Name of New Location:
Minimum Customers per Hour:
Maximum Customers Per Hour:
Average cookies sold per Hour:
Create new store (Congrats!)
Daily Simulated Salmon Cookie Sales By Hour And Location


PART 1: Template Matching
Problem Definition
The goal of part 1 of this project is to perform object detection and tracking of an object in a live video. The template matching method is used to perform object detection as well as tracking of the object. In this example, an object used is a pen. First, a template image the object, pen, is captured. On every frame, the template matching function call will be performed on the stream of image from the video against the template image. The goal of this project is to implement, test, and evaluate the template matching method on different size, orientation and change in illumination of the object.
Method and Implementation
The template matching method and implementation can be broken down into following steps:
The following detail description of method and implementation for each steps.
A. Template Image
In this project, we have decided to track a black pen - as an object to detect and track. The following is the template image of the pen we are going to track.
As you observe from the image, the orientation of pen is parallel to the horizon of the camera. This is an important detail that plays role in performance of the template matching algorithm.
The following code is used to read the template image and stores into 't_img':
t_img = imread(tempFileName, IMREAD_COLOR);
B. Reading Live Images from Video Channel
The following functions were used to open and read an image from a video channel.
First, an OpenCV object VideoCapture was created to open a video channel. In this case, channel 0 was opened:
VideoCapture videoCh(0);
Second, an OpenCV "read" method from the video object to read a image from video channel. Here the read image is stored in Mat object.
open0 = videoCh.read(Vframe0);
C. Template Matching
The stream of images from video are read in a while-loop and this image is used to perform template matching against
the template image described above.
The following function call 'tempMatchingOpenCV' which passes two variables to the function,
's_img', the search image and 't_img', the template image:
void tempMatchingOpenCV(Mat& s_img, Mat& t_img)
Call matchTemplate
In this function, first a resulting matrix is created to store the Normalized Correlation Coefficient calculated for
each pixel in the search image(s_img) against the template image (t_img).
Then the following OpenCV template matching function is called to calculate the NCC of two images:
matchTemplate(s_img, t_img, result, match_method);
Here, match_method = 5, i.e. Normalized Correlation Coefficient method. You can find more information about 'matchTemplate' function on following OpenCV documentation: OpenCV matchTemplate
Find Max NCC & location
Once you have the NCC results, the 'minMaxLoc' is used to find the maximum and minimum value in the result and the respective location of the result, as follows:
minMaxLoc(result, &minValue, &maxValue, &minLocation, &maxLocation, Mat());
You can find more information about 'minMaxLoc' function on following OpenCV documentation: OpenCV matchTemplate
Once we have the location of the Max NCC value, we use the following 'rectangle' method to draw rectangle around the detected object:
rectangle(imgDisplay, matchLocation, Point(matchLocation.x + t_img.cols, matchLocation.y + t_img.rows), Scalar::all(0), 2, 8, 0);
The following image shows an example of search image and resulting Normalized Correlation Coefficient.
Experiments
The experiments were The following are result of the object, 'pen', and detection and tracking using the template matching method
Results
Detected Images (Normal):
This image shows the pen being detected by the template matching method
Detected Images (Close Up):
This image shows the pen located very close to the camera, being detected by the template matching method.
Detected Images (Far Away):
This image shows the pen located far away from the camera such that the size of the pen is smaller than the
template image. Here, we can observe that part of my hand is being detected as part of the object.
Detected Images (Slightly Angled):
This image shows the pen slighted angled from horizontal plane. Here, we can observe that
the object is still being detected by the template matching method. However, with a pen that is more angled,
the algorithm has difficulty detecting the object.
UnDetected Images (Vertical):
This image shows the pen held vertically from the camera. The method fails to detect the object.
UnDetected Images (Too Far):
This image shows the pen is too far from the camera. The method fails to detect the object.
UnDetected Images (No Pen - False Positive):
In this image, there is no pen, however a similar object is determined as a pen - in this image, my glasses are shown as
that is highly correlated with the pen. They are both black and have similar horizontal features.
Discussion
In above experiments, we observed a number of cases which algorithm detected the object correctly, and few different cases which incorrectly identified the object. The cases which detected object correctly had the object in close correlation with the template image, where the orientation of the pen was parallel to the horizon of the camera.
Change in Orientation:
Change in Size of the Object:
Conclusions
The template matching algorithm implemented for this project does work moderately well for ideal case where the object is close correlated in terms of size and orientation. However, the template matching algorithm fails frequently when the object in the search image has different size or orientation. We observed this from a number of experimental case. Also, there can be false positive of the object when there are other objects that have similar property to the tracking object - which can cause failures.
The algorithm can be improved by compensating for the orientation of the object, or creating varying orientation of templates. Also, it can be improved by implementing the image pyramid method which compensates the size of the object in the search image.
PART 2: Gesture Recognition
Problem Definition
The goal of part 2 of this project is to design and implement algorithm that delineates hand shapes or gestures in a live video.
Method and Implementation
A. Template Images of Hand Shapes
For this part, three different hand shapes were used: (1) Palm, (2) Fist, (3) Index Finger. The following are template image used for shape of hands:
(1) Palm (2) Fist (3) Index Finger
B. Skin Detection
Since all our objects are hands (skin), we first perform a skin detection method on the stream on images to detect and isolate skin in the image into a grayscale image.
To do this, we use the skin detection function from the surveys of skin color modeling and detection techniques: Vezhnevets, Vladimir, Vassili Sazonov, and Alla Andreeva. "A survey on pixel-based skin color detection techniques."
The function call "skinDection" accepts the sources in image 'src', performs skin detection on the image and stores the grayscale result image in 'dst'. The following is function declaration:
void skinDetect(Mat& src, Mat& dst)
The implementation of skin detection as follows:
if ((R > 95 && G > 40 && B > 20) && (myMax(R, G, B) - myMin(R, G, B) > 15) && (abs(R - G) > 15) && (R > G) && (R > B)) { dst.at(i, j) = 255; }
The following is an example of detected skin image:
C. Contour
Once we obtain the grayscale image with detected skin, we use this image to find the contour of the skin detected in the image. At this point, we can find the largest contour area and make an assumption that this is the object (hand) we are looking for. With this assumption, we can find the largest rectangle around the detected object and treat as a sub-image that we can perform template matching.
findContours(frameDest, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0));
Documentation for finding contours: OpenCV findcontours
The following is an example of output of contour:
D. Object Recognition using Template Matching
Using the template matching technique, we take the each of the template images against the sub-image that we produced from the rectangle created by the contour. The maximum of the NCC is determined as the object that has the closest correlation with the template.
The following is an example of isolated palm image from live video:
Experiments
The experiment was performed on total of twenty different cases and the results were shown in confusion table.
Results
Result for Palm:
This image shows experimental result for detecting palm hand gesture. As you can see from the resulting output, Palm was correctly
detected.
Result for Fist:
This image shows experimental result for detecting fist hand gesture. As you can see from the resulting output, fist was correctly
detected.
Result for Index Finger:
This image shows experimental result for detecting index finger hand gesture. As you can see from the resulting output, index finger was correctly
detected.
Confusion Table
The following are confusion table for each of normal, close up distance, far distance and
total of three cases. For each experiment 15 cases were performed where hypothesis cases
are presented to the program to see if detection is correct or not.
Discussion
In this implementation, we can see that the classification of the algorithm works the best at close-up distance. As the distance from camera to hand gesture is increased the performance decreases.
Overall, we can see that the classification has most difficulty in distinguishing the Palm and Fist when Palm is presented. Also, the algorithm has difficulty in determining "One" index finger cases.
Conclusions
In general, the algorithm works quite well with the simple hand gestures. The classification of the hands can be much more improved by applying the pyramid image method to adjust for the size of the object in varying resolutions.
Information about Graphics
This is a simple graphics which shows different type of action/activity with respect to the hand gesture. For example, this can be used as a simple communication tool between a patient or a disabled person who is not able to speak properly but able to move and express with hand - without much restrictions. For example, it can be a simple tool for outdoor activity such as riding a mobile wheel chair.
Credits and Bibliography
Credit:
Reference:


{% extends 'base/backend_base.html' %} {% block title %}Surveys - Interns Australia{% endblock %} {% block content %}
This is a page where admin management will be presented
Manage Surveys View result {% if isAdmin %} Manage Staff {% endif %}


DiagnoBot API Reference
The DiagnoBot API.
API Endpoint
/api/v1
Request Content-Types: application/json
Response Content-Types: application/json
Version: 0.0.1
Symptoms
List symptoms
Get symptom by ID
symptom_id:
integer
in path
The symptom ID
200 OK
Successful operation
Response Example (200 OK)
{
"name": "Cough",
"id": 1
}
Diagnosis
The core diagnosis function
The diagnosis request
Request Example
{
"symptoms": [
{
"name": "Cough",
"id": 1
}
]
}
200 OK
Successful operation
type
Response Example (200 OK)
[
{
"probability": 0.83,
"name": "Bronchitis"
}
]


The dataverse package is the official R client for Dataverse 4 data repositories. The package enables data search, retrieval, and deposit with any Dataverse installation, thus allowing R users to integrate public data sharing into the reproducible research workflow.
In addition to this introduction, the package contains three additional vignettes covering:
They can be accessed from CRAN or from within R using vignettes(package = "dataverse")
.
The dataverse client package can be installed from CRAN, and you can find the latest development version and report any issues on GitHub:
if (!require("remotes")) {
install.packages("remotes")
}
remotes::install_github("iqss/dataverse-client-r")
library("dataverse")
(Note: dataverse is the next-generation iteration of the dvn package, which works with Dataverse 3 (“Dataverse Network”) applications. See the appendix of this vignette for a cross-walk of functionality between dvn and dataverse.)
Dataverse has some terminology that is worth quickly reviewing before showing how to work with Dataverse in R. Dataverse is an application that can be installed in many places. As a result, dataverse can work with any installation but you need to specify which installation you want to work with. This can be set by default with an environment variable, DATAVERSE_SERVER
:
library("dataverse")
Sys.setenv("DATAVERSE_SERVER" = "dataverse.harvard.edu")
This should be the Dataverse server, without the “https” prefix or the “/api” URL path, etc. The package attempts to compensate for any malformed values, though.
Within a given Dataverse installation, organizations or individuals can create objects that are also called “Dataverses”. These Dataverses can then contain other dataverses, which can contain other dataverses, and so on. They can also contain datasets which in turn contain files. You can think of Harvard’s Dataverse as a top-level installation, where an institution might have a dataverse that contains a subsidiary dataverse for each researcher at the organization, who in turn publishes all files relevant to a given study as a dataset.
You can search for and retrieve data without a Dataverse account for that a specific Dataverse installation. For example, to search for data files or datasets that mention “ecological inference”, we can just do:
dataverse_search("ecological inference")[c("name", "type", "description")]
The search vignette describes this functionality in more detail. To retrieve a data file, we need to investigate the dataset being returned and look at what files it contains using a variety of functions, the last of which - get_file()
- can retrieve the files as raw vectors:
For “native” Dataverse features (such as user account controls) or to create and publish a dataset, you will need an API key linked to a Dataverse installation account. Instructions for obtaining an account and setting up an API key are available in the Dataverse User Guide. (Note: if your key is compromised, it can be regenerated to preserve security.) Once you have an API key, this should be stored as an environment variable called DATAVERSE_KEY
. It can be set within R using:
Sys.setenv("DATAVERSE_KEY" = "examplekey12345")
With that set, you can easily create a new dataverse, create a dataset within that dataverse, push files to the dataset, and release it:
# create a dataverse
dat <- create_dataverse("mydataverse")
# create a list of metadata
metadat <- list(title = "My Study",
creator = "Doe, John",
description = "An example study")
# create the dataset
dat <- initiate_dataset("mydataverse", body = metadat)
# add files to dataset
tmp <- tempfile()
write.csv(iris, file = tmp)
f <- add_file(dat, file = tmp)
# publish new dataset
publish_dataset(dat)
Your data are now publicly accessible.
The original Dataverse client for R was called dvn; it worked with Dataverse versions <= 3 and was removed from CRAN in favor of dataverse in 2018. dvn provided functionality for searching, retrieving, and depositing data. Here is a cross-walk of functionality in case you were already familiar with the dvn package:
| API Category | dataverse functions | dvn functions |
|---|---|---|
| Data Search | dataverse_search() |
dvSearch() |
| Data Retrieval | get_file_metadata() |
dvMetadata() |
get_file() |
||
| Data Deposit | create_dataverse() |
|
initiate_dataset() |
dvCreateStudy() |
|
update_dataset() |
dvEditStudy() |
|
add_file() |
addFile() |
|
delete_file() |
dvDeleteFile() |
|
publish_sword_dataset() |
dvReleaseStudy() |
|
delete_sword_dataset() |
||
service_document() |
dvServiceDoc() |
|
dataset_statement() |
dvStudyStatement() |
|
list_datasets() |
dvUserStudies() |


---
title: "Teaching"
layout: archive
excerpt: "Introduction to Fereshteh's teaching"
sitemap: false
permalink: /teaching/
author_profile: true
---
{% include base_path %}
I believe in providing an interactive classroom experience, in which students are fully engaged and
are encouraged to participate and ask questions. I strive to teach students to think critically,
work independently, and to take ownership of their projects.
I have had the chance to develop and practice my teaching philosophy through several teaching and teaching assistant positions
but here, I list the most significant experiences:
MIDS w209 - Information Visualization and Communication - Winter 2018
Scheduled to teach the course at UC Berkeley's Information School in the upcoming semester.
COMP 1020 - Introductory Computer Science 2 - Winter 2016
As a sessional instructor/lecturer at the CS department of University of Manitoba, I taught and gave lectures on
topics related to advanced JAVA programming.
In addition to handling large classes of about 80 students, I worked to improve the course by updating
the curriculum and improving the lecture slides and by re-writing student assignment instructions to clarify areas
that posed misunderstandings.
COMP 3020 - Human-Computer Interaction 1 - Fall 2015
As a teaching assistant/marker at the CS department of University of Manitoba, I helped the course instructors through
various tasks including answering student questions, invigilating exams, and marking projects and assignments.
ACS-3909 - ADVANCED INTERNET PROGRAMMING - Winter 2010
I was invited back in the following term (winter 2010) to teach advance internet programming course at the University of Winnipeg's
Applied Computer Science department. This course provided students with a thorough knowledge of server-side web programming. Topics included
n-tiered systems, session tracking, interfaces and stereotypes, dynamic web page design, database connections, and XML processing.
Students gained considerable knowledge and experience by learning important features needed for e-commerce, applying advanced
web application techniques, and utilizing web databases.
ACS-2909 - INTERNET PROGRAMMING - Fall 2009
I was hired as a sessional instructor/lecturer at the University of Winnipeg's Applied Computer Science department to teach introductory
internet programming concepts in fall 2009.
This course provided students with an overview of Internet and Web programming, development tools, resources, utilities, multimedia,
and security issues. Students gained hands-on experience in Javascript, Rich Internet Applications (RIAs), Web services, Design Patterns
and Mobile Application Development.
{% include paginator.html %}


Get weekly updates revealing your latest impacts.
Your research is making impacts all the time. And with Impactstory Premium, you're getting the latest news on those impacts—everything from citations to downloads to tweets and more—delivered straight to your inbox.
By extending your free trial today, you won't miss a single notification—and you'll be helping to keep Impactstory a sustainable, open-source nonprofit. And all for less than than the cost of a latte every month.
But you should. Because your research is making impacts all the time. And with Impactstory Premium, you'll get the latest news on your most exciting impacts—everything from citations to downloads to tweets and more—delivered straight to your inbox.
Plus you get to help keep Impactstory a sustainable, open-source nonprofit…all for less than than the cost of a latte every month.


CP/M for OS X is a reimplementation of CP/M-80 for OS X, allowing CP/M transient programs (ie, applications) to run on modern computers.
CP/M for OS X does not attempt to reimplement the command control processor and does not provide any other sort of command-line interface.
To launch a CP/M program, locate its .COM in the Finder and double click.
When it launches an application, CP/M for OS X will create a virtual A: drive that maps to that application's directory. The application will then be launched from the A: drive.
To give the application access to a file outside of its own directory, drag and drop the file onto the application's window. CP/M for OS X will ensure that it has a virtual drive mapped for that file's folder and then type the drive letter and filename into the virtual machine.


Would love to just go over with my mouse on his gravatar to see main stats.
Left Side
Top 5 Weapons
Right Side:
SPM,W/L,K/DR, *
* every BBLOG user can define one stat to show.
Thx for BBLOG already. It made a lot of things easier for me and plenty of other people.
José Ortega
Global Moderator
It would be nice to see such a feature, but i think it will take a lot of bandwith from the servers...
Post edited 1 x times, last by
BrainFooLong
Administrator
BrainFooLong
Administrator
This feature requires too much requests to the battlelog server. Sry, rejected.
ORFK
Global Moderator
otherwise we shouldn't forget that a player can have more than one Player Account linked to a Battlelog / Origin Account. So if we have a player with two or more accounts, which should be displayed?
thats a reason too why its not a good idea to release this feature.
maybe a plugin developer will create a plugin like this, but i don't think so. sorry :-/


| scancode = the scancode for the key to test |
| This command returns the number of times a specified key has been hit since the last time you called the KeyHit() command.  ; Wait 5 seconds While MilliSecs() < current+5000 Wend ; Print the results Print "Pressed ESC " + KeyHit(1) + " times." |


Get in touch 💻
I help small and medium-sized businesses grow by delivering high-quality websites built with WordPress or Webflow. From design to development, I help my clients to get the stunning website they deserve.
How can I contribute to your project?
- I can design mockups for responsive websites.
- I can implement mockups into functional websites built with WordPress or Webflow.
- I can take care of on-going projects.
- I can edit photos, videos, and create digital content.
For more detailed information, visit my studio 👈
Address: 10 Colinton Rd, Edinburgh, EH10 5DT
Contact<EMAIL_ADDRESS>+44 7551 891614(uk) +33 6 34 60 48 28(fr)
Socials: Instagram LinkedIn Twitter
Other: Behance Peopleperhour


Project goals
Software support for writing requirements and specifications documents
There shall exist free and lightweight yet capable software for writing requirements and specifications documents
The state of the art for many small companies working with requirements: using Excel for requirements management in the projects with hundreds or thousands of requirements.
-
Requirements management
StrictDoc shall enable requirements management.
-
Modeling capability
StrictDoc's Data Model shall accommodate for maximum possible standard requirement document formats.
Examples of standard requirements documents include but are not limited to:
- Non-nested requirement lists split by categories (e.g., Functional Requirements, Interface Requirements, Performance Requirements, etc.)
-
Primary text implementation
SDOC format shall support encoding the Strict Doc Data Model in a plain-text human readable form.
-
Reduce documentation hazards
There shall exist no (or less) opportunity for writing incorrect or inconsistent documentation.
Every serious engineering activity, such as safety engineering or systems engineering, starts with requirements. The more critical is a product the higher the importance of good documentation.
Technical documentation can be and often becomes a source of hazards. It is recognized that many failures stem from inadequate requirements engineering. While it is not possible to fix the problem of inadequate requirements engineering in general, it is definitely possible to improve software that supports engineers in activities such as requirements engineering and writing technical documentation.
No (or less) run-away documentation
Software shall support engineers in keeping documentation up-to-date.
Technical documentation easily becomes outdated. Many existing tools for documentation do not provide any measures for ensuring overall consistency of documents and documentation trees.
Change management
Software shall provide capabilities for change management and impact assessment.
Change management is difficult. The bigger the project is, the harder it is to maintain its documentation. If a change is introduced to a project, it usually requires a full revision of its requirements.
When the basic capabilities of StrictDoc are in place, it should be possible to do a more advanced analysis of requirements and requirement trees:
- Finding similar or relevant requirements.
- Enforce invariants that should be hold. Example: mass or power budget.
-
Fuzzy requirements search
StrictDoc shall support finding relevant requirements.
This feature can be implemented in the CLI as well as in the future GUI. A fuzzy requirements search can help to find existing requirements and also identify relevant requirements when creating new requirements.
High-level requirements
-
Software support for writing requirements and specifications documents
There shall exist free and lightweight yet capable software for writing requirements and specifications documents
Technical documentation is hard, it can be an extremely laborious process. Software shall support engineers in their work with documentation.
The state of the art for many small companies working with requirements: using Excel for requirements management in the projects with hundreds or thousands of requirements.
Requirements management
StrictDoc shall enable requirements management.
-
Modeling capability
StrictDoc's Data Model shall accommodate for maximum possible standard requirement document formats.
Examples of standard requirements documents include but are not limited to:
- Non-nested requirement lists split by categories (e.g., Functional Requirements, Interface Requirements, Performance Requirements, etc.)
-
Primary text implementation
SDOC format shall support encoding the Strict Doc Data Model in a plain-text human readable form.
Data model
StrictDoc shall be based on a well-defined data model.
StrictDoc is a result of several attempts to find a solution for working with text-based requirements:
- StrictDoc, first generation: Markdown-based C++ program. Custom requirements metadata in YAML.
- StrictDoc, second generation: RST/Sphinx-based Python program. Using Sphinx extensions to manage meta information.
The result of these efforts was the realization that a text-based requirements and specifications management tool could be built on top of a domain-specific language (DSL) created specifically for the purpose of writing requirements and specifications documents. Such a language allows an explicit definition of a document data model which is called "grammar".
-
Modeling capability
StrictDoc's Data Model shall accommodate for maximum possible standard requirement document formats.
Examples of standard requirements documents include but are not limited to:
- Non-nested requirement lists split by categories (e.g., Functional Requirements, Interface Requirements, Performance Requirements, etc.)
-
Primary text implementation
SDOC format shall support encoding the Strict Doc Data Model in a plain-text human readable form.
-
Grammar
SDOC format shall be based on a fixed grammar.
Command-line interface
StrictDoc shall provide a command-line interface.
Platform support
StrictDoc shall work on all major platforms.
macOS support
StrictDoc shall work on macOS systems.
Linux support
StrictDoc shall work on Linux systems.
Windows support
StrictDoc shall work on Windows systems.
Requirements validation
StrictDoc shall allow validation of requirement documents.
-
Uniqueness of UID identifiers in a document tree
StrictDoc shall ensure that each UID used in a document tree is unique.
This is implemented but the error message shall be made more readable.
-
No cycles in a document tree
StrictDoc shall ensure that no requirements in document tree reference each other.
-
Valid HTML markup
StrictDoc's HTML export tests shall validate the generated HTML markup.
First candidate: Table of contents and its nested <ul>/<li> items.
Requirements text format
StrictDoc shall allow storage of requirements in a plain-text human readable form.
Linking requirements
StrictDoc shall support linking requirements to each other.
Scalability
StrictDoc shall allow working with large documents and document trees containing at least 10000 requirement items.
Traceability
StrictDoc shall support traceability of requirements.
Visualization
StrictDoc shall provide means for visualization of requirement documents.
Open source software
StrictDoc shall always be free and open source software.
Implementation requirements
Parallelization
StrictDoc shall enable parallelization of the time-consuming parts of the code.
Incremental generation
StrictDoc shall enable incremental generation of the documents.
When exporting documentation tree, StrictDoc shall regenerate only changed documents and files.
Data model
-
Requirements management
StrictDoc shall enable requirements management.
-
Software support for writing requirements and specifications documents
There shall exist free and lightweight yet capable software for writing requirements and specifications documents
Technical documentation is hard, it can be an extremely laborious process. Software shall support engineers in their work with documentation.
The state of the art for many small companies working with requirements: using Excel for requirements management in the projects with hundreds or thousands of requirements.
-
-
Data model
StrictDoc shall be based on a well-defined data model.
StrictDoc is a result of several attempts to find a solution for working with text-based requirements:
- StrictDoc, first generation: Markdown-based C++ program. Custom requirements metadata in YAML.
- StrictDoc, second generation: RST/Sphinx-based Python program. Using Sphinx extensions to manage meta information.
The result of these efforts was the realization that a text-based requirements and specifications management tool could be built on top of a domain-specific language (DSL) created specifically for the purpose of writing requirements and specifications documents. Such a language allows an explicit definition of a document data model which is called "grammar".
Modeling capability
StrictDoc's Data Model shall accommodate for maximum possible standard requirement document formats.
Examples of standard requirements documents include but are not limited to:
- Non-nested requirement lists split by categories (e.g., Functional Requirements, Interface Requirements, Performance Requirements, etc.)
-
Primary text implementation
SDOC format shall support encoding the Strict Doc Data Model in a plain-text human readable form.
Project
StrictDoc shall support the "Project" concept as a top-level entity that serves for grouping of SDoc documents into a single project documentation tree.
Project title
Project shall have a "Title" property.
Currently, the project title aspect is not part of the SDoc grammar. It is simply specified via the --project-title command-line option. This might change when the project title will be configured as part of the project-level config file (TOML or SDoc-like grammar).
Requirement item
Statement
Requirement item shall have a statement.
Content body
Requirement item might have an content body.
UID identifier
Requirement item might have an UID identifier.
UID identifier format
StrictDoc shall not impose any restrictions on the UID field format.
Conventions used for requirement UIDs can be very different. And there seems to be no way to define a single rule.
Some examples:
- FUN-003
- cES1008, cTBL6000.1 (NASA cFS)
- Requirements without a number, e.g. SDOC-HIGH-DATA-MODEL (StrictDoc)
- SAVOIR.OBC.PM.80 (SAVOIR)
Title
Requirement item might have an title.
References
Requirement item might have one or more references.
Comments
Requirement item might have one or more comments.
Special fields
StrictDoc shall support customization of the default Requirement's grammar with special fields.
Examples:
- RAIT compliance fields (Review of design, analysis, inspection, testing)
- Automotive Safety Integrity Level level (ASIL).
Links
StrictDoc's data model shall support linking document content nodes to each other.
Parent links
StrictDoc's data model shall support linking a requirement to another requirement using PARENT link.
SDOC file format
-
Modeling capability
StrictDoc's Data Model shall accommodate for maximum possible standard requirement document formats.
Examples of standard requirements documents include but are not limited to:
- Non-nested requirement lists split by categories (e.g., Functional Requirements, Interface Requirements, Performance Requirements, etc.)
-
Requirements management
StrictDoc shall enable requirements management.
-
Software support for writing requirements and specifications documents
There shall exist free and lightweight yet capable software for writing requirements and specifications documents
Technical documentation is hard, it can be an extremely laborious process. Software shall support engineers in their work with documentation.
The state of the art for many small companies working with requirements: using Excel for requirements management in the projects with hundreds or thousands of requirements.
-
-
Data model
StrictDoc shall be based on a well-defined data model.
StrictDoc is a result of several attempts to find a solution for working with text-based requirements:
- StrictDoc, first generation: Markdown-based C++ program. Custom requirements metadata in YAML.
- StrictDoc, second generation: RST/Sphinx-based Python program. Using Sphinx extensions to manage meta information.
The result of these efforts was the realization that a text-based requirements and specifications management tool could be built on top of a domain-specific language (DSL) created specifically for the purpose of writing requirements and specifications documents. Such a language allows an explicit definition of a document data model which is called "grammar".
Primary text implementation
SDOC format shall support encoding the Strict Doc Data Model in a plain-text human readable form.
-
Data model
StrictDoc shall be based on a well-defined data model.
StrictDoc is a result of several attempts to find a solution for working with text-based requirements:
- StrictDoc, first generation: Markdown-based C++ program. Custom requirements metadata in YAML.
- StrictDoc, second generation: RST/Sphinx-based Python program. Using Sphinx extensions to manage meta information.
The result of these efforts was the realization that a text-based requirements and specifications management tool could be built on top of a domain-specific language (DSL) created specifically for the purpose of writing requirements and specifications documents. Such a language allows an explicit definition of a document data model which is called "grammar".
Grammar
SDOC format shall be based on a fixed grammar.
No indentation
SDoc grammar's building blocks shall not allow any indentation.
Rationale: Adding indentation to any of the fields does not scale well when the documents have deeply nested section structure as well as when the size of the paragraphs becomes sufficiently large. Keeping every keyword like [REQUIREMENT] or [COMMENT] with no indentation ensures that one does not have to think about possible indentation issues.
Type safety
SDOC format shall allow type-safe encoding of requirement documents.
Document Generators
General
Generated file names
StrictDoc shall preserve original document file names when generating to all export formats.
HTML Export
Single document: Normal form
StrictDoc shall export single document pages in a normal document-like form.
Single document: Tabular form
StrictDoc shall export single document pages in a tabular form.
Single document: 1-level traceability
StrictDoc shall export 1-level traceability document.
Single document: Deep traceability
StrictDoc shall export deep traceability document.
Left panel: Table of contents
StrictDoc shall export all HTML pages with Table of Contents.
PDF Export
Sphinx documentation generator
StrictDoc shall support exporting documents to Sphinx/RST format.
Excel Export
StrictDoc shall support exporting documents to Excel format.
Validation
-
Requirements validation
StrictDoc shall allow validation of requirement documents.
Uniqueness of UID identifiers in a document tree
StrictDoc shall ensure that each UID used in a document tree is unique.
This is implemented but the error message shall be made more readable.
-
Requirements validation
StrictDoc shall allow validation of requirement documents.
No cycles in a document tree
StrictDoc shall ensure that no requirements in document tree reference each other.
-
Requirements validation
StrictDoc shall allow validation of requirement documents.
Valid HTML markup
StrictDoc's HTML export tests shall validate the generated HTML markup.
First candidate: Table of contents and its nested <ul>/<li> items.
Design decisions
Building blocks
TextX
TextX shall be used for StrictDoc grammar definition and parsing of the sdoc files.
TextX is an easy-to-install Python tool. It is fast, works out of the box.
Jinja2
Jinja2 shall be used for rendering HTML templates.
Sphinx and Docutils
Sphinx and Docutils shall be used for the following capabilities:
- Support of Restructured Text (reST) format
- Generation of RST documents into HTML
- Generation of RST documents into PDF using LaTeX
- Generating documentation websites using Sphinx
Backlog
Note: The items below are weakly sorted from top to bottom. The topmost items are either work-in-progress or will be implemented next.
Work in progress
Traceability and coverage
Linking with implementation artifacts
StrictDoc shall support linking requirements to files.
Validation: Broken links from requirements to source files
StrictDoc shall warn a user about all requirements whose links reference source files that do not exist.
Validation: Broken links from source files to requirements
StrictDoc shall warn a user about all source files whose links reference requirements that do not exist.
Requirements coverage
StrictDoc shall generate requirements coverage information.
Requirements coverage screen shows how requirements are linked with source files.
Source coverage
StrictDoc shall generate source coverage information.
Source coverage screen shows how source files are linked with requirements.
Project-level configuration file
StrictDoc shall support reading project configuration from a file.
- TOML format looks like a good option.
- Project title.
- Project prefix?
- Explicit or wildcard paths to sdoc files.
- Paths to dirs with source files.
- Config options for presenting requirements.
- Include/exclude requirements in TOC
Export and import capabilities
ReqIF import/export
StrictDoc shall support ReqIF format.
CSV import/export
StrictDoc shall support exporting documents to CSV format.
PlantUML export
StrictDoc shall support exporting documents to PlantUML format.
Confluence import/export
StrictDoc shall support importing/exporting documents from/to Confluence HTML storage format.
Tex export
StrictDoc shall support exporting documents to Tex format.
Doorstop import/export
StrictDoc shall support import and exporting documents from/to Doorstop format.
Markdown support for text and code blocks
StrictDoc shall support rendering text/code blocks into Markdown syntax.
StrictDoc as library
StrictDoc shall support it use as a Python library.
Such a use allows a more fine-grained access to the StrictDoc's modules, such as Grammar, Import, Export classes, etc.
-
Change management
Software shall provide capabilities for change management and impact assessment.
Change management is difficult. The bigger the project is, the harder it is to maintain its documentation. If a change is introduced to a project, it usually requires a full revision of its requirements.
When the basic capabilities of StrictDoc are in place, it should be possible to do a more advanced analysis of requirements and requirement trees:
- Finding similar or relevant requirements.
- Enforce invariants that should be hold. Example: mass or power budget.
Fuzzy requirements search
StrictDoc shall support finding relevant requirements.
This feature can be implemented in the CLI as well as in the future GUI. A fuzzy requirements search can help to find existing requirements and also identify relevant requirements when creating new requirements.
Filtering by tags
StrictDoc shall support filtering filtering by tags.
Advanced
Requirement checksumming
StrictDoc shall support calculation of checksums for requirements.
This feature is relatively easy to implement but the implementation is postponed until the linking between requirements and files is implemented.
Graphical User Interface (GUI)
StrictDoc shall provide a Graphical User Interface (GUI).
Several trade-offs to consider:
- Desktop vs Web. Rather web-based, i.e. Python backend and JS frontend, but which technology?
- Still keep the current behavior of a statically generated website?
Web server and editable HTML pages
StrictDoc shall provide a web server that serves as a StrictDoc backend for reading and writing SDoc files.
Facts table. Invariants calculation.
StrictDoc shall support creation of fact tables and allow calculation of invariants for constraints enforcement.
FMEA/FMECA tables
StrictDoc shall support creation of FMEA/FMECA safety analysis documents.
Technical documentation is hard, it can be an extremely laborious process. Software shall support engineers in their work with documentation.


{% load i18n %} {% load bootstrap_tags %}
{% trans "Each user you select will receive a message explaining that you asked for his help on this question and that you would like him to answer." %}


THE MAKER BUS
Tell your friends to join us for an awesome day of tinkering with the Maker Bus...
To:
Message:
{{ name }}
{{ message }}


13 decorations an interior designer would buy at Walmart right now
by Rachel Murphy- Insider spoke to a New York City-based interior designer to see which holiday-decor items she would buy from Walmart right now.
- One of her top seasonal picks is a pink-colored artificial tree that is 6 feet tall.
- She also suggested a few other items including a giant pre-lit wreath, gold-rimmed cocktail glasses, and blue twinkle lights.
- Visit Insider’s homepage for more stories.
‘Tis the season to decorate for the holidays – and Walmart has a lot of affordable decor options to choose from.
To help narrow down the options, Insider spoke to New York City-based interior designer Megan Hopp to find out some of the best seasonal items to pick up at Walmart.
Here are the holiday decorations an interior designer would buy at Walmart right now.
Disclaimer: Prices and availability are subject to change.
A set of silver bristle-brush trees can make your home sparkle.
Hopp said she especially recommends using these to decorate for Hanukkah, Christmas, or in homes that celebrate both holidays.
“These will look great paired together on a table or bookshelf, or distributed throughout your home,” she said.
Silver Tree Table-Top Christmas Decoration, Set of Six, $14
Deck the halls with a set of vintage-looking holiday ornaments.
Hopp told Insider that a set of vintage-inspired holiday ornaments is “as classic as they come.”
“The simple ball shape will have your tree looking extra crisp with a variety of colors and sparkle throughout,” she added.
Shiny Vintage Glass Ball Ornaments, Set of 12, $27.49
Hang your stockings with care using these gold hooks.
According to Hopp, stockings should be the focal point of a space without being too ornate or thematic. To achieve that look, she recommends these gold hooks because “they have a chic silhouette and simple elegance” about them.
Gold Stocking Holder, Set of Four, $13.99
This luxurious stocking comes in colors like green, ivory, and red.
Hopp said she loves decorating with stockings for the holidays, but she particularly likes these quilted velvet ones because of their “striking richness and texture” and luxurious-looking fabric.
Hand Quilted Velvet Stocking, $26.61
You can go big with this 4-foot wreath that comes with built-in lights.
When it comes to holiday wreaths, Hopp said you should go big or go home.
“In the case of a wreath, bigger is better,” she told Insider. “An oversized wreath above your fireplace or dining table will create an instant showstopper focal point in the room, and take your holiday home decor to the next level.”
48-inch Wreath with LED lights, $303.99
This set of cocktail glasses will add glitz and glam to your upcoming holiday party.
All holiday cocktails deserve a special glass since they can help visually elevate any drink, Hopp told Insider.
Her pick is these gold-rimmed or silver-rimmed glass cups that offer an “extra dose of glitz” while still having a classic style.
Better Homes & Gardens Metallic Rim Glasses, Set of Four, $14
You can spruce up your sofa with pillows that offer the right amount of holiday style without going overboard.
When it comes to home decor that is suited for the holidays, Hopp said she always tells her clients that anything too obvious (like a cushion featuring Santa Claus’ face) will leave you with more of a theme rather than an ambiance or a feeling.
She told Insider she suggests these red plaid pillows because “they have just enough holiday style while still fitting in right at home with your year-round decor.”
Better Homes & Gardens Holiday Plaid Decorative Pillow, $12.87
This simple menorah combines gold-colored candle holders and white marble.
“This menorah is luxe with its marble stone base and striking sleek silhouette,” Hopp said.
She told Insider her favorite part is the pairing of the gold and stone because it “makes for a beautiful standalone piece that’s flexible to fit with a variety of home decor schemes.”
Gold Menorah Candle Holder on Marble Base, $75.42
This small plate features a classic holiday design.
Made from fine ivory china, this plate earned top marks from Hopp because it’s a “classic nod to Christmases past with its delicate and nostalgic border.”
“These plates will look great on their own, or paired with your everyday dishes to transform them into a holiday place setting,” she said.
Lenox Holiday Butter Player, $14.99
Decorate with a pink tree instead of a green one for a whimsical twist.

Hopp told Insider that design is not just about what you see, but also what you smell – and she loves this festive-looking tin candle that has two wicks.
“Who wouldn’t want to small a candy cane? Not only a striking scent but this candle also comes in a beautiful modern jar designed to look like the candy,” she added.
Voluspa Crushed Candy Cane Candle, $36
You can celebrate with a strand of blue twinkle lights.
Hopp said one of her biggest holiday-decorating faux pas is hanging outdoor lights inside, but this blue twinkle light set is an exception to the rule.
“Traditional holiday lights can be clunky and sloppy when used on the inside,” she noted. “However, these blue twinkly lights will add a very delicate twinkle to your Hanukkah decor.”
Blue Twinkle Light Set, $16.99
This crystal-cut dessert stand will elevate your holiday treats.
Hopp told Insider this cake plate is perfect for displaying your favorite holiday treats.
“A special treat deserves a special plate, and this crystal-cut cake plate and dome is certainly that,” she said. “The intricate design and crystal material make this cake plate perfect for any holiday.”
Godinger Dublin Footed Cake Dome Plate, $81.22
Read More:


Jobs¶
Important
This module is being deprecated and will be removed in a future release. Please use the new Batch module as a replacement.
The ThreatConnect ™ TcEx Framework provides the TcExJob
module to automate writing certain data types to the ThreatConnect API. The App developer can dynamically build a JSON data object and the Job module will handle writing the data to the ThreatConnect API.
Once all the data has been added to the job a call to the process()
method will attempt to write the data to the ThreatConnect API.
Note
Any failures will set the exit_code()
to 3 or partial failure, unless the error is defined as a critical failure (defined in the __init__ method of TcExJob()
.
Groups¶
The group()
method accepts the following data structure. All required fields are highlighted.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | {
"attribute": [
{
"type": "Description",
"value": "Test Description"
}
],
"name": "Robin Sparkles",
"tag": [
{
"name": "APT"
},{
"name": "CrimeWare"
}
],
"type": "Adversary"
}
|
Note
The Jobs module will make multiple API calls to push all this data to the ThreatConnect API.
The module provides the group_results
property to get the status of each Group submitted.
1 2 3 4 5 6 7 8 9 10 11 | {
"cached": [],
"failed": [],
"not_saved": [],
"saved": [
"Robin Sparkles",
],
"submitted": [
"Robin Sparkles",
]
}
|
- Cached - The Group already existed in ThreatConnect and was pulled from cache.
- Failed - The Group add encountered an error when submitting to the API.
- Not Saved - The Group was not saved either due to a failure or “Halt on Error” was selected and a previous Group failed.
- Saved - The Group was saved to ThreatConnect via the API.
- Submitted - The complete list of submitted Group Names.
Documents¶
To create a document, use the same structure described above and add fileName
and fileData
fields. For example, the following JSON will create a document named test.txt
with the content This is just a test
:
1 2 3 4 5 6 7 8 9 10 11 12 | {
"attribute": [
{
"type": "Description",
"value": "Test Description"
}
],
"fileData": "This is just a test",
"fileName": "test.txt",
"name": "Test Document",
"type": "Document"
}
|
Group to Indicator Associations¶
The group_association()
method accepts the following data structure. All required fields are highlighted.
1 2 3 4 5 6 | {
"group_name": "Robin Sparkles",
"group_type": "Adversary",
"indicator": "<IP_ADDRESS>",
"indicator_type": "Address"
}
|
Warning
If more than one Group exist with the same name, the association created using
group_association()
will only associate the indicator
to the first group found with the name.
Group to Group Associations¶
The association()
method accepts the following data structure to create an association between two groups. All required fields are highlighted.
1 2 3 4 5 6 | {
"association_value": "Incident 1",
"association_type": "Incident",
"resource_value": "Pierre Despereaux",
"resource_type": "Adversary",
}
|
Warning
If more than one Group exist with the same name, the association created using
association()
will only associate the indicator
to the first group found with the name.
Indicators¶
The indicator()
method accepts the following data structure. All required fields are highlighted.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | {
"associatedGroup": [
"1",
"8"
],
"attribute": [
{
"type": "Description",
"value": "Test Description"
}
],
"confidence": 5,
"rating": "3",
"summary": "<IP_ADDRESS>",
"tag": [
{
"name": "APT"
},{
"name": "CrimeWare"
}
],
"type": "Address"
}
|
Note
To create file indicators using the tcex.tcex_job.indicator()
function, the summary
should be a string with each file hash (md5, sha1, and/or sha256) separated by <space>:<space>
. For example, the following json would create a file indicator with the md5 hash 905ad8176a569a36421bf54c04ba7f95
, sha1 hash a52b6986d68cdfac53aa740566cbeade4452124e
and sha256 hash 25bdabd23e349f5e5ea7890795b06d15d842bde1d43135c361e755f748ca05d0
:
{
"summary": "905ad8176a569a36421bf54c04ba7f95 : a52b6986d68cdfac53aa740566cbeade4452124e : 25bdabd23e349f5e5ea7890795b06d15d842bde1d43135c361e755f748ca05d0",
"type": "File"
}
The module provides the indicator_results
property to get the status of each Indicator submitted.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | {
"failed": [
"905ad8176a569a36421bf54c04ba7f95 : a52b6986d68cdfac53aa740566cbeade4452124e : 25bdabd23e349f5e5ea7890795b06d15d842bde1d43135c361e755f748ca05d0"
],
"not_saved": [
"905ad8176a569a36421bf54c04ba7f95 : a52b6986d68cdfac53aa740566cbeade4452124e : 25bdabd23e349f5e5ea7890795b06d15d842bde1d43135c361e755f748ca05d0"
],
"saved": [
"<IP_ADDRESS>",
"<IP_ADDRESS>",
"https://www.moonmoon.com/whotripme",
"HKEY_LOCAL_MACHINE : my-registry-key : REG_DWORD"
],
"submitted": [
"<IP_ADDRESS>",
"<IP_ADDRESS>",
"https://www.moonmoon.com/whotripme",
"905ad8176a569a36421bf54c04ba7f95 : a52b6986d68cdfac53aa740566cbeade4452124e : 25bdabd23e349f5e5ea7890795b06d15d842bde1d43135c361e755f748ca05d0",
"HKEY_LOCAL_MACHINE : my-registry-key : REG_DWORD"
]
}
|
- Failed - The Indicator add encountered an error when submitting to the API.
- Not Saved - The Indicator was not saved either due to a failure or “Halt on Error” was selected and a previous Indicator failed.
- Saved - The Indicator was saved to ThreatConnect via the API.
- Submitted - The complete list of submitted Indicator Names.
Indicator to Indicator Associations¶
The association()
method accepts the following data structure to create custom, Indicator to Indicator Associations. All required fields are highlighted.
1 2 3 4 5 6 7 | {
"association_value": "ASN1234",
"association_type": tcex.safe_rt("ASN"),
"resource_value": "<IP_ADDRESS>",
"resource_type": "Address",
"custom_association_name": "ASN to Address"
}
|
The required custom_association_name
key provides the name of the association you would like to use. These names can be found using the associationTypes API endpoint.
Note
When create an Indicator to Indicator association that is a File Action, make sure that the ‘parent’ File Indicator is provided as the resource_value
(not the association_value
).
For example, the following code will properly create an association between a Registry Key and a File Indicator:
assoc = {
'association_type': 'Registry Key',
'association_value': 'HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Services\\6to4 : DeleteFlag : REG_NONE',
'custom_association_name': 'File Registry Key',
'resource_type': 'File',
'resource_value': 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
}
tcex.jobs.association(assoc)
While the code snippet below will not work properly (notice that the location of the ‘parent’ File Indicator and the Registry Key have been switched):
assoc = {
'association_type': 'File',
'association_value': 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
'custom_association_name': 'File Registry Key',
'resource_type': 'Registry Key',
'resource_value': 'HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Services\\6to4 : DeleteFlag : REG_NONE'
}
tcex.jobs.association(assoc)
File Occurrence¶
The file_occurrence()
method accepts the following data structure. All required fields are highlighted.
1 2 3 4 5 6 | {
"date" : "2014-11-03T00:00:00-05:00",
"fileName" : "win999301.dll",
"hash": "BE7DE2F0CF48294400C714C9E28ECD01",
"path" : "C:\\Windows\\System"
}
|
Note
The hash value is not part of the File Occurrence body and will be stripped out before the POST. It is used to indicate which File Indicator to add the occurrence.
Sample Job Flow¶
The key method calls are highlighted in the following code sample.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 | from tcex import TcEx
tcex = TcEx()
# Get TcEx parser
parser = tcex.parser
parser.add_argument('--owner', help='ThreatConnect Owner', required=True)
# Get parsed args
args = tcex.args
# add indicator
tcex.jobs.indicator({
'summary': '<IP_ADDRESS>',
'type': 'Address'
})
# add group
tcex.jobs.group({
'name': 'Robin Sparkles',
'type': 'Adversary'
})
# add associations
tcex.jobs.group_association({
'group_name': 'Robin Sparkles',
'group_type': 'Adversary',
'indicator': '<IP_ADDRESS>',
'indicator_type': 'Address
})
# process job
tcex.jobs.process(args.owner)
tcex.message_tc(
'{} group, {} indicator and {} association added.'.format(
tcex.jobs.group_len, tcex.jobs.indicator_len, tcex.jobs.group_association_len))
tcex.exit()
|
Note
The Batch API call allows for Group Associations via the associatedGroup
field using
the Group Id. However, if Groups are being added in the Job the Group Id will not be known
until after the Group is added. The group_association()
method allows the Group name to be used instead of the Group Id. If the Group Id is
already known it can be associated using the associatedGroup
field.


User stories:1) I can pass a string as a parameter, and it will check to see whether that string contains either a unix timestamp or a natural language date (example: January 1, 2016)
2) If it does, it returns both the Unix timestamp and the natural language form of that date.
3) If it does not contain a date or Unix timestamp, it returns null for those properties.
https://r282-timestamp-api.herokuapp.com/December%2015,%202015
https://r282-timestamp-api.herokuapp.com/1450137600
{ "unix":<PHONE_NUMBER>, "natural": "December 15, 2015" }
Created by Suraj B Malode | 2016


Test Box
They look nice and offer a lot of editting posibillities which I'm still learning
It's the line that separates margin from padding. It can be used to help better understand how big are your elements i.e.
col-1
col-2
col-3
col-6
Think of it this way - padding is the part between element context and border(it's really useful to use borders in order to better understand how big is what)
Padding 1
Padding 2
Padding 3
Padding 4
Padding 5
To understand example above we must assume that there is the same amount of space under text as there is above it(Current display is different because of column usage). Padding is something that once assigned is going to be there and if screen becomes too small we might start to see some anomalies.But as you can see what we are doing is increasing our element cover area. This next example will make more sense of it.
Padding works really well with buttons especially if you need to make them easier to click. And while official documents are good at trying to explain the difference between padding and margin while doing simple online searches quite often people mentioned using padding only for increasing element cover area. And buttons are the most widely used example for that.
Margin 1
Margin 2
Margin 3
Margin 4
Margin 5
Margin 1
Margin 2
Margin 3
Margin 4
Margin 5
As you can see the active region is way smaller yet they are spaced out. Another big difference is when margins are used on elements that are aligned vertically. These margins then start to overlap.
I find that you can do a lot with margins, especially because they accept negative values as well. This is one of the reasons why I find official documentation of them a bit short. There is so much more to do with them and I still have a lot if exploring to do


{% extends "layout.html" %} {% block title %}API{% endblock %} {% block breadcrumb %}
It is possible to query the Stacks project yourself through an API. This way you don"t have to scrape the information from the HTML pages and it is consistent with our goal that the content of the Stacks project be as open as possible.
We can think of several applications:
If you intend to use this API, please contact us at<EMAIL_ADDRESS>This interface is not stable, please get in touch to discuss this with us.
The current API has less features than the previous one. If this causes problems, please get in touch. We intend to improve it over time.
To get the structure of the Stacks project, one can ask for a JSON file at
https://stacks.math.columbia.edu/data/tag/‹tag›/structure
example: 0ELT
For now you need to treat the 9 different parts in the Stacks project separately.
There are two different possibilities to get the statement of a tag:
https://stacks.math.columbia.edu/data/tag/‹tag›/content/statement
example: HTML statement for tag 015I
https://stacks.math.columbia.edu/data/tag/‹tag›/content/full
Because the mathematics is parsed by MathJax, the HTML output contains raw LaTeX math. It is up to the user to handle this (e.g. either use MathJax, or some image generation tool).
Previously it was also possible to get the TeX code of a tag. This is not possible at the moment, but if necessary we can implement this again. {% endblock %} {% block sidebar %} {{ macros.singlePageLinks() }} {% endblock %}


Shelter location and contact finder
Your friends are waiting for you!
Guide to Caring for your Dogs
Home
(current)
Find
Learn
Adopt
THEY ARE THERE
Find a shelter to adopt your dogs
Zipcode
Search


|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object domosaics.ui.ViewHandler
public class ViewHandler
Class ViewManager manages the creation, adding and removing of view
objects to Angstd and its main frame. The adding to the workspace
view is delegated to the WorkspaceManager
.
The class follows the singleton pattern, which means only one instance is
created during the applications lifetime. To get an instance of ViewManager,
use the static getInstance()
method.
To add a view to the main frame its necessary to call in a first step
the createView(ViewType, String)
method where a new View object is
created using the AngstdViewFactory
.
After the object is created it has to be added by calling
addView(View, ProjectElement)
. Now for everything is taken care
of (meaning e.g. the view is added to the workspace automatically as well).
Because Tools like the DomainDotplot or the DomainLegend are views as well (the difference is they are stored in an extra frame and not within the workspace) This class also manages the tool handling.
| Method Summary | ||
|---|---|---|
void |
addView(View view,
ProjectElement project)
Adds a view to the AngstdDesktop and to the workspace. |
|
int |
countViews()
Counts the number of created views (not Tools) stored in the workspace. |
|
|
createView(ViewType type,
java.lang.String name)
Uses the AngstdViewFactory to create a new view object of the
specified type. |
|
void |
disableActiveView()
Removes the active view from the domosaics desktop. |
|
void |
enableView(int viewID)
enables a view which means that it gets displayed within the mainframe. |
|
|
getActiveView()
Return the actually displayed View |
|
static ViewHandler |
getInstance()
Returns the current ViewManager instance. |
|
|
getView(ViewInfo viewInfo)
Returns the queried view based on its unique id stored within the view info. |
|
void |
removeView(ViewInfo info)
Completely eliminates a view from Angstd. |
| Methods inherited from class java.lang.Object |
|---|
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Method Detail |
|---|
public static ViewHandler getInstance()
public <V extends View> V createView(ViewType type, java.lang.String name)
AngstdViewFactory
to create a new view object of the
specified type. This method does not automatically add the created
object to the AngstdDesktop. To do that its necessary to invoke
addView() with the created view object.
V
- the generic view type (e.g. DomainViewI)type
- the type of the view to be created (e.g. ViewType.DOMAINS)name
- the name for the view displayed in the workspace
public void addView(View view, ProjectElement project)
AngstdDesktop
and to the workspace. The
view is stored in the view mapping using its ID. Therefore this id
must be unique (associated automatically when using the
AngstdViewFactory
.
view
- The view to be addedproject
- The project to which the view should be added (allowed to be null)public void removeView(ViewInfo info)
info
- the view to removepublic void enableView(int viewID)
viewID
- the viewID of the view which is about to be displayedpublic void disableActiveView()
public <V extends View> V getView(ViewInfo viewInfo)
V
- the generic view type (e.g. DomainViewI)viewInfo
- the view info of the requested view
public int countViews()
public <V extends View> V getActiveView()
V
- the generic view type (e.g. DomainViewI)
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


devghat
I had a great day at river bank.
Sharing Memories within mself
I had a great day at river bank.
water.... its too cold.
in Devghat.
I had a great day.
I had a great day.
I had a great day.
unforgotabble memories.
unforgotabble memories.
unforgotabble memories.
It was infact a great trip.
It was infact a great trip.


I combine three years in the animation industry with nine years of commercial experience in HTML, CSS, and JavaScript to build engaging, optimized, and accessible web experiences.
By day I serve as a Senior Front-End Engineer on Target Digital Web. By night and weekend, I mentor college students at the University of Minnesota - Twin Cities as a covocational college minister.
I also volunteered to mentor youth students in SF Bay Area for six years. As an avid photographer, videographer and editor, I loved capturing highlights of our annual summer missions to rural Cambodia and Mexico.
A timeline page in honor of Kevin Garnett's hall of fame enshrinement developed in Svelte and styled with Tailwind CSS.
In partnership with Timberwolves creative and marketing, I designed and developed a page featuring Anthony Edwards' rookie year highlights to promote his candidacy for 2020-21 NBA Rookie of the Year. This page was build with Svelte and Tailwind CSS.
This web experience was built to promote the highly anticipated jersey unveil for the Minnesota Lynx 2021 season. I received high fidelity web assets from the creative team, then designed and developed the experience in Webflow. The production version was deployed in the Lynx Wordpress CMS.
I had the privilege of creating the promotional page for the Minnesota Timberwolves 2020-21 season City Edition jersey unveil. I designed and developed this experience in Webflow. The production version was deployed in Drupal CMS.
A web video player app built utilizing YouTube Data and Embed APIs. I designed & developed the reusable UI components in React, and styled the UI with Sass. The production version was deployed in the Timberwolves Drupal CMS.
Following a design prototype, I built a responsive, shoppable mini site utilizing lazy loading.
Designer: Lawrence Guzman
A landing page I built utilizing Dixon and Moe's Rellax vanilla JS parallax library, launched at start of summer.
Designer: Grace Jang
To build out this mockup, I included motion video using Vimeo developer API, and shoppable UI elements with dynamic product pull API to allow customers a direct path to the product buyflow experience.
Designer: Alexander Abriam
• Contribute to full-stack Node.js and React universal application through pair programming and pull request reviews
• Implement design patterns in React & Next.js while contributing unit and functional tests in React Testing Library & Cypress to enhance Target's highly scalable web application
• Engaging in continuous improvement projects from API migrations to reimagining deals and top of funnel user experience
• Providing technical expertise to product and UX teams, advising best practices and highlighting risks
• Utilized RESTful APIs and modern JavaScript frameworks like React and Alpine.js to build dynamic, interactive web experiences for fans.
• Used Webflow to design and develop accessible and responsive pages for Drupal, Wordpress, and CMS-less sites.
• Guided data-driven build strategies with Marketing and Sales teams using Google Analytics.
• Implemented modern accessibility standards using the WebAIM WAVE tool for Banana Republic Online.
• Migrated the marketing content build process by rendering and styling React.js components with JSON data structures for US home and department pages.
• Applied site speed optimization standards to the US, Canada, and Factory Store websites including minifying CSS and JS, collaborating with designers to reduce image file size, replacing render-blocking jQuery scripts with vanilla JS and adding lazy-load to assets below the fold.
• Engaged in a mobile-first approach to collaborate cross-functionally with web production, design, and UX/UI, developing Gap Inc's first responsive website on Banana Republic Specialty and Factory Store websites.
• Developed interactive landing pages with functionalities including: parallax scrolling, accessible CSS3 animations, and shoppable UI elements using dynamic product pull API to allow customers a direct path to product buy flow.
• Managed A/B tests and personalization campaigns in Optimizely using Tealium badges to provide customers relevant marketing content and promotional offers.
• Collaborated with animators and film director, Rob Minkoff, to create over a dozen production-quality cycle animations for feature film "Mr. Peabody and Sherman".
• Interfaced daily with directors, Head of Character Animation, Head of VFX, and supervisors to apply verbal and written notes to cycle animations.
GPA: 3.8
GPA: 3.76


Magical Item: A merciful sword that refuses to kill its foes, but eagerly drinks in magic. Its main purpose is to absorb all magic, refusing to be sheathed if its purpose isn't met.
Summary
- +3 flutter blade (1Handed, 1d4+1d6 piercing or slashing, 19-20 Crit)
- Move action to switch between slashing and piercing damage
- Symbols on it pulse with a faint sky blue light (rad 10' bright, rad 15' shadowy)
- Merciful: Only does subdual damage
- Mage Killer: On successful hit can steal magic (see below)
- +6 vs Magic items or effects (see below)
- Cursed Item: You can't sheathe the blade without draining magic
Mage Killer
Every successful hit with this blade steals magic, choose one of the following for the blade to eat:
- Up 6 spell levels worth of spells/day
- Up to 2 uses of a Su or Sp ability
- One infinite use Su or Sp ability
- Any spell affect currently on the user
- Any effects of a magical item, disabling it for 1 hour
- If a magical item provides multiple bonuses, only one is disabled.
- e.g. +2 Keen Flaming Weapon: Only one of those 3 effects can be stolen per attack
Note that any ability that is the equivalent of a 7th level spell or higher cannot be stolen. Also Kaern's Blade cannot affect artifacts.
On a Confirmed Critical instead of doing bonus damage, the user can steal the magic instead, being able to store it in the blade for up to 1 Hour. The user can then cast/use as if he is the original source of the magic. If the original source is destroyed, the magic is lost as well.
The owner can specifically choose to target an effect or magical item, treat this as a called shot, but with a +6 Echantment bonus. However when using this the weapon does no damage at all.
Merciful
This blade refuses to kill any living being, specifically any creature termed alive, intelligent or soulled, doing only subdual damage to these creatures.
When this blade deals damage treat it as normal for the purposes of Damage Resistance. Then apply all damage as subdual damage to the creature. The blade cannot take a creature below -5 HP, refusing to damage said creatures. It can still steal magic from them however. Note that some creatures are soulled, but can't go below 0 HP in which case they are brought to at most 1 HP, and any further damage from Kaern's Blade causes them to be Disabled: unable to do any mental or physical actions until 8 hours* or they have 1 HP** worth of healing.
This ability is also affected by the owner's thoughts. Thus if an animated item was seen as a "pet" by the owner, the blade would refuse to destroy it.
Flavour Text
This ability manifests as the blade passing through opponents, and causing them to feel more and more exhausted, or . Thus the blade is still used to slash or stab, but passes through the opponents instead, seemingly turning into a pale blue ghostly blade. Against creatures immune to subdual damage, it works like normal.
Originally named after Lord Kaern, who also created the original "Kaern" (magitech items)
Description
Kaern's Blade is a True Chaotic intelligent magic item, it does not speak, or act in any way by itself, lying dormant most of the time.
The blade is a pale silver colour, with glowing sky blue symbols along the length.


These are some tools particularly useful for SE education, built by the same team behind se-education.org (i.e. sister projects).
RepoSense is a contribution analysis tool for Git repositories. It is particularly useful for those who want a chronological visualisation of the code contributions and commits made to a group of repositories. For example, educators can use RepoSense to track the progress of student projects and to examine the code written by each student.
RepoSense is available at https://reposense.org
TEAMMATES is a free online service for managing feedback paths in classes. A common (but not the only) use is for students to give peer feedback to other students.
TEAMMATES is available at https://teammatesOnline.info
MarkBind is a tool foe generating more dynamic websites from Markdown text. Optimized for creating text-heavy websites e.g., eLearning websites, online instruction manuals, project documentation etc.
Example websites generated by MarkBind are here.
MarkBind is available at https://markbind.org


Filter.AssociationRuleFilter, Filter.ItemSetFilter
| Constructor and Description |
|---|
ItemSetFilter(@Nullable Filter.ItemSetFilter parent,
@NotNull java.util.function.Predicate<ItemSet> predicate)
Creates a new filter, which applies to item sets.
|
| Modifier and Type | Method and Description |
|---|---|
@NotNull Filter.ItemSetFilter |
bySize(int minSize)
Sets the minimum size, an item set must have to be accepted by the filter.
|
@NotNull Filter.ItemSetFilter |
bySize(int minSize,
int maxSize)
Sets the minimum and maximum size, an item set must have to be accepted by the filter.
|
@NotNull Filter.ItemSetFilter |
bySupport(double minSupport)
Sets the minimum support, which must be reached by an item set to be accepted by the
filter.
|
@NotNull Filter.ItemSetFilter |
bySupport(double minSupport,
double maxSupport)
Sets the minimum and maximum support, which must be reached by an item set to be accepted
by the filter.
|
boolean |
test(@NotNull ItemSet t) |
forAssociationRules, forItemSets
public ItemSetFilter(@Nullable @Nullable Filter.ItemSetFilter parent, @NotNull @NotNull java.util.function.Predicate<ItemSet> predicate)
parent
- The parent o fhte filter as an instance of the generic type FilterType
or null, if no parent is availablepredicate
- The predicate, which should be used to test items, as an instance of the
type Predicate
. The predicate may not be null@NotNull public final @NotNull Filter.ItemSetFilter bySupport(double minSupport)
minSupport
- The minimum support, which should be set, as a Double
value.
The minimum support must be at least 0Filter.ItemSetFilter
. The filter may not be null@NotNull public final @NotNull Filter.ItemSetFilter bySupport(double minSupport, double maxSupport)
minSupport
- The minimum support, which should be set, as a Double
value.
The minimum support must be at least 0maxSupport
- The maximum support, which should be set, as a Double
value.
The maximum support must be at least the minimum support and at maximum
1Filter.ItemSetFilter
. The filter may not be null@NotNull public final @NotNull Filter.ItemSetFilter bySize(int minSize)
minSize
- The minimum size, which should be set, as an Integer
value. The
minimum size must be at least 0Filter.ItemSetFilter
. The filter may not be null@NotNull public final @NotNull Filter.ItemSetFilter bySize(int minSize, int maxSize)
minSize
- The minimum size, which should be set, as an Integer
value. The
minimum size must be at least 0maxSize
- The maximum size, which should be set, as an Integer
value. The
maximum size must be at least the minimum sizeFilter.ItemSetFilter
. The filter may not be nullpublic final boolean test(@NotNull @NotNull ItemSet t)


John Abraham Shows His SUPERBIKES For The 1st Time & It’s A Dreamy Video For Every Rider
In the video, we can see bike models like Ducati Panigale V4 and Yamaha Vmax 1700.
by Koimoi.com TeamBollywood’s love for fancy cars and bikes is well known and it’s only a few days ago that we learnt about Disha Patani purchasing a white Range Rover. Now, John Abraham has shared a video on social media featuring his 5 superbikes.
In an Instagram video, he introduces to his bike family to whom he referred as ‘My babies’. In the video, we can see bike models like Ducati Panigale V4 and Yamaha Vmax 1700.
We wish we could have such a lovely ‘family’!
On the professional front, John Abraham will be seen in Anees Bazmee’s upcoming family entertainer Pagalpanti. The movie arriving this Friday also features Anil Kapoor, Pulkit Samrat, Arshad Warsi, Saurabh Shukla, Urvashi Rautela and Kriti Kharbanda in key roles.
The movie features the recreation of Sridevi’s iconic number “Tera bimaar mera dil”. Urvashi Rautela and John Abraham are seen shaking a leg to a recreated version in Pagalpanti.
The original song featured in the 1989 hit, “Chalbaaz“, and was filmed on Sridevi and Sunny Deol.
Revealing that the number is a tribute to the late superstar Sridevi, Urvashi shared: “I was very nervous while shooting for this iconic scene. This recreation is kind of a tribute to the legendary actor from my side and I wanted to do justice to this song. People will enjoy the mood and vibe of the song and I hope they would love it.”


Spazzo is an invite-only platform that lets designers create content, and share it with other designers and potential recruiters! Go ahead, give Spazzo a try.


Portfolio
Home
Portfolio
About Me
ART 3870 Projects
CSS Animation
Bronco Billy's Redesign
Long Scrolling Page
Presentation


|
M480 BSP V3.05.005
The Board Support Package for M480 Series
|
Macros | |
| #define | DAC_START_CONV(dac) |
| Start the D/A conversion. More... | |
| #define | DAC_ENABLE_LEFT_ALIGN(dac) |
| Enable DAC data left-aligned. More... | |
| #define | DAC_ENABLE_RIGHT_ALIGN(dac) |
| Enable DAC data right-aligned. More... | |
| #define | DAC_ENABLE_BYPASS_BUFFER(dac) |
| Enable bypass voltage output buffer mode. More... | |
| #define | DAC_DISABLE_BYPASS_BUFFER(dac) |
| Disable bypass voltage output buffer mode. More... | |
| #define | DAC_ENABLE_INT(dac, u32Ch) |
| Enable the interrupt. More... | |
| #define | DAC_DISABLE_INT(dac, u32Ch) |
| Disable the interrupt. More... | |
| #define | DAC_ENABLE_DMAUDR_INT(dac) |
| Enable DMA under-run interrupt. More... | |
| #define | DAC_DISABLE_DMAUDR_INT(dac) |
| Disable DMA under-run interrupt. More... | |
| #define | DAC_ENABLE_PDMA(dac) |
| Enable PDMA mode. More... | |
| #define | DAC_DISABLE_PDMA(dac) |
| Disable PDMA mode. More... | |
| #define | DAC_WRITE_DATA(dac, u32Ch, u32Data) |
| Write data for conversion. More... | |
| #define | DAC_READ_DATA(dac, u32Ch) |
| Read DAC 12-bit holding data. More... | |
| #define | DAC_IS_BUSY(dac, u32Ch) |
| Get the busy state of DAC. More... | |
| #define | DAC_GET_INT_FLAG(dac, u32Ch) |
| Get the interrupt flag. More... | |
| #define | DAC_GET_DMAUDR_FLAG(dac) |
| Get the DMA under-run flag. More... | |
| #define | DAC_CLR_INT_FLAG(dac, u32Ch) |
| This macro clear the interrupt status bit. More... | |
| #define | DAC_CLR_DMAUDR_FLAG(dac) |
| This macro clear the DMA under-run flag. More... | |
| #define | DAC_ENABLE_GROUP_MODE(dac) |
| Enable DAC group mode. More... | |
| #define | DAC_DISABLE_GROUP_MODE(dac) |
| Disable DAC group mode. More... | |
Functions | |
| void | DAC_Open (DAC_T *dac, uint32_t u32Ch, uint32_t u32TrgSrc) |
| This function make DAC module be ready to convert. More... | |
| void | DAC_Close (DAC_T *dac, uint32_t u32Ch) |
| Disable DAC analog power. More... | |
| uint32_t | DAC_SetDelayTime (DAC_T *dac, uint32_t u32Delay) |
| Set delay time for DAC to become stable. More... | |
| #define DAC_CLR_DMAUDR_FLAG | ( | dac | ) |
| #define DAC_CLR_INT_FLAG | ( | dac, | |
| u32Ch | |||
| ) |
| #define DAC_DISABLE_BYPASS_BUFFER | ( | dac | ) |
| #define DAC_DISABLE_DMAUDR_INT | ( | dac | ) |
| #define DAC_DISABLE_GROUP_MODE | ( | dac | ) |
| #define DAC_DISABLE_INT | ( | dac, | |
| u32Ch | |||
| ) |
| #define DAC_DISABLE_PDMA | ( | dac | ) |
| #define DAC_ENABLE_BYPASS_BUFFER | ( | dac | ) |
| #define DAC_ENABLE_DMAUDR_INT | ( | dac | ) |
| #define DAC_ENABLE_GROUP_MODE | ( | dac | ) |
| #define DAC_ENABLE_INT | ( | dac, | |
| u32Ch | |||
| ) |
| #define DAC_ENABLE_LEFT_ALIGN | ( | dac | ) |
| #define DAC_ENABLE_PDMA | ( | dac | ) |
| #define DAC_ENABLE_RIGHT_ALIGN | ( | dac | ) |
| #define DAC_GET_DMAUDR_FLAG | ( | dac | ) |
| #define DAC_GET_INT_FLAG | ( | dac, | |
| u32Ch | |||
| ) |
Get the interrupt flag.
| [in] | dac | Base address of DAC module. |
| [in] | u32Ch | Not used in M480 DAC. |
| 0 | DAC is in conversion state. |
| 1 | DAC conversion finish. |
This macro is used to read FINISH bit (DAC_STATUS[0]) to get DAC conversion complete finish flag.
| #define DAC_IS_BUSY | ( | dac, | |
| u32Ch | |||
| ) |
| #define DAC_READ_DATA | ( | dac, | |
| u32Ch | |||
| ) |
| #define DAC_START_CONV | ( | dac | ) |
| #define DAC_WRITE_DATA | ( | dac, | |
| u32Ch, | |||
| u32Data | |||
| ) |
Write data for conversion.
| [in] | dac | Base address of DAC module. |
| [in] | u32Ch | Not used in M480 DAC. |
| [in] | u32Data | Decides the data for conversion, valid range are between 0~0xFFF. |
12 bit left alignment: user has to load data into DAC_DAT[15:4] bits. 12 bit right alignment: user has to load data into DAC_DAT[11:0] bits.
| void DAC_Close | ( | DAC_T * | dac, |
| uint32_t | u32Ch | ||
| ) |
| void DAC_Open | ( | DAC_T * | dac, |
| uint32_t | u32Ch, | ||
| uint32_t | u32TrgSrc | ||
| ) |
This function make DAC module be ready to convert.
| [in] | dac | Base address of DAC module. |
| [in] | u32Ch | Not used in M480 DAC. |
| [in] | u32TrgSrc | Decides the trigger source. Valid values are:
|
The DAC conversion can be started by writing DAC_DAT, software trigger or hardware trigger. When TRGEN (DAC_CTL[4]) is 0, the data conversion is started by writing DAC_DAT register. When TRGEN (DAC_CTL[4]) is 1, the data conversion is started by SWTRG (DAC_SWTRG[0]) is set to 1, external STDAC pin, timer event, or EPWM event.
| uint32_t DAC_SetDelayTime | ( | DAC_T * | dac, |
| uint32_t | u32Delay | ||
| ) |
Set delay time for DAC to become stable.
| [in] | dac | Base address of DAC module. |
| [in] | u32Delay | Decides the DAC conversion settling time, the range is from 0~(1023/PCLK1*1000000) micro seconds. |
For example, DAC controller clock speed is 160MHz and DAC conversion setting time is 1 us, SETTLET (DAC_TCTL[9:0]) value must be greater than 0xA0.


|
YT Music Uploader
Upload your music library automatically to YouTube Music.
|
Music library file and status More...
Public Member Functions | |
| MusicFile () | |
| Music library file and status More... | |
| MusicFile (string path, string hash) | |
| Music library file and status More... | |
| MusicFile (string path) | |
| Music library file and status More... | |
| async override Task< DbOperationResult > | Save () |
| Insert or update the database More... | |
| async override Task< DbOperationResult > | Delete () |
| Delete from the database (for MusicFiles, it typically set the flag of 'Removed' but doesn't actually delete from the database. This is so the file (using a checksum hash) can be compared with others to identify an already uploaded file if the files music to a different path More... | |
| async Task< DbOperationResult > | Delete (bool destroy) |
| Delete from the database. More... | |
Properties | |
| string | Path [get, set] |
| string | MbId [get, set] |
| string | ReleaseMbId [get, set] |
| string | EntityId [get, set] |
| string | VideoId [get, set] |
| string | Hash [get, set] |
| DateTime | LastUpload [get, set] |
| bool? | Error [get, set] |
| string | ErrorReason [get, set] |
| int? | UploadAttempts [get, set] |
| DateTime? | LastUploadError = null [get, set] |
| bool? | Removed = null [get, set] |
| Properties inherited from YTMusicUploader.Providers.DataModels.DbModels | |
| int | Id = -1 [get, set] |
| Properties inherited from YTMusicUploader.Providers.DataModels.IDbModel | |
| int | Id [get, set] |
Music library file and status
| YTMusicUploader.Providers.DataModels.MusicFile.MusicFile | ( | ) |
Music library file and status
| YTMusicUploader.Providers.DataModels.MusicFile.MusicFile | ( | string | path, |
| string | hash | ||
| ) |
Music library file and status
| YTMusicUploader.Providers.DataModels.MusicFile.MusicFile | ( | string | path | ) |
Music library file and status
|
virtual |
Delete from the database (for MusicFiles, it typically set the flag of 'Removed' but doesn't actually delete from the database. This is so the file (using a checksum hash) can be compared with others to identify an already uploaded file if the files music to a different path
the entry from the database
Implements YTMusicUploader.Providers.DataModels.DbModels.
| async Task<DbOperationResult> YTMusicUploader.Providers.DataModels.MusicFile.Delete | ( | bool | destroy | ) |
Delete from the database.
| destroy | False (default) just sets the flag to 'remove'. True (destroy) actually removes the entry from the database |
|
virtual |
Insert or update the database
Implements YTMusicUploader.Providers.DataModels.DbModels.
|
getset |
|
getset |
|
getset |
|
getset |
|
getset |
|
getset |
|
getset |
|
getset |
|
getset |
|
getset |
|
getset |
|
getset |


When you sign a letter, for example, everyone who recognizes your signature can confirm that you wrote the letter. Similarly when you digitally sign a file, anyone who "recognizes" your digital signature knows that the file came from you. The process of "recognizing" electronic signatures is called verification.
The ability to sign and verify files is an important part of the Java platform's security architecture. Security is controlled by the security policy that's in force at runtime. You can configure the policy to grant security privileges to applets and to applications. For example, you could grant permission to an applet to perform normally forbidden operations such as reading and writing local files or running local executable programs. If you have downloaded some code that's signed by a trusted entity, you can use that fact as a criterion in deciding which security permissions to assign to the code.
Once you (or your browser) have verified that an applet is from a trusted source, you can have the platform relax security restrictions to let the applet perform operations that would ordinarily be forbidden. A trusted applet can have freedoms as specified by the policy file in force.
The Java platform enables signing and verification by using special numbers called public and private keys. Public keys and private keys come in pairs, and they play complementary roles.
The private key is the electronic "pen" with which you can sign a file. As its name implies, your private key is known only to you so that no one else can "forge" your signature. A file signed with your private key can be verified only by the corresponding public key.
Public and private keys alone, however, aren't enough to truly verify a signature. Even if you've verified that a signed file contains a matching key pair, you still need some way to confirm that the public key actually comes from the signer that it purports to come from.
One more element, therefore, is required to make signing and verification work. That additional element is the certificate that the signer includes in a signed JAR file. A certificate is a digitally signed statement from a recognized certification authority that indicates who owns a particular public key. A certification authority are entities (typically firms specializing in digital security) that are trusted throughout the industry to sign and issue certificates for keys and their owners. In the case of signed JAR files, the certificate indicates who owns the public key contained in the JAR file.
When you sign a JAR file your public key is placed inside the archive along with an associated certificate so that it's easily available for use by anyone wanting to verify your signature.
To summarize digital signing:
Name: test/classes/ClassOne.class SHA1-Digest: TD1GZt8G11dXY2p4olSZPc5Rj64=
When a JAR file is signed, a signature file is automatically generated and placed in the JAR file's META-INF directory, the same directory that contains the archive's manifest. Signature files have filenames with an .SF extension. Here is an example of the contents of a signature file:
Signature-Version: 1.0 SHA1-Digest-Manifest: h1yS+K9T7DyHtZrtI+LxvgqaMYM= Created-By: 1.6.0 (Sun Microsystems Inc.) Name: test/classes/ClassOne.class SHA1-Digest: fcav7ShIG6i86xPepmitOVo4vWY= Name: test/classes/ClassTwo.class SHA1-Digest: xrQem9snnPhLySDiZyclMlsFdtM= Name: test/images/ImageOne.gif SHA1-Digest: kdHbE7kL9ZHLgK7akHttYV4XIa0= Name: test/images/ImageTwo.gif SHA1-Digest: mF0D5zpk68R4oaxEqoS9Q7nhm60=
As you can see, the signature file contains digest entries for the archive's files that look similar to the digest-value entries in the manifest. However, while the digest values in the manifest are computed from the files themselves, the digest values in the signature file are computed from the corresponding entries in the manifest. Signature files also contain a digest value for the entire manifest (see the SHA1-Digest-Manifest header in the above example).
When a signed JAR file is being verified, the digests of each of its files are re-computed and compared with the digests recorded in the manifest to ensure that the contents of the JAR file haven't changed since it was signed. As an additional check, digest values for the manifest file itself are re-computed and compared against the values recorded in the signature file.
You can read additional information about signature files on the Manifest Format page of the JDK™ documentation.
The signature block file contains two elements essential for verification:
Signature block filenames typically will have a .DSA extension indicating that they were created by the default Digital Signature Algorithm. Other filename extensions are possible if keys associated with some other standard algorithm are used for signing.
For more information about the Java platform's security architecture, see this related documentation:


OtteLab Turtlebot3 Documentation Download
Downloading This Documentation
If you so desire, you can download this site/documentation collection thing in a couple of formats. The
most obvious one is you can download the HMTL, CSS, and JS that make up this site, double-click on the
"index.html" file, and its off to the races. Alternatively, you can download this site as an application
from the download links below. As of now, there are no differences between the online version and the
downloadable versions since they are using the same code from the same repo.
HTML/CSS/JS Download:
Linux Downloads:
Debian package for Ubuntu and other
Debian-based distributions
All other distributions
To launch this version:
-
Open a terminal where you downloaded the .tar.gz file (right-click, Open in terminal)
-
Extract the zipped file:
$ tar xvzf turtlebotDocumentation-linux-x64.tar.gz
-
Enter the directory:
$ cd turtlebotDocumentation-linux-x64/
-
Set the file "turtlebotdocumentation" as runnable:
$ chmod +x turtlebotdocumentation
-
Then launch the file turtlebotdocumentaton:
$ ./turtlebotdocumentation


What is WebX. We are a group that uses our information infrastructure knowledge to help your business. How can we help? By providing you the communiation and information technology resources businesses in today's fast paced world need.
Businesses today need servers that can store their data. They need a phone system to take orders. Businesses today need infrastructure cabling to wire it all together. But more than that, today businesses need modern information security, switches, contact centers, and applications to pull all of their business data together.
Your time is costly, we can help. By giving us the ability to help you roll out your information technology needs you take a huge weight off of your shoulders. We run the information technology so you can run your business, lets make that promise to each other.
We are ready to create your entire information pipeline. From the front to back, we offer application designs that will keep your customers attention, to the cabling that the information will travel all the way to the servers we manage for you and finally to the contact center that you will use to stay in touch with your customers.
Phosfluorescently revolutionize viral leadership via turnkey technology. Synergistically monetize intermandated strategic theme areas through multimedia based.
Efficiently incentivize leading-edge alignments with go forward expertise. Conveniently myocardinate leveraged process improvements through progressive models.
Competently implement bricks-and-clicks collaboration and idea-sharing rather than visionary internal or "organic" sources. Rapidiously matrix premium core competencies for.
Dramatically supply adaptive imperatives and stand-alone content. Exceptional solutions after web-enabled potentialities. Synergistically negotiate alternative best practices whereas professional "outside the box" thinking.
Proactively engage orthogonal growth strategies without resource-leveling testing procedures. Seamlessly predominate interoperable growth strategies.
Proactively engage orthogonal growth strategies without resource-leveling testing procedures.
Proactively engage orthogonal growth strategies without resource-leveling testing procedures.
Proactively engage orthogonal growth strategies without resource-leveling testing procedures.
Proactively engage orthogonal growth strategies without resource-leveling testing procedures.
Proactively engage orthogonal growth strategies without resource-leveling testing procedures.
5200 SUBSCRIBERS
273 PROJECTS
640K APPRECIATIONS
132 CLIENTS
Credibly extend parallel relationships after clicks-and-mortar content. Credibly pontificate team building alignments rather than diverse quality vectors.
Credibly pontificate team building alignments rather than diverse quality vectors. Monotonectally benchmark business communities for distinctive mindshare.
Appropriately morph low-risk high-yield process improvements through progressive partnerships. Uniquely brand enabled. Globally network timely imperatives without plug-and-play schemas.


INJUSTICE 2 SOFTWARE © 2017 WARNER BRD ../LAROS. ENTERTAINMENT INC. DEVELOPED BY NETHERREALM STUDIOS.  ALL RIGHTS RESERVED. DC LOGO, AND ALL CHARACTERS, THEIR DISTINCTIVE LIKENESSES, AND RELATED ELEMENTS ARE TRADEMARKS OF DC COMICS © 2017. NETHERREALM STUDIOS LOGO, WB GAMES LOGO, WB SHIELD: ™ & © WARNER BROS. ENTERTAINMENT INC. (S17)
HELLBOY™ & © 2017 MIKE MIGNOLA. ©2018 VIACOM INTERNATIONAL INC. ALL RIGHTS RESERVED.
- DESIGNED FROM SCRATCH BY CHARLES UTHULOR
- TERMS OF USE (UPDATED)
- PRIVACY POLICY


There are multiple guides on running Kubernetes with CoreOS:
These guides are maintained by CoreOS and deploy Kubernetes the “CoreOS Way” with full TLS, the DNS add-on, and more. These guides pass Kubernetes conformance testing and we encourage you to test this yourself.
Guide to setting up a multi-node cluster on Vagrant. The deployer can independently configure the number of etcd nodes, master nodes, and worker nodes to bring up a fully HA control plane.
The quickest way to set up a Kubernetes development environment locally. As easy as git clone
, vagrant up
and configuring kubectl
.
A generic guide to setting up an HA cluster on any cloud or bare metal, with full TLS. Repeat the master or worker steps to configure more machines of that role.
These guides are maintained by community members, cover specific platforms and use cases, and experiment with different ways of configuring Kubernetes on CoreOS.
Set up a single master, multi-worker cluster on your choice of platform: AWS, GCE, or VMware Fusion.
Easy Multi-node Cluster on Google Compute Engine
Scripted installation of a single master, multi-worker cluster on GCE. Kubernetes components are managed by fleet.
Multi-node cluster using cloud-config and Weave on Vagrant
Configure a Vagrant-based cluster of 3 machines with networking provided by Weave.
Multi-node cluster using cloud-config and Vagrant
Configure a single master, multi-worker cluster locally, running on your choice of hypervisor: VirtualBox, Parallels, or VMware
Multi-node cluster with Vagrant and fleet units using a small OS X App
Guide to running a single master, multi-worker cluster controlled by an OS X menubar application. Uses Vagrant under the hood.
Resizable multi-node cluster on Azure with Weave
Guide to running an HA etcd cluster with a single master on Azure. Uses the Azure node.js CLI to resize the cluster.
Multi-node cluster using cloud-config, CoreOS and VMware ESXi
Configure a single master, single worker cluster on VMware ESXi.


password is required.
password is too short.
password is too long.
Your password must contain a number, uppercase and lowercase letters as well as one or more special characters


Push Notifications Playground
Trigger notification
Code that should be added to the page goes inside notification.html
Console code should be run in the browser’s console.