text:
# Exercise: TypeScript Basics

## Prerequisites

1. Install TypeScript with NPM

## Part A: TypeScript Type System

1. Open a command prompt and navigate to the type-system folder in the Before directory
   and navigate to the project directory.
    - Install NPM packages listed in packages.json.

    ```
    npm install
    ```

    *Note: Unless otherwise noted, you will need to run npm install from a
    command line at the project root prior to beginning work on each part of the lab.*

2. Open Visual Studio Code at the project root, and add a file
   to the src directory named 01-dynamic-typing.ts.
    - Begin by adding a dynamic_typing namespace to the file.
      Be sure to place code that follows in this namespace.

    ```js
    namespace dynamic_typing {
    }
    ```

    *Note: Namespaces are required in order to avoid collisions between variables
     with the same name that have been declared in the global namespace.*

3. Add a Person class with two properties: name (string) and age (number).

    ```js
    class Person {
        name: string;
        age: number;
    }
    ```

4. Add a Student class with an enrolled property (Date).

    ```js
    class Student {
        enrolled: Date;
    }
    ```

5. Then add a birthday function in the namespace that accepts a person parameter of type any and increments the age by 1.

    ```js
    function birthday(person: any) {
        person.age += 1;
    }
    ```

6. Create a new Student and assign it to a variable named joe. Set his age to 18.

    ```js
    let joe: any = new Student();
    joe.age = 18;
    ```

7. Lastly, call the birthday function, passing joe as the parameter. Then write his age to the console.

    ```js
    birthday(joe);
    console.log(joe.age);
    ```

    - Compile the project by pressing CMD + SHIFT + B (Mac) or CTRL + SHIFT + B (Windows / Linux).
      There should not be any compilation errors.
    - Show the Debug Console by pressing CMD + SHIFT + Y (Mac) or CTRL + SHIFT + Y (Windows / Linux),
      and press F5 to launch the debugger and run the code.
    - You should see the number 19 printed to the console.
    - Press SHIFT + F5 to stop the debugger.
    - The reason the code compiles and runs is that it leverages
      JavaScript’s native support for dynamic typing.

8. Copy and rename 01-dynamic-typing.ts to 02-structural-typing.ts, and rename the namespace to structural_typing.
    - Refactor the code to replace any with Person.
    - Do this in both in the birthday function and the initialization of the joe variable.

    ```js
    function birthday(person: Person) { // Remaining code elided ...
    let joe: Person = new Student();
    ```

    - You will now see a compilation error appear on the line of code on which joe is initialized,
     complaining that Student is missing a name property, which is how the TypeScript compiler enforces type safety.
    - Go ahead and copy the name property from Person to Student. The compilation error will remain
      but state that the age property is missing from Student. Copy the age property from Person to Student,
      and the compilation error will go away.

    ```js
    class Student {
        name: string;
        age: number;
        enrolled: Date;
    }
    ```

    - Notice that TypeScript allows conversion from Student to Person even though Student does not
      explicitly extend Person. This is because TypeScript uses structural typing to determine
      that the two types are compatible – Student has all the properties of Person, so it must be a Person.
      This is commonly referred to as duck typing: “If it quacks and walks like a duck, it must be a duck!”
    - Compile and run the program. You should see the number 19 printed to the Debug Console.

    *Note: You may need to clear output from the Debug Console in order verify that the program ran correctly.*

9. Copy and rename 02-structural-typing.ts to 03-nominal-typing.ts, and rename the namespace to nominal_typing.
    - Go ahead and remove the type annotation from the joe variable, so that it is assumed to be of type Student.
    - Add a protected property named gender of type string to the Person class.

    ```js
    protected gender: string;
    ```

    - You should notice a compilation on the line at which the birthday function is called, stating that Student is not assignable to Person because it is missing the gender property.
    - Rather than adding the gender property to Student, you can take advantage of nominal typing in TypeScript by refactoring Student to explicitly extend the Person type. Change the definition of Student as follows:

    ```js
    class Student extends Person {
    ```

    - Notice that the code compiles, even though Student has the same name and age properties as Person.
      But seeing as one of the benefits of nominal typing is code reuse, you can safely remove name
      and age properties from Student without causing any compilation errors. Person and Student should appear as follows:

    ```js
    class Person {
        protected gender: string;
        name: string;
        age: number;
    }

    class Student extends Person {
        enrolled: Date;
    }
    ```

10. After the line of code that creates a Student, set the name and enrolled properties as follows:

    ```js
    joe.name = "Joe";
    joe.enrolled = new Date();
    ```

    - Update console.log to display these properties as well.

    ```
    console.log(`Student named ${joe.name}, age ${joe.age}, enrolled on: ${joe.enrolled.toDateString()}`);
    ```

    - Output similar to the following should be displayed in the Debug Console:

    ```
    Student named Joe, age 19, enrolled on: Fri Sep 02 2016
    ```

## Part B: Type Inference

1. Open Visual Studio Code in the type-inference folder at the Before directory.
    - In the src directory, you will find a file named 01-type-inference.ts.
      Open the file and have a look at the contents.
    - You will see four classes: Person, Student, Faculty, and Mascot.
      Student and Faculty extend Person, which has a talk method.

    ```js
    class Person {
        talk() {
            console.log("Hello");
        }
    }

    class Student extends Person {
    }

    class Faculty extends Person {
    }

    class Mascot {
    }
    ```

    - You will also see three lines of code that initialize new instances of Student, Faculty, and Mascot.

    ```js
    let student = new Student();
    let teacher = new Faculty();
    let mascot = new Mascot();
    ```

2. Create a variable called people and initialize it to an array that includes a student and teacher.

    ```js
    let people = [student, teacher];
    ```

    - Invoke the talk function on the first element of the array.

    ```js
    people[0].talk();
    ```

    - You’ll notice that TypeScript infers the people variable to be an array of Person.
      This is indicated by intellisense when you mouse over the call to the talk function.

    - While you’re at it, call talk on the second element of the array.

    ```js
    people[1].talk();
    ```

    - Compile and run the program to make sure it works as expected,
      which is to print Hello to the console two times.

3. Next add a variable called mammals and initialize it to an array with student, teacher, and mascot.

    ```js
    let mammals = [student, teacher, mascot];
    ```

    - Call talk on the first element of the array.

    ```js
    mammals[0].talk();
    ```

    - This time you will receive a compilation error stating: “Property 'talk' does not exist on type 'Mascot'.”
      This indicates that TypeScript selected Mascot as the best common type, based on structural typing.

    - Add a type property (string) to Mascot.

    ```js
    class Mascot {
        type: string;
    }
    ```

    - The compilation error will now indicate that TypeScript is inferring a type that combines Student and Mascot.
4. Lastly, add a talk method to Mascot, logging “Woof” to the console.
    - The compile error will now disappear, because TypeScript is inferring
      Person as the best common type, based on structural typing.

    - While you’re at it, go ahead and call talk on the second and third elements of the mammals array.
      Then compile and run the program to observe the output.

## Part C: typeof Operator and Union Types

1. Open Visual Studio Code in the typeof-union folder at the Before directory.
    - In the src directory, you will find a file named 01-enrolled_date.ts.
      Open the file and have a look at the contents. There you will see Person and Student classes.
    - Student extends Person and has a private enrolled property with methods to set and get the enrollment date.

    ```js
    class Student extends Person {
        private enrolled: Date;
        setEnrolled(date: Date) {
            this.enrolled = date;
        }
        getEnrolled(): string {
            return this.enrolled.toDateString();
        }
    }
    ```

    - There is also code that initializes a new Student, sets the enrollment date,
      and displays student information to the console.

    ```js
    let student = new Student();
    student.name = "Sue";
    student.age = 20;
    student.setEnrolled(new Date());
    ```

    ```
    console.log(`Student named ${student.name}, age ${student.age}, ` +
        `enrolled on: ${student.getEnrolled()}`);
    ```

    - Compile and run the code. You should see student information logged to the console,
      with today’s date set as the enrollment date.

2. Copy and rename 01-enrolled_date.ts to 02-enrolled_any.ts.
   Then rename the namespace to enrolled_any.
    - Your task will be to refactor the setEnrolled function to accept either a date or string.
      The typeof operator will allow you to determine if the date parameter is a string.
    - Start by changing the parameter type on the date parameter for the setEnrolled function from Date to any.
      Then in the body of setEnrolled, use the typeof parameter to see if the date parameter is a string and,
      if so, pass it to the constructor of Date to create a new date that has been parsed from the string.

    ```js
    // Change parameter to any
    setEnrolled(date: any) {

        // See if a string was passed in
        if (typeof date === "string") {

            // Set enrolled to a new Date based on string value
            this.enrolled = new Date(date);
        }
        else {
            this.enrolled = date;
        }
    }
    ```

    - To call setEnrolled, you’ll need to create a string representation of today’s date,
      which depends on how dates are represented in your region. For the United States,
      dates are formatted as mm/dd/yyyy, as shown below. You may need to modify the code
      to match your geographic region.

    ```js
    let today = new Date();
    let dateString = `${today.getMonth()}/${today.getDate()}/${today.getFullYear()}`;
    student.setEnrolled(dateString);
    ```

    - Compile and run the code to see the enrollment date displayed along with the other student information.

3. Copy and rename 02-enrolled_any.ts to 03-enrolled_union.ts, and rename the namespace to enrolled_union.

4. Comment out the code that initializes dateString and calls setEnrolled;
   then call setEnrolled passing a number, such as 12345.

    ```js
    // let dateString = `${today.getMonth()}/${today.getDate()}/${today.getFullYear()}`;
    // student.setEnrolled(dateString);
    student.setEnrolled(12345);
    ```

    - Compile and run the program. The debugger will break on an exception that takes place in the getEnrolled function.
      The exception message will be: "this.enrolled.toDateString is not a function."
      The reason is simple. Because you passed a number to setEnrolled, this.enrolled was set to a number,
      and the number type does not have a toDateString function.

    *Note: Even though the enrolled property on Student is annotated as a Date,
    TypeScript respects the dynamic nature of JavaScript, which allows enrolled to be set to any type at runtime.*

5. In order to prevent a non-Date value other than string from being passed to setEnrolled, you can use a union type.
    - Change the type annotation on the date parameter to a union of string and Date types.

    ```js
    setEnrolled(date: string | Date) {
    ```

    - You’ll now get a compile error on the line of code that passes a number to setEnrolled:
      “Argument of type 'number' is not assignable to parameter of type 'string | Date'.”
    - To resolve the error, simply pass the today variable, which is a Date, instead of a number.

6. If you mouse over the date variable on the line in setEnrolled that follows use of the typeof operator,
   you’ll notice that TypeScript has “narrowed” the union type to a string. Similarly,
   mousing over the date variable in the else block will indicate that date has been narrowed to a Date.
   The benefit of type narrowing is that you can treat the variable in each scope as the narrowed type.

## Part D: Type Assertions and Type Guards

