text:
### 2017-04-23

#### swift
* [loopeer / AlertTransition](https://github.com/loopeer/AlertTransition):
        AlertTransition is a extensible library for making view controller transitions, especially for alert transitions.

* [SteveBarnegren / TweenKit](https://github.com/SteveBarnegren/TweenKit):
        Animation library for iOS in Swift

* [efremidze / Cluster](https://github.com/efremidze/Cluster):
        Easy Map Annotation Clustering 📍

* [lhc70000 / iina](https://github.com/lhc70000/iina):
        The modern video player for macOS.

* [ReactorKit / ReactorKit](https://github.com/ReactorKit/ReactorKit):
        A framework for reactive and unidirectional Swift application architecture

* [br1sk / brisk](https://github.com/br1sk/brisk):
        A macOS app for submitting radars

* [lkzhao / YetAnotherAnimationLibrary](https://github.com/lkzhao/YetAnotherAnimationLibrary):
        Designed for gesture-driven animations. Fast, simple, & extensible!

* [Minitour / EasySocialButton](https://github.com/Minitour/EasySocialButton):
        An easy way to create beautiful social authentication buttons

* [raywenderlich / swift-algorithm-club](https://github.com/raywenderlich/swift-algorithm-club):
        Algorithms and data structures in Swift, with explanations!

* [vsouza / awesome-ios](https://github.com/vsouza/awesome-ios):
        A curated list of awesome iOS ecosystem, including Objective-C and Swift Projects

* [google / xi-mac](https://github.com/google/xi-mac):
* [younatics / YNSearch](https://github.com/younatics/YNSearch):

🔍 Awesome fully customize search view like Pinterest written in Swift 3

* [IBAnimatable / IBAnimatable](https://github.com/IBAnimatable/IBAnimatable):
        Design and prototype customized UI, interaction, navigation, transition and animation for App Store ready Apps in Interface Builder with IBAnimatable.

* [Alamofire / Alamofire](https://github.com/Alamofire/Alamofire):
        Elegant HTTP Networking in Swift

* [allenwong / 30DaysofSwift](https://github.com/allenwong/30DaysofSwift):
        A self-taught project to learn Swift.

* [danielgindi / Charts](https://github.com/danielgindi/Charts):
        Beautiful charts for iOS/tvOS/OSX! The Apple side of the crossplatform MPAndroidChart.

* [avito-tech / Paparazzo](https://github.com/avito-tech/Paparazzo):
        Paparazzo is an iOS component for picking and editing photos

* [dkhamsing / open-source-ios-apps](https://github.com/dkhamsing/open-source-ios-apps):

📱 Collaborative List of Open-Source iOS Apps

* [material-motion / material-motion-swift](https://github.com/material-motion/material-motion-swift):
        A toolkit for building responsive motion using Core Animation.

* [ReactiveX / RxSwift](https://github.com/ReactiveX/RxSwift):
        Reactive Programming in Swift

* [BrikerMan / BMPlayer](https://github.com/BrikerMan/BMPlayer):
        video player in swift 3 and swift 2 for iOS, based on AVPlayer, support the horizontal, vertical screen. support adjust volume, brigtness and seek by slide. 基于AVPlayer，支持横屏、竖屏，上下滑动调节音量、屏幕亮度，左右滑动调节播放进度。

* [IvanVorobei / RequestPermission](https://github.com/IvanVorobei/RequestPermission):
        simple permission request with beautiful UI

* [CosmicMind / Material](https://github.com/CosmicMind/Material):
        An animation and graphics framework for Material Design in Swift.

* [SwiftyJSON / SwiftyJSON](https://github.com/SwiftyJSON/SwiftyJSON):
        The better way to deal with JSON data in Swift

* [Ramotion / gliding-collection](https://github.com/Ramotion/gliding-collection):
        Gliding Collection is a smooth, flowing, customizable decision for a UICollectionView Swift Controller

#### objective-c
* [fpillet / NSLogger](https://github.com/fpillet/NSLogger):
        A modern, flexible logging tool

* [maxfong / MFSIdentifier](https://github.com/maxfong/MFSIdentifier):
        iOS App获取唯一标识符方案

* [ViccAlexander / Chameleon](https://github.com/ViccAlexander/Chameleon):
        Flat Color Framework for iOS (Obj-C & Swift)

* [Roylee-ML / SwipeTableView](https://github.com/Roylee-ML/SwipeTableView):
        Both scroll horizontal and vertical for segment scrollview which have a same header. — 类似半糖、美丽说主页与QQ音乐歌曲列表布局效果，实现不同菜单的左右滑动切换，同时支持类似tableview的顶部工具栏悬停（既可以左右滑动，又可以上下滑动）。兼容下拉刷新，自定义 collectionview实现自适应 contentSize 还可实现瀑布流功能

* [CocoaLumberjack / CocoaLumberjack](https://github.com/CocoaLumberjack/CocoaLumberjack):
        A fast & simple, yet powerful & flexible logging framework for Mac and iOS

* [slackhq / SlackTextViewController](https://github.com/slackhq/SlackTextViewController):
        A drop-in UIViewController subclass with a growing text input view and other useful messaging features

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

* [OpenEmu / OpenEmu](https://github.com/OpenEmu/OpenEmu):

🎮 Retro video game emulation for macOS

* [Instagram / IGListKit](https://github.com/Instagram/IGListKit):
        A data-driven UICollectionView framework for building fast and flexible lists.

* [hackiftekhar / IQKeyboardManager](https://github.com/hackiftekhar/IQKeyboardManager):
        Codeless drop-in universal library allows to prevent issues of keyboard sliding up and cover UITextField/UITextView. Neither need to write any code nor any setup required and much more.

* [facebook / KVOController](https://github.com/facebook/KVOController):
        Simple, modern, thread-safe key-value observing for iOS and OS X.

* [gnachman / iTerm2](https://github.com/gnachman/iTerm2):
        iTerm2 is a terminal emulator for Mac OS X that does amazing things.

* [hellozimi / HCYoutubeParser](https://github.com/hellozimi/HCYoutubeParser):
        Fetches YouTube mp4 URLS for iOS and tvOS.

* [getsentry / react-native-sentry](https://github.com/getsentry/react-native-sentry):
        Official Sentry client for react-native

* [Coding / Coding-iOS](https://github.com/Coding/Coding-iOS):
        Coding iOS 客户端源代码

* [MacDownApp / macdown](https://github.com/MacDownApp/macdown):
        Open source Markdown editor for macOS.

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

* [SVProgressHUD / SVProgressHUD](https://github.com/SVProgressHUD/SVProgressHUD):
        A clean and lightweight progress HUD for your iOS and tvOS app.

* [matryer / bitbar](https://github.com/matryer/bitbar):
        Put the output from any script or program in your Mac OS X Menu Bar

* [WenchaoD / FSCalendar](https://github.com/WenchaoD/FSCalendar):
        A fully customizable iOS calendar library, compatible with Objective-C and Swift

* [coolnameismy / BabyBluetooth](https://github.com/coolnameismy/BabyBluetooth):

👶 The easiest way to use Bluetooth (BLE )in ios/os ,even bady can use . 一个非常容易使用的蓝牙库,适用于ios和os

* [naoufal / react-native-touch-id](https://github.com/naoufal/react-native-touch-id):
        React Native authentication with the native Touch ID popup.

* [arauchfuss / Simple-Comic](https://github.com/arauchfuss/Simple-Comic):
        OS X comic viewer

* [GGGHub / Reader](https://github.com/GGGHub/Reader):
        iOS基于CoreText实现的电子书阅读器，支持txt，epub格式

* [andreamazz / AMBubbleTableView](https://github.com/andreamazz/AMBubbleTableView):
        AMBubbleTableView

#### go
* [moby / moby](https://github.com/moby/moby):
        Moby Project - a collaborative project for the container ecosystem to assemble container-based systems

* [mholt / caddy](https://github.com/mholt/caddy):
        Fast, cross-platform HTTP/2 web server with automatic HTTPS

* [cockroachdb / cockroach](https://github.com/cockroachdb/cockroach):
        CockroachDB - the scalable, survivable, strongly-consistent SQL database

* [cznic / sqlite](https://github.com/cznic/sqlite):
        Package sqlite is an in-process implementation of a self-contained, serverless, zero-configuration, transactional SQL database engine. (Work In Progress)

* [google / periph](https://github.com/google/periph):
        periph - Peripherals I/O in Go

* [uber / jaeger](https://github.com/uber/jaeger):
        Jaeger - Uber's Distributed Tracing System

* [golang / go](https://github.com/golang/go):
        The Go programming language

* [tigrawap / slit](https://github.com/tigrawap/slit):
        slit - a modern PAGER for viewing logs, get more than most in less time

* [mehrdadrad / mylg](https://github.com/mehrdadrad/mylg):
        Network Diagnostic Tool

* [src-d / go-kallax](https://github.com/src-d/go-kallax):
        Kallax is a PostgreSQL typesafe ORM for the Go language.

* [Checkmarx / Go-SCP](https://github.com/Checkmarx/Go-SCP):
        Go programming language secure coding practices guide

* [gen2brain / url2img](https://github.com/gen2brain/url2img):
        HTTP server with API for capturing screenshots of websites

* [avelino / awesome-go](https://github.com/avelino/awesome-go):
        A curated list of awesome Go frameworks, libraries and software

* [kubernetes / kubernetes](https://github.com/kubernetes/kubernetes):
        Production-Grade Container Scheduling and Management

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

* [rooby-lang / rooby](https://github.com/rooby-lang/rooby):
        A new object oriented language written in Go aim on developing microservice efficiently.

* [spf13 / hugo](https://github.com/spf13/hugo):
        A Fast and Flexible Static Site Generator built with love in GoLang

* [elliotchance / c2go](https://github.com/elliotchance/c2go):

⚖ A tool for converting C to Go.

* [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

* [go-gitea / gitea](https://github.com/go-gitea/gitea):
        Gitea: Git with a cup of tea

* [gin-gonic / gin](https://github.com/gin-gonic/gin):
        Gin is a HTTP web framework written in Go (Golang). It features a Martini-like API with much better performance -- up to 40 times faster. If you need smashing performance, get yourself some Gin.

* [songtianyi / wechat-go](https://github.com/songtianyi/wechat-go):
        go version wechat web api and message framework for building chat bot

* [alexellis / faas](https://github.com/alexellis/faas):
        Functions as a Service (on Docker Swarm)

* [astaxie / beego](https://github.com/astaxie/beego):
        beego is an open-source, high-performance web framework for the Go programming language.

* [hsluoyz / casbin](https://github.com/hsluoyz/casbin):
        An authorization library that supports access control models like ACL, RBAC, ABAC

#### javascript
* [google / tamperchrome](https://github.com/google/tamperchrome):
        Tamper Chrome is a Chrome extension that allows you to modify HTTP requests on the fly and aid on web security testing. Tamper Chrome works across all operating systems (including Chrome OS).

* [notwaldorf / tiny-care-terminal](https://github.com/notwaldorf/tiny-care-terminal):

💖💻 A little dashboard that tries to take care of you when you're using your terminal.

* [huanxsd / MeiTuan](https://github.com/huanxsd/MeiTuan):
        高仿美团客户端 React-Native版，支持iOS、Android

* [avgjs / avg-core](https://github.com/avgjs/avg-core):
        A Future-oriented Adventure Game Framework based on React & Pixi.js. Docs: https://avgjs.github.io/docs/

* [facebook / react-vr](https://github.com/facebook/react-vr):
        Create amazing 360 and VR content using React

* [ericvicenti / intro-to-react](https://github.com/ericvicenti/intro-to-react):
        A Hands-On Walkthrough of your first React Web App

* [tannerlinsley / react-move](https://github.com/tannerlinsley/react-move):
        React Move - Beautifully and deterministically animate anything in React

* [MaiaVictor / forall](https://github.com/MaiaVictor/forall):
        Expressive static types and invariant checks for JavaScript.

* [facebook / react](https://github.com/facebook/react):
        A declarative, efficient, and flexible JavaScript library for building user interfaces.

* [vuejs / vue](https://github.com/vuejs/vue):
        A progressive, incrementally-adoptable JavaScript framework for building UI on the web.

* [aweary / tinytime](https://github.com/aweary/tinytime):
        A straightforward time and time formatter in <1kb

* [garbles / why-did-you-update](https://github.com/garbles/why-did-you-update):

💥 Puts your console on blast when React is making unnecessary updates.

* [ramon82 / zuck.js](https://github.com/ramon82/zuck.js):
        A javascript library that lets you add stories EVERYWHERE.

* [AlloyTeam / curvejs](https://github.com/AlloyTeam/curvejs):
        Made curve a dancer in HTML5 canvas - 魔幻线条

* [facebookincubator / create-react-app](https://github.com/facebookincubator/create-react-app):
        Create React apps with no build configuration.

* [ruyadorno / simple-slider](https://github.com/ruyadorno/simple-slider):

🎠 The 1kb JavaScript Carousel

* [wmhilton / download-with-webtorrent-button](https://github.com/wmhilton/download-with-webtorrent-button):
        Transform ordinary download links into super-powered WebTorrent ones!

* [twbs / bootstrap](https://github.com/twbs/bootstrap):
        The most popular HTML, CSS, and JavaScript framework for developing responsive, mobile first projects on the web.

* [facebook / react-native](https://github.com/facebook/react-native):
        A framework for building native apps with React.

* [nodejs / node](https://github.com/nodejs/node):
        Node.js JavaScript runtime ✨🐢🚀✨

* [styled-components / styled-components](https://github.com/styled-components/styled-components):
        Visual primitives for the component age 💅

* [javierbyte / control-user-cursor](https://github.com/javierbyte/control-user-cursor):
        Experiment to alter the cursor behavior.

* [prettier / prettier](https://github.com/prettier/prettier):
        Prettier is an opinionated JavaScript formatter.

* [airbnb / javascript](https://github.com/airbnb/javascript):
        JavaScript Style Guide

* [BoostIO / Boostnote](https://github.com/BoostIO/Boostnote):
        Boostnote is an open source note-taking app made for programmers just like you🚀

#### ruby
* [tootsuite / mastodon](https://github.com/tootsuite/mastodon):
        A GNU Social-compatible microblogging server

* [brunofacca / zen-rails-security-checklist](https://github.com/brunofacca/zen-rails-security-checklist):
        Checklist of security precautions for Ruby on Rails applications.

* [atech / postal](https://github.com/atech/postal):
        A fully featured open source mail delivery platform for incoming & outgoing e-mail

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

* [jondot / awesome-react-native](https://github.com/jondot/awesome-react-native):
        Awesome React Native components, news, tools, and learning material!

* [Homebrew / brew](https://github.com/Homebrew/brew):

🍺 The missing package manager for macOS

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

* [fastlane / fastlane](https://github.com/fastlane/fastlane):

🚀 The easiest way to automate building and releasing your iOS and Android apps

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

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

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

* [danger / danger](https://github.com/danger/danger):

🚫 Stop saying "you forgot to …" in code review

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

* [arbox / machine-learning-with-ruby](https://github.com/arbox/machine-learning-with-ruby):
         Useful resources for Machine Learning in Ruby.

* [sagivo / algorithms](https://github.com/sagivo/algorithms):
        algorithms playground for common questions

* [jekyll / jekyll](https://github.com/jekyll/jekyll):

🌐 Jekyll is a blog-aware, static site generator in Ruby

* [Tim9Liu9 / TimLiu-iOS](https://github.com/Tim9Liu9/TimLiu-iOS):
        iOS开发常用三方库、插件、知名博客等等

* [cantino / huginn](https://github.com/cantino/huginn):
        Create agents that monitor and act on your behalf. Your agents are standing by!

* [fastlane / boarding](https://github.com/fastlane/boarding):
        Instantly create a simple signup page for TestFlight beta testers

* [opal / opal](https://github.com/opal/opal):
        Ruby in the Browser

* [wpscanteam / wpscan-v3](https://github.com/wpscanteam/wpscan-v3):
        WPScan v3 BETA is a Black Box WordPress Vulnerability Scanner - https://wpscan.org

* [cloudfoundry / java-buildpack](https://github.com/cloudfoundry/java-buildpack):
        Cloud Foundry buildpack for running Java applications

* [code-mancers / rapidfire](https://github.com/code-mancers/rapidfire):
        Making Dynamic Surveys should be easy!

* [expertiza / expertiza](https://github.com/expertiza/expertiza):
        Expertiza is a web application where students can submit and peer-review learning objects (articles, code, web sites, etc). The Expertiza project is supported by the National Science Foundation.

* [logstash-plugins / logstash-output-s3](https://github.com/logstash-plugins/logstash-output-s3):

repository: josephyzhou/github-trending

gha_language: Go

repo_name: josephyzhou/github-trending


text:
---
title: Get Started
url: /docs
type: docs
include:
  - docs.sidebar
---

Zox.js was designed to be flexible and extensible,
so depending your goals you likely wont need to go through most of the docs.

## [The Basics](/docs/environment-bootstrapping)

If you're looking to start coding right away
you'll first want to learn the main concepts
on which the web server was based,
like plugins and services.

But if you're just looking to create a static site
that wont be necessary for you
unless you're going to use some of the more advanced features.

## [Static Sites](/docs/static-site-setup)

You can quickly start creating your static site
simply by creating a `markdown` or a `yaml` file
and a corresponding template for each page type.

Using HTML forms to enter the data
in a more user friendly way is also possible,
but not available by default.

## [Rendering Pipeline](/docs/render-service)

If you're going to work with templates
you're going to want to know they are handled internally.

The entire pipeline revolves around `Renderable` objects
who's role is to find the target template
and provide it with the data it needs.

## [React SSR](/docs/react-ssr)

React is most often used for single page apps,
but with the web server you can embed React components
anywhere inside your page.

Using the built-in `GraphQL Web Socket` connection utility
you can easily load data into your component
and subscribe to a remote event feed
to keep your component up to date with the server state.

## [GraphQL](/docs/graphql-intro)

While at the beginning developing your API using `REST` endpoints
seems as a more practical approach,
as your app grows so does the time you'll spend on your API.

By creating a GraphQL schema instead
you'll be able to easily extend and maintain your schema.

On top of that the built-in `graphql-plugins`
allows you to define type fields (endpoints) in an almost `REST-like` way.

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# couchdb-cluster-config

Util to configure a CouchDB 2.x cluster with several nodes.

## Motivation

Maybe you've followed the official [cluster setup docs](https://docs.couchdb.org/en/stable/setup/cluster.html)
when trying to setup a CouchDB cluster.

Maybe, like me, you didn't _really_ follow every tiny bit.
One example where one has to pay attention is the `vm.args` file
to configure a common Erlang cookie, or to set the node
names to something different than `localhost`.

Since I also needed more automation via api to setup an integration test environment
I played with same hacky [shell scripts](https://github.com/gesellix/couchdb-prometheus-exporter/commit/73fae7bc37194a0c8e63107fb16d7993d9cfef25),
but a nice implementation in Golang promises better portability and maintainability.

So here it is, a little utility to configure a CouchDB cluster.

## Usage

The tool currently only aims at the single task of initializing a CouchDB 2.x cluster,
but is designed for further extension by leveraging the [urfave/cli](https://github.com/urfave/cli)
package.

### Download/Installation

Like with most Golang based tools, you only need to have Golang installed locally.

    go get github.com/gesellix/couchdb-cluster-config
    couchdb-cluster-config --help

If you don't want to install a complete Golang package, you can also use the ready to run
Docker image.

    docker pull gesellix/couchdb-cluster-config
    docker run --rm gesellix/couchdb-cluster-config --help

There's no configuration necessary, everything works using command line parameters.

### Perform a fresh cluster setup

The couchdb-cluster-config tool expects to run in the same network like the CouchDB nodes.

The tool should work with freshly started nodes, so they usually don't know about an
admin user and not even the core databases `_users` and `_replicator`. For every listed node
the couchdb-cluster-config will ensure that the admin user and core databases exist.
Only then the cluster setup is performed by creating a cluster of all nodes.

### Some more details

To ease running the cluster setup in an automated environment, it waits for every node
to be available on port 5984. This allows to run the tool very early during startup
of a bunch of nodes.

You'll find a `docker-compose.yml` in the root directory of this repository. It allows
to setup an example cluster and also shows how to set node names and the Erlang cookie
before CouchDB startup.

## Contributing

If you found a bug, want to improve something or need a new feature, then
please file an issue or submit a pull request!
You can also contact me at Twitter [@gesellix](https://twitter.com/gesellix).

Never forget: Relax.

repository: rlebre/couchdb-cluster-config

gha_license_id: MIT

repo_name: rlebre/couchdb-cluster-config


text:
# Kubernetes Project Configs

This is a central place for Kubernetes-project specific configs for other tools in this repo.

### UNDER MIGRATION

Directory structure:

[jobs/](./jobs) : job configs for Kubernetes Prow deployment, potentially testgrid configs as well
[tests](./tests) : validation tests for the configs


text:
---
layout: page
title: About
permalink: /about/
---

I've been working as a developer for approximately twelve years. In the last eight i've been engaged with the Microsoft Dynamics platform. And that's been given me some really exciting challenges, such as to architect critical systems and integrate mobile devices to ERPs.

### More Information

I like music, a lot. And videogames, TV series and movies.
I read only technical books, but i'd like to read everything, honestly.

I never wanted to be a .NET developer nor a game developer or any other specific kind of developer.
Just a generic one. A developer. And that's all.

### Contact me

[eduardo.messias<EMAIL_ADDRESS>
---

*[Curriculum vitae](https://eduardomessias.github.io/curriculum-vitae){:target="_blank" rel="noopener"}*

branch_name: refs/heads/main

gha_language: CSS


text:
# Serverless Scaffolder

The Serverless Scaffolder is a highly opinionated AWS Lambda generator built using the Yeoman scaffolding tool. This tool is fantastic for spinning up new Lambda projects very quickly and so works well in conjunction with a microservices based architecture.

## Getting Started

Install Yeoman and the scaffolder via npm:

```bash
npm install -g yo
npm install -g generator-serverless-scaffolder
```

Move into the directory you wish to create your app in (e.g. projects/) and run the generator:

```bash
yo serverless-scaffolder
```

If you want to generate the project with full CodeBuild / CodePipeline and Lambda Terraform IAC then run with the `--iac` flag.

```bash
yo serverless-scaffolder --iac
```

Answer the questions when prompted. The app will now be generated with everything you need to start a Lambda based project.

## What is generated?

- src folder with index.js and Lambda entry point function
- Linter with opinionated linting rules
- .gitignore file which includes files you will typically want to keep out of your git repository
- .nvmrc which locks the Lambda to Node version 10.14.1. This can be changed if needed. To use the version included here install nvm and run `nvm use`
- Pre-commit rules which (among other things) ensures AWS keys are not accidentally posted to a git repository (pre-commit will need to be installed for this to work)
- The Jest testing suite to unit test code
- A package.json file with all the necessarry npm installs and commands to get you started developing Lambda functions
- A Readme with all the information you'll need to get started

## Subgenerators

### Service

To generate a new service in the `src/services` folder of your generated project run

```bash
yo serverless-scaffolder:service
```

This will create a new service class and Jest test file to unit test the aforementioned class.

### DynamoDB Database Service

To generate a new DynamoDB database service in the `src/services` folder of your generated project run

```bash
yo serverless-scaffolder:database
```

This will create a new database service class which interacts with any DynamoDB table provided in the parameters. It will also create a Jest test file with a set of unit tests to test the aforementioned class.

This service has the following methods:

#### getItem

Gets an item from a DynamoDB table when given the table name and the keys. The partition key must be included while the sort is optional. These keys should be included in the following format:

```javaScript
{
  nameOfPartitionKey: {S: 'keyValue'},
  nameOfSortKey: {N: 'keyValue'},
}
```

Where `S` and `N` denote strings and numbers respectively. For more information on interactions with DynamoDB getItem visit the [documentation](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB.html#getItem-property).

#### putItem

Puts an item into a DynamoDB table when given the table name and the full item including the keys. The item should be included in the following format:

```javaScript
{
  nameOfPartitionKey: {S: 'keyValue'},
  nameOfSortKey: {N: 'keyValue'},
  anExampleField: {S: 'an example value'}
}
```

Where `S` and `N` denote strings and numbers respectively. For more information on interactions with DynamoDB putItem visit the [documentation](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB.html#putItem-property).

### Util

To generate a new set of utils in the `src/utils` folder of your generated project run

```bash
yo serverless-scaffolder:util
```

This will create a new util file and Jest test file to unit test the aforementioned functions.

### Constants

To generate a new constants file in the `src/constants` folder of your generated project run

```bash
yo serverless-scaffolder:constants
```

This will create a new constants file.

### Errors

To generate a new error type file in the `src/errors` folder of your generated project run

```bash
yo serverless-scaffolder:error
```

This will create a new error class which can then be imported and thrown in any project JavaScript file.

### Infrastructure As Code

To generate all Terraform associated with standing up CodeBuild/CodePipeline and Lambda for a dev/test environment the following should be run from the root directory

```bash
yo serverless-scaffolder:iac
```

This will create all of the associated IAC in the `iac/` folder. If only the CI or the Lambda IAC is needed please run one of the subcommands found below.

#### Infrastructure As Code - CI (iac-ci)

To generate all associated Terraform to standup CodeBuild/CodePipeline for a dev/test environment located in `iac/`. This should be run from the root folder of your generated project.

```bash
yo serverless-scaffolder:iac-ci
```

All code will be generated in `iac/`.

#### Infrastructure As Code - Lambda (iac-lambda)

To generate all associated Terraform to standup lambda infrastructure for a dev/test environment. This should be run from the root folder of your generated project.

```bash
yo serverless-scaffolder:iac-lambda
```

All code will be generated in `iac/lambda`

#### Infrastructure As Code - API Gateway (iac-apigateway)

To generate all associated Terraform to standup API Gateway infrastructure for a dev/test environment. This should be run from the root folder of your generated project. The terraform should be ran after the Lambda terraform, as it depends on a lambda function being deployed in the same AWS account.

```bash
yo serverless-scaffolder:iac-apigateway
```

All code will be generated in `iac/apigateway`

## License

Apache-2.0 © [Blair Calderwood](https://github.com/blaircalderwood)

### Contributors

| [![Blair Calderwood][blaircalderwood_avatar]][blaircalderwood_homepage]
[Blair Calderwood][blaircalderwood_homepage] | [![Matt Childs][mattchilds1_avatar]][mattchilds1_homepage]
[Matt Childs][mattchilds1_homepage] | [![James Woolfenden][jameswoolfenden_avatar]][jameswoolfenden_homepage]
[James Woolfenden][jameswoolfenden_homepage] |
| ------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |

[blaircalderwood_homepage]: https://github.com/blaircalderwood
[blaircalderwood_avatar]: https://github.com/blaircalderwood.png?size=150
[mattchilds1_homepage]: https://github.com/mattchilds1
[mattchilds1_avatar]: https://github.com/mattchilds1.png?size=150
[jameswoolfenden_homepage]: https://github.com/jameswoolfenden
[jameswoolfenden_avatar]: https://github.com/jameswoolfenden.png?size=150

repository: blaircalderwood/serverless-scaffolder

gha_language: JavaScript

gha_license_id: NOASSERTION

repo_name: blaircalderwood/serverless-scaffolder


text:
# Singly Linked List

Code Challenges 05

## Challenge

- Challenge 05: Create three prototype functions for single linked list class; insert, include, and toString

![](inculdes.png)
![](insert.png)
![](tostring.png)

## Approach & Efficiency

I took the approach of minimizing big O space/time by keeping my functions simplistic and focused on only what was necessary to complete the task.
Big O space is O(1) and time is O(n);

## API

- .insert();
  - Insert a node at the beginning of a linked list
- .include();
  - Search for a value in a linked list and return true or false
- .toString()
  - Output a string of the contents of a linked list

# Challenge 6

Challenge 06: Create three prototype functions of linked list class; append, insert after, and insert before;

![](append.png)
![](insertafter.png)

![](insertbefore.png)

## API

- .append()
  - Add a node to the end of the linked list with a specified value
- .insertBefore()
  - Insert a node with a given value before a specified node
- .insertAfter()
  - Insert a node with a given value after a specified node;

# challenge 7

![](kthFromEnd.png)

# challenge 8

![](codech8.png)

gha_language: HTML


text:
# Projektor UI

[![Code coverage percentage](https://projektorlive.herokuapp.com/repo/craigatk/projektor/project/ui-jest/badge/coverage)](https://projektorlive.herokuapp.com/repository/craigatk/projektor/project/ui-jest/coverage)

The Projektor UI is a [React](https://reactjs.org/) app written with Typescript/Javascript,
built by [Parcel](https://parceljs.org/) with [Yarn](https://yarnpkg.com)

## Development

To start the dev server:

1. Install Yarn if you don't already have it
2. Download and install the project's dependencies with `yarn install`
3. Start the dev server with `yarn start`

This will start the server on `http://localhost:1234`

By default, when running locally the API backend points to `http://localhost:8080`
which is the default port of the server. Start up the server separately using Gradle.

## Testing

The UI is tested by a combination of React Testing Library unit tests
and Cypress browser tests.

To run the unit tests execute `yarn test`

And to run the Cypress tests either `cy:run` to run them headless or `cy:open`
to start the Cypress server and run the tests in Chrome.

## Formatting

The app uses [prettier](https://prettier.io/) for easy auto formatting.
To run the formatter execute `yarn format`

repository: craigatk/projektor

gha_language: Kotlin

repo_name: craigatk/projektor


text:
/*
Title: Application | ExpanDrive
Sort: 8
*/

When ExpanDrive has launched for the first time, you'll need to select the
"OpenStack Swift" Drive Type. Then you will be prompted with a form to enter your
configuration values.

![ExpanDrive Login](/img/content/bulk-storage/expandrivelogin.png)

## Standard Login

For standard OpenStack Keystone authentication, which will authenticate to
all of the containers in your Bulk Storage account, enter your specific
credentials as follows:

```
    auth server  - https://keystone.ca-ns-1.clouda.ca:8443/v2.0/tokens or https://keystone.ca-ns-1.clouda.ca:8443/v2.0
    username     - your Cloud-A login username
    api key      - your Cloud-A password
```

## Container Keys Login

For authentication using container specific API keys, which will
authenticate only to the Bulk Storage container of your choice enter your
credentials as follows:

```
    auth server  - https://ca-ns-1.bulkstorage.ca:8444/keys_auth/<container_name> (replace with the name of your container)
    username     - Full-Key or Read-Key
    api key      - your Container Key
```

## Testing / Debugging

Select “Validate Credentials” to ensure that the system has accepted
your credentials.

If Test Connection fails, ensure that you have entered your credentials
correctly. If you have entered your credentials correctly but are still
receiving a “Connection Failed” error message, ensure that you have the
correct ports open for Bulk Storage. Those ports are: 80, 443, 8443 and
8444.

repository: CloudA/knowledgebase

repo_name: CloudA/knowledgebase


text:
---
layout: article
title: "Gardening Days: Last Sunday of the Month"
categories: articles
tags: [sample]
comments: true
ads: false
image:
  teaser: communalTeaser.jpg
  feature: communalFeature.jpg

---

Our regular gardening days are held on the **last Sunday of every month from 11am to 1pm**. They’re casual, open to all, and there’s always lots to do around the garden for all ages and abilities. But mostly it’s just an excuse to get together and enjoy the terrace together. Bring a picnic (or cocktail) and pop on down!

+ Watering & Weeding
+ Pruning flowers & shrubs
+ Harvesting herbs, fruit and vegetables
+ Planting in new bulbs and plants and sowing seeds

Next dates for your calendar:

+ ~~28 May 2017~~
+ 25 June 2017
+ 30 July 2017
+ 27 August 2017


text:
# Drop Money on Death
An old Garry's Mod addon which allows to drop money on death.

The master branch version is 1.1 and cames from October 31st 2017.

The 1.2 branch version is 1.2 obviously and cames from July (and not August, sorry for the mistake when committing) 2018.

## Purpose

Drop a certain amount of money (based on percentage) of someone when he died.

## Modifying my addon

If you modify my addon, please fork it. It will indicate to me that this is useful and is not a random project on my GitHub account.

## License

This addon is provided with the MIT License which means that you need to credit me for my work if you use this, if it's a modified version or not.
If you just put my addon on your gmod server, you don't need to create some list where my pseudo or name is.
If you modify my addon and share it, you must credit me as the author of the original addon, put the github webpage of the original addon, and credit you as the author of the derivated work based on it.

## How to thank me for my work

Just :
- put a star if you use it (the more it has stars, the more I will work on it)
- fork it if you want to help me (by patching some issues, etc.)
- fork it if you want to create a derivative work based on it
- open issues if you encounter some bugs, have some ideas, etc.

Antoine James Tournepiche

repository: AntoineJT/gmod-dmod

repo_name: AntoineJT/gmod-dmod


text:
# Checkurl

Checkurl is a gem for checking details related to any given url. For example get response code, check if url is working or not, etc.

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'checkurl'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install checkurl

## Usage

Check response code:
```ruby
Checkurl.response_code("https://www.google.com")  # {:code=>"200", :message=>"OK"}
Checkurl.response_code("https://google.com/1234") # {:code=>"404", :message=>"Not Found"}
```

Check if URL is working or not:
```ruby
Checkurl.working?("https://www.google.com")   # true
Checkurl.working?("https://qwerty.com")       # false
```

## Development

After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/checkurl. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

## License

The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

## Code of Conduct

Everyone interacting in the Checkurl project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/checkurl/blob/master/CODE_OF_CONDUCT.md).


text:
# jQuery Rambling Slider [![Build Status](https://travis-ci.org/gonzedge/rambling.slider.png)](https://travis-ci.org/gonzedge/rambling.slider)

The jQuery Rambling Slider is a CoffeeScript improved modified version of the [jQuery Nivo Slider](http://github.com/gilbitron/Nivo-Slider) by Gilbert Pellegrom, which is "The Most Awesome jQuery Image Slider".
It includes some new options and methods to give the slider the ability to adapt different image sizes, flash support and transitions extensions.

You can find more about it on [my blog](http://www.ramblinglabs.com/blog) or on [this repository's wiki](http://github.com/gonzedge/rambling.slider/wiki).

## How to use the jQuery Rambling Slider

The compiled JavaScript and CSS files, are in the `assets/` directory. Those are `assets/javascripts/jquery.rambling.slider.js` and `assets/stylesheets/jquery.rambling.slider.css` for development, as well as `assets/javascripts/jquery.rambling.slider.min.js` and `assets/stylesheets/jquery.rambling.slider.min.css` for production. The images for the different themes are under `assets/images`.

Include the files (either development or production) in your html, and assuming you have something that resembles this:

``` html
<div id="slider">
  <img src="images/image1.jpg" alt="image1"/>
  <a href="#link"><img src="images/image2.jpg" alt="image2"/></a>
  <img src="images/image3.jpg" alt="image3"/>
  <img src="images/image4.jpg" alt="image4"/>
</div>
```

You can then initialize your slider with:

``` javascript
$(window).load(function(){
  $('#slider').ramblingSlider();
});
```

Note that it's set up in the `load` event from `window`, to ensure that the images are already loaded.

### Examples

There are usage examples available in the `examples/` directory.
You might want to see `default.html`, `adaptive.html` and `flash.html`.

## Issues

Please submit any issue you have or any bug that you find with the slider to [the project's issues on GitHub](http://github.com/gonzedge/rambling.slider/issues).

## Features

Among others, the new features added on top of the Nivo Slider include:

* `adaptImages`. __Default value:__ `false`. __Description:__ When set to `true`, uses images instead of backgrounds for the animations, and scales the images to the maximum dimension available.
* `useLargerImage`. __Default value:__ `true`. __Description:__ When set to `true`, uses the larger image dimensions as the maximum dimension available. Otherwise, it uses the slider width as the maximum available.
* `alignBottom`. __Default value:__ `false`. __Description:__ When set to `true`, aligns the bottom right corner of the scaled images with the bottom right corner of the slider. Otherwise, the images are aligned to the top left of the slider.
* Methods `stop`, `start` can be called via `$('#slider').ramblingSlider('stop')` and allow method chaining.
* Methods `option` and `effect` were added. Allow method chaining when calling the setters.
* Method `destroy` was added and allows method chaining.
* Methods `previousSlide`, `nextSlide` and `slide` were added and allow method chaining.
* Method `theme` was added and allows method chaining.
* Some new transitions: `foldLeft`, `rolloverLeft`, `rolloverRight`, `slideInRight`, `sliceUpRandom`, `sliceDownRandom`, `sliceUpDownRandom`, `foldRandom`, `sliceUpOutIn`, `sliceUpInOut`, `sliceDownOutIn`, `sliceDownInOut`, `sliceUpDownOutIn`, `sliceUpDownInOut`, `sliceFadeOutIn`, `sliceFadeInOut`, `foldOutIn`, `foldInOut`, `boxRainOutIn`, `boxRainInOut`, `boxRainGrowOutIn`, `boxRainGrowInOut`.
* Support for transitions extensibility. See [Adding and Overriding Transitions](http://github.com/gonzedge/rambling.slider/wiki/Adding-and-Overriding-Transitions).
* Support for flash elements.
* `fadeOut`, `slideInRight` and `slideInLeft` transitions from image to flash object.
* `slideInRight` and `slideInLeft` transitions from one flash object to another one.

## Supported jQuery versions

The jQuery Rambling Slider has been tested with the following jQuery Releases:

* 2.0.x
* 1.10.x
* 1.9.x
* 1.8.x
* 1.7.x

Version `0.4.0` drops support for versions:

* 1.6.x
* 1.5.x
* 1.4.x
* 1.3.x

For more info on the jQuery versions supported go to the [Supported jQuery Versions page](http://github.com/gonzedge/rambling.slider/wiki/Supported-jQuery-Versions).

## Contributing

### CoffeeScript and Gruntfile

If you're interested in modifying or improving this script, you'll need to resolve these dependencies first:

* NodeJS (`apt-get install nodejs`, `brew install node` for Mac OSX)
* Node Package Manager (`apt-get install npm`, comes with `node` in Mac OSX)
* CoffeeScript (`npm install -g coffee-script`)

You will need to run this inside the project's root directory:

``` bash
npm install
```

You can run the build like this:

``` bash
grunt
# or
grunt default
```

### Unit testing

To run the tests, just run:

``` bash
grunt spec
```

## License and copyright

Copyright (c) 2011-2013 Edgar Gonzalez

MIT License

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

extension: markdown


text:
# CurrentSensor

Handles a ACS712 current sensor via polling using [SoftTimer](https://github.com/prampec/arduino-softtimer).

Requires [SoftTimer](https://github.com/prampec/arduino-softtimer) to be installed.

## Description

It will repeatedly poll an ACS712 Current Sensor or similar, to produce an average, which is less prone to transient noises than the raw reading.

By default it polls the sensor every 10 milliseconds and averages over 10 readings, thus producing an average every 100ms, approximately.  A handler function will be called with this value, in milliamperes, as its single argument.

The current sensor comes in ranges of 5A, 20A and 30A.  To scale the reading to mA, it needs to know the type of sensor used.  It defaults to the 5A.

On creation, it requires:

* `int pin`  The analog input pin where the signal is received, usually one of the `A0` to `A`*n* constants.
* A handler function to respond to changes in the input. The function will receive the value of the signal, approximate in mA with the default settings.

## Usage

Include the CurrentSensor.h header file:

```C++
#include "CurrentSensor.h"
```

### Define the callback function

The function will be called every 100ms with the default values of polling interval and sample size.

```c++
void onCs(float value) {
  Serial.print("value: ");
  Serial.println(value);
}
```

### Create the instance

On creation the pin the sensor is attached to, and the callback function are needed.  The callback function is not required and can be given as `NULL`.

```c++
CurrentSensor cs(A2, onCs);
```

### Start sampling

Within the `setup()` function, start the sampling:

```c++

void setup() {
  Serial.begin(9600);

  cs.start();

  // ......
}
```

On starting, it assumes the consumer of the measured current is idle and it will use the first average as the idle reference value.

### Stop/suspend polling

Polling of the current sensor can be stopped at any time and later resumed.  The status can be read at any time:

```c++
Serial.println(cs.isActive());  // will print true
cs.stop();
Serial.println(cs.isActive());  // will print false

// and at a later time
cs.start();
Serial.println(cs.isActive());  // will print true
```

Calling either `start` or `stop` more than once consecutively does not hurt (meaning, you don't need to check whether it is active or not to change it).

### Setting the sensor range

The default is set for the 5A sensor.  To change the scale factor for other sensors, use the `setMaxCurrent` method.

```c++
  cs.setMaxCurrent(20);  // for the 20 ampere sensor
```

### Setting polling interval.

The default polling interval is set at 10ms.  It can be changed with the `SetPollingInterval` function.

```c++
cs.setPollingInterval(100);
```

The value is in milliseconds and has a maximum of 4,294,967.

### Setting the number of samples

The default number of samples per average is 10.  It can be changed with the `setTotalCount` method. The count should be a positive number, other values will have no effect.  A value of 1 will result in reading the raw value.  Too many samples may overflow the accumulator.

```c++
cs.setTotalCount(20);
```

### Change pin and handler

Either can be changed by calling the following functions:

```c++
  void setPin(int pin);
  void setHandler(void (*onHandler)(float value));
```

### Read the value

```c++
  float v = cs.getValue();
```

It will return the current value, in mA, read from the sensor.

repository: Satyam/Arduino

repo_name: Satyam/Arduino


text:
# RGBDS GBZ80

This extension provides support for the RGBDS flavor of the Game Boy's Z80 variant assembly language in Visual Studio Code.

## Features

### Syntax Highlighting Grammar

A full grammar definition for syntax highlighting is included.

![syntax highlighting](https://raw.githubusercontent.com/DonaldHays/rgbds-vscode/master/previews/syntax-highlighting.png)

### Documented Instruction Snippets

Instruction snippets reveal and document every instruction the Game Boy CPU understands. The documentation even includes the number of cycles instructions take!

![documented snippets](https://raw.githubusercontent.com/DonaldHays/rgbds-vscode/master/previews/instruction-snippets.gif)

### Problem Matcher

An included problem matcher enables Visual Studio Code to highlight invalid lines of code when you compile.

![problem matcher](https://raw.githubusercontent.com/DonaldHays/rgbds-vscode/master/previews/problem-matcher.gif)

### Documented Symbol Detection

Symbols you declare are detected and populated in Intellisense prompts. It even grabs your documentation comments!
- Any uninterrupted runs of lines that consist only of comments preceding a symbol declaration will be considered part of that symbol's documentation.
- A comment on the same line as a symbol declaration is also part of its documentation.

![intellisense](https://raw.githubusercontent.com/DonaldHays/rgbds-vscode/master/previews/doc-comment.gif)

### Documentation Hovers

Hover over symbol references to see their documentation at a glance.

![Syntax highlighting grammar](https://raw.githubusercontent.com/DonaldHays/rgbds-vscode/master/previews/hovers.gif)

### Jump to Declaration

For when you need to see a symbol's implementation.

![Syntax highlighting grammar](https://raw.githubusercontent.com/DonaldHays/rgbds-vscode/master/previews/definition.gif)

## Usage

The language support will automatically activate for any file with `.z80`, `.asm`, `.inc`, `.s`, or `.sm83` file extensions.

### Using the Problem Matchers

The `rgbasm` problem matcher is named "rgbdserror", and the `rgblink` problem matcher is named "rgbdslinkerror". The following is an example of a build task that calls `make` and uses the problem matchers.

```JSON
{
  "label": "build",
  "type": "shell",
  "command": "make",
  "group": {
    "kind": "build",
    "isDefault": true
  },
  "presentation": {
    "panel": "new"
  },
  "problemMatcher": ["$rgbdserror", "$rgbdslinkerror"]
}
```

### Include Path Searching

This extension supports Intellisense for symbols declared in included files. By default, it searches for included files relative to the directory of the open file. But you can configure additional directories to search via the `rgbdsz80.includePath` configuration variable. You may assign a string path or an array of string paths to that variable, and all associated directories will be searched in turn to resolve an included file. Configured paths may be either absolute or relative to the _workspace_ directory.

### Capitalization Formatting

You can customize capitalization rules for your code. See [Capitalization Formatting](https://github.com/DonaldHays/rgbds-vscode/blob/master/formatting.md) for details.

repository: DonaldHays/rgbds-vscode

gha_language: TypeScript

repo_name: DonaldHays/rgbds-vscode


text:
# an intro to proximal causal learning

**eric tchetgen tchetgen, wharton**

- measured covariates are rarely good enough to satisfy exchangeability
- ex. effect of RHC on 30-day survival in ICU
  - obv confounding: patients with RHC performed, were sicker
  - original study used propensity score matching  based on 73 covariates and found that RHC had negative effect
- standard assumptions
  - consistency / SUTVA: $Y=Y_A$
  - positivity: $f(A=a|L) > 0$
  - exchangeability: $Y_a \perp A|L$
- then, we get the *g-formula*: $\beta(a)=\sum_{l} E(Y \mid a, l) f(I)$
- proximal study design assumptions are fairly general
  - allows us to adjust for a certain structure of unmeasured confounding $U$
  - ![proximal_causal_learning](../assets/proximal_causal_learning.png)


text:
# bubble_coding
Signal driven GUI program representation.

Pete Baron (c)2017-2019
MIT License with attribution.

![alt text](https://github.com/pjbaron/bubble_coding/blob/master/bubble_invaders.jpg)

Purpose:

I have long visualised many programming tasks as a set of nested components with communication paths between them.  This is an attempt to turn that visualisation into a development tool.
When making games in particular there are certain types of task that come up very regularly which can be fiddly to handle.  e.g. the game control cycle, or complex menu systems.  Putting these into bubbles, then wiring them together with signals enables a simple visual representation with the possibility of reordering simply by dragging the wires around.

Important note: it is not my intention to replace textual code representation with a graphical replacement, every such attempt I have used has been unwieldy, slow to develop in and has offered only a poor representation of the logic.  I believe that at a function level there is (currently) no more efficient representation of program logic than a good textual coding language.  This project is an attempt to aid visualisation of high level code structure, to offer tools to simplify the creation and modification of that structure, and eventually to assist in debugging the programs by enabling visualisation of data transmission between the code components.

Useage:

You'll need to deploy it remotely, or set up a local server to run it locally.  Wamp Server is what I currently use for development.
Fire up the index.html in /invaders, you will see the bubble graph for the Invaders game.
At first glance the mess of bubbles and wires seems overwhelming.  Click and drag any bubble to move it around, order the work-space in a logical manner for your own ease of interpretation.  Notice that some bubbles are linked (e.g. bombs+bomb) which indicates a hierarchical relationship between them (BubbleEnclose( bombs, bomb )).

Press key 's' to switch between the bubble view and the game in operation.

Some bubbles represent utility features:
- Ticker is a system timer, you will see a wire labelled "start_timer" going into the top of this bubble, and a wire labelled "game_tick" leaving the bottom.
- Keys is the keyboard input system, this has no input wires, output wires are key_up and key_down for this project.
- Canvas is the display system, it has only one input labelled "create_canvas" from "space_invaders".  It registers itself automatically as 'canvas' and 'ctx' on the signal owner.

All other bubbles represent game objects except for "space_invaders" which is a standard format template for projects with timer driven update and draw bubbles.

I generally prefer to have system bubbles at the top, then the program controller "space_invaders", then arrange the program components in arcs below their parent or a source of a controlling signal.  This visually represents a program hierarchy whilst taking advantage of the 2D layout options available to this system.

Note: the bubble layout should save automatically into localStorage every time you make a change, although there may be a bug or a fitting issue with screen resizing - sometimes my layout is lost.

TODO:
- link to a web editor which opens the corresponding file when a bubble is selected, either as a split pane or with a zoom-in effect to show the code 'inside' the bubble
- modify web editor to recognise the bubble coding tags (BubbleExtend( name ), BubbleEnclose( name, name )) and hide them or display them in links as appropriate
- improve the example code structure, as a consequence of developing the example in parallel to the bubble system there are many dubious design decisions in Invaders
- add a debugging system where it is possible to see the signals being activated and their values, step into the functions, inspect variables, etc
- experiment with a 'jog' dial (like AV editors use) to rewind/play/fast forwards the debugger.  I believe that recording Signals and Bubble states before each one arrives might be enough to permit the rewind feature which would be particularly useful when debugging
- add controls to hide wires by pattern matching and useful toggles, (e.g. all "update"/"draw" wires on/off/thin-links, all util or system wires, etc)
- enable bends in wire for manual layout
- create automatic layout system for wires and bubbles that minimises cross-over and tries to represent the classes in a top-down hierarchy layout
- improve representation of linked bubbles (e.g. bombs+bomb, houses+house, invaders+invader) to show non-signal hierarchical relationships.  The original idea was to spawn an additional bubble inside the parent each time a new game item is created, this is clearly impractical when there could be thousands of child objects (I note that this didn't stop Unity from listing them all though).  Perhaps a representative bubble with a count indicator, and some way to reference/search the child list to find the particular one you are interested in, along with play-space debugging features where selecting the visual representation will allow the controlling bubble to be viewed and altered.
- frequently used features as 'stock' bubbles (templates) to reduce time spent on repetitive coding.  e.g. bombs, houses, invaders are all very simple list managers with some specific features to customise them for purpose.  In this case I imagine a 'list manager' bubble which can enclose the additional features And the child bubbles created.
- test the system with a more complex example including multi-level menus (check that they can be reordered by wire manipulations as envisaged originally).  Also more complex relationships between objects than simple parent/child - check that the signals can be used for all such, and that the representation doesn't become hopelessly involved.
- find a better way to handle bubbles like 'space invader' or 'collider' which connect to virtually every game object bubble, these highly connected objects make the layout very ugly to look at and hard to interpret at a glance.  Perhaps some sort of 'bus' which allows multiple wires to join at a nexus, or maybe just having good wire hiding features will be enough.

Contents:
```bash
.
├── invaders - top level folder for a bubble coding example project, the Invaders game
│    ├── image - art in .PNG format
│    ├── sfx - audio in .WAV format
│    ├── src - JavaScript for the environment and the demo
│    ├── game - the game files coded and marked-up for bubble coding
│    ├── lib - libraries used by the game and/or system
│    └── sys - the bubble coding system files including GUI display and the bubble implementation
└─────── util - useful static classes for building games or bubbles
```


text:
---
layout: post
title: The Man Behind the Theory of Evolution
permalink: /blog/book-reviews/evolution/
---

Unless you have been living under a rock, you will most likely know this man.

[![mw01728](https://i.ibb.co/DtyNdCm/mw01728.jpg)
](https://ibb.co/TkSZy8J)Source: http://po.st/l0tqFW

Yes, that’s Charles Darwin, undoubtedly one of THE most iconic figures in history. But how much of this fascinating biologist do you actually know? We’ve rounded up four facts which may change the way you view this stern-faced bearded man.

**1. He didn’t coin the term “survival of the fittest”.**

Yeah.. that term was actually created by Herbert Spencer, a philosopher who wanted to connect his economic and sociological theories with Darwin’s biological concepts.

[![awkward](https://media.giphy.com/media/kHZC0lHGShttiTiOrL/giphy.gif)
](https://imgbb.com/)Source: https://gph.is/g/EGyOgYl

But Darwin eventually adopted the phrase in his fifth edition of *The Origin of Species*. And just to clear the air, Darwin did indeed give full credit to Spencer for coining the famous term.

> But the expression often used by Mr. Herbert Spencer of the survival of the fittest is more accurate, and is sometimes equally convenient.

– Charles Darwin in *The Origin of Species* (chapter 4)

**2. He created a pro/con list to decide whether to marry.**

Ah, the gift of being logical. In 1838, Darwin composed a list that highlighted the upsides and downsides of marriage.

Under the upsides, Darwin [listed](https://www.history.com/news/10-things-you-may-not-know-about-charles-darwin) “children”, “constant companion (and friend in old age)…better than a dog anyhow” and “someone to take care of house.” And under the disadvantages, he listed “freedom to go where one liked,” “conversation of clever men at clubs” and “loss of time.”

He eventually married his first cousin Emma Wedgwood in 1839.

[
](https://imgbb.com/)**3. He dropped out of medical school and became a divinity student.**

Darwin’s father was a successful doctor and Darwin was to follow his footsteps by studying in one of Britain’s top medical schools. Unfortunately, he hated the sight of blood and found the lectures boring.

[![tired](https://giphygifs.s3.amazonaws.com/media/me0mqrZiCbxwQ/giphy.gif)
](https://imgbb.com/)Source: https://gph.is/XKnxpF

And of all the fields of study he could’ve chosen after dropping out of medical school, the man—who would come to challenge the dogma of creationism—enrolled in Cambridge to study divinity.

**4. He was a foodie.**

Animal activists today would have a thing or two to say to Darwin. While at Cambridge, he formed the Glutton Club to seek out and eat “strange flesh”. But the group chickened out after a particularly hard-to-digest brown owl.

[![patrick](https://giphygifs.s3.amazonaws.com/media/12uXi1GXBibALC/giphy.gif)
](https://imgbb.com/)Source: https://gph.is/197G1XA

He managed to continue his foodie hobby when he was travelling on the *HMS Beagle*—he dined on armadillos, ostriches, pumas, and a “20lb chocolate-coloured rodent” which he [thought](https://www.theguardian.com/lifeandstyle/2003/mar/09/foodanddrink.features15) was “the best meat [he] ever tasted”.

If you’d like to know more about the biologist who changed the way we view the world, here are some to start with:

1. [The voyage of the Beagle: the illustrated edition of Charles Darwin’s travel memoir and field journal](https://catalogue.nlb.gov.sg/cgi-bin/spydus.exe/FULL/WPAC/BIBENQ/9542051/140855883,3)
2. [Darwin: Portrait of a Genius](https://nlb.overdrive.com/media/874281)
3. [The Autobiography of Charles Darwin](https://nlb.overdrive.com/media/79349)

repository: isomerpages/nlb-nrm

branch_name: refs/heads/staging

gha_language: SCSS

repo_name: isomerpages/nlb-nrm


text:
# Pachira fuscolepidota (Steyerm.) W.S.Alverson SPECIES

#### Status
ACCEPTED

#### According to
International Plant Names Index

#### Published in
null

#### Original name
Pochota fuscolepidota Steyerm.

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# DevSecOpsVirtualEnv

This is a tool to build a virtual environment for the [DevSecOps Bootcamp](https://github.com/devsecops/bootcamp), up to date and with all the software and tools required for such bootcamp. Also to be used with different platforms such as Vagrant, Docker or AWS.

During the DevSecOps Bootcamp the students create a virtual machine using Vagrant with some of the packages and software required. Eventually other tools from the DevSecOps Toolkit are added to the machine. Every time the machine need to be provisioned it takes a lot of time, time that could be invested in learning, also those installed software and tools disappear and have to be installed again. To avoid these delays DevSecOpsVirtualEnv builded an up to date environment with all the required software and tools from the DevSecOps Toolkit. It also give the option to use other platforms such as Docker or AWS.

## Table of Content

- [Requirements](#requirements)
- [Installation](#installation)
- [Build an Environment](#build-an-environment)
  - [Vagrant](#vagrant)
  - [Docker](#docker)
  - [AWS](#aws)
- [TODO](#todo)

## Requirements
---

If you are on macOS it is recommended, but not required, to install [Homebrew](http://brew.sh/), it will help you to install everything from the command line.

    /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

[Packer](https://www.packer.io/) is required to build the vagrant box or the AMI. Download the installer for your operative system and architecture from https://www.packer.io/downloads.html or use Homebrew to install it (just on macOS).

        brew install packer

Depending of the DevSecOps environment platform you feel more comfortable you need to install [Vagrant](https://www.vagrantup.com/) or [Docker](https://www.docker.com/).

To use __Vagrant__ go to https://www.vagrantup.com/downloads.html and download the installer for your operative system and architecture.

If you are on macOS it can be installed with Homebrew Cask. You need to install VirtualBox then Vagrant, and (optional) [Vagrant Manager](http://vagrantmanager.com/) to manage the virtual machines from a GUI instead of CLI.

    brew cask install virtualbox
    brew cask install vagrant
    brew cask install vagrant-manager

To test it, check the version and create a VM with CentOS or whatever Linux you like.

    packer --version
    vagrant --version
    mkdir -p ~/Sandbox/Vagrant && cd $_
    vagrant init centos/7
    vagrant up
    vagrant ssh
    vagrant halt
    vagrant destroy

For more information go to https://www.vagrantup.com/docs/

To use __Docker__ go to https://www.docker.com/products/docker and download the installer for your operative system then follow the instructions for [macOS](https://docs.docker.com/docker-for-mac/) or [Windows](https://docs.docker.com/docker-for-windows/). But again, if you are on macOS it can be done with Homebrew Cask (not recommended at this time _July 2016_).

    brew cask install dockertoolbox

To test it, check the version, run an image with Nginx, run another with centos, list all the containers, delete them all and delete all the images.

    docker --version
    docker run -d -p 80:80 --name webserver nginx
    open http://localhost/  # Or, In a browser, go to http://localhost/
    docker run -it centos
    docker ps -a
    docker rm $(docker ps -a -q)
    docker images
    docker rmi $(docker images -a -q)

For more information go to https://docs.docker.com/

## Installation
---

Just clone the repository

    git clone https://github.com/johandry/DevSecOpsVirtualEnv.git DevSecOpsVirtualEnv && cd $_

## Build an Environment
---

The environment can be builded for different platforms using the script `build.sh`.

### Vagrant

To build it, use the parameter `--vagrant`, or nothing, it is the default option.

    ./build.sh --vagrant

This process will take a while, around 2 hours depending of your internet bandwidth, so be patience.

The build script will destroy the virtual machine running, remove the previous box created and create the new box using Packer. Once the box is ready you can use the box file or publish it on [Vagrant Cloud](https://atlas.hashicorp.com/vagrant) so others - students - can use it.

To use the box from the __filesystem__ (the created file), the `build.sh` script will do it for you if you export the variable `BOX_LOCAL` set to 1.

    export BOX_LOCAL=1
    ./build.sh --vagrant

To use the box from __Vagrant Cloud__ so everybody (i.e. Bootcamp students) can use it, just execute the `build.sh` script or export the variable `BOX_LOCAL` set to 0 (default value) before execute it.

    export BOX_LOCAL=0
    ./build.sh --vagrant

To make it available, it have to be uploaded first. _This process can and will be automated_.
  1. Go to https://atlas.hashicorp.com/vagrant and login.
  1. Go to the box __DevSecOps_CentOS_7__.
  1. Create a new version going to __New Version__ at the left menu.
  1. Enter the version number. Make sure it is compatible with [RubyGems versioning](http://guides.rubygems.org/patterns/#semantic-versioning).
  1. Enter the description. You can use the description of the previous version and add what is new.
  1. Click on __Create new provider__.
  1. Select the provider __VirtualBox__ and __Upload__. Click on __Continue to upload__.
  1. Choose the created file located in the directory `vagrant/boxes`.
  1. Click on Finish and go to Versions.
  1. Click on the __unreleased link__ then in __Release version__ button.

In both cases the box name is __johandry/DevSecOps_CentOS_7__. To change it, modify the `Vagrantfile` in the line

    config.vm.box = "johandry/DevSecOps_CentOS_7"

The first field (`johandry`) is the Vagrant Cloud username and the second field (`DevSecOps_CentOS_7`) is the box name.

To use the box, use the `Vagrantfile` in the repository, use the variable `config.vm.box` in a custom Vagrantfile or with:

    vagrant init johandry/DevSecOps_CentOS_7
    vagrant up
    vagrant ssh

### Docker

__NOTE__: It is important to know that it is not needed to build an image because [DockerHub](https://hub.docker.com/) will do it automatically every time the `Dockerfile` change in this GitHub repository.

To build the image for Docker execute the `build.sh` script with the parameter `--docker`, like this:

    ./build.sh --docker

The docker build is way more faster than the vagrant build and it - automatically - upload the image to Docker Hub, something that - at this time - have to be done manually with the vagrant build. The docker build takes around 15 minutes depending of your internet bandwidth.

Once the image is created, the script will upload it to DockerHub. Now you can pull it, check it and run it. When it is not needed, you may delete the container and image.

    docker pull johandry/devsecops    # Unnecessary if was recently builded
    docker images
    docker run -it --rm --name devsecops -v ${PWD}/workspace:/root/workspace johandry/devsecops

    docker rm $(docker ps -a | grep johandry/devsecops | cut -f1 -d\ )
    docker rmi johandry/devsecops

If the image is already in DockerHub, just need to run it.

    docker run -it johandry/devsecops

The parameter `-v ${pwd}/workspace:/root/workspace` when you run the container can be avoided if you share the directory (if it is not already shared) using the __File Sharing__ tab in the Docker Preferences.
  1. Click on the Docker icon (the whale with containers).
  1. Select __Preferences__ and go to the __File Shareing__ tab.
  1. Add the volume you want to share with the container (if not already there).
  1. Click __Apply & Restart__ to make the new directory available in every container.

### AWS

Ups! This is not done yet.

The idea is to create an AMI using Vagrant and publish it to AWS. It will provide the same advantages as if the VM is running on VirtualBox but instead will be an instance in your AWS account.

## TODO
---

- [ ] Make the Paker file publish the box to Vagrant Cloud. It could be done by uploading the box or just the URL of the box previously uploaded to another location.
- [ ] The Gems Restacker and Selfie are failing the build because aws-sdk cannot be loaded.
- [ ] Improve the Dockerfile, some commands may not be executed as RUN, instead can be external scripts. Like with Packer or Vagrant
- [ ] Set a VOLUME in the Dockerfile to sync a folder
- [ ] Do the AWS provider with Vagrant
- [ ] Do Vagrant multi-machine to create a Kali VM for the meta-exploits labs. Or, install meta-exploits in this machine.
- [ ] What other DevSecOps tools or software is required?
- [ ] Would we add other provided? OpenStak?
- [ ] Would we use Docker as provider in Vagrant or just use docker?
- [ ] Try Packer build the docker image, instead of using a Dockerfile. Or both.
- [ ] Add Rspec testing

repository: godinezj/DevSecOpsVirtualEnv

repo_name: godinezj/DevSecOpsVirtualEnv


text:
# JAFPro

This repository contains official code for the paper
[JAFPro: Joint Appearance Fusion and Propagation for Human Video Motion Transfer from Multiple Reference Images](https://dl.acm.org/doi/10.1145/3394171.3414001).

You can find detailed usage instructions for training from scratch and testing pre-trained model below.

If you find our code or paper useful, please consider citing

    @inproceedings{10.1145/3394171.3414001,
    author = {Yu, Xianggang and Liu, Haolin and Han, Xiaoguang and Li, Zhen and Xiong, Zixiang and Cui, Shuguang},
    title = {JAFPro: Joint Appearance Fusion and Propagation for Human Video Motion Transfer from Multiple Reference Images},
    year = {2020},
    booktitle = {Proceedings of the 28th ACM International Conference on Multimedia},
    }

## Installation

First you have to make sure that you have all dependencies in place.
The simplest way to do so, is to use [anaconda](https://www.anaconda.com/).

You can create an anaconda environment called `JAFPro` using
```
conda env create -f environment.yml
conda activate JAFPro
```

## DanceVideo Dataset

Our DanceVideo dataset consists of 1651 dance videos in the wild with static background. Each video has a length of two seconds with 15FPS (30 frames in total). The resolution of all videos is 256x256. You can download the whole dataset through https://drive.google.com/file/d/1xlybcxZXcQUCgUuq1K2FLaVGSr8d_NJW/view?usp=sharing

## Usage

Once you have installed all dependencies and downloaded the dataset, you are ready to test our pre-trained model or train a model from scratch.

### File structure

Except code directories, the scripts assume the following file structure.

```
JAFPro
├── checkpoints                # opt['model_save_dir'], where checkpoints placed
└── test_results               # opt["test_save_dir"], path to save test results
```

### Testing pretrained model

At first, download the pretrained model from https://drive.google.com/file/d/1q4Lu6ayHG3-dAl5mE4b6tr6e-O3SHbye/view?usp=sharing, and unzip it into `checkpoints` directory.

```
JAFPro
├── checkpoints
	├── $model_name             # e.g. appearance_propagation_interval
		├── Accu_iter_xx.pth
		├── bg_iter_xx.pth
		├── inpaint_iter_xx.pth
		├── pro_iter_xx.pth
		├── refine_iter_xx.pth
```

Then, you have to setup the data root in `options.py`

```
opt['smpl_root'] = '/your/path/to/DanceVideo/smpls'
opt['mask_root'] = '/your/path/to/DanceVideo/masks'
opt['data_root'] = '/your/path/to/DanceVideo/images'
```

To test the pretrained model, run

```
cd test/
python conv_pro_test.py --gpu 0 -e appearance_propagation_interval -n 4
```
arguments explanation:
```
--gpu: specify gpu device
-e: experiment name (model_name). The program will load checkpoints from JAFPro/checkpoints/$model_name
-n: number of frames
```

And the results will be saved to `test_results/$model_name`

### Calculate metrics

After testing a pretrained model, you can calculate metrics by running

```
python video_evaluation.py --pred /path/to/test/results/dir  --gt /path/to/DanceVideo/images/test --gpu 0 --type densepose
```

such that the metric for each video and for whole test set will be printed to terminal.

### Train a model from scratch

First, setup data root path in `options.py`
```
opt['smpl_root'] = '/your/path/to/DanceVideo/smpls'
opt['mask_root'] = '/your/path/to/DanceVideo/masks'
opt['data_root'] = '/your/path/to/DanceVideo/images'
```
Then, train the texture accumulation model by running the text_accu_LSTM.py for 5000 iterations.

Next, load the pretrained weight for texture accumulation, and run text_inpatin_convLSTM.py for 20000 iterations.

Next, load the pretrained weight in the previous training, and run inpaint_global_convLSTM_FGAN.py for 20000 iterations.

Finally, load the pretrained weight in the previous training, and run convLSTM_flowpro_Iinterval.py for 42000 iterations.

You can monitor on <http://localhost:6006> the training process using [tensorboard](https://www.tensorflow.org/guide/summaries_and_tensorboard):
```
cd OUTPUT_DIR
tensorboard --logdir ./monitoring --port 6006
```

repository: Larry-u/JAFPro

repo_name: Larry-u/JAFPro


text:
---
title: abort
description: abort API reference for redux-requests - declarative AJAX requests and automatic network state management for single-page applications
---

This is a small helper which adds a proper suffix to request action types, it can
be useful to compute type of aborted request action, for example:

```js
import { abort } from '@redux-requests/core';

abort('FETCH_BOOKS') === 'FETCH_BOOKS_ABORT';
```


text:
# Prog Generator

This is the code for the guitar riff writing tool, Prog Generator. This application was created to serve as a riff writing tool and as well as an example of using the Guitarist Toolbox API.

## Getting Started

These instructions will get you a copy of the project up and running on your local machine for development .

### Installing and Running Server

A step by step series of examples that tell you how to get a development env running
```
npm install
```

### Compiles and hot-reloads for development
```
npm run serve
```

## Built With

* [Vue.js](https://vuejs.org/v2/guide/) - The web framework used
* [Vuetify](https://vuetifyjs.com/en/getting-started/quick-start) - For material components
* [Guitarist Toolbox](https://github.com/moisesjsanchez/Guitarist-Toolbox) - Used to generate guitarist music theory terms

## License

This project is licensed under the MIT License - see the [LICENSE.md](https://github.com/moisesjsanchez/prog-generator/blob/master/LICENSE) file for details

repository: moisesjsanchez/prog-generator

gha_language: Vue

repo_name: moisesjsanchez/prog-generator


text:
# Khronos App Client for Frontend

For starting repo, follow these steps.

Install NVM [Show More](https://github.com/creationix/nvm/blob/master/README.markdown)

Install Node v6.3.0 via nvm

```js
nvm install v6.3.0
```

# Project Install

```js
npm install
./node_modules/protractor/bin/webdriver-manager update // Download the Selenium driver
```

## Basic commands

```js
npm start // Start the application in dev mode. Open in http://localhost:3000
npm run test // Run respective Unit tests from app
npm run deploy // Run the unit tests and e2e test, after it build the bundle. Show in http://localhost:8000
```

repository: Danjavia/ReatJS-Apollo-Starter-Kit

repo_name: Danjavia/ReatJS-Apollo-Starter-Kit


text:
---
title: Line
page_title: Line Series
position: 4
---

## Chart for Xamarin.iOS: Line Series

TKChartLineSeries plot their data points on Cartesian Area. Points are connected with straight lines. Here is how to set up a few line series:

```C#
var expensesData = new List<TKChartDataPoint> ();
var incomesData = new List<TKChartDataPoint> ();
var profitData = new List<TKChartDataPoint> ();

var categories = new [] { "Greetings", "Perfecto", "NearBy", "Family Store", "Fresh & Green" };
var expensesValues = new [] { 60, 30, 50, 32, 31 };
var incomesValues = new [] { 65, 75, 58, 59, 88 };
var profitValues = new [] { 5, 45, 8, 27, 57 };

for (int i = 0; i < categories.Length; ++i) {
    expensesData.Add (new TKChartDataPoint (new NSString (categories [i]), new NSNumber (expensesValues [i])));
    incomesData.Add (new TKChartDataPoint (new NSString (categories [i]), new NSNumber (incomesValues [i])));
    profitData.Add (new TKChartDataPoint (new NSString (categories [i]), new NSNumber (profitValues [i])));
}

var seriesForExpenses = new TKChartLineSeries(expensesData.ToArray());
seriesForExpenses.Title = "Expenses";
chart.AddSeries(seriesForExpenses);

var seriesForIncomes = new TKChartLineSeries(incomesData.ToArray());
seriesForIncomes.Title = "Incomes";
chart.AddSeries(seriesForIncomes);

var seriesForProfit = new TKChartLineSeries(profitData.ToArray());
seriesForProfit.Title = "Profit";
chart.AddSeries(seriesForProfit);
chart.Legend.Hidden = false;
```

![](../../images/chart-series-line001.png)

## Configure input and selection of line series

If you would like to configure the distance between finger touch and line to perform selection, set Selection property:

```C#
series.Selection = TKChartSeriesSelection.Series;
```

If you would like to change the series' stroke, you should use the following code snippet:

```C#
var seriesForProfit = new TKChartLineSeries (profitData.ToArray());
seriesForProfit.Style.Palette = new TKChartPalette ();
var paletteItem = new TKChartPaletteItem ();
paletteItem.Stroke = new TKStroke (UIColor.Green);
seriesForProfit.Style.Palette.AddPaletteItem (paletteItem);
chart.AddSeries (seriesForProfit);
```

![](../../images/chart-series-line003.png)

## Set null values visualization

In order to determines whether gaps should be displayed when there are nil values use DisplayNilValuesAsGaps property:

```C#
var seriesForProfit = new TKChartLineSeries (profitData.ToArray());
seriesForProfit.DisplayNilValuesAsGaps = true;
```

repository: telerik/xamarin-forms-docs

repo_name: telerik/xamarin-forms-docs


text:
## Introduction

This starter is an extension for [Spring Social](http://projects.spring.io/spring-social/) to enable connectivity with
Microsoft and provides API binding for [Microsoft Graph API](https://developer.microsoft.com/en-us/graph/).

If you're a Spring developer and want to try out Microsoft Graph, this is the right starter for you. For details, please
check the sample code [here](../microsoft-graph-spring-social-starter-sample/README.md).


text:
---
layout: post
blog-category: blog
title: Choosing Monkhorst and Pack K points mesh
author: Som Phene
image:
tags: [Quantum, Espresso, Resources, Input]
---

Read the papers of Chadi and Cohen (Phys. Rev. B 8, 5747 (1973)), and after that the paper of Mokhirst and Pack (Phys. Rev. B 13, 5188 (1976))

* [Theory for K points](https://journals.aps.org/prb/pdf/10.1103/PhysRevB.8.5747)
* [Monkhorst and Pack](https://journals.aps.org/prb/pdf/10.1103/PhysRevB.13.5188)
* [Choosing Kpoints mesh](https://th.fhi-berlin.mpg.de/th/fhi98md/doc/main/node15.html)