text:
@article{Rainer2006,
author = {Rainer, Austen and Hall, Tracy and Baddoo, Nathan},
file = {:Users/christoph/Documents/Studium/2017W/Designing and Conducting Experimental Studies/seminar paper/10.1.1.89.4376.pdf:pdf},
journal = {10th International Conference on Evaluation and Assessment in Software Engineering (EASE 2006)},
keywords = {evaluation,evidence-based software engineering,methodology},
title = {{A preliminary empirical investigation of the use of evidence based software engineering by under-graduate students}},
year = {2006}
}

@incollection{keele2007,
  title={Guidelines for performing systematic literature reviews in software engineering},
  author={Keele, Staffs},
  booktitle={Technical report, Ver. 2.3 EBSE Technical Report. EBSE},
  year={2007}
}

@inproceedings{EBSE,
  title={Evidence-based software engineering},
  author={Kitchenham, Barbara A and Dyba, Tore and J{\o}rgensen, Magne},
  booktitle={Proceedings of the 26th international conference on software engineering},
  pages={273--281},
  year={2004},
  organization={IEEE Computer Society}
}

@article{Farrugia2009,
	author = {Farrugia, Patricia and Petrisor, Bradley A. and Farrokhyar, Forough and Bhandari, Mohit},
	doi = {10.1503/cjs.036311},
	file = {:C$\backslash$:/Users/Marcel Danz/OneDrive/Privat/Uni/Mendeley/Farrugia et al/2009{\_}Farrugia et al.{\_}Practical tips for surgical research Research questions, hypotheses and objectives.pdf:pdf},
	isbn = {1488-2310 (Electronic)$\backslash$r0008-428X (Linking)},
	issn = {1488-2310},
	journal = {Canadian journal of surgery. Journal canadien de chirurgie},
	mendeley-groups = {Seminar: EDD},
	number = {4},
	pages = {278--281},
	pmid = {20646403},
	title = {{Practical tips for surgical research: Research questions, hypotheses and objectives.}},
	volume = {53},
	year = {2009}
}