1. Open Visual Studio Code in the assertions-guards folder at
   the Before directory and navigate to the project directory.
    - Open the file 01-person_assertions.ts. There you will find Person, Student, and Teacher classes.
    - Insert a function called learnOrTeach that accepts a person parameter of type Person.
    - Check for the existence of the teach function on person, then invoke teach.
      Do the same with regard to the learn function.

    ```js
    function learnOrTeach(person: Person) {
        if (person.teach) {
            person.teach();
        }
        if (person.learn) {
            person.learn();
        }
    }
    ```

    - Notice that you get compile errors indicating that teach and learn methods do not
      exist on the Person type. To eliminate the errors, you can add a type assertion
      in the form of the as operator.

    ```js
    function learnOrTeach(person: Person) {
        if ((person as Teacher).teach) {
            (person as Teacher).teach();
        }
        if ((person as Student).learn) {
            (person as Student).learn();
        }
    }
    ```

    - Lastly, add code to create a student and teacher and call learnOrTeach, passing each one to the function.

    ```js
    let student = new Student();
    let teacher = new Teacher();
    learnOrTeach(student);
    learnOrTeach(teacher);
    ```

    - Compile and run the code to see expected output.

2. Copy and rename 01-person_assertions.ts to 01-person_instanceof.ts, and rename the namespace to person_instanceof.
    - Use of the as operator in the previous section is a bit cumbersome,
      because you need to assert the type twice – first to check for the existence of a method,
      then to execute the method. The typeof operator won’t help much because it will return
      “object” for both Student and Teacher.
    - Instead of the as operator, you can use the instanceof operator to check whether person
      is a Student or Teacher type. This has the effect of “narrowing” the type,
      so there’s no need to use a type assertion when invoking a method on the object.
    - Refactor the learnOrTeach function to replace use of the as operator with instanceof to check for type compatibility.

    ```js
    function learnOrTeach(person: Person) {
        if (person instanceof Teacher) {
            person.teach();
        }
        if (person instanceof Student) {
            person.learn();
        }
    }
    ```

    - Compile and run the program to make sure it works as expected.

3. Copy and rename 02-person_instanceof.ts to 03-interface_guards.ts, and rename the namespace to interface_guards.
    - Let’s say we want to add a Robot class that has a learn function (assuming it has artificial intelligence),
      but it does not extend the Person class (for obvious reasons).

    ```js
    class Robot {
        learn() {
            console.log("Robot learning ...");
        }
    }
    ```

    - While you’re at it, update the log message for Student and Teacher to include the class name.

    ```
    console.log("Student learning ...");
    console.log("Teacher teaching ...");
    ```

    - To generalize the code, create a pair of interfaces, CanLearn and CanTeach, and insert learn and teach methods.

    ```js
    interface CanLearn {
        learn(): void;
    }

    interface CanTeach {
        teach(): void;
    }
    ```

    *Note: We will learn more about interfaces in a subsequent module.*

    - Update Student and Robot classes to implement CanLearn. Update the Teacher class to implement CanTeach.

    ```js
    class Student extends Person implements CanLearn {
    class Teacher extends Person implements CanTeach {
    class Robot implements CanLearn {
    ```

4. Next, refactor the learnOrTeach function by replacing the person parameter with a parameter
   called being that is a union of CanLearn and CanTeach. Then in each if block,
   replace the type name with the interface name.

    ```js
    function learnOrTeach(being: CanLearn | CanTeach) {
        if (being instanceof CanTeach) {
            being.teach();
        }
        if (being instanceof CanLearn) {
            being.learn();
        }
    }
    ```

    - You will receive compilation errors, because instanceof cannot be used with an interface,
       and also because the union type only contains properties that are in common between the two interfaces.

5. To eliminate the compilation errors, you can create a user-defined type guard, which can perform a runtime
   check for type compatibility using the as operator.
    - Create a canLearn function with a being parameter of type CanLearn | CanTeach that performs a
       type assertion using the as operator to determine if the learn method is not undefined.
    - In order for type narrowing to take place, canLearn will need to return a predicate in the form: parameterName is Type.

6. Create another user-defined type guard called canTeach that performs the same kind of type check for the CanTeach interface.

    ```js
    function canLearn(being: CanLearn | CanTeach): being is CanLearn {
        return (being as CanLearn).learn !== undefined;
    }

    function canTeach(being: CanLearn | CanTeach): being is CanTeach {
        return (being as CanTeach).teach !== undefined;
    }
    ```

    - Refactor the learnOrTeach function to replace use of the instanceof operator with user-defined type guards.

    ```js
    function learnOrTeach(being: CanLearn | CanTeach) {
        if (canTeach(being)) {
            being.teach();
        }
        if (canLearn(being)) {
            being.learn();
        }
    }
    ```

7. Lastly, add code to create a new Robot and pass it to learnOrTeach.

    ```js
    let robot = new Robot();
    learnOrTeach(robot);
    ```

    - Compile and run the program to verify expected output is displayed in the console.


text:
## Contribution

Require NODE > 8

### Getting started

```sh
> git clone https://github.com/fus-marcom/franciscan-react.git
> cd franciscan-react
> yarn install
> yarn develop
```

1. Use `yarn` package manager as we have used yarn to scaffolde the app. See https://yarnpkg.com
2. Make a separate branch per feature added or bug fixed. Make a different PR for each so that we can track history better.
3. **DO NOT COMMIT CHANGES THAT BREAKS THE RENDER**
4. No uncessary discussion about style guide. Always run precommit hook as prettier and eslint can format. You can add them to you editor as well. You can code in your own style and prettier and eslint will change it to standerd JS style which is our requirement.
5. Open a new issue for a new feature so that we may add it to our kanban board.
6.  Running tests before commit is recommended
8. Do not commit package-lock.json as we are using yarn.lock
9. Keep you environment vars in .env file. If you add any .env file make sure to add the entities in a .env.sample file for the repo.
10. Keep  you master branch up to date as to avoid merge conflicts
11. Happy coding!!

license: MIT

repository: jasmeetsohal/franciscan-react

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: jasmeetsohal/franciscan-react


text:
Hello!!!

Yup that's me! A big nose girl who loves coding and learning new things :) A few about myself: I love playing musical instruments and also singing, and I'm a huge animals lover.

 Want to contact?

