text:
# Episodes Updater

[![Open Source Love](https://badges.frapsoft.com/os/v1/open-source.svg?v=103)](https://github.com/ellerbrock/open-source-badges/)
[![HitCount](http://hits.dwyl.com/cannibalcheeseburger/automation-cli.svg)](http://hits.dwyl.com/cannibalcheeseburger/automation-cli)
[![MIT Licence](https://badges.frapsoft.com/os/mit/mit.svg?v=103)](https://opensource.org/licenses/mit-license.php)

It is a web scraper designed to give the list of latest episodes of choice based on content from imdb.com.

Added SQLite support . We now use SQLite instead to pandas with CSVs. Pretty good update in my opnion though the jury's still out.

Would really like someone to make a ui cuz its ugly.

## Installation
---
To install dependencies:

```
python -m pip install -r --user requirements.txt
```
To run:

```
python main.py
```

##  Overview
---
### 1. Main Menu
 - Select one of the options of your choice

### 2. Adding new series to you choice list
 - Enter name of the series you want to add
   - A brief plot of story will appear
   - Answer with Y(YES)/N(NO)/NEXT(LITERALLY NEXT) if it wasn't what you had in mind
 - Enter the season of series you want to stalk
 - Again y/n if you want to add another series to list

### 3. Display the list
 - Pretty straight forward

### 4. Update the dates of airing of latest episodes of series
 - Again, couldn't be more straight forward

## APIs
---
Most of the work was done by webscraping but i found these APIs that helped a lot https://github.com/alberanid/imdbpy.

repository: cannibalcheeseburger/EpisodesUpdates

repo_name: cannibalcheeseburger/EpisodesUpdates


text:
---
layout: default
---

# 1997-11-04 - Re: S/MIME

## Header Data

From<EMAIL_ADDRESS>(Anonymous)

To<EMAIL_ADDRESS>Message Hash: de1916c1da929d2a1790cb215d59b0ef87d286e28b5850f4a823653277a9eb94

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1997-11-04 21:14:29 UTC

Raw Date: Wed, 5 Nov 1997 05:14:29 +0800

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Anonymous)
Date: Wed, 5 Nov 1997 05:14:29 +0800
To<EMAIL_ADDRESS>Subject: Re: S/MIME
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

William H. Geiger III wrote:
> >>There is an old saying in the Security Field: "Poor Security is worse
> >>than no security at all".

>    at 11:24 AM, Ian Clysdale<EMAIL_ADDRESS>said:
>
> >   Sorry, I'm going to continue to take a viewpoint that I suspect is
> >rather unpopular in this list, and argue for the advantages of weak
> >crypto in certain circumstances

> This is nothing but selfserving bullshit in a vain effort to justify YOUR
> sellout for a paycheck.

Nortel is nothing more than a Canadian schill for the SnoopSpooks.

Just as the INSLAW Thieves & Murderers used Indian Reservations in an
attempt to pretend that they weren't breaking US law because their
actions were taking place on the soil of a Soverign Nation, the US
criminals use the same bullshit logic to circumvent the laws that
apply to their illegal actions.

It is no coincidence that Nortel is the nesting place of a wide
variety of censorship vermin such as Chris Lewis, and his ilk.
An analysis of a number of employees of Nortel and their bum
buddies shows that the time spent in their output of UseNet
cancels and FUD posts and emails corresponds to the hours of
a corporate work schedule.

Nortel is nothing more than a front for the SnoopSpooks who
want to capitalize on Canada's image as a Soverign Country
to push their backdoor products in the global community.
These are the same lame fuckers who pulled off this act
in Switzerland, with governments and corporations buying
security products from a country noted for its neutrality,
and then finding out later that it was a front for a
German company that had the CIA's nose up their butt.

It amazes me that corporations and governments put their trust
in any company with the word 'Security' in its name, without
doing a check on their backgrounds and connections that is
at least as intensive as they would do for a new employee.

{% endraw %}
```

## Thread

+ Return to [November 1997](/archive/1997/11)

+ Return to<EMAIL_ADDRESS>(Anonymous)](/authors/nobody_at_replay_com_anonymous_)"

+ 1997-11-04 (Wed, 5 Nov 1997 05:14:29 +0800) - Re: S/MIME -<EMAIL_ADDRESS>(Anonymous)_

license: MIT

branch_name: refs/heads/master

extension: md

gha_license_id: MIT

license_type: permissive


text:
# Change Log

## [v1.11.0](https://github.com/sensu/sensu-extensions/tree/v1.11.0) (2019-01-22)
[Full Changelog](https://github.com/sensu/sensu-extensions/compare/v1.10.0...v1.11.0)

**Merged pull requests:**

- Add sensu-extensions-deregistration handler [\#21](https://github.com/sensu/sensu-extensions/pull/21) ([amdprophet](https://github.com/amdprophet))

## [v1.10.0](https://github.com/sensu/sensu-extensions/tree/v1.10.0) (2018-08-10)
[Full Changelog](https://github.com/sensu/sensu-extensions/compare/v1.9.1...v1.10.0)

**Merged pull requests:**

- Include check dependencies 1.1.0 [\#20](https://github.com/sensu/sensu-extensions/pull/20) ([portertech](https://github.com/portertech))

## [v1.9.1](https://github.com/sensu/sensu-extensions/tree/v1.9.1) (2018-03-07)
[Full Changelog](https://github.com/sensu/sensu-extensions/compare/v1.9.0...v1.9.1)

**Merged pull requests:**

- Sign the sensu-extensions Ruby gem [\#18](https://github.com/sensu/sensu-extensions/pull/18) ([portertech](https://github.com/portertech))
- Implement automated changelog generation [\#17](https://github.com/sensu/sensu-extensions/pull/17) ([cwjohnston](https://github.com/cwjohnston))

## [v1.9.0](https://github.com/sensu/sensu-extensions/tree/v1.9.0) (2017-03-22)
[Full Changelog](https://github.com/sensu/sensu-extensions/compare/v1.8.0...v1.9.0)

**Merged pull requests:**

- Use occurrences 1.2.0 \(action flapping\) [\#16](https://github.com/sensu/sensu-extensions/pull/16) ([portertech](https://github.com/portertech))

## [v1.8.0](https://github.com/sensu/sensu-extensions/tree/v1.8.0) (2017-03-20)
[Full Changelog](https://github.com/sensu/sensu-extensions/compare/v1.7.1...v1.8.0)

**Merged pull requests:**

- Add ruby 2.4.0 to .travis.yml [\#15](https://github.com/sensu/sensu-extensions/pull/15) ([amdprophet](https://github.com/amdprophet))
- add check\_dependencies filter to core extensions [\#14](https://github.com/sensu/sensu-extensions/pull/14) ([cwjohnston](https://github.com/cwjohnston))

## [v1.7.1](https://github.com/sensu/sensu-extensions/tree/v1.7.1) (2016-09-12)
[Full Changelog](https://github.com/sensu/sensu-extensions/compare/v1.7.0...v1.7.1)

**Merged pull requests:**

- Only include necessary gem files [\#13](https://github.com/sensu/sensu-extensions/pull/13) ([amdprophet](https://github.com/amdprophet))

## [v1.7.0](https://github.com/sensu/sensu-extensions/tree/v1.7.0) (2016-08-22)
[Full Changelog](https://github.com/sensu/sensu-extensions/compare/v1.6.0...v1.7.0)

## [v1.6.0](https://github.com/sensu/sensu-extensions/tree/v1.6.0) (2016-07-28)
[Full Changelog](https://github.com/sensu/sensu-extensions/compare/v1.5.0...v1.6.0)

**Merged pull requests:**

- Support loading extensions from gems [\#12](https://github.com/sensu/sensu-extensions/pull/12) ([portertech](https://github.com/portertech))
- Add built-in occurrences filter extension [\#11](https://github.com/sensu/sensu-extensions/pull/11) ([portertech](https://github.com/portertech))

## [v1.5.0](https://github.com/sensu/sensu-extensions/tree/v1.5.0) (2016-03-22)
[Full Changelog](https://github.com/sensu/sensu-extensions/compare/v1.4.0...v1.5.0)

## [v1.4.0](https://github.com/sensu/sensu-extensions/tree/v1.4.0) (2015-11-03)
[Full Changelog](https://github.com/sensu/sensu-extensions/compare/v1.3.0...v1.4.0)

**Merged pull requests:**

- Support extension aliases [\#8](https://github.com/sensu/sensu-extensions/pull/8) ([portertech](https://github.com/portertech))

## [v1.3.0](https://github.com/sensu/sensu-extensions/tree/v1.3.0) (2015-09-16)
[Full Changelog](https://github.com/sensu/sensu-extensions/compare/v1.2.0...v1.3.0)

**Merged pull requests:**

- Removed sensu-em as a dependency, let Sensu core determine which eventmachine is used [\#7](https://github.com/sensu/sensu-extensions/pull/7) ([portertech](https://github.com/portertech))

## [v1.2.0](https://github.com/sensu/sensu-extensions/tree/v1.2.0) (2015-03-13)
[Full Changelog](https://github.com/sensu/sensu-extensions/compare/v1.1.0...v1.2.0)

**Merged pull requests:**

- Load extensions from symlinked directories [\#4](https://github.com/sensu/sensu-extensions/pull/4) ([portertech](https://github.com/portertech))
- Removed built-in attributes filter, part of core [\#3](https://github.com/sensu/sensu-extensions/pull/3) ([portertech](https://github.com/portertech))

## [v1.1.0](https://github.com/sensu/sensu-extensions/tree/v1.1.0) (2014-12-03)
[Full Changelog](https://github.com/sensu/sensu-extensions/compare/v1.0.0...v1.1.0)

**Merged pull requests:**

- move built-in filters into extensions [\#2](https://github.com/sensu/sensu-extensions/pull/2) ([portertech](https://github.com/portertech))

## [v1.0.0](https://github.com/sensu/sensu-extensions/tree/v1.0.0) (2014-06-12)
[Full Changelog](https://github.com/sensu/sensu-extensions/compare/v0.0.5...v1.0.0)

## [v0.0.5](https://github.com/sensu/sensu-extensions/tree/v0.0.5) (2014-05-27)
[Full Changelog](https://github.com/sensu/sensu-extensions/compare/v0.0.4...v0.0.5)

## [v0.0.4](https://github.com/sensu/sensu-extensions/tree/v0.0.4) (2014-05-25)
[Full Changelog](https://github.com/sensu/sensu-extensions/compare/v0.0.2...v0.0.4)

## [v0.0.2](https://github.com/sensu/sensu-extensions/tree/v0.0.2) (2014-05-23)
[Full Changelog](https://github.com/sensu/sensu-extensions/compare/v0.0.1...v0.0.2)

## [v0.0.1](https://github.com/sensu/sensu-extensions/tree/v0.0.1) (2014-05-22)

\* *This Change Log was automatically generated by [github_changelog_generator](https://github.com/skywinder/Github-Changelog-Generator)*


text:
# Destructuring Arrays

You can destructure arrays, tuples, and slices by matching on their elements:

```rust,editable
{{#include ../../third_party/rust-by-example/destructuring-arrays.rs}}
```

<details>

* Destructuring of slices of unknown length also works with patterns of fixed length.

     ```rust,editable
     fn main() {
         inspect(&[0, -2, 3]);
         inspect(&[0, -2, 3, 4]);
     }

     #[rustfmt::skip]
     fn inspect(slice: &[i32]) {
         println!("Tell me about {slice:?}");
         match slice {
             &[0, y, z] => println!("First is 0, y = {y}, and z = {z}"),
             &[1, ..]   => println!("First is 1 and the rest were ignored"),
             _          => println!("All elements were ignored"),
         }
     }
     ```

* Create a new pattern using `_` to represent an element.
* Add more values to the array.
* Point out that how `..` will expand to account for different number of elements.
* Show matching against the tail with patterns `[.., b]` and `[a@..,b]`

</details>

repository: google/comprehensive-rust

branch_name: refs/heads/main

gha_language: Rust

repo_name: google/comprehensive-rust


text:
CStruct-Packing-raku
===============

[![Build Status](https://travis-ci.org/pdf-raku/CStruct-Packing-raku.svg?branch=master)](https://travis-ci.org/pdf-raku/CStruct-Packing-raku)

## Description

CStruct::Packing is a simple solution for structured reading
and writing of CStructs as binary numerical data.

The module is an alternative to Native::Packing. It requires all structures
to be native CStructs, but can be signficantly faster.

## Example

```
use v6;
use CStruct::Packing :Endian;

# open a GIF read the header
my class LogicalDescriptor
    is repr('CStruct')
    does CStruct::Packing[VaxEndian] {

    has uint16 $.width;
    has uint16 $.height;
    has uint8  $.flags;
    has uint8  $.bgColorIndex;
    has uint8  $.aspect;
}

my $fh = "t/lightbulb.gif".IO.open( :r, :bin);
my $offset = 6;  # skip GIF header

my LogicalDescriptor $screen .= read: $fh, :$offset;
say "GIF has size {$screen.width} X {$screen.height}";
```

It currently handles records containing native integers (`int8`, `uint8`, `int16`, etc),
numerics (`num32`, `num64`) and inlined CStruct sub-records.

- Data may read be and written to binary files, via the `read` and `write` methods

-  Or read and written to buffers via the `unpack` and `pack` methods.

### Endianess

The two fixed modes are:

- VaxEndian (or LittleEndian) - least significant byte written first

- NetworkEndian (or BigEndian) - most significant byte written first

There is also a platform-dependant `HostEndian` mode. This will read
and write binary data in the same endianess as the host computer.

Endian Examples:

```
use CStruct::Packing :Endian;

class C is repr('CStruct') { has int16 $.a }
class C-vax  is repr('CStruct') is C does CStruct::Packing[VaxEndian] {}
class C-net  is repr('CStruct') is C does CStruct::Packing[NetworkEndian] {}
class C-host is repr('CStruct') is C does CStruct::Packing[HostEndian] {}

say C-vax.new(:a(42)).pack;    # Buf[uint8]:0x<2a 00>
say C-net.new(:a(42)).pack;    # Buf[uint8]:0x<00 2a>
say C-host.new(:a(42)).pack;   # Depends on your host

```

## Methods

### pack

    method pack(Any:D: Blob $buf?, :$layout --> Blob)

Returns a packed representation of the CStruct as a Blob.

### unpack

    method unpack(Blob:D $buf, :$layout --> Any:D)

Unpacks the buffer. If this method is called from an object, the object's
contents are replaced. Otherwise a new object is returned.

### read

    method read(IO::Handle \fh, UInt :$offset, :$layout -> Any:D)

Utility method to read and unpack a structure from a file handle.

### write

    method read(IO::Handle \fh, UInt :$offset, :$layout)

Uitility method to pack and write a structure to a file handle.

### packing-layout

    method packing-layout(--> CArray)

Precomputes the memory layout and endian conversionsfor a structure.

    my $layout = Rec.packing-layout; # precompute layout
    my @recs = 100 xx Rec.read($fh, :$layout);

### packed-size

    method packed-size(--> size_t)

Returns the size of the packed structure

### unpacked-size

    method unpacked-size(--> size_t)

Returns the size of the packed structure. S.unpacked-size should be equal
to nativesizeof(S).

repository: pdf-raku/CStruct-Packing-raku

repo_name: pdf-raku/CStruct-Packing-raku


text:
# CxxBuilder
This is an experimental repo for exploring how to upgrade Cxx.jl's building system to BinaryBuilder/BinaryProvider.

## Usage
Pre-built binaries can be found in the release page: https://github.com/Gnimuc/CxxBuilder/releases

### Build for Linux-x86_64
1. Download Julia-v1.1 binary: https://julialang-s3.julialang.org/bin/linux/x64/1.1/julia-1.1.0-linux-x86_64.tar.gz
2. Unzip downloaded tarball, create a directory called `JuliaBinary` and move unzipped contents into it
3. Download Julia-v1.1 source: https://github.com/JuliaLang/julia/releases/download/v1.1.0/julia-1.1.0.tar.gz
4. Unzip downloaded tarball, create a directory called `JuliaSource` and move unzipped contents into it
5. Download LLVM binary: https://github.com/staticfloat/LLVMBuilder/releases/download/v6.0.1-4%2Bnowasm/LLVM.v6.0.1.x86_64-linux-gnu-gcc7.tar.gz
6. Create a directory called `LLVM` and move downloaded tarball into it
7. Now, the file hierarchy should look like this:
```
CxxBuilder +
           | libcxxffi
           | patches
           | build_tarballs.jl
           | README.md
           + JuliaBinary +
                         | juliabin +
                                    | bin
                                    | etc
                                    | include
                                    | lib
                                    | ...
           + JuliaSource +
                         | julia +
                                 | base
                                 | contrib
                                 | deps
                                 | doc
                                 | etc
                                 | ...
           + LLVM +
                  | LLVM.v6.0.1.x86_64-linux-gnu-gcc7.tar.gz
```
8. Uncomment the line `# BinaryProvider.Linux(:x86_64; libc=:glibc, compiler_abi=CompilerABI(:gcc7)),` in `build_tarballs.jl`
9. Run `julia --color=yes build_tarballs.jl --verbose`
10. Find the binary in the `products` folder

### Build for MacOS
1. Download Julia-v1.1 binary: https://julialang-s3.julialang.org/bin/mac/x64/1.1/julia-1.1.0-mac64.dmg
2. Open the dmg image, right-click Julia-1.1.app, click `Show Package Contents`, copy `Contents/Resources/julia` to a new directory called `JuliaBinary`
3. Download Julia-v1.1 source: https://github.com/JuliaLang/julia/releases/download/v1.1.0/julia-1.1.0.tar.gz
4. Unzip downloaded tarball, create a directory called `JuliaSource` and move unzipped contents into it
5. Download LLVM binary: https://github.com/staticfloat/LLVMBuilder/releases/download/v6.0.1-4%2Bnowasm/LLVM.v6.0.1.x86_64-apple-darwin14-gcc7.tar.gz
6. Create a directory called `LLVM` and move downloaded tarball into it
7. Now, the file hierarchy should look like this:
```
CxxBuilder +
           | libcxxffi
           | patches
           | build_tarballs.jl
           | README.md
           + JuliaBinary +
                         | juliabin +
                                    | bin
                                    | etc
                                    | include
                                    | lib
                                    | ...
           + JuliaSource +
                         | julia +
                                 | base
                                 | contrib
                                 | deps
                                 | doc
                                 | etc
                                 | ...
           + LLVM +
                  | LLVM.v6.0.1.x86_64-apple-darwin14-gcc7.tar.gz
```
8. Uncomment the line `# BinaryProvider.MacOS(:x86_64; libc=:glibc, compiler_abi=CompilerABI(:gcc7)),` in `build_tarballs.jl`
9. Run `julia --color=yes build_tarballs.jl --verbose`
10. Find the binary in the `products` folder

repository: MaximeBouton/CxxBuilder

repo_name: MaximeBouton/CxxBuilder


text:
ChangeLog
=========

0.0.6 (2014-09-26)
------------------

* Added: `CData` element.
* #13: Better support for xml with no namespaces. (@kalmas)
* Switched to PSR-4 directory structure.

0.0.5 (2013-03-27)
------------------

* Added: baseUri property to the Writer class.
* Added: The writeElement method can now write complex elements.
* Added: Throwing exception when invalid objects are written.

0.0.4 (2013-03-14)
------------------

* Fixed: The KeyValue parser was skipping over elements when there was no
  whitespace between them.
* Fixed: Clearing libxml errors after parsing.
* Added: Support for CDATA.
* Added: Context properties.

0.0.3 (2013-02-22)
------------------

* Changed: Reader::parse returns an array with 1 level less depth.
* Added: A LibXMLException is now thrown if the XMLReader comes across an error.
* Fixed: Both the Elements and KeyValue parsers had severe issues with
  nesting.
* Fixed: The reader now detects when the end of the document is hit before it
  should (because we're still parsing an element).

0.0.2 (2013-02-17)
------------------

* Added: Elements parser.
* Added: KeyValue parser.
* Change: Reader::parseSubTree is now named parseInnerTree, and returns either
  a string (in case of a text-node), or an array (in case there were child
  elements).
* Added: Reader::parseCurrentElement is now public.

0.0.1 (2013-02-07)
------------------

* First alpha release

Project started: 2012-11-13

repository: Hywan/sabre-xml

repo_name: Hywan/sabre-xml


text:
# shadertoy-connector examples

<!-- MDTOC maxdepth:2 firsth1:0 numbering:0 flatten:0 bullets:1 updateOnSave:1 -->

- [Mathematica](#Mathematica)
- [Octave](#Octave)

<!-- /MDTOC -->

## Mathematica

If you followed the installation instructions, the Shadertoy package will be in
the user package load path, so it can be loaded directly from any session.

```mathematica
(* Load the Shadertoy package *)
<< Shadertoy`

(* Render a specific frame of a Shadertoy, with given inputs *)
Manipulate[
	RenderShadertoy["llySRh", Frame -> n, Mouse -> {x, y}],
		{n, 0, 10, 1}, {x, 0, 640}, {y, 0, 360}]

(* Compile some GLSL source and render it *)
shaderId = CompileShadertoy["void mainImage(out vec4 O, in vec2 U){O = vec4(sin(iTime*.1), cos(iTime*.1), length(U/iResolution.xy));}"];
RenderShadertoy[shaderId, Format -> "Luminance"]
```

Note that loading the package multiple times will terminate previous linked
processes and start them again, therefore clearing any state held by the various
contexts.

## Octave

The default install target for Octave puts `shadertoy_octave.oct` in the load
path.

```matlab
% Tell octave to autoload the functions from the .oct file
shadertoy_octave();

% Render a shadertoy as a matrix
img = st_render('llySRh');

% Show it
% Note that Octave does not support RGBA images, thus we only feed RGB to imshow
imshow(img(:,:,1:3));

% Grayscale render, next frame
img = st_render('llySRh', -1, -1, -1, 'Luminance');
```

repository: vtavernier/shadertoy-connector

repo_name: vtavernier/shadertoy-connector


text:
## Usage

The goal for this library is to enable command-line arguments to affect the parsed typesafe config.

## Running

e.g., you just write your application against a 'Config' instead of 'Array\[String\]', and then run it like this:

```bash
  java -cp myApp.jar my.App foo.x=bar /app/config/filesystem-config.conf classpathConfig.conf
```

## In Code

The 'MyApp' would then just use the args4c.implicits (or extend a ConfigApp) to be able to get the configuration:

```scala
  import args4c.implicits._

  object MyApp {
     override def main(args : Array[String]) : Unit = {
       val config = args.asConfig()
       println("Starting MyApp with config:")

       // let's "log" our app's config on startup:
       val summary : String = config.withPaths("myapp").summary()
       println(summary)

       startMyApplication(config)
     }

     def startMyApplication(conf : Config) = ...
  }
```

This shows how 'args.asConfig()' can get a configuration from the user arguments, and then use a 'summary' to produce a sensible, flat config summary
with sensitive entries obscured, as well as a source comment for some sanity as to where each entry comes from:

```bash
myapp.foo : bar # command-line
myapp.password : **** obscured **** # command-line
myapp.saveTo : afile # file:/opt/etc/myapp/test.conf@3
```

## Sensitive (Encrypted) Configurations

args4c also provides a 'args4c.ConfigApp' trait which provides some additional functionality to configuration-based
applications:

```scala
object MyApp extends args4c.ConfigApp with StrictLogging {

  override def run(config : Config) : Unit = {
     logger.info(s"Running with ${config.withPaths("myapp").summary()}")
      ...
  }
}
```

## Setting up sensitive config entries

Aside from brining in the implicit configurations, it adds argument parsing support to run your application with "--setup" in so sensitive configuration
settings can be supplied by the user using standard input.

The user will be prompted to indicate where the encrypted config should be created (and with what permissions), followed by prompts
for configuration entries:

```bash
> java -cp app.jar MyApp --setup
Save secure config to (.config/secret.conf):
Config Permissions (rwx------):
Add config path in the form <key>=<value> (leave blank when finished):example.password1=sEcr3t
Add config path in the form <key>=<value> (leave blank when finished):example.config.entry.key=password
Add config path in the form <key>=<value> (leave blank when finished):
Config Password:myapp
```

or, you can supply the default config location via e.g. the --secure=path/to/password.conf argument:

```bash
> java -cp app.jar MyApp --setup --secure=path/to/secret.conf
Save secure config to (path/to/secret.conf):
...
```

## Running with an encrypted config

Then, to run the application with this config taken into account, launch it with the '--secure=path/to/your/secret.conf'
(or just --secure to have it look in the default location). The application will then prompt for a config password from standard input.

```bash
> java -cp app.jar MyApp --secure=path/to/secret.conf -other.settings=true uat.conf
Config Password:_
```
or

```bash
> java -cp app.jar MyApp --secure
Config Password:_
```

Note: The --secure argument is in addition to any other configuration params:

```bash
> java -cp app.jar MyApp --secure -show=foo.bar foo.x=true uat.conf
Config Password:_
```

To avoid having to provide the password from standard input you can:
 * set the 'CONFIG_SECRET' environment variable
 * set the 'CONFIG_SECRET' system property to the JVM
 * override the 'readConfigPassword' function in your application

(I'm not recommending you expose your passwords via system properties or env variables -- the option's just there if you need it)

```bash
> java -DCONFIG_SECRET=confPassword -cp app.jar MyApp --secure show=foo
foo.bar : some value # reference.conf
> export CONFIG_SECRET=confPassword
> java -cp app.jar MyApp --secure show=foo
foo.bar : some value # reference.conf
```

gha_language: Scala


text:
# rusty_screeps

A very hacky and not-at-all good set of fooling around with [Screeps][screeps], a Javascript
MMO Game but in Rust. This project is built using the [`screeps-game-api`] bindings from the
[rustyscreeps] organization.

It's also recommended to use [`cargo-screeps`] for uploading the code, but the code should still
compile if using [`cargo-web`] directly instead.

Quickstart:

```bash
# clone:

git clone https://github.com/toddaaro/rusty_screeps
cd rusty_screeps

# cli dependencies:

cargo install cargo-screeps

# configure for uploading:

cp screeps-no-token.toml screeps.toml
nano screeps.toml

# release new version
./release 1.0.0 "we made it to 1.0.0!"

# build tool:

cargo screeps --help
```

[screeps]: https://screeps.com/
[`stdweb`]: https://github.com/koute/stdweb
[`cargo-web`]: https://github.com/koute/cargo-web
[`cargo-screeps`]: https://github.com/rustyscreeps/cargo-screeps/
[`screeps-game-api`]: https://github.com/rustyscreeps/screeps-game-api/
[rustyscreeps]: https://github.com/rustyscreeps/


text:
# Balls :basketball:f War
[![GitHub License](https://img.shields.io/github/license/liam-mack/Balls-of-War)](https://opensource.org/licenses/MIT)

## Description
A MERN stack two player online card game with a NBA twist. Using Create-React-App, our app features four teams (Lakers, Rockets, Heat and Raptors) with 18 players each from the 2020 season. Users have the option of choosing one of the eight stats(height, weight, field goal percentage, assist, rebounds, turnovers and personal fouls) to pit against the competition. The website is equipped with user functionality to create accounts, remember individual games and record match histories. Game state modifications occur server-side and saved in MongoDB. Future deployment in the works are as follows:
* Incorporating websockets
* Create your own player and increase your stats out of game with fitbit
* Add all teams and other stats
* Various game modes such as draft, regular and playoff seasons
* Add game balances and penalties
* Introduce coach, home/away, shotclock and fatigue variables
* Port to React-Native and add offline functionality
* Many more!

### Business Context
Due to the ongoing pandemic, the NBA season have been interrupted and social gatherings restricted which meant no basketball for months. Seeing as current basketball games on the market are expensive and also take time to develop, we wanted to create a simple, but fun interactive basketball related game that could be played with a friend. The inspiration for the game came from the childhood favourite card game WAR.

### User Stories
>AS an avid basketball fan

>I WANT a simple sports themed online card game

>SO THAT I can enjoy basketball and maintain social distancing during quarantine.

### Acceptance Criteria
>GIVEN a choice of decks WHEN I select a deck from the database THEN I am matched with an opponent

>GIVEN it is my turn
WHEN I select the top card
THEN I can choose a stat and play it

>GIVEN cards are in play
WHEN the turn is won
THEN the winner collects those cards

>GIVEN a player loses their turn
WHEN they have no more cards to play
THEN the winner is declared

More details can be found in our [proposal](https://docs.google.com/document/d/1BwLD8_vT9-0C1iab5XI0ZbSI9mZ77FO8_oEqO5aeio4/edit)

## Table of Contents
* [Installation](#Installation)
* [Usage](#Usage)
  * [Deployed](#Deployed)
  * [Signup](#Signup)
  * [Teams](#Teams)
  * [Play](#Play)
* [Technologies](#Technologies)
* [Authors](#Authors)
* [License](#License)
* [Contributing](#Contributing)
* [Questions](#Questions)

## Installation
Download or clone the repo to a working directory and extract its contents. Use a **C**ommand **L**ine **I**nterface to install necessary dependencies by running the following command:
```
npm i
```
## Usage
Type the following in any CLI to run the app.
```
npm start
```
### Deployed
![Deployed](images/Deployed.png)

### Signup
![Signup](images/Signup.gif)

### Teams
![Teams](images/Teams.gif)

### Play
![Play](images/Play.gif)

## Technologies
* [Express](https://expressjs.com/)
* [Express-Session](https://github.com/expressjs/session)
* [MySQL](https://www.mysql.com/)
* [Sequelize](https://sequelize.org/)
* [MongoDB](https://www.mongodb.com/)
* [Mongoose](https://mongoosejs.com/)
* [React](https://reactjs.org/)
* [React Router](https://reactrouter.com/)
* [Node](https://nodejs.org/en/)
* [Sass](https://github.com/sass/node-sass)
* [Passport](http://www.passportjs.org/)
* [bcryptjs](https://github.com/dcodeIO/bcrypt.js#readme)
* [Travis CI](https://travis-ci.com/)
* [ESlint](https://eslint.org/)
* [Bootstrap](https://getbootstrap.com/)
* [Fontawesome](https://fontawesome.com/)
* [Basketball Reference](https://www.basketball-reference.com/)

## Authors
[Liam Mackinnon](https://github.com/liam-mack), [Shamik Haldar](https://github.com/shamik05), [Mohammed-Yasir Suara](https://github.com/mohammedyasirsuara)

## License
This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details
## Contributing
Message any of the authors or open a pull request. See [CONTRIBUTING.md](CONTRIBUTING.md)
## Questions
Contact any of the [authors](#Authors)

repository: liam-mack/Balls-of-War

gha_language: JavaScript

repo_name: liam-mack/Balls-of-War


text:
# StickyViewPagerGridHeaders
StickyGridView + ViewPager + Header

StickyViewPagerGridHeaders is useful for Sticky GridView within ViewPager in fragment .Look like ViewPager with Headerview.
With use of library [StickyGridHeaders][1]

[![Android Arsenal](https://img.shields.io/badge/Android%20Arsenal-StickyViewPagerGridHeaders-green.svg?style=true)](https://android-arsenal.com/details/1/4362)

## Screenshot

![1](https://raw.githubusercontent.com/pchauhan/StickyViewPagerGridHeaders/master/Screenshots/ScreenOne.png)![2](https://raw.githubusercontent.com/pchauhan/StickyViewPagerGridHeaders/master/Screenshots/Screenhalfscroll.png)![3](https://raw.githubusercontent.com/pchauhan/StickyViewPagerGridHeaders/master/Screenshots/Screenfullscroll.png)

you can download to see example  for more understanding.

##Compatibility

 - Android 4.0+

##License
The MIT License (MIT)

Copyright (c) 2015 Parag Chauhan

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.

 [1]: https://github.com/TonicArtos/StickyGridHeaders


text:
# ToC

<!-- vim-markdown-toc GFM -->

* [{{cookiecutter.project_name}}](#cookiecutterproject_name)
    * [Installing / Getting started](#installing--getting-started)
    * [Developing](#developing)
        * [Built With](#built-with)
        * [Development commands](#development-commands)
            * [Dev-Server](#dev-server)
            * [Type-Checker (Flow)](#type-checker-flow)
                * [Required module not found](#required-module-not-found)
            * [Linters](#linters)
            * [Testing](#testing)
        * [Building](#building)
        * [CI](#ci)
        * [Deploying / Publishing](#deploying--publishing)
    * [Versioning](#versioning)
    * [Configuration](#configuration)
    * [Tests](#tests)
    * [Style guide](#style-guide)
    * [Api Reference](#api-reference)
    * [Database](#database)

<!-- vim-markdown-toc -->

# {{cookiecutter.project_name}}
> {{cookiecutter.short_description}}

A brief description of your project, what it is used for.
Also add a version badge if possible

## Installing / Getting started

To install all project dependencies simply run

```shell
npm i
```

## Developing

### Built With

This project includes quite a few opinionated settings which where
made according to our own guidelines. Therefore this template includes:

* Webpack as module bundler, dev server and build tool
* Babel for ES6 and Flow transpilation
* Flow as type-checker
* Standard as JS linter
* StyleLint as scss/css linter
* CSS-Autoprefixing via postcss
* Jest as testing framework
* SVG-Sprite for automatic sprite/scss generation
* normalize.css as CSS-reset

### Development commands

#### Dev-Server

To start the development server run:

```shell
npm start
```

This will built the svg-sprite files and start an instance
of webpack-dev-server. From then on the whole project will
rebuild, run your JS files through the Flow type-checker and
lint you JS with standard and you scss/CSS with stylelint.

#### Type-Checker (Flow)

To separately type-check your JS-files, run:

```shell
npm run flow
```

##### Required module not found

To add third party library flow support use [flow-typed](https://github.com/flowtype/flow-typed).

If the library of your choice does not support flow, you can add a file
named after the module into the `flow-typed`-directory. The file should have
the following content in it:

```javascript
// myModule.js
declare module 'myModule' {
  declare module.exports: any
}
```

If a local module is not resolve you can add an option to
the `.flowconfig` like so:

```bash
[options]
module.system.node.resolve_dirname=src
```

#### Linters

To separately lint your JS-files, run:

```shell
npm run lint
```

or to autmatically fix issues if possible, run:

```shell
npm run lint:fix
```

To separately lint your stylesheets, run:

```shell
npm run stylelint
```

or to automatically fix issues if possible, run:

```shell
npm run stylelint:fix
```

#### Testing

Tests should usually live next to their base files and should
be named like: `<myBaseFile>.test.js`.

To run Jest an check if your tests pass invoke:

```shell
npm run test
```

This will also generate a coverage folder, containing information
about the projects test coverage.

To continuously run Jest and have Jest watch for changes, run:

```shell
npm run test:watch
```

### Building

To build the project, run:

```shell
npm run build
```

This will build your svg-sprite files, compile, minify and bundle
everything and put all packaged files into the _dist/_ directory (if there is no such directory it will just be newly created, an existing directory will be removed first).
To allow our clients browsers to cache vendor files and only update the cache when it is really necessary, all important filenames include hashes for reference inside the built manifest file.

### CI

This project already includes a default _.gitlab-ci.yml_.
Just confiure the file to your needs.

### Deploying / Publishing

give instructions on how to build and release a new version
In case there's some step you have to take that publishes this project to a
server, this is the right time to state it.

```shell
packagemanager deploy your-project -s server.com -u username -p password
```

And again you'd need to tell what the previous code actually does.

## Versioning

We can maybe use [SemVer](http://semver.org/) for versioning. For the versions available, see the [link to tags on this repository](/tags).

## Configuration

Here you should write what are all of the configurations a user can enter when
using the project.

## Tests

Describe and show how to run the tests with code examples.
Explain what these tests test and why.

```shell
Give an example
```

## Style guide

Explain your code style and show how to check it.

## Api Reference

If the api is external, link to api documentation. If not describe your api including authentication methods as well as explaining all the endpoints with their required parameters.

## Database

Explaining what database (and version) has been used. Provide download links.
Documents your database design and schemas, relations etc...


text:
Instructions for Thorlabs powermeters using _thorlabspowermeter.py_

- For Windows users:
  1. Using this script requires the PM10xx drivers from Thorlabs
    https://www.thorlabs.com/newgrouppage9.cfm?objectgroup_id=4037&pn=PM100USB
  2. Once the Thorlabs software has been downloaded veryify that you are using the "PM  100D (NI-VISA TM)" drivers.
    - Using the TLPM drivers does not let ResourceManager find the device. (Manually finding the device address and bypassing ResourceManager.list_resources also won't work)
    - Switch back to the TLPM drivers when using the Thorlabs Optical Power Meter software.
    - - Note: The help section of this software has a logfile for troubleshooting
    - Accomplish this step using the Power Meter Driver Switcher software located in '\PowerMeters\Tools\DriverSwitcher' of the program's installation directory
-For Unix users:
  - pyvisa used the option _"@py"_ hence no drivers should be needed to make it work. It works also with ARM based devices, such as raspberry pi computers

repository: gregmoille/InstrumentControl

gha_language: Python

repo_name: gregmoille/InstrumentControl


text:
---
_id: 5a88e1abbd6dca0d5f0d1f68
title: "How to Receive SMS Messages with ASP.NET MVC Framework"
url: 'https://www.nexmo.com/blog/2017/03/31/recieve-sms-messages-with-asp-net-mvc-framework-dr/'
category: libraries-tools
slug: 'how-to-receive-sms-messages-with-asp-net-mvc-framework'
user_id: 5a83ce59d6eb0005c4ecda2c
username: 'bill-s'
createdOn: '2017-03-31T21:21:28.000Z'
tags: [asp.net-mvc,sms]
---

My previous tutorial explained how to use the Nexmo C# Client Library to send your first SMS message from an ASP.NET MVC web app. In this follow-up, I continue exploring the Nexmo Platform by showing how to receive SMS messages on a Nexmo phone number using the C# Client Library.

repository: dotnetweekly/dnw-gatsby

repo_name: dotnetweekly/dnw-gatsby


text:
---
title: talk-plugin-moderator-actions
permalink: /plugin/talk-plugin-moderator-actions/
layout: plugin
plugin:
    name: talk-plugin-moderator-actions
    default: true
    provides:
        - Client
---

Enables in-stream moderation so that Moderators can reject, approve comments,
as well as ban users, directly from the comment stream. When
[talk-plugin-featured-comments](/talk/plugin/talk-plugin-featured-comments) is
enabled, it will also give the User's an option to feature from the stream.

repository: ign/talk

gha_license_id: NOASSERTION

repo_name: ign/talk


text:
# Solid Editorial Session

Date: 2020-04-27

* Time: 13:00 CET (see your local time)
* Duration: 1 hour
* Call in Details: https://whereby.com/solid-project
* Moderator: csarven
* Attendees: justinwb (editor), csarven (editor), ericprud
* Summary:

## Organizing the Specification Work

* Variability in Specs: https://github.com/solid/specification/issues/138
* Review initial outline (in master branch)
* Look at best way to provide status of work on various spec sections
* Use "topic based organization"

## Resource Metadata

* Relating to https://github.com/solid/specification/pull/156
* Determine appropriate way to refer to section as a whole
* Metadata considered too broad of a term
* Consider renaming to Auxillary Resources
* Move specific metadata types into their own sections

repository: solid/specification

gha_language: HTML

repo_name: solid/specification


text:
# clientapi
Allows for access to the menchnet fpga cluster for computer vision
applications.

Outline of usage:

1. Create a module in python for your computer vision sensor:

Example: sensor1.py

#### Code to be uploaded and executed on the menchnet cloud

```python
# import libraries here, imports are restricted by a whitelist
# you can not access io or other system operations, the code
# is executed within a docker container running alpine and running
# as an unprivilaged user.
import torch

"""
ssapi is the server side api for menchnet it allows for the module
to register to events to listen to and to publish analytics based on
those events. You can even listen to events from other modules you
uploaded so that a composition of multiple asynchronously running modules
can be aggregated.
"""

def onStartup(ssapi):
    # configuration given by menchnet.activate
    config = ssapi.getConfig()
    # ...
    # perform global setup here

    # generate stapshot events every 2.0 seconds using the
    # video source specified by url
    ssapi.generator(ssapi.evt.SNAPSHOTS, url=config['url'], format="jpg", interval="2.0")

def onEvent(ssapi, evt):
    if evt.name == ssapi.evt.SNAPSHOTS:
        data = evt.getData()
        # jpg image to do some computation on
        # ...
        # send a confidence value
        ssapi.publish("score", some_value)
```

2. Upload the module to your account at menchnet

```python
import menchnet

# initialization
menchnet.login(username, api-key)
# upload a module, we give it the arbitrary name
# sensor1 the same as the module name but it can be
# anything you want.
menchnet.upload("sensor1", "/path/to/sensor1.py")
```

3. Use the module you uploaded

```python
# activation/listen/deactivation
menchnet.login(username, api-key)
def callback(some_value):
    # get the result from ssapi.publish("score", some_value)
    pass
# inside sensor1.py the ssapi.publish will append the event
# name score to the name of module so
#   menchnet.upload("sensor1", ...)
#   and ssapi.publish("score", data)
#   results in a data being published to the sensor1.score topic
#   this is pub/sub so any number of clients can listen for the same
#   event.
menchnet.listen("sensor1.score", callback)

# results in onStartup being called and passing in the keyword arguments
# of this function, which in this case is url="..."
# after calling this a daemon is running on menchnet which will
# connect to the url using and start taking snapshots, the onStartup
menchnet.activate("sensor1", url="...")

...

menchnet.deactivate("sensor1")
```

4. Remove the module

```python

import menchnet
menchnet.login(username, api-key)
menchnet.remove("sensor1")
```

repository: menchnet/clientapi

repo_name: menchnet/clientapi


text:
[![Contributors][contributors-shield]][contributors-url]
[![Forks][forks-shield]][forks-url]
[![Stargazers][stars-shield]][stars-url]
[![Issues][issues-shield]][issues-url]
[![MIT License][license-shield]][license-url]
[![LinkedIn][linkedin-shield]][linkedin-url]

podman on macOS LAB

    An Quick lab to use podman on macOS!

    Explore the docs »

    Report Bug
    ·
    Request Feature

  Table of Contents

      About The Project

Built With

      Getting Started

Prerequisites

Installation

Usage

Roadmap

Contributing

License

Contact

## 📘 About The Project

This project is just a lab to be able to use [podman](https://podman.io/) in an easy way working over a macOS

### 🛠 Built With

The project in strongly based on these following tools:

  * [Vagrant](https://www.vagrantup.com)
  * [ansible](https://www.ansible.com/)
  * [Fedora](https://getfedora.org/)

## 🛫 Getting Started

This is an example of how you may give instructions on setting up your project locally.
To get a local copy up and running follow these simple example steps.

### Prerequisites

To work with this project you need to have installed [Vagrant](https://vagrantup.com) an its default provider, as you might know this is [VirtualBox](https://www.virtualbox.org/)

### Installation

  1. Install the software pre-requisites
  2. Clone the repo
     ```shell
     git clone https://github.com/jjuarez/podman-on-macos.git
     ```

## 🔌 Usage

The example of use for this lab is extremely easy, just run the Virtual Machine
  ```shell
  vagrant up
  ```
### Configuration & Customization

All the configuraiton in this project is located at the podman role, you can override the variables as you whish

## 🏘 Roadmap

See the [open issues](https://github.com/jjuarez/podman-on-macos/issues) for a list of proposed features (and known issues).

## 🥼Contributing

Contributions are what make the open source community such an amazing place to be learn, inspire, and create. Any contributions you make are **greatly appreciated**.

  1. Fork the Project
  2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
  3.  Push to the Branch (`git push origin feature/AmazingFeature`)
  5. Open a Pull Request

## 🔖 License

Distributed under the MIT License. See [`LICENSE`](./LICENSE.txt) for more information.

## ✉ Contact

Your Name - [@thejtoken](https://twitter.com/thejtoken) -<EMAIL_ADDRESS>Project Link: [https://github.com/jjuarez/podman-on-macos](https://github.com/jjuarez/podman-on-macos)

[contributors-shield]: https://img.shields.io/github/contributors/jjuarez/podman-on-macos.svg?style=for-the-badge
[contributors-url]: https://github.com/jjuarez/podman-on-macos/graphs/contributors
[forks-shield]: https://img.shields.io/github/forks/jjuarez/podman-on-macos.svg?style=for-the-badge
[forks-url]: https://github.com/jjuarez/podman-on-macos/network/members
[stars-shield]: https://img.shields.io/github/stars/jjuarez/podman-on-macos.svg?style=for-the-badge
[stars-url]: https://github.com/jjuarez/podman-on-macos/stargazers
[issues-shield]: https://img.shields.io/github/issues/jjuarez/podman-on-macos.svg?style=for-the-badge
[issues-url]: https://github.com/jjuarez/podman-on-macos/issues
[license-shield]: https://img.shields.io/github/license/jjuarez/vagrant-ansible.lab.svg?style=for-the-badge
[license-url]: https://github.com/jjuarez/podman-on-macos/blob/master/LICENSE.txt
[linkedin-shield]: https://img.shields.io/badge/-LinkedIn-black.svg?style=for-the-badge&logo=linkedin&colorB=555
[linkedin-url]: https://www.linkedin.com/in/javierjuarez/
[product-screenshot]: docs/images/screenshot.png

repository: jjuarez/podman-on-macos

repo_name: jjuarez/podman-on-macos


text:
---
layout: post
title: "3D Scanning"
categories: performingavatars
---

I scanned Lin and Lin scanned me and it took us several tries to get a decent scan.
<iframe width="560" height="315" src="https://www.youtube.com/embed/eoiyo_hXuAY?rel=0" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen></iframe>

Even in my final scan, you can see that the carpet has fused inbetween my legs and one of the arms is a bit messy.
![alt text](/images/performingavatars/week2/itseez3d.png)

repository: jirrian/itp-blog

repo_name: jirrian/itp-blog


text:
---
layout: post
title:  "Starting Out"
date:   2016-05-09 08:21:54 -0700
---
In order to decide what kind of blog I wanted to make, I turned to some of my favorite blogs:

1. [Wait But Why](http://waitbutwhy.com/)
1. [colah.github.io](http://colah.github.io)
1. [What If?](https://what-if.xkcd.com/)

They all share a common theme.
The author has learned something and creates a post to share
that knowledge.

In Wait But Why, Tim Urban describes his process [like this](http://waitbutwhy.com/2015/06/how-tesla-will-change-your-life.html):

> The way I approach a post like that is I’ll start with the surface of the topic and ask myself what I don’t fully get—I look for those foggy spots in the story where when someone mentions it or it comes up in an article I’m reading, my mind kind of glazes over with a combination of “ugh it’s that icky term again nah go away” and “ew the adults are saying that adult thing again and I’m seven so I don’t actually understand what they’re talking about.” Then I’ll get reading about those foggy spots—but as I clear away fog from the surface, I often find more fog underneath. So then I research that new fog, and again, often come across other fog even further down. My perfectionism kicks in and I end up refusing to stop going down the rabbit hole until I hit the floor.

I love reading his posts because he does two things.  First, he thinks hard about what he doesn't get, even if it seems like something so obvious, everyone should already know about it.  Second, he digs and digs until he's gotten
to the basic principles at the "floor".  Reading his posts, I benefit
from his hard work. Not only that, but I get a basis to confront and contextualize new information about a topic.  (He refers
  to it as his "tree trunk" where he can hang new information later on in the
  post linked above.)  I feel like I am coming away with something valuable after
  spending time reading one of his posts.

Christopher Olah has a similar approach.  In the introduction to his post on [information theory](http://colah.github.io/posts/2015-09-Visual-Information/), he says:

> Unfortunately, information theory can seem kind of intimidating. I don’t think there’s any reason it should be. In fact, many core ideas can be explained completely visually!

He proceeds to break down this seemingly daunting area in a way that can only
be done by someone who gets the concepts at a fundamental level. By the end of the post,
 I am comfortable enough with the foundation of the topic that I could hold
 my own in a conversation about it.  I feel ready to add more to my foundation
 because it's been explained in such an accessible way.  Another thing that's
 great about his posts is that I know I can refer back to them.  For instance,
the concept of "mutual information" came up at work, and I knew immediately where I should
go for a refresher.

In ["What If?"](https://what-if.xkcd.com), Randall Munroe takes absurd hypothetical
question and answers them scientifically.  I love the way he takes ridiculous questions and breaks them down into small enough pieces that they fit into our understanding of the world.  He finds some footing to gain traction
 into the problem and explain it in terms of something more familiar.  When most
 people would say, "That's ridiculous, we'll never know", he keeps coming at the
 problem again and again until it starts to make sense.

What I like about all of these blogs is that they provide value to their readers
by being persistent with breaking down complicated topics into digestible chunks.
They get to the bottom of a topic, take a step back, and bring it back together.
They also take very little as a "given". Instead they construct building
blocks and the build up an understanding.

I want to take a similar approach to my blog.  I want break topics down to their
 first principles and build back up to an enriching understanding.
I want to take no knowledge for granted. I want a reader to come away knowing that
the topic has been thoroughly run down and feel confident about adding to their
understanding.

extension: markdown


text:
# The Bits and Bytes of Computer Networking

## About this Course
This course is designed to provide a full overview of computer networking. We’ll cover everything from the fundamentals of modern networking technologies and protocols to an overview of the cloud to practical applications and network troubleshooting.

# By the end of this course, you’ll be able to:
* Describe computer networks in terms of a five-layer model
* Understand all of the standard protocols involved with TCP/IP communications
* Grasp powerful network troubleshooting tools and techniques
* Learn network services like DNS and DHCP that help make computer networks run
* Understand cloud computing, everything as a service, and cloud storage

## SKILLS GAINED
* Domain Name System (DNS)
* Ipv4
* Network Model
* Troubleshooting

Instructor

## Google
The IT Support Professional Certificate program is part of Grow with Google, an initiative that draws on Google's 20-year history of building products, platforms, and services that help people and businesses grow. Through programs like these, we aim to help everyone– those who make up the workforce of today and the students who will drive the workforce of tomorrow – access the best of Google’s training and tools to grow their skills, careers, and businesses.

url: https://raw.githubusercontent.com/garynth41/Google-IT-Support-Professional-Certificate/b679d806f54c7a5ecbcfc5c58aa8413b1da0f69c/The Bits and Bytes of Computer Networking/readme.md


text:
# Immutable Interval Tree (Pre-alpha)

> This repository is still in development. Intervals can be inserted and queried, but there is still work to be done to remove nodes.

Changes to be made:

- Fix deletion
- Height should be 0 if no children, thinking depth
- Pass test(ish) cases from https://www.hackerrank.com/challenges/self-balancing-tree/forum

Similar to [davidisaaclee/interval-tree](https://github.com/davidisaaclee/interval-tree), I wanted an type-safe interval tree with immutable functional interface.

The primary motivations for this project was to be:

- Immutable (to store in Redux)
- Use Typescript
- Dependency free

## Install

```bash
# proposed
# npm install immutable-interval-tree
```

### Common usage patterns

- Add / remove a number of intervals

```typescript
const intervalsToAdd: IIntervalNode[] = []
const intervalsToRemove: string[] = []

let tree: IIntervalTree = IntervalTree.empty()

// insert intervals
tree = intervalsToAdd
    .reduce((tr, int) => IntervalTree.insert_node(tr, int), tree)

// remove intervals
tree = intervalsToRemove
    .reduce((tr, identifier) => IntervalTree.remove(tr, identifier), tree)
```

## Types

The primary types you must consider are:

```typescript
export interface IInterval {
    low: number;
    high: number;
}

/*
    Note that the IIntervalNode doesn't store children, this is stored on the IIntervalTree
*/
interface IIntervalNode extends IInterval {
    identifier: string;
    data?: any;
}

export interface IIntervalTree {
    index: { [identifier: string]: IIntervalNode };

    root: string | null;
    children: { [identifier: string]: IPotentialChildren };
}
```

## Other notes

- Based on the [Geeks for Geek guide](https://www.geeksforgeeks.org/interval-tree/).
- The repository was setup using: [Step by step: Building and publishing an NPM Typescript package.](https://itnext.io/step-by-step-building-and-publishing-an-npm-typescript-package-44fe7164964c)

repository: illusional/immutable-interval-tree

gha_language: TypeScript

repo_name: illusional/immutable-interval-tree


text:
---
title: "Functions in Go"
date: 2019-06-21T07:18:00Z
draft: false
author: "Simon Drake"

# post thumbnail
image: "/assets/images/post/functions_in_go.jpg"

# meta description
description: "Functions allow us to reduce duplication and increase maintainability. Learn how to write functions in Go, step by step!"

# taxonomies
# category: "beginner"
tags:
- beginner
- go

slug: "functions-in-go"

# post type
layout: post
---

At the end of the [Conditionals in Go](https://www.codetips.co.uk/languages/go/conditionals-in-go/) article, we ended with a programme that prints your `name`, `age`, `hobbies` and a statement based on the `age`.

```go
package main

import "log"

func main() {

  // Start of our code

	name := "Simon"
	age := 29
	hobbies := [4]string{"example1", "mountain biking", "example2", "example3"}

	log.Printf("Hello World. My name is %s.", name)

	if age < 13 {
		log.Println("I am considered a child")
	} else if age < 20 {
		log.Println("I am considered a teenager")
	} else if age < 70 {
		log.Println("I am considered an adult")
	} else {
		log.Println("I am considered a pensioner")
	}

	log.Printf("I have %d hobbies, and they are: ", len(hobbies))

	for i := 0; i < len(hobbies); i++ {
		log.Println(hobbies[i])
	}

	// End of our code

}

```

We're now going to add some "friends" and, for each of them, print the aged based statement depending on their ages.

We've already got the logic we need from the [Conditionals in Go](https://www.codetips.co.uk/languages/go/conditionals-in-go/) snippet above, so all we need to do is duplicate this for our friends.

```go
package main

import "log"

func main() {

	// Start of our code

	myName := "Simon"
	myAge := 29

	friendOneName := "David"
	friendOneAge := 17

	friendTwoName := "Bill"
	friendTwoAge := 42

	log.Printf("Hello World. My name is %s.", myName)

	if myAge < 13 {
		log.Println("I am considered a child")
	} else if myAge < 20 {
		log.Println("I am considered a teenager")
	} else if myAge < 70 {
		log.Println("I am considered an adult")
	} else {
		log.Println("I am considered a pensioner")
	}

	log.Println("I have two friends, and they are as follows:")

	log.Printf("%s: ", friendOneName)

	if friendOneAge < 13 {
		log.Println("I am considered a child")
	} else if friendOneAge < 20 {
		log.Println("I am considered a teenager")
	} else if friendOneAge < 70 {
		log.Println("I am considered an adult")
	} else {
		log.Println("I am considered a pensioner")
	}

	log.Printf("%s: ", friendTwoName)

	if friendTwoAge < 13 {
		log.Println("I am considered a child")
	} else if friendTwoAge < 20 {
		log.Println("I am considered a teenager")
	} else if friendTwoAge < 70 {
		log.Println("I am considered an adult")
	} else {
		log.Println("I am considered a pensioner")
	}

	// End of our code

}

```

Let's break down the changes we've made:

* We changed our `name` and `age` variables to `myName` and `myAge`, so there is a clear distinction between our information and our friends’ information.
* We added two friends (`friendOne` and `friendTwo`) and added their names/ages in separate variables.
* We added a new print statement to record how many friends we have.
* We log each friends name and run an `if/else if/else` statement to print out the appropriate aged based statement.

This might look OK, but duplicating code should be avoided wherever possible.

In the above code, we have three `if/else if/else` statements with the only difference being the variable being checked (`myAge`, `friendOneAge` or `friendTwoAge`).

What if we added one hundred friends, using this method, and then decided we wanted to add another age bracket in-between adult and pensioner?

We'd have to go through all of the `if/else if/else` statements, one by one, to add the new logic.

Thankfully we can use [functions](https://www.codetips.co.uk/beginner/what-is-a-function/) to cut down on all of this duplication.

The syntax for declaring a [function](https://www.codetips.co.uk/beginner/what-is-a-function/) in Go is simple. In fact, we’ve already done it for our programme - the `main` function:

```go
func main() {

}

```

Now let’s see a slightly more complex example; a function that takes two inputs, multiplies them, and prints the result.

```go
func multiply(num1 int, num2 int) {
	log.Println(num1 * num2)
}

```

Let’s break this down, one step at a time:

* We define a new function, using the `func` keyword, and name it `multiply`.
* We specify two parameters (`num1` and `num2`) and give them both a type of `int`.
* We declare our function body, which prints the result of `num1` multiplied (`*`) by `num2`.

Now we can use it as many times as possible!

```go
package main

import "log"

func multiply(num1 int, num2 int) {
	log.Println(num1 * num2)
}

func main() {

	multiply(5, 12)  // => 60
	multiply(51, 9)  // => 459
	multiply(12, 32) // => 384
	multiply(13, 42) // => 546
	multiply(31, 1)  // => 31
	multiply(21, 3)  // => 63
	multiply(30, 4)  // => 120
	multiply(19, 5)  // => 95
	multiply(9, 7)   // => 63

}

```

But sometimes we don’t just want to print to the screen. What if we want to use the result of `multiply` and divide it by 10?

For this we can use the `return` keyword, which does what it says; it returns the result.

```go
func multiply(num1 int, num2 int) int {
	return num1 * num2
}

```

We’ve now changed our function to return the result, instead of printing it to the screen.

You may have noticed we’ve also added an extra `int` in between the parameter declaration and function body. In the Go syntax, this is the return type and is required when returning a value from a function.

We specified it as `int` because two `int`’s multiplied (`num1 * num2`) yields an `int`.

Now we’re returning the result. If we want to use it, we need to assign it to a variable:

```go
package main

import "log"

func multiply(num1 int, num2 int) int {
	return num1 * num2
}

func main() {

	res1 := multiply(5, 12)
	log.Println(res1) // => 60
	res2 := multiply(51, 9)
	log.Println(res2) // => 459
	res3 := multiply(12, 32)
	log.Println(res3) // => 384
	res4 := multiply(13, 42)
	log.Println(res4) // => 546
	res5 := multiply(31, 1)
	log.Println(res5) // => 31
	res6 := multiply(21, 3)
	log.Println(res6) // => 63
	res7 := multiply(30, 4)
	log.Println(res7) // => 120
	res8 := multiply(19, 5)
	log.Println(res8) // => 95
	res9 := multiply(9, 7)
	log.Println(res9) // => 63

}

```

At the moment we’re only printing the result, but we can use the result in many different ways:

```go
package main

import "log"

func multiply(num1 int, num2 int) int {
	return num1 * num2
}

func main() {

	res1 := multiply(5, 12)
	log.Println(res1 * 10) // => 600
	res2 := multiply(51, 9)
	log.Println(res2 * res1) // => 27540
	res3 := multiply(12, 32)
	log.Println(res3 / 40) // => 9
	res4 := multiply(13, 42)
	log.Println(res4 / 10) // => 54
	res5 := multiply(31, 1)
	log.Println(res5 * 4) // => 124
	res6 := multiply(21, 3)
	log.Println(((res6 * 3) / 3) * 5) // => 315
	res7 := multiply(30, 4)
	log.Println(res7 / 2) // => 60
	res8 := multiply(19, 5)
	log.Println(res8 * 4) // => 380
	res9 := multiply(9, 7)
	log.Println(res9 / 9) // => 7

}

```

Now let’s use this new found wisdom to cut down on the duplication in our programme. Let’s go back and have a look at the code printing our friends:

```go
log.Printf("%s: ", friendOneName)

if friendOneAge < 13 {
	log.Println("I am considered a child")
} else if friendOneAge < 20 {
	log.Println("I am considered a teenager")
} else if friendOneAge < 70 {
	log.Println("I am considered an adult")
} else {
	log.Println("I am considered a pensioner")
}

log.Printf("%s: ", friendTwoName)

if friendTwoAge < 13 {
	log.Println("I am considered a child")
} else if friendTwoAge < 20 {
	log.Println("I am considered a teenager")
} else if friendTwoAge < 70 {
	log.Println("I am considered an adult")
} else {
	log.Println("I am considered a pensioner")
}

```

The code is exactly the same, other than the variable names (`friendOneName` , `friendOneAge`, `friendTwoName` and `friendTwoAge`). Let’s convert this into a function called `printAgeBracket`:

```go
func printAgeBracket(name string, age int) {
	log.Printf("%s: ", name)

	if age < 13 {
		log.Println("I am considered a child")
	} else if age < 20 {
		log.Println("I am considered a teenager")
	} else if age < 70 {
		log.Println("I am considered an adult")
	} else {
		log.Println("I am considered a pensioner")
	}
}

```

And now let’s use it in our code:

```go
package main

import "log"

func printAgeBracket(name string, age int) {
	log.Printf("%s: ", name)

	if age < 13 {
		log.Println("I am considered a child")
	} else if age < 20 {
		log.Println("I am considered a teenager")
	} else if age < 70 {
		log.Println("I am considered an adult")
	} else {
		log.Println("I am considered a pensioner")
	}
}

func main() {

	// Start of our code

	myName := "Simon"
	myAge := 29

	friendOneName := "David"
	friendOneAge := 17

	friendTwoName := "Bill"
	friendTwoAge := 42

	log.Printf("Hello World. My name is %s.", myName)

	if myAge < 13 {
		log.Println("I am considered a child")
	} else if myAge < 20 {
		log.Println("I am considered a teenager")
	} else if myAge < 70 {
		log.Println("I am considered an adult")
	} else {
		log.Println("I am considered a pensioner")
	}

	log.Println("I have two friends, and they are as follows:")

	printAgeBracket(friendOneName, friendOneAge)
	printAgeBracket(friendTwoName, friendTwoAge)

	// End of our code

}

```

Instead of all of that duplicated code, we’re calling our `printAgeBracket` function with the different variable names.

We can even add another three friends, without too much hassle:

```go
package main

import "log"

func printAgeBracket(name string, age int) {
	log.Printf("%s: ", name)

	if age < 13 {
		log.Println("I am considered a child")
	} else if age < 20 {
		log.Println("I am considered a teenager")
	} else if age < 70 {
		log.Println("I am considered an adult")
	} else {
		log.Println("I am considered a pensioner")
	}
}

func main() {

	// Start of our code

	myName := "Simon"
	myAge := 29

	friendOneName := "David"
	friendOneAge := 17

	friendTwoName := "Bill"
	friendTwoAge := 42

	friendThreeName := "Charlie"
	friendThreeAge := 12

	friendFourName := "Abby"
	friendFourAge := 24

	friendFiveName := "Edith"
	friendFiveAge := 74

	log.Printf("Hello World. My name is %s.", myName)

	if myAge < 13 {
		log.Println("I am considered a child")
	} else if myAge < 20 {
		log.Println("I am considered a teenager")
	} else if myAge < 70 {
		log.Println("I am considered an adult")
	} else {
		log.Println("I am considered a pensioner")
	}

	log.Println("I have five friends, and they are as follows:")

	printAgeBracket(friendOneName, friendOneAge)
	printAgeBracket(friendTwoName, friendTwoAge)
	printAgeBracket(friendThreeName, friendThreeAge)
	printAgeBracket(friendFourName, friendFourAge)
	printAgeBracket(friendFiveName, friendFiveAge)

	// End of our code

}

```

And now if we wanted to add another age bracket, all we have to do is amend our `printAgeBracket` function; that’s one place instead of however many friends we decided to add to our programme.

**Note:** Specifying our friends in this way (separate variables for `age` and `name`), is also not ideal. We’ll improve on this in a future article.

## Challenge

You’ve probably already realised that we didn’t convert the code related to our name (`myName`) and age (`myAge`) to use the `printAgeBracket` function.

That’s because we print something different with our name compared to our friends; “Hello World. My name is” instead of just the name.

See if you can update the `printAgeBracket` function to accept a `Boolean` parameter and conditionally print either statement depending on it.

If you need another hint, or want to show us your solution, [reach out to us](https://www.codetips.co.uk/contact-us/) and we’ll do what we can to help.


text:
---
layout: "sakuracloud"
page_title: "SakuraCloud: sakuracloud_packet_filter"
sidebar_current: "docs-sakuracloud-datasource-packet-filter"
description: |-
  Get information on a SakuraCloud Packet Filter.
---

# sakuracloud\_packet_filter

Use this data source to retrieve information about a SakuraCloud Packet Filter.

## Example Usage

```hcl
data "sakuracloud_packet_filter" "foobar" {
  name_selectors = ["foobar"]
}
```

## Argument Reference

 * `name_selectors` - (Optional) The list of names to filtering.
 * `filter` - (Optional) The map of filter key and value.
 * `zone` - (Optional) The ID of the zone.

## Attributes Reference

* `id` - The ID of the resource.
* `name` - The name of the resource.
* `expressions` - List of filter-expression. It contains some attributes to [Filter Expressions](#filter-expressions).
* `description` - The description of the resource.
* `zone` - The ID of the zone to which the resource belongs.

### Filter Expressions

Attributes for Filter Expressions:

* `protocol` - The target protocol.
* `source_nw` - The source network address (range).
* `source_port` - The source port (range).
* `dest_port` - The destination port (range).
* `allow` - The flag to allow packets. Default value is `true`.
* `description` - The description of the expression.


text:
# http4s.g8

A giter8 template for a hello world http4s service.

[![Build Status](https://travis-ci.org/bsamaripa/http4s.g8.svg?branch=master)](https://travis-ci.org/bsamaripa/http4s.g8)

## Usage

For sbt 0.13.13+, use the sbt new command.
```
sbt new bsamaripa/http4s.g8
```

This template can also be used by the giter8 client directly.
```
g8 bsamaripa/http4s.g8
```

## License
MIT


text:
# Bugsnag plugin for Craft CMS

Plugin that allows you to log errors/exceptions in Craft to Bugsnag.

## Installation

To install Bugsnag, follow these steps:

1. Download & unzip the file and place the `bugsnag` directory into your `craft/plugins` directory
2.  -OR- do a `git clone https://github.com/sjelfull/Craft-Bugsnag.git` directly into your `craft/plugins` folder.  You can then update it with `git pull`
3. Install plugin in the Craft Control Panel under Settings > Plugins
4. The plugin folder should be named `bugsnag` for Craft to see it.  GitHub recently started appending `-master` (the branch name) to the name of the folder for zip file downloads.

Bugsnag works on Craft 2.4.x and Craft 2.5.x.

## Bugsnag Overview

Bugsnag's cross platform error monitoring automatically detects crashes in your applications, letting you ship with confidence.

## Configuring Bugsnag

1. Copy  the bugsnag.php configuration file into your `craft/config` folder.
2. Update `serverApiKey` with a API key from your Bugsnag project.
2. (Optionally) Set the `environment` configuration setting to something. Defaults to `production`.

## Using Bugsnag

It will automatically log most exceptions/errors. If you want to log a exception/error from an custom plugin, you can use one of the two service methods:

- For exceptions: `craft()->bugsnag->notifyException($exception);`
- For errors: `craft()->bugsnag->notifyError($message);`

## Bugsnag Changelog

### 1.0.0 -- 2016.06.24

* Initial release

Brought to you by [Fred Carlsen](http://sjelfull.no)

repository: sjelfull/Craft-Bugsnag

repo_name: sjelfull/Craft-Bugsnag


text:
# Udacity Self-Driving Car Engineer Nanodegree
## Path Planning Project

## Infomation

The goal of this project was to implement a path planning algorithm that utilizes given way points and nearby vehicles (simulating sensor fusion).  The algorithm should enable the ego vehicle to drive around the track safely, in that the ego vehicle:

- Shall not collide with any other vehicle
- Shall not go off the track (3 far right lanes)
- Shall be able to overtake when the adjacent lane is free and the current lane has slower moving traffic
- Shall not exert any extreme accelerations or jerks in both lateral and longitudinal directions

### Algorithm

The algorithm includes several sub modules:

- Construct interpolated waypoints of nearby area  using spline interpolation
- Determine ego car parameters and construct vehicle object
- Generate predictions of each vehicles and determining the next possible states of the ego vehicle
- Calculating the cost of each potential next state and selecting the state with the lowest cost
- Creating and using the trajectory of the lowest state so that the ego vehicle proceeds in the allocated direction and speed

### State
State include keep line, change lane and currently changing line.We keep track of the state with two variables:
* *g_changing_lane* will be true if we have decided to change lane and go back to false when our change of lane is complete,
* *g_target_lane* will represent which lane the car will follow, which is useful to generate consistent trajectories.

### Trajectory
For car's trajectory, we need think about two thing: should it change and how it change. When we decide the action, we should create a *spline* to generate the car's trajetory. Through these action, we should follow these principles:
* At each step, we keep the last 10 time frames from previous calculated trajectory to ensure safety of our trajectory, which is equivalent to 0.2 sec.
* At the begin of decision, we alway calculate the other car to check those car is far away enough from our car.
* We use a *simple cubic spline interpolation library* to generate the car's trajetory
* The target trajectory and the target speed have a prediction over a total of 50 time frames (1 second).

### Speed
The speed should follow these principles:
* Can not over max speed limit(50mph).
* Through a checking function to decide speed up or slow down. We add up or slow the speed by limit acceleration in the function. The logic is below:
  * go through all related car from the sensor fusion.
  * calculate the related value of those cars.
  * if the line of the other car is in our line, we check if they are in front of us and close.
  * we check our car is still with in a safe distance at future.
  * if the case is yes, we speed up our car, or slow down.

### Lane changing
To change lane safely, we should follow these steps :
* Check the safety of the lines we can change to.
* Compare the other cars from fusion data with our car and calculate the line we are in, then calculate which line we can change to.
* The comparison used is deciding whether coincident may happen. If the coincidence is occurred, we can not change line.
* The state of change lane is continued action. We keep the state by a variable.

repository: wangminhang/CarND-Path-Planning-Project

repo_name: wangminhang/CarND-Path-Planning-Project


text:
# This is no longer maintenance
Nurevam is official shutdown.
Reason: [link](https://gist.github.com/Maverun/754ca37d731e5ed9706cf80e6ec03388)

# Nurevam
This is currenly the Alpha version.
I will update the public version of the bot regularly on this site.
This is the version, that can be run on any server.

In need of a FAQ,
[please check here](http://nurevam.site/faq)

Credit goes to [Cookie](https://github.com/cookkkie/mee6).
The website is based on his website, but heavily edited.
The level system is similar, yet homemade code.

repository: Maverun/Nurevam

repo_name: Maverun/Nurevam


text:
# entintar

This is a small tool to colorize and filter the verbose output of Maven or other unreadable text output.

## The name?

'entintar' is Spanish and AKFAIK means something like ink or colorize. Colorizer was already used.

## Usage

```
Usage: node ./bin/entintar [options]

Options:
  --encoding, -e  character-set of stdin input                 [default: "utf8"]
  --logfile       path/name of file where stdin is written to  [default: null]
  --color         colorize output (--no-color to disable)      [default: true]
  --rules         name of rule-set or path to rules.js         [default: "maven3"]
  --debug         output for easier debugging                  [default: false]
  --help, -h      show help and exit
```
## Installation

In most cases it makes only sense to install entintar globally:

    npm install entintar -g

## Example Output

![example output](https://github.com/hgoebl/entintar/blob/master/maven-colored.png?raw=true)

## Use with maven

You could use entintar by placing the filter after each call to `mvn`. Example:

    mvn clean install -Pgf-redeploy | entintar

Of course this is cumbersome. You better find a way to alias your mvn command and let your shell append the call
to the filter.

### Linux

Place following lines in your ~/.bashrc:

```bash
mvn_colored() {
    $MAVEN_HOME/bin/mvn $* | entintar
    # $MAVEN_HOME/bin/mvn $* | entintar --logfile mvn.log
}
alias mvn=mvn_colored
```

If you want to run the maven command w/out coloring, then run

    "mvn" ...

This will ignore the bash alias and directly run the mvn command.

### Darwin

**TODO** I don't have a Mac. @Apple, can you sponsor a MacBook to me, please? (Still waiting for an answer...)

### Cygwin

**TODO** My Windows7 node installation (0.6.18) doesn't work in Cygwin. Probably some cygpath calls could solve the problem.

### Windows

Out-of-the-box Windows lacks the support for `alias` like in bash.
You have to fiddle around with DOSKEY, PowerShell and the like. Please tell me if you found a solution!

Some probably helpful Links:

  * <http://superuser.com/questions/150244/command-aliases-in-dos>
  * <http://www.uberullu.com/alias-in-windows-command-line-ms-dos-how-to/>

## Extend

You can easily extend this tool by providing a rules.js (see lib/rules/maven3.js for an example).
If placed in the same directory, you can select the rules with the command line option --rules and the name
w/out '.js'.
It is also possible to place a rules file elsewhere and provide the full path to this file.

## TODO

  * Write a real test (not just invoke the program)

## License

MIT (see LICENSE file)

## See also

Similar Tools:
  * <http://linux.die.net/man/1/ccze>

Converting ANSI Colors to HTML:
  * <http://www.pixelbeat.org/scripts/ansi2html.sh>
  * <http://ziz.delphigl.com/tool_aha.php>

repository: hgoebl/entintar

repo_name: hgoebl/entintar


text:
# Bulls-and-Cows-Game
This is my first ever python code. This code lets you play the "Bulls and Cows" game for a number of upto 3 digits.

## Game Rules.

 - The computer(/opponent) decides a number with the number of digits of your choice.
 - The goal is to guess the number with the minimum number of guesses.
 - Each guess helps you get some information about the decided number.
 - A number which is commom to both the guess and the decided number is considered to be a cow if it is in the wrong place value.
 - If it is in the right place value, it is considered to be a bull. A guess can have multiple cows and bulls.
 - n bulls(where n is the number of digits in the decided number) imply a victory.

## Further Reading.
 You can read more on this topic following the wiki link and its references.
  - https://en.wikipedia.org/wiki/Bulls_and_Cows

repository: WadoodAbdul/Bulls-and-Cows-Game

repo_name: WadoodAbdul/Bulls-and-Cows-Game


text:
# Chef and Cook-Off Contests

Chef wants to prepare a Cook-Off contest with 5 problems chosen from a set of N problems. He has marked the difficulty of each problem within a range identified by one of the following strings: "cakewalk", "simple", "easy", "easy-medium", "medium", "medium-hard", "hard". According to this page, a Cook-Off contest must have problems of the following difficulties:

exactly one "cakewalk";
exactly one "simple";
exactly one "easy";
one "easy-medium" or one "medium";
one "medium-hard" or one "hard".
Given the information about the N problems, can you advise Chef if it's possible to pick 5 problems and form a valid Cook-Off contest?

## Input
The first line of input contains one integer T denoting the number of test cases.
T test cases follow.
The first line of each test case contains a single integer N.
Then N lines follow; the i-th line contains a single string si, denoting the difficulty of the i-th problem.
Output
For each test case, output "Yes" if it's possible to pick 5 problems and form a valid Cook-Off contest; otherwise, output "No".

## Constraints
* 1 ≤ T ≤ 100000
* 5 ≤ N ≤ 100000
* sum of N in all test cases ≤ 600000
* si can only be one of the following strings:
    * "cakewalk"
    * "simple"
    * "easy"
    * "easy-medium"
    * "medium"
    * "medium-hard"
    * "hard"
### Subtask #1 (11 points):

N = 5
### Subtask #2 (27 points):

5 ≤ N ≤ 15
T ≤ 100
### Subtask #3 (62 points):

original constraints
## Example

### Input:
3

5

easy

medium

medium-hard

simple

cakewalk

7

simple

simple

medium

medium

easy-medium

cakewalk

easy

7

cakewalk

simple

easy

easy-medium

medium

medium-hard

hard

### Output:

Yes

No

Yes

## Explanation
Example case 2: There are neither problems of "medium-hard" level nor "hard" level, so it's impossible to form a Cook-Off contest.

---
```
All submissions for this problem are available.
Author:	7★r_64
Editorial:	https://discuss.codechef.com/problems/C00K0FF
Tags:	cakewalk, ltime52, r_64
Date Added:	22-09-2017
Time Limit:	1 secs
Source Limit:	50000 Bytes
Languages:	CPP14, C, JAVA, PYTH 3.6, PYTH, CS2, ADA, PYPY, PYP3, TEXT, PAS fpc, RUBY, PHP, NODEJS, GO, TCL, HASK, PERL, SCALA, kotlin, BASH, JS, PAS gpc, BF, LISP sbcl, CLOJ, LUA, D, CAML, rust, ASM, FORT, FS, LISP clisp, swift, SCM guile, PERL6, CLPS, WSPC, ERL, ICK, NICE, PRLG, ICON, PIKE, COB, SCM chicken, SCM qobi, ST, NEM
```

path: /Practice/Beginner/Chef and Cook-Off Contests/README.md


text:
[Zoko](http://lulea.github.com/game-off-2012)
==================

Zoko is a simple 3D puzzle game that can be played in any modern web browser supporting WebGL. The basic idea of the game is based on the popular game often called [Sokoban](http://en.wikipedia.org/wiki/Sokoban),
 with the difference being that this version is played in 3D.

The objective of the game is to move all boxes to indicated platforms in as few steps as possible.

![Zoko Screenshot](http://www.minaspel.com/images/zoko-screen-01.png)

[Demo](http://lulea.github.com/game-off-2012)

Build instructions
------------------
In order to play the game run `cake build`. Since we're using AJAX to fetch textures and levels you will have to run it on a HTTP server
in order for it to work properly.

Ingredients
------------------
+ HTML5
+ CSS3
+ [CoffeeScript](http://coffeescript.org/)
+ [WebGL](http://en.wikipedia.org/wiki/WebGL)
+ [jQuery](http://jquery.com)
+ [Font Awesome](http://fortawesome.github.com/Font-Awesome)

Authors
------------------
**Samuel Nilsson**
+ http://twitter.com/samuelnilsson_
+ http://github.com/samuel02

**Sebastian Viklund**
+ http://github.com/dormin

License
------------------
The Zoko code is licensed under MIT http://www.opensource.org/licenses/MIT

gha_language: CoffeeScript


text:
# jstree-facade
A Scala.js facade for the jsTree jQuery library

## Installing the library

To use jstree-facade, add this line to your libraryDependencies:
```
"org.querki" %%% "jstree-facade" % "0.5"
```
This will include the .js file into your -jsdeps.js, and the minimized version into your -jsdeps.min.js in FullOpt builds.

There is one important constraint when using jsTree, though: the library assumes that you have a CSS "theme" included as well, or things won't display correctly. For the moment, the easiest way to deal with this is to include the desired theme explicitly in your HTML page, as something like this:
```
    <link rel="stylesheet" href="//cdn.jsdelivr.net/webjars/org.webjars/jstree/3.2.1/themes/default/style.min.css">
```
Adjust as needed for your environment. Note that there are two themes available by default -- poke around in the jstree archive at WebJars to look at the alternatives.

## About this facade

This is currently partial, to say the least -- jsTree is a pretty huge and complex Widget, and I've only implemented some of the pieces that I need so far. Pull requests are welcome to flesh it out further.

For more information about jsTree itself, including detailed information about the API and how to use it, see the [jsTree homepage](https://www.jstree.com/), and [the GitHub repo](https://github.com/vakata/jstree).

repository: jducoeur/jstree-facade

repo_name: jducoeur/jstree-facade


text:
# Profile Test Server

The Profile Test Server component is used in integration tests for the bluetooth
[profiles](https://fuchsia.googlesource.com/fuchsia/+/HEAD/src/connectivity/bluetooth/profiles/).

The server manages a fake piconet of peers, and simulates the behavior of the
[Profile Server](https://fuchsia.googlesource.com/fuchsia/+/HEAD/src/connectivity/bluetooth/core/bt-host/fidl/profile_server.h). The component implements the [ProfileTest](https://fuchsia.googlesource.com/fuchsia/+/HEAD/sdk/fidl/fuchsia.bluetooth.bredr/profile_test.fidl) interface, which can be used to
register mock peers in the piconet, launch profiles to test, and drive peer behavior. The server supports establishing L2CAP and RFCOMM connections.

## Build Configuration

To include the profile server and its tests in your build, add:

`--with //src/connectivity/bluetooth/testing/bt-profile-test-server` and
`--with //src/connectivity/bluetooth/testing/bt-profile-test-server:tests`
to your `fx set`.

To run the unit tests for the server: `fx test bt-profile-test-server-tests`.

## Library

The Profile Test Server also provides a client-facing library of utilities to launch and interact
with the server.
To use the tools provided in the library, add `//src/connectivity/bluetooth/testing/bt-profile-test-server:lib` to the
`BUILD.gn` of your test component.

Import the `ProfileTestHarness` to your test to get started! Instantiate the ProfileTestHarness and register mock peers using
the `ProfileTestHarness::register_peer` method. You can then emulate peer behavior by either operating directly on the mock peer or
launching a Bluetooth profile.


text:
This folder contains parameters for the co-alignment of MRI volumes with a deformable registration technique [1].
The technique itself is implemented [on its own GitHub page](https://github.com/simeks/deform). For saliency aggregation,
it was used to align the masked fat fraction (FF) and water fraction (WF) volumes of a moving to a fixed subject as follows:

>./deform registration -f0 path_to_fixed_ff.nrrd -f1 /path_to_fixed_wf.nrrd -m0 path_to_moving_FF.nrrd -m1 path_to_moving_wf.nrrd -p params.txt -o output.vtk

[1] [_S. Ekström, F. Malmberg, H. Ahlström, J. Kullberg, and R. Strand, “Fast Graph-Cut Based Optimization for Practical Dense Deformable Registration of Volume Images,” arXiv:1810.08427 [cs], Oct. 2018. arXiv: 1810.08427_](https://arxiv.org/abs/1810.08427)

repository: tarolangner/mri-biometry

repo_name: tarolangner/mri-biometry


text:
---
date: 19 Aug 2020
id: 'jharkhand-2014-legislative-election'
title: Jharkhand 2014 legislative election - state alliances, vote share, seats won and key events.
desc: The 2014 election for Jharkhand legislative assembly had given a stable government for the first time. All previous elections resulted in a hung assembly. Bharatiya Janata Party (BJP) got a single majority with

imgDesc: Image is a Pie chart and it shows the number of wons by various alliances in the state.
articleLang: 'en-US'
author: 'by theDataTalks'
altLang: true
isHome: false
topic: politics
---

<altLang />

# {{ $frontmatter.title }}
<i style="font-size: 0.75em;"> {{ $frontmatter.author }} {{ $frontmatter.date }} </i>

Visit <https://indiaelectiondata.in/legislative-election/> for detailed results.

The below pie chart shows the number of wons for each political party.

![](/img/politics/jharkhand-2014-legislative-election/jh-2014-election-1.png)

The below pie chart shows the number of wons for each political alliance.

![](/img/politics/jharkhand-2014-legislative-election/jh-2014-election-2.png)

The 2014 election for Jharkhand legislative assembly had given a stable government for the first time. All previous elections resulted in a hung assembly.

Bharatiya Janata Party (BJP) got a single majority with 43 seats. 41 seats are required for the majority to form a government. The detailed results are shown in the below tables & PI charts.

Out of 2.09 crore electors, the voter turns out was 1.39 crore, which is calculated to a polling percentage of 66.5%.

There were no major alliances formed prior to the election.

0.43 crore out of 1.39 crore voters has chosen BJP, which is 100.08% more compared to the 2009 election.
0.14 crore voters have chosen INC, which is 12.66% less compared to the 2009 election.
0.28 crore voters have chosen JMM, which is 81.35% more compared to the 2009 election.

The data file in \*.CSV format can be downloaded from [Jharkhand 2014 Legislative Election](https://thedatatalks.in/datas/politics/jharkhand-2014-legislative-election.csv)

The below table shows the won candidate details for each legislative constituency.
**The values are first sorted by party name & then by constituency name.**

![](/img/politics/jharkhand-2014-legislative-election/jh-2014-election-3.png)

<style>

</style>


text:
# WMT Alpha Data Integration Prototype

This section of the prototype illustrates how we will implement data integration.

[Pandas](http://pandas.pydata.org/) is a flexible and powerful Python library for data manipulation and analysis.

It provides rich functionality for working with database, file based and API abased data souces and for converting between them.

### Set-up Python Dev environment
Python development uses [virtualenvwrapper](http://virtualenvwrapper.readthedocs.io/en/latest/index.html) to provide dependency isolation.

To set up Python and VirtualEnv install as follows:

`brew install python`
`pip install virtualenvwrapper`

Add the following lines to your `~/.bash_profile`:

```
export WORKON_HOME=$HOME/.virtualenvs
export PROJECT_HOME=$HOME/Devel
source /usr/local/bin/virtualenvwrapper.sh
```

Run `source ~/.bash_profile` in order for these changes to take immediate effect

From the base project directory execute the following command to set up your environment:

`mkvirtualenv -a wmt-etl -r requirements.txt wmt-etl`

All subsequent times you want to work on this project you should just need to type:

`workon wmt-etl`

And it will switch to this virtualenv and take you to the ./wmt-etl directory.

### Running the ETL Job

To run the example ETL file, first ensure that the local development DB is running and execute the following script to submit it for execution:

`python etl.py`

repository: ministryofjustice/hmpps-wmt

repo_name: ministryofjustice/hmpps-wmt


text:
httpstime
=========

Simple bash script to set the system time via HTTPS.
Born out of frustration with all other existing solutions, see also:

* https://blog.hboeck.de/archives/890-In-Search-of-a-Secure-Time-Source.html

By default it will use the HTTP Date header from
[www.google.com](https://www.google.com) to set the time. Alternatively
another hostname can be passed on the command line.

Unlike NTP setting the time via HTTPS provides protection against
man in the middle attacks.

The accuracy is worse than NTP, as the time resolution is only
in seconds and network transmission times aren't considered.

Security considerations
=======================

This provides no protection against rogue Google servers sending
a bad time.

In theory the server could try to attack the parser in the "date"
tool. However I tested it with american fuzzy lop and it seems
robust.

license: Unlicense

repository: hannob/httpstime

gha_language: Shell

repo_name: hannob/httpstime


text:
# Optional Enhancements

## Goal

Optional enhancements are meant to spark our imagination! They can give us extra ideas for how to extend this project. Optional enhancements should never compromise the project requirements, unless there are special circumstances.

## Optional Means Optional

It is more important and more valuable to do good work with the requirements, and to solidify your learning. Please do not work on optional enhancements before feeling confident in the project requirements.

## Prompts

### Reset Button

Create a button in the `App` component. When this button is clicked, it will reset the game's state and clear all the game squares.

### Tests

There are tests provided for this optional enhancement!

Unskip these tests to verify if the reset button resets the grid. The provided tests check for:

- When the reset button (with the text "Reset Game") is clicked, the grid should go back to blank squares. It selects all the `<button class="square"></button>` elements and verifies that they have no text.
- Immediately after the reset button is clicked, the text "The winner is O" or "The winner is X" should not appear.

## Deploy on the Web

Deploy this project using GitHub Pages.

We recommend following [the `react-gh-pages` tutorial](https://github.com/gitname/react-gh-pages) for instructions!

## Notify Tie

If the game ends in a tie, adjust the text to indicate that until the game is reset.

## Customize Name

Include two `<input type="text">` elements that allow the two players to customize their name.

repository: AdaGold/react-tic-tac-toe

repo_name: AdaGold/react-tic-tac-toe


text:
# Writing 8: Keeping a Record of Your Research Work Part 2

**Due: Mon, Oct 13**

With the help of your research notes, create 1-2 slides to motivate your science and your research goals.


text:
# [Chapter 2] KAF Events

The **kaf event** feature allows you to register JavaScript functions as **events** and manage them easily, as well as **clarify the relationships** between HTML elements and events.

## The Basics of KAF Events

As in the case of kaf data, it can be defined by passing **"Events" as an argument** to the optional `events` when the instance is initialized. And you can fire an event with an arbitrary trigger by giving the attribute `kit-e` to the element.

In the example below, a **hello** event is fired when **click** a button with `kit-e="hello click"` and a **greet** event is fired when **dblclick** a button with `kit-e="greet dblclick"`.

> See [here](https://developer.mozilla.org/en-US/docs/Web/Events) for a list of available event triggers.

There is an obvious advantage to registering a function as a kaf event rather than simply defining it as `function hello() { ... }` in plain JavaScript.

First of all, just by looking at the HTML markup, you can see **at a glance which elements trigger which events with which triggers**. And the available scope of the event is limited to the interior of the KAF instance.

> If you define the event `hello`, you can call the method like `kaf.hello()` from an instance of the Kaf class.
>
> This is why it is not possible to define events with names that exist as kaf data names.

Also, if you look at the example, you can see that in the **greet** event, we are referring and reusing the event in the instance, such as `this.hello();`. As a result, you'll get an alert saying **Hello** when a GREET event occurs.

## Shorthand notation and multiple allocation

Furthermore, in the case of **click** events, you can omit to describe the event type. That is, `kit-e="hello"` is equivalent to `kit-e="hello click"`.

Also, you can assign multiple events to a single element like `kit-e="hello click, greet dblclick"`, separated by commas. Take a look at the following example.

This is an example of three incremental events for three data named `a, b, c`, and incrementing them in various ways.

- First, `kit-e="add2a"` increments the value of `a` when you click.
- Next, `kit-e="add2b, add2c mouseover"` increments the value of `b` on clicking and `c` on mouseover.
- Finally, `kit-e="add2a, add2b, add2c"` increments all values of `a, b, c` on click.

## Advanced Examples

Here's a slightly more advanced example using a KAF event. You can conveniently use kaf events in conjunction with **kaf data** using instance references by `this`.

---

[＞ [Chapter 3] See About i18n Support Feature](/en/i18n)

repository: mtsgi/kafjs

repo_name: mtsgi/kafjs


text:
# < AC - Defender  >

## About the project

This game was made in two weeks using Simple Grafics Library (A Academia de codigo internal grafics library),

## Story

Help the Katxupi protect the AC from the terrible monsters

## :rocket: Build with:

- Java (1.8)

## Release

[Click Here](https://github.com/FabyoSK/ac-defender/releases/tag/v1.0) to check the releases

## Authors

* **Fábio Alves** - [FabyoSK](https://github.com/FabyoSK)
* **Helcilino Castro** - [Castro555](https://github.com/Castro555)
* **Samuel Miranda** - [dtmiranda](https://github.com/dtmiranda)
* **Héricles Lima** - [avengerCoder](https://github.com/avengerCoder)
* **Elvin Reis** - [elvinreis](https://github.com/elvinreis)
* **David Nunes** - [Dnuns](https://github.com/Dnuns)

See also the list of [contributors](https://github.com/FabyoSK/ac-defender/contributors) who participated in this
project.

## License

This project is licensed under the MIT license.

repository: FabyoSK/ac-defender

repo_name: FabyoSK/ac-defender


text:
# Linked List
One of the data structures.
## Challenge
create a method to create a linked list
create a method to insert before or after the linkedlist
create a method to read from the last of linked list

## Approach & Efficiency
I used classes and it was easy.
## Checklist
- [x] New Branch
- [x] create classes
- [x] Update readme file
- [x] Create a test
- [x] Net, clean and flexable code
- [x] Add all needed methods

## Solution
![LL](../../assets/LL2.png)
![LL](../../assets/LL.png)


text:
## Agenda

* Implementation issues with Nodejs

## Attendance

* Paulo Chainho, Luis Duarte, Micael Pedrosa, Joel,  (PTIN)
* Ancuta Corici (FOKUS)
* Frédéric Luart, Nicholas (APizee)
* Antón Román (Quobis)

## Summary

It was agreed to have a common implememtation for the Browser Runtime and the Mobile Standalone App runtime.

It was also agreed to have a common implememtation for the Nodejs based Runtime implementations for Server Side runtime environments like the Kurento Media Server and M2M/IoT runtime environments like Raspberry PI. APIZEE volunteered to coordinate this work.

In order to promote portability it was agreed to use IndexDB API by all components requiring data persistence and the [Sandbox API](https://github.com/reTHINK-project/dev-runtime-core/blob/master/src/sandbox/Sandbox.js) proposed by PTIN.

It was also agreed on a [common methodology](https://github.com/reTHINK-project/dev-runtime-browser/issues/2) to import generic runtime core components by the different runtime implememtations.

repository: reTHINK-project/core-framework

repo_name: reTHINK-project/core-framework


text:
# The Quasar project

A new version of this program is available: [Quasar2](https://github.com/objectDisorientedProgrammer/Quasar2).

Authors: Doug Chidester, James Howard, Steve Corbett

## Warning
Running this executable may trigger your antivirus program. This is because the executable is not signed by a known source.

## Dependencies
Requires Microsoft .NET 4.5

## Building
Open Quasar.sln in Microsoft Visual Studio 2012 to build and run.

## Notes
The file _Quasar.dat located in the Quasar directory is where data will be stored by default.

repository: objectDisorientedProgrammer/Quasar

repo_name: objectDisorientedProgrammer/Quasar