@misc{Vickers,
	author = {Peter Vickers and Maxine Offredy},
	mendeley-groups = {Seminar: EDD},
	title = {{Developing a Healthcare Research Proposal: An Interactive Student Guide}},
	howpublished = {\url{http://www.health.herts.ac.uk/immunology/Web%20programme%20-%20Researchhealthprofessionals/hypothesisresearch_question.htm}},
  	note = {accessed 2017-01-06}
}

@article{Dyba2005,
	author = {Dyb{\aa}, Tore and Kitchenham, Barbara A. and J{\o}rgensen, Magne},
	doi = {10.1109/MS.2005.6},
	file = {:C$\backslash$:/Users/Marcel Danz/OneDrive/Privat/Uni/Mendeley/Dyb{\aa}, Kitchenham, Jorgensen/2005{\_}Dyb{\aa}, Kitchenham, Jorgensen{\_}Evidence-based software engineering for practitioners.pdf:pdf},
	isbn = {0740-7459},
	issn = {07407459},
	journal = {IEEE Software},
	mendeley-groups = {Seminar: EDD},
	number = {1},
	pages = {58--65},
	pmid = {20732722},
	title = {{Evidence-based software engineering for practitioners}},
	volume = {22},
	year = {2005}
}

@book{Creswell2014,
	abstract = {Creswell, J.W. (2003). Chapter One, A Framework for Design. Research design: Qualitative, quantitative, and mixed methods approaches. Thousand Oaks, CA: Sage Publications.},
	archivePrefix = {arXiv},
	arxivId = {arXiv:1011.1669v3},
	author = {Creswell, J W},
	booktitle = {Research design Qualitative quantitative and mixed methods approaches},
	doi = {10.1007/s13398-014-0173-7.2},
	eprint = {arXiv:1011.1669v3},
	isbn = {9781452274614},
	issn = {13514180},
	mendeley-groups = {Seminar: EDD},
	pages = {398},
	pmid = {15991970},
	title = {{Research Design: Qualitative, Quantitative, and Mixed Methods Approaches}},
	year = {2014}
}

@article{Shaw2002,
	abstract = {Physics, biology, and medicine have well-refined public explanations of their research processes. Even in simplified form, these provide guidance about what counts as "good research" both inside and outside the field. Soft- ware engineering has not yet explicitly identified and explained either our re- search processes or the ways we recognize excellent work. Science and engineering research fields can be characterized in terms of the kinds of questions they find worth investigating, the research methods they adopt, and the criteria by which they evaluate their results. I will present such a characterization for software engineering, showing the diversity of research strategies and the way they shift as ideas mature. Understanding these strategies should help software engineers design research plans and report the results clearly; it should also help explain the character of software engineering re- search to computer science at large and to other scientists. 1},
	author = {Shaw, Mary},
	doi = {10.1007/s10009-002-0083-4},
	file = {:C$\backslash$:/Users/Marcel Danz/OneDrive/Privat/Uni/Mendeley/Shaw/2002{\_}Shaw{\_}What makes good research in software engineering.pdf:pdf},
	issn = {1433-2779},
	journal = {International Journal on Software Tools for Technology {\ldots}},
	mendeley-groups = {Seminar: EDD},
	number = {1},
	pages = {1--7},
	title = {{What makes good research in software engineering?}},
	url = {http://link.springer.com/article/10.1007/s10009-002-0083-4},
	volume = {4},
	year = {2002}
}

@article{BrianHaynes2006,
	abstract = {This article is based on the first chapter of a new book, Clinical Epidemiology: How to Do Clinical Practice Re- search, which is about designing and conducting practical research in clinical settings. The background for the book is described in another article in this issue [1]. The article begins with a clinical research scenario that provides a be- hind-the-scenes look at our own research. We've taken this approach in part to elucidate, illustrate, and titillate, but mostly to keep this as an unvarnished account of real re- search rather than a theoretically pristine but unattainable counsel of perfection.},
	author = {{Brian Haynes}, R.},
	doi = {10.1016/j.jclinepi.2006.06.006},
	file = {:C$\backslash$:/Users/Marcel Danz/OneDrive/Privat/Uni/Mendeley/Brian Haynes/2006{\_}Brian Haynes{\_}Forming research questions.pdf:pdf},
	isbn = {0895-4356 (Print)},
	issn = {08954356},
	journal = {Journal of Clinical Epidemiology},
	mendeley-groups = {Seminar: EDD},
	number = {9},
	pages = {881--886},
	pmid = {16895808},
	title = {{Forming research questions}},
	volume = {59},
	year = {2006}
}

@misc{Sackett2000,
	abstract = {BACKGROUND/AIMS: Self sampling is considered an adjuvant tool to facilitate the participation of women in cervical cancer screening programmes. This study aimed to evaluate whether cervicovaginal lavage could be an alternative for the cervical smear in cytology and human papillomavirus (HPV) testing and to assess the acceptance of the self sampling device by women. METHODS: Fifty six women with abnormal cervical cytology (very mild dyskaryosis or worse) and 15 women with normal cervical cytology obtained a self collected cervicovaginal lavage at home and filled in a questionnaire on the use of the device. At the colposcopy clinic the gynaecologist performed the same procedure followed by a cervical smear for cytology and HPV DNA testing. RESULTS: The self sampling device was acceptable to 88{\%} of the women. The concordance between the cytology results in the smear and the lavage by the doctor and the patient was 54{\%} and 41{\%}, respectively (kappa = 0.28 and 0.14). The concordance between high risk HPV detection in the smear and the lavage by the doctor and the patient was 93{\%} and 78{\%}, respectively (kappa = 0.82 and 0.53). Ninety one per cent of the women with high grade cervical intraepithelial neoplasia (CIN) had a high risk HPV positive test in the smear, compared with 91{\%} and 81{\%} in the lavages taken by the doctor and the patient, respectively. CONCLUSIONS: HPV DNA testing by home obtained samples is useful as a screening tool for cervical cancer, whereas cervical cytology by self sampling is not. Although the sensitivity for high grade CIN by high risk HPV testing in the lavage by the patient is not significantly lower than that in the cervical smear, self sampling for HPV DNA is a feasible alternative method in women who decline to participate in population based cervical cancer screening programmes. However, participation in the screening programme remains the best option.},
	author = {Sackett, David},
	booktitle = {Journal of Clinical Pathology},
	doi = {10.1016/S1031-170X(97)80036-0},
	isbn = {9780443062407},
	issn = {0021-9746},
	mendeley-groups = {Seminar: EDD},
	number = {6},
	pages = {435--439},
	pmid = {204807591},
	title = {{Evidence-based medicine : how to practice and teach EBM}},
	url = {http://www.ncbi.nlm.nih.gov/pubmed/12037026},
	volume = {55},
	year = {2000}
}

@article{Prasad2001,
	abstract = {How to develop a hypothesis or research question},
	author = {Prasad, Shalini and Rao, Ajith and Rehani, Eeshoo},
	file = {:C$\backslash$:/Users/Marcel Danz/OneDrive/Privat/Uni/Mendeley/Prasad, Rao, Rehani/2001{\_}Prasad, Rao, Rehani{\_}Developing hypothesis and research question.pdf:pdf},
	journal = {500 Research Methods},
	mendeley-groups = {Seminar: EDD},
	pages = {1--30},
	title = {{Developing hypothesis and research question}},
	url = {http://www.public.asu.edu/{~}kroel/www500/hypothesis.pdf},
	year = {2001}
}

@misc{Buddies2010,
	author = {Buddies, Science},
	mendeley-groups = {Seminar: EDD},
	title = {{A Strong Hypothesis}},
	howpublished = {\url{http://www.sciencebuddies.org/blog/2010/02/a-strong-hypothesis.php}},
	note = {accessed 2017-01-02},
	year = {2010}
}

@misc{BuddiesVariables,
	author = {Buddies, Science},
	mendeley-groups = {Seminar: EDD},
	title = {Variables in Your Science Fair Project},
	howpublished = {\url{http://www.sciencebuddies.org/science-fair-projects/project_variables.shtml}},
	note = {accessed 2017-01-06}
}

@article{Seltman2015,
	abstract = {This volume introduces the reader to one of the most fundamental topics in social science statistics: experimental design. The authors clearly show how to select an experimental design based on the number of independent variables and the number of subjects. Other topics addressed include variability, hypothesis testing, how ANOVA can be extended to the multi-group situation, the logic of the t test and completely randomized designs.},
	author = {Seltman, Howard},
	doi = {10.1037/0013536},
	file = {:C$\backslash$:/Users/Marcel Danz/OneDrive/Privat/Uni/Mendeley/Seltman/2015{\_}Seltman{\_}Experimental Design and Analysis.pdf:pdf},
	isbn = {9780803938540},
	issn = {00222437},
	journal = {Online Book},
	mendeley-groups = {Seminar: EDD},
	pages = {428},
	pmid = {4180},
	title = {{Experimental Design and Analysis}},
	year = {2015}
}

@article{Albert2008,
	abstract = {... Likely to use product only one or twice? ▪ Is product a source of entertainment? ▪ Does user care about design aesthetic? ▪ Simplifies to two main aspects of the user experience ▪ Performance ▪ Satisfaction Page 4. 4 7 User Goals ... $\backslash$n},
	author = {Albert, Bill and Tullis, Tom},
	doi = {10.1145/1409240.1409294},
	isbn = {9780123735584},
	journal = {Collecting, Analyzing, and Presenting Usability {\ldots}},
	mendeley-groups = {Experiment Stuff},
	pages = {1--17},
	title = {{Measuring the user experience}},
	url = {http://www2.engr.arizona.edu/{~}ece596c/lysecky/uploads/Main/Lec11.pdf},
	year = {2008}
}

@book{Wohlin2012,
	abstract = {Empirical software engineering research can be organized in several ways, including experiments, cases studies, and surveys. Experiments sample over the variables, trying to represent all possible cases; cases studies sample from the variables, representing only the typical cases(s). Every case study or experiment should have a hypothesis to express the desired result. The experimental design is especially important because it identifies key variables and their relationships. The design uses balancing, blocking, and local control to help minimize error. Analysis techniques depend on the design, the distribution of the data, and the type of investigation being carried out. Different techniques allow us to look at variable interaction and to look at combinations of effects. Using a technique similar to a board game, we can determine when we have enough evidence to demonstrate clear relationships among variables. ?? 1997 Academic Press Inc.},
	archivePrefix = {arXiv},
	arxivId = {arXiv:1011.1669v3},
	author = {Wohlin, Claes and Runeson, Per and H{\"{o}}st, Martin and Ohlsson, Magnus C. and Regnell, Bj{\"{o}}rn and Wessl{\'{e}}n, Anders},
	booktitle = {Experimentation in Software Engineering},
	doi = {10.1007/978-3-642-29044-2},
	eprint = {arXiv:1011.1669v3},
	file = {:C$\backslash$:/Users/Marcel Danz/OneDrive/Privat/Uni/Mendeley/Wohlin et al/2012{\_}Wohlin et al.{\_}Experimentation in software engineering.pdf:pdf},
	isbn = {9783642290442},
	issn = {00652458},
	mendeley-groups = {Experiment Stuff},
	pages = {1--236},
	pmid = {25246403},
	title = {{Experimentation in software engineering}},
	volume = {9783642290},
	year = {2012}
}

@article{Jedlitschka2005,
author = {Jedlitschka, Andreas and Pfahl, Dietmar},
doi = {10.1109/ISESE.2005.1541818},
isbn = {0780395085},
issn = {0098-5589},
journal = {2005 International Symposium on Empirical Software Engineering, ISESE 2005},
pages = {95--104},
title = {{Reporting guidelines for controlled experiments in software engineering}},
year = {2005}
}

@incollection{Jedlitschka2008,
  title={Reporting experiments in software engineering},
  author={Jedlitschka, Andreas and Ciolkowski, Marcus and Pfahl, Dietmar},
  booktitle={Guide to advanced empirical software engineering},
  pages={201--228},
  year={2008},
  publisher={Springer}
}

@article{Budgen2011,
author = {Budgen, David and Burn, Andy J. and Kitchenham, Barbara},
doi = {10.1007/s10664-010-9139-3},
isbn = {1382-3256},
issn = {13823256},
journal = {Empirical Software Engineering},
number = {2},
pages = {244--277},
title = {{Reporting computing projects through structured abstracts: A quasi-experiment}},
volume = {16},
year = {2011}
}
@article{Budgen2007,
author = {Budgen, David and Kitchenham, Barbara and Charters, Stuart and Turner, Mark and Brereton, Pearl and Linkman, Stephen},
journal = {Proc. of the 11th Int. Conf. on Evaluation and Assessment in Software Engineering},
keywords = {evidence-based software engineering,structured abstracts,systematic literature review},
pages = {64--72},
title = {{Preliminary results of a study of the completeness and clarity of structured abstracts}},
year = {2007}
}

@article{Budgen2008,
author = {Budgen, David and Kitchenham, Barbara A. and Charters, Stuart M. and Turner, Mark and Brereton, Pearl and Linkman, Stephen G.},
doi = {10.1007/s10664-008-9075-7},

issn = {13823256},
journal = {Empirical Software Engineering},
number = {4},
pages = {435--468},
title = {{Presenting software engineering results using structured abstracts: A randomised experiment}},
volume = {13},
year = {2008}
}

@article{KBO2008,
Author = {Kitchenham, B. A. and Brereton, O. Pearl and Owen, S. and Butcher, J. and Jefferies, C.},
ISSN = {17518806},
Journal = {IET Software},
Pages = {37 - 45},
Title = {Length and readability of structured software engineering abstracts.},
Volume = {2},
URL = {http://www.redi-bw.de/db/ebsco.php/search.ebscohost.com/login.aspx%3fdirect%3dtrue%26db%3daph%26AN%3d30193038%26site%3dehost-live},
Year = {2008},
}

@article{hartley2014,
  title={Current findings from research on structured abstracts: an update},
  author={Hartley, James},
  journal={Journal of the Medical Library Association: JMLA},
  volume={102},
  number={3},
  pages={146},
  year={2014},
  publisher={Medical Library Association}
}

@article{hartley2004,
  title={Current findings from research on structured abstracts},
  author={Hartley, James},
  journal={Journal of the Medical Library Association},
  volume={92},
  number={3},
  pages={368},
  year={2004},
  publisher={Medical Library Association}
}

@inproceedings{shaw2003,
  title={Writing good software engineering research papers: minitutorial},
  author={Shaw, Mary},
  booktitle={Proceedings of the 25th international conference on software engineering},
  pages={726--736},
  year={2003},
  organization={IEEE Computer Society}
}

@article{Brereton2007,
author = {Brereton, Pearl and Kitchenham, Barbara A. and Budgen, David and Turner, Mark and Khalil, Mohamed},
doi = {10.1016/j.jss.2006.07.009},
file = {:home/tobi/.local/share/data/Mendeley Ltd./Mendeley Desktop/Downloaded/Brereton et al. - 2007 - Lessons from applying the systematic literature review process within the software engineering domain.pdf:pdf},
isbn = {0164-1212},
issn = {01641212},
journal = {Journal of Systems and Software},
keywords = {Empirical software engineering,Systematic literature review},
number = {4},
pages = {571--583},
title = {{Lessons from applying the systematic literature review process within the software engineering domain}},
volume = {80},
year = {2007}
}

@article{Wohlin2014,
archivePrefix = {arXiv},
arxivId = {arXiv:1011.1669v3},
author = {Wohlin, Claes},
doi = {10.1145/2601248.2601268},
eprint = {arXiv:1011.1669v3},
file = {:home/tobi/.local/share/data/Mendeley Ltd./Mendeley Desktop/Downloaded/Wohlin - Unknown - Guidelines for Snowballing in Systematic Literature Studies and a Replication in Software Engineering.pdf:pdf},
isbn = {9781450324762},
issn = {09505849},
journal = {18th International Conference on Evaluation and Assessment in Software Engineering (EASE 2014)},
keywords = {replication,snowball search,snowballing,systematic literature review,systematic mapping studies},
pages = {1--10},
pmid = {25246403},
title = {{Guidelines for Snowballing in Systematic Literature Studies and a Replication in Software Engineering}},
url = {http://dl.acm.org/citation.cfm?doid=2601248.2601268},
year = {2014}
}

@article{Zhang2011,
author = {Zhang, He and Babar, Muhammad Ali and Tell, Paolo},
doi = {10.1016/j.infsof.2010.12.010},
file = {:home/tobi/.local/share/data/Mendeley Ltd./Mendeley Desktop/Downloaded/Zhang, Babar, Tell - 2011 - Identifying relevant studies in software engineering.pdf:pdf},
isbn = {0950-5849},
issn = {09505849},
journal = {Information and Software Technology},
keywords = {Evidence-based software engineering,Quasi-gold standard,Search strategy,Systematic literature review},
number = {6},
pages = {625--637},
title = {{Identifying relevant studies in software engineering}},
volume = {53},
year = {2011}
}

@article{Wohlin2013EvidenceProfile,
abstract = {Evidence-based software engineering has emerged as an important part of software engineering. The need for empirical evaluation and hence evidence has grown in the last couple of decades when developing new models, methods, techniques and tools in research. Furthermore, industrial decision-making ought to become more evidence-based. The objective here is to develop and present an evidence-based profile, which could be used to divide pieces of evidence into dif- ferent types and hence creating an overall picture of evidence in a specific case. The evidence profile is developed in such a way that it allows evidence to be judged in context. The evidence profile consists of five types of evidence, and the profile is illustrated for perspective-based reading. It is shown how pieces of evi- dence can be classified into the different types. It is concluded that this type of ap- proach may be useful to capture the evidence with respect to a specific topic and in a specific context. The further work includes applying the evidence profile for evidence collected from different type of studies and contexts. Introduction},
author = {Wohlin, C},
file = {:Users/christoph/Documents/Studium/2017W/Designing and Conducting Experimental Studies/seminar paper/fose13.pdf:pdf},
journal = {Perspectives on the Future of Software Engineering},
mendeley-groups = {EBSE},
title = {{An Evidence Profile for Software Engineering Research and Practice}},
url = {http://link.springer.com/chapter/10.1007/978-3-642-37395-4{\_}10},
year = {2013}
}

@article{Atkins2004,
author = {Atkins, David and Best, Dana and Briss, Peter A and Eccles, Martin and Falck-Ytter, Yngve and Flottorp, Signe and Guyatt, Gordon H and Harbour, Robin T and Haugh, Margaret C and Henry, David and Hill, Suzanne and Jaeschke, Roman and Leng, Gillian and Liberati, Alessandro and Magrini, Nicola and Mason, James and Middleton, Philippa and Mrukowicz, Jacek and O'Connell, Dianne and Oxman, Andrew D and Phillips, Bob and Sch{\"{u}}nemann, Holger J and Edejer, Tessa Tan-Torres and Varonen, Helena and Vist, Gunn E and Williams, John W and Zaza, Stephanie and {GRADE Working Group}},
doi = {10.1136/bmj.328.7454.1490},
file = {:home/tobi/Documents/Studium/1617WS/SeminarUserStudies/Quellen/Critical Appraisal/GRADE.pdf:pdf},
isbn = {1756-1833 (Electronic)$\backslash$r0959-535X (Linking)},
issn = {1756-1833},
journal = {BMJ (Clinical research ed.)},
number = {7454},
pages = {1490},
pmid = {15205295},
title = {{Grading quality of evidence and strength of recommendations.}},
url = {http://www.ncbi.nlm.nih.gov/pubmed/15205295{\%}5Cnhttp://www.pubmedcentral.nih.gov/articlerender.fcgi?artid=PMC428525},
volume = {328},
year = {2004}
}

@article{Dyba2008,
author = {Dyb{\aa} Tore and Dings{\o}yr, Torgeir},
doi = {10.1016/j.infsof.2008.01.006},
file = {:home/tobi/Documents/Studium/1617WS/SeminarUserStudies/Quellen/Critical Appraisal/EmpiricalStudiesAgileSoftwareDevelopment.pdf:pdf},
isbn = {9783642125744},
issn = {09505849},
journal = {Information and Software Technology},
keywords = {Agile software development,Empirical software engineering,Evidence-based software engineering,Extreme programming,Research synthesis,Scrum,Systematic review,XP},
number = {9-10},
pages = {833--859},
pmid = {22207224},
title = {{Empirical studies of agile software development: A systematic review}},
volume = {50},
year = {2008}
}
@article{Jorgensen2016,
author = {J{\o}rgensen, Magne and Dyb{\aa}, Tore and Liest{\o}l, Knut and Sj{\o}berg, Dag I K},
doi = {10.1016/j.jss.2015.03.065},
file = {:home/tobi/Documents/Studium/1617WS/SeminarUserStudies/Quellen/Critical Appraisal/IncorrectResultsSEexperiments.pdf:pdf},
issn = {01641212},
journal = {Journal of Systems and Software},
keywords = {Controlled experiments,Empirical software engineering,Statistical hypothesis testing},
pages = {133--145},
title = {{Incorrect results in software engineering experiments: How to improve research practices}},
volume = {116},
year = {2016}
}
@article{Shepperd2015,
author = {Shepperd, Martin},
doi = {10.1109/MS.2015.8},
file = {:home/tobi/Documents/Studium/1617WS/SeminarUserStudies/Quellen/Critical Appraisal/How do i know whether to trust a research result.pdf:pdf},
issn = {0740-7459},
journal = {IEEE Software},
month = {jan},
number = {1},
pages = {106--109},
title = {{How Do I Know Whether to Trust a Research Result?}},
url = {http://ieeexplore.ieee.org/document/7030205/},
volume = {32},
year = {2015}
}

@article{Andrade2011,
abstract = {Abstracts of scientific papers are sometimes poorly written, often lack important information, and occasionally convey a biased picture. This paper provides detailed suggestions, with examples, for writing the background, methods, results, and conclusions sections of a good abstract. The primary target of this paper is the young researcher; however, authors with all levels of experience may find useful ideas in the paper.},
author = {Andrade, Chittaranjan},
doi = {10.4103/0019-5545.82558},
isbn = {1429275898},
issn = {0019-5545},
journal = {Indian Journal of Psychiatry},
mendeley-groups = {Structured Abstracts},
number = {2},
pages = {172},
pmid = {21772657},
title = {{How to write a good abstract for a scientific paper or conference presentation}},
url = {http://www.ncbi.nlm.nih.gov/pubmed/3136027{\%}5Cnhttp://www.indianjpsychiatry.org/text.asp?2011/53/2/172/82558},
volume = {53},
year = {2011}
}

@article{Rainer2008,
author = {Rainer, Austen and Beecham, Sarah},
file = {:Users/christoph/Library/Application Support/Mendeley Desktop/Downloaded/Rainer, Beecham - 2008 - Supplementary Guidelines , Assessment Scheme and evidence-based evaluations of the use of Evidence Based Softwa.pdf:pdf},
mendeley-groups = {EBSE and Students},
number = {February 2008},
pages = {1--27},
title = {{Supplementary Guidelines , Assessment Scheme and evidence-based evaluations of the use of Evidence Based Software Engineering, Version 2}},
year = {2008}
}

@book{Tullis2013,
abstract = {An important aspect of usability is being able to measure how usable a system really is, and how changes to the user interface of the system impact the end-user experience. This aspect of usability is known as usability metrics. This work looks at how to collect, analyse and present usability metrics. TS - WorldCat},
author = {Tullis, Tom and Albert, Bill},
booktitle = {Collecting, analyzing, and presenting usability metrics},
isbn = {9780124157811},
mendeley-groups = {Experiment Stuff},
title = {{Measuring the user experience}},
year = {2013}
}

@inproceedings{Janzen2008,
author = {Janzen, David S. and Ryoo, Jungwoo},
booktitle = {Software Engineering Education Conference, Proceedings},
doi = {10.1109/CSEET.2008.29},
isbn = {9780769531441},
issn = {10930175},
mendeley-groups = {EBSE and Students},
pages = {223--232},
title = {{Seeds of Evidence: Integrating Evidence-Based Software Engineering}},
year = {2008}
}

@misc{EBSEWeb,
title = {{Evidence Based Software Engineering}},
howpublished = {\url{https://community.dur.ac.uk/ebse}},
note = {accessed 2017-02-25}
}

@misc{SEED,
title = {{SEED}},
howpublished = {\url{http://evidencebasedse.com}},
note = {2017-2-25}
}

@misc{ScienceMethod,
	author = {Garland, Jr., Theodore},
	title = {{The Scientific Method as an Ongoing Process}},
	howpublished = {\url{http://idea.ucr.edu/documents/flash/scientific_method/story_html5.html}},
	note = {accessed 2017-03-24},
	year = {2015}
}

@article{nakayama2005adoption,
  title={Adoption of structured abstracts by general medical journals and format for a structured abstract},
  author={Nakayama, Takeo and Hirai, Nobuko and Yamazaki, Shigeaki and Naito, Mariko},
  journal={Journal of the Medical Library Association},
  volume={93},
  number={2},
  pages={237},
  year={2005},
  publisher={Medical Library Association}
}

@misc{ACMCCS,
	author = {Association for Computing Machinery},
	title = {{The 2012 ACM Computing Classification System toc}},
	howpublished = {\url{http://www.acm.org/about/class/class/2012}},
	note = {accessed 2017-03-30},
	year = {2015}
}

repository: TobiasGraef/Exp-SE

repo_name: TobiasGraef/Exp-SE


text:
package main

import (
	"fmt"
	"testing"
)

func TestAnnotation(t *testing.T) {
	for _, id := range []string{
		"080063bc-9a07-460b-b825-9bb1f4e0a578",
		"80cd5101-07ed-47e1-ba61-029b44ec035c",
		"ccaee346-4a37-45b7-8079-2237bffca9f3",
		"29779685-f8ba-4c48-b124-de09b993d76c",
	} {
		cmd := fmt.Sprintf("command a b # hc:%s", id)

		hc := newHealthCheck()

		if !hc.HasAnnotation(cmd) {
			t.Fatalf("HasAnnotation should return true for command %q", cmd)
		}
		if hc.FromAnnotation(cmd) != id {
			t.Errorf("FromAnnotation should return %q for command %q", id, cmd)
		}
	}
}

license: MIT

repository: alexkappa/crond

license_type: permissive

repo_name: alexkappa/crond

branch_name: refs/heads/master

extension: go


text:
string(TIMESTAMP output "%d;%H;%I;%j;%m;%M;%S;%U;%w;%y;%Y")
message("~${output}~")

list(LENGTH output output_length)

set(expected_output_length 11)

if(NOT output_length EQUAL ${expected_output_length})
    message(FATAL_ERROR "expected ${expected_output_length} entries in output "
        "with all specifiers; found ${output_length}")
endif()

extension: cmake


text:
DESCRIPTION = "2.6 Linux Development Kernel for the DNARD/Shark, SIMpad."
SECTION = "kernel"
LICENSE = "GPL"

inherit kernel

S = "${WORKDIR}/git"
SRC_URI = "git://www.openembedded.org/~zecke/git/linux/linux-2.6/.git;protocol=http \
           file://defconfig"

RPROVIDES_kernel-image += "hostap-modules"

COMPATIBLE_HOST = "(arm).*-linux"
COMPATIBLE_MACHINE = '(shark)'

do_configure_prepend() {
    install -m 0644 ${WORKDIR}/defconfig ${S}/.config
}

extension: bb


text:
@article{Choi2011,
 author = {Choi, Eunseo and Seeber, Leonardo and Steckler, Michael S. and Buck, W. Roger},
 doi = {10.1029/2011TC002943},
 file = {PDF:C\:\\Users\\eddy_\\Google Drive\\Zotero\\storage\\Z5SWNDM2\\Choi et al. - 2011 - One-sided transform basins and inverted curtains Implications for releasing bends along strike-slip faults.pdf:application/pdf},
 issn = {0278-7407},
 journal = {Tectonics},
 number = {November},
 pages = {TC6006},
 title = {One-sided transform basins and "inverted curtains": Implications for releasing bends along strike-slip faults},
 url = {http://www.agu.org/pubs/crossref/pip/2011TC002943.shtml},
 urldate = {2011-10-11},
 volume = {30},
 year = {2011}
}

branch_name: refs/heads/main

extension: bib


text:
package spoe

const basicConfig = `# _version=1
[ip-reputation]
spoe-agent iprep-agent
    messages check-client-ip
    option var-prefix iprep
    timeout hello 2s
    timeout idle  2m
    timeout processing 10ms
    use-backend agents
    log global
    option async

spoe-message check-client-ip
    args ip=src
    event on-client-session if ! { src -f /etc/haproxy/whitelist.lst }

spoe-group mygroup
    messages mymessage
`

repository: haproxytech/client-native

repo_name: haproxytech/client-native

gha_language: Go


text:
SUMMARY = "Unicode string library for C"
DESCRIPTION = "The 'libunistring' library implements Unicode strings (in the UTF-8, \
 UTF-16, and UTF-32 encodings), together with functions for Unicode \
 characters (character names, classifications, properties) and \
 functions for string processing (formatted output, width, word \
 breaks, line breaks, normalization, case folding, regular \
 expressions)."
HOMEPAGE = "http://www.gnu.org/software/libunistring/"

PR = "r0"
inherit debian-package
PV = "0.9.3"

LICENSE = "GPLv3+ & LGPLv3+ | GFDL-1.2+"
LICENSE_${PN} = "GPLv3+ & LGPLv3+"
LICENSE_${PN}-dev = "GPLv3+ & LGPLv3+"
LICENSE_${PN}-staticdev = "GPLv3+ & LGPLv3+"
LICENSE_${PN}-dbg = "GPLv3+ & LGPLv3+"
LICENSE_${PN}-doc = "GPLv3+ | GFDL-1.2+"
LIC_FILES_CHKSUM = "file://COPYING;md5=d32239bcb673463ab874e80d47fae504 \
                    file://COPYING.LIB;md5=6a6a8e020838b23406c81b19c1d46df6 \
                    file://doc/libunistring.texi;beginline=85;endline=107;md5=0eca48c8641a18c260ed173fdf166a65"

inherit autotools
BBCLASSEXTEND = "native"

# Avoid a parallel build problem
PARALLEL_MAKE = ""

repository: manut/meta-combo

repo_name: manut/meta-combo

branch_name: refs/heads/morty

gha_language: BitBake


text:
% Encoding: UTF-8

@Article{Dixon2019,
  author    = {William G. Dixon and Anna L. Beukenhorst and Belay B. Yimer and Louise Cook and Antonio Gasparrini and Tal El-Hay and Bruce Hellman and Ben James and Ana M. Vicedo-Cabrera and Malcolm Maclure and Ricardo Silva and John Ainsworth and Huai Leng Pisaniello and Thomas House and Mark Lunt and Carolyn Gamble and Caroline Sanders and David M. Schultz and Jamie C. Sergeant and John McBeth},
  journal   = {npj Digital Medicine},
  title     = {How the weather affects the pain of citizen scientists using a smartphone app},
  year      = {2019},
  month     = oct,
  number    = {1},
  volume    = {2},
  doi       = {10.1038/s41746-019-0180-3},
  publisher = {Springer Science and Business Media {LLC}},
}

@InCollection{Xie2014,
  author    = {Yihui Xie},
  booktitle = {Implementing Reproducible Computational Research},
  publisher = {Chapman and Hall/CRC},
  title     = {knitr: A Comprehensive Tool for Reproducible Research in {R}},
  year      = {2014},
  editor    = {Victoria Stodden and Friedrich Leisch and Roger D. Peng},
  note      = {ISBN 978-1466561595},
  url       = {http://www.crcpress.com/product/isbn/9781466561595},
}

@Manual{kableExtra,
  title  = {kableExtra: Construct Complex Table with 'kable' and Pipe Syntax},
  author = {Hao Zhu},
  note   = {R package version 1.3.1},
  year   = {2020},
  url    = {https://CRAN.R-project.org/package=kableExtra},
}

@Comment{jabref-meta: databaseType:bibtex;}

repository: anhnguyendepocen/personalpages

repo_name: anhnguyendepocen/personalpages


text:
# Use gem5 executable to produce a dtb

LICENSE = "MIT"

inherit deploy

DEPENDS = "gem5-aarch64-native"

do_configure[noexec] = "1"

do_compile() {
    # generate a dtb using gem5
    gem5.opt \
        ${STAGING_DATADIR_NATIVE}/gem5/${GEM5_RUN_PROFILE} \
        --dtb-gen

    if [ ! -f m5out/system.dtb ]; then
        echo "No dtb generated !!!"
        exit 1
    fi
}

do_install[noexec] = "1"

do_deploy() {
    install --d ${DEPLOYDIR}
    cp m5out/system.dtb ${DEPLOYDIR}/gem5-aarch64.dtb
}
addtask deploy before do_build after do_compile

repository: wistron-corporation/openbmc

repo_name: wistron-corporation/openbmc

gha_license_id: NOASSERTION


text:
package main

import (
	"github.com/LeakIX/ip4scout"
	"github.com/alecthomas/kong"
)

var App struct {
	Random ip4scout.RandomCommand `cmd help:"Scans random public IPs"`
}

func main() {
	ctx := kong.Parse(&App)
	// Call the Run() method of the selected parsed command.
	err := ctx.Run()
	ctx.FatalIfErrorf(err)
}


text:
package User

import (
	"encoding/json"
	"io/ioutil"
	"log"
	"os"
)

type User struct {
	Username           string
	Password           string
	Email              string
	SponsorMeeting     []string
	ParticipantMeeting []string
}

//register an  user with name, password, email
func RegisterAnUser(user *User) {
	AllUserInfo := GetAllUserInfo()
	flog, err := os.OpenFile("data/input_output.log", os.O_APPEND|os.O_WRONLY, 0600)
	defer flog.Close()
	check(err)
	logger := log.New(flog, "", log.LstdFlags)
	logger.Printf("agenda register -u %s -p %s -e %s", user.Username, user.Password, user.Email)

	if _, ok := AllUserInfo[user.Username]; !ok {
		AllUserInfo[user.Username] = *user
		os.Stdout.WriteString("register succeed!\n")
		logger.Print("register succeed!\n")
	} else {
		os.Stdout.WriteString("The userName have been registered\n")
		logger.Print("The userName have been registered\n")
	}
}

//Get all user infomation
func GetAllUserInfo() map[string]User {

	byteIn, err := ioutil.ReadFile("data/User.json")
	check(err)
	var allUserInfo map[string]User
	json.Unmarshal(byteIn, &allUserInfo)
	return allUserInfo
}

func check(r error) {
	if r != nil {
		log.Fatal(r)
	}
}


text:
@article{berchet15,
 author = {Berchet, A. and Pison, I. and Chevallier, F. and Paris, J. -D. and Bousquet, P. and Bonne, J. -L. and Arshinov, M. Y. and Belan, B. D. and Cressot, C. and Davydov, D. K. and Dlugokencky, E. J. and Fofonov, A. V. and Galanin, A. and Lavric, J. and Machida, T. and Parker, R. and Sasakawa, M. and Spahni, R. and Stocker, B. D. and Winderlich, J.},
 date-modified = {2018-01-09 14:37:34 +0000},
 journal = {Biogeosciences},
 number = {18},
 pages = {5393-5414},
 title = {Natural and anthropogenic methane fluxes in Eurasia: a mesoscale quantification by generalized atmospheric inversion},
 volume = {12},
 year = {2015}
}


text:
@inproceedings{WangLCSL19,
  author    = {Dongsheng Wang and
               Quichi Li and
               Lucas Chaves Lima and
               Jakob Grue Simonsen and
               Christina Lioma},
  title     = {Contextual Compositionality Detection with External Knowledge Bases
               and Word Embeddings},
  booktitle   = {{WWW International Workshop of Deep Learning for Graphs and Structured Data Embedding}},
  year      = {2019},
    timestamp = {2019-05-1},

  url={https://arxiv.org/pdf/1903.08389}
  }


text:
SUMMARY = "A case-insensitive ordered dictionary for Python"
HOMEPAGE = "https://github.com/pywbem/nocasedict"
LICENSE = "LGPLv2.1"
LIC_FILES_CHKSUM = "file://LICENSE;md5=1803fa9c2c3ce8cb06b4861d75310742"

SRC_URI[md5sum] = "93e7f19f73c7cd56c36cd7535b6b9ab1"
SRC_URI[sha256sum] = "6e5d5bd11de33f93d22545d9ed23a0b98f840f2cdac0d749d2faa4617adc7772"

inherit pypi setuptools3

repository: MaxKellermann/meta-openembedded

repo_name: MaxKellermann/meta-openembedded

gha_license_id: MIT


text:
package model

// Specifies the payment terms of the underlying transaction.
type PaymentTerms3 struct {

	// Due date specified for the payment terms.
	DueDate *ISODate `xml:"DueDt,omitempty"`

	// Payment period specified for these payment terms.
	PaymentPeriod *PaymentPeriod1 `xml:"PmtPrd,omitempty"`

	// Textual description of these payment terms.
	Description []*Max140Text `xml:"Desc,omitempty"`

	// Partial payment, expressed as a percentage, for the payment terms.
	PartialPaymentPercent *PercentageRate `xml:"PrtlPmtPct,omitempty"`

	// Direct debit mandate identification specified for these payment terms.
	DirectDebitMandateIdentification []*Max35Text `xml:"DrctDbtMndtId,omitempty"`

	// Monetary value used as a basis to calculate the discount in these payment terms.
	DiscountAmount *CurrencyAndAmount `xml:"DscntAmt,omitempty"`

	// Percent rate used to calculate the discount for these payment terms.
	DiscountPercentRate *PercentageRate `xml:"DscntPctRate,omitempty"`

	// Monetary value used as a basis to calculate the discount in these payment terms.
	DiscountBasisAmount *CurrencyAndAmount `xml:"DscntBsisAmt,omitempty"`

	// Monetary value used as a basis to calculate the penalty in the payment terms.
	PenaltyAmount *CurrencyAndAmount `xml:"PnltyAmt,omitempty"`

	// Percent rate used to calculate the penalty for these payment terms.
	PenaltyPercentRate *PercentageRate `xml:"PnltyPctRate,omitempty"`

	// Amount used as a basis to calculate the penalty amount.
	PenaltyBasisAmount *CurrencyAndAmount `xml:"PnltyBsisAmt,omitempty"`
}

func (p *PaymentTerms3) SetDueDate(value string) {
	p.DueDate = (*ISODate)(&value)
}

func (p *PaymentTerms3) AddPaymentPeriod() *PaymentPeriod1 {
	p.PaymentPeriod = new(PaymentPeriod1)
	return p.PaymentPeriod
}

func (p *PaymentTerms3) AddDescription(value string) {
	p.Description = append(p.Description, (*Max140Text)(&value))
}

func (p *PaymentTerms3) SetPartialPaymentPercent(value string) {
	p.PartialPaymentPercent = (*PercentageRate)(&value)
}

func (p *PaymentTerms3) AddDirectDebitMandateIdentification(value string) {
	p.DirectDebitMandateIdentification = append(p.DirectDebitMandateIdentification, (*Max35Text)(&value))
}

func (p *PaymentTerms3) SetDiscountAmount(value, currency string) {
	p.DiscountAmount = NewCurrencyAndAmount(value, currency)
}

func (p *PaymentTerms3) SetDiscountPercentRate(value string) {
	p.DiscountPercentRate = (*PercentageRate)(&value)
}

func (p *PaymentTerms3) SetDiscountBasisAmount(value, currency string) {
	p.DiscountBasisAmount = NewCurrencyAndAmount(value, currency)
}

func (p *PaymentTerms3) SetPenaltyAmount(value, currency string) {
	p.PenaltyAmount = NewCurrencyAndAmount(value, currency)
}

func (p *PaymentTerms3) SetPenaltyPercentRate(value string) {
	p.PenaltyPercentRate = (*PercentageRate)(&value)
}

func (p *PaymentTerms3) SetPenaltyBasisAmount(value, currency string) {
	p.PenaltyBasisAmount = NewCurrencyAndAmount(value, currency)
}


text:
include(RunCMake)

run_cmake(CMP0027-NEW)
run_cmake(CMP0027-OLD)
run_cmake(CMP0027-WARN)


text:
SUMMARY = "Kernel evdev device emulation"
DESCRIPTION = "The evemu library and tools are used to describe devices, record data, create devices and replay data from kernel evdev devices."
HOMEPAGE = "https://www.freedesktop.org/wiki/Evemu"

LICENSE = "GPL-3.0-only"
LIC_FILES_CHKSUM = "file://COPYING;md5=e6a600fd5e1d9cbde2d983680233ad02"

DEPENDS = "libevdev"

SRCREV = "86a5627dbeac8d9d9bc34326a758d6a477e876e4"
SRC_URI = "git://git@gitlab.freedesktop.org/libevdev/evemu.git;protocol=https;branch=master"

S = "${WORKDIR}/git"
PV = "gitr${SRCPV}"

inherit autotools pkgconfig

PACKAGES =+ "${PN}-python"
FILES:${PN}-python = "${libdir}/python*/site-packages/*"
RDEPENDS:${PN}-python = "python3"

repository: openembedded/meta-openembedded

repo_name: openembedded/meta-openembedded


text:
require networkmanager-pre0.7.inc

PR = "r2"
PV = "0.7olpc+git"

DEFAULT_PREFERENCE = "-1"

SRC_URI += "git://dev.laptop.org/users/sjoerd/NetworkManager.git;protocol=git;branch=olpc-patches;tag=f1fa6c27710196b7327402c59b2c55d920a12bb0 \
            file://define_kernel_types_for_old_linux_headers_and_warn_functions_from_glib_2_16.patch \
           "
S = "${WORKDIR}/git"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
package product

import (
    "github.com/bububa/opentaobao/core"
    "github.com/bububa/opentaobao/model/product"
)

/*
添加一个商品
taobao.item.add

此接口用于新增一个淘宝商品
商品的属性和sku的属性有包含的关系，商品的价格要位于sku的价格区间之中（例如，sku价格有5元、10元两种，那么商品的价格就需要大于等于5元，小于等于10元，否则新增商品会失败）
商品的类目和商品的价格、sku的价格都有一定的相关性（具体的关系要通过类目属性查询接口获得）
商品的运费承担方式和邮费设置有相关性，卖家承担运费不用设置邮费，买家承担运费需要设置邮费
当关键属性值选择了“其他”的时候，需要输入input_pids和input_str商品才能添加成功。

点击查看更多商品API说明
*/
func TaobaoItemAdd(clt *core.SDKClient, req *product.TaobaoItemAddRequest, session string) (*product.TaobaoItemAddAPIResponse, error) {
    var resp product.TaobaoItemAddAPIResponse
    err := clt.Post(req, &resp, session)
    if err != nil {
        return nil, err
    }
    return &resp, nil
}

repository: phpyandong/opentaobao

repo_name: phpyandong/opentaobao


text:
package client

import (
	"context"
	"strings"

	"github.com/pkg/errors"

	repairmanv1 "github.com/awesomenix/repairman/api/v1"
	corev1 "k8s.io/api/core/v1"
	apiextensions "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1"
	apierrors "k8s.io/apimachinery/pkg/api/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/types"
	"sigs.k8s.io/controller-runtime/pkg/client"
)

var (
	nodeType = "node"
)

// Client implementation for the repairman client
type Client struct {
	Name string
	client.Client
	NewRequest func() *repairmanv1.MaintenanceRequest
}

// New intializes repairman client
func New(clientName string, c client.Client) (*Client, error) {
	if clientName == "" {
		return nil, errors.New("client name required")
	}

	return &Client{
		Name:       clientName,
		Client:     c,
		NewRequest: newRequest,
	}, nil
}

// IsEnabled checks if repairman is enabled on server
func (c *Client) IsEnabled(rtype string) (bool, error) {
	if rtype != nodeType {
		return false, nil
	}

	mrCustomResourceDef := &apiextensions.CustomResourceDefinition{}
	err := c.Get(context.TODO(), types.NamespacedName{Name: "maintenancerequests.repairman.k8s.io"}, mrCustomResourceDef)
	if err != nil {
		if apierrors.IsNotFound(err) ||
			runtime.IsNotRegisteredError(err) {
			return false, nil
		}
		return false, err
	}
	return true, nil
}

// RequestMaintenance returns existing request, else creates a new one
func (c *Client) requestMaintenance(ctx context.Context, name, rtype string) (*repairmanv1.MaintenanceRequest, error) {
	request, err := c.getRequest(ctx, name, rtype)
	if err != nil {
		return nil, err
	}
	if request != nil {
		return request, nil
	}

	request = c.NewRequest()
	request.Labels = make(map[string]string)
	request.Labels["maintenancerequests.repairman.k8s.io/clientname"] = c.Name
	request.Spec = repairmanv1.MaintenanceRequestSpec{
		Name:  name,
		Type:  rtype,
		State: repairmanv1.Pending,
	}

	return request, c.Client.Create(ctx, request)
}

func newRequest() *repairmanv1.MaintenanceRequest {
	return &repairmanv1.MaintenanceRequest{
		ObjectMeta: metav1.ObjectMeta{
			GenerateName: "mr-",
		},
	}
}

func (c *Client) getRequest(ctx context.Context, name, rtype string) (*repairmanv1.MaintenanceRequest, error) {
	maintenanceRequests := &repairmanv1.MaintenanceRequestList{}
	labels := map[string]string{
		"maintenancerequests.repairman.k8s.io/clientname": c.Name,
	}
	err := c.Client.List(ctx, maintenanceRequests, client.MatchingLabels(labels))
	if err != nil {
		return nil, err
	}

	for _, request := range maintenanceRequests.Items {
		if strings.EqualFold(request.Spec.Name, name) &&
			strings.EqualFold(request.Spec.Type, rtype) &&
			request.Spec.State != repairmanv1.Completed {
			return &request, nil
		}
	}

	return nil, nil
}

// validate checks if node name is valid
// should also validate against current list of nodes

func (c *Client) validateNode(ctx context.Context, name string) error {
	nodelist := &corev1.NodeList{}
	err := c.List(ctx, nodelist)
	if err != nil {
		return err
	}
	for _, node := range nodelist.Items {
		if strings.EqualFold(node.Name, name) {
			return nil
		}
	}
	return errors.Errorf("invalid node name in %d node list", len(nodelist.Items))
}

func (c *Client) validate(ctx context.Context, name, rtype string) error {
	switch rtype {
	case nodeType:
		return c.validateNode(ctx, name)
	}

	return nil
}

// IsMaintenanceApproved checks if a maintenance request on a name and type is approved
func (c *Client) IsMaintenanceApproved(ctx context.Context, name, rtype string) (bool, error) {
	if err := c.validate(ctx, name, rtype); err != nil {
		return false, err
	}
	request, err := c.requestMaintenance(ctx, name, rtype)
	if err != nil {
		return false, err
	}
	if request.Spec.State == repairmanv1.Approved {
		return true, nil
	}

	return false, nil
}

// UpdateMaintenanceState sets desired state if a live (not completed) maintenance request exists
func (c *Client) UpdateMaintenanceState(ctx context.Context, name, rtype string, desiredState repairmanv1.MaintenanceState) error {
	if desiredState == repairmanv1.Approved {
		return errors.New("cannot set state as approved")
	}
	if err := c.validate(ctx, name, rtype); err != nil {
		return err
	}
	request, err := c.getRequest(ctx, name, rtype)
	if err != nil {
		return err
	}
	if request == nil {
		return errors.New("request must exist before state can be updated")
	}
	switch request.Spec.State {
	case repairmanv1.Pending:
		return errors.New("request is not yet approved")
	case repairmanv1.Completed:
		return errors.New("request is already completed")
	}
	request.Spec.State = desiredState

	return c.Client.Update(ctx, request)
}


text:
require u-boot-socfpga-common.inc

UBOOT_VERSION = "v2021.01"

SRCREV = "c11f4e161a2d86a3657fbbc21f87bc4afb815eb9"

LIC_FILES_CHKSUM = "file://Licenses/README;md5=5a7450c57ffe5ae63fd732446b988025"

repository: kraj/meta-altera

repo_name: kraj/meta-altera

gha_language: HTML


text:
package server

import (
	"fmt"
	"net/http"
	"sync"

	"github.com/gerblaurynas/websocket-chat/internal/transport"
	"github.com/pkg/errors"
	"github.com/rs/zerolog"
	"nhooyr.io/websocket"
)

type Server struct {
	log         zerolog.Logger
	connections map[string]transport.Connection
	reader      *transport.Reader
	writer      *transport.Writer
	lock        sync.Locker
}

func New(log *zerolog.Logger) *Server {
	return &Server{
		log:         *log,
		connections: make(map[string]transport.Connection),
		reader:      new(transport.Reader),
		writer:      new(transport.Writer),
		lock:        new(sync.Mutex),
	}
}

func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path == "/websocket" {
		s.handleConnection(w, r)
		return
	}

	http.NotFoundHandler().ServeHTTP(w, r)
}

func (s *Server) handleConnection(w http.ResponseWriter, r *http.Request) {
	username, c, err := s.connectClient(w, r)
	if err != nil {
		s.log.Warn().Msg(err.Error())
		return
	}

	defer s.disconnectClient(username, c)

	for {
		msg, err := s.reader.Read(c, username)
		if err != nil {
			switch err.(type) {
			case transport.UserError:
				s.writer.SendError(err, c)
				continue
			default:
				s.log.Warn().Msg(err.Error())
				return
			}
		}

		s.lock.Lock()
		err = s.writer.SendAll(msg, s.connections)
		s.lock.Unlock()
		if err != nil {
			s.log.Warn().Msg(err.Error())
			return
		}
	}
}

func (s *Server) connectClient(w http.ResponseWriter, r *http.Request) (username string, c *websocket.Conn, err error) {
	username = r.URL.Query().Get("username")
	if username == "" {
		http.Error(w, "username not found", 400)
		err = errors.New("username not found")
		return
	}
	s.lock.Lock()
	defer s.lock.Unlock()
	if _, ok := s.connections[username]; ok {
		http.Error(w, "username already connected", 409)
		err = errors.New("username already connected")
		return
	}

	// allow connections from chrome extensions
	options := &websocket.AcceptOptions{
		InsecureSkipVerify: true,
	}

	c, err = websocket.Accept(w, r, options)
	if err != nil {
		err = errors.Wrap(err, "cannot upgrade connection")
		return
	}

	s.connections[username] = c
	s.log.Info().Msg(fmt.Sprintf("%s connected", username))

	return username, c, nil
}

func (s *Server) disconnectClient(username string, c *websocket.Conn) {
	_ = c.Close(websocket.StatusInternalError, "internal error")

	s.lock.Lock()
	delete(s.connections, username)
	s.lock.Unlock()
	s.log.Info().Msg(fmt.Sprintf("%s disconnected", username))
}

repository: gerblaurynas/websocket-chat

repo_name: gerblaurynas/websocket-chat


text:
DESCRIPTION = "The pycodes package provides various extensions to Python for low density parity check (LDPC) codes \
(an extremely powerful class of error correcting codes). LDPC codes can be used for physical layer error correction \
in wireless, telephone, DSL, or cable modems; packet loss correction in multicast and distribution of bulk data over \
the Internet; and even data compression. A variety of decoding/quantization algorithms are provided including standard\
things like sum-product as well as linear programming relaxations."
SECTION = "devel/python"
PRIORITY = "optional"
MAINTAINER = "Michael 'Mickey' Lauer <mickey@Vanille.de>"
LICENSE = "PYCODES"
SRCNAME = "pycodes"

SRC_URI = "http://www.csua.berkeley.edu/~emin/source_code/pycodes/pycodes-1-1.tar.gz \
           file://no-docs.patch;patch=1"
S = "${WORKDIR}/${SRCNAME}"

inherit distutils


text:
package defaults

import (
	"github.com/containers-ai/alameda/datahub/pkg/entities"
)

func DefaultSchemaTarget() []interface{} {
	schemas := make([]interface{}, 0)

	// Cluster-status cluster
	schemas = append(schemas, &entities.TargetClusterStatusCluster{})

	// Cluster-status controller
	schemas = append(schemas, &entities.TargetClusterStatusController{})

	// Kafka consumer group
	schemas = append(schemas, &entities.TargetKafkaConsumerGroup{})

	return schemas
}

repository: cochicde/alameda

repo_name: cochicde/alameda


text:
SUMMARY = "An interface library to access tags for identifying languages"
HOMEPAGE = "http://tagoh.bitbucket.org/liblangtag/"
LICENSE = "LGPL-3.0-only"
LIC_FILES_CHKSUM = " \
    file://COPYING;md5=e6a600fd5e1d9cbde2d983680233ad02 \
"

DEPENDS = "libxml2"

SRC_URI = " \
    https://bitbucket.org/tagoh/${BPN}/downloads/${BPN}-${PV}.tar.bz2 \
    file://0001-configure.ac-add-missing-HAVE_INTROSPECTION-check.patch \
    file://0002-configure.ac-remove-untranslated-AX_CHECK_ENABLE_DEB.patch \
"
SRC_URI[sha256sum] = "1f12a20a02ec3a8d22e54dedb8b683a43c9c160bda1ba337bf1060607ae733bd"

inherit autotools pkgconfig gobject-introspection

export GIR_EXTRA_LIBS_PATH="${B}/liblangtag/.libs"

BBCLASSEXTEND = "native"

repository: schnitzeltony/meta-office

repo_name: schnitzeltony/meta-office


text:
package nats

import (
	"context"
	"crypto/tls"
	"fmt"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/gofrs/uuid"
	"github.com/nats-io/nats.go"
	"github.com/nats-io/stan.go"

	"github.com/benthosdev/benthos/v4/internal/bundle"
	"github.com/benthosdev/benthos/v4/internal/component"
	"github.com/benthosdev/benthos/v4/internal/component/input"
	"github.com/benthosdev/benthos/v4/internal/component/input/processors"
	"github.com/benthosdev/benthos/v4/internal/docs"
	"github.com/benthosdev/benthos/v4/internal/impl/nats/auth"
	"github.com/benthosdev/benthos/v4/internal/log"
	"github.com/benthosdev/benthos/v4/internal/message"
	btls "github.com/benthosdev/benthos/v4/internal/tls"
)

func init() {
	err := bundle.AllInputs.Add(processors.WrapConstructor(newNATSStreamInput), docs.ComponentSpec{
		Name:    "nats_stream",
		Summary: `Subscribe to a NATS Stream subject. Joining a queue is optional and allows multiple clients of a subject to consume using queue semantics.`,
		Description: `
Tracking and persisting offsets through a durable name is also optional and works with or without a queue. If a durable name is not provided then subjects are consumed from the most recently published message.

When a consumer closes its connection it unsubscribes, when all consumers of a durable queue do this the offsets are deleted. In order to avoid this you can stop the consumers from unsubscribing by setting the field ` + "`unsubscribe_on_close` to `false`" + `.

### Metadata

This input adds the following metadata fields to each message:

` + "``` text" + `
- nats_stream_subject
- nats_stream_sequence
` + "```" + `

You can access these metadata fields using [function interpolation](/docs/configuration/interpolation#bloblang-queries).

` + auth.Description(),
		Config: docs.FieldComponent().WithChildren(
			docs.FieldString(
				"urls",
				"A list of URLs to connect to. If an item of the list contains commas it will be expanded into multiple URLs.",
				[]string{"nats://127.0.0.1:4222"},
				[]string{"nats://username:password@127.0.0.1:4222"},
			).Array(),
			docs.FieldString("cluster_id", "The ID of the cluster to consume from."),
			docs.FieldString("client_id", "A client ID to connect as."),
			docs.FieldString("queue", "The queue to consume from."),
			docs.FieldString("subject", "A subject to consume from."),
			docs.FieldString("durable_name", "Preserve the state of your consumer under a durable name."),
			docs.FieldBool("unsubscribe_on_close", "Whether the subscription should be destroyed when this client disconnects."),
			docs.FieldBool("start_from_oldest", "If a position is not found for a queue, determines whether to consume from the oldest available message, otherwise messages are consumed from the latest.").Advanced(),
			docs.FieldInt("max_inflight", "The maximum number of unprocessed messages to fetch at a given time.").Advanced(),
			docs.FieldString("ack_wait", "An optional duration to specify at which a message that is yet to be acked will be automatically retried.").Advanced(),
			btls.FieldSpec(),
			auth.FieldSpec(),
		).ChildDefaultAndTypesFromStruct(input.NewNATSStreamConfig()),
		Categories: []string{
			"Services",
		},
	})
	if err != nil {
		panic(err)
	}
}

func newNATSStreamInput(conf input.Config, mgr bundle.NewManagement) (input.Streamed, error) {
	var c input.Async
	var err error
	if c, err = newNATSStreamReader(conf.NATSStream, mgr); err != nil {
		return nil, err
	}
	return input.NewAsyncReader("nats_stream", c, mgr)
}

type natsStreamReader struct {
	urls    string
	conf    input.NATSStreamConfig
	ackWait time.Duration

	log log.Modular

	unAckMsgs []*stan.Msg

	stanConn stan.Conn
	natsConn *nats.Conn
	natsSub  stan.Subscription
	cMut     sync.Mutex

	msgChan       chan *stan.Msg
	interruptChan chan struct{}
	interruptOnce sync.Once
	tlsConf       *tls.Config
}

func newNATSStreamReader(conf input.NATSStreamConfig, mgr bundle.NewManagement) (*natsStreamReader, error) {
	if conf.ClientID == "" {
		u4, err := uuid.NewV4()
		if err != nil {
			return nil, err
		}
		conf.ClientID = u4.String()
	}

	var ackWait time.Duration
	if tout := conf.AckWait; len(tout) > 0 {
		var err error
		if ackWait, err = time.ParseDuration(tout); err != nil {
			return nil, fmt.Errorf("failed to parse ack_wait string: %v", err)
		}
	}

	n := natsStreamReader{
		conf:          conf,
		ackWait:       ackWait,
		log:           mgr.Logger(),
		msgChan:       make(chan *stan.Msg),
		interruptChan: make(chan struct{}),
	}

	close(n.msgChan)
	n.urls = strings.Join(conf.URLs, ",")
	var err error
	if conf.TLS.Enabled {
		if n.tlsConf, err = conf.TLS.Get(mgr.FS()); err != nil {
			return nil, err
		}
	}

	return &n, nil
}

func (n *natsStreamReader) disconnect() {
	n.cMut.Lock()
	defer n.cMut.Unlock()

	if n.natsSub != nil {
		if n.conf.UnsubOnClose {
			_ = n.natsSub.Unsubscribe()
		}
		n.natsConn.Close()
		n.stanConn.Close()

		n.natsSub = nil
		n.natsConn = nil
		n.stanConn = nil
	}
}

func (n *natsStreamReader) Connect(ctx context.Context) error {
	n.cMut.Lock()
	defer n.cMut.Unlock()

	if n.natsSub != nil {
		return nil
	}

	var opts []nats.Option
	if n.tlsConf != nil {
		opts = append(opts, nats.Secure(n.tlsConf))
	}

	opts = append(opts, authConfToOptions(n.conf.Auth)...)

	natsConn, err := nats.Connect(n.urls, opts...)
	if err != nil {
		return err
	}

	newMsgChan := make(chan *stan.Msg)
	handler := func(m *stan.Msg) {
		select {
		case newMsgChan <- m:
		case <-n.interruptChan:
			n.disconnect()
		}
	}
	dcHandler := func() {
		if newMsgChan == nil {
			return
		}
		close(newMsgChan)
		newMsgChan = nil
		n.disconnect()
	}

	stanConn, err := stan.Connect(
		n.conf.ClusterID,
		n.conf.ClientID,
		stan.NatsConn(natsConn),
		stan.SetConnectionLostHandler(func(_ stan.Conn, reason error) {
			n.log.Errorf("Connection lost: %v", reason)
			dcHandler()
		}),
	)
	if err != nil {
		return err
	}

	options := []stan.SubscriptionOption{
		stan.SetManualAckMode(),
	}
	if len(n.conf.DurableName) > 0 {
		options = append(options, stan.DurableName(n.conf.DurableName))
	}
	if n.conf.StartFromOldest {
		options = append(options, stan.DeliverAllAvailable())
	} else {
		options = append(options, stan.StartWithLastReceived())
	}
	if n.conf.MaxInflight != 0 {
		options = append(options, stan.MaxInflight(n.conf.MaxInflight))
	}
	if n.ackWait > 0 {
		options = append(options, stan.AckWait(n.ackWait))
	}

	var natsSub stan.Subscription
	if len(n.conf.QueueID) > 0 {
		natsSub, err = stanConn.QueueSubscribe(
			n.conf.Subject,
			n.conf.QueueID,
			handler,
			options...,
		)
	} else {
		natsSub, err = stanConn.Subscribe(
			n.conf.Subject,
			handler,
			options...,
		)
	}
	if err != nil {
		natsConn.Close()
		return err
	}

	n.natsConn = natsConn
	n.stanConn = stanConn
	n.natsSub = natsSub
	n.msgChan = newMsgChan
	n.log.Infof("Receiving NATS Streaming messages from subject: %v\n", n.conf.Subject)
	return nil
}

func (n *natsStreamReader) read(ctx context.Context) (*stan.Msg, error) {
	var msg *stan.Msg
	var open bool
	select {
	case msg, open = <-n.msgChan:
		if !open {
			return nil, component.ErrNotConnected
		}
	case <-ctx.Done():
		return nil, component.ErrTimeout
	case <-n.interruptChan:
		n.unAckMsgs = nil
		n.disconnect()
		return nil, component.ErrTypeClosed
	}
	return msg, nil
}

func (n *natsStreamReader) ReadBatch(ctx context.Context) (message.Batch, input.AsyncAckFn, error) {
	msg, err := n.read(ctx)
	if err != nil {
		return nil, nil, err
	}

	bmsg := message.QuickBatch([][]byte{msg.Data})
	part := bmsg.Get(0)
	part.MetaSetMut("nats_stream_subject", msg.Subject)
	part.MetaSetMut("nats_stream_sequence", strconv.FormatUint(msg.Sequence, 10))

	return bmsg, func(rctx context.Context, res error) error {
		if res == nil {
			return msg.Ack()
		}
		return nil
	}, nil
}

func (n *natsStreamReader) Close(ctx context.Context) (err error) {
	n.interruptOnce.Do(func() {
		close(n.interruptChan)
	})
	return
}

repository: cludden/benthos

repo_name: cludden/benthos


text:
package main

import (
  "bufio"
  "fmt"
  "os"
  "strings"
)

func main() {
  reader := bufio.NewReader(os.Stdin)

  fmt.Print("What day of the week is it? ")
  dowInput, _ := reader.ReadString('\n')
  dow := strings.TrimSuffix(dowInput, "\n")

  if dow == "Saturday" || dow == "Sunday" {
    fmt.Println("Stay home.")
  } else {
    fmt.Println("Go to work.")
  }
}

repository: fernandoacorreia/learning-go

repo_name: fernandoacorreia/learning-go


text:
SUMMARY = "OpenSwitch System Monitoring Daemon"
LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/Apache-2.0;md5=89aea4e17d99a7cacdbeed46a0096b10"

DEPENDS = "ops-cli ops-supportability"

BRANCH ?= "${OPS_REPO_BRANCH}"

SRC_URI = "${OPS_REPO_BASE_URL}/ops-sysmond;protocol=${OPS_REPO_PROTOCOL};branch=${BRANCH}"

SRCREV="a8664b129d41020783bec8ad4bd50c004069f2d4"

# When using AUTOREV, we need to force the package version to the revision of git
# in order to avoid stale shared states.
PV = "git${SRCPV}"

S = "${WORKDIR}/git"

# This directory is temporary and is just used to validate
# if the sysmond recipe was picked up. It would change to a model of installing
# a service once we have a NTP Daemon service working
DIR_${PN} = "/usr/share/sysmond"

FILES_${PN} = "${DIR_${PN}}"

do_install() {
      install -d ${D}"${DIR_${PN}}"
}

FILES_${PN} += "/usr/lib/cli/plugins/"
inherit openswitch cmake

repository: billyjbryant/ops-build

repo_name: billyjbryant/ops-build

gha_language: Python


text:
// Package dispute provides the dispute-related APIs
package dispute

import (
	"fmt"
	"net/url"

	stripe "github.com/stripe/stripe-go"
)

const (
	Duplicate    stripe.DisputeReason = "duplicate"
	Fraudulent   stripe.DisputeReason = "fraudulent"
	SubCanceled  stripe.DisputeReason = "subscription_canceled"
	Unacceptable stripe.DisputeReason = "product_unacceptable"
	NotReceived  stripe.DisputeReason = "product_not_received"
	Unrecognized stripe.DisputeReason = "unrecognized"
	Credit       stripe.DisputeReason = "credit_not_processed"
	General      stripe.DisputeReason = "general"

	Won             stripe.DisputeStatus = "won"
	Lost            stripe.DisputeStatus = "lost"
	Response        stripe.DisputeStatus = "needs_response"
	Review          stripe.DisputeStatus = "under_review"
	WarningResponse stripe.DisputeStatus = "warning_needs_response"
	WarningReview   stripe.DisputeStatus = "warning_under_review"
	ChargeRefunded  stripe.DisputeStatus = "charge_refunded"
)

// Client is used to invoke dispute-related APIs.
type Client struct {
	B   stripe.Backend
	Key string
}

// Update updates a charge's dispute.
// For more details see https://stripe.com/docs/api#update_dispute.
func Update(id string, params *stripe.DisputeParams) (*stripe.Dispute, error) {
	return getC().Update(id, params)
}

func (c Client) Update(id string, params *stripe.DisputeParams) (*stripe.Dispute, error) {
	var body *url.Values

	if params != nil {
		body = &url.Values{}

		if params.Evidence != nil {
			params.Evidence.AppendDetails(body)
		}

		params.AppendTo(body)
	}

	dispute := &stripe.Dispute{}
	err := c.B.Call("POST", fmt.Sprintf("/charges/%v/dispute", id), c.Key, body, dispute)

	return dispute, err
}

// Close dismisses a dispute in the customer's favor.
// For more details see https://stripe.com/docs/api#close_dispute.
func Close(id string) (*stripe.Dispute, error) {
	return getC().Close(id)
}

func (c Client) Close(id string) (*stripe.Dispute, error) {
	dispute := &stripe.Dispute{}
	err := c.B.Call("POST", fmt.Sprintf("/charges/%v/dispute/close", id), c.Key, nil, dispute)

	return dispute, err
}

func getC() Client {
	return Client{stripe.GetBackend(), stripe.Key}
}

repository: fritzpay/paymentd

repo_name: fritzpay/paymentd