Doing Thesis, Why and How?
18 Jun 2015Recently we defended our respective thesis work of six months at IIITB. This write up describes the overall experience and some suggestions for anyone who might be interested in taking up thesis. ( With inputs from Shivam and Srinivas)
Why did I choose thesis over an internship ?
I had around two and half year of work experience before I joined IIITB. So it was a little easier for me to take this decision. I believe that an internship is more or less IT experience, which I already had. Thesis is an opportunity which would be difficult to get again in life. The idea of getting to work with Profs. for almost six months was more exciting to me than doing an internship. I did apply for one particular company before making this decision official. I was very interested in it and it offered only internships ( that is no direct full time offers ). Once I couldn’t clear their interviews, I was sure I wanted to do a thesis.
What I worked on ?
I worked with Prof. Jaya Sreevalsan-Nair and my thesis was titled ‘Augmenting NodeTrix for Effective Small World Network Visualization’. It involved some improvements over the existing visualization called NodeTrix. I used D3.js and OpenGL for the implementation part. I had taken a reading elective on ‘Small World Networks’ in the third semester and this work was a logical extension to it.
What was the overall experience like ?
Overall it was fun. Yes, there were times of frustration, boredom, feeling helpless, but overall it was greatly satisfying. This would not have been possible without the presence of Srinivas, Shivam and Prashant around, during this period.
Possible Misconceptions about Thesis
- Thesis need different kinds of technical skills.
Nope it doesn’t. There is enough time to learn any kinds of tools/technology that might be required for your work, on the fly. So if not knowing Python/Matlab/Java/Android/R/LaTeX or anything else is stopping you from taking a decision, think about it again. That being said, thesis does require different kind of personal skills. You should be sincere, self-motivated and patient at the least. You will be mostly working independently with guidance from your Prof., many times not realizing what direction your work is going in. Not getting good/expected results will test your patience for sure.
- Thesis doesn’t pay you enough money compared to an internship.
Well yes, in direct comparison stipend offered can be substantially lower than the average stipend given by companies. However, you do save both money and time by not traveling. Since you will be in hostel for these six months, you will be probably paying lesser as rent than those who would have to move out of campus. Plus you get to enjoy campus life/events for another six months.
Why would you wanna do thesis ?
-
Very diluted Phd flavor: If you plan to take up a Phd. in future but are not sure about it, then taking up a thesis might help you in making this decision. Although thesis is not comparable to a full-fledged Phd. in any sense, it does give you a mild idea of how does it feel like to work independently. You might end up getting a glimpse of frustrations that Phd. candidates would face for a substantially longer period of time.
-
Publish paper: If you put in enough efforts, you might end up publishing a paper on your work. It is an accomplishment in itself and shows one’s capability of working under minimal supervision. This could be very helpful in applying for Phd. admissions.
-
Get to know Profs.: You will be spending a good amount of time interacting with your Prof. during this period. You will get to know them closely and might end up learning minute nuances of their trade. Working so closely with them and interacting with them on different ideas is a very nice experience. This close interaction also improves your chances of getting a letter of recommendation from them, in case you need it for further studies.
-
Get to know yourself: You get to know a lot about yourself as an individual. Where do your weaknesses stand, what are your strong points, how much pressure can you handle, can you keep yourself self motivated etc.

-
Placements : Depending on how you plan, you can get time to prepare for full time placements. Staying in campus will be advantageous as you won’t have to travel back on weekends whenever a company visits. However, it is strongly advices to get placements done in the third semester itself. It will give you free mind to work.
Why wouldn’t you wanna do thesis?
-
Losing out on some companies: Although there will be lots of companies offering stand alone full-time offers, there are quite a few only offering internships. Only way you can get into them is via taking up an internship and then converting it into a full-time offer. Mind you, these can be some good companies, and can prove out to be a disadvantage if you are highly interested in joining any such company. However, if you put in nice enough efforts, chances are that your guide will help you to get interview call for some jobs which are related to your work. There is no official rule / certainty for this, but is still a possibility.

-
Its very easy to lose track: With so much time in hand and no one to constantly push/monitor you, its easy to lose track of what you are doing. If you choose to take up thesis without strong motivation, it will be difficult to carry yourself enthusiastically till the end.
-
If you get bored easily: You will be mostly working on a single idea all this time. You will be reading/implementing a lot, but only in this restricted scope. This can get boring sometimes.
Some advice if you do decide to take up thesis
We (me, Srinivas and Shivam) discussed a lot about things we could have done better. Following are some point that came up :
-
Start early : If you plan to take up thesis, do take a reading elective in the previous semester. One of the major reason for not getting sufficient time to experiment enough is that a lot of time is spend in literature survey. If you take up reading elective, it will not only help you in covering a lot of papers beforehand but will also give you an idea about how comfortable you will be working with the Prof. Doing your RE sincerely is half your work done. Implement the state-of-art papers in this semester only. This will give a lot of time and scope for experimentation during your thesis work. If this part is not done beforehand, it will consume a major chunk of overall thesis time.
-
Work in groups : This is probably something all of us realized at the end of thesis work. Working on a larger common problem could have been more fruitful. We also felt that pair-programming worked great whenever we had worked together earlier. Moreover, each other’s company was a great comfort on its own. If possible do give a thought on taking up thesis as a team of two-three people, if your Prof. allows that. Even if you end up doing thesis in different topics/domain, try setting up your work environment in same Lab/Library etc. It will be highly beneficial both technically and morally. Working alone in your room is not advised.
-
Chart out overall plan: Srinivas was probably the only person doing this. Making a rough overall plan with time line can be very helpful in planning things up. With so much time in hand, it is very easy to go off track. Just having rough estimates should work out fine. Keep the granularity of your planning at around 15 days. eg. Week 1-2 : Reading paper U,V,W and Implementing algorithm X. Week 3-4 : Learning GPU programming, implementing parallel version. Week 5-6 : Implement algorithm X with changes Y and Z and match performance differences. etc.
-
Prepare report along with: Try not to wait till the last month to begin writing thesis. Take thesis template (in LaTeX format) from any of the seniors or library and keep filling it throughout the thesis work. Whenever you are conducting any sort of experiments, do write why you conducted, were the outcomes favorables, what was the data set used, save the results with proper labels etc. Not doing this will make it very difficult to recollect all this information at the end.
-
Pick Prof. you are comfortable with: There are some Profs. which are more popular than others. Try not to follow other’s opinion about a Professor. See how comfortable you personally are working with them. Taking up a reading elective can help in this process.
-
Pick a sport: Playing sports on regular basis will be very beneficial in keeping you calm. Pick anything from TT/Football/Cricket/Badminton etc. and follow it up regularly. I personally had great experience jogging in the evenings and it helped me a lot by keeping me motivated and charged up during the thesis duration.
-
Define your thesis topic as precisely as possible: Define your problem statement with as minute details as possible. Write down the expected outcomes and overall work you will be doing before hand. Do validate the feasibility of implementing it in the given time frame.
-
Feeling of ‘my work is a waste’: There will be time where you will be feeling that whatever you are doing is just redundant work, most of it already done by others. Understand that even a minor original contribution is an achievements itself. This could be working out an algorithm for different data sets, combining two algorithms to generate a new one, tweaking small changes in any step of the algorithm etc.
How to choose thesis topics
-
Join some LAB: If possible be a part of a lab at IIITB. This will be helpful to give you an idea about various projects/ideas floating around in your domain. Collaborating with MS/Phd. students will also prove beneficial.
-
Problem statements in your domain: There are several website posting interesting real time challenges in different domain. Such problems are very well defined and have clean data sets associated with them. For visualization communities Shivam suggests looking at problems in IEEEVis, InfoVis Wiki, Old InfoVis competitions
-
Different research papers type: Read about different paper types in IEEE. This can give you an idea about different themes your work can fall in. Eg. coming up with a new algorithm, analyzing some existing algorithm etc. You can then define you problem statement accordingly.
-
Read previous years thesis: Read up some previous years thesis to see the kind of work done earlier under some Professor. If you like some of the ideas, you can try and extend them in your own thesis work. It will also give a good idea about what a thesis work will feel like in the end.
Addendum
-
Thesis Defense: The last date for submitting thesis and internship report is somewhere around 15th of June. Do confirm this once with the placement office. After submitting the report you have to present your work in an open seminar where a couple of professors and students (you can call your friends) are present. But seminar happens in a very friendly and encouraging environment. Instead of pointing out your mistakes, Profs. will actually help you to understand what could have been done better and how you can take your work forward.
-
Paper Publication: It would be wonderful if you can bring it to a point where you can publish the work, but it is not a compulsion at all. After you graduate, it is difficult to work on it further. So even if paper is not complete when you submit your thesis, do continue working on it while you are still to join a company, and try publishing after you graduate. Your Profs. will help you for sure. It took over an year, but I was finally able to get mine published in the form of a paper with the help of Shivam and Prof. Jaya
Agarwal S., Tomar A., Sreevalsan-Nair J. (2017) NodeTrix-Multiplex: Visual Analytics of Multiplex Small World Networks. In: Cherifi H., Gaito S., Quattrociocchi W., Sala A. (eds) Complex Networks & Their Applications V. COMPLEX NETWORKS 2016 2016. Studies in Computational Intelligence, vol 693. Springer, Cham
If you have any queries, suggestions, feel free to ask them in comments section or contact any of us directly. We will be happy to help.