[![Linkedin](https://img.shields.io/badge/-LinkedIn-blue?style=flat&logo=Linkedin&logoColor=white)](https://www.linkedin.com/in//mariana-coimbra-87087118b/)
[](https://github.com/marianacoimbra)
<EMAIL_ADDRESS>

Ok, back to the point:

I'm a undergratuate of Computer Science at the Federal University of Campina Grande (UFCG) in Brazil. I am currently working as a Front-end developer and also very interested on learning about data analysis  :)

I hope you're enjoying this tour at the Elas@Computação repository! Thank you for your attention, visitor :)

repository: helenadantas/sobrElas

repo_name: helenadantas/sobrElas


text:
# BlockSat_Plots
Plots and csv data showing frequency spectrum plots of the Blockstream Satellite signal from Telstar 11N 37W

More information;

https://blockstream.com/satellite/

https://github.com/Blockstream/satellite

*BlockSat v2.0 signal from Telstar 11N, (Europe) with adjacent satellite West of Telstart 11N*

![Current_signal](https://github.com/pikefloyd/BlockSat_Plots/blob/master/20200529/Blocksat_v2_2MHz_BW.png)


text:
# Tap Room

#### By Kristen Hopper

## Technologies Used

* _HTML_
* _CSS_
* _JavaScript_
* _React_
* _npm_
* _webpack_

## Setup/Installation Requirements

1. Within your terminal, navigate to the directory you wish to clone the repository to
2. Clone the repository: `$ git clone https://github.com/krishops/tap-room.git`
3. Navigate to the tap-room directory and run `npm install` in the terminal
4. run `npm start` to start a development server at http://localhost:3000

## Description

This project demonstrates the use of React in building a website.
The following mock-ups show the initial plan for building this site.

## Known Bugs

* There are no known issues with this project.

## License

[MIT](https://opensource.org/licenses/MIT)

Copyright (c) Kristen Hopper

## Contact Information

hopperdavis@gmail.com

repository: krishops/tap-room

branch_name: refs/heads/main

repo_name: krishops/tap-room


text:
#Tornado "Trails"
## Introduction & Motivation
In effort to ease the developement on tornado, I am developing a standard model tornado app.
##What's in the Box?
-tornado developement model and tools
-user auth models
-Bootstrap 2.3.2
-jQuery 2.0.2
-*almost* ready to roll server

##Requirements:
- [tornado v3.1](https://github.com/facebook/tornado)
- [asyncmongo v1.3-alpha3](https://github.com/bitly/asyncmongo)
- [pymongo v2.5.2](https://github.com/mongodb/mongo-python-driver)
- [MongoDB v2.4.4](https://github.com/mongodb/mongo) (install via `$ brew install mongodb` on OSX)
- python (3 or 2.7+)

##Setup
To set this up, simply edit the config.py file to your liking, then run `$ python run.py`

For deployment, you **will** want to run it behind nginx. An example config is included.

##Modification/Paradigm
The design paradigm is pretty simple. Will add more documentation later, but it should be easy to read the code.

##Scaffolding
If you take a look in the tools folder, I've started working on some scaffolding code which is pretty cool. Right now all it has is scaffolding for creating new modals or handlers, but I anticipate adding even more in the future. To see how these work, run them as `$ python New____.py -h`

*Brought to you by Jeremy Rubin, 2013*

repository: JeremyRubin/tornado-trails

repo_name: JeremyRubin/tornado-trails


text:
## The Chest X-Ray Dataset goes in this folder

Homepage of the ISIC2016 dataset:
[https://data.mendeley.com/datasets/rscbjbr9sj/2](https://data.mendeley.com/datasets/rscbjbr9sj/2)

Download the ChestXRay2017.zip file and extract it in this folder.

This should be the structure of this folder once the data is in place:
- test (folder)
    - NORMAL (folder)
    - PNEUMONIA (folder)
- train (folder)
    - NORMAL (folder)
    - PNEUMONIA (folder)
- val (folder)
    - NORMAL (folder)
    - PNEUMONIA (folder)
- README.md (this file)

gha_license_id: MIT


text:
# Auto Regressive networks
* directed probabilistic models without latent variables, where conditional probability distribution are represented using NN
* the graph structure is a complete graph
* decomposes a joint probability distribution over visible variables as a product of conditionals
    $$
    p(x_d|x_{d-1}, \cdots, x_1)
    $$

## Linear Auto-Regressive networks

* each $p(x_d|x_{d-1}, \cdots, x_1)$ is a linear model
* if the variables are continuous, than the linear auto-regressive model is just an another way to formulate a multivariate Gaussian dist, capturing linear pairwise interactions between the observed variables

![](../.images/machine_learning/linear_autoregressivej_networks.png)

## Neural Auto Regressive networks

* same left to right flow as linear auto-reg networks
* joint conditional are parametrized using a NN, which is powerful enough to approx any joint distribution


text:
---
layout: default
---

# 1998-02-06 - Software Money

## Header Data

From: Declan McCullagh<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: a317acca60f0e76364b9bd77d6f23dd8791cf99c4a34f19a6ec5856017fde89a

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1998-02-06 20:14:24 UTC

Raw Date: Sat, 7 Feb 1998 04:14:24 +0800

## Raw message

```
{% raw  %}From: Declan McCullagh<EMAIL_ADDRESS>Date: Sat, 7 Feb 1998 04:14:24 +0800
To<EMAIL_ADDRESS>Subject: Software Money
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

http://cgi.pathfinder.com/netly/editorial/0,1012,1722,00.html

The Netly News (http://netlynews.com/)
February 2, 1998

Software Money
by Declan McCullagh<EMAIL_ADDRESS>
        Successful political campaigns follow a simple formula: 1) Spend
   heaps of money; 2) Puzzle out how to squeeze your message into one
   sentence, or, better yet, a bumper sticker.

        Silicon Valley finally got the first part right. Software
   chieftains, historically eager to squander cash on doomed marketing
   campaigns but loath to spend the same opposing government regulations,
   are about to ante up millions to detangle the skein of rules that
   restrict sales of data-scrambling encryption software. Sure, it's
   pocket change to California's zillionaires, but it may be just enough
   to get their deregulatory point across in the nation's capital.

[...]

       Together the duo will coordinate the lobbying and media efforts
   of a new industry coalition, as yet unnamed but likely to be dubbed
   something like the Alliance for Computer Privacy. The
   soon-to-be-announced project (contracts haven't been signed yet) grew
   out of the Alliance for a Secure Tomorrow, which firms hurriedly
   created last fall to battle FBI-backed legislation banning software
   such as PGP, which is capable of encoding messages so securely that
   police can't crack them. But the AST languished. Soon CEOs of more
   than a dozen high-tech companies started talking about a more
   aggressive approach. "The only time you're going to win this battle is
   when you put money on the table," says Lauren Hall of the Software
   Publishers Association.

[...]

{% endraw %}
```

## Thread

+ Return to [February 1998](/archive/1998/02)

+ Return to "[Declan McCullagh <declan@well.com>](/authors/declan_mccullagh_declan_at_well_com_)"

+ 1998-02-06 (Sat, 7 Feb 1998 04:14:24 +0800) - Software Money - _Declan McCullagh<EMAIL_ADDRESS>


text:
# WebApp

Here you may find simple example of `WebApp`. For work of this example you will need one of two things:

* Your own domain with SSL (letsencrypt is okay)
* Test account in telegram

What is there in this module:

* JVM part of this example is a server with simple static webapp sharing and bot which just gives the webapp button to open webapp
* JS part is the WebApp with one button and reacting to chaged user theme and app viewport

## How to run

```bash
./gradlew run --args="TOKEN WEB_APP_ADDRESS"
```

gha_language: Kotlin


text:
# MMM-Sounds

This a module for the [MagicMirror](https://magicmirror.builders/).
It can play WAV sounds through your Pi when triggered by other modules.

**This can only play WAV files.**

Although this has been developed for the Raspbian operating system, any system that uses `alsa` would likely work too.

## Prerequisites
1. [Read this to configure sound output for your Raspberry Pi](https://www.raspberrypi.org/documentation/configuration/audio-config.md)
2. Make sure `alsa` is installed on your Pi: `sudo apt-get install alsa-base alsa-utils`
3. Adjust your volume output, try 100% first with: `alsamixer`
4. Optional, test your speaker output: `speaker-test -t sine -f 440 -c 2 -s 1`

## Module Installation
1. Navigate into your MagicMirror's `modules` folder and execute `git clone https://github.com/jc21/MMM-Sounds.git`
2. Execute `cd MMM-Sounds && npm install` to install the node dependencies.
3. Optional, test the alsa player with a wav file: `aplay sounds/woop-woop.wav`
4. Add config to your magic mirror config file

## Using the module

To use this module, add it to the modules array in the `config/config.js` file:

````javascript
modules: [
	{
		module: 'MMM-Sounds',
		config: {
			startupSound:   'wobble.wav',
			quietTimeStart: '23:00',      // 11pm
			quietTimeEnd:   '07:00'       // 7am
		}
	}
]
````

## Configuration options

The following properties can be configured:

			Option
			Description

			startupSound
			The sound to play after module startup

Possible values: string

Default value: null

			defaultDelay
			The default delay before playing the file in milliseconds

Possible values: integer

Default value: 10

			quietTimeStart
			The 24 hour and minute start of Quiet time

Possible values: string

Default value: null

			quietTimeEnd
			The  24 hour and minute end of Quiet time

Possible values: string

Default value: null

			debug
			Enable to display more debug messages in console

Possible values: bool

Default value: false

## Quiet Times

This module supports *not* playing sounds during a quiet time, if BOTH the `quietTimeStart` and `quietTimeEnd` config
options are specified.

The values for these times are HH:mm and must be in 24 hour format. Examples:

- `00:30` - 12:30am
- `06:30` - 6:30am
- `14:11` - 2:11pm
- `23:30` - 11:30pm

## Telling the module to play sounds from another module

From another module you can tell this module to play a sound in 2 ways:

In your module:

```javascript
this.sendNotification('PLAY_SOUND', 'wobble.wav');
```

or also specifying a delay:

```javascript
this.sendNotification('PLAY_SOUND', {sound: 'wobble.wav', delay: 1000}); // 1 second delay
```

## Included sounds

- `buzz.wav`
- `sonar.wav`
- `ta-ting.wav`
- `twip.wav`
- `wobble.wav`
- `woop-woop.wav`

## Adding sounds

Just put your WAV files in `modules/MMM-Sounds/sounds/` and reference those files in your other modules.

## Known modules that play sounds

- [MMM-IFTTT](https://github.com/jc21/MMM-IFTTT)


text:
[![Build Status](https://travis-ci.org/puppetlabs/trapperkeeper.png?branch=master)](https://travis-ci.org/puppetlabs/trapperkeeper)

Trapperkeeper is a Clojure framework for hosting long-running applications and services.  You can think of it as a sort of "binder" for Ring applications and other modular bits of Clojure code.

* [Overview](Overview.md)
 * [Credits and Origins](Overview.md#credits-and-origins)
 * [Hopes and Dreams](Overview.md#hopes-and-dreams)
* [Trapperkeeper Quick Start](Trapperkeeper-Quick-Start.md)
 * [Leiningen Template](Trapperkeeper-Quick-Start.md#lein-template)
 * [Hello World](Trapperkeeper-Quick-Start.md#hello-world)
* [Defining Services](Defining-Services.md)
 * [`defservice`](Defining-Services.md#defservice)
 * [Service Lifecycle](Defining-Services.md#service-lifecycle)
 * [Example Service](Defining-Services.md#example-service)
 * [Multi-arity Protocol Functions](Defining-Services.md#multi-arity-protocol-functions)
 * [`service`](Defining-Services.md#service)
 * [Optional Services](Defining-Services.md#optional-services)
* [Referencing Services](Referencing-Services.md)
 * [Individual Functions](Referencing-Services.md#individual-functions)
 * [A Map of Functions](Referencing-Services.md#a-map-of-functions)
 * [Plumatic Graph Binding Form](Referencing-Services.md#plumatic-graph-binding-form)
 * [Via Service Protocol](Referencing-Services.md#via-service-protocol)
* [Bootstrapping](Bootstrapping.md)
* [Built-in Services](Built-in-Services.md)
 * [Configuration Service](Built-in-Configuration-Service.md)
 * [Shutdown Service](Built-in-Shutdown-Service.md)
 * [nREPL Service](Built-in-nREPL-Service.md)
* [Error Handling](Error-Handling.md)
* [Service Interfaces](Service-Interfaces.md)
* [Command Line Arguments](Command-Line-Arguments.md)
 * [Other Ways to Boot](Command-Line-Arguments.md#other-ways-to-boot)
* [Restart File Feature for Determining When Services Have Been Started](Restart-File.md)
* [Test Utils](Test-Utils.md)
* [Trapperkeeper Best Practices](Trapperkeeper-Best-Practices.md)
 * [To Trapperkeeper Or Not To Trapperkeeper](Trapperkeeper-Best-Practices.md#to-trapperkeeper-or-not-to-trapperkeeper)
 * [Separating Logic From Service Definitions](Trapperkeeper-Best-Practices.md#separating-logic-from-service-definitions)
 * [On Lifecycles](Trapperkeeper-Best-Practices.md#on-lifecycles)
 * [Testing Services](Trapperkeeper-Best-Practices.md#testing-services)
* [Using the "Reloaded" Pattern](Reloaded-Pattern.md)
* [Experimental Plugin System](Plugin-System.md)
* [Polyglot Support](Polyglot-Support.md)
* [Helpful Leiningen Features](Helpful-Leiningen-Features.md)

repository: puppetlabs/trapperkeeper

gha_language: Clojure

repo_name: puppetlabs/trapperkeeper


text:
# Chapter 5 : Use 403 when user is not authorized

AU : Hi there.

AB : Let me guess. API problem.

AU : Yes. I'm getting error message that "Only HR team can creae a new user".

AB : Yes. That's the new policy. And you are not authorized to create a new user.

AU : In that case you should not send 422. You should send 403.

AB : C'mon. Now this is getting too much. How many special status codes you have.

AU : This is the last one.

AB : Ok. I'm listening.

AU : ***If user is not authenticated then send status code 401.***

AU : ***However if user is authenticated and user is *forbidden* then send 403.***

AU : Yes so in this case the server knows who you are. It's just that you are not authorized to access the information you are requesting.

AB : Got it. That is simple. Anyone who is forbidden will get 403.

gha_language: JavaScript


text:
## 1.0.17

* fail quietly on retryable network failures
## 1.0.16

* simplify socket management
## 1.0.15

* eliminate resource leak by closing http client when idle
* retry loading tiles on retryable errors, reduce exception noise
## 1.0.13

* expand compatibility to include latest `flutter_map` release 0.14.0
## 1.0.12

* improve place name abbreviations

## 1.0.11

* add theme version to cache key to enable theme providers to invalidate the cache
## 1.0.9

* improve label layout
* add place name abbreviations

## 1.0.7

* improve stability
## 1.0.6

* reduce unnecessary tile repaints
* add jitter to mixed mode tile repaints
## 1.0.4

* improve support for text
## 1.0.3

* eliminate occasional hairline gap between tiles
* improve tile appearance when zooming to zoom levels higher than the tile size

## 1.0.1

* use theme ID to segregate cached tiles by theme
## 1.0.0

* release
## 0.1.3

* add option for raster-only images
* add debug tile option
## 0.1.2

* image memory cache is conigurable
## 0.1.1

* reduce memory usage
* add storage-based cache
## 0.1.0

* add mixed mode rendering
## 0.0.8

* improve rendering speed with a repaint boundary
* reduce memory overhead by caching fewer tiles
## 0.0.7

* improve transition between tile sizes by rendering larger tiles while zooming smaller tiles
* improve performance by retaining some parsed vector tile data in memory
## 0.0.6

* remove debounce because it's not needed and adds jitter
## 0.0.5

* improve performance
* reduce zoom scalling oversize effect on lines such as roads
## 0.0.4

* improve line size interpolation
## 0.0.2

* support zoom levels higher than the maximum supported by
  the map tile provider.

## 0.0.1

* Initial version

repository: chuyentt/flutter-vector-map-tiles

repo_name: chuyentt/flutter-vector-map-tiles


text:
# Detect if request method is POST

```php
$is_post = $_SERVER['REQUEST_METHOD'] == 'POST';
```

- $is_post - will contain ```true``` if POST request has been made
- REQUEST_METHOD - system variable with current request type

group: request_method


text:
# robotum

Home robot

[Gateway](app/be/gateway/README.md)
[Auth](app/be/auth/README.md)
[Frontend](app/fe/README.md)
[Robot controller](robot/robotcontroller/README.md)
[Robot board](robot/robotboard/README.md)

## Code sanity

```bash
pip3 install ci/requirements.txt
ci/pylintify
ci/blackify
```

repository: hasboeuf/robotum

gha_language: Python

repo_name: hasboeuf/robotum


text:
# mobile_acuity
Mobile Acuity library for create and search.

##Dependencies

    gem 'curb'

##IMPORTANT

Because Mobile Acuity uses the `--data-binary` call in curl / http, you're not able to use `RestClient` or other gems in place of curb.


text:
# Tennis scoring app (tss) in Node.ts (TypeScript)

Testing the solution

```bash
git clone https://github.com/shawfire/tennis-scoring.git
cd tennis-scoring/tss-node-ts
npm install
npm run test
npm run tdd # During development
```

references

- [How to Set Up a TypeScript + Node.js App in 5 Minutes](https://levelup.gitconnected.com/how-to-set-up-a-typescript-node-js-app-in-5-minutes-93ffee3b1768)
- [Using Mocks for Testing in JavaScript with Sinon.js](https://stackabuse.com/using-mocks-for-testing-in-javascript-with-sinon-js/)- [How to set up a modern JavaScript project [Tutorial]](https://www.robinwieruch.de/javascript-project-setup-tutorial/)
- [The minimal Node.js with Babel Setup](https://www.robinwieruch.de/minimal-node-js-babel-setup)

repository: shawfire/tennis-scoring

repo_name: shawfire/tennis-scoring


text:
# Avatax plugin for Craft CMS 3.x

Calculate and add sales tax to an order's base tax using Avalara's AvaTax service.

## Requirements

This plugin requires Craft CMS 3.1.0 or later and Craft Commerce 2.0 or later.

> Related: The Craft 2.x Commerce 1.x [version](https://github.com/matternow/craft-avataxtaxadjuster) of this plugin is no longer actively maintained but is still supported.

## Installation

To install the plugin, follow these instructions.

1. Open your terminal and go to your Craft project:

        cd /path/to/project

2. Then tell Composer to load the plugin:

        composer require matternow/craft-avatax

3. In the Control Panel, go to Settings → Plugins and click the “Install” button for Avatax.

## Setup Overview

Setup and configuration is detailed below, but here's a quick overview of what you'll need to do get started:

1. Configure the plugin settings with your Avalara account info and test the connection.
2. Configure the plugin settings with your origin address and default tax codes.
3. Set the "Avatax" tax category to be available to your product types.
4. Assign the "Avatax" tax category to your products.
4. Optionally add the product-specfic tax code field to your Product Type fields to allow per-product tax codes.
5. Optionally add the customer usage type field to your User fields to set up tax-exempt customers.

## Configuring AvaTax Account Connection

1. Visit the settings page at Settings → Avatax
2. Enter your the Account ID, License Key, and Company code credentials for each environment.
3. Selecting *Sandbox* or *Production* will enable the chosen environment.
4. Click the *Test Connection* button to verify your connection.
5. Click the *Save* button to save your settings.

![Account Settings](resources/img/plugin-settings.png)

## Configuring AvaTax Ship From Origin

1. Specify a valid origin address to ship from.
2. Click the *Save* button to save your settings.

![Origin](resources/img/plugin-origin.png)

## Configuring AvaTax Plugin Options

1. Visit the settings page at Settings → Avatax
2. *Tax Calculation Enabled* - enable or disable tax calculation independantly of other settings.
3. *Committing Enabled* - enable or disable document committing.
4. *Address Validation Enabled* - enable or disable Avalara's address verification.
5. *Debugging enabled* - while setting up and testing enable debugging to log all API interactions. Be sure to disable once live.
6. Click the *Save* button to save your settings.

![Plugin Options](resources/img/plugin-options.png)

## Using AvaTax

1. Visit Commerce → Settings → Tax Categories. A tax category with the handle "avatax" should exist, if not, create one.

	![Product Tax Categories](resources/img/tax-categories.png)

2. Click the Avatax Tax Category. Check the product type(s) the Avalara Tax Rates will be available to.

	![Avatax Tax Category Settings](resources/img/tax-category-settings.png)

After completing the installation and configuration, AvaTax will calculate and apply sales tax to all orders with a valid shipping address for products with the Avatax tax category selected.

![Avatax Tax Category Settings](resources/img/product-category.png)

## Tax Codes

*E.g. 'P0000000' - Tangible personal property (TPP)*.

You can set the default [Avalara Tax Code](https://taxcode.avatax.avalara.com/) by setting the Default Tax Code value in the plugin settings. This is the default tax code that will get sent to Avalara for all products.

![Defaults](resources/img/plugin-defaults.png)

You can also set a specific Tax Code for each product by adding a custom field to your Products.

#### To set up the product field:

1. Visit Settings → Fields. You should see a field named "AvaTax Tax Code" that was created during plugin installation. If not create, one. Note that the field "Name" can be anything you'd like, e.g. "AvaTax Tax Code" or "Product Tax Code", but the field "Handle" must match `avataxTaxCode` and is case sensitive.
2. Visit Commerce → Settings → Product Types and click the name of your Product Type.
2. Click the *Product Fields* tab.
3. Add the AvaTax Tax Code field and save.

![Fields](resources/img/plugin-fields.png)

In your product entries you can now enter any text to send along as the AvaTax Tax Code. If this field does not exist or is left empty the default tax code setting in your config file will be used.

![Product Field](resources/img/product-field.png)

> Hint: By default the field is plain text, but you could change it to a dropdown with pre-configured values for your use case as long as the handle stays the same.

## Shipping Codes

*E.g. 'FR' - Shipping Only - common carrier - FOB destination.*

Shipping charges are sent as a separate line item to AvaTax. You can set your default [Avalara Tax Code](https://taxcode.avatax.avalara.com/) for shipping charges by setting the Default Shipping Code in the plugin settings.

![Defaults](resources/img/plugin-defaults.png)

## Tax-Exempt Customers

You can specify a customer to be exempt from tax by adding a custom field to your User settings which is used to specify an [Avalara Entity/Use Code](https://help.avalara.com/000_Avalara_AvaTax/Exemption_Reason_Matrices_for_US_and_Canada).

#### To set up the User field:

1. Visit Settings → Fields. You should see a field named "AvaTax Customer Usage Type" that was created during plugin installation. If not create, one. Note that the field "Name" can be anything you'd like, e.g. "AvaTax Customer Usage Type" or "Entity/Use Code", but the field "Handle" must match `avataxCustomerUsageType` and is case sensitive.
2. Visit Settings → Users → Fields.
3. Add the AvaTax Customer Usage Type field and save.

![Fields](resources/img/plugin-fields.png)

In your User accounts you can now set an Entity/Use Code to send to Avalara. It is up to you how you implement this for your users if you allow them to edit their own profiles on the front-end, but this will most likely remain an administrative task in most cases.

This necessarily requires a registered User to be logged in during checkout, not guest checkouts.

![Dropdown](resources/img/user-field.png)

> Hint: By default this dropdown field contains all the default Avalara Entity/Use Codes but you can edit the options to customize for own use case or if you’ve set up custom codes via the AvaTax website.

## Promotions

Promotions are supported. For Sales, the sale price is simply sent to Alavara as the Line Item amount. Discounts are sent as a separate line item using the *Default Discount Code* plugin setting as the Avalara Tax Code.

## Refunds

Craft Commerce supports refunds for completed transactions if the [payment gateway](https://craftcommerce.com/support/which-payment-gateways-do-you-support) supports refunds. If refunds are supported for an order Commerce displays a "Refund" button in the order’s Transaction history.

As of Commerce 2.0 partial refunds can be initiated multiple times from the admin control panel. Triggering a full refund for the exact amount of the original order will issue a new Return Invoice for full amount of the corresponding AvaTax transaction. Be aware that triggering a partial refund will issue a new Return Invoice for the partial amount to the corresponding AvaTax *customer* but is not tied to the original transaction. This is because AvaTax only issues refunds on a transaction in full, for specific line items, or as a percentage.

## Config Overrides

You can use Craft's [plugin config file](https://docs.craftcms.com/v3/extend/plugin-settings.html#overriding-setting-values) support to override many of the plugin settings in the control panel. This is handy to "lock down" certain settings, and also to provide [per-environment settings](https://docs.craftcms.com/v3/config/environments.html#config-files).

1. Copy `config.php` from the `avataxtax` directory to your craft/config folder and rename it to `avatax.php`
2. Update values in `avatax.php` and save.

## AvaTax Plugin Roadmap

Some things to do, and ideas for potential features:

* Config settings for default tax codes at the Product Type level.

---

Brought to you by [Matter Communications](http://matternow.com)

repository: matternow/craft-avatax

gha_language: PHP

repo_name: matternow/craft-avatax


text:
# grunt-html-html-reporter

[![NPM version](https://badge.fury.io/js/grunt-html-html-reporter.png)](http://badge.fury.io/js/grunt-html-html-reporter) [![Build Status](https://travis-ci.org/prantlf/grunt-html-html-reporter.svg?branch=master)](https://travis-ci.org/prantlf/grunt-html-html-reporter) [![Dependency Status](https://david-dm.org/prantlf/grunt-html-html-reporter.svg)](https://david-dm.org/prantlf/grunt-html-html-reporter) [![devDependency Status](https://david-dm.org/prantlf/grunt-html-html-reporter/dev-status.svg)](https://david-dm.org/prantlf/grunt-html-html-reporter#info=devDependencies) [![Greenkeeper badge](https://badges.greenkeeper.io/prantlf/grunt-html-html-reporter.svg)](https://greenkeeper.io/) [![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079.svg)](https://github.com/semantic-release/semantic-release)

[![NPM Downloads](https://nodei.co/npm/grunt-html-html-reporter.png?downloads=true&stars=true)](https://www.npmjs.com/package/grunt-html-html-reporter)

A custom reporter for [grunt-html] - the HTML validation task - which formats the validation results to HTML. There is a [Grunt] task available for converting already written report files, which uses this reporter - [grunt-html-html-report-converter].

## Installation

You can use the reporter programmatically. In that case you do not need [Grunt] as stated below. You can also use the reporter directly with the [grunt-html] task. The reporter is usually installed and used together with other development tasks.

You need [node >= 4][node], [npm] and [grunt >= 0.4][Grunt] installed and your project build managed by a [Gruntfile] with the necessary modules listed in [package.json], including [grunt-html]. If you haven't used Grunt before, be sure to check out the [Getting Started] guide, as it explains how to create a Gruntfile as well as install and use Grunt plugins. Once you're familiar with that process, you may install this plugin with this command:

```sh
$ npm install grunt-html-html-reporter --save-dev
```

## Programmatic Usage

You can use the reporter programmatically to process accessibility results as an object in JavaScript. For example, for converting a JSON report file to a HTML report file:

```js
const report = require('grunt-html-html-reporter')
const input = fs.readFileSync('report.json', 'utf-8')
const results = JSON.parse(input)
const output = report(results)
fs.writeFileSync('report.html', output, 'utf-8')
```

## Usage with grunt-html

The value of the [`reporter`] property of the [`htmllint`] task has to be a path to this module, relative to the `Gruntfile.js`, in which the task is used:

```js
htmllint: {
  options: {
    errorlevels: ['error', 'warning', 'info'],
    reporter: './node_modules/grunt-html-html-reporter',
    reporterOutput: 'output/report.html',
  },
  all: {
    src: ['input/*.html']
  }
}
```

## Contributing

In lieu of a formal styleguide, take care to maintain the existing coding style.

## Release History

 * 2018-01-27   v0.2.2   Do not report unknown messqge types as notices
 * 2017-11-25   v0.2.1   Support Node.js < 7
 * 2017-11-24   v0.2.0   Fix recognition of warnings,
                         say "notices" instead of "notes"
 * 2017-11-24   v0.0.1   Initial release

## License

Copyright (c) 2017-2018 Ferdinand Prantl

Licensed under the MIT license.

[node]: http://nodejs.org
[npm]: http://npmjs.org
[package.json]: https://docs.npmjs.com/files/package.json
[Grunt]: https://gruntjs.com
[Gruntfile]: http://gruntjs.com/sample-gruntfile
[Getting Gtarted]: https://github.com/gruntjs/grunt/wiki/Getting-started
[grunt-html]: https://github.com/jzaefferer/grunt-html
[`reporter`]: https://github.com/jzaefferer/grunt-html#reporter
[`htmllint`]: https://github.com/jzaefferer/grunt-html#getting-started
[grunt-html-html-report-converter]: https://github.com/prantlf/grunt-html-html-report-converter


text:
# flux

## Overview

Flux is an imperative programing language that compiles to *executable
packet flows.* The intent is to allow the network behavior of an application
to be programmatically encoded without dealing with the application-layer
details. The ultimate goal is to enable better experimentation of CCN-based
applications, forwarders, and (forwarding, caching, etc.) strategies.

## Development

Inspired by the following tutorial:

[http://www.stephendiehl.com/llvm/#chapter-2-parser-and-ast](http://www.stephendiehl.com/llvm/#chapter-2-parser-and-ast)

## Workflow

Flux compiles to instrumented ccnx-pktpusher files -- what are called programmable
packets. The details of these instrumented files can be found in the ccnx-pktpusher
project.

## Language Sketches

### (1) flux DSL to specify flows

- specify constants for keys, certificates, etc. (key chains, names of keys, etc.)
- command to send interest (and specify return content size)
- general control flow commands (loops, conditions)

key k1 = RSA("root", 1024, nil)
key k2 = RSA("child", 1024, k1)

// TODO

flow flowOneName(link l) {
    while true {
        // send and receive explicit
        receive(l, "/name/of/interest", nil)
        asyncSend(l, "/name/of/interest", nil)

        // block send
        send(l, "/name/of/interest", nil)

        // delays
        uniformWait(0.05)
        expWait(0.05)
    }
}

link l1 = Link(/prefix/)
flowOneName(l1)

delay = exp(100) // uniform(100) (other distributions here)
scheduleWithRepeat(flowOneName, l1, delay)
schedule(flowOneName, l1, delay)

repository: chris-wood/flux

repo_name: chris-wood/flux


text:
# Fitness Tracker [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

## Table of Contents
* [Description](#description)
    * [Deployed Application](#deployed-application)
* [Installation](#installation)
* [Usage](#usage)
* [License](#license)
* [Contributing](#contributing)
* [Tests](#tests)
* [Acknowledgments](#acknowledgments)
* [Questions](#questions)

## Description
This application is a fitness tracker. It tracks a user's workouts using a MongoDB noSQL database. On startup, the application shows the user's most recent workout. Users are able to add exercises to their last workout, or begin a new workout. The applicaiton also has a dashboard which shows the users last seven workouts.

### Deployed Application

## Installation

Clone the repository: "git@github.com:aubrey-heim/workout-tracker.git"

Install the dependencies using “npm i” in the terminal

Seed your database using "npm run seed"

Start the application using "npm start"

## Usage
To use this project visit: https://morning-tor-15408.herokuapp.com/

## License
This repository has a MIT license. For more information on this license, please visit: https://choosealicense.com/licenses/mit

## Contributing
Contributions to this project are welcome!

Fork the Project

Create a branch for your feature (git checkout -b feature/featureName)

Commit your changes (git commit -m'Your commit message')

Push your changes to the feature branch (git push origin feature/featureName)

Open a pull request

Also feel free to open issues for the project.

## Tests
There are no tests to run for this project

## Acknowledgments
Front-end code provided by the UW Full-Stack Web Development Bootcamp: https://uwa.bootcampcontent.com/UWA-Bootcamp/uw-sea-fsf-pt-08-2020-u-c

## Questions
If you have any questions, please contact Aubrey Heim.

GitHub: [aubrey-heim](https://github.com/aubrey-heim)

Email: [aubrey.l.heim<EMAIL_ADDRESS>

repository: aubrey-rigby/workout-tracker

repo_name: aubrey-rigby/workout-tracker


text:
Easy3D - webGL
----------
Yet another JS 3D/game engine test

Trying out webGL, transfering most of my old Delphi and C# OpenGL game engine structure in webGL

Current project state is available for testing [here](https://m4nusky.com/projects/Easy3D_webGL/) (updated ~~every 24h~~ sometimes).

### /ver5
- [ver5demo1.html](https://m4nusky.com/projects/Easy3D_webGL/ver5demo1.html) basic test page, skeleton html, auto-setup
- [ver5demo2.html](https://m4nusky.com/projects/Easy3D_webGL/ver5demo2.html) test page with dedicated target div, auto-setup
- [ver5demo3.html](https://m4nusky.com/projects/Easy3D_webGL/ver5demo3.html) demo for full screen and/or pointer lock
- [ver5demo4.html](https://m4nusky.com/projects/Easy3D_webGL/ver5demo4.html) primitive mesh generation with random parameters
- [ver5demo5.html](https://m4nusky.com/projects/Easy3D_webGL/ver5demo5.html) various basic GLSL shaders demo
### current WIP
- [ver5demo6.html](https://m4nusky.com/projects/Easy3D_webGL/ver5demo6.html) animator demo (Direct, Transform, Physics, Particules)

### /ver4:
- [ver4.html](https://m4nusky.com/projects/Easy3D_webGL/ver4/ver4.hmtl): Works with mouse/keyboard in desktop browser, touch controls for mobile.
- [ver4cellshader.html](https://m4nusky.com/projects/Easy3D_webGL/ver4/ver4cellshader.html): toon/cell shading render demo
- [ver4fullscreen.html](https://m4nusky.com/projects/Easy3D_webGL/ver4/ver4fullscreen.html): pointer lock, full screen demo
- [ver4stl.html](https://m4nusky.com/projects/Easy3D_webGL/ver4/ver4stl.html): binary STL loader/viewer app
- [ver4physic.html](https://m4nusky.com/projects/Easy3D_webGL/ver4/ver4physic.html): Collision Detection and Physics demo
- [ver4maze.html](https://m4nusky.com/projects/Easy3D_webGL/ver4/ver4maze.html): Ball in Maze game, game loop and logic, pseudo-random maze generator.

### Random project that uses the testing framework and game loop
- [Memory.html](https://m4nusky.com/Memory/Memory.html): Remake of the classic "Simon" memory game. With color position shuffle!
- [ver5prop1.html](https://m4nusky.com/projects/Easy3D_webGL/ver5prop1.html): Parametric Propeller Generator Tool for aircraft that can export to ASCII STL. Using the Clark-Y profile.

### Folders
- /Electron: content specific for Electron app (STL viewer, like MS Photo or Image Viewer but for 3D stl files)
- /Images: icons / sprites / images resources
- /Models: Mesh and object data
- /Tests:
    - [performance test](https://m4nusky.com/projects/Easy3D_webGL/tests/test1.html) for JS
    - [JS gl-matrix vs WebGL sahders](https://m4nusky.com/projects/Easy3D_webGL/tests/testMat.html)
    - [WebGL](https://m4nusky.com/projects/Easy3D_webGL/Tests/testMatShader.html)
    - [CSS fullscreen flex layout](https://m4nusky.com/projects/Easy3D_webGL/Tests/testLayout3.html)
    - [Oklab Color Space](https://m4nusky.com/projects/Easy3D_webGL/Tests/testColors.html)
- /ver0: WebGL [tutorial](https://m4nusky.com/projects/Easy3D_webGL/ver0/tuto1.html) transcript and tests, controls abstraction and [demo](https://m4nusky.com/projects/Easy3D_webGL/ver0/tuto2.html)
- /[ver3](https://m4nusky.com/projects/Easy3D_webGL/ver3/ver3.html): basic engine contorls, model loading

Current work-in-progress and next steps
----------
### --ver5:
- flatten engine to reduce nested objects/structures depth (objects of arrays of objects of arrays)
- extract all "DEV" stuff to a debug class
- loader for all the required scripts
    - script list
    - data-main and data-fail tag in html page
    - fallback on error
- collision detection and physics
    - fix jitter due to gravity
    - Static-vs-Dynamic tests
    - culling
    - test progressive approximation instead of interpolation
    - Basic Physics (bounce, slide, stick) as body data attached to entity
    - Improved Physics (mass, moment of rotation etc)
- optimizations
    - new nlogn(O) algorithm instead of (O)n^2 for unique vertex search
    - new algorithm for edge finding and stroke generation
- textures
    - convert all mesh, loader, generators, to textures and convert colors to LUT-colors
    - convert all shader and scenes to LUT colors and textures
- Regroup vertexArrays for mesh data in an interleaved array
    - in scene renderer
    - in entity
    - in loader
- Sprites (always facing viewer, shader with minimal inputs)
- Text render in 3D scene
    - in world as entity
    - world-to-viewport as sprite
- Evaluate value of render culling on mobile
    - Z position
    - frustum
- Coordinate conversion
    - World to screen
    - Screen to world

### --ver6
- Other type of physics mechanic for controls. (chase camera/3rd person with spring and hit test)
- Improved Collision Detection with dual Interpolation (point, edge, sphere, plane, box, triangles)
- Evaluate quaternions
- Animations
    - Transform animations with state list and transitions (linear, sharp, dull)
    - Path interpolation animator for bots and animations
- Better lights shaders (array of different types of ligts) (spot, point etc)
- UI / HUD
- NetCode
- Improved Entity loading
    - external tool should prepare model data for better load perf
        - generate solid body data (primitives), mesh cleanup
        - remove duplicate solid body data, edges in creases
        - generate detail levels, sprites, binary (Bake)
    - STL, OBJ, MS3D to binary or other ready-to-use format
    - entities property format (JSON/YAML)
        - detail levels, binary type, solid body data, textures, references, scale, offset position
- Sounds
- Some kind of game:
    - Tetris ?
    - 3D Asteroid ?
    - 3D bullet hell ?
    - space war ?
    - dogfighter ?
    - horde/tower defence ?

### --ver7:
- Basic AI
    - ScripterSequence (source engine style)
    - Pathfinding
- 3D cube tree or AABB Collision target culling
- CD bodies nesting
    - single for simpl
    - array of for complex
    - interaction modes between bodies
- Entity hierarchy
    - parents with n-childs
    - matrix propagation
- Mesh hierarchy
    - vertex bind node
    - vertex weight
    - keyframe anim and interpolation
- shaders
    - update to leverage GPU matrix multiplication efficiency instead of JS engine
    - test render to texture in multiple passes for 1 final light pass (Nanite style!)

Overview of collistion detection possibilities and implementation difficulty
-----------

| Entity Type   | Vertor  | Sphere | Plane | Cube | Traingle Mesh |
|:------------- |:-------:|:------:|:-----:|:----:|:-------------:|
| Vector        | useless |  Easy  | Easy  |  ok  |  hmm |
| Sphere        |         |  Easy  |  ok   |  hmm | nope |
| Plane         |         |        |  useless | wtf | nope |
| Cube          |         |        |       | not easy | nope |
| Triangle Mesh |         |        |       |       | NOPE |

Evaluations of CD and physics
-----------
* [old] Eager: test and adjust all CD for each collisions, single pass
* Shortest: test and keep only shortest hit of each source
* Average: test and note all collisions, result is average of all adjustments
* Incremental: test (eager) multiple time along path of CD solids instead of shape interpolation
* [Current] Shortest multi-pass: test all then adjust for shortest hit, mark as done, re-test for next hits n-times or until no more hits
* Progressive: Find shortest collision time, adjust all for time, recalc next pass until time reach 1 or maximum passes

Interpolations
-----------
* Point : vector
* Edge : plane
* Sphere : capsule
* Plane : box
* Box : box

-M4nuski


text:
---
########### THIS FILE IS AUTO GENERATED - ANY CHANGES WILL BE VOID ###########
title: allblocks
description: OpenBB Discord Command
---

# allblocks

The command allows the user to retrieve the last 15 block trades of a given security. This command will provide a summary of the last 15 block trades, including the time, price, quantity, and total gross value of each trade.

### Usage

```python wordwrap
/dp allblocks ticker
```

---

## Parameters

| Name | Description | Optional | Choices |
| ---- | ----------- | -------- | ------- |
| ticker | Stock Ticker | False | None |

---

## Examples

```
/dp topsum
```

---

repository: conrad-strughold/GamestonkTerminal

repo_name: conrad-strughold/GamestonkTerminal


text:
# Keras implementation of a pix2pix GAN for image-to-image translation

This repository provides a keras implementation of a [pix2pix](https://arxiv.org/abs/1611.07004) and tests it by performing image-to-image translation on publicly available data.

## Corresponding blog post:

The results presented in this repository are explained in detail in this [blog post](https://nchlis.github.io/2019_11_22/page.html).

## Available models:

Only the trained keras model for the downsized GAN is available in the repo, since the rest of the models exceed the maximum size (100MB) GitHub allows for a single file.


text:
# [DDE Problems](@id dde_prob)

## Mathematical Specification of a DDE Problem

To define a DDE Problem, you simply need to give the function ``f``, the initial
condition ``u_0`` at time point ``t_0``, and the history function ``h``
which together define a DDE:

```math
\frac{du}{dt} = f(u,h,p,t) \qquad & (t \geq t_0)
```
```math
u(t_0) = u_0,
```
```math
u(t) = h(t) \qquad &(t < t_0).
```

``f`` should be specified as `f(u, h, p, t)` (or in-place as `f(du, u, h, p, t)`),
``u_0`` should be an AbstractArray (or number) whose geometry matches the
desired geometry of `u`, and ``h`` should be specified as described below. The
history function `h` is accessed for all delayed values. Note that we are not
limited to numbers or vectors for ``u_0``; one is allowed to provide ``u_0``
as arbitrary matrices / higher dimension tensors as well.

## Functional Forms of the History Function

The history function `h` can be called in the following ways:

- `h(p, t)`: out-of-place calculation
- `h(out, p, t)`: in-place calculation
- `h(p, t, deriv::Type{Val{i}})`: out-of-place calculation of the `i`th derivative
- `h(out, p, t, deriv::Type{Val{i}})`: in-place calculation of the `i`th derivative
- `h(args...; idxs)`: calculation of `h(args...)` for indices `idxs`

Note that a dispatch for the supplied history function of matching form is required
for whichever function forms are used in the user derivative function `f`.

## Declaring Lags

Lags are declared separately from their use. One can use any lag by simply using
the interpolant of `h` at that point. However, one should use caution in order
to achieve the best accuracy. When lags are declared, the solvers can more
efficiently be more accurate and thus this is recommended.

## Problem Type

### Constructors

```
DDEProblem(f[, u0], h, tspan[, p]; <keyword arguments>)
DDEProblem{isinplace}(f[, u0], h, tspan[, p]; <keyword arguments>)
```

Parameter `isinplace` optionally sets whether the function is inplace or not.
This is determined automatically, but not inferred.

Parameters are optional, and if not given then a `NullParameters()` singleton
will be used which will throw nice errors if you try to index non-existent
parameters. Any extra keyword arguments are passed on to the solvers. For example,
if you set a `callback` in the problem, then that `callback` will be added in
every solve call.

For specifying Jacobians and mass matrices, see the [DiffEqFunctions](@ref performance_overloads) page.

### Arguments

* `f`: The function in the DDE.
* `u0`: The initial condition. Defaults to the value `h(p, first(tspan))` of the history function evaluated at the initial time point.
* `h`: The history function for the DDE before `t0`.
* `tspan`: The timespan for the problem.
* `p`: The parameters with which function `f` is called. Defaults to `NullParameters`.
* `constant_lags`: A collection of constant lags used by the history function `h`. Defaults to `()`.
* `dependent_lags` A tuple of functions `(u, p, t) -> lag` for the state-dependent lags
  used by the history function `h`. Defaults to `()`.
* `neutral`: If the DDE is neutral, i.e., if delays appear in derivative terms.
* `order_discontinuity_t0`: The order of the discontinuity at the initial time point. Defaults to `0` if an initial condition `u0` is provided. Otherwise it is forced to be greater or equal than `1`.
* `kwargs`: The keyword arguments passed onto the solves.

## Example Problems

Example problems can be found in [DiffEqProblemLibrary.jl](https://github.com/JuliaDiffEq/DiffEqProblemLibrary.jl/tree/master/src/dde).

To use a sample problem, such as `prob_ode_linear`, you can do something like:

```julia
#] add DiffEqProblemLibrary
using DiffEqProblemLibrary.ODEProblemLibrary
# load problems
ODEProblemLibrary.importodeproblems()
prob = ODEProblemLibrary.prob_ode_linear
sol = solve(prob)
```

### DDEs with 1 constant delay

```@meta
CurrentModule = DDEProblemLibrary
```

```@docs
prob_dde_constant_1delay_ip
prob_dde_constant_1delay_oop
prob_dde_constant_1delay_scalar
prob_dde_constant_1delay_long_ip
prob_dde_constant_1delay_long_oop
prob_dde_constant_1delay_long_scalar
```

### DDEs with 2 constant delays

```@docs
prob_dde_constant_2delays_ip
prob_dde_constant_2delays_oop
prob_dde_constant_2delays_scalar
prob_dde_constant_2delays_long_ip
prob_dde_constant_2delays_long_oop
prob_dde_constant_2delays_long_scalar
```

### DDETest Problems

Some details:

```
# DDEs with time dependent delays
prob_dde_DDETST_A1, prob_dde_DDETST_A2,
# DDEs with vanishing time dependent delays
prob_dde_DDETST_B1, prob_dde_DDETST_B2,
# DDEs with state dependent delays
prob_dde_DDETST_C1, prob_dde_DDETST_C2, prob_dde_DDETST_C3, prob_dde_DDETST_C4,
# DDEs with vanishing state dependent delays
prob_dde_DDETST_D1, prob_dde_DDETST_D2,
# neutral DDEs with time dependent delays
prob_dde_DDETST_E1, prob_dde_DDETST_E2,
# neutral DDEs with vanishing time dependent delays
prob_dde_DDETST_F1, prob_dde_DDETST_F2, prob_dde_DDETST_F3, prob_dde_DDETST_F4, prob_dde_DDETST_F5,
# neutral DDEs with state dependent delays
prob_dde_DDETST_G1, prob_dde_DDETST_G2,
# neutral DDEs with vanishing state dependent delays
prob_dde_DDETST_H1, prob_dde_DDETST_H2, prob_dde_DDETST_H3, prob_dde_DDETST_H4
```

```@docs
prob_dde_DDETST_A1
prob_dde_DDETST_A2
prob_dde_DDETST_B1
prob_dde_DDETST_B2
prob_dde_DDETST_C1
prob_dde_DDETST_C2
prob_dde_DDETST_C3
prob_dde_DDETST_C4
prob_dde_DDETST_D1
prob_dde_DDETST_D2
prob_dde_DDETST_E1
prob_dde_DDETST_E2
prob_dde_DDETST_F1
prob_dde_DDETST_F2
prob_dde_DDETST_F3
prob_dde_DDETST_F4
prob_dde_DDETST_F5
prob_dde_DDETST_G1
prob_dde_DDETST_G2
prob_dde_DDETST_H1
prob_dde_DDETST_H2
prob_dde_DDETST_H3
prob_dde_DDETST_H4
```

### Radar5 Test Problems

```@docs
prob_dde_RADAR5_oregonator
prob_dde_RADAR5_robertson
prob_dde_RADAR5_waltman
```

### QS Example

```@docs
prob_dde_qs
```

gha_license_id: NOASSERTION


text:
# DndCharacterGenerator

Browser based DnD Character Generator. Built with Javascript, leveraging React and Redux.

![Screenshot](/docs/Generator.png)

## Getting Started

### Prerequisites

NPM (Node Package Manager) is the only hard requirement, and is used to manage the other dependencies (which may be viewed under package.json).

### Installing

Once NPM is installed, you can install the dependencies from the project directory with the command:

```
npm install
```

## Running the tests

The project uses Jest as a unit test runner. You can run the tests from the project directory using an npm script:

```
npm test
```

When evoked, Jest will display options for running unit tests.

## Deployment

Deploying to a test/localhost environment is done via an npm script:

```
npm start
```

## Contributing

Feel free to submit a pull request! We have many ideas for where this simple project may go, and would love contributors.

## Authors

- David Gordon - *Initial designs and implementation*

## License

This project is licensed under the MIT License

repository: gordon-david/DndCharacterGenerator

repo_name: gordon-david/DndCharacterGenerator


text:
---
title: Find duplicated Vim key-maps
date: 2019-02-10T18:14:10-08:00
---
Vim is not a typed language and it allows keymapping multiple handlers onto the same key, which sometimes leads to unexpected behavior. Here's a simple way to find conflicts.

`:verbose imap <search your key here>`

Here's what I got, it greps all the keymaps from plugins too, which is pretty helpful.

```
i  (           * coc#_insert_key('request', 'iKA==0')
i  (<CR>       * (<CR>)<C-O>O
        Last set from ~/.config/nvim/init.vim line 76
Press ENTER or type command to continue
```

repository: neilitalia/blog-fork

repo_name: neilitalia/blog-fork


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

# rdatasets

<!-- badges: start -->

[![R build
status](https://github.com/jolars/rdatasets/workflows/R-CMD-check/badge.svg)](https://github.com/jolars/rdatasets/actions)
<!-- badges: end -->

A range of datasets for use in R.

## Installation

You can install the package from [GitHub](https://github.com/) with:

``` r
devtools::install_github("jolars/rdatasets")
```

repository: jolars/rdatasets

repo_name: jolars/rdatasets


text:
## Why Composite Design Pattern
* Tight coupling of the data structure and functionality imdepedes extensability. Composite Pattern helps in loose coupling.
* For instance, in  a tree with differenet types of nodes (operator and operand in an expression tree), it might be difficult to add new type of node if the
  data structure is tightly coupled with the functionality.
* Will be useful to represent has-a or part-whole hierarchies where both the part and whole are represented uniformly.

## Intent
* Treat individual objects and multiple recursively composable objects uniformly.

## Applicability

Example hierarchy:

## Consequences
* Uniformity: E.g., we can iterate through the tree without knowing the internal structure.

* Extensibility

* Parsimony

## References
* [YT Video](https://www.youtube.com/watch?v=2HUnoKyC9l0&index=18&list=PLF206E906175C7E07)
* [SafariOnline](https://www.safaribooksonline.com/library/view/design-patterns-in/9780133489989/5_2.html)

repository: spinaki/design-patterns

repo_name: spinaki/design-patterns


text:
# DVR DHCPDiscover (multiple CCTV products) UDP-MIB

## Port: 37810

## Proto: UDP

## Amplification factor: ~9x

## Reflector count: ~315,000 (Dec 2019 - Going up since last scan)

---

Multiple DVR/XVR/NVR products implement multiple UDP ports for different SNMP-like protocols.
37810 (this finding) is specifically for IP Search and DHCP Discovery JSON.
37777 is the default port for remote connections, etc.

### Example Request / Response

- Request: 62 bytes

  - > ~# echo -ne '\x20\x00\x00\x00\x44\x48\x49\x50\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x7b\x22\x6d\x65\x74\x68\x6f\x64\x22\x3a\x22\x44\x48\x44\x69\x73\x63\x6f\x76\x65\x72\x2e\x73\x65\x61\x72\x63\x68\x22\x7d'|nc -u <IP_ADDRESS> 37810

- Response: 759 bytes

  - `DHIP▒▒{"mac":"58:10:8c:4d:3b:fa","method":"client.notifyDevInfo","params":{"deviceInfo":{"AlarmInputChannels":0,"AlarmOutputChannels":0,"DeviceClass":"MHDX","DeviceType":"MHDX 1016","HttpPort":1101,"IPv4Address":{"DefaultGateway":"<IP_ADDRESS>","DhcpEnable":false,"IPAddress":"<IP_ADDRESS>","SubnetMask":"<IP_ADDRESS>"},"IPv6Address":{"DefaultGateway":"fe80::1272:23ff:fe4c:1d5a","DhcpEnable":true,"IPAddress":"2804:7f4:5380:8bc5:5810:8cff:fe4d:3bfa\/64","LinkLocalAddress":"fe80::5a10:8cff:fe4d:3bfa\/64"},"MachineName":"KELVIN","Manufacturer":"Intelbras","Port":1102,"RemoteVideoInputChannels":2,"SerialNo":"O9RF220012635","Vendor":"Intelbras","Version":"3.210.IB01.3","VideoInputChannels":16,"VideoOutputChannels":0}}}`

### Documentation

- <https://ipvm.com/reports/dahua-oem> (OEM Listing and article about US bans)
- <https://community.boschsecurity.com/t5/Security-Video/What-Ports-need-to-be-open-for-LAN-and-WAN-Access-for-Divar-AN/ta-p/536> (Ports)
- <https://www.dahuasecurity.com/?us> (A large number of responders are this manufacturer)
- <https://www.hybrid-analysis.com/sample/0a6d12fc58871c387c2e322b099a545b981a91f6719c5251adf6a79c4bd851b7?environmentId=120> (Potential Dahua windows client analysis)

### Mitigations

- Stop allowing Internet access, restrict to LAN as default configuration (vendor issue)!
- Similar to WSD SOAP Discovery Queries
- <https://www.csoonline.com/article/3089298/iot-botnet-25-513-cctv-cameras-used-in-crushing-ddos-attacks.html>

url: https://raw.githubusercontent.com/mikust/AMP-Research/81a3a95842616e5f6f498b8df1e04a5383ace7b5/DVR IP Camera port 37810/README.md

repository: mikust/AMP-Research

path: /DVR IP Camera port 37810/README.md

repo_name: mikust/AMP-Research


text:
---
title: "Before Trump Takes Office"
displayTitle: "Before Trump Takes Office"
date: 2017-01-16 15:54:00
excerpt: "A description of the high-water mark before Trump takes office."
metaDescription:
  "A description of the high-water mark before Trump takes office."
metaKeywords: politics, trump
image: /static/images/2017-01-16-before-trump.jpg
metaImage: /static/images/2017-01-16-before-trump.jpg
metaOgType: "article"
author: "0xADADA"
license: cc-by-nc-sa
tags: [essays]
---

<figure>
  <img src="/static/images/2017-01-16-before-trump.jpg"
    alt="Trump" title="Trump">
</figure>

Before Trump takes office, I want to create a picture of the high-water mark,
something I can point to and say "That was how it was" without the fog of time,
or the distortions of propaganda and ideology. I was inspired by Sarah Kendzior:

> Fellow Americans, I have a favor to ask you. Today is November 18, 2016. I
> want you to write about who you are, what you have experienced, and what you
> have endured. Write down what you value; what standards you hold for yourself
> and for others. Write about your dreams for the future and your hopes for your
> children. Write about the struggle of your ancestors and how the hardship they
> overcame shaped the person you are today. Write your biography, write down
> your memories. Because if you do not do it now, you may forget. Write a list
> of things you would never do. Because it is possible that in the next year,
> you will do them. Write a list of things you would never believe. Because it
> is possible that in the next year, you will either believe them or be forced
> to say you believe them.[^1]
>
> ‒Sarah Kendzior

## The Spectacle of 2016

The 2016 election was a farce and a tipping point where politics have finally
become an extension of what Guy Debord called "The
Spectacle"[^2]. Both "viable" candidates offered the same neoliberal flavor of
poison. It was a false choice between "Coke vs Pepsi."

Clinton campaigned on a platform powered by a misplaced faith[^3] in Big
Data[^4]. She spoke in a language of clinical rhetoric to nobody except Wall Street. She was a status quo
candidate that lacked vision, offering nothing except a hedge against the
fascism of Trump. Her speeches were empty, dispassionate and simply disengaged
from reality. Her campaign and the DNC were corrupt from the start, and they
didn't try to hide it.

In my view, Trump is an angsty teenager who uses knee-jerk reactions and emotion
to speak to those disgusted, disenfranchised, and ignored by the
[Washington Consensus](https://en.wikipedia.org/wiki/Washington_Consensus). The
Republican party nearly destroyed itself by failing to field a status quo
candidate from their own ranks. This opened a gap which Trump was able to fill
by speaking directly to the middle class fear of sliding into the lower classes.
This fear has been stoked by mainstream media after the economic crisis that
started in 2008 and has continued up to today.

The candidates lie, and we know they're lying, and they know we know they're
lying. It doesn't matter because there is
[no longer an alternative vision for the future](https://en.wikipedia.org/wiki/End_of_history)
and there is no longer any accountability for those in power.

If one thing is clear from this election, it is the contradictions inherent in
the policies that Trump wishes to enact, as well as the contradictions inherent
in Neoliberal Capitalism:

- Trump believes that government regulation is preventing economic growth in the
  US and wishes to deregulate. Yet regulation is the people's best means to
  prevent corporate abuses of power: It can be used to prevent job flight
  abroad, as well as prevent tax-shelters, and incentivize hiring and
  manufacturing at home.
- Trump says he is against war abroad, and yet wants to deploy more troops to
  Iraq and Afghanistan.
- An inability to account for economic contradictions such as "overproduction
  relative to demand", with unemployment due to automation and a shrinking of
  discretionary spending in the middle class.
- Military contradictions including rising tensions between the US, NATO, and
  its military allies, as shown with the recent spying scandals revealed by
  Edward Snowden; along with the increasing economic unsustainability of war.
- Cultural contradictions including tensions between U.S.A. Judeo-Christianity,
  Islam, and other minorities as we see a rising trend of anti-Muslim sentiment
  growing in the "Alt-Right".
- Social contradictions encompassing the increasing gulf between the so-called
  ‘American Dream’, the belief that everyone can prosper in America through hard
  work, and the reality of American life (the fact that more and more people
  can’t).

It seems Trump could actually be a less "hawkish" president than Clinton (who
just wants to go to more wars to fill the coffers of companies involved with the
military industrial complex). Trump instead seems to want to "do business" with
Russia and China. The fear I have for Trump is not the "Hawkish Empire" that
Hillary Clinton would've brought with her, but instead a form of "Corporate
Fascism" where he pours fuel on the fire of trans-national capitalism, while
funding the NSA/FBI/CIA to go after those who dissent against a
corporate-sponsored deep-state.

In such a Intellio fascist nightmare, the U.S.A. uses it military might to act
as the private security arm of Boeing, Microsoft, Google, Facebook, Chase & JP
Morgan. We will see a deeper criminalization of copyright infringement,
boycotting, and more forced-purchase agreements like the current "Mandatory
Health Insurance" programs that force taxpayers to use their income to buy
big-corporate services. At the same time, we will see a gutting of
"commonwealth" programs like the ACA, and Planned Parenthood. These programs
will not be abolished, but will instead be privatized much in the same way vast
portions of the Russian national state was privatized after 1989. In its wake we
will see the rise of a new corporate oligarchy.

This election I made a conscious decision not to debate my coworkers, friends
and family over the candidates or "the issues". The 2016 campaign pitted two
candidates against each other in a way that drastically simplified and framed
discourse in moral absolutes. These absolutes were curated and made digestible
for mainstream media and social media.

 Debate isn't debate when "the issues"
are carefully curated to frame the dialog as a decision between choosing evils
when they're both evil. Taking sides can only end in animosity towards each
other, and creates wedges in the very communities we need to be building for
when the time comes to fight against corporate-fascism. Most importantly, we
lose sight of the bigger picture when the majority is split across artificially
imposed lines. Now is the time we should be gathering forces in our local
communities with the friends, coworkers and families that actually impact our
daily lives. Think global; act local is a cliche, but it works, and it's our
best defense against the shitstorm to come.

## At Present

I can freely drive from home to any state in the US, without interference from
the police or border patrol. Border patrol thinks they can have their way with
folks along the border, but it's just a hassle. TSA wastes time with security
theater at airports, but I can travel to any country without problem. Be polite,
say as little as possible, and the headache goes away.

When planes fly overhead, I sometimes look to the sky and wonder where those
travellers are going. I don't worry about drone strikes at home. When I hear
police sirens, I typically don't even notice, its probably a traffic infraction.
Don't talk to the police, but be polite and the headache (usually) goes away.

I don't believe that immigrants are rapists, killers and drug dealers. I believe
immigrants today are no different than the immigrants that built this country;
they're just people trying to take the opportunity to improve their lives.

I don't believe that terrorists want to fight us because they "hate our
freedoms" but instead they want to fight to protect their own way of life. I
believe terrorism is caused by a reaction to U.S. policies in the middle east
funding the (primarily) Saudi Arabian royal family. The royal family receives
military equipment to oppress its own people and extract local natural resources
(oil) at the expense of its own people. The royal family also sends money to the
Salafi movement, an ultra-conservative regressive form of Islam that is
destabilizing the middle east and is the root of Al-Queda, ISIL and the current
war in Syria. In exchange for a market for Saudi oil and military supplies, the
U.S. indirectly empowers the wider Salafi movement to fight against the West
while companies like Boeing, Lockheed Martin, Pratt & Whitney, KBR, General
Electric, Honeywell, Raytheon, General Dynamics, Northrop Grumann profit from
demand generated by continual wars.

I refuse to succumb to divide and conquer tactics; when the oppressor uses
arbitrary difference to separate humanity and then pit them against one another
by granting one side rights and denying those rights to the other. These are
apartheid tactics. Separation, isolation, and alienation are inhumane tactics
that serve the interests of authority and power. The differences used to
separate can be based on race, nationality, religion, gender, sexuality, class,
political party, and merit. These differences should be embraced and celebrated,
not used to divide us. We are all 99% similar, and the differences are what make
us unique. If they attack our minorities, they attack us all. Our strength lies
in unity against bigotry, hatred, and fear. We are united as one people for the
good of all.

I refuse to engage in consumerist activism. I wont be buying Che Guevara
t-shirts to lend my personal brand more progressive looking street-cred.
I wont be cheering for corporations making donations to political causes when it
serves their bottom line[^5]. These types of activism are counterproductive as
they subjugate real social activism via personal relationships into a
[relationship mediated by physical goods](<https://en.wikipedia.org/wiki/Reification_(Marxism)>)
and associations to brands.

I refuse to acknowledge the DHS, CBP as necessary or helpful
to US national security, as defenders of the constitution or more generally as
upkeepers of the rule of law.

I will express my opinions and disagreements with the U.S.A government as I
always have. I will continue to be anti-war, anti-drone, anti-neoliberal,
anti-imperialist, anti-capitalist, and violently anti-fascist (if the fascists
seek to impose oppressive rule here in the U.S.A.) Censorship isn't political in
the U.S.A. We address censorship as a market opportunity. When folks are
pirating movies, companies address that gap by providing a (relatively) cheap
service to make it convenient to pay for the movie. The rhetoric of alarm around
"Fake News" is alarming however. It's beginning to sound eerily similar to the
rationale the Chinese government is using to censor social media, the "danger of
rumors" causing fractures in social cohesion. I'm worried the Trump
administration will take a similar path.

I will oppose the reappropriation of language. I will not use terms they
redefine, nor use new terms they make[^6]. We must preserve the true meaning of
words, and reconsider the use of language to simplify discourse and bias our
perspectives.

The media, press, bloggers and social media are free to criticize the political
establishment; it's a national pastime. The Daily Show and Colbert Report are
built on getting laughs from the deep cynicism of the Left. I post my criticism
to my site, twitter, etc. and don't expect the police to visit my house, my
work, or to worry about them asking about the post the next time I get pulled
over for a traffic infringement or at border control. I'm relaxed when
expressing my views, I go to protests and engage in local politics. I consider
these acts to be part of my civic duty and expect the government to NOT ask
about my activities. An expectation otherwise would result in the erosion of
civic activity due to self-censorship- the most pernicious form of censorship
because the censorship has become internalized.

My associations with friends, family, coworkers and neighbors are private, and I
expect them to remain private. I worry about my peers, who continue to divulge
the nature of their personal relationships and love-lives to social media
companies. This is the slow commodification of relationships. I worry that these
companies (Facebook, Tinder, etc) are increasingly mediating cherished
relationships between people.

Obama deported more undocumented migrants than any previous administration, he
unilaterally dropped ~26,000 bombs on Syria, Libya, Afghanistan, Yemen, Iraq and
other countries. I expect this to continue. I don't worry about going to war,
either at home or abroad. War has been a venture for the Washington Consensus to
control foreign access and control to natural resources and access to markets
for our trans-national corporate interests. This impacts the poor, those who
volunteer to fight, and immigrants who see a path to citizenship. The Consensus
seems wise enough to know the majority is war-fatigued, and fear protest or
resistance if a draft was ever reinstated. I don't expect the middle class to
rally behind Trumps wars, and I certainly will never support his wars.

The worst aspect of the Obama administration is that it quelled the energy of
left-oriented grassroots movements. People thought "Oh, Obama is like me, hes
smart and he's got this covered." It kept the Left at ease, and this mindset
resulting in eight years of political inaction.

The one redeeming side-effect of the Trump administration is that it will reveal
the true nature of modern neoliberal power politics in the United States.
Trumps' administration will brazenly take action without the pretenses of
conciliatory compromise, or mutual respect for any existing political party or
an adversarial press. His administration will be the "Big Reveal" of the level
of corruption in our body politic. Trump will accomplish this by placing the big
influencers (who, up to this point, have been outside advisors) in direct
positions of power; e.g. Instead of having Exxon Mobile acting as an external
industry advisor, Trump will make him the CEO the Secretary of State. These acts
will tear down the facade of a disinterested political apparatus and reveal the
true nature of politics rigged from top down to reward the biggest corporations.
This will help the Left appeal to the middle by pointing out readily apparent
and brazen corrpution.

During difficult times, there is a blossoming of arts and culture in response to
authoritarian oppression. While I have no expectations for positive reform in
federal politics, I have high hopes for local community action and the arts.

[^1]:
    Kendzior, Sarah.
    [We're heading into dark times. This is how to be your own light in the Age of Trump](https://thecorrespondent.com/5696/were-heading-into-dark-times-this-is-how-to-be-your-own-light-in-the-age-of-trump/1611114266432-e23ea1a6)
    _The Correspondent_.
    The Correspondent,
    18 Nov. 2016.
    Web.
    3 Jan. 2017.

[^2]:
    Debord, Guy. _The Society of the Spectacle_.
    Perlman, Fredy (Translator).
    Detroit: Black & Red,
    Print. 1983.

[^3]:
    Siegel, Eric.
    [How Hillary's Campaign Is (Almost Certainly) Using Big Data](https://blogs.scientificamerican.com/guest-blog/how-hillary-s-campaign-is-almost-certainly-using-big-data/)
    _Scientific American_.
    Scientific American,
    Web. 2016.

[^4]:
    Wagner, John.
    [Clinton’s data-driven campaign relied heavily on an algorithm named Ada. What didn’t she see?](https://www.washingtonpost.com/news/post-politics/wp/2016/11/09/clintons-data-driven-campaign-relied-heavily-on-an-algorithm-named-ada-what-didnt-she-see/)
    _The Washington Post_.
    The Washington Post,
    Web. 2016.

[^5]:
    I've collected a few examples of this type of behavior in a Twitter Moment
    [Performative Anti-Trump Activism](https://twitter.com/i/moments/817897786301710336).

[^6]:
     For example, terms like 'fake news'.


text:
# Assignment 1 - 2D Platform Game

## Lluc is the name of this platformer game

This Project is made for the first assignment of Videogames Development subject

##Instalation
Unzip the .zip file and execute the .exe that is contained inside the decompressed folder
***
##Controls:
**A** - Player moves to the left direction

**D**- Player moves to the right direction

**Space**- Player Jumps

##Debug Funcionality:
**F1** - Start from the beginning of the first level

**F2** - Start from the beginning of the current level

**F3**- Start from the beggining of the second level

**F5**- Save the current state of the game

**F6** - Load the saved state of the game

**F9** - Debug colliders to see them

**F10** - GodMode
***
##Link to GitHub repository:
https://github.com/AlexandruC5/Dev.Project

####
A game made by **Alexandru Mihai Cercel** and **Gerard Clotet**
***
###Issues
During this assigment our major goal has been to implement the colliders and make them work properly but despite our efforts we weren't able to achieve it even though we managed to implement some kind of collisions


text:
# dns

api gateway urls are ok for prototyping but you'll quickly want to setup dns for a custom domain name. the manual steps to do this are fairly straightforward, however also automatable. and if something can be outomated it should be.

## setup

As with other workflows dns is setup with the following added to `scripts` in `package.json`:

```
{
  "dns": "AWS_PROFILE=xxx AWS_REGION=us-east-1 arc-dns"
}
```

This example `.arc` file defines `@domain` with the domain name `wut.click` as the value:

```arc
@app
testapp

@domain
wut.click

@html
get /
```

## usage

`npm run dns` and follow the guided output; you will have to re-run the command as you progress through the following stages of dns configuration:

- create and verify certificates with aws certificate manager
- setup hosted zone in route53
- create the domain and api mapping in api gateway
- create an alias record set in route53

as each phase progresses re-run `npm run dns` to move forward.

repository: indexzero/arc-workflows

repo_name: indexzero/arc-workflows


text:
# Tools of the Trade
A repo describing the tools used in this module, how to install them and start to use them

In this module, we'll be using a variety of software packages that professional Java developers commonly use. This is not an exhaustive list, but it contains some of the most important, and useful tools for any developer to have.

# Setup your Dev Environment
Please setup your device in advance of the class if you can.

## Before you start installing anything - backup
Backup everything on your device. Ideally, always store important documents and user files on a secure cloud service like OneDrive. As a student, you have free access to cloud storage. Most people only learn to backup when they suffer catastrophic, unrecoverable data loss.

## Installation Options
You can research and examine every piece of software listed below and decide where and how you want to install it.
An alternative to that is to use a software package manager, like ```Chocolately```.
Chocolately is a command line tool, and throughout this module you will see the command line used extensively.
A command line can be opened in normal or administrative (*elevated*) mode.
Administration mode can change the operating system (e.g. install software), normal is restricted from some operations.
A more advanced (and popular with Windows developers and DevOps teams) command line system is PowerShell.
Some installation instructions require PowerShell instead of the traditional Command line (note, PowerShell can always be used instead but some students may find it more complex).
The quickest way to launch an administrative command line is ```WIN + x``` and select Command Prompt (Admin) and follow the instructions at [Chocolatey](https://chocolatey.org/install).
The command used for preparing this module<EMAIL_ADDRESS>-NoProfile -InputFormat None -ExecutionPolicy Bypass -Command "iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))" && SET "PATH=%PATH%;%ALLUSERSPROFILE%\chocolatey\bin"```
Now close and reopen the command line shell (elevated as admin again).

### Development

Install:
1. Maven, a software project management tool, sorts dependencies and builds ```choco install -y maven```
1. GIT, a source code management tool ```choco install -y git```
1. Visual Studio Code, a multi-platform, open source IDE ```choco install -y visualstudiocode```
1. Visual Studio Code Java Extensions Pack
   1. Launch Visual Studio Code, you should see the welcome screen
   1. activate Extensions with ```CTRL + SHIFT + X```
   1. type ```java extension pack``` and ```enter```
   1. click on Install under ```Java Extension Pack```
1. Visual Studio Code Azure Extensions Pack
   1. Launch Visual Studio Code
   1. activate Extensions with ```CTRL + SHIFT + X```
   1. type ```azure functions``` and ```enter```
   1. click on Install under ```Azure Functions```

### Cloud
This course uses Azure, a cloud service from Microsoft.
You can get Azure for free with the Azure for Student program.
Install the Azure Command Line interface: ```choco install -y azure-cli```

repository: enda-lee/tools

repo_name: enda-lee/tools


text:
# NASSCOM - The NLP Week (Day 2)

SSMT Notebooks for NASSCOM Workshop on Speech To Speech Machine Translation

## About

India’s cultural diversity can be gauged by the fact that we transact in 22 official languages and converse in thousands of dialects. Advanced AI/ML capabilities applied to NLP can spur seamless integration of the social and business ecosystem in India by mending language barriers. With over 700 million internet subscribers, there is a rapidly growing demand for understanding India’s vernacular languages for myriad functions in areas such as multilingual customer service, search applications in native language and virtual agents in vernacular languages.

Natural Language Processing (NLP) has the capability to enable wider reach of information aided by Internet explosion across the country. Initiatives like the National Language Translation Mission by Govt of India are aiming to create a ‘voice-based internet’ and have Indian Language technology systems and products deployed in the field with the help of start-ups. This will result in development of the next generation 'conversational' apps & websites.

The forthcoming edition of NASSCOM’s AI Parley will bring together on a series of expert programs focused on NLP for India. The week-long conference will emphasize 4 key segments –

Day 2 - Segment - Developing a high quality speech to speech machine translation (SSMT)

The session will help developers comprehend the workflow associated with developing speech to speech models. (2:00PM-6:00PM)

### Speakers

- Dr. Preethi Jyothi , Assistant Professor of Computer Science and Engineering Department at IIT Bombay
- Dr. Pushpak Bhattacharyya, Professor of Computer Science and Engineering Department at IIT Bombay

#### Assisting Students

- Jyotsana Khatri
- Nikhil Saini
- Vineet Bhatt
- Aakash Banerjee

### Time
Apr 6, 2021 02:00 PM in India

### Main Event Webpage
https://nasscom.in/nlp-week/

repository: csalt-research/speech-to-speech-mt

repo_name: csalt-research/speech-to-speech-mt