text:
# Software Development Life Cycle, Agile, and SCRUM

## SDLC
  ### What is SDLC?
  - SDLC is a process used by the software industry to design, develop, and test high quality software
    - SDLC is governed by an international standard (ISO/IEC 12207)
  - SDLC consists of a detailed plan describing how to develop, maintain, replace, and alter or enhance specific software
  ### Phases

  ![plot](./IMG/sdlc_stages.jpg)

  - Planning
    - Propose alternative solutions
    - Cost estimates
  - Analysis
    - Gather required features
    - Analyze existing systems
    - Scrutinize proposed system for flaws
  - Design
    - Generate documentation
    - UML diagrams, Gantt charts, etc
    - Pseudocode
  - Implementation
    - Actually program the damn thing
  - Testing
    - Write test cases for your code
    - Allows for easier maintenance
    - Let QA attempt to break the product
  - Deployment
    - Application is made available to the user
    - Bugs here can launch a new SDLC

### Models of SDLC
  - SDLC is a process to which there are several methodologies to implement that process: Waterfall, Iterative, Agile, DevOps, V-Model, Spiral, Lean, etc.
  - The big picture here is to understand the changes that software development has undergone e.g. why the Waterfall method's failure led to Agile's popularity
  - Waterfall

    ![plot](./IMG/waterfall_model.png)

    - Divide software development into separate phases
    - One phase must be finished before beginning the next phase
    - Main focus is gathering all requirements at first and then building the product based off of those requirements
    - Product is delivered once it has been completed
    - Does not allow for much revision due to gathering requirements first and designing around that
    - Think P0 - PizzaBox
	    - Strict requirements shown at the very beginning
	    - Strict timeline of development and due date (code freeze and presentations)
  - Iterative

    ![plot](./IMG/iterative_model.jpg)

    - Start with a simple implementation of just a subset of the requirements and iterate over the remaining features
    - Main focus is clearly defining major features and minor features that may be modified during the development process
  - Agile

    ![plot](./IMG/Agile.png)

    - Every project needs to be handled differently and you need to tailor existing methods to best suit the project requirements
    - Major focus is taking an iterative approach and presenting a working software build at the end of every iteration
    - Leads to a much less detailed plan but this allows for far greater flexibility in terms of features

  - DevOps

    ![plot](./IMG/DevOps.png)

    - Traditionally, the IT operations team is responsible for deploying and managing the software while having little interaction with the development team that writes the code
    - DevOps ensures both teams work closely together
    - Sometimes both teams are even merged into one, where an engineer will work on the entire SDLC

  - V-Model (Verification and Validation Model)

    ![plot](./IMG/v_model.jpg)

    - Can be considered an extension of Waterfall
    - Each development is closely followed by testing right after, so this method goes back and forth between development and testing often
    - A phase must be fully completed before moving onto the next
    - Verification is a static analysis technique which is reviewing without executing the code
    - Validation is a dynamic analysis technique which is actually executing the code and running it through tests
  - Spiral Model

    ![plot](./IMG/spiral_model.jpg)

    - Has 4 phases that a software project repeatedly passes through--called Spirals--until it is completed
    - Identification, Design, Construction, Risk Analysis
  - Lean Model

    ![plot](./IMG/Lean.png)

    - Reduce unnecessary work at every opportunity (cutting meetings, reducing documentation, etc.)
    - Only work on what is essential at the time so no multitasking
    - Agile incorporates a lot of Lean methodology
	  - Both care about fast delivery of working software
	    - Agile does this through small batch sizes and “sprints”
            - Lean does this through cutting as much unnecessary cost, scope, and work in general as possible

  ### Pros and Cons of SDLC
  - Pros
    - Systematic way of developing software
    - Repeated use allows for quicker development periods due to programmers gaining experience in the processes
    - Promotes transparency since it requires large amounts of communication
  - Cons
    - Poor planning can result in similar levels of product performance
    - Large amounts of documentation can lead to confusion/potentially conflicting documents depending on who wrote them
    - Requires good team communication

## Agile
  ### The 12 Principles of the Agile Manifesto (summary/interpretation):
  - https://agilemanifesto.org/principles.html
  1. First priority is to satisfy the client
  2. Flexible to changes in requirements at any point
  3. Frequently deliver working software
  4. Developers and business people frequently work together
  5. The people working on the project should care about the project
  6. Best method of communication is face-to-face
  7. Progress is measured by working software
  8. Effort should be constant throughout the SDLC so as to avoid burnout but still be efficient
  9. Frequently pay attention to good design
  10. ”..Simplicity--the art of maximizing the amount of [unnecessary] work not done..” Basically, don’t do unnecessary work
  11. Promotes self-organizing teams such that teams don’t depend on a manager but manage their own associated responsibilities and timelines
  12. Regularly reflect on what’s working well and not working well for the team, and implement the necessary changes

  ### Advantages of Agile
  - Client plays a larger role
	  - Increased client satisfaction since the final product is more likely to truly meet their requirements
  - Shorter Time To Market (TTM)
	  - Since working software is frequently delivered, it’s possible for a client to get the application out sooner
  - Flexibility
	  - The product can easily adapt to any additional requirements by the client
  - Teamwork
    - Autonomous, self-organizing teams plus constant self-reflection results in continuous improvement and better team morale
    - Teamwork and relationship with the client is also improved as well because the frequent communication

  ### Disadvantages of Agile
  - Less predictability
    - The more rigid waterfall process makes it easier to quantify the time, effort, and cost of the final product as opposed to Agile
  - Takes longer
	  - Having such frequent communication between the testers, developers, and client is a time-consuming process
  - Client plays a larger role
	  - This is listed as both an advantage and a disadvantage because a lack of communication can severely hamper the development of the product
	  - Clients must be willing and able to play a much larger role in the SDLC than as opposed to another approach
  - Poor documentation
	  - Requirements are spelled out flexibly and just in time for development as opposed to all at the beginning which can lead to less detailed documentation
    - This can cause a newer developer to the team to be unsure of how certain features perform since they were not present at the frequent meetings with the client
  - Scope creep
	  - Agile is more prone to scope creep as constant changes and uncontrolled growth in the project’s scope can lead to a project never being completed
  - Overall be careful to use Agile when clients have a strict budget, deadline, and project scope

## SCRUM
  ### What is SCRUM
  - An Agile framework that helps teams apply adaptive solutions to complex problems
  - Framework focuses on direct contact with the product owner and breaking their desired product into sections known as Sprints
  - Developers outline goals for each Sprint and work on them
  - At the end of each Sprint the developers meet with the product owners, review the work that was completed, and adjust plans for the next Sprint as needed
  ### Scrum Roles
  - Product Owner
    - NOTE: Product Owner is 1 person, not all stakeholders
    - Responsible for maximizing the value of the product resulting from the work of the Scrum Team
    - Develops the Product Goal
    - Creates and triages the Product Backlog items
  - Scrum Master
    - Accountable for ensuring team is following Scrum framework
    - Essentially a coordinator, makes sure the developers are working and fixes any roadblocks they may run into
    - Typically is the middleman between the Product Owner and the Developers
  - Developers
    - Create a plan for the Sprint, the Sprint Backlog
    - Adapt their plan as needed to reach the Sprint Goals
    - Hold each other accountable
  ### Scrum Cycle
  - Sprint

    ![plot](./IMG/SCRUM.png)

    - Fixed length period of one month or less
    - Time period where you work towards achieving the goals listed in the Sprint Planning, Daily Scrums, previous Sprint Review, and previous Sprint Retrospective
    - Product Backlog and scope of project can be clarified with the Product Owner as issues arise
  - Sprint Planning
    - Lays out the work that should be accomplished during the upcoming Sprint
    - Communication between Scrum Team and Product Owner is crucial. Questions typically asked are:
      - Why is this Sprint valuable?
        - Helps the team decide on a Sprint Goal
      - What can be accomplished this Sprint?
        -  Helps narrow down items on the Product Backlog
      - How will the chosen work get done?
        - Developers break Product Backlog items down into individual days and assign roles
  - Daily Scrum
    - ~15 minute Daily meetings where you adjust the Sprint Backlog based on your progress towards the Sprint Goal
    - If the Product owner or Scrum Master are working on items in the Sprint Backlog, they act as developers
    - Often times team members meet immediately after the Daily Scrum for more technical discussions about issues they are facing
  - Sprint Review
    - Inspect the outcome of the Sprint and determine any future adaptations
    - The Product Backlog may be adjusted based on the progress in the current Sprint
    - Typically includes the following:
      - Product Owner explains what Product Backlog items have been Done and what are not Done
      - Developers discuss what went well during the Sprint, what problems they ran into, and the solutions they found
      - The Product Owner projects delivery dates based on the current progress and assess budget concerns if delays occurred
      - Team decides how to move forward to help ease the upcoming Sprint’s Sprint Planning
  - Sprint Retrospective
    - Inspect how the last Sprint went and what got Done
    - Identify the most helpful changes to improve effectiveness
    - Discuss what went well during the Sprint
    - Discuss what could have been improved during the Sprint
    - Discuss how developers will improve in the next Sprint
  - Scrum Documentation
    - Sprint Backlog
      - Composed of the Sprint Goal (the Why), the set of Product Backlog items selected for the Sprint (the What), and an action plan for delivering the Increment (the How)
    - Sprint Goal
      - The main objective for a Sprint
    - Increment
      - A concrete stepping stone toward the Product Goal
      - Work cannot be considered part of an Increment unless it meets the Definition of Done
      - Description of the state of an Increment when it meets the quality measures set in place
    - Product Backlog
      - Ordered list of what is needed to improve the product
      - Gets refined by breaking down items into smaller, more manageable pieces