Gecode::Options::_I Class Reference
Helper class storing Gist inspectors. More...
#include <driver.hh>
Public Member Functions | |
| _I (void) | |
| Constructor. | |
| void | click (Gist::Inspector *i) |
| Add inspector that reacts on node double clicks. | |
| void | solution (Gist::Inspector *i) |
| Add inspector that reacts on each new solution that is found. | |
| void | move (Gist::Inspector *i) |
| Add inspector that reacts on each move of the cursor. | |
| void | compare (Gist::Comparator *i) |
| Add comparator. | |
| Gist::Inspector * | click (unsigned int i) const |
| Return click inspector number i, or NULL if it does not exist. | |
| Gist::Inspector * | solution (unsigned int i) const |
| Return solution inspector number i, or NULL if it does not exist. | |
| Gist::Inspector * | move (unsigned int i) const |
| Return move inspector number i, or NULL if it does not exist. | |
| Gist::Comparator * | compare (unsigned int i) const |
| Return comparator number i, or NULL if it does not exist. |
Detailed Description
Helper class storing Gist inspectors.
Definition at line 603 of file driver.hh.
Constructor & Destructor Documentation
| Gecode::Options::_I::_I | ( | void | ) | [inline] |
Constructor.
Definition at line 514 of file options.hpp.
Member Function Documentation
| void Gecode::Options::_I::click | ( | Gist::Inspector * | i | ) | [inline] |
Add inspector that reacts on node double clicks.
Definition at line 519 of file options.hpp.
| void Gecode::Options::_I::solution | ( | Gist::Inspector * | i | ) | [inline] |
Add inspector that reacts on each new solution that is found.
Definition at line 523 of file options.hpp.
| void Gecode::Options::_I::move | ( | Gist::Inspector * | i | ) | [inline] |
Add inspector that reacts on each move of the cursor.
Definition at line 527 of file options.hpp.
| void Gecode::Options::_I::compare | ( | Gist::Comparator * | i | ) | [inline] |
Add comparator.
Definition at line 531 of file options.hpp.
| Gist::Inspector * Gecode::Options::_I::click | ( | unsigned int | i | ) | const [inline] |
Return click inspector number i, or NULL if it does not exist.
Definition at line 535 of file options.hpp.
| Gist::Inspector * Gecode::Options::_I::solution | ( | unsigned int | i | ) | const [inline] |
Return solution inspector number i, or NULL if it does not exist.
Definition at line 539 of file options.hpp.
| Gist::Inspector * Gecode::Options::_I::move | ( | unsigned int | i | ) | const [inline] |
Return move inspector number i, or NULL if it does not exist.
Definition at line 543 of file options.hpp.
| Gist::Comparator * Gecode::Options::_I::compare | ( | unsigned int | i | ) | const [inline] |
Return comparator number i, or NULL if it does not exist.
Definition at line 547 of file options.hpp.
The documentation for this class was generated from the following files:
- gecode/driver.hh (Revision: 15218)
- gecode/driver/options.hpp (Revision: 15218)


Welcome to Nile Ethiopian Restaurant, Colorado's authentic Ethiopian restaurant. Nile Ethiopian Restaurant is the place for great food. Our restaurant is built on the same foundations and traditions as Ethiopia. A sample of our spicy and vegitarian foods will fulfill your hunger, and introduce you to the priceless traditions of Ethiopia. We invite you to experience the traditions and flavorful foods.
Gather around the tray (mosseb) made for a group to eat from the same platter. Experience the community dish by eating from the same plate and sharing bread (called injira). Sharing the same bread is socially significant in the Ethiopian culture and also creates a bond of friendship and personalloyalty between the diners. It is said that people who eat from the same plate (mosseb) will never betray one another.
Negou Seid 2015


fair
Square
Home
Setting
Hi Charles,
Welcome to FairSqure. You can get started by creating
your own fair in less than 10 minutes
Create New Fair
All Fair
01/09/2020 9:40AM
Outdoor#20
Standard
Edit
Login to Fair Admin
Create Your Fair in four steps
Step 1
Fair Information
Step 2
Set up Environment
Step 3
Vendor's Settings
Step 4
Payment Set up
Name your Fair
Select Fair Category
Fashion Fair
Electronics Fair
Game Fair
Sports Fair
Fair Description
Start Date
End Date
Banner Slider
Dimensions: xx bb yy
Upload Image
Partner's Logo
Add another partner
Proceed
Cancel
Total Expected Vendors
one
two
three
Fair Type
Fashion Fair
Electronics Fair
Game Fair
Sports Fair
Fair Environment
Fashion Fair
Electronics Fair
Game Fair
Sports Fair
Set Up Events
Conference
Network Room
Panel Session
Set Up Panel Session
Number of Panelist
Fashion Fair
Electronics Fair
Game Fair
Sports Fair
Number of Speakers
Fashion Fair
Electronics Fair
Game Fair
Sports Fair
Select Conference Room
Select Panel Session Room
Proceed
Back
Vendors Signup Link
https://vcfair.com
Collect Name & Phone Number
Collect Additional information from Vendors
Add New Field
Field Type
Input/File etc
Electronics Fair
Game Fair
Sports Fair
Set Vendor's Sign Up Free
Vendor's Category
Vendor's Sign up price
Select Category Features
Add Another Feature
Add Another Category
Proceed
Back
Set up how you want people to you in your Fair
Payment Option A
Payment Option C
Payment Option B
Payment Option D
Preview
Back


| Properties' Summary |
short
Border |
denotes the border style of the control.
Allowed values are
|
boolean
Enabled |
determines whether the control is enabled or disabled.
|
::com::sun::star::awt::FontDescriptor
FontDescriptor |
contains the font attributes for the text in the control
|
long
TextColor |
specifies the text color (as RGB value) of the control.
|
long
TextLineColor |
specifies the text line color (as RGB value) of the control.
|
long
FontRelief |
specifies the relief for the font described in FontDescriptor
|
long
FontEmphasisMark |
specifies the emphasis mark for the font described in FontDescriptor
|
short
IconSize |
specifies the size of the icons in the control
|
boolean
ShowPosition |
determines whether the control should provide functionality for positioning the
parent form
|
boolean
ShowNavigation |
determines whether the control should provide functionality for navigating the
parent form
|
boolean
ShowRecordActions |
determines whether the control should provide functionality for acting on the current record
of the parent form
|
boolean
ShowFilterSort |
determines whether the control should provide functionality for filtering and sorting the
parent form
|
long
RepeatDelay |
specifies a repeat delay for the control
|
| Properties' Details |
Border
short Border;
- Description
- denotes the border style of the control.
Allowed values are
- 0: no border at all
- 1: 3D border
- 2: simple flat
|
|
Enabled
boolean Enabled;
- Description
- determines whether the control is enabled or disabled.
|
|
FontDescriptor
::com::sun::star::awt::FontDescriptor FontDescriptor;
- Description
- contains the font attributes for the text in the control
|
|
TextColor
long TextColor;
- Description
- specifies the text color (as RGB value) of the control.
|
|
TextLineColor
long TextLineColor;
- Description
- specifies the text line color (as RGB value) of the control.
This color is used if the FontDescriptor defines
that the text in the control should be underlined or stroke out.
|
|
FontRelief
long FontRelief;
- Description
- specifies the relief for the font described in FontDescriptor
The value must be one of the ::com::sun::star::text::FontRelief
constants.
|
|
FontEmphasisMark
long FontEmphasisMark;
- Description
- specifies the emphasis mark for the font described in FontDescriptor
The value must be one of the ::com::sun::star::text::FontEmphasis
constants.
|
|
IconSize
short IconSize;
- Description
- specifies the size of the icons in the control
At least the following values are to be supported:
- 0: small icons (16x16)
- 1: medium size icons (26x26)
|
|
ShowPosition
boolean ShowPosition;
- Description
- determines whether the control should provide functionality for positioning the
parent form
|
|
ShowNavigation
boolean ShowNavigation;
- Description
- determines whether the control should provide functionality for navigating the
parent form
|
|
ShowRecordActions
boolean ShowRecordActions;
- Description
- determines whether the control should provide functionality for acting on the current record
of the parent form
|
|
ShowFilterSort
boolean ShowFilterSort;
- Description
- determines whether the control should provide functionality for filtering and sorting the
parent form
|
|
RepeatDelay
long RepeatDelay;
- Description
- specifies a repeat delay for the control
Some buttons of a NavigationToolBar may show repeating behaviour, e.g. may be
repeatedly triggered when the user keeps the mouse pressed over such a button.
The delay between two such triggers (in milliseconds) is specified with this property.
|
|
Copyright © 2013, The Apache Software Foundation, Licensed under the Apache License, Version 2.0. Apache, the Apache feather logo, Apache OpenOffice and OpenOffice.org are trademarks of The Apache Software Foundation. Other names may be trademarks of their respective owners.


A simple timepicker component for Twitter Bootstrap.
Please take a look at the CHANGELOG.md
and the issues tab for issues we’re
working on and their relative priorities.
This project is registered as a Bower package, and can be installed with the following command:
bower install bootstrap-timepicker
You can also download our latest release (and any previous release) here.
View demos & documentation.
If you make money using this timepicker, please consider supporting its development.
Install NodeJS and Node Package Manager.
Install packages
npm install
bower install
grunt test // run jshint and jasmine tests
grunt watch // run jsHint and Jasmine tests whenever a file is changed
grunt compile // minify the js and css files
Thanks to everyone who have given feedback and submitted pull requests. A list of all the contributors can be found here.
Special thanks to @eternicode and his Twitter Datepicker for inspiration.


