text:
MessageBird's REST API for Go
=============================
This repository contains the open source Go client for MessageBird's REST API. Documentation can be found at: https://developers.messagebird.com.

[![Build Status](https://travis-ci.org/messagebird/go-rest-api.svg?branch=master)](https://travis-ci.org/messagebird/go-rest-api) [![PkgGoDev](https://pkg.go.dev/badge/github.com/messagebird/go-rest-api/v9)](https://pkg.go.dev/github.com/messagebird/go-rest-api/v9)

Requirements
------------
- [Sign up](https://www.messagebird.com/en/signup) for a free MessageBird account
- Create a new access key in the [dashboard](https://dashboard.messagebird.com/en-us/developers/access).
- An application written in Go to make use of this API

Installation
------------
The easiest way to use the MessageBird API in your Go project is to install it using *go get*:

```
$ go get github.com/messagebird/go-rest-api/v9
```

Examples
--------
Here is a quick example on how to get started. Assuming the **go get** installation worked, you can import the messagebird package like this:

```go
import "github.com/messagebird/go-rest-api/v9"
```

Then, create an instance of **messagebird.Client**. It can be used to access the MessageBird APIs.

```go
// Access keys can be managed through our dashboard.
accessKey := "your-access-key"

// Create a client.
client := messagebird.New(accessKey)

// Request the balance information, returned as a balance.Balance object.
balance, err := balance.Read(client)
if err != nil {
	// Handle error.
	return
}

// Display the results.
fmt.Println("Payment: ", balance.Payment)
fmt.Println("Type:", balance.Type)
fmt.Println("Amount:", balance.Amount)
```

This will give you something like:

```bash
$ go run example.go
Payment: prepaid
Type: credits
Amount: 9
```

Please see the other examples for a complete overview of all the available API calls.

Errors
------
When something goes wrong, our APIs can return more than a single error. They are therefore returned by the client as "error responses" that contain a slice of errors.

It is important to notice that the Voice API returns errors with a format that slightly differs from other APIs.
For this reason, errors returned by the `voice` package are of type `voice.ErrorResponse`. It contains `voice.Error` structs. All other packages return `messagebird.ErrorResponse` structs that contain a slice of `messagebird.Error`.

An example of "simple" error handling is shown in the example above. Let's look how we can gain more in-depth insight in what exactly went wrong:

```go
import "github.com/messagebird/go-rest-api/v9"
import "github.com/messagebird/go-rest-api/v9/sms"

// ...

_, err := sms.Read(client, "some-id")
if err != nil {
	mbErr, ok := err.(messagebird.ErrorResponse)
	if !ok {
		// A non-MessageBird error occurred (no connection, perhaps?)
		return err
	}

	fmt.Println("Code:", mbErr.Errors[0].Code)
	fmt.Println("Description:", mbErr.Errors[0].Description)
	fmt.Println("Parameter:", mbErr.Errors[0].Parameter)
}
```

`voice.ErrorResponse` is very similar, except that it holds `voice.Error` structs - those contain only `Code` and `Message` (not description!) fields:

```go
import "github.com/messagebird/go-rest-api/v9/voice"

// ...

_, err := voice.CallFlowByID(client, "some-id")
if err != nil {
	vErr, ok := err.(voice.ErrorResponse)
	if !ok {
    		// A non-MessageBird (Voice) error occurred (no connection, perhaps?)
    		return err
    }

	fmt.Println("Code:", vErr.Errors[0].Code)
	fmt.Println("Message:", vErr.Errors[0].Message)
}
```

Documentation
-------------
Complete documentation, instructions, and examples are available at:
[https://developers.messagebird.com](https://developers.messagebird.com).

Upgrading
---------
If you're upgrading from older versions, please read the [Messagebird `go-rest-api` upgrading guide](UPGRADING.md).

License
-------
The MessageBird REST Client for Go is licensed under [The BSD 2-Clause License](http://opensource.org/licenses/BSD-2-Clause). Copyright (c) 2022 MessageBird

repository: messagebird/go-rest-api

repo_name: messagebird/go-rest-api


text:
## Downloads

**Validator Pack and Definitions:**

The following file contains all the value sets, profiles, extensions, list of pages and urls in the IG, etc. defined as part of the this Implementation Guides:

- [Validator Pack](validator.pack)

In addition there are format specific definitions files:
- [XML](definitions.xml.zip)
- [JSON](definitions.json.zip)
- [TTL](definitions.ttl.zip)

These files should be the first choice whenever generating any implementation artifacts since they contain all of the rules about what makes these US Core profiles valid. Implementers will still need to be familiar with the content of the specification and profiles that apply in order to make a conformant implementation.  See the overview on [validating FHIR profiles and resources](http://hl7.org/fhir/STU3/validation.html) for more information about validating profiles and how to use these artifacts.

**Schematrons** are also available and listed below:

- [vhdir-location](vhdir-location.sch)
- [vhdir-organization](vhdir-organization.sch)
- [vhdir-practitioner](vhdir-practitioner.sch)
- [vhdir-practitionerrole](vhdir-practitionerrole.sch)

**Examples:** all the examples that are used in this Implementation Guide available for download:

- [XML](examples.xml.zip)
- [JSON](examples.json.zip)
- [TTl](examples.ttl.zip)

license: MIT

repository: dchaput/providerdirectory-ig

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: dchaput/providerdirectory-ig


text:
# Coma Phone (Android)

Auto-answers calls on speakerphone. Always hear your friends talk, even while in a coma.

[](https://f-droid.org/packages/me.yardenac.comaphone/)
[](https://play.google.com/store/apps/details?id=me.yardenac.comaphone)

*Fork of [RaiseToAnswer](https://github.com/TheLastProject/RaiseToAnswer)*

repository: yardenac/comaphone

gha_language: Kotlin

gha_license_id: MIT

repo_name: yardenac/comaphone


text:
---
tags: [Notebooks/PG7232/Theory]
title: Week 7 - Theory
created: '2021-02-27T16:55:18.559Z'
modified: '2021-03-03T08:10:17.461Z'
---

# Week 7 - Theory

Last week we covered topics relating to Modeling/Construction.

This week we will discussing a couple of topics related to both Construction and Deployment.

* Quality Assurance.
* Continuous Integration.
* Design Pattern: State Machines.

Practice Session:
* Data Wrangling.

---
---

# Motivation - Quality Assurance

* Well everybody wants SW that works, that you can feel proud of.

* Yet, this is very vague, like saying we would like to be better at something, and end up falling into in action.

* What I want:
  * Describe what Software Quality Means
  * How do you achieve it
  * What is usually on the way of SW Quality.

* References:
  * Pressman 1.5, 4, 14, 16, 17

## Meaning of Quality
* There are many defnitions of quality
 * Some share the same values: eg those things they aim for.

![Icon](../img/quality_values.jpg)

* It is probably safe to say that by following SW engineering principles, with good criteria, you will achieve it.
  * Pressman 1.5: Principles for SW Engineering Practice.
  * Pressman 4: Principles guiding each practice step:
    * Process: Guide your project management work.
    * Practice: Guide your technical work.
    * Detail for each project phase:
      * Communication
      * Planning
      * Modeling
      * Construction
      * Deployment

## The Quality Dilemma
The quality dilemma is essentially this:

![Icon](../img/quality_balance.jpg)

* Good Enough Software
  * This means identifying the main value points and focusing on those:
    * Does the marketing team require a better looking GUI, rather than support for all cases?
  * Also it means understanding what the implications of different costs are:
    * Does the cost of maintenance warrant a complex architecture?

![Icon](../img/quality_cost.jpg)
![Icon](../img/week7-cost-defects.png)

* What is Good Enough Embedded Software?
  * We can't ignore our area, and Embedded Systems interact with persons.
  * Good Enough Embedded Software needs to acertain a minimum threshold:
    * Minimum set of features such that hazards are not created.
    * *Nobody wants good enough aircraft avionics software*

## How do you Achieve Quality

It is the responsability or everybody in the organization:
* It is not just responsability of the QA managers.
* It is not just responsability of the Testers.
* It is not just responsability of the Engineers.

Ultimately Senior Management is responsible, specially of making sure company/team dynamics are such that everybody is covering an aspect of quality.

Remember Week 5, Agile? Agile aims to inherently build quality into the deliverables, not by introducing checks, but rather from a process level.

From different perspectives the actitivites can be synthesized as:
* Software Engineering Methods
* Project Management Techniques
* Quality Control
* Quality Assurance

---
---
# Continuous Integration.

In this section I would like to cover the theory around Continuous Integration and how can it be applied to Embedded Systems.

## Why is this relevant?
* However you call it, Agile, Continuous Delivery etc, all rely on quick small iterations of code.
* The key though is to include activites that increase quality on each iteration.
* Remember week 5? Agile...

![Icon](../img/ci_iteration.jpg)

## What is actually Continuous Integration?
* First let's take a look a the big picture
![Icon](../img/ci_chain.jpg)

* Continuous Deploymen: Getting changes into production automatically.
* Continuous Delivery: Getting changes into a test/production environment after building *safely*, *quickly*, in a *sutainable* way.
* Continuous Integration: Is the practice of integrating developers work as often as possible.

## What do you need to do Continuous Integration?

In this lecture I would like to solely focus on Continuous Integration and outline the building blocks you need to practice it.

Summary in one phrase:
* A viable environment to undertake the necessary processes to build/test/release in an *automated* fashion.
* Key enablers:
  * Automation
  * Unit Testing

Some specific elements include:
* A Code Versioning System
* A CI Orchestration System
  * Jenkins
  * GitHub (module)
  * GitLab (module)
  * BitBucket (module)
  * Buildkite
* Time
  * To plan/build the tests
  * To create/maintain infrastructure
* Team buy-in
  * All developers must buy into the flow and contribute to it

## What is Unit Testing

Unit Testing involves test at the smallest software level: a module or component.

These tests should test both:
* Interfaces
* Internal behaviour.

Noting from Pressman, Boundary checks are one of the most important tasks:
* Do we have enough space?
* Do we control the full range of possible inputs?
* Does our program behave when doing more iterations than expected?

From Pressman:
*Unit testing is normally considered as an adjunct to the
coding step. The design of unit tests can occur before coding begins or after source
code has been generated.*

Key enabler for Unit Testing: Mocking (Stubbing).

### Mocking
Or Stubbing is the technique of replacing *drivers* or *sub-modules* with dummy or controlled versions.

![Icon](../img/mock.png)

This allows for:
* Controlled environment
* Easy test vector injection
* Easier result check

## Considerations for Embedded Systems

* Check the lecture from week 3. A good SW architecture is critical to enable this.
* Do not understimate the challenges and cost associated to handling low-level HW.
* Do not understimate the un-friendliness of Embedded Dev-Ecosystems.
* Ways of mitigating:
  * Distributed SW architecture.
  * De-Risking HW componentes (eg models, experience).
  * Stay outside of Vendor Specific tools as much as possible (don't be dogmatic, be pragmatic about this).

## Conclusion
* Continuous Integration is the practice of integrating small changes, several times as quickly as possible.
* To make this practice scalable and viable you need automation.
* Proprietary tools without SW friendly interfaces are rife in the embedded world.
  * Learning and Experience are the only ways of mitigating this.

## Must Check References
* [Throw The Switch](https://www.throwtheswitch.org/)
* [Jumper Virtual Lab Environment](https://docs.jumper.io/)
* [Atlassian: CI vs CD vs CD](https://www.atlassian.com/continuous-delivery/principles/continuous-integration-vs-delivery-vs-deployment)
* [Jenkins for HW Builds](https://fpgalanguages.com/fpga-1//jenkins-for-hw-builds)

## Other References
* [Balena](https://www.balena.io/os/)
* [In the cloud FPGA based simulation](https://fires.im/)
* [Continuous Integration of FPGA Designs](https://indico.cern.ch/event/799025/contributions/3523397/attachments/1901239/3138541/20190903_Continuous_Firmware_Integration_Glein.pdf)
* [Alan Fitch: Continuous Integration for FPGA Design and Verification](https://www.youtube.com/watch?v=P0EHxJ7EhaQ)
* [Jenkins & Embedded: Talks by Oleg Nenashev and Robert Martin](https://www.jenkins.io/solutions/embedded/)

---
---
# Design Pattern: The State Machine
* We will be consulting Bruce chapter 5.4
* I am assuming you understand well the concept of State Machines.

## Description of the Problem
* Systems responses often depend on the inputs from the user, but also from previous inputs.
* State Machines help implement "State Memory" in a system.
* This is not a HW concept, we can implement this in SW too.
* Useful to implement:
  * Control interfaces/menus.
  * Encoders/Decoders.
  * Anything that requires remembering state to compute its output.

## Implementation
Bruce presents various different approaches to State Machines:
* Single Event Receptor
  * It is the simplest implementation, based of a case switch.
* Multiple Event Receptor
  * It decomposes the case switch into different function calls.
* State Table
  * It creates a 2D array such that:
   ```c
   void execute_fsm(input, state){
    next_state[input][state].transition();
   }
   ```
   * Useful with: large state spaces, same latency in response.
* State (Object)
  * Uses objects to implement each state.
* Others (AND-States)

It is worth nothing that each implementation has got different trade-offs.

In general it is a useful way to document what should happen when. Any of the more advanced patterns should help avoid massive files.

## Example

I will focus on a MERSM (Multiple Even Receptor State Machine), as it is a simple one that I haven't done before.

I want to implement a coding machine, where:
* User inputs a pre-defined number of characters.
* Output over UART encodes these characters in some obscure format.
* Let's checkout the [repo in GitHub](https://github.com/ptorru/design_patterns/tree/main/mer_fsm) for that.

![Icon](../img/fsm.jpg)

branch_name: refs/heads/main

gha_language: C


text:
# Presentation.vbs

[Overview]
[Requirements]
[References]

## Overview

[Presentation.vbs] provides a way to keep the computer awake while giving a presentation, for systems that don't have `PresentationSettings.exe`, notably Windows 10 Home systems.

Click the moon icon in the system tray to see a menu.

When presentation mode is on, the computer and monitor are typically prevented from going into a suspend (sleep) state or hibernation. The computer may still be put to sleep by other applications or by user actions such as closing a laptop lid or pressing a sleep button or power button.

Phone charger mode is the same as presentation mode except that the monitor is turned off, initially

## Requirements

You must have run [Setup.vbs], which installs the VBScript extensions used by [Presentation.vbs].

[Presentation.vbs] may require changes to Windows settings in order to work properly.

Specifically, you may want to increase the value that controls when the following components go to sleep or turn off for both AC (plugged in) and DC (battery):

- Display(s)
- Hard Drive(s)
- Computer

[PresentationSettings.hta] is intended to make these settings accessible from a single location.

## References

[Watcher.cs documentation](../docs/CSharpClasses.md#user-content-watcher "github.com\koswald\VBScript")
[How to change Lock screen timeout before display turn off on Windows 10]
[Does Your Windows Computer Display Turn Off Every 15 Minutes?]
[Canonical Names of Control Panel Items]
[SetThreadExecutionState]

[Overview]: #overview
[Requirements]: #requirements
[References]: #references

[Setup.vbs]: ../Setup.vbs
[Presentation.vbs]: Presentation.vbs
[PresentationSettings.hta]: PresentationSettings.hta

[How to change Lock screen timeout before display turn off on Windows 10]: https://www.windowscentral.com/how-extend-lock-screen-timeout-display-turn-windows-10 "windowscentral.com"
[Does Your Windows Computer Display Turn Off Every 15 Minutes?]: https://www.online-tech-tips.com/windows-7/does-your-windows-7-computer-display-turn-off-every-15-minutes/ "online-tech-tips.com"
[Canonical Names of Control Panel Items]: https://learn.microsoft.com/en-us/windows/desktop/shell/controlpanel-canonical-names "learn.microsoft.com"
[SetThreadExecutionState]: https://learn.microsoft.com/en-us/windows/desktop/api/winbase/nf-winbase-setthreadexecutionstate "learn.microsoft.com"

repository: koswald/VBScript

repo_name: koswald/VBScript


text:
---
layout: default
title: "Welcome to Geometry Smash"
---

    [![Build Status](https://www.travis-ci.com/video-game-coding-club/geometry-smash.svg?branch=master)](https://www.travis-ci.com/video-game-coding-club/geometry-smash)
    [![CircleCI](https://circleci.com/gh/video-game-coding-club/geometry-smash/tree/master.svg?style=svg)](https://circleci.com/gh/video-game-coding-club/geometry-smash/tree/master)
    [![GitHub pull requests](https://img.shields.io/github/issues-pr/video-game-coding-club/geometry-smash.svg)](https://github.com/video-game-coding-club/geometry-smash/pulls)

    [![GitHub issues](https://img.shields.io/github/issues/video-game-coding-club/geometry-smash.svg)](https://github.com/video-game-coding-club/geometry-smash/issues)
    [![Join the chat at https://gitter.im/video-game-coding-club/geometry-smash](https://badges.gitter.im/video-game-coding-club/geometry-smash.svg)](https://gitter.im/video-game-coding-club/geometry-smash?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
    [![Maintainability](https://api.codeclimate.com/v1/badges/2b63bc13f257312435e9/maintainability)](https://codeclimate.com/github/video-game-coding-club/geometry-smash/maintainability)

# The Game

This video game is under active development by Mountain Elementary
students in Los Alamos, NM. It started as a summer break coding
project in 2018.

You can play the game right here: [**Play Geometry Smash**](game.html)

# Authors

In alphabetical order:

- Adis Bock (@adisbock)
- Adrian Medin (@zmedin)
- Anders Medin (@andmedin)
- Ajla Bock (@ajlabock)
- Levi Gibson (@LeviCodes)
- Lucas Price (@lucasprice)
- Zach Gibson (@zachgib)

# Contribute

Contributions are very welcome. If you would like to help please
create a [new issue](https://github.com/video-game-coding-club/geometry-smash/issues)
or submit a [pull request](https://github.com/video-game-coding-club/geometry-smash/pulls).

Please see also:

- Our [Kanban
  board](https://github.com/video-game-coding-club/geometry-smash/projects/1)
  is tracking what we are currently working on. Feel free to pick up
  any of the open
  [issues](https://github.com/video-game-coding-club/geometry-smash/issues)
  and start working on it.
- We also use
  [Gitter](https://gitter.im/video-game-coding-club/geometry-smash)
  for real time chat. Drop by and say hi!
- If you don't want to install any software and start developing
  anyway have a look at
  [GitPod](https://gitpod.io#https://github.com/video-game-coding-club/geometry-smash)
  as your fully featured IDE (Note that the open source plan is
  limited to 100 hours of usage per month).

You can find more information on a suggested workflow on our
[Developer Workflow](DeveloperWorkflow.md) page. If you want to run
the game locally to test your code changes please have a look on our
[Test the game locally](TestLocally.md) page.

More information on git can be found on our [git](Git.md) page.

# GitPod

[GitPod](https://gitpod.io#https://github.com/video-game-coding-club/geometry-smash)
offers tight GitHub integration. All necessary `git` commands can be
run via the GUI instead of the command line. The game itself lives in
`game.html`. Just right-click on the file `game.html` and open it with
the "Mini Browser" and the game should start.

repository: video-game-coding-club/geometry-smash

gha_language: JavaScript

repo_name: video-game-coding-club/geometry-smash


text:
# Thermodesulfovibrio Henry et al., 1994 GENUS

#### Status
ACCEPTED

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Henry, E. A. , Devereux, R. , Maki, J. S. , Gilmour, C. C. , Woese, C. R. ,Mandelco, L. , Schauder, R. , Remsen, C. C. , and Mitchell, R. "Thermodesulfovibrio yellowstonii, gen. nov. and sp. nov. : its phylogenetic relationship to Thermodesulfobacterium commune and their origins deep within the bacterial domain. " Arch. Microbiol. (1994) 161:62-69.

#### Original name
null

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
Dear instructor:
* The dates at the top of this markdown (.md) document will help order the classes in the portal.
Please, if you don't need to, do not change the one that is now.
* Take into account that there is a feature in the dates: if you use a date in the future, the class will be not visible in the portal until the date you have assigned.
* You can create dedicated folders if you need to.
* But if you simply need to add some pictures, you can use the folder ../static/img/ mentioned at the top as /school2021/img/
-->

<!---->

# Welcome to the ESCAPE Summer School

## The ESCAPE project

https://projectescape.eu/

## The school organisation

### Communication

#### Slack
You shall have received an invitation link to slack by email (the one you used to register to the school).
Slack will be used throughout the school as the main communication channel between participants, tutors and organizers.

#### GatherTown

You shall have received an invitation link to GatherTown by email (the one you used to register to the school).
GatherTown is a platform where you can meet fellows as you would in real life, discuss about the school or other topics, but also have fun.
This is the main place we will meet during coffee breaks or breakout sessions for small groups exercises and discussions.

Note however that the platform is limited to 200 simultaneous connections. Please be considerate, if you are not using the platform, just disconnect.
It will be rebooted everyday before the lectures to make a fresh start.

### Lectures
The lectures will be streamed live on YouTube, recorded and fully accessible afterwards.

During the lectures, you will be able to ask questions in the corresponding slack channel.
Questions will be selected by the chairman for the tutors, while others will be answered directly in the chat.

## Summary of links and tools

**School main page**: https://indico.in2p3.fr/event/20306/

**Lectures portal**: https://escape2020.github.io/school2021/

**GitHub**: https://github.com/escape2020/school2021

**YouTube live**: https://www.youtube.com/channel/UC05braEQdP2rCSUamHm9I_Q/live

**Slack**: https://escape-data-school.slack.com/ (by invitation only)

**GatherTown**: https://gather.town/app/Rww2ZWwsxiA2Usz3/ESCAPE%20school (login using your registration email)

## Slides:

### Welcome address

https://indico.in2p3.fr/event/20306/contributions/95827/

<object data="https://indico.in2p3.fr/event/20306/contributions/95827/attachments/64621/89714/20210607_ESCAPE_SCHOOL_INTRO.pdf" type="application/pdf" width="100%" height="550px">
    <embed src="https://indico.in2p3.fr/event/20306/contributions/95827/attachments/64621/89714/20210607_ESCAPE_SCHOOL_INTRO.pdf">
    </embed>
</object>

### School organisation

https://indico.in2p3.fr/event/20306/contributions/95829/

<object data="https://indico.in2p3.fr/event/20306/contributions/95829/attachments/64622/89718/20210607_ESCAPE_SCHOOL_ORGA.pdf
" type="application/pdf" width="100%" height="550px">
    <embed src="https://indico.in2p3.fr/event/20306/contributions/95829/attachments/64622/89718/20210607_ESCAPE_SCHOOL_ORGA.pdf
">
    </embed>
</object>

## Recorded lecture

<iframe width="100%" height="500" src="https://www.youtube.com/embed/TUrJ_IudVx8" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

---

gha_language: Jupyter Notebook


text:
# basscss-sass

Transpiled Basscss Sass partials

http://basscss.com

This repository is provided as a convenience for users working within a Sass build process.
Basscss is written in standard, spec-compliant CSS, using some new features like [custom media queries](http://dev.w3.org/csswg/mediaqueries/#custom-mq) and [custom properties](http://www.w3.org/TR/css-variables/), and is distributed across multiple modules.

If you have any choice in the matter, I highly recommend using [PostCSS](https://github.com/postcss/postcss) instead of Sass.

## Getting Started

```bash
npm install basscss-sass
```

```bash
bower install basscss-sass
```

## Sass Tips

Using Sass as a preprocessor can cause numerous issues when working on large scale CSS with multiple contributors. I recommend following these tips when using Sass.

- **Never use @extend.** `@extend` is an anti-pattern, and Basscss is not intended to work with this functionality in Sass.
- **Avoid Mixins** Mixins lead to unnecessary complexity, are generally poorly understood, often lead to code bloat, and do not align with Basscss's design principles.
- **Avoid Nesting Selectors** To maintain the composability of Basscss, avoid nesting selectors as much as possible.

## Contributing

**The scss files in this repository are not source files.**
They are transpiled from their respective CSS modules using the
[css-scss](https://github.com/jxnblk/css-scss) module.

Do **not** edit the scss files in this repository.

See <CONTRIBUTING.md> for more.

---

[MIT License](LICENSE.md)


text:
# Singleton pattern

- [Singleton pattern](https://en.wikipedia.org/wiki/Singleton_pattern)

## Implementation

An implementation of the singleton pattern must:

- ensure that only one instance of the singleton class ever exists; and
- provide global access to that instance.

Typically, this is done by:

- declaring all constructors of the class to be private; and
- providing a static method that returns a reference to the instance.

The instance is usually stored as a `private static` variable; the instance is created when the variable is initialized, at some point before the static method is first called. The following is a sample implementation written in Java.

```java
public final class Singleton {

    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return INSTANCE;
    }
}
```

## Lazy initialization

因为是静态的，多线程访问的时候，并发存在问题，因此需要加锁

```java
public final class Singleton {

    private static volatile Singleton instance = null;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized(Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }

        return instance;
    }
}
```

使用静态内部类，实现`懒加载`

```java
public class Something {
    private Something() {}

    private static class LazyHolder {
        static final Something INSTANCE = new Something();
    }

    public static Something getInstance() {
        return LazyHolder.INSTANCE;
    }
}
```

实现原理：

上面的代码片段,`LazyHolder` 是一个静态内部类，只有在`getInstance`第一次被调用的时候，才会执行类加载，而 JVM，JLS（Java Language Specification） 保证了类加载的安全性

Since the class does not have any static variables to initialize, the initialization completes trivially.

❌ The idiom can only be used when the construction of Something can be guaranteed to not fail. In most JVM implementations, if construction of Something fails, subsequent attempts to initialize it from the same class-loader will result in a `NoClassDefFoundError` failure.

注意：使用这种方式，必须保证构造方法成功的只想，不然会出现 `NoClassDefFoundError`错误

## 好文链接

- [Double-checked_locking](https://en.wikipedia.org/wiki/Double-checked_locking)


text:
# 52167-Programming-and-Scripting

Exercise submissions for the 52167 Programming and Scripting on the GMIT Higher Diploma in Data Analytics 2018 Course

## Problem Sets

1. 01_fibname.py - Exercise 1 and 2 submissions

1. 02_collatz.py - Exercise 3 submission

1. 03_euler_5.py - Exercise 4 submission

1. 04_iris_format.py - Exercise 5 submission

1. 05_factorial.py - Exercise 6 submission

## Instructions

1. Python 3.6.3 installation required

1. Clone or download scripts from this repository

1. Open Terminal window

1. Run the following command
    *python filepath/filename.py*

## References

* [Visual Studio Code](https://code.visualstudio.com/)
* [Anaconda](https://www.anaconda.com/download/#macos)
* [GMIT Course Material](https://learnonline.gmit.ie/course/view.php?id=3940)
* [Python Tutorial](https://docs.python.org/3/tutorial/)
* [Mastering MarkDown](https://guides.github.com/features/mastering-markdown/)


text:
## spark-summit-2019-demo
Demo created for [Life is but a Stream](https://databricks.com/sparkaisummit/north-america/sessions-single-2019?id=125) presentation at Spark AI Summit 2019 (San Francisco, CA). The Notebook found within this repository is meant to be run on a Databricks cluster. If you do not have access to one already, you can [signup](https://databricks.com/try-databricks) to run the demo.

If you simply want to see the results and visuals that were generated at each step of the demo, then you can view the _SEC Apache Logs.html_ page contents. Otherwise, follow the setup steps below to be able to generate these results for yourself. Note that this content was originally created using Spark 2.4.0 with the Databricks Runtime (DBR) Version 5.3.

### AWS Setup
1. Create/log into your AWS account and establish an access key and secret using IAM.
2. Create an S3 bucket and an associated [Databricks mount](https://docs.databricks.com/spark/latest/data-sources/aws/amazon-s3.html#mount-an-s3-bucket). Configure the mount name within the _SEC Apache Logs_ notebook, in the first code cell.
3. Create a Kinesis Data Stream called _spark-summit-2019_ with the default settings.
4. Create a DynamoDB table called _sec-company-lookup_, with a primary partition key called _cik_ (STRING). Override the default settings to configure the table to use ON-DEMAND capacity.
5. Create a Lambda function called _sec-company-lookup_, targeting _Node.js 8.10_, using the contents of _lambda.js_.
6. Create an AWS Gateway API that passes requests through to the _sec-company-lookup_ Lambda function. Deploy the API Gateway, and configure the public URL within the _SEC Apache Logs_ notebook, in the first code cell..

### Data Setup
1. Download [SEC EDGAR web server logs](https://www.sec.gov/dera/data/edgar-log-file-data-set.html) to your local computer.
2. Upload the CSV content to a sub-folder within your AWS S3 bucket called _sec-logs_.
3. Download the [IANA status codes](https://www.iana.org/assignments/http-status-codes/http-status-codes-1.csv), and upload the CSV content to a sub-folder within your AWS S3 bucket called _http-status-codes_.
4. Launch a Databricks Spark cluster, which has the _AWS_ACCESS_KEY_ID_, _AWS_SECRET_ACCESS_KEY_, and _AWS_REGION_ environment variables configured to use your AWS IAM credentials.
5. Attach a new Notebook to this cluster, and run the following code. This will populate your DynamoDB table with the necessary _cik_ -> _company name_ information.

```scala
import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClientBuilder;
import com.amazonaws.services.dynamodbv2.model.AttributeValue;
import scala.collection.JavaConverters._

// Ensure that this mount has already been established; it can point to any S3 bucket within your AWS account.
val dataMount = "/mnt/spark-summit-2019-demo"

spark
  .read
  .text(s"$dataMount/cik-ticker/company")
  .map(c => {
    val line = c.getString(0)
    val name = line.substring(0, 62).trim
    val cik = line.substring(74, 86).trim
   (cik, name)
  }).as[(String, String)]
  .distinct()
  .foreach(r => {
    val dynamoDB = AmazonDynamoDBClientBuilder
      .standard()
      .build()

    dynamoDB.putItem("sec-company-lookup", Map(
      ("cik" -> new AttributeValue(r._1)),
      ("name" -> new AttributeValue(r._2))
    ).asJava)
  })
```
  6. Run the following code to generate files representing the hourly activity within the SEC server logs.

```scala
import org.apache.spark.sql.types.StructType
import org.apache.spark.sql.catalyst.ScalaReflection
import org.apache.spark.sql.functions._

// Ensure that this mount has already been established; it can point to any S3 bucket within your AWS account.
val dataMount = "/mnt/spark-summit-2019-demo"

case class Log(ip: String, date: String, time: String, zone: Float, cik: Float, accession: String, extention: String, code: Float, size: Float, idx: Float, norefer: Float, noagent: Float, find: Float, crawler: Float, browser: String)

val logSchema = ScalaReflection.schemaFor[Log].dataType.asInstanceOf[StructType]

// Load the raw logs from S3.
val logs = spark
  .read
  .option("header", "true")
  .schema(logSchema)
  .csv(s"$dataMount/sec-logs/")

// Break them down by hour of the day.
for(i <- 0 to 23) {
  logs
    .filter(hour(format_string("%s %s", $"date", $"time")) === i)
    .repartition(1)
    .write
    .csv(s"$dataMount/sec-logs-hourly/$i/")
}
```

### Publishing Data
1. Ensure that Docker is installed and running on your computer. Clone the [Docker container provided by Zendesk](https://github.com/zendesk/docker-amazon-kinesis-agent).

```bash
git clone https://github.com/zendesk/docker-amazon-kinesis-agent.git
```
2. Traverse into the cloned repository, and update the _agent.json_ file to contain the name of your Kinesis data stream.

```json
{
  "cloudwatch.emitMetrics": true,
  "kinesis.endpoint": "kinesis.us-east-1.amazonaws.com",
  "cloudwatch.endpoint": "monitoring.us-east-1.amazonaws.com",
  "flows": [
    {
      "filePattern": "/tmp/log-input/*.*",
      "kinesisStream": "spark-summit-2019"
    }
  ]
}
```

3. Run the following commands to build and execute the container. When the container is running, this will mount the input folder to the local path _~/kinesis-logs/_. Create that in advance, or choose and configure a different local path.

```bash
docker build -t spark-summit-2019/kinesis-agent .
docker run -v ~/kinesis-logs:/tmp/log-input/ spark-summit-2019/kinesis-agent:latest
```

4. Now that the Kinesis data agent is running (via Docker), anytime a file is placed inside of the _~/kinesis-logs/_ folder it's contents will be parsed and published to the Kinesis data stream. You can drop the SEC web server logs into this location while running the Spark Structured Streaming portion of the demo Notebook to see the magic come to life.


text:
# Initialize protobuf types

To use the protobuf types, they have to be linked to the ```/usr/local/include```
folder, in the same way like Google's protobuf well-known-types.

```console
foo@bar:~$ mkdir /usr/local/include/roockie
foo@bar:~$ ln -s $GOPATH/src/github.com/roockie-nebula/protobuf/types /usr/local/include/roockie/protobuf
```

Now the protobuf types can be imported into your proto definition file.
```
syntax = "proto3";

package startrek;

import "roockie-nebula/protobuf/timestamp.proto";
import "roockie-nebula/protobuf/nullstring.proto";
import "roockie-nebula/protobuf/nullint.proto";

message StarfleetShip {
	string name = 1;
	roockie.protobuf.NullInt passengers = 2;
	roockie.protobuf.NullString mission = 3;
	roockie.protobuf.Timestamp departure_time = 4;
}
```

repository: roockie-nebula/protobuf

repo_name: roockie-nebula/protobuf


text:
# VolumeVisualizationGL

### An OpenGL 4.5 based large volume renderer.

## Feature:
----
1. **OpenGL 4.5 based:**
All OpenGL APIs are DSA version. They are very clear and effective. Therefore, the source code is also a good example for learning the newer API, which covers the most common API on rendering.
2. **Native API almost in one file:**
Almost all OpenGL calls are explicitly written in *main()* function that you can easily read from start to end and understand the graphics pipeline configuration.
3. **Large Scale Volume Data Rendering:**
It can render serveral tera-bytes volume data interactivly.
4. **Flexible volume data format:** For better perfermance, you can define your own data format without recompiling the renderer. Just extents the data reader by the plugin ```IBlock3DPluginInterface ``` defined in **[VMCore][1]**

**Installation:**
----
### Requirements:
1. **Git**
2. **CMake**
3. **C++17 or heigher**

### Dependences:
The only external dependency is **[GLFW][2]**.

Besides, it has dependent libraries **[VMCore][1]**,**[VMUtils][2]** and **[VMat][3]**, which are automatically installed by the cmake scripts
### Windows:
**[Vcpkg][5] is highly recommanded to install the GLFW**.

```
git clone https://github.com/cad420/VolumeVisualizationGL.git --recursive
```
The project could be opened in **VS2019** or **VS2017** by **Open Folder** and compiled

### Linux:
You can use any package manager you like to install **GLFW**.
After install the external dependences:

```
git clone https://github.com/cad420/VolumeVisualizationGL.git --recursive
```
You need cmake configuring and compiling as usual.

### macOS:
---
OpenGL is deprecated by Apple long ago. It has no latest version this project rely on.
Moreover, the performence of OpenGL on macOS is horrible. Forget it on macOS though it could be compiled successfully theratically as what to be done on Linux.

### Others:
---
 1. Please reference the command line parameters handler for further use.
 1. The project is just ported from **VisualMan** and not tested well. It only run with a small-scale data.
 2. The project do not integrate default data reader for any formats. If you need our data reader, please compile it from **[VMPlugins](https://gitub.com/cad420/VMPlugin)**, and put the shared library into the subdirectory *plugins* in the executable binary's directory.
 3. There is a OpenGL graphics driver issue when using Intel GPU. see https://software.intel.com/en-us/forums/graphics-driver-bug-reporting/topic/740117. I do not have other GPU now, so I try a alternative way. If you have other GPU, you can subsititute with better codes commented in rendering loop.

[1]: https://github.com/cad420/VMCore
[2]: https://github.com/cad420/VMUtils
[3]: https://github.com/cad420/VMat

[4]: https://github.com/glfw/glfw
[5]: https://github.com/microsoft/vcpkg


text:
---
layout: "podcast-or-interview"

mp3_bytes: "42054912"
mp3_duration: "43:48"

guest: "Nick Hnatiw"
guest_avatar: "nick-hnatiw"
guest_website: "http://passwordspace.com/"

category: "podcast"
tags:
  - "django"
  - "python"
  - "react"
  - "digitalocean"
  - "heroku"
  - "postgres"
  - "sendgrid"
  - "ubuntu"
  - "webpack"

title: "Password Space Is a Password Manager for Families"
description:
  Nick Hnatiw talks about building a password manager with Django and Python.
  It's hosted on Heroku and DigitalOcean.
---

In this episode of Running in Production, {{ page.guest }} goes over building a
password manager with Django and Python. It's hosted on Heroku and
DigitalOcean.

Nick talks about using Django Rest Framework because there's a web app along
with native mobile apps, the value in charging for a product to avoid having
your data sold, using HashiCorp Vault to manage user's private keys and more.

## Topics Include

- 5:05 -- Motivation for using Django and Python
- 7:15 -- The Django admin isn't perfect but it helps save a lot of time
- 9:16 -- Using Django Guardian and Django Rest Framework
- 11:05 -- It's a monolithic API back-end with 1 extra small service to handle private keys
- 13:12 -- The back-end is about 1,000 or 2,000 lines of code
- 14:03 -- It'll be a small amount per month to use and all of your data will be private
- 16:42 -- Using React on the front-end and why the back-end is an API
- 18:26 -- The back-end will likely be open source in the future
- 20:35 -- Developing the API back-end alongside the React + mobile app front-ends
- 22:04 -- The site is hosted on Heroku's free tier (including PostgreSQL too)
- 26:43 -- The process to develop a feature and then have it be live on the site
- 29:55 -- The database and encrypted keys are being backed up
- 30:45 -- The Vault service is running on a $5 / month DigitalOcean server
- 34:01 -- The server is running Ubuntu and we share a fun trip down memory lane with Gentoo
- 37:04 -- Best tips? Discovering Vault and being able to use it to secure user data
- 42:54 -- Check out <{{ page.guest_website }}>

## Links

###### 📄 References

- <https://en.wikipedia.org/wiki/Don%27t_repeat_yourself>
- <https://www.vaultproject.io/>

###### ⚙ Tech Stack

{% include services-used.html %}

###### 🛠 Libraries Used

- <https://github.com/encode/django-rest-framework>
- <https://gunicorn.org/>

gha_language: HTML


text:
<!-- README.md is generated from README.Rmd. Please edit that file -->

# AustralianElections <img src="man/figures/logo.png" align="right" height="250" />

<!-- badges: start -->

[![Travis build
status](https://travis-ci.org/RohanAlexander/AustralianElections.svg?branch=master)](https://travis-ci.org/RohanAlexander/AustralianElections)
<!-- badges: end -->

`AustralianElections` is a collection of datasets related to Australian
elections. The datasets are:

-   **byelections**:
-   **elections**: The main dataset.
-   **parliaments**: Dates of each parliament.
-   **voting_data**: All federal elections.
-   **voting_data_with_ids**:

The datasets are up-to-date as of 10 September 2019.

If you have suggestions on how I could improve the datasets, or
corrections, please don’t hesitate to get in touch.

## Installation

You can install this package from GitHub with:

``` r
# install.packages("devtools")
devtools::install_github("RohanAlexander/AustralianElections")
```

## Example

This is an example of how to load the data:

``` r
devtools::install_github("RohanAlexander/AustralianElections")

byelections <- AustralianElections::get_auselection("byelections")
elections <- AustralianElections::get_auselection("elections")
parliaments <- AustralianElections::get_auselection("parliaments")
voting_data <- AustralianElections::get_auselection("voting_data")
voting_data_ids <- AustralianElections::get_auselection("voting_data_with_ids")
```

Alternatively, you can load only a specific year:

``` r
voting_data_2016 <- AustralianElections::get_auselection("voting_data", year = 2016)
```

Or, a range of years by using a relational operator:

In addition to providing access to these datasets, `AustralianElections`
also provides two pre-filtered datasets based upon the
two-party-preferred results and the eventual winner. These datasets by
default use the `voting_data_with_ids` dataset, but can be set to use
the `voting_data` dataset instead.

To call the two-party-preferred dataset you can use:

``` r
twopp_ids <- AustralianElections::auselect_twopp()
```

To call the version based on the `voting_data` you use:

``` r
twopp_noids <- AustralianElections::auselect_twopp(w_ids = F)
```

The winners dataset works similarly, with the default dataset being
`voting_data_with_ids` while setting `w_ids` to `FALSE` will set the
base dataset to `voting_data`.

``` r
winners_ids <- AustralianElections::auselect_winners()
```

``` r
winners_noids <- AustralianElections::auselect_winners(w_ids = F)
```

## Dataset details

TBD

## TODO

## Roadmap

## Sources

## Acknowledgements

## Citation

If you use `AustralianElections`, please consider citing:

Alexander, Rohan. (2019). AustralianElections: Datasets on Australian
Elections. Source:
<https://github.com/RohanAlexander/AustralianElections>.

## Author information

**Rohan Alexander** (corresponding author and repository maintainer)
University of Toronto
Information Sciences
140 St George St
Toronto, ON, Canada
Email<EMAIL_ADDRESS>

repository: RohanAlexander/AustralianElections

repo_name: RohanAlexander/AustralianElections


text:
    Mysql To MongoDb

I made this tool as i was starting to learn mongodb and i couldnt find any decent alternative.

The tool is working as expected and even tested on a live working app that uses mysql, however i strongly recommend that you use this package with a grain of salt.

## Installation

- `composer require ctf0/mysql-to-mongodb`

- (Laravel < 5.5) add the service provider

    ```php
    'providers' => [
        ctf0\MysqlToMongoDb\MysqlToMongoDbServiceProvider::class,
    ]
    ```

## Usage

```bash
mongo:migrate            # clone mysql data to mongodb
mongo:migrate:pivot      # resolve pivot foreign ids (ManyToMany)
mongo:migrate:relation   # resolve foreign ids (OneToMany)
mongo:migrate:cleanup    # remove un-wanted field/collection from the db
mongo:migrate:maintain   # backup/restore mongo db (mongodump / mongorestore)
```

[Wiki](https://github.com/ctf0/MysqlToMongoDb/wiki/Usage)

## Notes

- if you havent installed mongodb yet, check http://wp.me/p4DYee-9Q
- make sure that you can connect to both of your dbs through laravel without any issues.
- the package assume that your **mysql** driver connection is `mysql` and your **default** driver connection is `mongodb`.
- the package **doesnt** recreate the table types from `mysql`, and its up to `mongodb` to decide at that point, however currently the below types gets converted on migration
    - `tinyint(1) => bool`
    - `timestamp => date`
    - `multi(OneToMany) => index`
    - `unique => index/unique/sparse`

        **having a field with the same name in 2 different collections will give an error, so as a-way-around the index is saved as (CollectionName_field)**

- all your app calls to `id` should be changed to `_id` except in view which is automatically converted through the model.
- `moloquent` use `string` for the relation linking/referencing, so when converting the ***foreign_ids*** to `ObjectId` now you will have `string` on one side and `ObjectId` on the other which will cause lots of trouble, so its kept as **string**.

## ToDo

* Find Away To Add Data In Bulk Instead Of One By One.
* Upload Db Backup To S3.
* Make A Small GUI For Easier Migration.


text:
# NaiveHTTP

Work-in-progress at a focused `NSURLSession` simplification wrapper that is also my learning exercise for [Protocol-Oriented Programming](https://developer.apple.com/videos/wwdc/2015/?id=408).

## Installation

This is a framework, so you can either build it as such or include it as a submodule/subproject and link it to your binary in Build Phases.

> Don't forget to `git submodule update --init` to download other dependencies.

## Usage

```swift
import NaiveHTTP

let sessionConfig = NSURLSessionConfiguration.ephemeralSessionConfiguration()
let naive = NaiveHTTP(configuration: sessionConfig)

let query = ["key1":"value1", "key2":"value2"]
let customHeaders = ["X-Some-Header" : "Feh"]

naive.GET(
    "http://example.org/thing",
    params: query,
    headers: customHeaders) { (data, response, error) -> Void in
        // Do stuff with the callback values
    }
```

Convenience functions, like `jsonGET` let you work with "pure JSON" endpoints.

## Protocols

This project is taking on some shape with respect to use of Protocols, which has been helping with testing against fake network responses.

## Tests

The main suite runs against <http://httpbin.org> but is configurable to run against your own local instance of it. Check the `NAIVEHTTP_EXTERNAL_TEST_SERVER` environment variable under the Test section in the NaiveHTTP scheme and set it to the appropriate value.

If you want to run your own local `httpbin` you can use Python and PIP:

```sh
pip install httpbin
python -m httpbin.core
```

You can read more info about running a local `httpbin` at <https://github.com/Runscope/httpbin>

repository: otanistudio/NaiveHTTP

gha_language: Swift

repo_name: otanistudio/NaiveHTTP


text:
# projectTwo

# Cane Banking
Cane Banking is a full-stack web application that allows users to sign up, perform transactions, check balance, transfer funds, and open up accounts such as saving, checking, or credit card account. As a client, the user will have access to common services like checking balance, create a saving, checking, or credit card account, deposit a check, transfer funds and etc. As an employee, user will have access to client applications, approve and deny applications for account creation, and answer inquiries.
# Technologies Used
Postgres Database,
React Native,
Redux,
TypeScript,
AWS: API Gateway, cloudWatch, DynamoDB, Lambda, RDS.
# Getting Started
## git clone https://github.com/cane-banking/projectTwo.git
## CLIENT=http://localhost:3001
## MOBILE=http://localhost:19006
## ANDROID=http://localhost:19000
# Usage
You will need an AWS account, and API Gateway, CloudWatch, DynamoDB, Lambda, RDS services.
1) npm install on caneBanking-frontend folder.
2) npm install on expressbackend folder.
## caneBanking-frontend
npm run start
# License
This project uses the following license: https://opensource.org/licenses/ISC

license: ISC

repository: cane-banking/projectTwo

repo_name: cane-banking/projectTwo


text:
# [Which is my cat?](http://gorgeous-pump.surge.sh/)

![Which-is-my-cat](screenshots/example.JPG)

![Highest-rating](screenshots/ratings.JPG)

> A front end app created using React for simulating a web UI that could be used for training an ML model using supervised learning.

---

### Table of Contents

- [Description](#description)
- [Installation](#installation)
- [License](#license)
- [Info](#info)

---

## Description

The aim of this assignment is to get help from the user to train a dataset of images and correctly tag the images of cats. You can store up to 20 to 30 images in an /images folder in your codebase. Some of these images will be actual cat photos and others need to be of random objects. You need to get the user to click on actual cat images and then rate those images accurately based on the user feedback. When you shuffle through all the images, at the end, you will need to show the images to the user with the most ratings.

Have a look at the Live version [here](http://gorgeous-pump.surge.sh/).

#### Technologies

- React

---

## Installation

#### `Step 1` - Clone the repo

```bash
$ git clone https://github.com/roheat/indorse-cats.git
```

#### `Step 2` - cd in the repo

```bash
$ cd indorse-cats
```

#### `Step 3` - Install dependencies

```bash
$ npm install
```

#### `Step 4` - Run application

```bash
$ npm start
```

In browser, open [http://localhost:3000](http://localhost:3000)

---

## License

MIT © [roheat](https://github.com/roheat)

---

## Info

- Website - [roheat.com](https://roheat.com)
- Twitter - [@roheatdotcom](https://twitter.com/roheatdotcom)
- LinkedIn - [Rohith Srivathsav](https://www.linkedin.com/in/rohith-srivathsav/)

repository: roheat/indorse-cats

repo_name: roheat/indorse-cats


text:
# Single Transaction Multi Signature Contract

<div>

[![Build Status](https://travis-ci.org/NFhbar/SingleTxMultisig.png?branch=master)](https://travis-ci.org/NFhbar/SingleTxMultisig)
[![Coverage Status](https://coveralls.io/repos/github/NFhbar/SingleTxMultisig/badge.svg?branch=master)](https://coveralls.io/github/NFhbar/SingleTxMultisig?branch=master)
[![NSP Status](https://nodesecurity.io/orgs/nicolas-frega/projects/ff951f47-780c-48d0-af12-330754a60afa/badge)](https://nodesecurity.io/orgs/nicolas-frega/projects/ff951f47-780c-48d0-af12-330754a60afa)
[![contributions welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat)](https://github.com/NFhbar/SingleTxMultisig/issues)

</div>

## Description
A single transaction multi signature contract based on: [Gnosis Multisig](https://github.com/gnosis/MultiSigWallet).
This version includes the modifier:
```
modifier onlyOneTransaction() {
      require(transactionCount == 0);
      _;

    }
```
which allows for only one transaction. After that the contract is rendered unusable.

Useful for simple transactions in which parties part ways after execution.

## Install
### ethpm
```
$ truffle install<EMAIL_ADDRESS>```
[single-tx-multisig](https://www.ethpm.com/registry/packages/47).

### Clone
Clone repo:
```
git clone git@github.com:NFhbar/SingleTxMultisig.git
```

Create a new ```.env``` file in root directory and add your private key:
```
RINKEBY_PRIVATE_KEY="MyPrivateKeyHere..."
```
If you don't have a private key, you can use one provided by Ganache (for development only!):
```
RINKEBY_PRIVATE_KEY="c87509a1c067bbde78beb793e6fa76530b6382a4c0241e5e4a9ec0a0f44dc0d3"
```
then:
```
npm install
```
To enter Truffle:
```
truffle develop
```
To compile:
```
truffle(develop)> compile
```
To migrate:
```
truffle(develop)> migrate
```
To test:
```
truffle(develop)> test
```
or
```
npm run test
```

## Coverage Analysis
### Solidity Coverage
To run [Solidity Coverage reports](https://github.com/sc-forks/solidity-coverage):
```
$ npm run coverage
```
Keep in mind solidity-coverage now expects a globally installed truffle.
Coverage report available [here](https://github.com/NFhbar/SingleTxMultisig/blob/master/coverage).

## Docker
Docker image [here](https://hub.docker.com/r/nfhbar/singletxmultisig/).
Dockerfile [here](https://github.com/NFhbar/Docker-SingleTxMultisig).

## Issues/Bugs
### Wrong Contract Address
When migrating
```
Error: Attempting to run transaction which calls a contract function, but recipient address 0x8cdaf0cd259887258bc13a92c0a6da92698644c0 is not a contract address
```
Solution: delete contents of [/build/contracts](./build/contracts) and recompile.

### Not Enough Funds during test
When testing in truffle develop
```
Error: sender doesn't have enough funds to send tx.
```
Solution: restart truffle develop.

Notes: truffle does not reset accounts balance on multiple runs.

### Solidity Coverage testrpc ghost process
After running solidity-coverage, testrpc remains a ghost process.

repository: kyawmyohlaing/SingleTxMultisig

repo_name: kyawmyohlaing/SingleTxMultisig


text:
PyPresent
========
Quantified patient MHC presentation

Author: Rachel Marty <br>

Introduction
--------
PyPresent has been developed to improve the reproducibility of MHC-I and MHC-II presentation scores as seen in (Marty et al. 2017). It is a wrapper that is build around netMHCpan and netMHCIIpan. Users can get residue-centric presentation by single alleles and multi-allelic patients.

Requirements
---------
PyPresent uses the following software:

1. [NetMHCpan-3.0](http://www.cbs.dtu.dk/services/NetMHCpan-3.0/)
2. [NetMHCIIpan-3.1](http://www.cbs.dtu.dk/services/NetMHCIIpan-3.1/)

*Licensed only for academic use*

And the following Python modules:

1. [Pandas](https://pandas.pydata.org/)
2. [Scipy](https://www.scipy.org/)
3. [Bio](https://biopython.org/)

*[Anaconda](https://www.anaconda.com/download) makes downloading the python modules easy*, you can install necessary environment from `pypresent.yml` file.

Setup
---------
1. Clone repository locally.
2. Download NetMHCpan and NetMHCIIpan, install them by following software README, run test to check if they work (`gawk` is required).
3. Update paths for NetMHCpan, NetMHCIIpan and a temporary directory in the config.py file.
4. Download python modules.
5. Run example_usage.ipynb. The scores should be as follows:
	* HLA-A01:01 - 0.25
	* DRB1_1114 - 46.0
	* Patient MHCI - 1.810..
	* Patient MHCII - 5.379..

Inputs needed for scores
------
### Single-Allelic Score (Best Rank)
* MHC-I/MHC-II allele
* Mutation information:
	* Gene sequence - *string or fasta file*
	* Residue position
	* New amino acid

### Multi-Allellic Score (PHBR)
* All MHC-I/MHC-II alleles
* Mutation information:
	* Gene sequence
	* Residue position
	* New amino acid

Test examples
------
See example_usage.ipynb

Contact
------
ramarty [at] ucsd.edu

Citation
------

[Marty, Rachel, et al. "MHC-I genotype restricts the oncogenic mutational landscape." Cell 171.6 (2017): 1272-1283.] (https://www.cell.com/cell/fulltext/S0092-8674(17)31144-3)

repository: XSLiuLab/pypresent

repo_name: XSLiuLab/pypresent


text:
For the duration, these tentacles turn the ground in the area into difficult terrain.

When a creature enters the affected area for the first time on a turn or starts its turn there, the creature must succeed on a Dexterity saving throw or take 3d6 bludgeoning damage and be restrained by the tentacles until the spell ends. A creature that starts its turn in the area and is already restrained by the tentacles takes 3d6 bludgeoning damage.

A creature restrained by the tentacles can use its action to make a Strength or Dexterity check (its choice) against your spell save DC. On a success, it frees itself.

repository: lester-lee/dnd

repo_name: lester-lee/dnd


text:
This directory contains some scripts for running performance tests for IANS, such as for evaluating video performance.

Video Streaming
-----------

	video/*
        eval/video_over_time.R     Plot video representation, buffer level, throughput rate, etc over time
        eval/stallings.R           Plot stalling count, median/mean/max duration
        eval/representations.R     Plot representations during video playout
        eval/dump_json.py          From logged data with stallings, compute P.1203 QoE
        eval/plot_qoe.R            Plot QoE data computed by dump_json.py as barplot
        eval/heatmap_video.R       Plot QoE data as heatmap
        eval/show_best_worst.R     Output the video loads with the best and the worst MOS
        eval/data_during_load.R    Analyze and plot distributions of certain MAM network characteristics, such as download rate, during video load

Running experiments
-----------

	video/
		run.sh              Run a single experiment
        stream_video.sh     Start streaming one or multiple videos given in a URL file (run as part of run.sh)
        load_stuff.sh       Fake audio data to be loaded


text:
# print is flat, code is deep: the importance of media-specific analysis

## n. katherine hayles

---

Expanding textuality beyond printed page likely retains fascism of semiotics, eliding differences in media. What is speicific about code?

*materiality is reconceptualized as the interplay between a text's physical characteristics and its signifying strategies, a move that entwines instantiation and signification at the outset*. material embodiments interact dynamically with linguistic, rhetorical and literary practices to create the effects we call literature.

materiality = physical property + conceptual contents + signifying strategies + interpretive activities of readers and writers. materiality should be understood as existing in complex dynamic interplay with content, coming into focus or fading into the background, depending on what performances the work enacts.

can we also imagine that languages specs and documentation **are code-specific materiality**?

electronic texts:
1. are dynamic images
2. include both analog resemblance and digital coding
3. are generated through fragmentation and recombination
4. have depth and operate in 3D
5. are written in code as well as natural languages
6. are mutable and transformable
7. are spaces to navigate
8. are written and read in *distributed cognitive environments*
9. initiate and demand cyborg reading practices

bolter and grusin say in remediation that every media encapsulates the other, but is that true for programming languages? aren't they both forward and backward?

how do medium-specific constraints and possibilities shape texts?

from the discreeteness of alphabetic writing to the analogue of word and pattern recognition

*books also create rich cognitive environments, but they passively embody the cognitions of writer, reader and book designer, rather than actively participate in cognition themselves*

- rita raley (2001)

repository: periode/thesis

repo_name: periode/thesis


text:
 Amazon ML Challenge 2021

 Final Solution of Team DeVaSh.Ai (First Runners-Up)

![](assets/Flowchart.png)

### Solution Presentation video can be found here: [Link](https://www.twitch.tv/videos/1107585685?t=4h18m36s)
### Presentation link: Presentation

## Team Members
1. [Varun Yerram](https://github.com/Varun221)
2. [Debarshi Chanda](https://github.com/DebarshiChanda)
3. [Aishik Rakshit](https://github.com/aishik-rakshit)
4. [Shreya Sajal](https://github.com/shreyasajal)


text:
[![Unit 🧪 `template.ipynb`](https://github.com/dfm/tess-atlas/workflows/Unit%20%F0%9F%A7%AA%20%60template.ipynb%60/badge.svg)](https://github.com/dfm/tess-atlas/actions?query=workflow%3A%22Unit+%F0%9F%A7%AA+%60template.ipynb%60%22)
[![end-to-end 🧪 `template.ipynb`](https://github.com/dfm/tess-atlas/workflows/end-to-end%20%F0%9F%A7%AA%20%60template.ipynb%60/badge.svg)](https://github.com/dfm/tess-atlas/actions?query=workflow%3A%22end-to-end+%F0%9F%A7%AA+%60template.ipynb%60%22)

  TESS Atlas

## Installation instructions
To intall the necessary packages, run
```bash
pip install -r requirements.txt
```

## Instructions to update TESS Atlas
1. Create and analyse some TOIs with the following: `make run`
2. Commit the completed TOIs to a branch and make a PR to main
3. Once PR to main completed, run `make website` to convert the notebooks to HTML and upload to the gh-pages branch and deploy to github-pages

## Run one notebook
To run the analysis for one notebook, you can run
```bash
python tess_atlas/run_toi.py <toi id number>
```
where an example `<toi id number> = 724`

To run all the notebooks, you can run
```bash
python tess_atlas/run_tois.py
```

## Run tests on template.ipynb
```bash
pytest tests/
```

repository: athulvis/tess-atlas

repo_name: athulvis/tess-atlas


text:
Translating by Ping

How to switch from NetworkManager to systemd-networkd on Linux
================================================================================
In the world of Linux, adoption of [systemd][1] has been a subject of heated controversy, and the debate between its proponents and critics is still going on. As of today, most major Linux distributions have adopted systemd as a default init system.

Billed as a "never finished, never complete, but tracking progress of technology" by its author, systemd is not just the init daemon, but is designed as a more broad system and service management platform which encompasses the growing ecosystem of core system daemons, libraries and utilities.

One of many additions to **systemd** is **systemd-networkd**, which is responsible for network configuration within the systemd ecosystem. Using systemd-networkd, you can configure basic DHCP/static IP networking for network devices. It can also configure virtual networking features such as bridges, tunnels or VLANs. Wireless networking is not directly handled by systemd-networkd, but you can use wpa_supplicant service to configure wireless adapters, and then hook it up with **systemd-networkd**.

On many Linux distributions, NetworkManager has been and is still used as a default network configuration manager. Compared to NetworkManager, **systemd-networkd** is still under active development, and missing features. For example, it does not have NetworkManager's intelligence to keep your computer connected across various interfaces at all times. It does not provide ifup/ifdown hooks for advanced scripting. Yet, systemd-networkd is integrated well with the rest of systemd components (e.g., **resolved** for DNS, **timesyncd** for NTP, udevd for naming), and the role of **systemd-networkd** may only grow over time in the systemd environment.

If you are happy with the way **systemd** is evolving, one thing you can consider is to switch from NetworkManager to systemd-networkd. If you are feverishly against systemd, and perfectly happy with NetworkManager or [basic network service][2], that is totally cool.

But for those of you who want to try out systemd-networkd, you can read on, and find out in this tutorial how to switch from NetworkManager to systemd-networkd on Linux.

### Requirement ###

systemd-networkd is available in systemd version 210 and higher. Thus distributions like Debian 8 "Jessie" (systemd 215), Fedora 21 (systemd 217), Ubuntu 15.04 (systemd 219) or later are compatible with systemd-networkd.

For other distributions, check the version of your systemd before proceeding.

    $ systemctl --version

### Switch from Network Manager to Systemd-Networkd ###

It is relatively straightforward to switch from Network Manager to systemd-networkd (and vice versa).

First, disable Network Manager service, and enable systemd-networkd as follows.

    $ sudo systemctl disable NetworkManager
    $ sudo systemctl enable systemd-networkd

You also need to enable **systemd-resolved** service, which is used by systemd-networkd for network name resolution. This service implements a caching DNS server.

    $ sudo systemctl enable systemd-resolved
    $ sudo systemctl start systemd-resolved

Once started, **systemd-resolved** will create its own resolv.conf somewhere under /run/systemd directory. However, it is a common practise to store DNS resolver information in /etc/resolv.conf, and many applications still rely on /etc/resolv.conf. Thus for compatibility reason, create a symlink to /etc/resolv.conf as follows.

    $ sudo rm /etc/resolv.conf
    $ sudo ln -s /run/systemd/resolve/resolv.conf /etc/resolv.conf

### Configure Network Connections with Systemd-networkd ###

To configure network devices with systemd-networkd, you must specify configuration information in text files with .network extension. These network configuration files are then stored and loaded from /etc/systemd/network. When there are multiple files, systemd-networkd loads and processes them one by one in lexical order.

Let's start by creating a folder /etc/systemd/network.

    $ sudo mkdir /etc/systemd/network

#### DHCP Networking ####

Let's configure DHCP networking first. For this, create the following configuration file. The name of a file can be arbitrary, but remember that files are processed in lexical order.

    $ sudo vi /etc/systemd/network/20-dhcp.network

----------

    [Match]
    Name=enp3*

    [Network]
    DHCP=yes

As you can see above, each network configuration file contains one or more "sections" with each section preceded by [XXX] heading. Each section contains one or more key/value pairs. The [Match] section determine which network device(s) are configured by this configuration file. For example, this file matches any network interface whose name starts with ens3 (e.g., enp3s0, enp3s1, enp3s2, etc). For matched interface(s), it then applies DHCP network configuration specified under [Network] section.

### Static IP Networking ###

If you want to assign a static IP address to a network interface, create the following configuration file.

    $ sudo vi /etc/systemd/network/10-static-enp3s0.network

----------

    [Match]
    Name=enp3s0

    [Network]
    Address=<IP_ADDRESS>/24
    Gateway=<IP_ADDRESS>
    DNS=<IP_ADDRESS>

As you can guess, the interface enp3s0 will be assigned an address <IP_ADDRESS>/24, a default gateway <IP_ADDRESS>, and a DNS server <IP_ADDRESS>. One subtlety here is that the name of an interface enp3s0, in facts, matches the pattern rule defined in the earlier DHCP configuration as well. However, since the file "10-static-enp3s0.network" is processed before "20-dhcp.network" according to lexical order, the static configuration takes priority over DHCP configuration in case of enp3s0 interface.

Once you are done with creating configuration files, restart systemd-networkd service or reboot.

    $ sudo systemctl restart systemd-networkd

Check the status of the service by running:

    $ systemctl status systemd-networkd
    $ systemctl status systemd-resolved

![](https://farm1.staticflickr.com/719/21010813392_76abe123ed_c.jpg)

### Configure Virtual Network Devices with Systemd-networkd ###

**systemd-networkd** also allows you to configure virtual network devices such as bridges, VLANs, tunnel, VXLAN, bonding, etc. You must configure these virtual devices in files with .netdev extension.

Here I'll show how to configure a bridge interface.

#### Linux Bridge ####

If you want to create a Linux bridge (br0) and add a physical interface (eth1) to the bridge, create the following configuration.

    $ sudo vi /etc/systemd/network/bridge-br0.netdev

----------

    [NetDev]
    Name=br0
    Kind=bridge

Then configure the bridge interface br0 and the slave interface eth1 using .network files as follows.

    $ sudo vi /etc/systemd/network/bridge-br0-slave.network

----------

    [Match]
    Name=eth1

    [Network]
    Bridge=br0

----------

    $ sudo vi /etc/systemd/network/bridge-br0.network

----------

    [Match]
    Name=br0

    [Network]
    Address=<IP_ADDRESS>/24
    Gateway=<IP_ADDRESS>
    DNS=<IP_ADDRESS>

Finally, restart systemd-networkd:

    $ sudo systemctl restart systemd-networkd

You can use [brctl tool][3] to verify that a bridge br0 has been created.

### Summary ###

When systemd promises to be a system manager for Linux, it is no wonder something like systemd-networkd came into being to manage network configurations. At this stage, however, systemd-networkd seems more suitable for a server environment where network configurations are relatively stable. For desktop/laptop environments which involve various transient wired/wireless interfaces, NetworkManager may still be a preferred choice.

For those who want to check out more on systemd-networkd, refer to the official [man page][4] for a complete list of supported sections and keys.

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

via: http://xmodulo.com/switch-from-networkmanager-to-systemd-networkd.html

作者：[Dan Nanni][a]
译者：[译者ID](https://github.com/译者ID)
校对：[校对者ID](https://github.com/校对者ID)

本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出

[a]:http://xmodulo.com/author/nanni
[1]:http://xmodulo.com/use-systemd-system-administration-debian.html
[2]:http://xmodulo.com/disable-network-manager-linux.html
[3]:http://xmodulo.com/how-to-configure-linux-bridge-interface.html
[4]:http://www.freedesktop.org/software/systemd/man/systemd.network.html

url: https://raw.githubusercontent.com/zky001/TranslateProject/b9da878d21f1e98557754e4626aee2e01e8b8798/sources/tech/20150831 How to switch from NetworkManager to systemd-networkd on Linux.md


text:
---
layout: page
title: Render Controllers
parent: Concepts
---

# Render Controllers

<details id="toc" open markdown="block">
  <summary>
    Table of contents
  </summary>
  {: .text-delta }
1.  But you don't need to be afraid! You should think of render-controllers as logic packs that take `short-name` definitions from the RP Entity File, and determine how they will be combined/layered/rendered in-game.

# Defining short-names

Render controllers work based on the short-name definitions of the RP entity file. Short-names are local identifiers, which we define in the RP entity file, and can then use in the render controller (and other places!). Variables such as `geometry`, `materials`, and `textures` can be defined in the entity,

Lets look at a simplified version of the spider RP entity file:

{% include filepath.html path="RP/entity/spider.json" %}
```json
{
    "format_version": "1.8.0",
    "minecraft:client_entity": {
        "description": {
            "identifier": "minecraft:cave_spider",
            "materials": {
                "default": "spider",
                "invisible": "spider_invisible"
            },
            "textures": {
                "default": "textures/entity/spider/cave_spider"
            },
            "geometry": {
                "default": "geometry.spider.v1.8"
            },
            "render_controllers": [
                "controller.render.spider"
            ]
        }
    }
}
```

In this case, four short-name definitions have been created:
 - `default`, in the materials array
 - `invisible`, in the materials array
 - `default`, in the textures array
 - `default`, in the geometry array

You can define multiple short-names in each array, such as in the `materials` example above.

You should think of short-name definitions as `importing` the assets you want. At this state, you are defining the textures, geometry, and materials that you want to use in your entity. In the render-controller stage, you won't import anything. You will simply use the assets you already imported to create the rendered entity.

# Simple render-controller

A simple render controller looks like this:

{% include filepath.html path="RP/render_controllers/cow.render.json" %}
```json
{
    "format_version": "1.8.0",
    "render_controllers": {
        "controller.render.cow": {
            "geometry": "Geometry.default",
            "materials": [
                {
                    "*": "Material.default"
                }
            ],
            "textures": [
                "Texture.default"
            ]
        }
    }
}
```

This controller is taking the short-name definitions from the entity file, and `rendering` them. For example the line: `"textures": [ "Texture.default"]` says: "Take the default texture, and apply it to the entity". The render controller doesn't know what the default texture is, it simply applies it.

# Re-using render controllers

Since render controllers work based on short-names, it is possible to re-use the same render controller for all of your entities. For simple entities with one material, one texture, and one geometry, custom render controllers are not necessary.

For example, the render controller above is used for the `minecraft:cow` entity. If you want to use this render controller in your own pack, simple define like: `"render_controllers": [ "controller.render.cow" ]` in your entity file.

`warning:` Remember! Render controllers work based on short-names. If you want to use the cow render controller, you need to provide the short-names it is using. In this case, you will need to provide:
 - `default` geometry
 - `default` texture
 - `default` material

# Creating custom render controllers

 Often we want more power over the rendering of our entities, such as rendering layered textures, multiple geometries, or applying different materials to different bones. To create a custom render controller, simply copy and paste a vanilla render controller into the `render_controllers` folder, and edit to your liking!

# Texture layering

 Layering textures is currently written as a wiki article here: [Texture Layering](/tutorials/texture-layering).

repository: JustMrDevilGH/bedrock-wiki

branch_name: refs/heads/gh-pages

repo_name: JustMrDevilGH/bedrock-wiki


text:
# GoHub

[![Github Release](https://img.shields.io/github/release/direct-connect/go-dcpp.svg)](https://github.com/direct-connect/go-dcpp/releases)

Direct Connect hub implementation for ADC and NMDC protocols (and beyond).

Requires Go 1.12+.

**Features:**

- Fully multi-threaded.
- Support NMDC, ADC and IRC users on the same hub.
- Uses a single port for all protocols (protocol auto-detection).
- Search and chat between NMDC and ADC.
- Supports TLS for ADC (`adcs://`) and NMDC (`nmdcs://`).
- Automatic TLS certificate generation.
- HTTP(S) pinger support.
- User registration, profiles and operators.
- User commands.
- Chat rooms.
- Go plugins.
- LUA scripts.
- PtokaX LUA scripts support.
- Flood filters.

**TODO:**

- Spam filters.
- Get certificates from LetsEncrypt.

You may also need to install [Git](https://git-scm.com/download/win).

To build the hub binary, run:

```bash
go build .\cmd\go-hub
```

### Running the hub

First, run the hub configuration:

```
./go-hub init
```

This will create a file called `hub.yml` with the default configuration.

To create a user with admin permissions:
```
./go-hub user add "Bob" "MyPass" root
```

To run the hub:

```
./go-hub serve
```

Check help for additional commands and flags:

```
./go-hub -h
```

### Profiling

To enable performance profiling:

```
./go-hub serve --pprof
```

A profiling endpoint will be available at http://localhost:6060/debug/pprof.

See [pprof](https://golang.org/pkg/net/http/pprof/) documentation for more details.

### License

BSD 3-Clause License

repository: RoLex/go-dcpp

repo_name: RoLex/go-dcpp


text:
# Movie Store Simulator

## Project Information

Authors: [Bill Zhao](https://github.com/iambillzhao),
         [Lucas Bradley](https://github.com/LucasBradley01)

## Project Description

The files in this repository are the submissions of Assignment 4: Movies
of CSS 343 at the UW. This project was pair programmed by
[Bill Zhao](https://github.com/iambillzhao) and
[Lucas Bradley](https://github.com/LucasBradley01) in March 2020.

This project fully utilizes the benefits of polymorphism and factory patterns
of Object-oriented programming. In which, each functionality at different
levels are being factored into smaller classes for changeability and
simplicity.

This movie rental store simulator allows customers to easily add genres, types
of media, and additional movies to the existing program. Currently, "borrow",
"return", "inventory", and "history" are being implemented as the core
functionality and more could be added with additional classes.

## Project Checklist

Development Platform: Microsoft Windows

Tested on Linux Lab: YES!

Tested on Travis CI: YES!

Fixed clang-tidy messages: YES!

Fixed valgrind messages: YES!

## Command Functionality Checklist

Inventory: Fully implemented!

History: Fully implemented!

Borrow: Fully implemented!

Return: Fully implemented!

## Location of error message or functionality

State the file and function where the information can be found

invalid command code: The request besides the allowed functions will be denied

invalid movie type: The movie will not be created and the program will continue
                    to operate under the original state

invalid customer ID: The customer will not be created and such customer-related
                     functions cannot be used, all access denied

invalid movie: The movie that are duplicate, or with missing information cannot
               be created and all related functions are automatically ignored
               until all information are gathered.

factory classes: defined in ``factory.cpp``.
<br> 'F' stands for comedy, 'C' stands for classic, 'D' stands for drama.

hashtable: hashtable is the container for all movies, with a string as its
           value and a movie pointer to the corresponding movie

container used for comedy movies: comedy movies are stored in the hashtable
                                  with its unique identifier f.

function for sorting comedy movies: defined in ``transaction.cpp``.

function where comedy movies are sorted: sorting elements are defined in
``comedy.cpp``.

functions called when retrieving a comedy movie based on title and year:
the function ``std::string Comedy::sortingElement()`` will be called to
identify the order of comedy movies and retrieve the movie according to
the given title and year.

functions called for retrieving and printing customer history:
``void printHistory() const`` in ``customer.cpp``.

container used for customer history: a vector of all transactions.

functions called when borrowing a movie: depending on the genre, it will call
                                         the borrow function in the
                                         corresponding class.

explain borrowing a movie that does not exist: the corresponding request will
                                               be denied and the transaction
                                               is failed because it can not be
                                               found in the store inventory.

explain borrowing a movie that has 0 stock: the corresponding request will be
                                            denied and the transaction is
                                            failed because there is no more
                                            movies to borrow.

explain returning a movie that customer has not checked out: the corresponding
                                                             request will be
                                                             accepted and the
                                                             transaction is
                                                             recorded because
                                                             the movie could be
                                                             returned by a
                                                             friend of the
                                                             original borrower.

any static_cast or dynamic_cast: most functions are inherited and none are
                                 casted currently

repository: iambillzhao/Movie-Store

repo_name: iambillzhao/Movie-Store