text:
---
published: false
title: i02
layout: post
author: Yu
categories: v55
hidden: true
---

| 项目 | 具体内容 | 链接 |
|---:|---|---|
| 作者 | Kris De Brabanter, Johan Suykens, Bart De Moor| |
| 题目 |Nonparametric Regression via StatLSSVM | [下载地址](http://www.jstatsoft.org/v55/i02/paper) |
| 参考资料 |Vol. 55, Issue 2, Oct 2013 | |
| | 提交日期 2011-08-29, 接收日期 2013-10-27| |
| 类别 | 论文| |
| 摘要 | We present a new MATLAB toolbox under Windows and Linux for nonparametric regression estimation based on the statistical library for least squares support vector machines (StatLSSVM). The StatLSSVM toolbox is written so that only a few lines of code are necessary in order to perform standard nonparametric regression, regression with correlated errors and robust regression. In addition, construction of additive models and pointwise or uniform confidence intervals are also supported. A number of tuning criteria such as classical cross-validation, robust cross-validation and cross-validation for correlated errors are available. Also, minimization of the previous criteria is available without any user interaction.| |
| 论文 | Nonparametric Regression via StatLSSVM  (application/pdf, 871.5 KB)| [下载地址](http://www.jstatsoft.org/v55/i02/paper) |
| 补充材料 | | |
| |StatLSSVM.zip:        MATLAB source package  (application/x-zip-compressed, 310.4 KB)|  [下载地址](http://www.jstatsoft.org/v55/i02/supp/1) |
| |StatLSSVM-manual.pdf: StatLSSVM user manual  (application/pdf, 800.3 KB)|  [下载地址](http://www.jstatsoft.org/v55/i02/supp/2) |
| |v55i02.m:             MATLAB example code from the paper  (application/octet-stream, 5.4 KB)|  [下载地址](http://www.jstatsoft.org/v55/i02/supp/3) |
| 资源 | [BibTeX](http://www.jstatsoft.org/v55/i02/bibtex) [OAI](http://www.jstatsoft.org/oai?verb=GetRecord&identifier=oai.jstatsoft/v55/i02&prefix=oai_dc)| |
| |  | [返回卷目录]({{site.baseurl}}/volume/v55.html) |

repository: yulijia/jstatsoft

repo_name: yulijia/jstatsoft


text:
# From BDFL to Consensus Seeking:
> A [Bespoke.js](http://markdalgleish.com/projects/bespoke.js) presentation, built with [generator-bespoke](https://github.com/markdalgleish/generator-bespoke)

## Notes

* What is a governance model
  * Why?
  * ?Administrative Governance vs Technical Governance?

* What is a BDFL
 * Definiton
 * Example

* Consensus Seeking
 * Definiton
 * Example

* Cathedral vs Bazaar

* Node Board
  * Long term care and feeding of the foundation and project
  * Focused on growth and adoption
  * Non profit

* History of Node
  * BDFL && Cathedral
  * Started by Ryan

* BDFL
 * problem from a corporate member side
 * worried about direction

* open stack
* no single person or company is in charge of the direction of the community

* Fork was due to the community not getting things in... neglect

* Tooling

* Code Reviews

* CLA vs DCO
 - is it a good move?

* Process can allow you to hand off responsibility

* Superstars in Node
 - Rich trott
 - Anna
 - william Kapke
 - Me

7.5 million users, exponential

## View slides locally

First, ensure you have the following installed:

1. [Node.js](http://nodejs.org)
2. [Bower](http://bower.io): `$ npm install -g bower`
3. [Gulp](http://gulpjs.com): `$ npm install -g gulp`

Then, install dependencies and run the preview server:

```bash
$ npm install && bower install
$ gulp serve
```

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
---
layout: post
title: "Triage of my Cauchy kernel project"
categories: research
---

This is a post about my latest paper, ["Minimax separation of the Cauchy kernel"](https://arxiv.org/abs/1909.06911),
 which I have just posted to the arXiv and submitted to the
 [SIAM Journal on Numerical Analysis](https://www.siam.org/Publications/Journals/SIAM-Journal-on-Numerical-Analysis-SINUM).
I have wanted to write and publish a math paper for a long time, to signify an increased emphasis in my research
 on the mathematical underpinnings of atomistic simulation.
It has taken me longer than expected to reach this goal because it has been difficult to focus on mathematical work
 that is entirely unrelated to work obligations,
 and my attempts to align employment with this sort of research activity have repeatedly failed.
However, I am an extremely stubborn person,
 and I will persist in my more mathematical work even if my pace is slower than I'd like.
For example, I had to heavily triage my original plan to complete this already massively delayed paper in a timely manner
  by dropping a set of planned applications and saving them for follow-up papers.

I have always enjoyed math a lot, since early in grade school.
It was my favorite subject all throughout high school (I was underwhelmed by my science classes until college),
 and was even on several competitive high school math teams.
I would have been a math major in college (rather than the hedge of a dual math/physics major),
 but I wanted to pursue academic research and was repeatedly told that a math degree could only lead to an actuarial career.
While I strayed from a more mathematical career by going to graduate school for physics,
 my research interests in physics have always been of a highly mathematical nature.
I like to view computational physics as a kind of experimental math,
 where approximations and algorithms are tested for their relevance to physical simulation.
My overly simple grad-school perspective on quantum mechanics was as a physical manifestation of linear algebra,
 which meant that computational condensed matter physics was just a very complicated numerical linear algebra problem.
However, working in quantum information theory for five years have given me a broader perspective
 on the statistical and complexity-theoretic aspects of quantum mechanics.

I discussed the background on this project a bit in a [previous post]({% post_url 2019-05-12-linear-scaling-too-little %}).
Around 2007, I was working on a banded Hermitian eigensolver that was inspired by the physics concept of Wannier functions
 (a.k.a. Boys orbitals in quantum chemistry).
These functions demonstrated that simultaneous spatial and spectral locality was possible,
 which allowed for more flexibility in divide-and-conquer strategies for eigensolving beyond the
 [one that had already been established at the time](https://doi.org/10.1137/S0895479892241287).
In the course of these numerical experiments,
it became necessary to fit low-rank approximations of the Cauchy kernel with a general form

$$ \frac{1}{x - y} \approx \sum_{i=1}^{r} \frac{f_i(y)}{x - y_i} $$

where I was free to choose both $$y_i$$ and $$f_i(y)$$.
For a fixed value of $$y$$, this was a standard linear minimax optimization problem.
I had previously messed around with linear and nonlinear minimax optimization problems
 that I thought would be useful in electronic structure
 (for example, [my paper on rational approximations of Fermi-Dirac functions](https://doi.org/10.1063/1.4965886) originated from earlier attempts during grad school),
 so I already had some experience with problems of this form.
I proceeded as I had in the past, with an ad-hoc implementation of the Remez algorithm.
This time, I could make use of the analytical expressions for Cauchy matrix inverses and determinants
 in fitting the approximant at a set of max-residual points.
It turned out that the relative error was what would lead to the tightest error bounds in
 my intended application, so I adapted my solution to minimize relative error.
I then noticed something very surprising: the location of the maximum residual points did not change when I changed $$y$$.
Because of the Cauchy matrix inverse formula,
 this meant that the optimal $$f_i(y)$$ were rational functions rather than something more general and arbitrary.
Also, I was observing much more regular trends in the solutions than in other problems that I had solved,
 such as the maximum residual points and optimal $$y_i$$ values for different $$r$$ values collapsing
 onto a common function just like with Chebyshev nodes.

I don't keep detailed research records (I've mostly operated under the assumption that published papers are record enough),
 but at some point either in late grad school or early in my academic post-doc at UT Austin,
 I decided that this result was probably optimal with respect to maximum relative error from a basic dimension-counting argument
 (I couldn't see how a more general functional form could reduce the maximum error) and I wanted to prove it.
I'm not really big into proving things because it's hard and you aren't really rewarded for doing so as a physicist.
However, I do think electronic structure simulations need a more rigorous underpinning,
 and there is probably a small set of core results waiting to be discovered that are important enough for a formal proof.
I decided that this was one such result.
My basic proof strategy was to prove separate upper and lower bounds, whereby optimality was proven if the bounds were equal.
I proved the upper bound very quickly because it was a very straightforward task of restricting a minimization to a simple subset of the original domain.

I finally put together the lower-bound proof while at Sandia,
 but only after returning to it multiple times for brief but intense bursts of activity.
Around summer 2012, I finally learned about Zolotarev's work in applying elliptic integrals/functions to rational approximation.
This was very exciting at the time, because it explained all of the special structure that I had observed numerically.
I can't imagine how anyone could make the connection from those numerical observations to the theory of elliptical integrals,
 and indeed Zolotarev had worked in the other direction - his adviser, Chebyshev, had instructed him to look for useful applications of elliptic integrals.
Unfortunately, my excitement died down when I realized that none of this made a lower-bound proof any easier,
 although I could now rule out the previously-unexplained structure as being relevant to a proof.
I did eventually cobble together a lower-bound proof as I was exposed to the necessary mathematical ideas while at Sandia.
I worked on an idea for [relaxing classical stat mech problems into linear programs](https://arxiv.org/abs/1603.05180),
 which was itself a catastrophic failure, but it increased my familiarity with convex optimization and linear programming (two linear programs being essential steps in my proof).
Also, I was exposed to many lower-bound proofs of classical computational complexity in quantum information theory
 that were a part of complexity-theoretic separation proofs between classical and quantum computing power.
While none of those proofs were directly relevant, I learned about the wide variety of clever tricks and strategies
 that are often employed in producing lower bounds for optimization problems.
I finally had a serviceable draft of a proof in summer 2017, which I polished up a few months ago for this paper.
I probably could have wrapped this up a lot sooner if Sandia was supportive of my research interests, but it was not,
 and research tends to go a lot slower when you are being paid to do something else as your full-time job.

This is my oldest research project that has been brought to fruition,
 and hopefully it is a sign of maturity and a precursor to other results following suit (albeit very slowly).
My initial proof in summer 2017 was tied to a paper on banded Hermitian eigensolvers,
 and it collapsed under the weight of trying to accomplish too much at once.
Up until three weeks ago, this paper was tied to three applications that would have further delayed it by many months if I hadn't cut them.
I have a natural tendency to make big plans for papers,
 and I need to actively fight that by breaking up projects into smaller publishable pieces.
Having shorter, more numerous papers is advantageous for many reasons,
 and it is almost essential for surviving the rat race of modern academia.

My immediate next research priority is finishing up the first delayed application of this paper to electronic structure calculations.
However, I need to do a better job of mixing blog posts about active research papers
 with other research discussions about other interests that are in a more passive mode.
I'd like to start discuss quantum computing on this blog soon, and I have two quantum computing papers lined up as #2 and #4 in my publication queue.
I also continue to refine and develop my semiempirical electronic structure plans,
 and I will discuss that at some point as well.
I am happy to have finally finished this long-delayed paper,
 but my research agenda and career are very deep in a hole
 and it will take a lot of work before I can escape that hole.
There will be a lot more research triage in my future.

gha_language: Jupyter Notebook

gha_license_id: MIT


text:
## Bingo API for using with Elasticsearch

**IN DEVELOPMENT**

This SDK is intended to:

- Read molecules from SDF, Smiles, Mol, CML files, etc
- Index them into Elasticsearch
- Have ability to search molecules efficiently with different similarity metrics (Tanimoto, Tversky, Euclid)
- Filter additionally based on text or number fields attached to the records

#### Supported Elasticsearch versions and distributions

We are supporting 7.15.x Elasticsearch and most major distributions available (AWS, Elastic, OpenDistro, etc)

*TBD test against other 7.x versions*

### Installation

#### Dependency

Install dependency using pip

```
pip install bingo-elastic
```

Install async version

```
pip install bingo-elastic[async]
```

bingo-elastic async version supports all the same methods to index and search
molecules as sync. To use async version, just instantiate `AsyncElasticRepository`

#### Elastisearch installation

You could use any favourite Elasticsearch distribution:

- [Open Distro Elasticsearch](https://opendistro.github.io/for-elasticsearch-docs/docs/install/)
- [Elasticsearch](https://www.elastic.co/guide/en/elasticsearch/reference/current/install-elasticsearch.html)
- [OpenSearch](https://opensearch.org/docs/latest/opensearch/install/index/)
- many many more available on premise and as cloud products & services

Something simple could be done as following:

```
docker run -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e "indices.query.bool.max_clause_count=4096" docker.elastic.co/elasticsearch/elasticsearch:7.15.1
```

### Usage

#### Create ElasticRepository

Sync

```
repository = ElasticRepository(IndexName.BINGO_MOLECULE, host="<IP_ADDRESS>", port=9200)
```

Async

```
repository = AsyncElasticRepository(IndexName.BINGO_MOLECULE, host="<IP_ADDRESS>", port=9200)
...
repository.close()
```

Async version also supports async context manager to auto close connections:

```
async with AsyncElasticRepository(IndexName.BINGO_MOLECULE, host="<IP_ADDRESS>", port=9200) as rep:
    ...
```

Using with FastAPI:

```
app = FastAPI()
rep = AsyncElasticRepository(IndexName.BINGO_MOLECULE, host="<IP_ADDRESS>", port=9200)

# This gets called once the app is shutting down.
@app.on_event("shutdown")
async def app_shutdown():
    await rep.close()
```

Other customisations like SSL, custom number of shards/replicas, refresh interval, and many more are supported by `ElasticRepository` and `AsyncElasticRepository`

#### Read Indigo records from file

IndigoRecord can be created from IndigoObject.

Full usage example:
```
from bingo_elastic.model.record import IndigoRecord
from indigo import Indigo

indigo = Indigo()
compound = indigo.loadMoleculeFromFile("composition.mol")
indigo_record = IndigoRecord(indigo_object=compound)
```

`bingo_elastic` provides helpers to load sdf, cml, smiles and smi files

```
from bingo_elastic.model import helpers

sdf = helpers.iterate_sdf("compounds.sdf")
cml = helpers.iterate_cml("compounds.cml")
smi = helpers.iterate_smiles("compounds.smi")
```

Also function `helpers.iterate_file(file: Path)` is available. This function
selects correct iterate function by file extension. The `file` argument must
be `pathlib.Path` instance

```
from bingo_elastic.model import helpers
from pathlib import Path

sdf = helpers.iterate_file(Path("compounds.sdf"))
```

#### Index records into Elasticsearch

Full usage example sync:

```
from bingo_elastic.model import helpers
from bingo_elastic.elastic import, ElasticRepository IndexName
from pathlib import Path

repository = ElasticRepository(IndexName.BINGO_MOLECULE, host="<IP_ADDRESS>", port=9200)
sdf = helpers.iterate_file(Path("compounds.sdf"))
repository.index_records(sdf)
```

Full usage example async:

_Async indexing and search requires event loop created_

```
import asyncio
from bingo_elastic.model import helpers
from bingo_elastic.elastic import AsyncElasticRepository, IndexName
from pathlib import Path

async def index_compounds():
    repository = AsyncElasticRepository(IndexName.BINGO_MOLECULE, host="<IP_ADDRESS>", port=9200)
    sdf = helpers.iterate_file(Path("compounds.sdf"))
    await repository.index_records(sdf)

asyncio.run(index_compounds)

```

*CAVEAT*: Elasticsearch doesn't have strict notion of commit, so records might appear in the index later on
Read more about it here -  https://www.elastic.co/guide/en/elasticsearch/reference/master/index-modules.html#index-refresh-interval-setting

For indexing one record the the method `ElasticRepository.index_record` can be used

#### Retrieve similar records from Elasticsearch

Sync:
```
from bingo_elastic.predicates import SimilarityMatch
alg = SimilarityMatch(target, 0.9)
similar_records = repository.filter(similarity=alg, limit=20)
```

Async:
```
from bingo_elastic.predicates import SimilarityMatch
alg = SimilarityMatch(target, 0.9)
similar_records = await repository.filter(similarity=alg, limit=20)
```

In this case we requested top-20 most similar molecules compared to `target` based on Tanimoto similarity metric

Supported similarity algorithms:
- `SimilarityMatch` or `TanimotoSimilarityMatch`
- `EuclidSimilarityMatch`
- `TverskySimilarityMatch`

#### Find exact records from Elasticsearch

Sync:
```
exact_records = repository.filter(exact=target, limit=20)
```

Async:
```
exact_records = await repository.filter(exact=target, limit=20)
```

In this case we requested top-20 candidate molecules with exact same fingerprint to `target`.
`target` should be an instance of `IndigoRecord` class.

#### Subsctructure match of the records from Elasticsearch

Sync:
```
submatch_records = repository.filter(substructure=target)
```

Async:
```
submatch_records = await repository.filter(substructure=target)
```

In this case we requested top-10 candidate molecules with exact same fingerprint to `target`.

#### Custom fields for molecule records

_Async protocol exact same, just don't forget to `await`_

Indexing records with custom fields

```
indigo_record = IndigoRecord(indigo_object=compound)
indigo_record.chembl_id = "CHEMBL2063090"
indigo_record.compound_key = "GRAZOPREVIR"
indigo_record.internal_id = 10001
```

Searching similar molecules to the target and filtering only those that have value of the `chembl_id` equals to `CHEMBL2063090`

```
from bingo_elastic.queries import KeywordQuery

alg = TanimotoSimilarityMatch(target)
result = elastic_repository.filter(similarity=alg,
                                   chembl_id=KeywordQuery("CHEMBL2063090"))
```

Or you can just write:

```
result = elastic_repository.filter(similarity=alg,
                                   chembl_id=RangeQuery(1, 10000))
```

You could also use similarly wildcard and range queries

```
from bingo_elastic.queries import WildcardQuery

result = elastic_repository.filter(chembl_id=WildcardQuery("CHEMBL2063*"))

```

```
from bingo_elastic.queries import RangeQuery

result = elastic_repository.filter(internal_id=RangeQuery(1000, 100000))

```

repository: epam/Indigo

repo_name: epam/Indigo


text:
---
name: Bug raport
about: bug with crash and without
title: ''
labels: 'type bugs'
---

Please make sure your issue complies with these guidelines:
- [ ] Make sure you are on the latest version of PMMP & PiggyFactions
- [ ] Issue must have not been reported previously

### version info
* pmmp:
* status:
* php:

### description
bug description here

### console error
console error here


text:
---
layout: post
title: Phalcon v4.0.0-alpha2 released
date: 2019-02-02T17:18:06.203Z
tags:
  - phalcon
  - phalcon4
  - release
  - alpha
---
The Phalcon Team is happy to announce the release of **v4.0.0 Alpha 2**! [Github Tag](https://github.com/phalcon/cphalcon/releases/tag/v4.0.0-alpha.2)

We cannot thank your community enough! By reporting bugs, offering feedback and suggestions, pull requests, being active in discussions about how the framework should move towards the future, you all help us make Phalcon better with every release.
<!--more-->

As mentioned before, we took a different approach with our releases, with v4. The goal is to release often and release small. This way we allow the community to catch up, find bugs, provide feedback etc.

We are releasing the second alpha version today, which has a lot of bug fixes from the first alpha as well as completing work already commissioned for the v4 series. You can see our project [here](https://github.com/phalcon/cphalcon/projects/3)

### Changelog
#### Added
- Added `notFound()` method in `Phalcon\Translate\Adapter\NativeArray` which returns the key requested if not found. The method can be overriden when extending the class, returning what the developer needs [#13007](https://github.com/phalcon/cphalcon/pull/13007)
- Added `Phalcon\Service\Locator`, `Phalcon\Service\LocatorInterface` and `Phalcon\Service\LocatorFactoryInterface` to allow for the creation of service locators and factories throughout the application [#13771](https://github.com/phalcon/cphalcon/pull/13771)
- Added `Phalcon\Http\Request::setParameterFilters`. It allows you to preset filters for specific input (i.e. `id`, `name` etc.). You can then retrieve the automatcally sanitized values using `Phalcon\Http\Request::getFilteredQuery`, `Phalcon\Http\Request::getFilteredPost` and `Phalcon\Http\Request::getFilteredPut` [#13488](https://github.com/phalcon/cphalcon/issues/13488)

#### Fixed
- Fixed `Phalcon\Mvc\Micro::handle` to properly return a response object [#13712](https://github.com/phalcon/cphalcon/issues/13712)
- Fixed `Phalcon\Cache\Backend\Libmemcached` returning "empty" values being as `null` when they could be `0`, `false` or empty `string`. [#13497](https://github.com/phalcon/cphalcon/issues/13497)
- Fixed session adapters to properly implement [`SessionHandlerInterface::write`](http://php.net/manual/en/sessionhandlerinterface.write.php)
- Fixed `Phalcon\Session\Manager` to not interact with `$_SESSION` variable if the session has not been started [#13718](https://github.com/phalcon/cphalcon/issues/13718), [#13520](https://github.com/phalcon/cphalcon/issues/13520)
- Fixed `Phalcon\Cli\Console` class not found error if handling the same module twice [#13724](https://github.com/phalcon/cphalcon/issues/13724)
- Fixed `Phalcon\Cache\Backend\Libmemcached` returning "empty" values being as `null` when they could be `0`, `false` or empty `string`. [#13497](https://github.com/phalcon/cphalcon/issues/13497)
- Fixed `Phalcon\Mvc\View\Engine\Volt\Compiler::functionCall` building the incorrect code for the following tags; `select`, and `select_static` [#13459](https://github.com/phalcon/cphalcon/issues/13459)
- Fixed `Phalcon\Tag\Select` not rendering without any options.

#### Changed
- Changed the `Phalcon\Tag::renderTitle()` parameters such as `Phalcon\Tag::getTitle()` [#13706](https://github.com/phalcon/cphalcon/pull/13706)
- Changed the `Phalcon\Html\Tag::renderTitle()` parameters such as `Phalcon\Html\Tag::getTitle()` [#13706](https://github.com/phalcon/cphalcon/pull/13706)
- Changed the `Phalcon\Version::get()` to follow [semantic versioning](https://semver.org/) [#13720](https://github.com/phalcon/cphalcon/pull/13720)
- Changed the `Phalcon\Translate\Adapter\NativeArray` to accept a new parameter in the constructor `triggerError`. This will trigger an error if the key is not found [#13007](https://github.com/phalcon/cphalcon/pull/13007)
- Changed the default action of `Phalcon\Acl\Memory`to be `Acl::DENY` instead of `Acl::ALLOW` [#13758](https://github.com/phalcon/cphalcon/pull/13758)
- Changed `Phalcon\Mvc\User\Plugin` to `Phalcon\Plugin` [#13749](https://github.com/phalcon/cphalcon/issues/13749)
- Changed `Phalcon\Exception` to implement `\Throwable` interface.[#13750](https://github.com/phalcon/cphalcon/issues/13758)
- Changed `Phalcon\Http\Cookie`. The `httpOnly` property is no longer initialised with a value [#13464](https://github.com/phalcon/cphalcon/issues/13464)
- Changed the default action for no arguments of `Phalcon\Acl\Memory`to be `Acl::DENY` instead of `Acl::ALLOW` [#13769](https://github.com/phalcon/cphalcon/issues/13769)
- Changed the implementation of `Phalcon\Filter`. It uses a service locator and a service locator factory now. It has more sanitizers now. [#13060](https://github.com/phalcon/cphalcon/issues/13060)

### Documentation
We have been working in parallel to enhance our documentation and rewrite all the articles (or at least check them for accuracy) for v4. The progress is slow but steady and it will continue until we finalize all the documentation.

Several contributors have jumped in and are helping with all the documents, rewriting, proof reading and offering corrections. The documentation repository is located [here](https://github.com/phalcon/docs), and our docs application [here](https://github.com/phalcon/docs-app). Others have also visited our project on [Crowdin](https://crowdin.com/project/phalcon-documentation), and are helping with translating our documents to their native tongue. The list of already refactored/rewritten documents can be found in our [project for v4](https://github.com/phalcon/docs/projects/1) in the `docs` repository.

> Please note that we will accept changes to the [docs](https://github.com/phalcon/docs) repository only for the English language (`en` folder). All other languages are handled by [Crowdin](https://crowdin.com).
{: .alert .alert-info }

### Installation/Upgrade
The packages in [packagecloud.io](https://packagecloud.io/phalcon) are being updated (at the time of this post) and will be ready soon. You will need to use the `mainline` repository to install v4.0.0-alpha2. You can also download the zip file, as well as DLLs for Windows, from our release page [here](https://github.com/phalcon/cphalcon/releases/tag/v4.0.0-alpha.2).

You can also clone the repository and checkout the tag, and then run

```bash
zephir fullclean
zephir build
```

to install the new extension. Detailed installation instructions can be found in our [documentation page](https://docs.phalcon.io/4.0/en/installation).

### Thank you
Once again a huge thank you to all of our contributors! You guys have helped us a lot. You can help us even more by installing this version and testing it. If you find bugs, please report them in our [Github Issues](https://github.com/phalcon/cphalcon/issues) page. Alternatively you can always join us in our [Discord server](https://phalcon.link/discord) or our [Forum](https://phalcon.link/forum).

<3 Phalcon Team

repository: jenovateurs/blog

repo_name: jenovateurs/blog


text:
# textcom
A Text-Based Roguelike in Python, based on XCOM: Enemy Unknown

**Running the game:**

Please have Python 3.x installed (where x is any number, just make sure it's 3.something, preferably 3.4.3). You can find a download at www.python.org/downloads Either double click on the program to run it in Terminal/IDLE/Command Prompt, or right click and go Open With...IDLE Shell.

If you already have it installed but aren't sure what version it is, just run IDLE if you can, and it should tell you. If you don't have Python 3.x, please upgrade to it, because the game won't run as well and might crash.

**How to play:**

On your turn, a list of takeable actions will be shown. Enter the number of the action you wish to take. It's that simple.
 Every 5 rooms there will be an upgrade shop, where you can buy new weapons and augment your soldier.

**Next steps:**

Perks. More weapons. Weapon upgrades.

**Thanks to:**

Everyone who forked this and submitted bug reports! Big thanks to /u/net_goblin, who, without the help of, the game would not be as optimised as it is.

-/u/TachyonNZ

repository: TachyonNZ/textcom

gha_language: Python

repo_name: TachyonNZ/textcom


text:
# dtk-bibliography

This package contains the bibliography for "Die TeXnische Komödie", the journal
of the German-speaking user group.

It is updated on a quarterly basis, last update 2023-06-22: updated for issue
2023-02

# How to produce dtk-bibliography.pdf

Run dtk-bibliography.tex through Arara or run the following commands manually:

* lualatex dtk-bibliography.tex
* biber dtk-bibliography
* lualatex dtk-bibliography.tex
* lualatex dtk-bibliography.tex

Note that dtk-authoryear.bbx and dtk-authoryear.dbx must be in the same directory
respectively the (local) texmf tree.

# License

This material is subject to the LaTeX Project Public License 1.3c.

repository: dante-ev/dtk-bibliography

gha_language: TeX

repo_name: dante-ev/dtk-bibliography


text:
# Class: SpriteAnimation

SpriteAnimation is used to define an animation as a series of materials to
apply to a Sprite, with specifications on key frames, frame rate, and if the
animation should repeat.

SpriteAnimation uses an array of key frames to iterate through for
defining the materials to apply and for how long to apply them.

## Hierarchy

* **SpriteAnimation**

## Index

### Constructors

* [constructor](spriteanimation.md#constructor)

### Properties

* [durationSinceRepeat](spriteanimation.md#durationsincerepeat)
* [frameRate](spriteanimation.md#framerate)
* [keyframes](spriteanimation.md#keyframes)
* [repeat](spriteanimation.md#repeat)
* [repeatCount](spriteanimation.md#repeatcount)

## Constructors

###  constructor

\+ **new SpriteAnimation**(`keyframes`: [SpriteKeyFrame](spritekeyframe.md)[], `frameRate`: number, `repeat`: number, `durationSinceRepeat`: number, `repeatCount`: number): *[SpriteAnimation](spriteanimation.md)*

**Parameters:**

Name | Type | Default |
------ | ------ | ------ |
`keyframes` | [SpriteKeyFrame](spritekeyframe.md)[] | - |
`frameRate` | number | - |
`repeat` | number | - |
`durationSinceRepeat` | number | 0 |
`repeatCount` | number | 0 |

**Returns:** *[SpriteAnimation](spriteanimation.md)*

## Properties

###  durationSinceRepeat

• **durationSinceRepeat**: *number*

State tracker, keeping track of the time since the animation has repeated.

___

###  frameRate

• **frameRate**: *number*

The frame rate of the animation in frames per second

___

###  keyframes

• **keyframes**: *[SpriteKeyFrame](spritekeyframe.md)[]*

Key frames to apply, each one specifies a material and duration of
keyframe in frames.

___

###  repeat

• **repeat**: *number*

If the animation should repeat, a value of 0 means 0 repetitions and it
will not repeat, a value of 5 means 5 repeats. A value of -1 means
infinite repetitions.

___

###  repeatCount

• **repeatCount**: *number*

State tracker, keeping track of the number of times the animation has repeated.

repository: jthomperoo/JamJarWeb

repo_name: jthomperoo/JamJarWeb


text:
# [Knex.js](https://knexjs.org/)

Knex.js is a SQL query builder that's used to take away the need for the developer to work with raw queries (for the most part...). Click [here](https://devhints.io/knex) for a useful cheatsheet.

## Getting Started

First, install the Knex CLI via `npm i -g knex`.

### Migrations

Migration files allow us to create/update tables easily. While in the `server/db` directory (i.e. the one with the `knexfile`), simple running `knex migrate:make migration_name` will create a new migration file.

Once you've finished writing the migration, running `knex migrate:latest` will update your database to match your latest migrations.

If you happen to make updates to your migrations, first run `knex migrate:rollback`, then rerun `knex migrate:latest`.

### Seed Files

Seed files are used to populate your database with an initial set of data. To create a seed file, run `knex seed:make seed_name`.

This will generate a file in which there is an insert method. Using the table in which you want to insert rows, add in however many objects you want. When they're added, running `knex seed:run` will execute all seed files.

 });

// But this way, it filters out the rows for you.
knex.select().from('users').then(users => { ... });
```

### `SELECT ... WHERE`

```
knex.raw('SELECT * FROM users WHERE user_id = 1;').then(user => { ... });

knex.select().from('users').where('user_id', 1).then(user => { ... });
```

### `INSERT`

```
const { first_name, last_name, email, username, password } = req.body.user;

knex.raw(`
    INSERT INTO users (first_name, last_name, email, username, password)
    VALUES [?, ?, ?, ?, ?];
`, [first_name, last_name, email, username, password]).then(() => {
    ...
})

knex('users').insert({
    first_name: first_name,
    last_name,                  // shorthand
    email,
    username,
    password
}).then(() => { ... });
```

### `UPDATE`

```
const { user_id } = req.params;
const { first_name } = req.body;

knex.raw('UPDATE users SET first_name = ? WHERE user_id = ?;', [first_name, user_id]).then(() => {
    ...
});

knex('users').where('user_id', user_id).update({
    first_name
}).then(() => { ... });
```

### `DELETE`

```
const { user_id } = req.params;

knex.raw('DELETE FROM users WHERE user_id = ?;', user_id).then(() => { ... });

knex('users').where('user_id', user_id).del().then(() => { ... });
```

### `INNER JOIN`

```
const { user_id } = req.params;

knex.raw('SELECT * FROM books INNER JOIN users ON
            (books.author_id = users.id);').then(books => { ... });

knex('books').innerJoin('users', 'books.author_id', 'users.id').then(books => { ... });
```

repository: Weieiei/Kronologi

path: /server-old/Knex Info.md

filename: Knex Info.md

repo_name: Weieiei/Kronologi


text:
# iPhoneMK

iPhoneMK is a loose collection of Objective-C classes for the iPhone SDK that I have put together over time which I feel might be of general utility to people.

If you find any of these classes useful, I'd love to hear about it. If you have improvements for any of them, feel free to commit your changes. If you have any classes you would like to add to the collection, please provide them.

## Class List

### Views
* `MKNetworkImageView` - A view that displays an image downloaded from the internet.
* `MKNumberBadgeView` - A view that replicates and extends the number badge UI element in iOS
* `MKSoundCoordinatedAnimationView` - A view that enables "scripting" of `CAAnimation`'s via a plist.
* `MKTouchTrackingView` - A light weight view that simplifies detecting and responding to touches. Includes a variant that will properly detect touches against a animating `MKSoundCoordinatedAnimationLayer` layer that moves location on screen.

### Table View Cells
* `MKIconCheckMarkTableViewCell` - A cell that manages a boolean state and uses a configurable set of `UIImage` objects to represent that state.
* `MKSocialShareTableViewCell` - A cell that makes it easy to use the `SLComposeViewController` features of iOS 6 from a `UITableView`.
* `MKSwitchControlTableViewCell` - A cell that simply provides a UISwitch to control a boolean state.

### Other
* `MKParentalGate` - A set of classes that implements a dexterity-based parental gate. Intended for use in apps for children under 5.

## ARC Support

Some of iPhoneMK is not ARC-enabled code, some requires ARC. Compiler errors have been built into the code base to help you identify which classes need ARC and which don't. Furthermore, the errors instruct you how to change that file's compilation method to support it's ARC-mode. Basically, if you have an ARC-enabled project, you will need to use the `-fno-objc-arc` compiler flag on iPhoneMK source files that are not ARC-enabled. Similarly, if you are not using ARC, you will have to use the `-fobjc-arc` compiler flag on iPhoneMK source files that require ARC.

## License

iPhoneMK is licensed under the Apache License, Version 2.0


text:
### [Click to download the dataset](https://www.kaggle.com/maksymshkliarevskyi/reddit-data-science-posts/download)

### [Reddit-Data-Science-Posts Dataset on Kaggle](https://www.kaggle.com/maksymshkliarevskyi/reddit-data-science-posts)

### **This dataset includes over 500,000 posts from 19 Date Science subreddits:**

1. [r/analytics](https://www.reddit.com/r/analytics/) (reddit_Analytics.csv),
2. [r/deeplearning](https://www.reddit.com/r/deeplearning/) (reddit_DL.csv),
3. [r/datascience](https://www.reddit.com/r/datascience/) (reddit_DS.csv),
4. [r/datasets](https://www.reddit.com/r/datasets/) (reddit_Datasets.csv),
5. [r/kaggle](https://www.reddit.com/r/kaggle/) (reddit_Kaggle.csv),
6. [r/learnmachinelearning](https://www.reddit.com/r/learnmachinelearning/) (reddit_LML.csv),
7. [r/MachineLearning](https://www.reddit.com/r/MachineLearning/) (reddit_ML.csv),
8. [r/statistics](https://www.reddit.com/r/statistics/) (reddit_Statistics.csv),
9. [r/artificial](https://www.reddit.com/r/artificial/) (reddit_AI.csv),
10. [r/AskStatistics](https://www.reddit.com/r/AskStatistics/) (reddit_ASt.csv),
11. [r/computerscience](https://www.reddit.com/r/computerscience/) (reddit_CS.csv),
12. [r/computervision](https://www.reddit.com/r/computervision/) (reddit_CV.csv),
13. [r/dataanalysis](https://www.reddit.com/r/dataanalysis/) (reddit_DA.csv),
14. [r/dataengineering](https://www.reddit.com/r/dataengineering/) (reddit_DE.csv),
15. [r/DataScienceJobs](https://www.reddit.com/r/DataScienceJobs/) (reddit_DSJ.csv),
16. [r/datascienceproject](https://www.reddit.com/r/datascienceproject/) (reddit_DSP.csv),
17. [r/data](https://www.reddit.com/r/data/) (reddit_Data.csv),
18. [r/MLQuestions](https://www.reddit.com/r/MLQuestions/) (reddit_MLq.csv),
19. [r/rstats](https://www.reddit.com/r/rstats/) (reddit_Rst.csv).

repository: lazycrazyowl/Reddit-Data-Science-Posts

branch_name: refs/heads/main

repo_name: lazycrazyowl/Reddit-Data-Science-Posts


text:
---
title: How do I mine LBRY credits?
category: mining
---
Library Credits (LBC) are mined over a 20-year Proof of Work period.
Block rewards increase every 100 blocks by 1LBC, peak at 500, and decline slowly.

LBRY mining is dominated by the GPU market and we don't see CPU mining as econonmically viable at this point.  If you still want to CPU mine to help the network, see instructions below.

For GPU mining, please see our list of [pools](https://lbry.io/faq/mining-pools). Each pool has a slightly different setup so please check their Getting Started page.

For CPU mining, LBRY binaries are out for OS X, Windows, and Ubuntu. Others may try compiling from source.

You can download the latest binaries [here](https://github.com/lbryio/lbrycrd/releases/latest)

## Mining on Ubuntu

1. unzip the binaries, and `cd` into the directory containing them
1. `./lbrycrdd -server -printtoconsole -gen`
1. If you need to start over, run `rm -rf bins.zip lbry* ~/.lbry*`. **Note:** this will delete your wallet and any credits you may have.

## Mining on macOS

1. unzip the binaries, and `cd` into the directory containing them
1. `mkdir ~/Library/Application\ Support/lbrycrd`
1. `sudo chown -R "$(whoami)" ~/Library/Application\ Support/lbrycrd`
1. `echo -e "rpcuser=lbryrpc\nrpcpassword=$(env LC_CTYPE=C LC_ALL=C tr -dc A-Za-z0-9 < /dev/urandom | head -c 16 | xargs)" > ~/Library/Application\ Support/lbrycrd/lbrycrd.conf`
1. `./lbrycrdd -server -printtoconsole -gen`
1. If you need to start over, run `rm -rf bins.zip lbry* ~/.lbry ~/Library/Application\ Support/lbrycrd`. **Note:** this will delete your wallet and any credits you may have.

## Compiling

Join us on [Slack](https://slack.lbry.io) if you need help compiling from source!


text:
## Contributing

This code is presented as an archive; we are unable to accept contributions at this time.

## Contributor License Agreement

Contributions to this project must be accompanied by a Contributor License
Agreement (CLA). You (or your employer) retain the copyright to your
contribution; this simply gives us permission to use and redistribute your
contributions as part of the project. Head over to
<https://cla.developers.google.com/> to see your current agreements on file or
to sign a new one.

You generally only need to submit a CLA once, so if you've already submitted one
(even if it was for a different project), you probably don't need to do it
again.


text:
### 2014-11-04

#### objective-c
* [
      yuantiku
      /
      YTKNetwork
](https://github.com/yuantiku/YTKNetwork):
      YTKNetwork is a high level request util based on AFNetworking.

* [
      linkedin
      /
      Hakawai
](https://github.com/linkedin/Hakawai):
      A powerful, extensible UITextView.

* [
      venmo
      /
      VENTouchLock
](https://github.com/venmo/VENTouchLock):
      A Touch ID and Passcode framework used in the Venmo app.

* [
      krzysztofzablocki
      /
      KZNodes
](https://github.com/krzysztofzablocki/KZNodes):
      Have you ever wonder how you could make Origami like editor in 1h ?

* [
      facebook
      /
      AsyncDisplayKit
](https://github.com/facebook/AsyncDisplayKit):
      Smooth asynchronous user interfaces for iOS apps.

* [
      krzysztofzablocki
      /
      KZPlayground
](https://github.com/krzysztofzablocki/KZPlayground):
      Playgrounds for Objective-C

* [
      lanayotech
      /
      vagrant-manager
](https://github.com/lanayotech/vagrant-manager):
      Manage your vagrant machines in one place with Vagrant Manager for OS X

* [
      krzysztofzablocki
      /
      KZBootstrap
](https://github.com/krzysztofzablocki/KZBootstrap):
      iOS project bootstrap aimed at high quality coding.

* [
      dogo
      /
      SCLAlertView
](https://github.com/dogo/SCLAlertView):
      Beautiful animated Alert View. Written in Swift but ported to Objective-C

* [
      jaredsinclair
      /
      JTSImageViewController
](https://github.com/jaredsinclair/JTSImageViewController):
      An interactive iOS image viewer that does it all: double tap to zoom, flick to dismiss, et cetera.

* [
      rs
      /
      SDWebImage
](https://github.com/rs/SDWebImage):
      Asynchronous image downloader with cache support with an UIImageView category

* [
      yechunjun
      /
      CCLogSystem
](https://github.com/yechunjun/CCLogSystem):
      A Log system for iOS.Support print, record and review logs.

* [
      Mantle
      /
      Mantle
](https://github.com/Mantle/Mantle):
      Model framework for Cocoa and Cocoa Touch

* [
      realm
      /
      realm-cocoa
](https://github.com/realm/realm-cocoa):
      Realm is a mobile database: a replacement for Core Data & SQLite

* [
      MortimerGoro
      /
      MGSwipeTableCell
](https://github.com/MortimerGoro/MGSwipeTableCell):
      An easy to use UITableViewCell subclass that allows to display swippable buttons with a variety of transitions.

* [
      rowanj
      /
      gitx
](https://github.com/rowanj/gitx):
      Fork of Pieter's nice git GUI for OS X.  Includes branch/tag sidebar and various fixes. Current development focus is on removing legacy git command line usage in favour of libgit2 and objective-git.

* [
      SamRothCA
      /
      Today-Scripts
](https://github.com/SamRothCA/Today-Scripts):
      A widget for running scripts in the Today View in OS X Yosemite's Notification Center

* [
      hackiftekhar
      /
      IQKeyboardManager
](https://github.com/hackiftekhar/IQKeyboardManager):
      IQKeyboardManager is a drop-in universal library which allows you to prevent issues of the keyboard sliding up and covering UITextField/UITextView without needing you to writing any code and much more.

* [
      magicalpanda
      /
      MagicalRecord
](https://github.com/magicalpanda/MagicalRecord):
      Super Awesome Easy Fetching for Core Data 1!!!11!!!!1!

* [
      jdg
      /
      MBProgressHUD
](https://github.com/jdg/MBProgressHUD):
      MBProgressHUD + Customizations

* [
      sammcewan
      /
      WYPopoverController
](https://github.com/sammcewan/WYPopoverController):
      WYPopoverController is for the presentation of content in popover on iPhone / iPad devices. Very customizable.

* [
      krzysztofzablocki
      /
      KZLineDrawer
](https://github.com/krzysztofzablocki/KZLineDrawer):
      Beatiful and fast smooth line drawing algorithm for iOS - as seen in Foldify.

* [
      jessesquires
      /
      JSQMessagesViewController
](https://github.com/jessesquires/JSQMessagesViewController):
      An elegant messages UI library for iOS

* [
      skywinder
      /
      ActionSheetPicker-3.0
](https://github.com/skywinder/ActionSheetPicker-3.0):
      Quickly reproduce the dropdown UIPickerView / ActionSheet functionality on iOS.

* [
      ksuther
      /
      KSImageNamed-Xcode
](https://github.com/ksuther/KSImageNamed-Xcode):
      Xcode plug-in that provides autocomplete for imageNamed: calls

#### go
* [
      sosedoff
      /
      pgweb
](https://github.com/sosedoff/pgweb):
      Web-based PostgreSQL database browser

* [
      docker
      /
      docker
](https://github.com/docker/docker):
      Docker - the open-source application container engine

* [
      GoogleCloudPlatform
      /
      kubernetes
](https://github.com/GoogleCloudPlatform/kubernetes):
      Container Cluster Manager

* [
      9seconds
      /
      ah
](https://github.com/9seconds/ah):
      A better history

* [
      gocardless
      /
      logjam
](https://github.com/gocardless/logjam):
      a log shipping tool

* [
      bndr
      /
      gojenkins
](https://github.com/bndr/gojenkins):
      Jenkins API Client in Go

* [
      zettio
      /
      weave
](https://github.com/zettio/weave):
      The Docker Network

* [
      limetext
      /
      lime
](https://github.com/limetext/lime):
      Open source API-compatible alternative to Sublime Text

* [
      syncthing
      /
      syncthing
](https://github.com/syncthing/syncthing):
      Open Source Continuous File Synchronization

* [
      astaxie
      /
      build-web-application-with-golang
](https://github.com/astaxie/build-web-application-with-golang):
      A golang ebook intro how to build a web with golang

* [
      getqujing
      /
      qtunnel
](https://github.com/getqujing/qtunnel):
      A secure socket tunnel works on getqujing.com

* [
      hu17889
      /
      go_spider
](https://github.com/hu17889/go_spider):
      [爬虫框架 (golang)] An awesome Go concurrent Crawler(spider) framework. The crawler is flexible and modular. It can be expanded to a Individualized crawler easily or can only use the default crawl components.

* [
      tsenart
      /
      vegeta
](https://github.com/tsenart/vegeta):
      HTTP load testing tool and library. It's over 9000!

* [
      purpleworks
      /
      fleet-ui
](https://github.com/purpleworks/fleet-ui):
      Web based UI for fleet

* [
      flynn
      /
      flynn
](https://github.com/flynn/flynn):
      A next generation open source platform as a service (PaaS)

* [
      coreos
      /
      etcd
](https://github.com/coreos/etcd):
      A highly-available key value store for shared configuration and service discovery

* [
      gogits
      /
      gogs
](https://github.com/gogits/gogs):
      Gogs(Go Git Service) is a painless self-hosted Git Service written in Go.

* [
      lox
      /
      httpcache
](https://github.com/lox/httpcache):
      An RFC7234 compliant golang http.Handler for caching HTTP responses

* [
      dustin
      /
      go-humanize
](https://github.com/dustin/go-humanize):
      Go Humans! (formatters for units to human friendly sizes)

* [
      deis
      /
      deis
](https://github.com/deis/deis):
      Your PaaS. Your Rules.

* [
      gopherjs
      /
      gopherjs
](https://github.com/gopherjs/gopherjs):
      A compiler from Go (golang.org) to JavaScript for running Go code in a browser

* [
      influxdb
      /
      influxdb
](https://github.com/influxdb/influxdb):
      Scalable datastore for metrics, events, and real-time analytics

* [
      go-martini
      /
      martini
](https://github.com/go-martini/martini):
      Classy web framework for Go

* [
      youtube
      /
      vitess
](https://github.com/youtube/vitess):
      vitess provides servers and tools which facilitate scaling of MySQL databases for large scale web services.

* [
      pravj
      /
      geo_pattern
](https://github.com/pravj/geo_pattern):
      now create beautiful generative background images from a string in golang.

#### javascript
* [
      keen
      /
      dashboards
](https://github.com/keen/dashboards):
      Responsive dashboard templates for Bootstrap

* [
      ConnorAtherton
      /
      walkway
](https://github.com/ConnorAtherton/walkway):
      An easy way to animate simple SVG elements.

* [
      romashamin
      /
      Size-Marks-PS
](https://github.com/romashamin/Size-Marks-PS):
      Photoshop script for web designers and front-end engineers

* [
      rtfeldman
      /
      seamless-immutable
](https://github.com/rtfeldman/seamless-immutable):
      Immutable data structures for JavaScript which are backwards-compatible with normal JS Arrays and Objects.

* [
      ksky521
      /
      nodePPT
](https://github.com/ksky521/nodePPT):
      这可能是迄今为止最好的网页版PPT

* [
      techfort
      /
      LokiJS
](https://github.com/techfort/LokiJS):
      javascript embeddable / in-memory database

* [
      angular
      /
      material
](https://github.com/angular/material):
      Material design for Angular

* [
      zodiac
      /
      isicp
](https://github.com/zodiac/isicp):
      Interactive Structure and Interpretation of Computer Programs

* [
      aFarkas
      /
      lazysizes
](https://github.com/aFarkas/lazysizes):
      High performance lazy loader for images (responsive and normal), iframes and scripts, that detects any visibility changes triggered through user interaction, CSS or JavaScript without configuration.

* [
      angular
      /
      angular.js
](https://github.com/angular/angular.js):
      HTML enhanced for web apps

* [
      vesparny
      /
      angular-kickstart
](https://github.com/vesparny/angular-kickstart):
      angular-kickstart - speed up your AngularJS development and testing with a great gulpjs build system.

* [
      enaqx
      /
      awesome-react
](https://github.com/enaqx/awesome-react):
      A collection of awesome React libraries, resources and shiny things.

* [
      B1naryStudio
      /
      js-mobile-console
](https://github.com/B1naryStudio/js-mobile-console):
      Console for debugging web apps right on mobile device

* [
      meteor
      /
      meteor
](https://github.com/meteor/meteor):
      Meteor, an ultra-simple, database-everywhere, data-on-the-wire, pure-Javascript web framework.

* [
      facebook
      /
      immutable-js
](https://github.com/facebook/immutable-js):
      Immutable Persistent Data Collections for Javascript

* [
      facebook
      /
      react
](https://github.com/facebook/react):
      React is a JavaScript library for building user interfaces. It's declarative, efficient, and extremely flexible. What's more, it works with the libraries and frameworks that you already know.

* [
      addyosmani
      /
      tmi
](https://github.com/addyosmani/tmi):
      TMI (Too Many Images) - discover your image weight on the web

* [
      adobe
      /
      brackets
](https://github.com/adobe/brackets):
      An open source code editor for the web, written in JavaScript, HTML and CSS.

* [
      driftyco
      /
      ionic
](https://github.com/driftyco/ionic):
      Advanced HTML5 mobile development framework and SDK. Build great hybrid apps with web technologies you already know and love. Best friends with AngularJS.

* [
      karpathy
      /
      convnetjs
](https://github.com/karpathy/convnetjs):
      Deep Learning in Javascript. Train Convolutional Neural Networks (or ordinary ones) in your browser.

* [
      NimbusFoundry
      /
      Chat
](https://github.com/NimbusFoundry/Chat):
      Group chat plugin on Foundry

* [
      kenwheeler
      /
      mcfly
](https://github.com/kenwheeler/mcfly):
      Flux architecture made easy

* [
      mbostock
      /
      d3
](https://github.com/mbostock/d3):
      A JavaScript visualization library for HTML and SVG.

* [
      joyent
      /
      node
](https://github.com/joyent/node):
      evented I/O for v8 javascript

* [
      jonschlinkert
      /
      remarkable
](https://github.com/jonschlinkert/remarkable):
      Markdown parser, done right. 100% Commonmark support, extensions, syntax plugins, high speed - all in one.

#### ruby
* [
      Homebrew
      /
      homebrew
](https://github.com/Homebrew/homebrew):
      The missing package manager for OS X.

* [
      dtinth
      /
      JXA-Cookbook
](https://github.com/dtinth/JXA-Cookbook):
      Cookbook for JavaScript for Automation in Mac OS X Yosemite

* [
      rails
      /
      rails
](https://github.com/rails/rails):
      Ruby on Rails

* [
      voltrb
      /
      volt
](https://github.com/voltrb/volt):
      A ruby web framework where your ruby runs on both server and client

* [
      jekyll
      /
      jekyll
](https://github.com/jekyll/jekyll):
      Jekyll is a blog-aware, static site generator in Ruby

* [
      caskroom
      /
      homebrew-cask
](https://github.com/caskroom/homebrew-cask):
      A CLI workflow for the administration of Mac applications distributed as binaries

* [
      bbatsov
      /
      ruby-style-guide
](https://github.com/bbatsov/ruby-style-guide):
      A community-driven Ruby coding style guide

* [
      sass
      /
      sass
](https://github.com/sass/sass):
      Sass makes CSS fun again.

* [
      discourse
      /
      discourse
](https://github.com/discourse/discourse):
      A platform for community discussion. Free, open, simple.

* [
      apotonick
      /
      trailblazer
](https://github.com/apotonick/trailblazer):
      A new architecture for Rails.

* [
      plataformatec
      /
      devise
](https://github.com/plataformatec/devise):
      Flexible authentication solution for Rails with Warden.

* [
      opal
      /
      opal
](https://github.com/opal/opal):
      Ruby to Javascript compiler

* [
      elasticsearch
      /
      logstash
](https://github.com/elasticsearch/logstash):
      logstash - logs/event transport, processing, management, search.

* [
      Thibaut
      /
      devdocs
](https://github.com/Thibaut/devdocs):
      API Documentation Browser

* [
      capistrano
      /
      capistrano
](https://github.com/capistrano/capistrano):
      Remote multi-server automation tool

* [
      ruby
      /
      ruby
](https://github.com/ruby/ruby):
      The Ruby Programming Language

* [
      rapid7
      /
      metasploit-framework
](https://github.com/rapid7/metasploit-framework):
      Metasploit Framework

* [
      activeadmin
      /
      activeadmin
](https://github.com/activeadmin/activeadmin):
      The administration framework for Ruby on Rails applications.

* [
      spree
      /
      spree
](https://github.com/spree/spree):
      Spree is a complete open source e-commerce solution for Ruby on Rails.

* [
      CocoaPods
      /
      CocoaPods
](https://github.com/CocoaPods/CocoaPods):
      The Objective-C library dependency manager.

* [
      gogotanaka
      /
      Q
](https://github.com/gogotanaka/Q):
      Do you know one of the best language in this world?

* [
      CocoaPods
      /
      Specs
](https://github.com/CocoaPods/Specs):
      The CocoaPods Master Repo

* [
      watsonbox
      /
      pocketsphinx-ruby
](https://github.com/watsonbox/pocketsphinx-ruby):
      Ruby speech recognition with Pocketsphinx

* [
      intridea
      /
      grape
](https://github.com/intridea/grape):
      An opinionated micro-framework for creating REST-like APIs in Ruby.

* [
      thoughtbot
      /
      laptop
](https://github.com/thoughtbot/laptop):
      A shell script which turns your OS X laptop into an awesome development machine.

repository: josephyzhou/github-trending

gha_language: Go

repo_name: josephyzhou/github-trending


text:
b Server
==========

This is the server component used with the Android and iPhone security labs available at https://github.com/SecurityCompass/AndroidLabs and https://github.com/SecurityCompass/iPhoneLabs

Setup
-----

You'll need to install:

* blinker
* cherrypy
* flask
* flask-sqlalchemy
* simplejson

Run:

    easy_install blinker cherrypy flask flask-sqlalchemy simplejson

Using
-----

To run the HTTP server on port 8080

    python app.py

To run the HTTPS server on port 8443

    python app.py --ssl --port 8443

extension: markdown


text:
@shaizei/cli

A next-generation CLI to quickly scaffold pre-configured yet on-demand configurable React applications.

## Getting Started

### 1. Installation

Using Yarn:

```sh
  yarn global add @shaizei/cli
```

Using npm:

```sh
  npm install @shaizei/cli -g
```

### 2. Verifying Installation

After installation, confirm if the installation is successful by running the following command:

```shell
shaizei --version
```

If the above command is successfully executed, and the current version is printed, it means that CLI is installed successfully.

### 3. Usage

In order to check all the available commands and options, pass the `--help`  command:

```shell
shaizei --help
```

In order to find all the available scripts, please checkout [@shaizei/scrips](https://www.npmjs.com/package/@shaizei/scripts).

repository: shahzaibkhalid/shaizei

gha_language: JavaScript

repo_name: shahzaibkhalid/shaizei


text:
---
client: "Gsawery von Dach"
title: "Abulia's countryside"
cover: "./landscape1.jpg"
position: 3
date: "2018-05-01"
service: "Parchment, ink"
material: "Parchment, ink"
---
One day, Von Dach rested under a tree in an Abulian orchard, when a pear fell on his head. While examining the bump on his forehead, he is widely believed to have invented a prototype of the modern-day selfies tick.

Today, Abulia is the world’s **4th biggest producer of pears and selfie sticks**. Nearly 12% of the population works in the selfie stick industry, and various accounts credit the invention with a large influx of tourists in recent years [citation needed].

repository: abuliaofficial/carnet

repo_name: abuliaofficial/carnet


text:
<!--
  ~ Licensed to the Apache Software Foundation (ASF) under one
  ~ or more contributor license agreements.  See the NOTICE file
  ~ distributed with this work for additional information
  ~ regarding copyright ownership.  The ASF licenses this file
  ~ to you under the Apache License, Version 2.0 (the
  ~ "License"); you may not use this file except in compliance
  ~ with the License.  You may obtain a copy of the License at
  ~
  ~   http://www.apache.org/licenses/LICENSE-2.0
  ~
  ~ Unless required by applicable law or agreed to in writing,
  ~ software distributed under the License is distributed on an
  ~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  ~ KIND, either express or implied.  See the License for the
  ~ specific language governing permissions and limitations
  ~ under the License.
  -->

# Committers (in alphabetical order):

Please see: [Apache Parquet Committers and PMC](http://people.apache.org/committers-by-project.html#parquet)

# Reviewing guidelines:
Committers have the responsibility to give constructive and timely feedback on the pull requests.
Anybody can give feedback on a pull request but only committers can merge it.

First things to look at in a Pull Request:
 - Is there a corresponding JIRA, and is it mentioned in the description? If not ask the contributor to make one.
 - If a JIRA is open, make sure it is assigned to the contributor. (they need to have the contributor role here: https://issues.apache.org/jira/plugins/servlet/project-config/PARQUET/roles)
 - Is it an uncontroversial change that looks good (has apropriate tests and the build is succesful)? => merge it
 - Is it something that requires the attention of committers with a specific expertise? => mention those committers by their github id in the pull request.

repository: piyushnarang/parquet-mr

repo_name: piyushnarang/parquet-mr


text:
# letmesleep
This script sets the wakeup toggle to disabled on a given PRODID.
This stops the device from being able to wakeup the computer from sleep.
I did this so that my mouse didn't wake my laptop while it was in my bag.

Tested in Fedora Core 24 with an Microsoft Mouse.

# Setup
Find the idProduct of your device and change the PRODID var.
Set the script executable and put the script in `/lib/systemd/system-sleep`.

# Thanks
Inspired by http://askubuntu.com/a/713247

repository: rjsteixeira/letmesleep

repo_name: rjsteixeira/letmesleep


text:
# AdminDrop
###### *Bukkit / Spigot / Minecraft / Server Plugin*

All things need limitations, why not item related interactions? This plugin allows the server to impose restrictions on a player to prevent them from throwing/picking up items, opening specific inventories, and placing/breaking blocks.

Utilizing permissions you can force a player or group to always have restrictions or paired with a region plugin for event areas. Great for a multitude of server types ranging from RPG servers (prison servers especially) to hardcore PVP servers and can even come in handy for events.

Officially back on GitHub! This comes with a change to the MIT license in honor of Hacktober2019.

------------

### AdminDrop Tested on:
![](https://i.imgur.com/iZsakTq.png)

1.7.2 / 1.8 / 1.9 / 1.10 / 1.11 / 1.12

###### AdminDrop v<IP_ADDRESS>rxx-SNAPSHOT Not Always Tested.AdminDrop v<IP_ADDRESS>rxx-SNAPSHOT Not Always Tested.
Use Builds on Jenkins with that in mind. Jenkins is currently only open to only some, that will change with time. (need funds for paid hosting)

------------

#### Doccumentation below is relavent for Versions <IP_ADDRESS> through <IP_ADDRESS>r1-SNAPSHOT.

------------

### Features:

- Stops the dropping of items on death for self, target or all offline/online players
- Stops the ability to throw items for self, target or all offline/online players
- Stops the ability of picking up items for self, target or all offline/online players
- Stops in the name of love; for self, target or all offline/online players
- Stops the ability of opening chests and storage items for self, target or all offline/online players
- Stops the ability to break blocks for self, target or all offline/online players
- Stops the ability to place blocks for self, target or all offline/online players
- Checks personal status of toggles and that of other players

Want to reach out or follow me? Find me on Twitter @pyropyro78

### Permissions:
#### Self
- AdminDrop.self.status - Check one's own status of toggles
- AdminDrop.self.deathdrop - Set one's own drops on death toggle
- AdminDrop.self.throwaway - Set one's own throwing away toggle
- AdminDrop.self.pickup - Set one's own picking up of items toggle
- AdminDrop.self.chestaccess - Set one's own ability to open chests or storage items (single, double, ender, hopper, dropper, minecart chest, brewing stand)
- AdminDrop.self.block.break - Set one’s own restriction to breaking blocks
- AdminDrop.self.block.place - Set one’s own restriction to placing blocks

#### Other
- AdminDrop.other.status - Check status of others' toggles.
- AdminDrop.other.deathdrop - Modify other user's drops on death toggle.
- AdminDrop.other.throwaway - Set others' throwing away toggle.
- AdminDrop.other.pickup - Modify other user's drops on death toggle.
- AdminDrop.other.chestaccess - Set others' ability to open chests or storage items (single, double, ender, hopper, dropper, minecart chest, brewing stand).
- AdminDrop.other.block.break - Set others' own restriction to breaking blocks
- AdminDrop.other.block.place - Set others' own restriction to placing blocks

#### Overrides
- AdminDrop.alwayson.deathdrop - Makes toggle for drops on death always on
- AdminDrop.alwayson.throwaway - Makes throwing away toggle always on
- AdminDrop.alwayson.pickup - Makes picking up of items toggle always on
- AdminDrop.alwayson.chestaccess - Makes chest access toggle always on
- AdminDrop.alwayson.block.break - Makes block breaking toggle always on
- AdminDrop.alwayson/block.place - Makes block placing toggle always on

#### Override Ignore Star Permission
- If you use the '*' permission on a user/group that you wish to have something like AdminDrop.alwayson.pickup you will need to use - -AdminDrop.ignore.star.pickup on the line before the '*' permission to enable it on that a user/group.
- AdminDrop.ignore.star.deathdrop - Makes toggle for drops on death always on for ‘*’ users
- AdminDrop.ignore.star.throwaway - Makes throwing away toggle always on for ‘*’ users
- AdminDrop.ignore.star.pickup - Makes picking up of items toggle always on for ‘*’ users
- AdminDrop.ignore.star.chestaccess - Makes chest access toggle always on for ‘*’ users
- AdminDrop.ignore.star.block.break - Makes block breaking toggle always on for ‘*’ users
- AdminDrop.ignore.star.block.place - Makes block placing toggle always on for ‘*’ users

#### Restricted
- AdminDrop.restricted.reload – Allows user to reload config files if changes are made to the files while server is running

------------

### Commands:
- /ad deathdrop - Toggles Death Drops [ON/OFF]
- /ad deathdrop [player/online/all] - Toggles other's Death Drops on/off
- /ad deathdrop [player/online/all] [ON/OFF] - Toggles other's Death Drops on/off
- /ad throwaway - Toggles the ability to throw away items on/off
- /ad throwaway [player/online/all] - Toggles other's throw away items on/off
- /ad throwaway [player/online/all] [ON/OFF] - Toggles other's throw away items on/off
- /ad pickup - Toggles the ability to pick up items on/off
- /ad pickup [player/online/all] - Toggles other's ability to pick up items on/off
- /ad pickup [player/online/all] [ON/OFF] - Toggles other's ability to pick up items on/off
- /ad chestaccess - Toggles the ability to open chests on/off
- /ad chestaccess [player/online/all] - Toggles other's ability to open chests on/off
- /ad chestaccess [player/online/all] [ON/OFF] - Toggles other's ability to open chests on/off
- /ad blockbreak - Toggles the restriction to break blocks on/off
- /ad blockbreak [player/online/all] - Toggles other's restriction to break blocks on/off
- /ad blockbreak [player/online/all] [ON/OFF] - Toggles other's restriction to break blocks on/off
- /ad blockplace - Toggles the restriction to place blocks on/off
- /ad blockplace [player/online/all/all] - Toggles other's restriction to place blocks on/off
- /ad blockplace [player/online/all] [ON/OFF] - Toggles other's restriction to place blocks on/off
- /ad reload – Reloads config files
- /ad status - Gets current status
- /ad status [player] - Gets players current status
- /ad help - Displays commands
- /ad alt - Shows alternate commands

### Alternate Commands:
- /ad dd - Toggles Death Drops on/off
- /ad dd [player/online/all] - Toggles other's Death Drops on/off
- /ad dd [player/online/all] [ON/OFF] - Toggles other's Death Drops on/off
- /ad ta - Toggles the ability to throw away items on/off
- /ad ta [player/online/all] - Toggles other's throw away items on/off
- /ad ta [player/online/all] [ON/OFF] - Toggles other's throw away items on/off
- /ad pu - Toggles the ability to pick up items on/off
- /ad pu [player/online/all] - Toggles other's ability to pick up items on/off
- /ad pu [player/online/all] [ON/OFF] - Toggles other's ability to pick up items on/off
- /ad ca - Toggles the ability to open chests on/off
- /ad ca [player/online/all] - Toggles other's ability to open chests on/off
- /ad ca [player/online/all] [ON/OFF] - Toggles other's ability to open chests on/off
- /ad bb - Toggles the restriction to break blocks on/off
- /ad bb [player/online/all] - Toggles other's restriction to break blocks on/off
- /ad bb [player/online/all] [ON/OFF] - Toggles other's restriction to break blocks on/off
- /ad bp - Toggles the restriction to place blocks on/off
- /ad bp [player/online/all] - Toggles other's restriction to place blocks on/off
- /ad bp [player/online/all] [ON/OFF] - Toggles other's restriction to place blocks on/off
- /ad reload – Reloads config files
- /ad status - Gets current status
- /ad status [player] - Gets players current status
- /ad help - Displays commands
- /ad ac - Shows alternate commands

------------

### Notes:
1. Remember, always delete your old config or make the appropriate changes when updating to a newer version as things may have changed.
2. Items do not stay in inventory on death if drops are toggled to not drop, they just simply do not drop them.

###### This plugin was authored by pyropyro78.

gha_language: Java


text:
# Tron Legacy syntax theme for Atom

This is a conversion of Dayle Rees' Tron Legacy for TextMate (https://github.com/daylerees/colour-schemes/blob/master/legacy/TronLegacy.tmTheme) with some tweaks of my own.

![Screenshot](https://camo.githubusercontent.com/a16578c5cf4a596a68d73038892c8a70a6492cac/687474703a2f2f692e696d6775722e636f6d2f446567753246542e706e67)

repository: Riari/tron-legacy-atom

gha_language: CSS

repo_name: Riari/tron-legacy-atom


text:
You are given an  `n x n`  integer matrix  `board`  where the cells are labeled from  `1`  to  `n^2`  in a  [**Boustrophedon style**](https://en.wikipedia.org/wiki/Boustrophedon)  starting from the bottom left of the board (i.e.  `board[n - 1][0]`) and alternating direction each row.

You start on square  `1`  of the board. In each move, starting from square  `curr`, do the following:

-   Choose a destination square  `next`  with a label in the range  `[curr + 1, min(curr + 6, n^2)]`.
    -   This choice simulates the result of a standard  **6-sided die roll**: i.e., there are always at most 6 destinations, regardless of the size of the board.
-   If  `next`  has a snake or ladder, you  **must**  move to the destination of that snake or ladder. Otherwise, you move to  `next`.
-   The game ends when you reach the square  `n2`.

A board square on row  `r`  and column  `c`  has a snake or ladder if  `board[r][c] != -1`. The destination of that snake or ladder is  `board[r][c]`. Squares  `1`  and  `n^2`  do not have a snake or ladder.

Note that you only take a snake or ladder at most once per move. If the destination to a snake or ladder is the start of another snake or ladder, you do  **not**  follow the subsequent snake or ladder.

-   For example, suppose the board is  `[[-1,4],[-1,3]]`, and on the first move, your destination square is  `2`. You follow the ladder to square  `3`, but do  **not**  follow the subsequent ladder to  `4`.

Return  _the least number of moves required to reach the square_ `n^2`_. If it is not possible to reach the square, return_ `-1`.

**Example 1:**

![](https://assets.leetcode.com/uploads/2018/09/23/snakes.png)

**Input:** board = [[-1,-1,-1,-1,-1,-1],[-1,-1,-1,-1,-1,-1],[-1,-1,-1,-1,-1,-1],[-1,35,-1,-1,13,-1],[-1,-1,-1,-1,-1,-1],[-1,15,-1,-1,-1,-1]]
**Output:** 4
**Explanation:**
In the beginning, you start at square 1 (at row 5, column 0).
You decide to move to square 2 and must take the ladder to square 15.
You then decide to move to square 17 and must take the snake to square 13.
You then decide to move to square 14 and must take the ladder to square 35.
You then decide to move to square 36, ending the game.
This is the lowest possible number of moves to reach the last square, so return 4.

**Example 2:**

**Input:** board = [[-1,-1],[-1,3]]
**Output:** 1

**Constraints:**

-   `n == board.length == board[i].length`
-   `2 <= n <= 20`
-   `board[i][j]`  is either  `-1`  or in the range  `[1, n^2]`.
-   The squares labeled  `1`  and  `n^2`  do not have any ladders or snakes.

repository: gurfinkel/leetCode

repo_name: gurfinkel/leetCode


text:
# soat-sample

Repository for liquibase example.

## Run the application :

Just compile the application and lauch the war in a tomcat.

You can use the postgresql driver using the spring profile `db-jndi` or use a H2 memory database.

## Try the `./liquibase.sh` scripts.

Just use the command `./liquibase.sh -h`  or `./liquibase.sh -h -Ddetail=true` to understand how to use it !

repository: jfenuk/liquibase-example

repo_name: jfenuk/liquibase-example


text:
# 800k lines cpp compile challenge

80万行cpp编译挑战

800k lines cpp 编译 challenge

## generate 生成Cpp代码

`go run generator.go`

## compile 编译Cpp代码

`g++ -m64 main.cpp`

## binary test 二进制测试

`./a.out`

## pregenerate code 预生成代码

For challengers without a `golang` environment, the `main.7z` in the project is the generated cpp code.

对于没有`golang`环境的挑战者，项目中的`main.7z`便是已经生成好的cpp代码。

## Story 缘起

![](assets/4.jpg)![](assets/5.jpg)![](assets/6.jpg)

There are several pictures circulating in the community. It depicts a student who has written over 800,000 lines of code to complete an assignment, but cannot get it to compile.

社群流传着几张图片。描述了一个学生为了完成作业而写下了80万行代码，但是无法通过编译。

The assignment requires you to enter a number with no more than 5 digits, output each digit separately, and then output the numbers in reverse order.

作业的要求是输入一个不超过5位的数字，分别输出每一位，再将数字倒序输出。

Obviously, we know that his code was generated and not handwritten. And he was probably just trying to make a joke.

But we can still take on the challenge of compiling this code.

显然，我们知道他的代码是生成的而非手写的。而且他应该只是想开个玩笑。

但是我们还是可以来挑战一下编译这个代码。


text:
# Laravel file cache garbage collector

When using the file cache driver, Laravel creates the cache files but never purges expired ones. This can lead to
a situation where you have a large number of unused and irrelevant cache files, especially if you do a lot of short-term
caching in your system.

This package creates an artisan command cache:gc that will garbage-collect your cache files, removing any that have expired.
You may run this manually or include it in a schedule.

Thanks to Jon Baker for inspire [https://github.com/jdavidbakr/laravel-cache-garbage-collector]

## Install

Via Composer

``` bash
$ composer require nitogel/laravel-fcache-gc
```

Then add the service provider to `app/Console/Kernel.php` in the $commands array:

``` php
\Nitogel\LaravelFileCacheGarbageCollector\ClearExpiredCache::class
```

## Usage

``` bash
$ php artisan cache:gc
```
``` bash
$ php artisan cache:gc -d -i
```

## Params
```-d``` deleting folders
```-i``` interactive deleting

repository: nitogel/laravel-fcache-gc

gha_language: PHP

repo_name: nitogel/laravel-fcache-gc


text:
# progressive [![NPM version](https://badge.fury.io/js/progressive.svg)](http://badge.fury.io/js/progressive)

> Simple template based status bar for node.js

## Install
## Install with [npm](npmjs.org)

```bash
npm i progressive --save
```

## Run tests

```bash
npm test
```

## Usage

```js
var Progressive = require('progressive');
```

## API
### [Progressive](index.js#L31)

Create a new instance of a progress bar with the given options.

* `options` **{Object}**: Configuration options for the progress bar.

```js
var bar = new Progressive();
```

### [.update](index.js#L72)

Update the progress bar passing in an increment and/or local data.

* `inc` **{Object}**: Integer to increment the progress bar by.
* `locals` **{Object}**: Additional data to pass to the progress bar template

```js
bar.update(2, { foo: 'bar' });
```

## Contributing
Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](https://github.com/doowb/progressive/issues)

## Author

**Brian Woodward**

+ [github/doowb](https://github.com/doowb)
+ [twitter/doowb](http://twitter.com/doowb)

## License
Copyright (c) 2014 Brian Woodward
Released under the MIT license

***

_This file was generated by [verb](https://github.com/assemble/verb) on December 19, 2014._

repository: doowb/progressive

repo_name: doowb/progressive


text:
### Answer : x is 3
```python
- x += x - x translates into x = x + ( x - x )
- Python evaluates the expression, x = 3 + 3 - 3
- The result is 3
- x variable is assigned to value of 3
```

repository: kikitux/introductionCS

repo_name: kikitux/introductionCS


text:
Now, have any of y'all ever looked up this word?
You know, in a dictionary?
(Laughter)
 Yeah, that's what I thought.
How about this word?
Here, I'll show it to you.

Lexicography: the practice of compiling dictionaries.
Notice -- we're very specific -- that word "compile."
The dictionary is not carved out of a piece of granite,
out of a lump of rock. It's made up of lots of little bits.
It's little discrete --
that's spelled D-I-S-C-R-E-T-E -- bits.
And those bits are words.
Now one of the perks of being a lexicographer --
besides getting to come to TED -- is that you get to say really fun words,
like lexicographical.

Lexicographical has this great pattern:
it's called a double dactyl. And just by saying double dactyl,
I've sent the geek needle all the way into the red.
(Laughter)

(Applause)

But "lexicographical" is the same pattern as "higgledy-piggledy."
Right? It's a fun word to say,
and I get to say it a lot.
Now, one of the non-perks of being a lexicographer
is that people don't usually have a kind of warm, fuzzy, snuggly image of the dictionary.
Right? Nobody hugs their dictionaries.
But what people really often think about the dictionary is, they think more like this.
Just to let you know, I do not have a lexicographical whistle.
But people think that my job is to let the good words
make that difficult left-hand turn into the dictionary,
and keep the bad words out.
But the thing is, I don't want to be a traffic cop.
For one thing, I just do not do uniforms.
And for another, deciding what words are good
and what words are bad is actually not very easy.
And it's not very fun. And when parts of your job are not easy or fun,
you kind of look for an excuse not to do them.
So if I had to think of some kind of occupation
as a metaphor for my work, I would much rather be a fisherman.
I want to throw my big net into the deep, blue ocean of English
and see what marvelous creatures I can drag up from the bottom.
But why do people want me to direct traffic, when I would much rather go fishing?
Well, I blame the Queen.
Why do I blame the Queen?
Well, first of all, I blame the Queen because it's funny.
But secondly, I blame the Queen because
dictionaries have really not changed.
Our idea of what a dictionary is has not changed since her reign.
The only thing that Queen Victoria would not be amused by in modern dictionaries
is our inclusion of the F-word, which has happened
in American dictionaries since 1965.
So, there's this guy, right? Victorian era.
James Murray, first editor of the Oxford English Dictionary.
I do not have that hat. I wish I had that hat.
So he's really responsible for a lot of
what we consider modern in dictionaries today.
When a guy who looks like that, in that hat,
is the face of modernity, you have a problem.
And so, James Murray could get a job on any dictionary today.
There'd be virtually no learning curve.

And of course, a few of us are saying: okay, computers!
Computers! What about computers?
The thing about computers is, I love computers.
I mean, I'm a huge geek, I love computers.
I would go on a hunger strike before I let them take away Google Book Search from me.
But computers don't do much else other than
speed up the process of compiling dictionaries.
They don't change the end result.
Because what a dictionary is,
is it's Victorian design merged with a little bit of modern propulsion.
It's steampunk. What we have is an electric velocipede.
You know, we have Victorian design with an engine on it. That's all!
The design has not changed.
And OK, what about online dictionaries, right?
Online dictionaries must be different.
This is the Oxford English Dictionary Online, one of the best online dictionaries.
This is my favorite word, by the way.

Erinaceous: pertaining to the hedgehog family; of the nature of a hedgehog.
Very useful word. So, look at that.
Online dictionaries right now are paper thrown up on a screen.

This is flat. Look how many links there are in the actual entry: two!
Right? Those little buttons,
I had them all expanded except for the date chart.
So there's not very much going on here.
There's not a lot of clickiness.
And in fact, online dictionaries replicate
almost all the problems of print, except for searchability.
And when you improve searchability,
you actually take away the one advantage of print, which is serendipity.
Serendipity is when you find things you weren't looking for,
because finding what you are looking for is so damned difficult.
So --
(Laughter)

(Applause)
 -- now, when you think about this,
what we have here is a ham butt problem.
Does everyone know the ham butt problem?
Woman's making a ham for a big, family dinner.

We have a pan that's too small!
 There's no reason to throw it away.
The bad words -- see, when people think about a place
and they don't find a place on the map,
they think, "This map sucks!"
When they find a nightspot or a bar, and it's not in the guidebook,
they're like, "Ooh, this place must be cool! It's not in the guidebook."
When they find a word that's not in the dictionary, they think,
"This must be a bad word." Why? It's more likely to be a bad dictionary.
Why are you blaming the ham for being too big for the pan?
So, you can't get a smaller ham.
The English language is as big as it is.
So, if you have a ham butt problem,
and you're thinking about the ham butt problem,

the conclusion that it leads you to is inexorable and counterintuitive:
paper is the enemy of words.
How can this be? I mean, I love books. I really love books.
Some of my best friends are books.
But the book is not the best shape for the dictionary.
Now they're going to think "Oh, boy.
People are going to take away my beautiful, paper dictionaries?"
No. There will still be paper dictionaries.
When we had cars -- when cars became the dominant mode of transportation,
we didn't round up all the horses and shoot them.
You know, there're still going to be paper dictionaries,
but it's not going to be the dominant dictionary.
The book-shaped dictionary is not going to be the only shape
dictionaries come in. And it's not going to be
the prototype for the shapes dictionaries come in.

So, think about it this way: if you've got an artificial constraint,
artificial constraints lead to
arbitrary distinctions and a skewed worldview.
What if biologists could only study animals
that made people go, "Aww." Right?
What if we made aesthetic judgments about animals,
and only the ones we thought were cute were the ones that we could study?
We'd know a whole lot about charismatic megafauna,
and not very much about much else.
And I think this is a problem.
I think we should study all the words,
because when you think about words, you can make beautiful expressions
from very humble parts.
Lexicography is really more about material science.
We are studying the tolerances of the materials

that you use to build the structure of your expression:
your speeches and your writing. And then, often people say to me,
"Well, OK, how do I know that this word is real?"
They think, "OK, if we think words are the tools
that we use to build the expressions of our thoughts,
how can you say that screwdrivers are better than hammers?
How can you say that a sledgehammer is better than a ball-peen hammer?"
They're just the right tools for the job.
And so people say to me, "How do I know if a word is real?"
You know, anybody who's read a children's book
knows that love makes things real.
If you love a word, use it. That makes it real.
Being in the dictionary is an artificial distinction.
It doesn't make a word any more real than any other way.
If you love a word, it becomes real.
So if we're not worrying about directing traffic,
if we've transcended paper, if we are worrying less
about control and more about description,
then we can think of the English language
as being this beautiful mobile.
And any time one of those little parts of the mobile changes,
is touched, any time you touch a word,
you use it in a new context, you give it a new connotation,
you verb it, you make the mobile move.
You didn't break it. It's just in a new position,
and that new position can be just as beautiful.
Now, if you're no longer a traffic cop --
the problem with being a traffic cop is
there can only be so many traffic cops in any one intersection,
or the cars get confused. Right?
But if your goal is no longer to direct the traffic,
but maybe to count the cars that go by, then more eyeballs are better.
You can ask for help!
If you ask for help, you get more done. And we really need help.

Library of Congress: 17 million books,
of which half are in English.
If only one out of every 10 of those books
had a word that's not in the dictionary in it,
that would be equivalent to more than two unabridged dictionaries.
And I find an un-dictionaried word --
a word like "un-dictionaried," for example --
in almost every book I read. What about newspapers?
Newspaper archive goes back to 1759,
58.1 million newspaper pages. If only one in 100
of those pages had an un-dictionaried word on it,
it would be an entire other OED.
That's 500,000 more words. So that's a lot.
And I'm not even talking about magazines. I'm not talking about blogs --
and I find more new words on BoingBoing in a given week
than I do Newsweek or Time.
There's a lot going on there.
And I'm not even talking about polysemy,
which is the greedy habit some words have of taking
more than one meaning for themselves.
So if you think of the word "set," a set can be a badger's burrow,
a set can be one of the pleats in an Elizabethan ruff,
and there's one numbered definition in the OED.
The OED has 33 different numbered definitions for set.

One of them is just labeled "miscellaneous technical senses."
Do you know what that says to me?
That says to me, it was Friday afternoon and somebody wanted to go down the pub.
(Laughter)

That's a lexicographical cop out,
to say, "miscellaneous technical senses."
So, we have all these words, and we really need help!
And the thing is, we could ask for help --
asking for help's not that hard.
I mean, lexicography is not rocket science.
See, I just gave you a lot of words and a lot of numbers,
and this is more of a visual explanation.
If we think of the dictionary as being the map of the English language,
these bright spots are what we know about,
and the dark spots are where we are in the dark.
If that was the map of all the words in American English, we don't know very much.
And we don't even know the shape of the language.
If this was the dictionary -- if this was the map of American English --
look, we have a kind of lumpy idea of Florida,
but there's no California!
We're missing California from American English.
We just don't know enough, and we don't even know that we're missing California.
We don't even see that there's a gap on the map.
So again, lexicography is not rocket science.
But even if it were, rocket science is being done
by dedicated amateurs these days. You know?
It can't be that hard to find some words!
So, enough scientists in other disciplines
are really asking people to help, and they're doing a good job of it.
For instance, there's eBird, where amateur birdwatchers
can upload information about their bird sightings.
And then, ornithologists can go
and help track populations, migrations, etc.
And there's this guy, Mike Oates. Mike Oates lives in the U.K.
He's a director of an electroplating company.
He's found more than 140 comets.
He's found so many comets, they named a comet after him.
It's kind of out past Mars. It's a hike.
I don't think he's getting his picture taken there anytime soon.
But he found 140 comets without a telescope.
He downloaded data from the NASA SOHO satellite,
and that's how he found them.
If we can find comets without a telescope,
shouldn't we be able to find words?
Now, y'all know where I'm going with this.
Because I'm going to the Internet, which is where everybody goes.
And the Internet is great for collecting words,
because the Internet's full of collectors.
And this is a little-known technological fact about the Internet,
but the Internet is actually made up of words and enthusiasm.
And words and enthusiasm actually happen to be
the recipe for lexicography. Isn't that great?
So there are a lot of really good word-collecting sites out there right now,
but the problem with some of them is that they're not scientific enough.
They show the word, but they don't show any context.
Where did it come from? Who said it?
What newspaper was it in? What book?
Because a word is like an archaeological artifact.
If you don't know the provenance or the source of the artifact,
it's not science, it's a pretty thing to look at.
So a word without its source is like a cut flower.
You know, it's pretty to look at for a while, but then it dies.
It dies too fast.
So, this whole time I've been saying,
"The dictionary, the dictionary, the dictionary, the dictionary."
Not "a dictionary," or "dictionaries." And that's because,
well, people use the dictionary to stand for the whole language.
They use it synecdochically.
And one of the problems of knowing a word like "synecdochically"
is that you really want an excuse to say "synecdochically."
This whole talk has just been an excuse to get me to the point
where I could say "synecdochically" to all of you.
So I'm really sorry. But when you use a part of something --
like the dictionary is a part of the language,
or a flag stands for the United States, it's a symbol of the country --
then you're using it synecdochically.
But the thing is, we could make the dictionary the whole language.
If we get a bigger pan, then we can put all the words in.
We can put in all the meanings.
Doesn't everyone want more meaning in their lives?
And we can make the dictionary not just be a symbol of the language --
we can make it be the whole language.
You see, what I'm really hoping for is that my son,
who turns seven this month -- I want him to barely remember
that this is the form factor that dictionaries used to come in.
This is what dictionaries used to look like.
I want him to think of this kind of dictionary as an eight-track tape.
It's a format that died because it wasn't useful enough.
It wasn't really what people needed.
And the thing is, if we can put in all the words,
no longer have that artificial distinction between good and bad,
we can really describe the language like scientists.
We can leave the aesthetic judgments to the writers and the speakers.
If we can do that, then I can spend all my time fishing,
and I don't have to be a traffic cop anymore.
Thank you very much for your kind attention.

repository: prewittdavon/TEDVis

repo_name: prewittdavon/TEDVis


text:
---
title: 'Week 8 (Jun 27 - Jul 3)'
published: false
date: '27-06-2018 00:00'
hide_from_post_list: false
hide_git_sync_repo_link: true
header_image_credit: 'Nicholas Wang, Flickr.com'
header_image_creditlink: 'https://www.flickr.com/photos/cloneofsnake/13966760787/'
header_image_alt_text: 'Interview in coffee shop'
---

## How to understand and communicate people's needs and behaviours?
[Needsfinding](https://www.google.ca/slides/about/)
[User Models](https://www.google.ca/slides/about/)
[Stories of Usage](https://www.google.ca/slides/about/)

===

## **How to understand and communicate people's needs and behaviours?**

### Summaries and Questions
[Jun 27 Class One-minute Summaries](https://canvas.sfu.ca/courses/55288/assignments)

### Presented Slides
[Placeholder Slides](https://docs.google.com/presentation/d/e/2PACX-1vSPiOUzmRG4EB6ng8KQgOwZEbVuN2u1d5tGVTiAyzlVuO_o4Zjyli3oAf_U_CqXml_6GMUBR9nUyEYb/pub?start=false&loop=false&delayms=3000)

[googleslides]https://docs.google.com/presentation/d/e/2PACX-1vSPiOUzmRG4EB6ng8KQgOwZEbVuN2u1d5tGVTiAyzlVuO_o4Zjyli3oAf_U_CqXml_6GMUBR9nUyEYb/embed?start=false&loop=false&delayms=3000[/googleslides]

### Assignments
[User Research Report](https://canvas.sfu.ca/courses/55288/assignments)
[Informed Consent Materials](https://canvas.sfu.ca/courses/55288/files)

### Supplemental Materials
[What People Are Really Doing Video](http://vimeo.com/album/169777/video/7099570)
[iframe url="https://player.vimeo.com/video/7099570"]

### Required Reading
[embedly]http://www.smashingmagazine.com/2013/09/5-step-process-conducting-user-research/[/embedly]


text:
# Slow Cooker Chicken Enchilada Soup
*Serves 6*

**For the enchilada sauce:**
* Neutral cooking oil, such as canola or safflower
* 1 medium yellow onion, diced
* 1 large jalapeño, seeded and finely chopped
* 3 cloves garlic, minced
* 2 tablespoons chili powder, prerably Mexican-style
* 1 tablespoon ground cumin
* 1 tablespoon granulated sugar
* 2 medium tomatoes, coarsely chopped
* 1 (15-ounce) can tomato sauce
* 2 cups low-sodium chicken broth, plus more for thinning as needed
* Kosher salt
* Freshly ground black pepper
* cinnamon

**For the soup:**
* 1 (15-ounce) can yellow corn, drained
* 1 (15-ounce) can black beans, rinsed and drained
* 2 to 3 pounds boneless, skinless chicken thighs
* Heavy cream (optional)
* Cayenne pepper (optional)
* Serving options: Shredded cheddar cheese, sour cream, tortilla chips, fresh cilantro

## Directions
Heat a few tablespoons of oil in a large Dutch oven or skillet over medium heat until shimmering. Add the onions and jalapeño and cook until softened, 5 to 7 minutes. Add the garlic, chili powder, cumin, and sugar and stir until fragrant, 30 seconds to 1 minute. Add the tomatoes, tomato sauce, and broth, season with salt and pepper, and bring to a gentle boil. Transfer to a 5 quart-or larger slow cooker.

Add the corn, beans, and chicken, and stir to combine. Cover and cook until the chicken is cooked through, 6 to 7 hours on the LOW setting or 4 hours on the HIGH setting.

Shred the chicken into bite-sized pieces with 2 forks. Stir in a splash of heavy cream if desired. Taste and season with salt, pepper, and cayenne pepper as desired. Serve with cheddar cheese, sour cream, tortilla chips, and cilantro for garnish if desired.

*[From The Kitchn](https://www.thekitchn.com/recipe-slow-cooker-chicken-enchilada-soup-193675)*

repository: faithrusk/Recipes

repo_name: faithrusk/Recipes


text:
# D-Wave Ising Sample Collector (D-WISC)

The D-WISC toolset is used to collect larger numbers of samples, on the order of millions, from a specific D-Wave QPU.  The `dwisc.py` collection script takes a [bqpjson](http://bqpjson.readthedocs.io/en/stable/) file as input (typically generated by [D-WIG](https://github.com/lanl-ansi/dwig)) and outputs a _solution_ json document that provides detailing the collected samples.  The helper script `combis.py` can be used to combine many _solution_ documents from repeated runs of `dwisc.py`.

The remainder of this documentation assumes that,

1. You have access to a D-Wave QPU
2. You have installed the dwave-cloud-client
2. You are using a bash terminal

### Basic Usage

The primary entry point of the D-WISC toolset is `dwisc.py` this script is used to collect samples from a D-Wave QPU.  For example, the following command will collect 25000 samples of from the bqpjson file `ran1_1.json` and send the resulting sample data to standard output,
```
./dwisc.py -f test/data/ran1_1.json
```
Bash stream redirection can be used to save the standard output to a file, for example,
```
./dwisc.py -f test/data/ran1_1.json > ran1_1_is_1.json
```
A detailed list of all command line options can be viewed via,
```
./dwisc.py --help
```

It is fairly common to combine results from several runs of `dwisc.py`.  If multiple sample files are placed in a directory, `combis.py` can be used to quickly combine those files and send the resulting sample data to standard output,
```
./combis.py -sd test/result
```
Again, bash stream redirection can be used to save the standard output to a file, for example,
```
./combis.py -sd test/result > result.json
```

### Connecting to a QPU

D-WISC uses the `dwave-cloud-client` for connecting to the QPU and will use your `dwave.conf` file for the configuration details.  A specific profile can be selected with the command line argument `--profile <label>`.  If no configuration details are found, D-WISC will produce an error.

### Solution JSON File

The solution file output by D-WISC is a JSON document with has the following structure,
```
{
  "collection_start": "<UTC start time of sample collection>",
  "collection_end": "<UTC end time of sample collection>",
  "metadata": {<QPU identification data>},
  "solve_ising_args": {<arguments passed to solve_ising>},
  "timing": {<aggregate QPU timing information>}
  "variable_ids": [<an ordered list of QPU variable ids>],
  "solutions":[
    {
      "solution":[<variable assignments of -1 and 1>],
      "num_occurrences":<int>,
      "energy":<float>
    },
    ...
  ]
}
```
The `metadata` and `solve_ising_args` fields are optional, all other fields are required.

## License
D-WISC is provided under a BSD-ish license with a "modifications must be indicated" clause.  See the `LICENSE.md` file for the full text.
This package is part of the Hybrid Quantum-Classical Computing suite, known internally as LA-CC-16-032.

repository: lanl-ansi/dwisc

gha_license_id: NOASSERTION

repo_name: lanl-ansi/dwisc


text:
# Quiksizzler

An Invisible, Inc. workflow automation tool. This repository is no longer maintained; instead, refer to the [combined repository for my Invisible tools](https://github.com/Sizzlefrost/invisible-mod-tools)

repository: Sizzlefrost/quiksizzler

repo_name: Sizzlefrost/quiksizzler


text:
WLActivityViewController
======================

WLActivityViewController is a UIActivityViewController subclass with title. It is useful for displaying information about the items to be shared, e.g., URL of a web page.

The initial design came from Tumblr’s iOS app. It is later adopted by other popular apps like Tweetbot, Twitterrific and [Moke](http://moke.com/moke/).

repository: WillJonesMagic/WLActivityViewController

repo_name: WillJonesMagic/WLActivityViewController