| %seed% {future} | R Documentation |
Set random seed for future assignment
fassignment %seed% seed
fassignment |
The future assignment, e.g.
|
seed |
(optional) If TRUE, the random seed, that is, the state of the
random number generator (RNG) will be set such that statistically sound
random numbers are produced (also during parallelization).
If FALSE (default), it is assumed that the future expression does neither
need nor use random numbers generation.
To use a fixed random seed, specify a L'Ecuyer-CMRG seed (seven integer)
or a regular RNG seed (a single integer). If the latter, then a
L'Ecuyer-CMRG seed will be automatically created based on the given seed.
Furthermore, if FALSE, then the future will be monitored to make sure it
does not use random numbers. If it does and depending on the value of
option |


Motivation: Increased availability of various genotyping techniques has initiated a race for finding genetic markers that can be used in diagnostics and personalized medicine. Although many genetic risk factors are known, key causes of common diseases with complex heritage patterns are still unknown. Identification of such complex traits requires a targeted study over a large collection of data. Ideally, such studies bring together data from many biobanks. However, data aggregation on such a large scale raises many privacy issues.
Results: We show how to conduct such studies without violating privacy of individual donors and without leaking the data to third parties. The presented solution has provable security guarantees.
Contact:
Supplementary information:
Genome-wide association studies (GWAS) are one of the driving reasons behind the formation of nationwide and privately funded gene banks. Many chronic diseases and various cancer types are known to have genetic disposition factors ( Chakravarti and Little, 2003 ; Lander and Schork, 1994 ). Although many underlying genetic signatures have been successfully identified for Mendelian disorders ( Hamosh et al., 2005 ), not many genetic risk factors for complex diseases have been discovered and confirmed. GWAS have identified some risk factors for type II diabetes ( Prokopenko et al., 2008 ) and for a few other common diseases ( Manolio et al., 2008 ; Wellcome Trust Case Control Consortium, 2007 ). GWAS have been modestly successful in pharmacogenetics ( Grant and Hakonarson, 2007 ) and cancer research ( Varghese and Easton, 2010 ). The size and structure of a study cohort are the main limiting factors in such studies, as the individual impact of genomic differences is usually small. Larger sample sizes increase the sensitivity of statistical tests and make it possible to apply a wide range of data-mining methods ( Moore et al., 2010 ; Szymczak et al., 2009 ).
Ideally, studies should use nationwide and continent-wide patient cohorts. Formation of such cohorts is becoming feasible as genotyping costs are rapidly decreasing ( Hayden, 2010 ; Pettersson et al., 2009 ). In addition to nationwide biobanks, e.g. the UK Biobank, several personal genomics companies, such as 23andMe and Navigenics, already possess large and diverse patient cohorts. Biobanks are also forming large collaboration networks, such as P3G and HuGENet, to combine their patient cohorts and improve study quality. Privacy of individual gene donors is one of the biggest concerns in such projects. In many countries, genotype data are classified as sensitive data that can be handled by complying with specific restrictions, e.g. HIPAA in the USA and the Data Protection Directive in the European Union. These restrictions are justified, as a leak of genetic information can cause genome-based discrimination when more health-related patterns have been discovered.
Standard anonymization methods are not applicable to genotype data, as the data themselves are an ultimate identity code. Only 30–80 out of 30 million single-nucleotide polymorphisms (SNPs) are needed to uniquely identify a person ( Lin et al., 2004 ). Moreover, the size of online genotype databases for genealogy studies, such as SGMF and YHRD, has made re-identification of anonymized genotype data a real threat ( Gymrek et al., 2013 ). Re-identification attacks ( Malin and Sweeney, 2000 , 2002 ) based on combining inferred phenotypes with public data become practical, as the list of known associations between genotype and phenotypic traits ( Hindorff et al., 2009 ) evolves. Finally, Homer et al. (2008) showed that even aggregated pools of genomic data can leak private information. Although follow-up studies ( Visscher and Hill, 2009 ) softened initial claims, the threat remains.
These findings created a debate whether one can promise privacy of genotype data in consent forms at all ( P3G Consortium et al., 2009 ). In the following, we show how to set up an infrastructure where the genotype data can be stored and processed so that none of the peers involved in the process can reconstruct the data, and thus the risk of accidental leaks and malicious data abuse is greatly reduced. The data analysis algorithms are executed in an oblivious manner so that only the desired outcome is revealed to the user and nothing else. Differently from well-known data perturbation and masking techniques ( Machanavajjhala et al., 2007 ; Sweeney, 2002 ), security guarantees are cryptographic. These guarantees depend on the computational complexity of well-established mathematical problems and not on the background knowledge of potential attackers. As such, the presented methodology is applicable to protecting biobanks and other medical databases.
There are four principal groups of stakeholders in a typical medical study: data donors, data collectors, data analysts and supervisory organizations. Data donors consent to give their tissue samples and record other types of medical data, e.g. various questionnaires covering health issues. Data collectors are responsible for gathering and storing the data and keeping the donors’ confidentiality. The baseline requirements are forced by the laws, e.g. by the Genetic Information Nondiscrimination Act of 2008 in the USA. However, more stringent privacy guarantees can reduce data donors’ fears about data abuse and increase the participation rate.
Data collectors and supervisory organizations must guarantee that the data analysts (researchers) meet privacy restrictions. The confidentiality problem is somewhat smaller if the data analysts are from the same institution as the data collectors. If the analysts are not part of the organization, usually confidentiality agreements are signed between the parties. In most cases, collected data are stored in several databases so that direct personal information is not accessible to researchers. Instead, each patient gets a (pseudo) random barcode that links different databases together ( De Moor et al., 2003 ). On rare occasions, databases are merged either to identify specific persons or to form datasets needed for medical research.
All such solutions provide only partial security guarantees for data donors. Even if genetic data are stored separately and are not directly accessible, they must be (partially) released before the actual data analysis is carried out. Hence, a single fault by a data analyst or an insider attack might effectively obliterate all privacy guarantees. Therefore, compromises in confidentiality are needed for the creation of worldwide data banks for the scientific community.
These privacy issues are often alleviated with data perturbation and agglomeration techniques. For instance, the National Institutes of Health in the USA published the ratio of SNP alleles of various case–control studies ( Couzin, 2008 ) because it is essentially impossible to split a DNA mixture back to individual genotypes. However, it turned out that it is possible to detect whether a specific person is in the mixture or not ( Homer et al., 2008 ). As case–control groups are often based on sensitive information, the data had to be removed.
Such unexpected security breaches are common for ad hoc perturbation or agglomeration methods because one often overlooks the effect of potential background knowledge to security. Although for certain problems perturbation and agglomeration methods can provide provable security, their overall applicability is limited and there are many known impossibility results ( Dwork, 2011 ).
In this work, we propose a data collection system where sensitive data are secret shared among several independent entities. In brief, secret sharing assures that each party gets completely random-looking data. However, when all parties pool the data together sensitive values can be restored (see Fig. 1 for an example of how secret sharing works). Depending on the exact nature of the used secret sharing scheme, the privacy of shared values is preserved even if some of the parties holding shares collude (discussed further in the methods section). Hence, data can be shared without the fear of unexpected disclosure. Moreover, with the use of specific multi-party computation techniques, computations on secret shared data can be carried out without leaking any information ( Bogdanov et al., 2008 ; Damgård et al., 2009 ). As a result, one can deploy a distributed computation environment that securely collects the data, does oblivious computations and returns the desired end results. Such systems have been successfully used for securing auctions ( Bogetoft et al., 2009 ) and analyzing financial data ( Bogdanov et al., 2012 ).
This figure illustrates how players A and B use a 3-out-of-3 additive secret sharing scheme to distribute two 32-bit integer values x and y to shares. The shares are sent to three servers that use the homomorphic property of the scheme to securely compute the sum of x and y. The shares of the sum are sent to player C, who reconstructs the result
There are other cryptographically secure computation techniques, e.g. (fully) homomorphic encryption. However, these techniques are significantly slower and less feasible on the large genome databases.
Figure 2 depicts the overall workflow of secure GWAS. The core of such a system consists of three or more dedicated data centers ( hosts) that are assumed to be independent organizations. For a worldwide study, these can be biobanks of different countries, regulatory authorities and patient interest groups. None of them have to be unconditionally trusted as long as too many of them do not collude with others. In particular, a successful attack against one or two of the data centers leaks no information and there even exists a recovery procedure from such attacks.
Secure GWAS consists of three major stages: data acquisition, formation of case–control groups and statistical testing. Panel ( A) depicts how these three stages are linked. Data are gathered and sent in securely coded shares to be stored. For statistical tests, case and control info is securely coded and applied to the securely stored data so that statistical analyses can be carried out. Panel ( B) describes two alternative scenarios that can be used for secure storage of genotype and phenotype data. Scenario 1 depicts a situation where genotype data are entered into secure storage by the wetlab and phenotype data are entered by the donors themselves. Scenario 2 depicts a case where different gene banks send selected genotype and phenotype data to secure storage so they can make joint analyses on more data. Panel ( C) describes how case and control groups can be formed. In the simplest case, researches have unrestricted access to phenotype data and can thus form case and control groups by themselves. In more complex settings, researchers do not have rights to access phenotype data, and hosts must use secure multi-party computations to construct case and control groups based on inclusion criteria
Genomic data are entered into the system by primary data collectors, e.g. wetlabs or different biobanks who collect and process the biological samples and who want to make joint analyses on shared data. For this operation, standard clinical protocols for genotyping are sufficient for security. At the end of the stage, the data are secret shared and transferred securely to the hosts.
Clinical data can be entered into the system either by the data donors themselves or by primary data collectors. The data are sent to the secure phenotype database in secret shared form to ensure confidentiality. In the analysis stage, the data analyst specifies the algorithm to be run on the secret shared data and waits for the results. For GWAS, the analyst first forms case and control groups. Next, the algorithm computes the necessary statistics and, finally, it releases the loci that show a statistically significant differentiation according to the specified case–control groups. If the analyst wants to further examine a secured input value, all parties hosting the system must agree to disclose the respective shares.
We acknowledge that standard security measures are sufficient when the data are collected and analyzed by a single organization. Still, long-term projects can benefit from distributed data storage. First, a break-in into a data center yields no usable information. Second, splitting the data among independent organizations gives additional guarantees for the data donors, e.g. participants of commercial studies have no way of knowing what happens to their data if the project goes bankrupt. If one core center belongs to the state, participants know with greater certainty that their data cannot be abused. Third, other sources of private data can be incorporated into the analysis without privacy leaks. In particular, medical institutions can use their patient records to enhance analysis. The proposed solution provides a way to conduct the analysis so that neither the gene bank nor the medical institution releases their data.
The benefits of our approach are evident in collaborative studies between independent biobanks. As nothing beyond the desired test results are revealed during the computation, the solution provides superior privacy guarantees compared with alternatives based on meta-analysis techniques ( Wolfson et al., 2010 ), where each biobank first computes local summaries that are collaboratively merged into a final result. As a result, only a few summary values are disclosed. However, it is impossible to tell what exactly can be inferred about concealed values. Moreover, leakages of individual studies can cumulate as in DNA pools, where aggregation of minuscule effects on SNP frequencies allows us to make strong conclusions.
The biggest technical drawback of our solution is computational efficiency. As the data are secret shared between core centers and each oblivious computation step requires network communication, secure algorithms are several magnitudes slower than their insecure counterparts. Hence, we set up a controlled experiment to show that GWAS are feasible in our setting.
Finally, note that legal restrictions can form a major obstacle, as secret sharing is not as widely used as data encryption. However, legal issues are out of our scope as we analyze only the technological feasibility and potential advantages.
The first step in GWAS is splitting individuals into case and control groups. These groups are formed based on phenotypic traits, such as presence and severity of disease. Although all four nucleotides can be located in a SNP site, it is common to consider two alleles, where the first one corresponds to the reference sequence and the other represents potential mutations. Table 1 depicts the
Contingency table for the standard
| Group | Allele A | Allele B |
|---|---|---|
| Cases | a | c |
| Controls | b | d |
These tests are accurate if the Hardy–Weinberg equilibrium condition is satisfied for a particular SNP, whereas the Cochran–Armitage test for trend can be used without this assumption. First, one must assemble the
Contingency table for the Cochran–Armitage test for trend
| Group | Allele AA | Allele AB | Allele BB | Total |
|---|---|---|---|---|
| Cases |
r
0
|
r
1
|
r
2
|
m
1
|
| Controls |
s
0
|
s
1
|
s
2
|
m
2
|
| Total |
n
0
|
n
1
|
n
2
|
N |
Transmission disequilibrium test (TDT) is applicable only if the data consist of parent–child trios. The test measures whether one homozygous genotype is more over-represented than the other among affected children with heterozygous parents. For that we must first select trios where both parents have heterozygous genotype. Let u be the count of AA and v be the count of BB genotypes among children. Then the corresponding statistic
A secure computation program is similar to a standard computer program. The difference between the two is in how the data are stored and processed. In a standard program, all values are processed publicly, whereas in a secure computation program, it is possible to specify which values are publicly visible and which are stored using techniques like secret sharing. These values can be used in computations without leaking their contents.
In our proposed solution, the data are secret shared between three or more hosts. The hosts themselves are not able to understand the values stored in their databases because each value looks like random noise owing to secret sharing. However, it is not trivial to perform computations on secret shared values as special secure multi-party computation protocols are required. The secure computation protocols used by the hosts preserve the privacy of the data during computation. The genotype data remain secure as long as the hosts do not share their databases of shares with each other. Figure 1 shows how secure multi-party computation works with secret sharing.
Secure computation can be used to perform most data processing operations. However, current solutions have some important differences compared with standard programming: (i) floating-point operations are significantly slower; (ii) comparison operations are slower than multiplication and addition; (iii) parallel execution of several operations is faster than sequential execution. Further details can be found in the
Allele-level descriptions of genotypes are commonly stored as sequences of pairs where each pair is encoded as AA, AB, BB or NN, corresponding to a specific SNP. In GWAS, such data are converted into contingency tables as described in Tables 1 and 2 depending on the analysis method being used.
This kind of counting, however, requires the use of string comparison operations that we would like to avoid, as they tend to be relatively slow in the case of share computing. Therefore, we represent each SNP as a pair of integers
During the data collection phase, data donors, wetlabs or gene banks must first convert genotypes into the form described above and then secret share them between data hosts. As a result, we get a secret shared database where each column corresponds to an individual donor and there are two rows for each SNP (one for
To hide the identities of case and control group members, secret shared index vectors are used to specify the groups. An index vector
The two principal ways of how to construct case–control groups can be seen in Figure 2 Panel C. In the first scenario, analysts have direct access to clinical data for a set of donors and, thus, are able to select case and control groups and construct index vectors. In the second scenario, phenotype data are also stored in secret shared form. In this case, there exists a secret shared database of phenotype attributes that consists of boolean attributes (e.g. has diabetes) and integers (e.g. age, blood pressure, height). To construct case and control groups, the analyst has to specify a logical expression based on which the hosts perform the necessary comparisons and output the two index vectors in secret shared form. For simple inclusion criteria, such as the one we used for experiments
Let
For the second contingency table,
To determine whether a SNP is significant, one must check whether a P-value that is associated with a test statistic is below a pre-described significance level. Let α be the desired significance level and let
Direct evaluation of formulae (1)–(4) requires floating-point arithmetic, which we would like to avoid. Hence, we must rewrite the equation
The significance level must be determined considering the multiple testing issue. The simplest way is to use Bonferroni correction, which is a conservative measure. It is also possible to perform privacy-preserving FDR correction. We estimate that the secure version of the standard FDR procedure takes about 10 min to complete for 262 264 SNPs. However, there are alternatives to the original algorithm that are significantly faster; see the
To demonstrate the feasibility of our approach, we used the S
We used 270 genotypes from the H
Each of the donors has 262 264 measured SNPs. First, we ran the algorithm on the data of 270 donors, and then we went on to test the data of 540, 810 and 1080 donors. We performed the experiments on three servers running S
The time spent on data acquisition and secure storage does not depend on the statistical test used later on. It depends only on the number of SNPs and the number of gene donors. The average time it takes to encode and share the SNPs for the described case can be seen in Table 3 . Note that secret sharing and uploading data are done only once for each dataset; hence, this is a single-time cost.
Performance results for data upload and filtering
| Number of donors | Upload | Filtering |
|---|---|---|
| 270 donors | 12.0 min | 0.51 s |
| 540 donors | 17.3 min | 0.59 s |
| 810 donors | 23.2 min | 0.63 s |
| 1080 donors | 29.4 min | 0.68 s |
The time needed to form case–control groups depends on the application scenario. When the analyst has direct access to phenotype data and can form case and control groups by herself/himself, then there is no computational overhead. In more involved cases, the case and control groups must be constructed based on secret shared phenotype attributes. In this case, the overhead depends on the complexity of inclusion criteria for case and control groups. Filtering results presented in Table 3 show that formation of such groups can be done in seconds for typical inclusion criteria that consist of simple comparison operations mixed with logical conjunctives.
The time needed to perform the statistical test depends on the test, but in all cases it can be broken down into counting allele frequencies and evaluating test statistic. As Tables 4 and 5 clearly show, the main performance bottleneck is frequency counting, which scales linearly w.r.t. the total number of SNP measurements. As our encoding is optimized for
Performance results for three different frequency analyses
| Number of donors |
|
Cochran–Armitage | TDT |
|---|---|---|---|
| 270 donors |
|
|
|
| 540 donors |
|
|
|
| 810 donors |
|
|
|
| 1080 donors |
|
|
|
| 1080 donors (non-secure) | 14 s | 35 s | 11 s |
Performance results for four test evaluation methods
| Number of donors |
|
|
Cochran– Armitage | TDT |
|---|---|---|---|---|
| 270 donors |
|
|
|
|
| 540 donors |
|
|
|
|
| 810 donors |
|
|
|
|
| 1080 donors |
|
|
|
|
| 1080 donors (non-secure) | 21 ms | 20 ms | 49 ms | 11 ms |
The presented results clearly show that cryptographically secure evaluation of statistical tests on genome-wide scale is practically feasible. The expected running time is hours instead of a few minutes when computed non-securely. However, the latter is not a significant slowdown compared with the time needed to acquire the data if the secure analysis method is not used.
Although the results prove the practical feasibility of cryptographically secure GWAS, the solution is also notably more resource demanding than the alternatives. We have to analyze further whether potential benefits outweigh costs. We consider three potential application scenarios and contrast our approach with the alternatives.
By now many countries have national or state-funded biobanks. There are more than 40 state-governed biobanks in Europe ( Zika et al., 2010 ) and many others in Asia and America ( Swede et al., 2007 ). Thus, there is a huge potential for collaborative studies between biobanks, hospitals and pharmaceutical companies. For example, if a clinical study indicates that a treatment is ineffective for a certain group of people, a genome-wide association study can indicate whether a particular set of SNPs can be used to predict efficacy of a treatment. In particular, GWAS have shown that certain SNP mutations influence efficacy of treatments for asthma, inflammatory bowel disease, coronary heart disease and cancer ( Grant and Hakonarson, 2007 ).
Privacy issues are the major obstacle in such studies: neither biobanks nor research institutions can give out data without explicit consent from the patients or explicit decision by a relevant ethics committee. In such scenarios, secure GWAS can be used as a pilot study for assessing potential benefits of combined studies. In particular, there is no reason to merge the data for further analysis if a secure GWAS reveals no differentially expressed SNPs. Because such a study can be conducted in a few hours, it can significantly speed up pharmacogenetic studies and the results can be used by ethics committees to make more seasoned decisions.
In many state-funded studies, collected data must be made accessible for public use by submitting them to a central repository. The NIH example shows a direct publication of GWAS data may cause unintended consequences even if the data are presented to the public in aggregated form ( Couzin, 2008 ). One potential solution is to set up an online web service for conducting GWAS: a researcher just posts inclusion criteria for case and control groups and all computations are done by the host. In most cases, such a solution is adequate without cryptographic countermeasures. Privacy issues emerge only if researchers want to pool together data from several different repositories to detect weak associations or the inclusion criteria must remain private. In these cases, secure GWAS methodology can be applied by combining methods for international consortium studies with phenotype-based filtering (see Fig. 2).
One of the main hurdles in GWAS is the sample size. For rare diseases, there are not enough genotyped patients to form a big enough case group. Also, over- and under-representation of sub-populations can cause spurious associations. Larger studies involving several international biobanks can diminish the impact of such problems.
Two competing alternatives to our solution in this setting are federated database systems with additional security mechanisms and hierarchical aggregation of the data.
A federated database system offers middleware that automatically binds together several sources and allows users to make various queries without knowing how the data are organized. As such, a federated database system does not solve privacy issues. Hence, one needs an honest broker—a dedicated server with strengthened security measures that assembles the data and processes all queries ( Boyd et al., 2007 ). The latter introduces a single point of failure—nothing can be done if the security of the honest broker is breached. Also, as the data are sent directly to the honest broker, all biobanks must have explicit clearance for releasing the data.
Hierarchical data aggregation is applicable when results of individual studies can be combined with some meta-analysis technique (e.g. Wolfson et al., 2010 ). In such cases, the honest broker must access only aggregated summaries of individual data sources to produce the desired result. Consequently, we get stronger privacy guarantees, as the broker receives only a limited amount of information. However, unexpected privacy breaches can still occur because aggregation methods provide no explicit security guarantees and it is extremely difficult to assess how much information is leaked through summaries. Also, the approach cannot be used when members of case and control groups must be kept secret.
In a nutshell, while the alternatives are faster than our solution, they are also much more vulnerable to various attacks, and thus, privacy concerns can prevent their usage or considerably delay the initial setup time. Moreover, hierarchical data aggregation techniques can be combined with our solution. Namely, our solution can be used to replace the honest broker—biobanks secret share the aggregated results, and thus, fewer operations must be done on shares. For the analysis part of GWAS, the resulting hybrid algorithm will only take the time given in Table 5 plus a little overhead, making the computation time ∼30 s to 1 min as the filtering of case and control groups and computation of contingency tables are done locally.
The rapid decrease of genotyping costs and moderate success in genetic diagnostics have sparkled interest in personal genomics. Companies, such as 23andMe, deCODEme and Navigenics, offer personalized genotyping services. Although participants have a right to withdraw their data at any moment, this right is enforced only by physical and organizational methods. As a consequence, a single successful outsider or insider attack can obsolete all privacy guarantees. Numerous data leakages in other areas have shown that this is an irreversible procedure. Once data have leaked, there is no way to recall them. On a shorter timescale, such events are highly improbable. However, such projects need privacy guarantees that last more than 100 years to protect participants and their offspring. In such settings, distributed storage based on secret sharing is one of the best cryptographic alternatives, as a successful breach of security of a single facility yields no information and it is possible to recover from such events.
Funding: The research was supported by the
Conflict of Interest: none declared.


THE OBJECTIVE: COMPLETE THE FIRST EVER MULTI-DAY BIKE TRAVERSE OF THE CORDILLERA REAL’S WEST SIDE.
This past summer a crew of four Yeti ambassadors – Nate Hills, Thomas Woodson, Carston Oliver, and Joey Schusler, set out on a 2-week bikepacking trip to Bolivia. The objective was to complete the first ever multi-day bike traverse of the Cordillera Real’s west side following llama trails, open scree fields, and primitive trekking paths. These mountains proved to be one of our greatest challenges to date.


Adapting a Reference Board Initialization Script to Your Board
This section provides the steps required to modify an existing reference board initialization script for your custom board. If your board is not based on a supported reference platform, then you should follow the procedure described in Creating a Custom Initialization Script Using a Template.
Prerequisites
A new basic project has been created in Sourcery CodeBench.
The Sourcery Probe target initialization files have been located within the Sourcery CodeBench installation.
Procedure
Import the reference board's <target>.maj initialization script from the Sourcery CodeBench installation or Nucleus BSP package into your product. See Table 1-4 for default installation directory locations, then look in the tsp subdirectory.
Or, if you are using Nucleus ReadyStart, copy the initialization script from the reference board BSP installation directory to your working directory.
Rename <target>.maj file in your working directory to a more suitable name (<new_target>.maj). It is recommended to use the name of the board because it is a board initialization file.
Open <new_target>.maj within Sourcery CodeBench or use a text editor.
Edit the file to adapt it to the customizations you made to the board relative to the reference platform. Detailed comments in the init script indicate places where changes are likely.


Here at Bomboo Buddies we want to see more and more happy pandas in this world, so we've set up a new way for your panda to meet other pandas and spread the LOVE!
The latest census in 2014 found that there were 1,864 giant pandas alive in the wild. While still very low, this represents a real success story, with numbers increasing from around 1,000 in the late 1970s.
Take a look round and find out for your self! See our pandas, our merchaindise and our date ideas.


This page tests all of the different ways that content on a page can change text that might affect a live region.


Plato on Github
Report Home
compiled\ember-runtime\lib\ext\function.js
Maintainability
74.22
Lines of code
200
Difficulty
26.87
Estimated Errors
0.60
Function weight
By Complexity
By SLOC
/** @module ember @submodule ember-runtime */ 'use strict'; function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } var _emberMetalCore = require('ember-metal/core'); var _emberMetalCore2 = _interopRequireDefault(_emberMetalCore); // Ember.EXTEND_PROTOTYPES, Ember.assert var _emberMetalExpand_properties = require('ember-metal/expand_properties'); var _emberMetalExpand_properties2 = _interopRequireDefault(_emberMetalExpand_properties); var _emberMetalComputed = require('ember-metal/computed'); var _emberMetalMixin = require('ember-metal/mixin'); var a_slice = Array.prototype.slice; var FunctionPrototype = Function.prototype; if (_emberMetalCore2['default'].EXTEND_PROTOTYPES === true || _emberMetalCore2['default'].EXTEND_PROTOTYPES.Function) { /** The `property` extension of Javascript's Function prototype is available when `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Function` is `true`, which is the default. Computed properties allow you to treat a function like a property: ```javascript MyApp.President = Ember.Object.extend({ firstName: '', lastName: '', fullName: function() { return this.get('firstName') + ' ' + this.get('lastName'); }.property() // Call this flag to mark the function as a property }); var president = MyApp.President.create({ firstName: 'Barack', lastName: 'Obama' }); president.get('fullName'); // 'Barack Obama' ``` Treating a function like a property is useful because they can work with bindings, just like any other property. Many computed properties have dependencies on other properties. For example, in the above example, the `fullName` property depends on `firstName` and `lastName` to determine its value. You can tell Ember about these dependencies like this: ```javascript MyApp.President = Ember.Object.extend({ firstName: '', lastName: '', fullName: function() { return this.get('firstName') + ' ' + this.get('lastName'); // Tell Ember.js that this computed property depends on firstName // and lastName }.property('firstName', 'lastName') }); ``` Make sure you list these dependencies so Ember knows when to update bindings that connect to a computed property. Changing a dependency will not immediately trigger an update of the computed property, but will instead clear the cache so that it is updated when the next `get` is called on the property. See [Ember.ComputedProperty](/api/classes/Ember.ComputedProperty.html), [Ember.computed](/api/#method_computed). @method property @for Function @public */ FunctionPrototype.property = function () { var ret = (0, _emberMetalComputed.computed)(this); // ComputedProperty.prototype.property expands properties; no need for us to // do so here. return ret.property.apply(ret, arguments); }; /** The `observes` extension of Javascript's Function prototype is available when `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Function` is true, which is the default. You can observe property changes simply by adding the `observes` call to the end of your method declarations in classes that you write. For example: ```javascript Ember.Object.extend({ valueObserver: function() { // Executes whenever the "value" property changes }.observes('value') }); ``` In the future this method may become asynchronous. If you want to ensure synchronous behavior, use `observesImmediately`. See `Ember.observer`. @method observes @for Function @public */ FunctionPrototype.observes = function () { for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { args[_key] = arguments[_key]; } args.push(this); return _emberMetalMixin.observer.apply(this, args); }; /** The `observesImmediately` extension of Javascript's Function prototype is available when `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Function` is true, which is the default. You can observe property changes simply by adding the `observesImmediately` call to the end of your method declarations in classes that you write. For example: ```javascript Ember.Object.extend({ valueObserver: function() { // Executes immediately after the "value" property changes }.observesImmediately('value') }); ``` In the future, `observes` may become asynchronous. In this event, `observesImmediately` will maintain the synchronous behavior. See `Ember.immediateObserver`. @method observesImmediately @for Function @private */ FunctionPrototype.observesImmediately = function () { _emberMetalCore2['default'].assert('Immediate observers must observe internal properties only, ' + 'not properties on other objects.', function checkIsInternalProperty() { for (var i = 0, l = arguments.length; i < l; i++) { if (arguments[i].indexOf('.') !== -1) { return false; } } return true; }); // observes handles property expansion return this.observes.apply(this, arguments); }; /** The `observesBefore` extension of Javascript's Function prototype is available when `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Function` is true, which is the default. You can get notified when a property change is about to happen by adding the `observesBefore` call to the end of your method declarations in classes that you write. For example: ```javascript Ember.Object.extend({ valueObserver: function() { // Executes whenever the "value" property is about to change }.observesBefore('value') }); ``` See `Ember.beforeObserver`. @method observesBefore @for Function @private */ FunctionPrototype.observesBefore = function () { var watched = []; var addWatchedProperty = function addWatchedProperty(obs) { watched.push(obs); }; for (var i = 0, l = arguments.length; i < l; ++i) { (0, _emberMetalExpand_properties2['default'])(arguments[i], addWatchedProperty); } this.__ember_observesBefore__ = watched; return this; }; /** The `on` extension of Javascript's Function prototype is available when `Ember.EXTEND_PROTOTYPES` or `Ember.EXTEND_PROTOTYPES.Function` is true, which is the default. You can listen for events simply by adding the `on` call to the end of your method declarations in classes or mixins that you write. For example: ```javascript Ember.Mixin.create({ doSomethingWithElement: function() { // Executes whenever the "didInsertElement" event fires }.on('didInsertElement') }); ``` See `Ember.on`. @method on @for Function @public */ FunctionPrototype.on = function () { var events = a_slice.call(arguments); this.__ember_listens__ = events; return this; }; }