gha_language: C#


text:
---
layout: note
title: Verification tool competition
---

Competitions for (automatic) verification tools compare tools against a common
set of benchmarks and typically compare results based on how many of the
benchmarks can be verified within a given time.  The need to have a common
input/output language and the creation of a growing set of benchmarks helps
drive a research area forward.

(There are also competitions for [auto-active verification] tools and
interactive verification tools but these also test the expertise of the humans
driving the tools.)

{% include links.html %}

license: MIT

repository: alastairreid/RelatedWork

branch_name: refs/heads/main

extension: md

gha_language: TeX

gha_license_id: MIT

license_type: permissive

repo_name: alastairreid/RelatedWork


text:
## Ponzu Docker build

Ponzu is distributed as a [docker image](https://hub.docker.com/r/ponzu/ponzu/),
which aids in ponzu deployment. The Dockerfile in this directory is used by Ponzu
to generate the docker image which contains the ponzu executable.

If you are deploying your own Ponzu project, you can write a new Dockerfile that
is based from the `ponzu/ponzu` image of your choice. For example:
```docker
FROM ponzu/ponzu:latest

# your project set up ...
# ...
# ...
```

### The following are convenient commands during development of Ponzu core:

#### Build the docker image. Run from the root of the project.
```bash
# from the root of ponzu:
docker build -t ponzu-dev
```

#### Start the image, share the local directory and pseudo terminal (tty) into for debugging:
```bash
docker run -v $(pwd):/go/src/github.com/ponzu-cms/ponzu -it ponzu-dev
pwd # will output the go src directory for ponzu
ponzu version # will output the ponzu version
# make an edit on your local and rebuild
go install ./...
```

Special thanks to [**@krismeister**](https://github.com/krismeister) for contributing this!

repository: agreyfox/eshop

branch_name: refs/heads/master

repo_name: agreyfox/eshop


text:
First of all, thank you for your contribution! :-)

Please makes sure that these checkboxes are checked before submitting your PR, thank you!

* [ ] Make sure that you propose PR to right branch: bugfix for `master`, feature for latest active branch `vx.x.x`.
* [ ] Rebase before creating a PR to keep commit history clear.
* [ ] Add some descriptions and refer relative issues for you PR.

Extra checklist:
if** *isNewFeature* **:**

  * [ ] Update API docs for the component.
  * [ ] Update/Add demo to demonstrate new feature.
  * [ ] Update TypeScript definition for the component.

repository: JserWang/rc-bmap

gha_language: JavaScript

repo_name: JserWang/rc-bmap


text:
# Problem Domain
Given a string containing only, d's and u's, where d signifies a single step down, and u a single step up, count how many valleys exist across the whole array.

# Visual

        uuduuddddudduudu
            /\
         /\/  \
        /______\________
                \/\  /\/
                   \/
        there are total of
        3 valleys here

A valley seems to be definied by all of the negative space after a zero intersection to the next zero intersection

        du
        __
        \/

The smallest unit considered valley

        dddduuududduuu
        ______________
        \            /
         \    /\/\  /
          \  /    \/
           \/

Despite the three distinct troughs, there is only the two zero intersections, so this entire sequence would be classified as one valley

        ud   /\   zero intersection from mountain
            ----
        du   \/   zero intersection from valley

There are two routes by which one can hit the zero intersection, from postivie space (ie mountain) or from negative space (ie valley). Given the problem domain we only care about the zero intersection from negative space, one method to do this is to only add the valley Counter increment to code blocks related to upward movement

# Algorithm
* Give d's and u's a numerical value
* Track the rise and fall of the mountains and valleys
* If the sequence hits the zero intersection from negative space, record as one valley
* Return number of valleys

# Psuedocode
* decl arr <- str split
* decl int valley count
* decl int level tracker
* for i in arr
    * if d -- l level tracker
    * if u ++ 1 level tracker
        * if level tracker === 0, valley count +1
* return valley count
## Research

repository: MichaelJahns/codeChallenges

gha_language: Java

repo_name: MichaelJahns/codeChallenges


text:
On this step we will authenticate and identify users in our app.

Before we go ahead and start extending our app, we will add few packages which will make our lives a bit less complex when it comes to authentication and users management.

First we will add a `Meteor` package called `accounts-phone` which gives us the ability to verify a user using an SMS code:

    $ meteor add<EMAIL_ADDRESS>    $ meteor add mys:accounts-phone

And second, we will add `angular-meteor-auth` which provides us with authentication related functions:

    $ meteor npm install angular-meteor-auth

Of course, don't forget to load the relevant modules:

{{{diff_step 4.3}}}

In order to make the SMS verification work we will need to create a file located in `server/sms.js` with the following contents:

{{{diff_step 4.4}}}

If you would like to test the verification with a real phone number, `accouts-phone` provides an easy access for [twilio's API](https://www.twilio.com/), for more information see [accounts-phone's repo](https://github.com/okland/accounts-phone).

For debugging purposes if you'd like to add admin phone numbers and mater verification codes which will always pass the verification stage, you may add a `settings.json` file at the root folder with the following fields:

    {
      "ACCOUNTS_PHONE": {
        "ADMIN_NUMBERS": ["123456789", "987654321"],
        "MASTER_CODE": "1234"
      }
    }

Now let's create the same flow of `Whatsapp` for authentication: first we need to ask for the user's phone number, verify it with an SMS message and then ask the user to pick his name.

So these flows are created by 3 views: login, confirmation and profile.

Let's add these states, each with HTML template and controller:

{{{diff_step 4.5}}}

We will now add the view of login state which includes an input and a save button and later we will add a modal dialog to verify the user's phone:

{{{diff_step 4.6}}}

And for the controller the logic is simple, we ask the user to check again his phone number, and then we will use `Accounts` API in order to ask for SMS verification:

{{{diff_step 4.7}}}

{{{diff_step 4.8}}}

Note that we didn't provide all the settings for `account-phone`, so it will run in debug mode. It means that a real SMS won't be sent now, but if you'd like to receive the verification code just open your terminal and view `Meteor`'s logs.

Our next step would be preventing unauthorized users from viewing contents which they have no permission to. In order to do that we will add a pre-requirement to the relevant routes which will require the user to log-in first. `angular-meteor-auth` provides us with a service which is called `$auth`, and it has a method called `$awaitUser()` which returns a promise that will be resolved only once the user has logged in. For more information about `angular-meteor-auth` see [reference](http://www.angular-meteor.com/api/1.3.6/auth).

{{{diff_step 4.9}}}

And now we want to handle a case that this promise does not resolve (In case that the user is not logged in), so let's create a new run block to our `routes.js` file:

{{{diff_step 4.10}}}

{{{diff_step 4.11}}}

And now let's add some `css`:

{{{diff_step 4.12}}}

The next step is to add the confirmation view, starting with the HTML:

{{{diff_step 4.13}}}

And the controller:

{{{diff_step 4.14}}}

{{{diff_step 4.15}}}

We will use `Accounts` API again to verify the user and in case of successful authentication we will transition to the `profile` state, which we will add in the next step.

Let's implement the profile view, which provides the ability to enter the user's nickname and profile picture:

{{{diff_step 4.16}}}

And the controller:

{{{diff_step 4.17}}}

{{{diff_step 4.18}}}

And some `css`:

{{{diff_step 4.19}}}

As you can see, the controller uses the server method `updateName()` which we need to implement in the `lib/methods.js`:

{{{diff_step 4.20}}}

`Meteor` sets the user identity in case of a logged in user into the `this.userId` variable, so we can check if this variable exists in order to verify that the user is logged in.

Now let's add this validation to the `newMessage()` method we created earlier, and also add the identity of the user to each message he sends.

{{{diff_step 4.21}}}

Great, now the last missing feature is logout. Let's add a state for the settings view:

{{{diff_step 4.22}}}

And create the view which contains the logout button:

{{{diff_step 4.23}}}

Now let's implement this method inside the `SettingsCtrl`:

{{{diff_step 4.24}}}

{{{diff_step 4.25}}}

We also need to modify the way we identify our users inside the messages list, so let's do it:

{{{diff_step 4.26}}}

And the last missing feature is about adding auto-scroll to the messages list in order to keep the view scrolled down when new messages arrive:

{{{diff_step 4.27}}}

repository: CodexCodech/Ionic-MeteorCLI-WhatsApp

repo_name: CodexCodech/Ionic-MeteorCLI-WhatsApp


text:
---
layout: post
title: Extracting data from docs, mapping
---

#### Links for class

* [What to do with the docs]({{ site.url }}/class5/class5.html)
* [Extracting data from a PDF]({{ site.url }}/class5/pdf_converter/)
* [Tutorial on Getting started with the Github desktop app]({{ site.url }}/class5/fusion_map)

### Readings for Oct. 7

Read: [Distrust Your Data](https://source.opennews.org/en-US/learning/distrust-your-data/)

Read: [When Maps Shouldn’t Be Maps](http://www.ericson.net/content/2011/10/when-maps-shouldnt-be-maps/)

Read: [Connecting with the Dots](https://source.opennews.org/en-US/learning/connecting-dots/)

### Homework 1

Answer these questions about the readings.

[Questions about the Class 5 reading assignments](https://docs.google.com/forms/d/1OUNIeWXx9tAdTZytYpOfuHmkAfPsQ-GNB8aQVa5jMeI/viewform?usp=send_form)

### Homework 2
* Extract data from [this PDF](http://andrewbtran.github.io/JRN-418/class5/pop_towns2012-2.pdf).
* Don't just convert it to a spreadsheet. Clean it up nice.
* Save it as a CSV and upload it to the private Github repo.

### Homework 3
Critique a piece of data journalism
Find a story that purports to use data, read it, and answer the following questions:

* What data was used in the story?
* Where'd the data come from?
* Why was the data collected in the first place?
* What conclusions does the story come to based on the data?
* What are the limits to the data?
* Is the original somewhere online? If so, post the link.

**Write the answers to these questions in Markdown format and post it to your Github repo.**

Here are some stories if you don't want to find any on your own:

* [Do lobster prices have anything to do with the McDonald’s lobster roll? | TrendCT](http://trendct.org/2015/07/09/do-lobster-prices-have-anything-to-do-with-the-mcdonalds-lobster-roll/)
* [The growth of Connecticut sectors — and the shrinking of a few | TrendCT](http://trendct.org/2015/07/08/gdp-of-industry-subsectors-over-time/)
* [The Republican Candidates Donald Trump Has Hurt the Most - The New York Times](http://www.nytimes.com/2015/09/15/upshot/the-candidates-donald-trump-has-hurt-the-most.html?_r=0)
* [Coal, Gas, Nuclear, Hydro? How Your State Generates Power : NPR](http://www.npr.org/2015/09/10/319535020/coal-gas-nuclear-hydro-how-your-state-generates-power)
* [Which Connecticut towns prefer Dunkin’ Donuts or Starbucks? | TrendCT](http://trendct.org/2015/08/10/which-connecticut-towns-prefer-dunkin-donuts-or-starbucks/)
* [The Tiger Mom Tax: Asians Are Nearly Twice as Likely to Get a Higher Price from Princeton Review - ProPublica](https://www.propublica.org/article/asians-nearly-twice-as-likely-to-get-higher-price-from-princeton-review)
* [Perilous highway | longform.theday.com](http://longform.theday.com/i95-perilous-highway/)

#### To download before next week's class


text:
# Backoffice Admin Example

This application illustrates how to use `backoffice` to build an admin
dashboard.

Run with:

```sh
mix phx.serve
```

repository: leuchtturm-solutions/backoffice

repo_name: leuchtturm-solutions/backoffice


text:
# Modifiers

Modifiers are use to set specific or modify behavior for classes, methods and functions (attributes too in some rare occasions). This changes will be enforced by the compiler.

- Visibility modifiers: Go read them in the classes chapter, I'm too lazy to copy-paste them here.
- `abstract`

## Functions and methods only modifiers

The following qualifiers can only be applied to functions or methods.

- `nodiscard`: If the returned value by the function (or method) is discarded by the caller, the compiler is encouraged to emit a warning.

## Method only modifiers

- `overridecall`
  - If a sub class overrides this method, the original overrided method will be automatically called at the start of the overrider method (unless the overrider method make an explicit call to the overrided method). The overrider method will inherit this behavior (it's recommended to tag the overredier method with this modifier explicity).
- `overloadcall`
  - If a sub class overloads this method, the original overloaded method will be automatically called at the start of each overloader method (unless the overloader method make an explicit call to the overloaded method).
  - In the super class: A method tagged with this modifier can't be overloaded by the same class, only by sub classes.

repository: AngheloAlf/APL

path: /docs/014 - Modifiers.md

filename: 014 - Modifiers.md

repo_name: AngheloAlf/APL


text:
# 2.4.15
- Updating favicon to a generic JS one
- Webpack 4 being used

# 2.3.2
- Removed jekyll
- 100/100 lighthouse and google pagespeed insights
- Bootstrap 4 out of beta
- Fewer dependencies
- Decouple gulp tasks from this package

# 2.2.0
- HMR
- CSS HMR
- PurifyCSS
- CriticalCSS

### 2.1.0
- Add Bootstrap 4 Beta as an Frontend Framework option
- Decouple jQuery from bundle on production mode.
- Keep alive the opened browser tab when you hit `npm run code`. Thanks Facebook!

### 2.0.0
- Reduced number of total dependencies
- Webpack integration to handle JS files
- God mode svg inline icons with pug mixins
- Unified fonts task
- Deploy via FTP
- Jekyll and HTML both are now Environment aware 💅
- No more support to LESS & Stylus css preprocessors. (Help: https://github.com/Pixel2HTML/pixel2html-generator/wiki/Using-other-styles-preprocessor-language)
- No more support to BassCss framework

### 1.3.5
- Minor fixes.

### 1.3.4
- Fixed some minor bugs on JS compilation.
- Minor other fixes.

### 1.3.3
- Fixed some minor bugs on Jekyll builds.
- Smarter use of config variables to gulp routines.
- Updated dependencies versions.
- Some tests improvement.
- `projectName` variable instead of `projectId` to generate more white label projects.

### 1.3.2
- Fix some miss references to vendor fonts
- Updated JS syntax to ES6
- Minor fixes

### 1.3.1
- Added missing references to vendor scripts on pug base files

#### 1.3.0
- Migrate to Gulp 4.
- Import reset.css only when there no selected FrontEnd Framework.
- Added `production` flag to gulp tasks to speed up the compilation process on `development` mode (no mins, no compressions).
- Added CSScomb.
- Added PurifyCSS.
- Improvements in the PUG file structure, now it have some layouts, mixins and imports.
- Moved `sourcemaps` to a external file.
- Removed useless Gulp Plumber.
- Added some SVG magic by default.

#### 1.2.3
- Added fonts support to default gulp routine.

#### 1.2.2
- Added `dist` directories configuration on `config.js` file.
- Added Zurb Foundation initializer on `main.js` file.
- Updated library versions.

#### 1.2.1
- Fixed version name.

#### 1.2.0
- Added Jekyll support.
- Removed vendor gulp tasks in favor of `config.js`.
- Added gulp group css media queries support.
- Improved bower inclusion of libs on index.js.

#### 1.1.2
- Added PUG/Jade support.

#### 1.1.0
- Minor bugfixing.
- Removed `gitlab-ci.yml` integration.
- Add generator version to config file.

#### 1.0.0
- Initial release.


text:
# Hello World
###### F#

### 1. Approch to Solving the problem

No biggie here, just a single command

### 2. How to compile and run this code

Download the F# standalone compiler from here: http://download.microsoft.com/download/F/3/D/F3D6045E-4040-4058-ADAD-2698F1793CBC/Microsoft.FSharp.SDK.Core.msi
Add it to your path: C:\Program Files (x86)\Microsoft SDKs\F#\4.1\Framework\v4.0\fsc.exe
Then compile and run like below

Example:
```
> fsc src\HellowWorld.fs
> HelloWorld.exe
```

### 3. How this program works

Running this program simply prints "Hello World"


text:
# Basis functions

```@setup FEMBase
using FEMBase
using FEMBase.FEMBasis: eval_dbasis!, jacobian, grad, interpolate,
                        get_reference_element_coordinates, create_basis
using FEMBasis
```

Shape functions, also known as basis functions, interpolation polynomials and
so on. Typically unknown field variable is interpolated from element nodal
values using continuous functions. That is,

```math
u(\xi,t) = \sum_{i} N(\xi,t) u_{i}[t]
```math

Standard Lagrange shape functions are implemented.

Linear shape functions:
- Seg2 (2-node segment)
- Tri3 (3-node triangle)
- Quad4 (4-node quadrangle)
- Tet4 (4-node tetrahedron)
- Pyr5 (5-node pyramid)
- Wedge6 (6-node wedge)
- Hex8 (8-node hexahedra)

Quadratic and biquadratic shape functions:
- Seg3
- Tri6, Tri7
- Quad8, Quad9
- Tet10
- Wedge15
- Hex20, Hex27

NURBS shape functions:
- NSeg
- NSurf
- NSolid

Creating new basis is done simply by calling that constructor, without any
arguments:

```@repl FEMBase
Seg2()
Tri3()
Quad4()
```

The dimensions of basis functions can be determined by `size` and `length`.
In JuliaFEM, we have a convention that arrays grow on right according to
number of nodes and down according to the spatial index. So if we have a
row vector $\boldsymbol N$ and a column vector $\boldsymbol u$, interpolation
goes $u = \boldsymbol N \boldsymbol u$:

```@repl FEMBase
N = [1 2 3] # evaluated basis functions
u = [1, 2, 3] # field value at discrete points
N*u
```

For example, `Quad4` is defined in two dimensions and it has 4 nodes, so
```@repl FEMBase
B = Quad4()
size(B)
length(B)
```

Evaluating basis functions and they partial derivatives with respect to some
$\xi$ is done efficiently using `eval_basis!` and `eval_dbasis!`. For these
commands one needs to allocate array outside of the hot loops to get speed.

```@repl FEMBase
N = zeros(1, length(B))
dN = zeros(size(B)...)
xi = (0.0, 0.0)
eval_basis!(B, N, xi)
eval_dbasis!(B, dN, xi)
```

For Langrange interpolation polynomials, by definition, on each node shape
function corresponding to that node gets value of 1 and the rest is zero.
Node ordering follows the same defined in e.g. in ABAQUS and in many other
FEM softwares. The actual shape of domain can be inspected using command
`get_reference_element_coordinates`:

```@repl FEMBase
get_reference_element_coordinates(Quad4)
```

```@example FEMBase
for xi in get_reference_element_coordinates(Quad4)
    eval_basis!(B, N, xi)
    println("$N at $xi")
end
```

## Mathematics

Without knowing anything about the shape of the real domain (after all, basis
is usually defined on dimensionless, reference domain), `eval_dbasis!` is
calculating gradient with respect to dimensionless coordinates $\xi_i$, i.e.

```math
\left(\frac{\partial\boldsymbol{N}}{\partial\boldsymbol{\xi}}\right)_{ij}=\frac{\partial N_{j}}{\partial\xi_{i}}
```

Usually this is not wanted, but instead gradient of basis functions is
calculated with respect to natural coordinates $X_i$,

```math
\left(\frac{\partial\boldsymbol{N}}{\partial\boldsymbol{X}}\right)_{ij}=\frac{\partial N_{j}}{\partial X_{i}}
```

Without going into the mathematical details, to transform partial derivatives
from reference element to natural coordinates, inverse of Jacobian matrix is
needed.

```@repl FEMBase
X = ([0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0])
xi = (0.0, 0.0)
J = jacobian(B, X, xi)
inv(J) * dN
```

Or directly, using `grad`:

```@repl FEMBase
dNdX = grad(B, X, xi)
```

If interpolation domain is a manifold, i.e. space having lower dimension than
the actual space (read: surface in 3d), Jacobian is not square and inverse
cannot be taken.

```@repl FEMBase
X2 = ([0.0,0.0,0.0], [1.0, 0.0,1.0], [1.0,1.0,1.0], [0.0,1.0,0.0])
xi = (0.0, 0.0)
J = jacobian(B, X2, xi)
```

One can use Jacobian to calculate
[surface integral](https://en.wikipedia.org/wiki/Surface_integral):

```math
\iint_{S}f\,\mathrm{d}\Sigma=\iint_{T}f\left(\boldsymbol{x}\left(s,t\right)\right)\left\Vert \frac{\partial\boldsymbol{x}}{\partial s}\times\frac{\partial\boldsymbol{x}}{\partial t}\right\Vert \,\mathrm{d}s\mathrm{d}t
```

```@repl FEMBase
4*norm(cross(J[1,:], J[2,:])), sqrt(2) # area of manifold
```

Gradient of e.g. displacement field or temperature field can be also evaluated,
with the same `grad` function, by adding field `u`:

```@repl FEMBase
u = ([0.0, 0.0], [1.0, -1.0], [2.0, 3.0], [0.0, 0.0])
T = (1.0, 2.0, 3.0, 4.0)
grad(B, u, X, xi)
grad(B, T, X, xi)
```

One can interpolate fields using basis, i.e. calculate $u = \boldsymbol{N}\boldsymbol{u}$ as described before:

```@repl FEMBase
interpolate(B, u, xi)
interpolate(B, T, xi)
```

In "hot loops", it's absolutely necessary that no unnecessary memory allcations
happen as it is reducing the performance dramatically from C speed. To avoid
unnecessary memory allocations, a struct `BasisInfo` is introduced, containing
workspace for calculations.

```@repl FEMBase
bi = BasisInfo(Quad4)
eval_basis!(bi, X, xi)
bi.J       # Jacobian
bi.N       # shape functions
bi.dN      # shape function derivatives, with respect to xi
bi.detJ    # determinant of Jacobian
bi.grad    # shape function derivatives, with respect to X
bi.invJ    # inverse of Jacobian
```

Calculating gradient of some field `u` can be done memory efficiently using
this `BasisInfo` structure:

```@repl FEMBase
gradu = zeros(2, 2)
grad!(bi, gradu, u)
```

## Defining custom shape functions

Depending from the type of shape functions, they can be created more or less
automatic way. An ultimate goal is to create all kind of shape functions just
by defining the general principles and let computer handle the all boring
things and create shape functions automatically using metaprogramming to get
efficient code.

For Lagrange type interpolation, ones needs only to define polynomial and
corner points for domain. For example, if domain is $[0,1]^2$, one can use
`create_basis`, and give polynomial with degree matching to the number of
point to interpolate.

```@repl FEMBase
code = create_basis(
    :MyQuad,
    "My special domain",
    (
        (0.0, 0.0),
        (1.0, 0.0),
        (1.0, 1.0),
        (0.0, 1.0),
    ),
    "1 + u + v + u*v"
);

eval(code)
```

What we have defined is a interpolation polynomial and "corner points". As
a result, we have a new basis `MyQuad`, working just like expected. All
Lagrange polynomials are done like this.

```@repl FEMBase
B = MyQuad()
xi = (0.5, 0.5)
eval_basis!(B, N, xi)
```

In this case, and considering domain, partial derivatives of shape functions
are with respect to $X$, because interpolation polynomials are calculated
against real domain and not "reference domain". That is, partial derivatives
should match to what already calcualated.

```@repl FEMBase
eval_dbasis!(B, dN, xi)
```

Jacobian should be identity matrix:

```@repl FEMBase
J = jacobian(B, X, xi)
```

And taking gradient with respect to $X$ should return also same result than
before:
```@repl FEMBase
u = ([0.0, 0.0], [1.0, -1.0], [2.0, 3.0], [0.0, 0.0])
grad(B, u, X, xi)
```

Shape functions can be defined manually and calculate partial derivatives
automatically. For example, for pyramid elements typical ansatz approach is
not applicable. Some other degenerated elements exists in fracture mechanics.

For example, C1-continuous Hermite shape functions ready to approximate
Euler-Bernoulli beam equations can be defined as:

```@repl FEMBase
code = create_basis(
    :C1Hermite,
    "C1-continuous Hermite shape functions",
    (
        (0.0,),
        (0.0,),
        (1.0,),
        (1.0,)
    ),
    (
        "2*u^3 - 3*u^2 + 1",
        "u^3 - 2*u^2 + u",
        "-2*u^3 + 3*u^2",
        "u^3 - u^2"
    )
);
eval(code)
```

Again, we should have 1.0 in corresponding nodal point or it's derivative,
according to that order we have $u(0), u'(0), u(1), u'(1)$, so

```@repl FEMBase
B = C1Hermite()
N = zeros(1, 4)
dN = zeros(1, 4)
eval_basis!(B, N, (0.0,))
eval_dbasis!(B, dN, (0.0,))
eval_basis!(B, N, (1.0,))
eval_dbasis!(B, dN, (1.0,))
```

The last option is to build everything from scratch. For that, one must
import and define following functions:
- Base.size
- Base.length
- FEMBase.get_reference_element_coordinates
- FEMBase.eval_basis!
- FEMBase.eval_dbasis!

As an examples, a simple implementation of P-hierarchical 1d-basis would
then be the following:

```@example FEMBase
import Base: size, length
import FEMBase: get_reference_element_coordinates,
                eval_basis!, eval_dbasis!,
                AbstractBasis

type PSeg <: AbstractBasis
    order :: Int
end

function PSeg()
    return PSeg(1)
end

function length(basis::PSeg)
    return basis.order+1
end

function size(basis::PSeg)
    return (1, basis.order+1)
end

function get_reference_element_coordinates(basis::PSeg)
    return ((-1.0,), (1.0,))
end

nothing # hide
```

Next, define Legengre polynomials:

```@example FEMBase
"""
    get_legendre_polynomial(n)

Return Legendgre polynomial of order `n` to inverval ξ ∈ [1, 1].

Implementation uses Bonnet's recursion formula. See
https://en.wikipedia.org/wiki/Legendre_polynomials
"""
function get_legendre_polynomial(n)
    n == 0 && return xi -> 1.0
    n == 1 && return xi -> xi
    Pm1 = get_legendre_polynomial(n-1)
    Pm2 = get_legendre_polynomial(n-2)
    A(xi) = (2.0*n-1.0)*xi*Pm1(xi)
    B(xi) = (n-1.0)*Pm2(xi)
    return xi -> (A(xi)-B(xi))/n
end

"""
    get_legendre_polynomial_derivative(n)

Return derivative of Legendgre polynomial of order `n` to
inverval ξ ∈  [-1, 1]
"""
function get_legendre_polynomial_derivative(n)
    n == 0 && return xi -> 0.0
    n == 1 && return xi -> 1.0
    Pm1 = get_legendre_polynomial_derivative(n-1)
    Pm2 = get_legendre_polynomial_derivative(n-2)
    A(xi) = (2.0*(n-1.0)+1.0)*xi*Pm1(xi)
    B(xi) = (n+1.0-1.0)*Pm2(xi)
    return xi -> (A(xi)-B(xi))/(n-1.0)
end

nothing # hide
```

And finally implement `eval_basis!` and `eval_dbasis!` functions:

```@example FEMBase
function eval_basis!{T}(basis::PSeg, N::Matrix{T}, xi::Tuple{T})
    n = length(basis)
    t = xi[1]
    N[1] = 0.5*(1-t)
    N[2] = 0.5*(1+t)
    n < 3 && return N
    for i=3:n
        j = i-1
        P1 = get_legendre_polynomial(j)
        P2 = get_legendre_polynomial(j-2)
        N[i] = 1.0/sqrt(2.0*(2.0*j-1.0))*(P1(t)-P2(t))
    end
    return N
end

function eval_dbasis!{T}(basis::PSeg, dN::Matrix{T}, xi::Tuple{T})
    n = length(basis)
    t = xi[1]
    dN[1] = -0.5
    dN[2] = 0.5
    n < 3 && return N
    for i=3:n
        j = i-1
        P1 = get_legendre_polynomial_derivative(j)
        P2 = get_legendre_polynomial_derivative(j-2)
        dN[i] = 1.0/sqrt(2.0*(2.0*j-1.0))*(P1(t)-P2(t))
    end
    return dN
end

nothing # hide
```

Let's try it:

```@repl FEMBase
B = PSeg()
N = zeros(1, length(B))
eval_basis!(B, N, (0.0,))
B.order = 2
N = zeros(1, length(B))
eval_basis!(B, N, (0.0,))
```

![Hierarchical shape functions up to order 6](figs/pbasis.svg)


text:
# Authentication Flow

This document will detail the authentication flow Surfbird is following at the time of writing (and will be updated accordingly with changes)

### Account Request

As soon as the renderer process is loaded and the Vue mount is initialized, the process will send out a request to the main process using the
channel `surfbird:request:accounts`.

The main process is then returning all already authenticated accounts in an array over the `surfbird:get:accounts` channel. Now here are two
possible outcomes from this request:

1. If there are accounts available, they will be added to the store so that they are accessible in the renderer process
2. If no accounts were returned by the request, a modal prompting the user to authenticate with a service will be opened

### Authentication

If no account has been authenticated to Surfbird prior, a modal prompting the user to authenticate with a service will be opened.

On creation, the modal component will request all available services from the main process using the `surfbird:request:services` channel.

The main process is then returning all available services over the `surfbird:get:services` channel.

With the services available, the modal will generate links that enable a user to connect with the specified services. If a link is clicked,
a event will be fired that sends a authentication request to the main process on the `surfbird:authentication:start` channel, handing over `{ service: 'service-identifier' }` as a payload.

Back to the main process, after receiving the service identifier, it will initialize a new Authentication class with the supplied identifier,
calling the `authenticate` method, which will prompt the user to authorize Surfbird getting access to the users account on the service.

**Read more: [Authenticators](authenticators.md)**

Once authentication has been successful the received tokens will be sent back to the renderer process over the `surfbird:authentication:done`
channel. The main process receives the sent data and pushes the newly authenticated account into the store.

### Account Addition

_(both outcomes from the `surfbird:get:accounts` request lead here)_

Once the tokens have been received, an action `addAccount` with the tokens as payload will be dispatched to the store.

Inside the then committed state mutation `ADD_ACCOUNT` a new
Account class will be pushed into the state. On creation of this class, the API client for the corresponding service will be initialized with the given tokens.

**Read more: [Clients](clients.md)**

After the account has been added, another action `refreshUserInfo` will be dispatched, which not only verifies the authenticated user for valid tokens, but also returns user data. We take the user data and save it inside the corresponding account with the state mutation `REFRESH_USER_INFO` to have it available for displaying in the interface.

repository: opencollective/surfbird

repo_name: opencollective/surfbird


text:
# PTBalloonView / PTBalloonLabel

[![Version](https://img.shields.io/cocoapods/v/PTBalloonView.svg?style=flat)](http://cocoapods.org/pods/PTBalloonView)
[![License](https://img.shields.io/cocoapods/l/PTBalloonView.svg?style=flat)](http://cocoapods.org/pods/PTBalloonView)
[![Platform](https://img.shields.io/cocoapods/p/PTBalloonView.svg?style=flat)](http://cocoapods.org/pods/PTBalloonView)

PTBalloonView and PTBalloonLabel are the view and label, like balloon.
It is easy to use this balloon view and label.
And it can be set balloon's inflating and deflating animations.

|PTBalloonView|PTBalloonLabel|
|---|---|
|![PTBalloonView](https://raw.githubusercontent.com/pjocprac/PTBalloonView/master/Images/balloon_view.gif "PTBalloonView")|![PTBalloonLabel](https://raw.githubusercontent.com/pjocprac/PTBalloonView/master/Images/style_popshift.gif "PTBalloonLabel")|

## Description
PTBalloonView is a simple popup view like a balloon. The `contentView` property is used for your view to be shown in a balloon.

PTBalloonLabel is a simple popup label, which is subclass of PTBalloonView. It have additional properties, title, text, and buttons, instead of contentView.

## Requirements
iOS 8.0

## Installation

PTBalloonView is available through [CocoaPods](http://cocoapods.org). To install
it, simply add the following line to your Podfile:

```ruby
pod "PTBalloonView"
```

## Usage

At first, to popup balloon view is only code below. (shows empty balloon.)
```swift
let balloonView = PTBalloonView()
balloonView
    .contentView(UIView(frame: CGRectMake(0, 0, 120, 80))) // replace to your content view
    .inflate(TARGET_VIEW) // replace TARGET_VIEW to target view
```
and deflate balloon is only code below.
```swift
balloonView.deflate()
```

To popup PTBalloonLabel.
```swift
let balloonLabel = PTBalloonLabel()
balloonLabel
    .title("PTBalloonLabel Demo")
    .text("This balloon is PTBalloonLabel Demo")
    .addButton(title: "close", type: .Close)
    .inflate(TARGET_VIEW) // replace TARGET_VIEW to target view
```

Details, see the Demo and the [Class Reference](#ClassReference).

#### Balloon Style
To change balloon's style, you can use methods (named same as properties).

#### Balloon Animations
To change balloon's animations, `inflateAnimation()` and `deflatingAnimation()` methods can be used.

## Class Reference
[Class Reference](Documents/README.md)

## Demo
To run the example project, clone the repo, and run `pod install` from the Example directory first.

#### Balloon Animation
Balloon's pumping up and deflating animations can be selected.

|Pop|PopShift|Fade|
|---|---|---|
|![Pop](https://raw.githubusercontent.com/pjocprac/PTBalloonView/master/Images/style_pop.gif "Pop")|![PopShift](https://raw.githubusercontent.com/pjocprac/PTBalloonView/master/Images/style_popshift.gif "PopShift")|![Fade](https://raw.githubusercontent.com/pjocprac/PTBalloonView/master/Images/style_fade.gif "Fade")|

|FadeShift|Revolution|RevolutionShift|
|---|---|---|
|![FadeShift](https://raw.githubusercontent.com/pjocprac/PTBalloonView/master/Images/style_fadeshift.gif "FadeShift")|![Revolution](https://raw.githubusercontent.com/pjocprac/PTBalloonView/master/Images/style_revolution.gif "Revolution")|![RevolutionShift](https://raw.githubusercontent.com/pjocprac/PTBalloonView/master/Images/style_revolutionshift.gif "RevolutionShift")|

|Slide (can choose direction)|
|---|
|![Slide](https://raw.githubusercontent.com/pjocprac/PTBalloonView/master/Images/style_slide.gif "Slide")|

#### Target Animation
Target view's animations can be selected also. (It applies only when balloon inflating.)

|Pop|Blink|Rotation|Sway|
|---|---|---|---|
|![Target Pop](https://raw.githubusercontent.com/pjocprac/PTBalloonView/master/Images/target_style_pop.gif "Target Pop")|![Target Blink](https://raw.githubusercontent.com/pjocprac/PTBalloonView/master/Images/target_style_blink.gif "Target Blink")|![Target Rotation](https://raw.githubusercontent.com/pjocprac/PTBalloonView/master/Images/target_style_rotation.gif "Target Rotation")|![Target Sway](https://raw.githubusercontent.com/pjocprac/PTBalloonView/master/Images/target_style_sway.gif "Target Sway")|

## Author

Takeshi Watanabe<EMAIL_ADDRESS>
## License

PTBalloonView is available under the MIT license. See the LICENSE file for more info.

repository: galigalikun/PTBalloonView

repo_name: galigalikun/PTBalloonView


text:
# Edge Microgateway Setup

This directory provides profiles for API products, developers, and apps.

Directions:

1. If you do not have an account yet, register at:
>https://accounts.apigee.com/accounts/sign_up

2. In the file `../setenv.sh`, configure values for your
organization, username, environment.

3. Run `setup.sh` in this directory to create all sample entities.
```
 ./setup.sh
```

4. Enter your org admin password when prompted.

5. Enter `edgemicro_cloudfoundry` when prompted to enter the proxies to attach to the API product.

# Get help

For assistance, post to the Apigee Developer Forum:

http://support.apigee.com

Copyright 2013 Apigee Corporation

Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy
of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.


text:
# Text2HBM
This project contains artefacts from the project Text2HBM. The goal of the project is to develop methods for automatic generation of behaviour models from textual instructions. The models are later used for sensor-based activity recognition.

For more details, visit the project's website https://text2hbm.org/.


text:
Playground

A simple playground for HTML, CSS and JavaScript supporting module imports.

**Playground** is a HTML, CSS and JS demonstration component that runs entirely in the browser and does not require loading any third party sites.

## Usage

Install from `npm` with:

```
npm install @agney/playground
# OR
yarn add @agney/playground
```

```jsx
import Playground from "@agney/playground";
/* Why is there a tabs import? https://github.com/agneym/playground#why-is-there-a-reacttabs-import*/
import<EMAIL_ADDRESS>
const App = () => {
  const snippet = {
    markup: `<div id=app />`,
    css: ``,
    javascript: `import { h, Component, render } from 'preact';
import htm from 'htm';

const html = htm.bind(h);

const app = html\`<div>Hello World from Playground!</div>\`

render(app, document.getElementById('app'));`,
  };
  return (
    <Playground
      id="example"
      initialSnippet={snippet}
      defaultEditorTab="javascript"
      transformJs
    />
  );
};
```

## Demo

https://www.agney.dev/blog/introducing-playground

## Features

1. Load preview for predefined code.
1. Autoreloading preview.
1. Allows bare ES package imports. This means you can add imports for any library that supports ES Module resolution and playground will automatically load it into your code.
1. See console output in the component itself.
1. Control the tab loaded by default for your use-case.

## Applications

1. Add to static blogs to present your HTML, CSS or JavaScript code.
1. Allow users to change the code and see the output in real time.

## API

|      Props       |                                                   description                                                   |                                           default                                           | required |
| :--------------: | :-------------------------------------------------------------------------------------------------------------: | :-----------------------------------------------------------------------------------------: | :------: |
|        id        |                                       a unique identifier for the iFrame                                        |                                                                                |   true   |
|  initialSnippet  |                                          Initial code to be displayed                                           |                                                                                |   true   |
| defaultEditorTab |                Initial editor tab to be displyed. Possible values: "markup", "css", "javascript"                |                                          "markup"                                           |  false   |
| defaultResultTab |                Initial tab on result panel to be displayed. Possible values: "console", "result"                |                                          "result"                                           |  false   |
|   transformJs    |             Transform the JavaScript using Babel. This is required if you want bare module imports              |                                            false                                            |  false   |
|     presets      | Array of presets you want Babel to transform. This works only if transformJs is true. Eg. `["react", "es2015"]` |                                                                                |  false   |
|      theme       |                             Pass in the theme variables to customise the appearance                             | [Our Theme](https://github.com/agneym/playground/blob/master/playground/src/utils/theme.ts) |  false   |

### Format for initial snippet

```js
{
  markup: `<h1>Title</h1>`,
  css: `h1 { color: red }`,
  javascript: `console.log("this")`
}
```

### Why is there a @reach/tabs import?

Playground uses [`@reach/tabs`](https://reach.tech/tabs/) as a dependency. We could bundle the stylesheet or inject it inline on runtime. But both those options add unnecessary code if you are already using it.

_This might cause breaking changes if you have a different version of `@reach/tabs` but then I'm just expecting it to be stable along the road._

### How does module imports work?

If an NPM package exposes an endpoint for "module", then you can direcly import this package by it's name.

```js
import { format } from "date-fns";

format(new Date(2014, 1, 11), "yyyy-MM-dd");
```

Unfortunately, not all packages currently support this feature. You can search through an entire list of packages through [Skypack](https://www.skypack.dev/).

You can use community created packages to replicate the functionality. For eg. React would be:

```js
import React, { createElement } from "https://cdn.skypack.dev/react";
import ReactDOM from "https://cdn.skypack.dev/react-dom";

ReactDOM.render(
  createElement("div", {}, "Hello World"),
  document.getElementById("app")
);
```

### How do I demo React code with JSX?

```jsx
import Playground from "@agney/playground";

const App = () => {
  const snippet = {
    markup: `<div id=app />`,
    css: ``,
    javascript: `import React, { createElement } from "https://cdn.skypack.dev/react";
import ReactDOM from "https://cdn.skypack.dev/react-dom";

ReactDOM.render(
  <h1>Hello World</h1>,
  document.getElementById("app")
);`,
  };
  return (
    <Playground
      initialSnippet={snippet}
      defaultEditorTab="javascript"
      transformJs
      presets={["react"]}
    />
  );
};
```

## What about the bundle size?

The component is fairly small at about ![npm bundle size](https://img.shields.io/bundlephobia/minzip/@agney/playground). You can find the total size and time on [Bundle Phobia](https://bundlephobia.com/result?p=@agney/playground).

When transforming JavaScript it uses [Babel Standalone](https://babeljs.io/docs/en/babel-standalone) which adds a considerable size. Playground loads Babel from a CDN so that it can be loaded from browser cache on change.

It uses [Chrome's Native Lazy Loading](https://web.dev/native-lazy-loading/) so that the iframes for results are loaded lazily and your pages remain fast.

## Contributing

This project makes use of [Yarn Workspaces](https://yarnpkg.com/lang/en/docs/workspaces/) for development.

1. Run `yarn` for installing dependencies.

2. Run `yarn start` to start development on package.

3. To start example, run `yarn start-example`.

Pull Requests are Welcome. Please create an issue to discuss before making a feature or large change. Thank You :smile:

## Credits

Icons made by Freepik from www.flaticon.com

repository: agneym/playground

gha_language: TypeScript

repo_name: agneym/playground


text:
# neatbook

One line generates your Python project.  Save hours.

## Install

Run this command:

       pip install neatbook

## Using

1. Create a new project directory
2. Create a python file with this code inside that directory:

       from neatbook.neatbook import *
       Neatbook()

3. Execute this python script with the command line
4. Find and open the Jupyter Notebook created for you in the same directory
  - (Install anaconda if you would like to open Jupyter Notebooks)
5. Follow the instructions for installing TPOT here: http://epistasislab.github.io/tpot/installing/


text:
# e-commerce-backend
ORM Back-End

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

## Description
The following application is a back-end application for an e-commerce site. This uses the Express.js API to use Sequelize to interact with the e-commerce MySQL database.
It is meant to be used such that managers at retail companies may compete with other e-commerce companies by using the latest technologies in their backend.

## Installation
1. Open up Insomnia/POSTman, Workbench and your IDE of choice (I used VSCode)
2. Fork the repo and open in your IDE
3. Install Express.js, MySQL, Sequelize, dotenv
4. Import the database in Workbench, seed the database
5. Start the server and run all requests in Insomnia or Postman

## Usage
1. Seed database
2. Start the server
3. Run the appropriate requests in the Insomnia Core

## License
MIT License

Copyright (c) [2021] [Ishya Casukhela]

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

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

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

repository: casukhelai/e-commerce-backend

repo_name: casukhelai/e-commerce-backend


text:
# MetronicDataTableBundle
This bundle helps to implement data source actions for [mDataTables](https://keenthemes.com/metronic/documentation.html#sec14) JavaScript plugin when it's used in [remote-type processing](https://keenthemes.com/metronic/documentation.html#sec14) mode.

## Requirements

PHP needs to be a minimum version of PHP 7.0.

Symfony must be of 2.7 or above.

## Installation

### Step 1: Download the Bundle

Open a command console, enter your project directory and execute the following command to download the latest stable version of this bundle:

```console
composer require gesdinet/metronic-datatables-bundle
```

This command requires you to have Composer installed globally, as explained in the [installation chapter](https://getcomposer.org/doc/00-intro.md) of the Composer documentation.

### Step 2: Enable the Bundle

If you are using Symfony 3 or below, enable the bundle by adding it to the list of registered bundles in the `app/AppKernel.php` file of your project:

```php
public function registerBundles()
{
    $bundles = [
        // ...
        new Gesdinet\MetronicDataTableBundle\GesdinetMetronicDatatableBundle(),
    ];
}
```

In symfony 4+ this is no longer necessary :)

## Usage

Please see the complete usage example [here](../../wiki).

repository: gesdinet/MetronicDatatableBundle

gha_language: PHP

repo_name: gesdinet/MetronicDatatableBundle


text:
# [Advent of Code 2020](https://adventofcode.com/2020)
Solutions to the [Advent of Code](https://adventofcode.com/2020) Challenges for 2020

Written in [C#](https://docs.microsoft.com/en-us/dotnet/csharp/) and [.NET5](https://dotnet.microsoft.com/download/dotnet/5.0) using [Visual Studio Community](https://visualstudio.microsoft.com/vs/community/).

## [Day01](https://github.com/andrewboudreau/AdventOfCode_2020/blob/main/Day01/)
Finding target value by using a pairs of numbers. Used a hashset to see if the target difference of a sample exists.
The second day worked very easily based on the part 1 solution.
```csharp
if (values.Contains(target - value))
{
    return (value, target - value);
}
```

## [Day02](https://github.com/andrewboudreau/AdventOfCode_2020/tree/main/Day02)
Setting up the `InputStringParsers` pattern. Parsing data from the previous years was always a pain so I want to keep the step separate and simple this year.
Working with functions, simple fun, building a validation system. Trying very hard to keep the solution method simple by creating DSL but also SIMPLE SIMPLE SIMPLE!
```csharp
foreach (var input in inputLine)
{
    isValid += RepeatedCharacterRequirment(input.GetParameters(), input.GetPassword());
}
```

## [Day03](https://github.com/andrewboudreau/AdventOfCode_2020/tree/main/Day03)
Introduced the `Grid` and started building up `Common` namespace.

## [Day04](https://github.com/andrewboudreau/AdventOfCode_2020/tree/main/Day04)
Working more with C# records and a domain. Started using more `IEnumerable` with `yield return` which is feeling way more comfortable this year.
```csharp
public static IEnumerable<Passport> ToPassports(this IEnumerable<string> inputs)
{
    var passport = Passport();

    foreach (var line in inputs)
    {
        if (line == PassportDelimiter)
        {
            yield return passport;
            passport = Passport();
            continue;
        }

        var fields = line.Split(FieldDelimiter);
        foreach (var field in fields)
        {
            var (Key, Value, _) = field.Split(KeyValueDelimiter);
            passport.Add(new Field(Key, Value));
        }
    }
}

static Passport Passport()
{
    return new Passport(new List<Field>(8));
}
```

## [Day05](https://github.com/andrewboudreau/AdventOfCode_2020/tree/main/Day05)
Binary numbers! I really feel like my experience with emudev really helped identify the gimmick in this one. that the characters map directly to the binary value. I was so happy to be able to identify that when reading the problem initially. I created lots of variants cause, why not. `BinaryToIntegerWithLinqAggregate` `BinaryToIntegerWithForLoop`

```csharp
public static IEnumerable<BoardingPass> ToBoardingPasses(this IEnumerable<string> inputs)
{
    foreach (var encoded in inputs)
    {
        // take the first seven bits and create the binary version of that value
        var row = InputToInt(encoded[..7]);

        // take the last 3 bits and create the binary version of that value
        var column = InputToInt(encoded[7..]);

        yield return new BoardingPass(row, column);
    }
}

public static int InputToInt(this string encoded)
{
    var binary = encoded.Replace("F", "0").Replace("B", "1").Replace("L", "0").Replace("R", "1");
    return Convert.ToInt32(binary, 2);
}
```

## [Day06](https://github.com/andrewboudreau/AdventOfCode_2020/tree/main/Day06)
Some fun domain building, not sure if there is a much better approach, most likely. I do think you have to look at each item but I wonder if there is a a simple binary operations that can be applied in batch to find the requested queries.

## Previous Solutions
[2019 Solutions](https://github.com/andrewboudreau/AdventOfCode_2019/tree/master/AdventOfCode_2019)


text:
Building PiWeb API
==================

TL;DR
-----

* do development on "develop" branch or feature branches called "feature/<cool_new_feature>"
* do NOT do development on "master" branch
* use GitHub forks and pull requests, but do NOT merge to "master" branch
    * use development or feature branches instead
* put release notes into WHATSNEW.txt
* tag public versions with tags including the version number
    * beta releases with "v<version_number>-beta.n", e.g. "v1.1.0-beta10"
    * official releases with "v<version_number>", e.g. "v1.0.1"
* NuGet package is automatically built by AppVeyor
* publish NuGet package from AppVeyor to nuget.org
* merge official release tag to master branch

Comprehensive
-------------

PiWeb API is a .NET library packaged as NuGet. The NuGet packages are built automatically using
[AppVeyor](https://ci.appveyor.com/project/czjlorenz/piweb-api). There is also a build badge on
the README.md front page like this:

[![Build status](https://ci.appveyor.com/api/projects/status/q48run5x0ge40h9p?svg=true)](https://ci.appveyor.com/project/czjlorenz/piweb-api)

PiWeb API uses a branching model called
[Git Flow](http://nvie.com/posts/a-successful-git-branching-model/)
in order to provide bug fixes for stable releases. This means that the master branch
only contains stable code. Any development work is done either on a branch called "develop"
or on separate feature branches called "feature/<cool_new_feature>". Hotfixes are done
on branches called "hotfix/<bug_description>". Stabilization work towards a new
release (if required) is done on branches called "release/<target_version>". Once a
release is ready for deployment a tag called "v<version_number>", e.g. "v1.0.0", is
created. This tag is merged to the master branch. Therefore the master branch only
contains stable release code.

This branching model was first described by Vincent Driessen in
his blog entry
[A successful Git branching model](http://nvie.com/posts/a-successful-git-branching-model/).
A good overview and comparison with the simplifed
[Github flow](https://guides.github.com/introduction/flow/) can be found in the blog entry
[Git Flow vs Github flow](https://lucamezzalira.com/2014/03/10/git-flow-vs-github-flow/).

Version numbers of assembly and nuget package follow the rules set by
[semantic versioning](https://semver.org/). They are automatically created
from tags in the git repository using
[GitVersion](https://gitversion.readthedocs.io/en/latest/examples/).

The contents of the file WHATSNEW.txt is put into the release notes section
of the nuget. So in order to tell the users about the great new features
in the new version put a description into this file.

The build scripting should support GitHub flow as well as long as tags with version
numbers are created. You should be aware that with GitHub flow only bugfixes for the
current release are possible.

Unstable and release nuget packages are created by [AppVeyor](https://ci.appveyor.com/project/czjlorenz/piweb-api).
The AppVeyor [project feed](https://ci.appveyor.com/nuget/piweb-api) provides
an easy way to consume any built version including unstable versions.
Stable release nuget packages are meant to be deployed to nuget.org making them
official.

Known Issues
------------

In case the NuGet version is wrong, GitVersion and AppVeyor have an known incompatibility.
See issue [1289|https://github.com/GitTools/GitVersion/issues/1289] in GitVersion project.
This is fixed in the latest beta build v4.0.0-beta.13 of GitVersion which unfortunately
is not available on nuget.org. The workaround is not to have multiple branches pointing
to the very same commit.

repository: czjlorenz/PiWeb-Api

gha_license_id: NOASSERTION

repo_name: czjlorenz/PiWeb-Api


text:
# interviewAlgorithm
Goal: Give programmers the ability to see a compatibility rating with a job posting.  This will make applying for jobs a learning process instead of a hit or miss process.

Future Versions:
v0.1
  Read all user's repos and generate the following statistics:
    Total lines committed
    Total lines committed for each language
    Total languages (Ability to learn)
    Total commits
    Total commits within 30 minutes of another commit (communication)
    Total merged pull request from other users (communication)
    Total lines of documentation (wisdom)
    Frequency of commits (endurance)
    maybe more, maybe less

v0.2
  Get user's resume information from linkedin, need the follow:
    User's name
    Email
    Past jobs (Search through for languages, project names, etc)
    Languages
    Education

v0.3
  Create git coverage report of linkedin profile
    Show which languages are backed by git repositories, create list of up to ten commits for each language
    Show which projects have git repositories
    Show which languages are not back by git repositories
    Don't show which projects don't have git repositories (company projects would always be red and would get annoying)
    Show strength of each language (using some algorithm that accounts for total commits in language, last commit in language, 10000 hour rule, and other data that proves useful)

v0.4
  Given job description string, create a compatibility report
    Show languages in common with just profile
    Show languages in common with profile and git
    Highlight projects that match job description
    Show compatibility score (doesn't have to be right yet) (start with language strength vs years wanted in languages to compute score)

v0.5
  Compatibility report improvements
  Add pipeline, Coverage at 30%

v0.6
  Database integration to store past reports
    Add interest score to compatibility report (times compatibility score has increased)
    Future feature: alert companies when they are being targeted by an applicant (interest score of 5+)
  Coverage at 40%

v0.7
  Linkedin job postings
  Coverage at 50%

v0.8
  More compatibility report improvements
  Coverage at 60%

v0.9
  v0.9.0 - Team compatibility reports
    Alert users when another user is searching for a similar job so they can create a team to work on a project to benefit both of them
  v0.9.1 - Open source project compatibility reports
    Alert users when there is an open source project that would help their compability score with a job description
  Coverage at 70%

v1.0
  Get rid of programmer art, dead code, prettify code, get coverage above 80%


text:
# interactive-architecture

Interactive architecture diagrams for JavaScript.

## Examples

- Example:
  - interactive diagram: [spacetime.nypl.org/interactive-architecture/example](http://spacetime.nypl.org/interactive-architecture/example)
  - source code: [`example/index.html`](example/index.html)
  - SVG: [`example/example.svg`](example/example.svg)
- NYC Space/Time Directory architecture:
  - interactive diagram: [spacetime.nypl.org/architecture](http://spacetime.nypl.org/architecture)
  - source code: [github.com/nypl-spacetime/architecture](github.com/nypl-spacetime/architecture)
  - SVG: [`architecture.svg`](https://github.com/nypl-spacetime/architecture/blob/gh-pages/architecture.svg)

## Usage

Add the following JavaScript and CSS to your HTML:

```html
<head>
  <script src="http://spacetime.nypl.org/interactive-architecture/js/d3.v4.min.js" charset="utf-8"></script>
  <script src="http://spacetime.nypl.org/interactive-architecture/js/interactive-architecture.js" charset="utf-8"></script>
  <link rel="stylesheet" href="http://spacetime.nypl.org/interactive-architecture/css/interactive-architecture.css">
  <link rel="stylesheet" href="http://spacetime.nypl.org/interactive-architecture/css/markdown-popup.css">
</head>
```

Note: interactive-architecture needs [D3.js](https://d3js.org/) to work. You can use the version included in this repository, use a CDN, or use a local copy.

Then, add a container for the diagram:

```html
<body>
  <article>
    <div id='architecture'>
    </div>
  <article>
</body>
```

Finally, create the interactive architecture diagram using JavaScript:

```js
var config = {
  getHref: function (link) {
    return link.getAttribute('xl:href')
  },
  getStyle: function (href, link) {
    return {
      fill: 'rgba(255, 255, 255, 0)',
      strokeWidth: '2px'
    }
  },
  getPopupContents: function (href, link) {
    if (href.indexOf('https://github.com') >= 0) {
      return iA.gitHub.getReadme(href)
    }
  }
}

iA.architecture.create('#architecture', 'architecture.svg', config)
```

## Creating SVG diagrams

It's easy! Download and install [Omnigraffle](https://www.omnigroup.com/omnigraffle), create your architecture diagram and add links to each component's GitHub repository:

1. Go to the properties pane of an object;
2. Add an _Opens an URL_ action;
3. Add the HTTPS URL of the component's GitHub repository (or any other URL)

![](images/omnigraffle.png)

Or, if you don't want to use Omnigraffle, that's fine too! Just make sure architecture components
are contained by an `<a>` element with an `xl:href` attribute, like so:

```html
<a xl:href="https://github.com/nypl-spacetime/architecture">
  <path d="M 451 774 L 448 777 C<PHONE_NUMBER>5 449.34315 774 451 774 Z" />
  <text>
    <tspan>Architecture Diagram</tspan>
  </text>
</a>
```

If your SVG files use different namespaces for the `href` attributes (e.g. `xlink:href`), you can override the default namespace. See below for details.

## API

### `iA.architecture.create(element, svg, [config], [callback])`

Creates an interactive diagram from a SVG URL.

#### Parameters:

- `element`: query selector of element that will hold the diagram
- `svg`: URL of SVG file
- `config` (optional): configuration object
- `callback` (optional): function that is called when SVG is loaded and diagram is successfully created

#### Configuration:

```js
var config = {
  // SVG elements which contain the architecture diagram's components
  //   e.g. ellipse, rect, circle. Default is path.
  element: 'path',

  // Returns the attribute containing the component's URL. The link parameter
  //   is one of the diagram's SVG <a> elements.
  getHref: function (link) {
    // Example:
    return link.getAttribute('xlink:href')
  },

  // This function is called when a user clicks one the the diagram's
  //   components. The HTML returned by this function is displayed in a
  //   popup window. The return value can be a string, HTML, or a Promise
  //   returning HTML.
  getPopupContents: function (href, link) {
    // Example 1:
    return iA.gitHub.getReadme(href)

    // Example 2:
    return '💾💾 Popup contents! 💾💾'
  }
}
```

Configuration is optional; unspecified options are replaced by default options.

#### Styling:

interactive-architecture adds `interactive-architecture` class to the diagram's container element, you can use CSS to style components with links like this:

```css
.interactive-architecture a > path {
  stroke: #ef5526;
  stroke-width: 4px;
  fill: white;
}
```

Sometimes, it might be necessary to use CSS' `!imporant` rule:

```css
.interactive-architecture a > path {
  fill: red !important;
}
```

### `iA.gitHub.getReadme(org, [repo])`

Returns a Promise that will load the README.md file from the specified GitHub repository.

#### Parameters:

- `org`: GitHub username or organization of the README's repository
- `repo` (optional): name of the README's repository (if not specified, `getReadme` will assume the first parameter is a comlete repository URL)

## License

MIT

gha_language: HTML


text:
# MDC React Roadmap
We release a new version of MDC React every 2 weeks. We try and keep MDC React within one version of MDC Web. This roadmap is based of the [MDC Web roadmap](https://github.com/material-components/material-components-web/blob/master/ROADMAP.md), but specific to MDC React.

## Current Release
### 0.4.x - June 2018
- Depend on MDC Web 0.38.x
- New extended FAB
- New select

## Upcoming Releases

### 0.5.x - September 2018
- Depend on MDC Web 0.39.x
- New tabs
- New switch
- New chips
- New icon button

### 0.6.x - October 2018
- Depend on MDC Web 0.40.x
- New list
- New navigation drawer
- New menu
- New checkbox

### 0.7.x - November 2018
- Depend on MDC Web 0.41.x
- New dialog
- New select (drop down menu attached to a text field)
- New side sheet
- New radio

### 0.8.x - December 2018
- Depend on MDC Web 0.42.x
- Prefix and suffix support in Text Field