Richard Gasquet
(France)
Getty Images
Birthdate:
June 18, 1986 (28 years old)
Birthplace:
Beziers, France
Residence:
Neuchatel, Switzerland
Height:
6' 1" (185 cm)
Weight:
165 lb (75 kg)
Plays:
Right-handed
Turned Pro:
2002 (13 years on tour)
Official Site:
http://www.richardgasquet.net/
#21
Singles Ranking


Greed
Semantic fluid grids for SCSS
Greed is an SCSS library for building semantic fluid grids. It relies on placeholder selectors and mixins, so that it doesn't pollute your CSS class namespace.
This was written by Rocky Meza and is hosted on GitHub.
Examples
The source code for these examples is available on GitHub.
Fluid
Fourth
Fourth
Fourth
Fourth
Third
Third
Third
Half
Half
Full
Fourth
Half
Fourth
Two-thirds
Third
Responsive
Thing
Thing
Thing
Thing
Thing
Thing
Thing
Thing
Thing
Thing
Thing
Thing
Thing
Thing
Thing


Destination
{{destination.abbrev}}
Enter Time of Departure
Seats Available In The Ride
Description
directions_car


Extremely Fast Registration!
Finish Within Seconds!
Choose A Location
We have relationships with business's in your area!
Receive your results within days!
You than have the option to post those results and the date of verification.
© 2016 Footer


The human body, man. How does it work?
I am obsessed with life optimization. Every day we make hundreds of small decisions that have profound effects on our mental and physical state.
The most important thing you can do to increase your energy levels is to understand that your body works as an energetic system. While plants get their energy from the sun and the dirt, we animals get our energy from the food we put in our mouths. All of your great ideas first started out as food!
To maximize the energy available to your brain, you can optimize three basic systems: 1. Facilitate the flow of available nutrition around your body. 2. Increase the quantity of nutrition in your body through food choice. 3. Increase your body’s ability to process nutrition from food.
Blood: The basic pathway
Blood is the way water-soluble vitamins, minerals, amino acids, and electrolytes get where they need to go in our bodies. This system has a pump, which is our big beautiful heart, and the better our heart works, the better this system performs. The way to optimize blood flow is pretty simple.
- Don’t skip leg day. But after that:
- Don’t skip cardio day.
Lymph: It's a thing
The lesser-known circulatory pathway is the lymphatic system. Lymphatic fluid is the body’s waterway, and it’s how fat-soluble minerals and vitamins like A, D, E, and K travel though our bodies. It’s also how lymphocytes, the disease fighting white blood cells, get around. Unlike blood, lymphatic fluid has no pump to move it around. Instead, we have to move it ourselves!
If you’ve ever taken a yoga class, you probably felt pretty amazing afterwards. The teacher may also have talked about “moving energy” through the body. It’s not just a new agey idea, it’s actually a very real physical process. By bending and stretching, we move old interstitial fluid away from our tissues and help vitamins and white blood cells reach their intended bodily destination.
To get the most out of your lymph, there are two main methods of optimization: drink a lot of water, and stretch your body out. Drink the most distilled water you can find. Protip: get a reverse-osmosis water filter, which takes out the disinfectants that are used to treat tap water.
I’ve also taken to “urban lifestyle yoga,” which is doing yoga stretches whenever you feel like it out in the wild. You may get some strange looks, but little do those people know how great you feel from an efficient movement of lymphatic fluid!
Micronutrition: Lego blocks of immune response
The second way to increase your available energy resources is to maximize the total volume of nutrition flowing around. Below calories and the macronutrients are micronutrients. Vitamins and minerals. These are the building blocks of new tissue. Good micronutrition is like having a giant bucket of legos. Your body can build anything that it wants!
To maximize micronutrition, the best thing you can do is to eat plants. Fruits and vegetables. We are still 100% animals and not yet cyborgs, so plant food is where micronutrition is most bio-available to us.
As anyone else who has tried to hack their body by eating only protein bars and multivitamins will know, taking a supplement is not the same as eating food. The nutrition in supplement-based food like Soylent is not only less bioavailable, it’s also missing a crucial element. We don’t just need the building blocks of micronutrition, we also need the processing agents--bacteria.
The microbiome: We are not alone
If vitamins and minerals are micronutrition, then bacteria is nanonutrition. The human body is comprised of 10x more bacterial cells than human cells. Don’t freak out, but you and I are living with almost 3 pounds of bacterial symbiotes inside of us, and they are known as the microbiome.
The microbiome is responsible for nutrient processing and energy extraction from the small intestine into the circulatory system. It is where some of the best neurotransmitters like dopamine and serotonin are created. A damaged microbiome results in depression, lowered immune response, and chronic health conditions like celiac and leaky gut syndrome. A healthy microbiome means that you can extract maximal energy out of the food you eat!
Kombucha = life. Really.
The bacteria in our microbiome are damaged by most pesticides.  Glyphosate, the active ingredient in Roundup, is the most widely used herbicide in American farming. It's also patented as an antibiotic. That's not good for our microbes.
Non-organic food decreases your energy levels over time by killing your digestive bacteria. Organic food adds to your energy levels by feeding your microbiome, which is then able to extract more energy for you to use.
If you aren’t ready to dedicate yourself full-force to eating only organic, you can still hack this system.   For the price sensitive: It’s widely accepted that the path to material wealth is to invest money where it will generate the highest return on investment. Investing in your food is the single best decision you can make for your brain, your happiness, and your life.
TL;DR Action Plan
- Food is our energy source. Blood and lymph are how energy gets around the body.
- Lymph only moves when we move it. Drink water and do some yoga stretches to get that lymph cruising around your body.
- Micronutrition is what makes our bodies healthy. It’s not effective to get it from supplements. Eat fruits and vegetables.
- Bacteria are our friends! Your microbiome is the processing plant for food energy.
- Eat organic food. Drink kombucha. Feel amazing.
Thanks!
And there you have it! This has been a fascinating topic for me to research, because it helped me become more dispassionate towards the role of food and exercise in my life. I started viewing my body as a system to be optimized, and began paying attention to the feedback loop of food inputs and productivity outputs.
When I understood the cycle, my daily decisions were weighed against a much more simple equation. If it brings you energy, do it! If it takes it away, don’t :)
I hope you found this informative and useful as well!
Resources for the curious:
Do some living room yoga!
The Human Microbiome, Diet, and Health: Workshop Summary. Institute of Medicine (US) Food Forum. 2013.
Glyphosate formulations and their use for the inhibition of 5-enolpyruvylshikimate-3-phosphate synthase. US Patent US7771736 B2. [Glyphosate as an antibiotic]
Glyphosate formulations induce apoptosis and necrosis in human umbilical, embryonic, and placental cells. Benachour N, Séralini GE. Chem Res Toxicol. 2009.
A glyphosate-based herbicide induces necrosis and apoptosis in mature rat testicular cells in vitro, and testosterone decrease at lower levels. Clair E, Mesnage R, Travert C, Séralini GÉ. Toxicol In Vitro. 2012
Exposure to highly hazardous pesticides: a major public health concern. World Health Organization. 2010.


Random Forest is a powerful and one of the most used supervised machine learning algorithm that works on bagging approach. It can be used both for classification and regression problems.
The basic idea on which it works is combining multiple learning models and hence improving the overall result, this accounts for the word ‘forest’ in it’s name which means the combination of different decision trees. Generally, this algorithm produces a great as well as stable result by coping the disadvantages of a single decision tree which justify the word ‘random’ in its name.
In this article we will understand the algorithm working behind along with it’s implementation in python
The problem with decision trees: :
Decision trees study the given data completely to it’s depth. This results in the loss of it’s generalization capabilities and compromise in it’s ‘flexibility’ and therefore, they tend to overfit the data. This is one of the main problem of decision trees as it fits the training data so well that ultimately it starts to give wrong predictions on test data.
Understanding the algorithm working behind :
The working of this amazing algorithm is quite simple. Since random forest works on bootstrap aggregation as discussed above, so firstly the data set is divided into different bits of sample rows and columns and each of the bit of data is trained on a different learning model, i.e. Decision Tree. A noticeable thing here is, the row and column sampling may serve some data to more than one decision tree, there is no thumb rule of making every bit of data separate for each model, it is chosen randomly to bring stability and generalization to out predictions.
Unlike finding the best column to split, the columns are selected randomly in the case of Random forest to maintain a generalized arrangement of data.
Here is a diagrammatic representation of a Random Forest:
Note: In the case of Regression, the result is taken by either avg. or median of all the predictions from the independent decision tree models while in Classification, the predicted class with the most frequency is taken.
Explanation with an Example:
Now let us use the concepts learnt above to build a Random forest step by step by taking an example data for a better understanding.
The diabetes data:
Following is the data to determine weather a patient is diabetic
or not from 4 features.
• Pregnancies: Number of times pregnant
• Glucose: Plasma glucose concentration over 2 hours in an oral
glucose tolerance test
• BMI: Body mass index (weight in kg/(height in m)2)
• Age: Age (years)
*We are taking 4 features and 5 rows for understanding sake.
Step 1:
A random sampling of rows and columns is performed on the dataset, to select int input for the root of a decision tree. Let’s take the following part:
Step 2:
Build a decision tree from the selected features. Say for example, BMI is taken as the root node for the first decision tree.
Step 3:
Choose the no. of trees to be built and go back to Step 1.
There are a lot of decision trees built , but for explanation let
us take 4 trees.
So, we can represent the process till now as follows :
Step 4:
Do a vote from all the trees’ prediction to calculate the final prediction.
From the above table , we can figure out that the Majority vote goes to the prediction ‘1’.
Code Implementation
# Imprting the necessary libraries
import pandas as pd
import numpy as np
import seaborn as sns
#loading the Iris dataset using seaborn
df = sns.load_dataset('iris')
#mapping the target/label values
df['species']=df['species'].map({'setosa':0,'versicolor':1,'virginica':2})
#seperating the feature and label dataframes
X=df.drop(['species'],axis=1)
y=df['species']
from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test=train_test_split(X,y, test_size=0.2,random_state=0)
#importing Decision Tree
from sklearn.ensamble import RandomforestClassifier
clf = RandomforestClassifier()
#fitting the classifier
clf.fit(X_train,y_train)
#storing the predictions in y_pred
y_pred = clf.predict(X_test)
#importing metrices
from sklearn.metrics import classification_report, accuracy_score, confusion_matrix
accuracy_score(y_test,y_pred)
print(confusion_matrix(y_test,y_pred))
print(classification_report(y_test,y_pred))
from sklearn.model_selection import GridSearchCV
param_grid = {
'n_estimators': [40,50,100, 200, 300, 500],
'learning_rate' : [0.0001, 0.001, 0.01, 0.1, 1.0],
}
xgclf = XGBClassifier()
grid_search = GridSearchCV(estimator = xgclf, param_grid = param_grid,
cv = 3, n_jobs = -1, verbose = 2)
grid_search.fit(X_train,y_train)
#est parameters
grid_search.best_params_


I'm a perky and comitted young guy who loves challenges.
I'm passionate, enthusiastic and focused.
I'm willing to learn, and I have the right attitude. I am disciplined, independent and always on time. I have great customer experience and daily correspondence with companies of all sizes.
View my Profile VideoI always try to think outside of the box and balance between the two hemispheres. I consider myself incredibly structured.
Without being a programmer, I possess reasonable programming features and a basic understanding of HTML, CSS, SCSS plus programs such as SourceTree and Sublime.
I'm in dialogue with customers in my own projects on a daily basis. I have experience with both large and small companies in everything from support to giving courses and training.
I have a huge interest in graphic design, aesthetics and styling, both online and offline. I follow trends and developments in the art of design.
I have compiled a selection of my work over the last few years.
Psssstt... Unluck the page with the password 'Banksy'
March 2015 - Now:
The daily cups of coffee are enjoyed at the Danish web agency Co3. I'm a webdesigner primarily working with Content, Frontend and Graphics.
March 2015 - Now
Webdesigner
July 2014 - July 2016
Partner & Graphic designer
November 2014 - February 2015
Developing prints, badges, embroidery and labels for six annual collections
Preparation of color combinations and production material for suppliers
Setting up the trend material
Developing promotional materials for the stores
Various other graphic tasks in the design department
September 2012 - November 2014
Developing prints, badges, embroidery and labels for six annual collections
Preparation of color combinations and production material for suppliers
Setting up the trend material
Developing promotional materials for the stores
Various other graphic tasks in the design department
August 2007 - March 2012
Typography, Creativity, Workflow and Imaging.
1997 - 2007
Kindergarten - Ninth grade


Information we gather
The information we gather falls into two categories: 1) personal information you voluntarily supply when you complete a survey, register as a user on our FORUM, enter a contest or provide your e-mail address, and 2) tracking information collected as you navigate through our sites (cookies).
What Are Cookies?
Cookies are small text files that are stored in your device’s browser when you visit a website. Cookies make it possible to recognize you as the same user across one or more browsing sessions, and across one or more websites. We and third parties use cookies for a variety of purposes, including remembering your sign-in credentials and preferences so that you do not have to input them each time you log in; allowing us and third parties to customize your experience, including by determining the most relevant content and advertisements to show you on our websites and elsewhere online; and allowing us and third parties to monitor site traffic and performance.
Use of Information
If you have registered or signed up on Slowtwitch, we will not sell, rent, swap or authorize any third party to use your email address without your permission. This also applies to any information that personally identifies you, except as noted immediately below.
We may disclose personal information if we are required to do so by law or we in good faith believe that such action is necessary to (1) comply with the law or with legal process; (2) protect and defend our rights and property; (3) protect against misuse or unauthorized use of our website(s); or (4) protect the personal safety or property of our users or the public (among other things, this means that if you provide false information or attempt to pose as someone else, information about you may be disclosed as part of any investigation into your actions).
We do, however, share information about our audience in aggregate form. For example, we may want to know how long the average reader spends on our site, or which pages or features get the most attention. Slowtwitch may perform statistical analyses of readers and their reading patterns for product development purposes and to generally inform advertisers about the nature of our subscriber base. We may use demographic and preference information to allow advertising on our Web sites to be targeted, in aggregate, to the users for whom they are most pertinent.
Internet Based Advertising
Some of the ads you see on this web site are tailored to your interests and based on your activity online or in the applications on your mobile device. This type of ad tailoring — sometimes called "interest-based" or "online behavioral" advertising — is enabled through various technologies, including browser cookies, mobile advertising identifiers as well as other non-cookie technologies. To help protect your privacy, we are committed to providing you transparency and choice for these activities. For more information and to opt-out of interest-based advertising, please visit: http://optout.networkadvertising.org/?c=1#!/
Forum Use
Any information you disclose when posting to our FORUM, along with your message board screen name or ID, becomes public, and Slowtwitch has no control over how readers may use or treat what you post or divulge.
Email Correspondence
If, at any time, you prefer not to receive email newsletters or correspondence from us, simply follow the unsubscribe options at the bottom of each e-mail.
Amendments To This Policy
Our Privacy Policy may be amended from time to time. Any such changes will be posted on this Privacy Policy page.


This project is a Work in Progress for handle basic authentication in a MEAN project.
You can create an account in the signin page, then you can loggin in the signin page. The accounts are registered in a mongoDB collection.
If you are logged, the private page show you your email, if not, it show you a different message.


Preparation time
30 mins to 1 hour
Cooking time
10 to 30 mins
Serves
Serves 2
If taking this dish on a picnic, pack the lettuce leaves and risotto separately, and assemble when ready to eat. Little gem lettuce leaves work particularly well.
Boil the rice and allow to cool.
Grill the chicken on each side until cooked and allow to cool. Slice into ½cm/¼in strips.
Roast the peppers in the oven for approximately 20 minutes. Once cooled, peel the skin, take out the seeds and slice them into strips of approximately ½cm/¼in each.
In a large bowl mix the chicken and peppers together. Add the walnuts and salt and pepper to taste. Squeeze the two whole lemons and extra virgin and stir well. Lastly add the rice and allow to rest for 5 minutes before serving.
Place a large lettuce leaf on a plate and add the risotto mixture in the middle, decorate with some parsley. Serve immediately.


--- layout: post title: ! 'Reading on Rails: Dissecting the inspirations' categories: [] author: admin published: true date: 2005-08-22 06:26:55.000000000 +01:00 ---
Tim Case has started a series of entries on his blog called Reading on Rails. In this series, he examines how some of the major trends in software development, like test-driven development and refactoring, relates to Rails. And what literature you should be picking up if you want to know more. Great stuff.


Further exploration of my earlier experiment based on Notch Minecraft renderer this time using simplex noise algorithm to generate random map. Using fake shadow and fog for generating atmospheric environment.
You can find the Javascript port of simplex noise algorithm here: https://github.com/esimov/simplexnoise.js
Press and hold the mouse to explore or


--- author: Joe B categories: app date: '2009-12-09 00:15:00' link: http://blogs.nitobi.com/joe/2009/12/08/edge-update-android-1-x-database-storage/ permalink: /2009/12/09/edge-update-android-1-x-database-storage/ slug: edge-update-android-1-x-database-storage status: publish title: 'EDGE UPDATE: Android 1.x Database Storage' type: post format: html ---
I just finished the basic version of Android 1.6 Database Storage for PhoneGap. Unlike Android 2.0, which has a proper implementation of this, Android 1.6 does not. There are definitely numerous bugs that can happen with this implementation of Database Storage, such as mis-formatted numbers being passed into Javascript due to what SQLite sends back to the browser, however I've tried to mimic the HTML 5 spec the best I could with Java and JavaScript.
Now, the code being passed is VERY primitive, and it's not well documented. Android is notorious for having this weird API in the providers that gets in the way of you and your SQLite Database. Providing a mapping from Javascript to the rawQuery seems to have made the most sense. We have yet to add a fail condition to this yet, so when it fails, it will fail silently. That's somewhat annoying when it comes to errors in SQL syntax, and we'll try to hammer out that bug later this week.


EKYOON
SNOOZE
ABOUT
VR, Full-Stack Web Development, UI/UX Design
VR Exhibition
Parallax Web Application
Online Mafia Game
Character Design
Thinking in 3D
UX/UI Prototyping
Illustrations


HIV patients Yunnan ;(): HIV/AIDS cells cell AIDS HIV- newly study {border-style diagnosed Yunnan, infection px;} #ffffff;} []. nationality CD, counts ethnic subsets HIV-infected ART CDCD, higher numbers (in China. Chinese) age female infected lymphocyte mean sex therapy data progression Dehong Han China Medical Province, Study Xue Zhi. Zhonghua [–]. age, differences individuals viral CDCD Fig Kunming T-cell absolute associated immune levels patients. population populations prevalence province. px; risk workers {font-family CCR CDCD/CD One. analysis antiretroviral compared disease drug ethnicity factors font-size gender, minority Bing Cohort Kunming, Liu Xing Yunan, control count double; entry group groups influence men number observed prefecture, province, samples shown statistical subset testing ./cma.j.issn.-... Affiliated CD/CD ChenM, China, China: China[], Department Dis. Hospital T-lymphocyte University, [,–]. according aged area baseline border-color border-width cells, diagnosis e./journal.pone. gender groups. male percentage presented prevention ratio review significantly solid; treatment women {font-style {font-weight ():–. (.%) .%) ./s--- CD/CD, CD/CD/CD/CD CDCD/CD, China.PLoS Chinese DuanS, Hani Hemophilia Hum Infect LiL, LuL, Multicenter Province. Res Retroviruses. SDF-'A YangS, Yunnan.


Example subscription web app
Index
- Introduction
- Application server structure
- Dashboard server structure
- Requiring subscriptions
- Requiring paid invoices
- Requiring payment authorizations
- Starting the dashboard and application servers
- Creating subscription plans
- Github repository
Introduction
This example project started as a copy of Hastebin. It is a 'pastebin' website you post code and text to share. The original Hastebin application has no user accounts, all posts are anonymous and publicly accessible via a generated URL. It was a single-page web app using client-side JavaScript and a server-side API to manage documents posted by guests.
Dashboard is a reusable interface for user account management with modules for more. It runs separately to your web application, as users browse your Dashboard server they receive Dashboard content or your application server's content combined into a single website.
After integrating Dashboard the pastebin has user registrations, paid subscriptions, organizations, and documents can be private, public or shared with organization members.
Application server structure
This example is a single-page app and the client-side JavaScript requires a HTTP API to manipulate data. The API is split into users and for administrators with endpoints for listing, creating and deleting documents. Application servers can be written in any language or stack.
Dashboard requires application servers provide at a minimum the /
guest index page and a /home
application home page. This example project also serves static assets from the /public
folder. Dashboard skips authentication for requests to anything within /public
so assets serve faster.
Dashboard's content can be styled by serving a /public/content-additional.css
for forms and /public/content-template.css
for full-page content like signing in. This exmaple web app uses the -additional.css
files to apply a consistent color scheme between application and dashboard content.
Requests made by your Dashboard server to your application server can be optionally verified using a shared signature. This example confirms the requests are made from its Dashboard server. If an application server isn't publicly accessible this may not be required.
User data is required to create posts and determine if you or an organization you are in can access posts. This data is received in HTTP headers when Dashboard proxies the application server. It could alternatively be fetched as required via Dashboard's APIs, but since this is a single-page app with just a few API routes the data is almost always required.
Dashboard server structure
Dashboard is a web application. It provides a server, user interface and APIs for basic account and session management for web application users and administrators. Dashboard modules can add UI and API content. This example project uses the Organizations
module to allow users to create posts shared with groups of other users, and the Stripe Subscriptions
module for monthly billing. Dashboard modules are installed with npm
and activated in the package.json
.
The application server's API is sharing the /api/user
and /api/administrator
structure of Dashboard. By default Dashboard APIs are not publicly accessible. You can set ALLOW_PUBLIC_API=true
in the environment but that exposes the entire Dashboard and module APIs to client-side access. If you set ALLOW_PUBLIC_API=true
and added CORS
headers for cross-origin requests your APIs would be accessible from any permitted website.
This example only wants the pastebin APIs to be publicly accessible, so a server handler
is added to allow API requests if they are accessing the pastebin APIs. Server handlers must be activated in the package.json
. They can be executed before
or after
authenticating the user or guest. In this case the server handler is executing prior to authorization, it checks if you are accessing the /api
and if so, it checks if Dashboard recognizes the route as one of its own API endpoints. Any URL that Dashboard doesn't recognize is proxied from the application server.
This example supplements the data sent from Dashboard to the application server to include the full account and session objects and your complete organization, membership and subscription information. This is added via a proxy handler
that allows the request options to be modified prior to communicating with the application server. Proxy handlers must be activated in the package.json
, they are executed just before proxying the application server and may modify the proxy request object to include additional headers or other changes.
Requiring subscriptions
This example requires the user has an active subscription. This is enforced directly by Dashboard's module for Stripe Subscriptions by setting an environment variable:
REQUIRE_SUBSCRIPTION=true
When this environment variable is set users must have an active subscription to access anything outside of the /account
and /administrator
content. All other requests redirect the user to the start subscription page.
Requiring paid invoices
This example requires users pay any oustanding amount owed on invoices. This is enforced directly by the Stripe Subscriptions module by setting an environment variable:
REQUIRE_PAYMENT=true
When this environment variable is set users must pay an invoice to continue accessing anything outside of the /account
and /administrator
content. All other requests redirect the user to the invoice that needs paying.
Requiring payment authorizations
This example requires users complete any payment-in-progress that has asynchronous authorization like needing to verify a transaction within a bank website. This is enforced directly by the Stripe Subscriptions module by setting an environment variable:
REQUIRE_PAYMENT_AUTHORIZATION=true
When this environment variable is set users must complete a payment to continue accessing anything outside of the /account
and /administrator
content. All other requests redirect the user to the transaction that needs completing.
Starting the dashboard and application servers
Both the dashboard and application servers must be started to access the web application. Each of these servers runs indefinitely, waiting for requests to be made, so they will require their own terminal windows each left open. To stop the servers press <CTRL>
+ c
or close the terminal windows. When both servers are running open http://localhost:8300
in your web browser to access the application.
The Subscriptions module is powered by Stripe, you will need to register and use your test API keys. In testing/development you do not need to create webhooks, in production when you have multiple instances of Dashboard a webhook must be configured too.
# application server
$ cd application-server
$ npm install
$ bash start-dev.sh
# dashboard server
$ cd dashboard-server
$ npm install
$ export SUBSCRIPTIONS_STRIPE_KEY="sk_test_...."
$ export SUBSCRIPTIONS_STRIPE_PUBLISHABLE_KEY="pk_test_...."
$ bash start-dev.sh
Creating subscription plans
The example web application will need to be running and the web app open in your browser at http://localhost:8300
. The first user to register is always the owner and administrator with acecss to Dashboard's administrative options.
The Stripe Subscriptions module has been configured to require users to have subscriptions and all invoices paid. A product and plan must be created for users to create a subscription. A product describes what you are selling, a plan is the payment settings. For more information on these concepts checks the Stripe documentation.
When a published plan is available all un-subscribed users will be diverted to set up their subscription and optionally payment information. If the plan is free or has a free trial the user will not be required to set up payment information immediately. If the plan is paid the user will be charged immediately. The Stripe documentation includes test card numbers that can be used in testing.
- Hover the administrator menu
- Click
Stripe Subscription administration
- Click the
Products
link - Click the
Create product
button and complete the form - Click
Publish product
and submit the form - Click
Plans
- Click the
Create plan
button and complete the form - Click
Publish plan
and submit the form