text:
# iOS Best Practices

This guide outlines the best practices I've collected working on various teams/projects.

## Introduction

## Table of Contents
* [Style](#style)
* [General Principles](#general-principles)
* [Object Collaboration](#object-collaboration)
* [Model View Controller](#model-view-controller)

## Style
Our [Style Guide](https://github.com/FlyingJalapeno/Objective-C-Style-Guide) contains information on formatting code and other concrete coding techniques. Because Objective-C is a dynamic language and is intimately intertwined with Cocoa and its conventions, the line between style and best practices tends to be a bit blurry.

## General Principles
Below are some general principles to guide you when architecting your code.

### Always use the highest abstraction possible
When choosing a technology for implementing behavior, always choose the highest level abstraction that meets your needs. This keeps you from introducing unneeded complexity too soon in your application (YAGNI / Pre-optimization).

Some examples:
AVPlayer vc RemoteIO
Autolayout vs Frame calculation code
NSNotifications vs KVO
NSOperations vc GCD

#### GCD
Although GCD is a lower level abstraction, the API is rather straightforward and quick to implement. This makes GCD / dispatch blocks extremely good for quickly trampolining to and from main thread or as a replacement for "performSelector:afterDelay".  However, if your code begins to require state or order of operation is important, you should move to something more structured like NSOperations.

### Immutability
When possible favor immutability in your objects. In practical terms, this means pass all needed information in during initialization. This reduces the complexity by reducing the number of possible states of your object.  This makes the objects implementations more straightforward to write since you do not have to worry about existence of properties and indeterminate states.

### Dependency Injection
With immutability comes dependency injection. In it's most basic form, this simply means passing all required parameters on initialization. This has a few effects - one is adding immutability, the other is declaring dependencies in a formal way that can be enforced at build time instead of at run time.

###  Subclass only if needed
Subclassing is useful for organizing code, but can quickly become rigid and hard to deal within Objective-C codebases. Cocoa encourages composition over subclassing, and expresses this through it's APIs. (Composition over inheritance)

Before subclassing, try the following:
1. Can I use a category instead?
2. Can I separate this into another object and use the delegate pattern to coordinate behavior?

#### View Controllers
Specifically, you should generally avoid creating an base View Controller class that is used throughout your app. Adding behavior in this way can make difficult to make visual changes to views later on. Additionally, view controllers from 3rd party libraries will be unable to inherit your custom behavior, and so you may end up duplicating code anyways.

Note: This is not proposing that you never create an abstract view controller class, instead keep such view controllers scoped to a specific set of related view controllers.

##### Use Categories to share UI code.
Building on the category principal, a great way to share code between your view controllers is to encapsulate flows and behaviors in category methods that can be accessed from all view controllers.

By adding a category to hold your logic, view controllers can now "opt in" to the behavior you defined

### What should be public
Only expose properties and methods needed by other classes.

#### Minimal
 You should always strive for publicly exposing the fewest number of properties and methods. This reduces the number entry points into the class which reduces the complexity of how the class can be used.

#### Expose all initialization parameters
Any parameters passed in during initialization should be exposed as a public, and if possible, a readonly property. This allows users of your class to differentiate between instances using the arguments passed in when creating them.

### Structure and complex behavior
NSOperations (or something like BFTask in [Bolts](https://github.com/BoltsFramework/Bolts-iOS)) are good abstractions for asynchronous, dependent tasks. (Command Pattern)

These types of classes provide structure to your business rules and workflows and encapsulate that behavior into a concrete object while providing a standard API for progress, cancelation, and errors.

### Global Access
In general global access should be avoided when possible. Sometimes it appropriate - one example is a user session which may be needed by many classes in an app. It can be overkill to pass this as a initializer parameter in every class, so this is a good candidate for global access.

#### Singletons
The most common way to provide global access. Singletons should be used sparingly. Refrain from having any view controller or view singletons - most of the time you can scope the behavior to specific class or a category (add a UIViewController category). Many times a singleton sees like a good idea, but eventually you may need "2" of that object - and many assumptions your code made will be wrong. Singletons also make unit testing much harder.

#### App Delegate
It is common for people to use the App Delegate as a singleton - which in turn leads to the app delegate containing and externalizing objects that are not its responsibility. Many times people do this to get a reference to the entry point of the view(controller) hierarchy - try creating a purpose built object for this instead.

#### NSObject Categories
Adding categories to NSObject usually is a bad idea - since almost everything is an NSObject. Try to better scope your code.

## Object Collaboration
### Types of communication
Depending upon the situation, use an appropriate communication pattern. The standard patterns are below listed in order of increasing complexity.

#### Message
Simply passing a message to an object and invoking a method. This is the most basic form of communication in Cocoa/Objective-C.

#### Target/Action
A form of message passing bound to specific control states. This is only used for views communicating to other views or view controllers.

#### Blocks
Invoking a block of code before/after a task. Useful for asynchronous communication. A great way to decouple the message sender from the actual code that is executed. Can also send back "responses" via the block return value. Usually defined in line, so intent can be more clear than using delegation.

#### Delegation
A more specific form of message sending implemented through the use of protocols and is thus more loosely coupled as the sender does not know the receivers type.  Useful for Informing another object before/after a task, or asking "should" this action take place. "Ok" for asynchronous communication, but with a little more overhead than a block.  that also allows for "responses" via the method return value.

#### Notification Center
Posting a notification before/after task, useful for notifying multiple objects. Although it is more overhead, it is a more formal way to specify specific events,

#### KVO
Fine grained notifications at a property level. This is the most verbose and error prone of the techniques, and in general should be avoided if possible. If it must be used, look into a more resilient 3rd party wrapper like [MAKVONotificationCenter](https://github.com/mikeash/MAKVONotificationCenter) or [ReactiveCocoa](https://github.com/ReactiveCocoa/ReactiveCocoa).

### Communication Strategies
Based on the types of objects involved, below is a list of appropriate ways to communicate:

#### Views
##### View -> View
- Message
- Delegation
- Target/Action

##### View -> View Controller
- Blocks
- Target/Action
- Delegation

##### View -> Model Controller
- NEVER

##### View -> Model
- NEVER

### View Controllers
##### View Controller -> View
- Message

##### View Controller -> View Controller
- Use the Model Layer to communicate changes
- Delegation
- Blocks

##### View Controller -> Model Controller
- Message

##### View Controller -> Model
- Message

### Model Controllers
##### Model Controller -> View
- NEVER

##### Model Controller -> View Controller
- Block
- Notification
- KVO
- Delegation (not preferred for long lived objects that can change delegates)

##### Model Controller -> Model Controller
- Block
- Notification
- KVO
- Delegation (not preferred for long lived objects that can change delegates)

##### Model Controller -> Model
- Message

### Models
#### Model -> View
- NEVER

##### Model -> View Controller
- Notification
- KVO

##### Model -> Model Controller
- Notification
- KVO

##### Model -> Model
- Message
- KVO - maybe, more limey this should be in a Model Controller

## Model View Controller
In general you should follow Apple guidelines and design your apps using MVC principals. Practically that breaks down into the following:

### Models
Make your models "dumb".  Do not place methods on the models that control behavior. Models should reflect state.

They should not contain methods that control behavior. These methods should be contained in controller objects.

Methods on model objects should largely be confined to lazy and stateless data transformation, like returning a date as a string, or a sorted array of its children.

#### Concrete Models vs Generic Collections
When possible you should always use custom subclasses and protocols model objects to represent your data. Using NSDictionaries and NSArrays to pass around data leads to more verbose code (ex. accessing values by key) and ambiguity of data types. Using the language features is leads to more understandable and expressive code.

### Controllers
Controllers come in two broad flavors.

#### View Controllers
The primary purpose for view controllers is:

1. Control the navigation of the application
2. Provide a bridge models and views. They pull in data and push it out to the views in the form they need.

Beyond this, view controllers tend to be a dumping ground for all code without a home. Look for ways to remove code by using collaborating objects. Below are some common behaviors that are included in View Controller implementations that can easily be moved into other files.

##### Datasources
A great way to reduce the amount of code in view controllers is to remove the boilerplate code for table views and collection views. This is a technique covered extensively on [objc.io](http://www.objc.io/issue-1/lighter-view-controllers.html).

##### Layout
Layout code should be contained in Nibs, Storyboards, or custom view classes (or in the case of collection views, layout classes).

##### Business Logic
Business logic, domain knowledge should be placed where it can be shared among view controllers - use Model Controllers and Models.

#### Model Controllers / Services
Model Controllers should perform model manipulations that are UI independent (like network and processing) exception: user input . Use these to encapsulate business logic, algorithms, and rules. Anything that doesn't require a UI class should be put in these objects so they can be shared in different parts of the code base. This also perpetuates composition over subclassing, i.e. placing behavior in a shared component instead of View Controller abstract superclass.

### Views
Views should encapsulate layout code.

#### Plan for updates and animations
Place code that updates your views based on the model in a separate method in your view controller, like:

```objc
- (void)updateViewAnimated:(BOOL)animated;
```

Call this method whenever you need to update the view. The animated flag gives you the opportunity to animate changes as well. This also plays nicely with lifecycle methods:

```objc
- (void)viewDidAppear:(BOOL)animated{
  [super viewDidAppear:animated];
  [self updateViewAnimated:animated];
}
```

#### Auto Layout
Auto Layout was designed to allow rapid UI development when working with multiple screen sizes and localized content. It also provides a high level abstraction (constraints) to describe layouts.

Auto Layout should be favored over old style springs and struts autoresizing behavior and frame calculations in code which can be difficult to maintain and understand.

#### Nibs vs Storyboards vs Code
In general use the highest level abstraction you can. In order:

##### Storyboards
Storyboards are great for static workflows. For complex applications, one storyboard is onerous, if not impossible. In that case you can use multiple storyboards, each confined to a specific workflow. Login/Signup flows are great candidates for this.

If your workflows are more dynamic, then storyboards provide little advantage over a traditional nib (Except: Only Storyboards have access to certain new features like static table views and prototype cells.

##### Nibs
Nibs are great for table view cells and collection view cells, as well as views that do not play nicely with storyboards (You need several top level objects to construct your view).

#### Code
Writing layout code is a necessity when performing animations. Remember that many times you can do your initial layout in a Nib/Storyboard, and modify the views in code at runtime.

If using Nibs/Storyboards with Auto Layout, you will need to expose your constraints as IBOutlets to modify them in code.

### Minimum Supported OS
If possible, support only 1 OS prior to the current OS, with an eye on dropping support each summer as major OS betas are released.

repository: FlyingJalapeno/iOS-Best-Practices

repo_name: FlyingJalapeno/iOS-Best-Practices


text:
---
layout: post
title: Content formatting in this blog
tags: HTML Markdown Blogging
shortinfo: Here I show the Markdown syntax one can use to make HTML documents appear on the web, and some of the tools I have built to make reading this blog easier and more appealing.
mathjax: true
---

## The default HTML and Markdown syntax
---

Compared to other computer languages I know, HTML is incredibly bloated. For example, the tags used in HTML, say the body tag `<body>` needs an ending tag `</body>` once you are done filling out the content, and all of the style changes or other specificities are crammed into the parent tag. This has the effect of making HTML documents look ridiculously messy.

This is why web development seems to have split into three separate entities, HTML/Markdown, CSS, and JavaScript. HTML serves as the main language with which your browser translates the content to display on your screen. CSS serves as a separate file that contains all information regarding the styling and formatting of content, so that the programmer does not need to cram all of the style code into HTML tags. Javascript is there to take care of any more complicated functionality you may require to code by hand. Some genius (John Gruber) invented Markdown as a more user-friendly alternative to the main content specifications in HTML, translating from a more intuitive layout to raw HTML. Here is how you use some of the basic functions:

| Formatting Type   | Markdown Syntax   |
|-------------------|-------------------|
| paragraph text    |`paragraph text`   |
| *italic*          |`*italic*`         |
| **bold**          |`**bold**`       |
| ***both***        |`***both***`       |
| ~~strikethrough~~ |`~~strikethrough~~`|
| `inline codeblock`|`` `inline codeblock` ``  |

Markdown was never meant to be an exhaustive list of syntax re-mapping for HTML, so there are many things you might find missing. Luckily, raw HTML syntax is still valid inside Markdown documents. This is great for practically any specific text manipulation you might need, just not so great for your eyes. Here are some things I use that are not in Markdown by default:

| Formatting Type           | HTML Syntax                     |
|---------------------------|---------------------------------|
| somesuperscript| `some<sup>superscript</sup>`    |
| somesubscript  | `some<sub>subscript</sub>`      |
| HTML |`<abbr title="HyperText Markup Langage">HTML</abbr>`|
| insert          |`<ins>insert</ins>`               |

## Other Markdown syntax
---

If you need to quote a large amount of text, you can do this in blockquotes:

> This is a blockquote. The default HTML syntax for this is messy:
> `<blockquote>text</blockquote>`, but in Markdown this same thing is achieved with:

```
> greater-than symbols in front
> of your text elements
```
Making the Markdown document look much cleaner. Keep in mind that all of the formatting and styling of the specific blockquotes, tables, etc., shown here are done with CSS outside of the Markdown file. How did I do that large code block you ask?

## Syntax Highlighting
---

Sometimes you need to show literal code in your documents. Luckily this works great, for a huge library of languages, natively. Just specify the language you want in three backticks, like this:

{% highlight markdown%}
``` mathematica

a=4;
b=3;
Times[3,4]

function[x_,y_]:= x^2+y^2

```
{% endhighlight %}

The above markdown code yields:

``` mathematica

a=4;
b=3;
Times[3,4]

function[x_,y_]:= x^2+y^2

```

## Lists
---

You can make ordered and unordered lists using the Markdown syntax. You can use

* Asterisks
* Dashes
* or Pluses

to make your list elements just like

```
* Asterisks
- Dashes
+ or Pluses
```

and no matter what you use, Markdown will format it the same way. Ordered lists are made with numbers following a dot, but they don't have to be in order in Markdown. A random order like this

```
3. randomly
1. ordered
2. list
```
will still format ordered in your final document:

3. randomly
1. ordered
2. list

## Tables
---

You can build tables in the Markdown document just like they might look in the document. The only important features are that there are at least three dashes in each column, and the positions of the colons define left, center, and right aligned table elements. Here's an example:

```
| The Table | Contents | Go Here  |
|:----------|:--------:|---------:|
|left       |  center  |     right|
```

Yields the following:

| The Table | Contents | Go Here    |
|:----------|:--------:|-----------:|
|left       | center   |  right     |

Hopefully that helped a little if you are currently new to this like I was.

## kramdown
____

Jekyll, the engine I use to compile this website, uses by default an extension of Markdown called kramdown.  One of these nice additions is the ability to add classes/ids to paragraph elements. For example, I defined several custom message classes using CSS, and to use them, I can specify that they are meant to be those classes by adding some kramdown code, like so:

```
This warning block can be used to bring attention to a very
important item that is crucially not missed by the reader.
{: class="message warning"}
```

These classes can be used to bring attention to in-line text that I don't want the reader to miss (inspired by those you can find on the Jekyll website) and they come in four different forms.

This warning block can be used to bring attention to a very important item that is crucially not missed by the reader.
{: class="message warning"}

This note block can act as a sort of footnote that I want the reader to read now rather than at the bottom of the page.
{: class="message note"}

This tip block can be used to show little pieces of information that may make following a tutorial easier if the reader is not as familiar with the framework.
{: class="message tip"}

This example block can be used to showcase short examples to make a concept more clear.
{: class="message example"}

## MathJax
---

MathJax is the display engine you use if you want beautiful math formatting online. According to them:

> (MathJax is) a JavaScript display engine for mathematics that works in all browsers.
> No more setup for readers. It just works.

It works with kramdown just fine, and uses the well-known $$\mathrm{\LaTeX}$$ math-typesetting syntax.

To use it, as is recommended on their website, you include the following in the head of your HTML:

``` html
<script
src="https://polyfill.io/v3/polyfill.min.js?features=es6">
</script>
<script id="MathJax-script" async
<EMAIL_ADDRESS></script>
```
{: style="font-size: 95%;"}

This will ensure that your website will always use the latest version of MathJax.

In this blog, I decided to use a constant version, so that I don't have to deal with future versions changing the format as I like it, so I used the following instead:

``` html
<script type="text/javascript" async
  src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.7/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
</script>

<script type="text/javascript" id="MathJax-script" async
<EMAIL_ADDRESS></script>
```
{: style="font-size: 93%;"}

To use MathJax, you wrap "display mode math" $$\mathrm{\LaTeX}$$ code in double dollars (`$$...$$`), and inline math in single dollars (`$...$`). Here is a quick example of how you might write an article involving spherical harmonics in kramdown:

```
The spherical harmonics are defined based on Laplace's
equation

$$
\nabla^2 f(r,\theta,\phi)=0\,,
$$

where the Laplacian operator $\nabla^2$ in spherical
coordinates is

$$
\nabla^2 = \frac{1}{r^2}\frac{\partial}{\partial r}\left(r^2\frac{\partial}{\partial r}\right)+\frac{1}{r^2\sin(\theta)}\frac{\partial}{\partial \theta}\left(\sin(\theta)\frac{\partial}{\partial \theta}\right)+\frac{1}{r^2\sin^2(\theta)}\frac{\partial^2}{\partial\phi^2}\,.
$$
```
{: style="font-size: 95%;"}

Which fully rendered yields:

_______

The spherical harmonics are defined based on Laplace's equation

$$
\nabla^2 f(r,\theta,\phi)=0\,,
$$

where the Laplacian operator $\nabla^2$ in spherical coordinates is

$$
\nabla^2 = \frac{1}{r^2}\frac{\partial}{\partial r}\left(r^2\frac{\partial}{\partial r}\right)+\frac{1}{r^2\sin(\theta)}\frac{\partial}{\partial \theta}\left(\sin(\theta)\frac{\partial}{\partial \theta}\right)+\frac{1}{r^2\sin^2(\theta)}\frac{\partial^2}{\partial\phi^2}\,.
$$

____

Which is just as good as $\mathrm{\LaTeX}$ for my puposes anyway.

license: MIT

branch_name: refs/heads/master

extension: md

gha_language: CSS

gha_license_id: NOASSERTION

license_type: permissive


text:
# njk: powerful portable templating

*njk* is a single binary command line application designed to provide powerful
templating capabilities using environment variables.

Its primary use is to build configuration files at boot time in containerized
environments.

*njk* stands on shoulders of giants. It uses [Nunjucks](https://mozilla.github.io/nunjucks/)
as the templating engine and [QuickJS](https://bellard.org/quickjs/) as the
runtime. The result is **a statically linked binary which is < 1MB**.

**NOTE:** Windows is not currently supported.

## Usage

```bash
./njk /path/to/template-file.njk > /config/your-config-file
```

Example:

```
Hello, {{ env.USER }}
```

## Documentation

Check the [Nunjucks documentation on templating](https://mozilla.github.io/nunjucks/templating.html).

**NOTE:** Templates get a single context variable: `env` containing the environment
variables.

## Similar tools

* [frep](https://github.com/subchen/frep)

repository: saghul/njk

gha_language: C

gha_license_id: MIT

repo_name: saghul/njk


text:
![Example](circle.png)

## Installation for Telegram usage
Follow the installation below
run a webserver on port 80 or 443
set path in ./src/image.js (line: 68) & ./launch.js (line: 17) to the webserver root directory
set url in ./launch.js (line: 17)
enter telegram bottoken in secret.json.example and remove .example
```shell script
npm i telebot
node launch.js
```

# Twitter Interaction Circle

Originally from [Twopcharts](https://twopcharts.com/) it has been making the round in the dev community.
I believe this is a great opportunity for a project to learn from.
The concept is easy and straightforward but the realization encompasses a lot of concepts.

You can read more about the realization of this project on the [HackerTyper Blog](https://blog.hackertyper.net/post/twitter-interaction-circles-guide/)

## Installation
```shell script
git clone git@github.com:duiker101/twitter-interaction-circle.git
cd twitter-interaction-circle
yarn install
```

Run with
```shell script
yarn build
```

You can also generate a text version of the image with the complete list of the presented users with the following command
```shell script
yarn build --text
```
The output will go in `users.txt` file in the root of the project

## Setup
To use the project you will need Twitter API keys. You can get one on the [developer portal](https://developer.twitter.com).

Once you have them, rename the `.env.example` file `.env` and put them in there, it should look like this:

```dotenv
CONSUMER_KEY=AAAAAAA
CONSUMER_SECRET=BBBBBBB
ACCESS_TOKEN_KEY=CCCCCCC
ACCESS_TOKEN_SECRET=DDDDD
```

Make sure you don't have spaces.

## Modifications

If you wish, you can replace the first part of the main loop in the `index.js` to use the getUser() function instead of getMe().
This will allow you to generate the circles for any public Twitter user. All the API methods used take advantage only of public data.

## Challenges

You can try to apply the following changes to test your knowledge:
- Apply a shade to  each avatar based on the most common type of interaction
- Fetch the circles for another user
- Render a grid instead of the circles

branch_name: refs/heads/main


text:
Welcome to GitExplorer 👋

### 🏠 [Homepage](https://github.com/Falkaniere/gitExplorer#readme)

---

## Get started

For GitExplorer to work in development, you need to follow the steps below

---

To install **Chocolatey** run in a PowerShell run the command below

~~~sh
Set-ExecutionPolicy Bypass -Scope Process -Force; iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'))
~~~

Finished, close the PowerShell adn run the following commands on prompt like **administrator**

~~~sh
choco install git
~~~

~~~sh
choco install nodejs
~~~

~~~sh
choco install yarn
~~~

---

To clone and install all dependences, run the command below

~~~sh
git clone https://github.com/Falkaniere/gitExplorer.git

cd gitExplorer

yarn install

~~~

## 🤝 Contributing

Contributions, issues and feature requests are welcome!
Feel free to check [issues page](https://github.com/Falkaniere/gitExplorer/issues).

## Show your support

Give a ⭐ if this project helped you!

license: ISC

repository: Falkaniere/gitExplorer

repo_name: Falkaniere/gitExplorer


text:
# _Anagram or Antigram?_

#### _A practice application using Ruby, Gem & Pry. 5.8.2020_

#### By _**Allison Mackey**_

## Description

_This application will allow the user to enter two words and return a true or false statement to them. True if the two words are anagrams, false if they are not._

## Setup/Installation Requirements

* _Clone Repository from GitHub : https://github.com/amackey693/Week8CodeReview.git
* _Open folder in Virtual Studio Code (or your text editor of choice)_
* _Open your terminal in Virtual Studio Code & type code . this will open all files associated with this app.
* _Before you initialize GIT, be sure to delete the already exisiting .git file by running this command in your terminal $rm -rf .git_
* _Create your own repository and push new changes to GitHub_

## Behavior Driven Development

|   Behavior Description        |
|-------------------------------|
| 1. Allows user to input two words [X]|
| 2. Splits each word into an array [X]|
| 3. Iterates over each ltr of the array to compare[X]|
| 4. Returns true if they contain the same letters [X]|
| 5. Returns false if they do not contain the same letters [X]|
| 6. Accounts for case sensitivity [X]|
| 7. Accounts for multiple words w/ spaces & punctuations [X]|

## Known Bugs

_No known bugs at this time_

## Support and contact details

_If you have any questions or any issues please feel free to submit an issue here: https://github.com/amackey693/Week8CodeReview.git_

## Technologies Used

_Ruby, Gem, Pry_

### Licenses
*MIT LICENSE*

Copyright (c) 2020 **_Allison Mackey_**


text:
## How to get Apple Pay private key

### 1. Export your private key as .p12

Open your Keychain Access, locate your Apple Pay private key, export it as .p12 file.

### 2. Convert .p12 to .pem
    $ openssl pkcs12 -in YourPrivateKey.p12 -nodes -out YourPrivateKey.pem

### 3. Print private key
    $ cat YourPrivateKey.pem

### 4. You got the private key

The base64 encoded string between `BEGIN` and `END` is your private key.

    <REDACTED_PRIVATE_KEY>

Then you are able to use it like below

    var p = new ApplePayParameters
    {
        PrivateKey = "{Your-Private-Key-Is-Here}"
    };

## License

Licensed under the [MIT](LICENSE) License.

repository: chengbo/ApplePayAndroidPayDecryption

repo_name: chengbo/ApplePayAndroidPayDecryption


text:
# IntuBuilder

Learning new algorithms has always been a challenging task for beginners. Let alone grabbing the intuition of how the algorithm works under the hood is an even challenging problem. There are many people who just memorize the algorithms in the start rather than really learning how does it work under the hood, many are never able to develop the intuition for that.

My project which I am calling “IntuBuilder” is an attempt to solve this exact problem by providing interactive and visual proofs of how an algorithm works underneath the surface along with providing underlying theory and concepts of the various algorithms in a fun and interactive way so that the processes of learning and building intuition of algorithms becomes easier for everybody.

The project itself is built in “Python” language which uses the 'Pygame' framework to deliver interactive and visual proofs for algorithms.

Each algorithm will contain a wiki page and a help menu.

- The main tool through which we can interact and visualize the algorithm.
- The wiki page will have all the theory and resources to master the algorithm.
- And the help menu will guide us on how to use the tool to visualize and interact with the algorithm.

The project itself will cover visualization, analysis, and theory of algorithms falling under the following domain:

- Graph Algorithms
- Fast Fourier Transformation
- Sorting Algorithms
- Huffman encoding
- Dynamic programming Algorithms
- Some basic algorithms like Fibonacci etc.

repository: Naval-surange/AAD-project

repo_name: Naval-surange/AAD-project


text:
# GRAFIMO tutorials

In this directory are contained two hands-on tutorials on **how to search motif occurrences in VGs** and on **how to build a genome variation graph (VG) with GRAFIMO**.

## Searching for motif occurrences in genome variation graphs

The directory `findmotif_tutorial` contains a Shell script with an hands-on tutorial on how to search potential motif occurrences in
VGs with GRAFIMO.

The content of `findmotif_tutorial` is:
- **`findmotif_tutorial.sh`**: Shell script describing how to search motif occurrences on genome variation graphs. In the script are shown
a simple motif search with GRAFIMO and some advanced options. Given that GRAFIMO, VG, Tabix and GraphViz are installed in your system and are
reachable via Unix `$PATH`, you can run the script to inspect the output.
- **`data` directory**: directory containing the data used during the tutorial steps

Please note that data used for the tutorial are simple toy examples.

## Building genome variation graphs with GRAFIMO

The directory `buildvg_tutorial` contains a Shell script with an hands-on tutorial on how to build genome variation graphs with GRAFIMO,
by using a reference genome FASTA file and a VCF file.

The content of `buildvg_tutorial` is:
- **`buildvg_tutorial.sh`**: Shell script describing how to build genome variation graphs with GRAFIMO. In the script are shown
a simple motif search with GRAFIMO and some advanced options. Given that GRAFIMO, VG, Tabix and GraphViz are installed in your
system and are reachable via Unix `$PATH`, you can run the script to inspect the output.
- **`data` directory**: directory containing data used during the tutorial steps

Please note that data used for the tutorial are simple toy examples.

repository: pinellolab/GRAFIMO

gha_language: Python

repo_name: pinellolab/GRAFIMO


text:
---
layout: post
title: "Continuous Integration,delivery,deploy"
categories: DevOps
tags: [DevOps]
image:
  feature: seaside-06.jpg
  teaser: seaside-06.jpg
  credit:
  creditlink:
---

Continuous Integration,continuous delivery and continuous deploy are terms used a lot into software world. But I think, in most cases, are used in the wrong way, by me in the first place.
I have read the guide to dev ops of DZone and I found a very simple and clear definitions of these things:

Continuous Integration is a software development practice in which you build and test software every time a developer pushes code to the application.

Continuous Delivery is a software engineering approach in which continuous integration, automated testing, and automated deployment capabilities allow software to be developed and deployed rapidly, reliably, and repeatedly with minimal human intervention. Still, the deployment to production is defined strategically and triggered manually.

Continuous Deployment is a software development practice in which every code change goes through the entire pipeline and is put into production automatically, resulting in many production deployments every day. It does everything that Continuous Delivery does, but the process is fully automated; there’s no human intervention at all.

So, at first sight, these are the definitions of the same thing, but it isn’t. Continuous integration stops at test stage, continuous delivery make a more step and stops at manually deployment to production. Continuous Deployment makes the last step and deploy automatically software to production.

I think is important to keep in mind these differences in order to make the right choose in your software production chain.


text:
---
layout: guide
doc_stub: false
search: true
enterprise: true
section: GraphQL Enterprise - Object Cache
title: Runtime Considerations
desc: Settings and observability per-query
index: 4
---

With caching configured, here are a few more things to keep in mind while queries are running.

## Skipping the cache

You can set `skip_object_cache: true` in your query `context: { ... }` to disable `ObjectCache` for a given query.

## Manually adding an object to caching

By default, `ObjectCache` gathers the objects "behind" each GraphQL object in the result, then uses their fingerprints as cache keys. To manually register another object with the cache while a query is running, call `Schema::Object.cacheable_object(...)`, passing the object and `context`. For example:

```ruby
field :team_member_count, Integer, null: true do
  argument :name, String, required: true
end

def team_member_count(name:)
  team = Team.find_by(name: name)
  if team
    # Register this object so that the cached result
    # will be invalidated when the team is updated:
    Types::Team.cacheable_object(team, context)
    team.members.count
  else
    nil
  end
end
```

(When the cache is disabled, `cacheable_object(...)` is a no-op.)

## Measuring the cache

While the cache is running, it logs some data in a Hash as `context[:object_cache]`. For example:

```ruby
result = MySchema.execute(...)
pp result.context[:object_cache]
{
  key: "...",                 # the cache key used for this query
  write: true,                # if this query caused an update to the cache
  ttl: 15,                    # the smallest `ttl:` value encountered in this query (used for this query's result)
  hit: true,                  # if this query returned a cached result
  public: false,              # true or false, whether this query used a public cache key or a private one
  messages: ["...", "..."],   # status messages about the cache's behavior
  objects: Set(...),          # application objects encountered during the query
  uncacheable: true,          # if ObjectCache found a reason that this query couldn't be cached (see `messages: ...` for reason)
}
```

repository: rmosolgo/graphql-ruby

gha_language: Ruby

repo_name: rmosolgo/graphql-ruby


text:
---
title: "The Devil All the Time (2020) Tamil Dubbed HD"
date: "2020-10-09"
---

##  The Devil All the Time (2020) | Dubhoodtamil

[![](https://1.bp.blogspot.com/-5TfxlDhKp6M/X4ABJC3RI2I/AAAAAAAACp8/FKhv9fReNvcSP_vFBcIrbkmpE3x-QyBUACNcBGAsYHQ/w295-h436/MV5BZmE1NmVmN2EtMjZmZC00YzAyLWE4MWEtYjY5YmExMjUxODU1XkEyXkFqcGdeQXVyMTkxNjUyNQ{7c91919003b18fbfe18f8d0a8715b92cf9e57c9a8b9d318e5deae4019927ce00}2540{7c91919003b18fbfe18f8d0a8715b92cf9e57c9a8b9d318e5deae4019927ce00}2540._V1_.jpg)](https://1.bp.blogspot.com/-5TfxlDhKp6M/X4ABJC3RI2I/AAAAAAAACp8/FKhv9fReNvcSP_vFBcIrbkmpE3x-QyBUACNcBGAsYHQ/s2048/MV5BZmE1NmVmN2EtMjZmZC00YzAyLWE4MWEtYjY5YmExMjUxODU1XkEyXkFqcGdeQXVyMTkxNjUyNQ{7c91919003b18fbfe18f8d0a8715b92cf9e57c9a8b9d318e5deae4019927ce00}2540{7c91919003b18fbfe18f8d0a8715b92cf9e57c9a8b9d318e5deae4019927ce00}2540._V1_.jpg)

Movie : The Devil All the Time (2020)

Director : Antonio Campos

Starring : Robert Pattinson, Tom Holland

Genres : Crime, Drama, Thriller

Quality : BDRip

Language : Tamil

Rating : 5.4/10

Synopsis: Sinister characters converge around a young man devoted to protecting those he loves in a postwar backwoods town teeming with corruption and brutality.

## **Click Below  To Download Movie**

**[Download 342MB](https://oncehelp.com/the-devil-1)**

**[Download 517MB](https://oncehelp.com/the-devil-2)**

By Dubhoodtamil


text:
# grunt-i18n-properties

> grunt plugin for converting java property i18n and l10n files to javascript source or json

## Getting Started
This plugin requires Grunt `~0.4.5`

If you haven't used [Grunt](http://gruntjs.com/) before, be sure to check out the [Getting Started](http://gruntjs.com/getting-started) guide, as it explains how to create a [Gruntfile](http://gruntjs.com/sample-gruntfile) as well as install and use Grunt plugins. Once you're familiar with that process, you may install this plugin with this command:

```shell
npm install grunt-i18n-properties --save-dev
```

Once the plugin has been installed, it may be enabled inside your Gruntfile with this line of JavaScript:

```js
grunt.loadNpmTasks('grunt-i18n-properties');
```

## The "i18n" task

### Overview

i18n converts a bunch of java i18n property files into locale specific json files. A `bundle` of i18n files have a three level hierarchy:

1. specific localisations for regional language variations ( eg `en_AU`, `pt_BR` ) - usually only some keys are localised
2. a file for each supported language ( eg `es`, `it`, `jp`, `zh`) - most keys are translated
3. the primary development (fallback) language (often English `en`) - all keys are available in the development language

Project_en.properties

	Project.Name = grunt-i18n-properties
	Project.Description = A great little project

Project_es.properties

	Project.Description = Un pequeño gran proyecto

Project_en_AU.properties

	Project.Description = A little ripper of a project

grunt-i18n-properties provides the best available translation from any of the three levels that are available

for example

generating an `en_AU` file will produce

	Project.Name = grunt-i18n-properties
	Project.Description = A little ripper of a project

selecting the `Project.Name` from the generic `en` file, and the `Project.Description` from the region specific `en_AU` file.

generating a `pt_BR` file will produce results just from the `en` file ( providing Brazilian portuguese users with english ), since neither `pt` nor `br_BR` files are available.

### Options

#### options.process

Type: `Function( properties, language )`

Default value: `JSON.stringify`

A function that transforms the final properties map into the string that is written to the language file.

convert to json

	function( prop ) { return JSON.stringify( prop ); }

push the properties into a javascript object with the language as a key

	function( prop, lang ) { return "strings['" + lang + "'] = " + JSON.stringify( prop ) + ";"}

pretty print json

	function( prop ) { return JSON.stringify( prop, null, "  " ); }

#### options.primary

Type: `String` or `false`

Default value: `"en"`

The primary development language. Eg the fallback language used when a key has not been translated yet
if `primary` is `false`, no fallback is used, so untranslated keys will be missing

#### options.langs

Type: `Array of Strings`

Default value: `["en_AU"]`

An array of all the languages you wish to support. Typically you would provide languages with the regional component, though this is not required.

a typical example might look like `["en_US", "en_UK", "en_AU", "fr_FR", "de_DE", "it_IT", "es_ES" "pt_PT", "zh_CN", "ja_JP", "ko_KR", "ar_EG"]`

#### options.dest

Type: `String`

Default value: `"strings/{lang}/{bundle}.json"`

A path pattern for writing out the i18n json files.

`{lang}` is replaced with one of the codes from `options.langs`

`{bundle}` is replaced with the name of the language bundle. In the example above this would be `Project`

## Contributing

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

## Release History

**0.1.0** Initial Publish


text:
#Magento Admin Panel Workshops part #12

Going through Configuration:

1. General
    1. General
    2. Web
    3. Design
    4. Currency setup
    5. Store Email Addresses
    6. Contacts
    7. Reports
    8. Content Management
    9. New relic reporting
2. Catalog
    1. Catalog
    2. Inventory
    3. Visual Merchandiser
    4. XML Sitemap
    5. RSS Feeds
    6. Email to a Friend
3. Customers
    1. Newsletter
    2. Customer Configuration
    3. Wish List
    4. Invitations
    5. Reward Points
    6. Promotions
    7. Gift registry
    8. Persistent Shopping Cart
4. Sales
    1. Sales
    2. Sales emails
    3. PDF Print-out
    4. TAX
    5. Checkout
    6. Shipping methods
    7. Google API
    8. Payment Methods
    9. Gift Cards
5. Services
6. Advanced


text:
# What is happening in this gif ?

A 3D model of a dragon is being deformed in real-time along a curve with a vertex shader.
The curve is made by following a physicalized box.

# The story behind a gif

I've discovered the **curve modifier** in [Blender](https://www.blender.org) and really love it.
People on Twitter went crazy with the gif below, so I always wanted to share how to do it.

# And ?

One night I couldn't sleep, because I had an intuition.
I thought I could make the maths for the curve modifier above.

Turns out it is always more complicated than excepted.
It took me time to figure out the geometry involved.
Struggling with maths is hard and frustrating.
But what a satisfaction when things work!

#### No interpolation
The gif below is the first tentative.
It looks cool, but it is not perfect.
It needs a smooth linear interpolation.

#### With interpolation
This is mainly because I used an array of float to pass positions to the shader.
And I've discovered that you could just send float within a texture.
It's great because texture gets a linear interpolation filter.

#### Warning
It is almost working like a charm, but my curve modifier still got weird glitches.
I guess I'm fine with it since I'm just doing it to mess with shaders.

# Let's do it in Unity3D with a vertex shader !

In this repository, you will find the scripts and the shader.

The **CurveModifier.cs** is the base script used to simplify different cases of application.
His main function is to translate an array of vector into a texture.
An important information is that the texture format is **RGBAFloat**.
It allows the texture to store 32 bit floats, and so positions.

#### Simplified version of what CurveModifier.cs does
```javascript
void Init () {
  texture = new Texture2D(resolution, 1, TextureFormat.RGBAFloat, false);
  colorArray = new Color[resolution];
  vectorArray = new Vector3[resolution];
}

// Get a curve point with a clamped ratio
public Vector3 GetCurvePoint (float ratio) {
  return vectorArray[ (int) Mathf.Floor ( vectorArray.Length * ratio ) ];
}

// Store points into a texture
public void CurveToTexture () {
	for (int i = 0; i < resolution; ++i) {
		float ratio = i / (float)resolution;
		Vector3 p = GetCurvePoint(ratio);
		colorArray[i] = new Color(p.x, p.y, p.z, 0.0);
	}
	texture.SetPixels(colorArray);
	texture.Apply();
}
```

So for example we can use a Bezier Curve like [this one on the Asset Store](https://www.assetstore.unity3d.com/#!/content/11278).
And then just fill the vector array with the bezier points.
You can check **BezierCurveModifier.cs** that uses the bezier package.

#### Let's get scared at looking the vertex shader
```javascript
// this function set the vertex position
v2f vert (appdata v)
{
	// unity stuff
	v2f o;

	// use transform component
	float4 vertex = mul(_Object2World, v.vertex);

	// axis setup (compress vectors into scalars)
	float vertexForward = vertex.x * _Forward.x + vertex.y * _Forward.y + vertex.z * _Forward.z;
	float vertexRight = vertex.x * _Right.x + vertex.y * _Right.y + vertex.z * _Right.z;
	float vertexUp = vertex.x * _Up.x + vertex.y * _Up.y + vertex.z * _Up.z;

	// the actual clamped ratio position on the curve
	float ratio = abs(vertexForward + _Time.x * _TimeSpeed);
	ratio = lerp(clamp(ratio, 0.0, 1.0), fmod(ratio, 1.0), _ShouldLoop);

	// used to distribute point on the plane that is perpendicular to the curve forward
	float angle = atan2(vertexUp, vertexRight);
	float radius = length(float2(vertexRight, vertexUp));

	// get current point through the texture
	float4 p = float4(ratio, 0.0, 0.0, 0.0);
	float3 bezierPoint = mul(_World2Object, tex2Dlod(_CurveTexture, p));

	// get neighbors of the current ratio
	float unit = 1.0 / _CurveResolution;
	float ratioNext = fmod(ratio + unit, 1.0);
	float ratioPrevious = fmod(ratio - unit + 1.0, 1.0);

	// make things loop or not
	ratioNext = lerp(clamp(abs(ratio + unit), 0.0, 1.0), ratioNext, _ShouldLoop);
	ratioPrevious = lerp(clamp(abs(ratio - unit), 0.0, 1.0), ratioPrevious, _ShouldLoop);

	// get next and previous point through the texture
	p.x = ratioNext;
	float3 bezierPointNext = mul(_World2Object, tex2Dlod(_CurveTexture, p));
	p.x = ratioPrevious;
	float3 bezierPointPrevious = mul(_World2Object, tex2Dlod(_CurveTexture, p));

	// find out vectors
	float3 forward = normalize(bezierPointNext - bezierPoint);
	float3 backward = normalize(bezierPointPrevious - bezierPoint);
	float3 up = normalize(cross(forward, backward));
	float3 right = normalize(cross(forward, up));

	// voila
	vertex.xyz = bezierPoint + right * cos(angle) * radius + up * sin(angle) * radius;

	// unity stuff
	o.vertex = mul(UNITY_MATRIX_MVP, vertex);
	o.uv = TRANSFORM_TEX(v.uv, _MainTex);
	return o;
}
```

Looks like hieroglyphs, right ? I still can't believe it works.
My methodology is to change a + into a * and watch if things get better.
And with luck, sometimes you find the right combination.

# Let's play with the examples

## Things to know about the curve modifier

#### You have to find the right curve axis.

#### You can change the scale to adjust the curve distribution

#### Changing position and rotation will have consequences

#### There is chance that you will need a bigger culling bounds
Because the shader won't change the mesh bounds.
So the camera can be out of range.
And the model can disappear from the frustum culling.

## Things to know about the Bezier Curve modifier

You can modify the spline to change the curve.

You can change the cycle offset speed.

## Things to know about the Follow Curve modifier

You can change the how quick you follow the target.

# Alright folks

Of course there is lot of things left to do. Like bugs fix, solid curve system and better user experience.
But I am just having fun with vertex shaders on my free time and feel satisfied with the actual prototype.
Feels free to contact me if you want to improve the project.

I would love to hear about your project if you are using my shader.
You can contact me on Twitter : [@leondenise](https://www.twitter.com/leondenise)
And please share your code like everyone else in this open source community <3

repository: pcioni/CurveModifier

repo_name: pcioni/CurveModifier


text:
# moustache_trophy
A 3d printable moustache trophy that I made for a competition.

![trophy](https://github.com/mjseabright/moustache_trophy/raw/master/trophy.jpg)

Video of the build process [here](https://youtu.be/A53l12WBTaE)


text:
---
layout: default
---

# About

*[[My main blog]({{ site.personal_url }}/about) has information about me.]*

This site roughly follows the the [Zettelkasten] ideas on how to organize
notes about a research field.
It consists of
[short summaries of papers]({{ "papers/" | relative_url }})
and [notes about concepts in the papers]({{ "notes/" | relative_url }})
related to what I am working on or that I am thinking about.

The main organizing principle in a Zettelkasten is aggressive cross-linking
between different pages.
This allows the structure to evolve organically as you add links and notes
and it encourages you to discover new connections between papers and topics.

I originally organized my notes into a number of topics and tried to write
notes about those topics.
This did not work well for several reasons:
it is hard to come up with a good taxonomy;
it is hard to figure out where to put a paper when it is the first in some sub-topic;
I am typically only reading some narrow slice of a field skewed by my interest;
I am often an outsider/newcomer to the field struggling to make sense of what I am reading
and struggling to find the important papers in a sea of publications.

My summaries of papers are often brief and based on a single quick
skim of the paper.
If you are an author and feel that I misunderstood your paper,
I am happy (eager!) to correct details if you want to get in touch.

This backlog of papers is growing faster than I can read papers on the
backlog.
Someday, I will need to come up with a plan to handle this better...

## Recommendations for learning a field

This site is the result of my need to learn a new research field
where I am a complete newcomer and don't know the shape of the field:
the important papers, the important research groups/people, the important
concepts.
In fact, I don't even know the terminology and how it is normally used.

I have had to do this several times in my career so I have some
recommendations.

1. Hunt for survey articles.
   These may be a few years out of date, may not fit your interest/focus,
   etc. but they are great for getting an overview of a topic, getting
   the terminology (as it was used when the paper was written) and
   finding the important papers.

   I have [a list of survey articles]({{ "notes/survey" | relative_url }})
   and you can find more in places like
   [ACM Computer Surveys](https://dl.acm.org/journal/csur)
   or the [Encyclopedia of Computer Science](https://www.wiley.com/en-gb/Encyclopedia+of+Computer+Science%2C+4th+Edition-p-9780470864128)
   and the major publishers sometimes have books with names like
   "The Handbook of ...".

2. If you have a list of papers (e.g., some subset of the papers in this list
   or a list of classic papers in the field or papers from a survey),
   collect all the papers and
   then read them in the order that they were published.
   Reading them in this order helps you understand how the field developed,
   what contribution a paper made to the field, how the terminology and
   notation changed over time, what ideas were once important but now
   seem to be ignored or a bit old-fashioned.
   I find this to be the most satisfying and rewarding order to read papers.

   (As you do this, your interests will evolve and you will find other
   papers and topics that you ought to read.  So you will also have
   to hunt for papers and try to evaluate the importance of papers
   by following the next criteria.)

3. If you do not have a list of papers, the key thing is to create your
   own list.

   Start with the most recent major conference in the field and skim the
   Related Work section of every paper looking for:
   - which authors are frequently cited
   - which papers are referred to as "seminal work" or similar
   - which papers are often cited
   - which other conferences are the important papers published at
   and update your list of papers.[^star-papers]

   At this stage, you will have a list of papers that you think
   might be important.
   Follow up each of these leads to find more papers, conferences and
   authors that you ought to read.
   Try to evaluate the importance of a paper or author by looking at the citation
   count in [Google Scholar](https://scholar.google.com/)
   versus the age of the paper
   and by looking at the related papers.
   Now read a few of the papers and use any new understanding to update
   your list.

   Unfortunately, this will result in you reading the newest papers
   first. Oh well, it's the best you can do...

[^star-papers]:
     If you use [Google Scholar](https://scholar.google.com) to lookup papers,
     it can be handy to "star" papers to keep track of the interesting papers.

Often you will have to use a hybrid approach.
You might find a [survey article]({{ "notes/survey" | relative_url }})
in [ACM Computer Surveys](https://dl.acm.org/journal/csur)
or the [Encyclopedia of Computer Science](https://www.wiley.com/en-gb/Encyclopedia+of+Computer+Science%2C+4th+Edition-p-9780470864128)
or some other book but it will always be a few years out of date.
If you find one, then you can use method (1) on the papers in that survey
and only have to use method (2) for more recent papers.

I like to print papers so that I can stuff them in my pocket,
read them on the train, underline sections, put questions to myself
in the margins, etc.

After reading each paper, make notes about the paper (maybe a bit like
the notes on this site).
I think it is also a good idea to try to write notes about ideas that span
multiple papers both to reduce redundancy and to encourage you to
identify the key concepts in a field.

Writing notes about papers and concepts forces you to think about how
to explain the material – which is a great way of forcing yourself
to understand it.
It also forces you to practice using any new terminology you find
in the papers.  For example, just what is the difference between
"symbolic evaluation" and "symbolic execution"?
Finally, if you find yourself writing a paper in the field,
then parts of your notes about a concept or a paper can maybe be copied
directly into the paper.
(At least, that is what the [Zettelkasten] advocates claim.)

As you read each paper, be sure to record enough information that you will be
able to find the paper and cite it in the future.  My approach is to get
a BibTeX file for the paper and use a
[script to convert that to
json](https://github.com/alastairreid/RelatedWork/tree/master/_scripts/bib2md.py)
that I include in the summary that I write.  I believe that I could reconstruct
a BibTeX file from that information but I have not yet written the script
to do so. Alternatively, the
[doi](https://en.wikipedia.org/wiki/Digital_object_identifier)
information should be enough.

It is probably a bad idea to copy the content of this site – you will learn
more by trying to write your own summaries and notes.
But, by all means, copy the Jekyll framework and scripts and, if it is relevant
to you, my list of interesting papers.
(But maybe you should consider using a wiki instead?)

## Building the site

The tooling around this site is pretty simple at the moment: I have repurposed
the Jekyll material from [my website](https://alastairreid.github.io) (which is based on
[Barry Clark's Jekyll Now](https://github.com/barryclark/jekyll-now))
and I have a
[Python script](https://github.com/alastairreid/RelatedWork/tree/master/_scripts/bib2md.py)
that converts BibTeX entries to page templates.
But ideally this would be much more integrated with one or more of the main
research search engines like [Google Scholar](https://scholar.google.com)
– perhaps as some form of overlay over the basic website.

I recently updated the [404 page]({{"404.html"| relative_url }})
based on the awesome glitch effect on the [SeaHorn 404
page](http://seahorn.github.io/404.html)
that is based on [this glitch effect](http://codepen.io/bulby97/pen/fcvay).
This may hurt your eyes.

I have been slowly working on a [clean
rebuild](https://alastairreid.github.io/clean-slate/) of this site based on the
Jekyll default site profile with the minimum number of changes to give it the
important features of this site.

---

[Zettelkasten]: https://zettelkasten.de/posts/zettelkasten-improves-thinking-writing/

repository: alastairreid/RelatedWork

gha_language: TeX

repo_name: alastairreid/RelatedWork


text:
# smart-storage

## killing the process
ps aux | grep "main.py"
sudo kill -9 858

#reading from acelerometer

https://www.raspberrypi.org/forums/viewtopic.php?t=22266

# RFID
https://www.parallax.com/sites/default/files/downloads/28140-28340-RFID-Reader-Documentation-v2.4.pdf
<EMAIL_ADDRESS>
Format sd card
Copy noob files

Wiernig the acd
https://cdn-learn.adafruit.com/downloads/pdf/reading-a-analog-in-and-controlling-audio-volume-with-the-raspberry-pi.pdf

Wiering the pi
https://i.stack.imgur.com/sVvsB.jpg

sudo apt-get update
sudo apt-get install python-dev
sudo apt-get install python-setuptools
sudo easy_install rpi.gpio

git clone git://gist.github.com/3151375.git

https://frillip.com/using-your-raspberry-pi-3-as-a-wifi-access-point-with-hostapd/

http://stackoverflow.com/questions/42505741/raspberrypi-as-hotspot-without-internet-accessed-via-a-domain-name

ssh<EMAIL_ADDRESS>
## ssh
https://www.raspberrypi.org/documentation/remote-access/ssh/

## static ip
https://duckduckgo.com/?q=raspberry+pi+static+ip&t=raspberrypi&ia=web

### /etc/network/interfaces
# interfaces(5) file used by ifup(8) and ifdown(8)

# Please note that this file is written to be used with dhcpcd
# For static IP, consult /etc/dhcpcd.conf and 'man dhcpcd.conf'

# Include files from /etc/network/interfaces.d:
```
auto lo
iface lo inet loopback

iface eth0 inet manual

allow-hotplug wlan0
iface wlan0 inet static
    address <IP_ADDRESS>
    netmask <IP_ADDRESS>
    network <IP_ADDRESS>
    broadcast <IP_ADDRESS>
    gateway: <IP_ADDRESS>
    wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf

allow-hotplug wlan1
iface wlan1 inet manual
    wpa-conf /etc/wpa_supplicant/wpa_supplicant.conf
```
### /etc/wpa_supplicant/wpa_supplicant.conf
```
ctrl_interface=DIR=/var/run/wpa_supplicant GROUP=netdev
update_config=1
country=GB

network={
        ssid="<Network>"
        psk="<Password>"
        key_mgmt=WPA-PSK
}
```

repository: DagF/smart-storage

repo_name: DagF/smart-storage


text:
---
id: testability
title: Testability
sidebar_label: Testability
---

*Http4ts* abstracts the http related objects. Therefore, `Request` and `Response` are just simple objects with methods that can be safely manipulated in an immutable way. Writing unit tests against handlers or filters is extremely simple. As an example, let's try to write some tests for the following handler:

```ts
const exampleUserInfo = {
  firstName: "Jane",
  lastName: "Doe"
};

async function getUserProfileHandler(req: HttpRequest): Promise<HttpResponse> {
  const authHeader = req.headers["authorization"] as string | undefined;
  if (!authHeader) {
    return res({ status: HttpStatus.UNAUTHORIZED });
  }

  const token = authHeader.toLowerCase().substring("bearer ".length);
  if (token !== "valid-token") {
    return res({ status: HttpStatus.UNAUTHORIZED });
  }

  return res({
    status: HttpStatus.OK,
    body: jsonBody(exampleUserInfo)
  });
}
```

This is an example handler that checks the validity of the token in the `authorization` header and returns `OK` with user info in the body when the token is valid. We can write the following tests for this handler (Tests are written in [Jest](https://jestjs.io/)):

```ts
describe("loginHandler tests", () => {
  it("should return unauthorized when request has no auth header", async () => {
    const request = req("/", "GET", "", {});

    const response = await loginUserHandler(request);

    expect(response.status).toBe(HttpStatus.UNAUTHORIZED);
  });

  it("should return unauthorized when the token is not valid", async () => {
    const headers = {
      authorization: "bearer invalid-token"
    };
    const request = req("/", "GET", "", headers);

    const response = await loginUserHandler(request);

    expect(response.status).toBe(HttpStatus.UNAUTHORIZED);
  });

  it("should return ok with user info when the token is valid", async () => {
    const headers = {
      authorization: "bearer valid-token"
    };
    const request = req("/", "GET", "", headers);

    const response = await loginUserHandler(request);

    const expectedUserInfo = {
      firstName: "Jane",
      lastName: "Doe"
    };

    expect(response.status).toBe(HttpStatus.OK);
    expect(response.body).toEqual(stringBody(JSON.stringify(expectedUserInfo)));
  });
});
```

As you can see in these tests, there is no special or framework-specific preparation needed to write tests. Your tests can focus on the real business logic instead of being littered with lots of noisy setup code.

gha_language: TypeScript


text:
---

title: Multiple Triggers
---

Quartz is designed with the ability to register a job with multiple triggers.
Each job can have a base line set of data, and then each trigger can bring its
own set of data as well. During the job execution Quartz will merge the data
for you, with the data in the trigger overriding the data in the job.

Our example job:

```csharp
public class HelloJob : IJob
{
    public static readonly JobKey Key = new JobKey("customer-process", "group");

    public async Task Execute(IJobExecutionContext context)
    {
        var customerId = context.MergedJobDataMap.GetString("CustomerId");
        var batchSize = context.MergedJobDataMap.GetString("batch-size");

        await Console.WriteLineAsync($"CustomerId={customerId} batch-size={batchSize}")
    }
}
```

Below, we have two triggers, each with their own set of data, but
we only had to register the one job.

```csharp
public Task DoSomething(IScheduler schedule, CancellationToken ct)
{
    var job = JobBuilder.Create<HelloJob>()
                        .WithIdentity(HelloJob.Key)
                        .Build();

    await schedule.AddJob(job, replace: true, storeNonDurableWhileAwaitingScheduling: true, ct);

    // Trigger 1
    var jobData1 = new JobDataMap { { "CustomerId", "1" } };
    await scheduler.TriggerJob(new JobKey("customer-process", "group"), jobData1, ct);

    // Trigger 2
    var jobData2 = new JobDataMap { { "CustomerId", "2" } };
    await scheduler.TriggerJob(new JobKey("customer-process", "group"), jobData2, ct);
}
```

When this runs you will see:

```text
CustomerId=1 batch-size=
CustomerId=2 batch-size=
```

### Job Data and Trigger Data

You could even set common data parameters on the job itself. Here
we are adding some job data to the job itself.

```csharp
public Task DoSomething(IScheduler schedule, CancellationToken ct)
{
    var job = JobBuilder.Create<AnExampleJob>()
                        .WithIdentity(HelloJob.Key)
                        .UsingJobData("batch-size", "50")
                        .Build();

    await schedule.AddJob(job, replace: true, storeNonDurableWhileAwaitingScheduling: true, ct);

    // Trigger 1
    var jobData1 = new JobDataMap { { "CustomerId", 1 } };
    await scheduler.TriggerJob(HelloJob.Key), jobData1, ct);

    // Trigger 2
    var jobData2 = new JobDataMap { { "CustomerId", 2 } };
    await scheduler.TriggerJob(HelloJob.Key), jobData2, ct);
}
```

When this runs you will see:

```text
CustomerId=1 batch-size=50
CustomerId=2 batch-size=50
```

repository: quartznet/quartznet

gha_language: C#

repo_name: quartznet/quartznet


text:
# Jeeaaasus - youtube-dl
[![GitHub last commit](https://img.shields.io/github/last-commit/jeeaaasus/youtube-dl?logo=github)](https://github.com/Jeeaaasus/youtube-dl/actions/workflows/push-unstable-image.yml/)
[![GitHub Automated build](https://img.shields.io/github/actions/workflow/status/jeeaaasus/youtube-dl/push-release-version-image.yml?logo=github)](https://github.com/Jeeaaasus/youtube-dl/actions/workflows/push-release-version-image.yml/)
[![Image Size](https://img.shields.io/docker/image-size/jeeaaasustest/youtube-dl/latest?style=flat&logo=docker)](https://hub.docker.com/r/jeeaaasustest/youtube-dl/)
[![Docker Pulls](https://img.shields.io/docker/pulls/jeeaaasustest/youtube-dl?style=flat&logo=docker)](https://hub.docker.com/r/jeeaaasustest/youtube-dl/)
[![Docker Stars](https://img.shields.io/docker/stars/jeeaaasustest/youtube-dl?style=flat&logo=docker)](https://hub.docker.com/r/jeeaaasustest/youtube-dl/)

**Automated yt-dlp Docker image for downloading YouTube subscriptions**

Docker hub page [here](https://hub.docker.com/r/jeeaaasustest/youtube-dl).
yt-dlp documentation [here](https://github.com/yt-dlp/yt-dlp).

# Features
* **Easy Usage with Minimal Setup**
    * Quality options with env parameter
    * Included format selection argument
    * Included set of starter arguments
* **Automatic Updates**
    * Self updating container
    * Automated image building
* **Automatic Downloads**
    * Interval options with env parameter
    * Channel URLs from file
* **PUID/PGID**
* **yt-dlp Options**
   * SponsorBlock
   * Format
   * Quality
   * High fps videos
   * Download archive
   * Output
   * Subtitles
   * Thumbnails
   * Geo bypass
   * Proxy support
   * Metadata
   * Etc

# Quick Start
"I want to download all my subscriptions and my watch later playlist in 4k"
```
docker run -d \
    --name youtube-dl \
    -v youtube-dl_data:/config \
    -v <PATH>:/downloads \
    -e youtubedl_subscriptions=true \
    -e youtubedl_watchlater=true \
    -e youtubedl_quality=2160 \
    jeeaaasustest/youtube-dl
```
Then add your cookies as explained in the [Configure youtube-dl](https://github.com/Jeeaaasus/youtube-dl#configure-youtube-dl) section below.

"I want to download only certain channels"
```
docker run -d \
    --name youtube-dl \
    -v youtube-dl_data:/config \
    -v <PATH>:/downloads \
    jeeaaasustest/youtube-dl
```
Then configure the channels as explained in the [Configure youtube-dl](https://github.com/Jeeaaasus/youtube-dl#configure-youtube-dl) section below.

**Explanation**
* `-v youtube-dl_data:/config`
  This makes a Docker volume where your config files are saved, named: `youtube-dl_data`.

* `-v <PATH>:/downloads`
  This makes a bind mount where the videos are downloaded.
  This is where on your Docker host you want youtube-dl to download videos.
  Replace `<PATH>`, example: `-v /media/youtube-dl:/downloads`

# Env Parameters
`-e <Parameter>=<Value>`

| Parameter | Value (Default) | What it does
| :---: | :---: | :--- |
| `TZ` | `Europe/London` | Specify TimeZone for the log timestamps to be correct.
| `PUID` | (`911`) | If you need to specify UserID for file permission reasons.
| `PGID` | (`911`) | If you need to specify GroupID for file permission reasons.
| `UMASK` | (`022`) | If you need to specify umask for file permission reasons.
| `youtubedl_debug` | `true` (`false`) | Used to enable verbose mode.
| `youtubedl_lockfile` | `true` (`false`) | Used to enable youtubedl-running, youtubedl-completed files in downloads directory. Useful for external scripts.
| `youtubedl_webui` | `true` (`false`) | If you would like to beta test the unfinished web-ui feature, might be broken!
| `youtubedl_webuiport` | (`8080`) | If you need to change the web-ui port.
| `youtubedl_subscriptions` | `true` (`false`) | If you want to download all your subscriptions. Authentication is required.
| `youtubedl_watchlater` | `true` (`false`) | If you want to download your Watch Later playlist. Authentication is required.
| `youtubedl_interval` | `1h` (`3h`) `12h` `3d` `false` | If you want to change the default download interval.
This can be any value compatible with [gnu sleep](https://github.com/tldr-pages/tldr/blob/main/pages/linux/sleep.md) or if set to false, the container will shutoff after executing. A low interval value risks you being ip-banned by YouTube.
1 hour, (3 hours), 12 hours, 3 days, false.
| `youtubedl_quality` | `720` (`1080`) `1440` `2160` | If you want to change the default download resolution.
720p, (1080p), 1440p, 4k.

# Image Tags
* **`unstable`**
    * Automatically built when a new GitHub commit is pushed.
    * Container updates to the newest yt-dlp commit while running.
* **`latest`**
    * Automatically built when a new version of yt-dlp is released.
    * Container updates to the latest version of yt-dlp while running.
* **`v<VERSION>`**
    * Automatically built when a new version of yt-dlp is released.
    * Does not update.

# Configure youtube-dl
* **Authentication**

    Cookies are used to authenticate your YouTube account which is necessary if you want to download members only videos you have access to or your own private videos and playlists like Watch Later.

    In order to pass your cookies to youtube-dl, you first need a browser extension to extract your cookies, for example, [Get cookies.txt](https://chrome.google.com/webstore/detail/get-cookiestxt/bgaddhkoddajcdgocldbbfleckgcbcid/) (Chrome) or [cookies.txt](https://addons.mozilla.org/en-US/firefox/addon/cookies-txt/) (Firefox).
    Once you've extracted your cookies, place the `cookies.txt` file inside your Docker volume named `youtube-dl_data` or the folder `/config/` inside your container. One way of doing this would be using the command: `docker cp ./cookies.txt youtube-dl:/config/`.
    Then youtube-dl will find and use the `cookies.txt` file automatically.

* **channels.txt**

    File location: `/config/channels.txt`.
    This is where you input all the YouTube channels (or any valid URL) you want to have videos downloaded from.
    ```
    # One per line
    # Name
    https://www.youtube.com/user/channel_username
    # Another one
    https://www.youtube.com/channel/UC0vaVaSyV14uvJ4hEZDOl0Q
    ```
    You can also specify additional args to be used per URL. This is done by adding args after the URL separated by the ` | ` character.
    These will override any conflicting args from `args.conf`.
    ```
    # Examples
    # Output to 'named' folder instead of channel name
    https://www.youtube.com/channel/UC0vaVaSyV14uvJ4hEZDOl0Q | --output '/downloads/named/%(title)s.%(ext)s'

    # Use regex to only download videos matching words
    https://www.youtube.com/channel/UC0vaVaSyV14uvJ4hEZDOl0Q | --no-match-filter --match-filter '!is_live & title~=(?i)words.*to.*match'

    # Use regex to only download videos not matching words
    https://www.youtube.com/channel/UC0vaVaSyV14uvJ4hEZDOl0Q | --no-match-filter --match-filter '!is_live & title!~=(?i)words.*to.*exclude'

    # Download a whole playlist, also disable reverse download order
    https://www.youtube.com/playlist?list=D9sLB5EVaCarZ7lbpQfGch3jJuYCRt | --playlist-end '-1' --no-playlist-reverse
    ```
    Adding with Docker:
    `docker exec youtube-dl bash -c 'echo "# NAME" >> ./channels.txt'`
    `docker exec youtube-dl bash -c 'echo "URL" >> ./channels.txt'`

    It is recommended to use the UCID-based URLs, they look like: `/channel/UC0vaVaSyV14uvJ4hEZDOl0Q`, as the other ones might get changed.
    You find the UCID-based URL by going to a video and clicking on the uploader.

* **pre-execution.sh**

    File location: `/config/pre-execution.sh`.
    This is an optional user defined script that is executed before youtube-dl starts downloading videos.

* **post-execution.sh**

    File location: `/config/post-execution.sh`.
    This is an optional user defined script that is executed after youtube-dl has finished its full execution.

* **archive.txt**

    File location: `/config/archive.txt`.   *delete to make youtube-dl forget downloaded videos*
    This is where youtube-dl stores all previously downloaded video IDs.

* **args.conf**

    File location: `/config/args.conf`.   *delete and restart container to restore [default arguments](https://github.com/Jeeaaasus/youtube-dl/blob/master/root/config.default/args.conf)*
    This is where all youtube-dl execution arguments are, you can add or remove them however you like. If unmodified this file is automatically updated.

    **Unsupported arguments**
    * `--config-location`, hardcoded to `/config/args.conf`.
    * `--batch-file`, hardcoded to `/config/channels.txt`.

    **Default arguments**
    * `--output '/downloads/%(uploader)s/%(title)s.%(ext)s'`, makes youtube-dl create separate folders for each channel and use the video title for the filename.
    * `--playlist-end '16'`, makes youtube-dl only download the latest 16 videos, per channel.
    * `--playlist-reverse`, makes youtube-dl download channel videos in the order they were uploaded.
    * `--match-filter '!is_live'`, makes youtube-dl ignore live streams.
    * `--windows-filenames`, restricts filenames to only Windows allowed characters.
    * `--ignore-no-formats-error`, keeps youtube-dl from crashing when trying to download a video premiere.
    * `--no-progress`, removes a lot of unnecessary clutter from the logs.
    * `--sleep-requests '1'`, makes youtube-dl wait 1 second between requests. Be careful changing this! YouTube might feel you are making too many requests and ip ban you.
    * `--merge-output-format 'mp4'`, makes youtube-dl create mp4 video files.
    * `--sub-langs 'all,-live_chat'`, makes youtube-dl embed subtitles.
    * `--embed-metadata`, makes youtube-dl embed metadata like video description and chapters.
    * `--sponsorblock-mark 'all'`, makes youtube-dl create chapters from [SponsorBlock](https://sponsor.ajay.app/) segments.

    yt-dlp configuration options documentation [here](https://github.com/yt-dlp/yt-dlp#usage-and-options).

repository: Jeeaaasus/youtube-dl

repo_name: Jeeaaasus/youtube-dl


text:
# efs

An fs module stand-in for reading and writing encrypted files

## Installation

    $ npm install efs

## Usage

`efs` attempts to be as similar to `fs` as possible. The one place where
it differs is in how it needs to be required.

```javascript
var efs = require('efs').init('aes-128-cbc', 'password');

// encrypt and write file
efs.writeFileSync('/tmp/example', 'hello world');

// decrypt and read file
efs.readFileSync('/tmp/example');
```

## API

There's only one API method in `efs` that differs from Node's `fs`
module. Please see [Node's fs docs](http://nodejs.org/api/fs.html)
for how to use all the other methods.

### init(algorithm, password)

Initializes the `efs` module with the given encryption algorithm and
derives the encryption key from the given password.

__Arguments__

* algorithm - the encryption algorithm to use. It is dependent on the
available algorithms supported by the version of OpenSSL on the platform.
Examples are 'aes-128-cbc', 'aes192', etc. On recent releases,
`openssl list-cipher-algorithms` will display the available ciphers.
* password - the password used to derive the encryption/decryption key

## Caveats/Exceptions

Although most `fs` modules have been implemented in `efs`, there are
some exceptions:

* `efs.open` only supports opening a file for writing.
* `efs.read` and `efs.readSync` is not supported.
* Writing to arbitrary positions in a file using `efs.write` is not
  supported.
* `efs.truncate` and `efs.truncateSync` are not supported.
* `efs.appendFile` and `efs.appendFileSync` are supported but not
  terribly efficient. They result in reading and decrypting the entire
  file and then re-encrypting and writing it back out.

## License

(The MIT License)

Copyright (c) 2012 Jeff Kunkle

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.

gha_language: HTML


text:
# Future Talk Move Prediction
Code for future talk move prediction from the ACL 2021 Findings paper ["What Would a Teacher Do? Predicting Future Talk Moves"](https://arxiv.org/abs/2106.05249)

Model settings can be configured in `experiments.conf`, including specifying if pretrained layers need to be used.

To use the GPU, change device from 'cpu' to 'cuda' in `train.py`, `models.py` and `nn_blocks.py`

Train models using `python train.py --expr name_of_experiment`, e.g. `python train.py --expr retrain`. Specify the location of where to save the model in `log_dir` of the experiment configuration.

Evaluate models using `python evaluation.py name_of_experiment`.

repository: ananyaganesh/ftmp

repo_name: ananyaganesh/ftmp


text:
# PokeIV
Pokemon management tool for Go using [tejado's pgoapi API](https://github.com/tejado/pgoapi).

# About
PokeIV provides an interface to manage your pokemon in Pokemon Go.
Current features:
* Player information
* Batch pokemon transfering.
* Batch pokemon evolution.
* Batch renaming pokemon with configurable format.
* Lists of pokemon all pokemon indicating their IV, CP, ATK, DEF, and STA.
  * Pokemon are divided into 3 lists:
    * Highest IV pokemon--those above a given threshold (default 80%)
    * Pokemon that can be evolved, in descending IV order (evolve the best first)
    * Recommended pokemon to transfer--those which can/should not be evolved and are below threshold(s)
* Options to set how the tool splits up and displays your pokemon.
  * White/black lists to only display the pokemon you want to
  * delays for transferring, evolution and renaming to avoid suspicious activity

# Windows
There is now an executable distribution of PokeIV located in the 'dist' directory. This executable was built using py2exe and does not need an external Python installation to run. It was built on Windows 10 and has not been tested on other versions.

# Linux / other
Requires Python 2/3

E.g. in Ubuntu run:
```bash
sudo apt-get install python python-tk
```

### Installation
```
pip install -r requirements.txt
```

# Screenshot
![pokeIV screen shot](./screenshot.jpg "Screenshot")

repository: canele/PokeIV

gha_language: Tcl

repo_name: canele/PokeIV


text:
### Extra things we've had fun with.

* [I Love Puerto Rico](http://www.ilovepuertorico.org/)

We wanted to understand how citizens respond to the question about civic pride and then see if there is a connection to the actions they take in daily life. We also want to gather stories about what creates a unique sense of place here in Puerto Rico.

Yo me quedo en Puerto Rico is live and already hosts more than 90 messages from puertorriqueños that decided to stay in Puerto Rico and what they love about their island.

The app has gotten forked by several of the other fellowship teams. It currently lives online at I Love Puerto Rico, and the codebase can be found on [Github](https://github.com/CoquiCoders/ilovepr)

### **Negocio Local**

A promotion system for local businesses.

The idea for Negocio Local came out of the [Unhackathon for Puerto Rico](http://coquicoders.org/unhackathon-for-puerto-rico-san-francisco-side). Puerto Ricans are a highly consumerist culture, however a movement of supporting local businesses is not yet encouraged mainstream.

We came up with an idea and a design for a sticker that a business owner may put on his or her storefront in order to encourage people to shop inside his or her store instead of Macy's or Sears. We knew that unifying local business under a strong brand would have a big impact. However, we wanted to add a bit of engagement and interaction to the system.

We added a call to action on the sticker, the gist being "Text ___ to<PHONE_NUMBER> to find out more". Upon receiving the sticker, the business owner would go on the site, register a short code for their business, and before attaching the sticker to the glass, write the short code in the black line.

She would also have the opportunity to determine what the response will be once someone does text the number. Some business owners may want to simply text a coupon back, while others may want
to provide some history about their business.

![Negocio Local Stickers](https://dl.dropboxusercontent.com/u/1009233/Negocio%20Local/2014-04-26%2019.14.59.jpg)

When the user texts the number, the system will do a simple calculation of how many businesses the user has texted vs how many are in the system, and the user will get a response something to the effect of "You are 95% Puerto Rican", a simple gamification play.

We also wanted to add some analytics and management for business owners which we sketched out here:

![Negocio Local Backend](https://dl.dropboxusercontent.com/u/1009233/Negocio%20Local/2014-04-26%2019.15.10.jpg)

Eventually, the goal would be to provide a local business directory and encourage and empower Puerto Ricans to shop locally.

We have been interviewing various small and local businesses and associations both in Puerto Rico and in Oakland and are still getting feedback on the concept.

* [Humedad San Juan](http://humedadsanjuan.com)

Clara and Ainsley are painfully aware of the humidity on a daily basis because for two ladies with wavy hair - humidity can mean the difference between looking presentable and looking completely disheveled. So - we thought - wouldn’t it be funny if… we gave a reading of the humidity and then showed a corresponding icon of a lady with progressively unruly hair.

![Image Title](https://dl.dropboxusercontent.com/u/7894148/Chronicles/humedad-sanjuan.jpg)

* Tale of Two-Islands

A collaboration between [Anna Marie Panlilio](http://www.codeforamerica.org/people/anna-marie-panlilio/) , from team Rhode Island and Team Puerto Rico. This photo blog show cased the different, yet similar, environments that the two "island" fellowship teams experienced during February residency.

![Image Title](http://cl.ly/Xlp5/Screen%20Shot%202014-09-28%20at%208.45.31%20AM.png)

View it on [Tumblr](http://a-tale-of-two-islands.tumblr.com
)

* Coqui Song

When we came back from residency, we were inspired to share our experience by writing a song.

repository: CoquiCoders/beta-book

repo_name: CoquiCoders/beta-book


text:
---
title: Modern CSS Frameworks
publishedDate: 2020-05-13T09:40:42.214Z
author: Siabsish Mohanty
banner: sunflower.jpg
bannerCredit: Photo by [Paul Skorupskas](https://unsplash.com/photos/7KLa-xLbSXA) on [Unsplash](https://unsplash.com)
category: Technology
summary: >-
    Web Developers used to spend a lot of time creating beautiful CSS. Thanks to
    the CSS frameworks, we now have a better, faster, and more effective way to
    build responsive websites.
keyword:
    - css
    - frameworks
    - web development
---

## How do CSS frameworks work?

CSS framework gives web developers a basic structure, which includes grid, interactive UI patterns, web typography, tooltips, buttons, form elements, icons. This structure helps web developers to start quickly and efficiently when they are designing a website or web applications.

That means developers can free themselves from starting everything from scratch. CSS framework will create a solid foundation for them. Besides, developers can also reuse code in all projects they work on.

## Why do front-end developer need a CSS framework?

CSS frameworks have their downsides. So you need to understand whether you need one or not. Here are a few strong arguments for using the frameworks:

-   **To build a website/web application faster**
    You can save time by having a solid foundation that you can rely on. CSS frameworks give web developers something that they can use and customize (if required).

-   **To validate the design hypothesis**
    You can build a solution and test it with your users. It is much faster and easier to create a prototype or wireframe with a framework rather than do it from scratch.

-   **You can find a CSS framework for your specific needs**
    There are a lot of great frameworks you can choose from. Sometimes people give up using a CSS framework because they couldn't find a suitable option. If you struggle to find a framework for your specific needs, then you should check our list of 15 CSS frameworks.

repository: sibasishm/my-blog

gha_language: JavaScript

repo_name: sibasishm/my-blog


text:
# Geolocation [![Latest Stable Version](https://poser.pugx.org/midnite81/geolocation/version)](https://packagist.org/packages/midnite81/geolocation) [![Total Downloads](https://poser.pugx.org/midnite81/geolocation/downloads)](https://packagist.org/packages/midnite81/geolocation) [![Latest Unstable Version](https://poser.pugx.org/midnite81/geolocation/v/unstable)](https://packagist.org/packages/midnite81/geolocation) [![License](https://poser.pugx.org/midnite81/geolocation/license.svg)](https://packagist.org/packages/midnite81/geolocation) [![Build](https://travis-ci.org/midnite81/geolocation.svg?branch=master)](https://travis-ci.org/midnite81/geolocation) [![Coverage Status](https://coveralls.io/repos/github/midnite81/geolocation/badge.svg?branch=master)](https://coveralls.io/github/midnite81/geolocation?branch=master)

A IP Info DB integration for Laravel

# Versioning

| Version | Branch    | PHP    | Laravel | Notes                                                                        |
|---------|-----------|--------|---------|------------------------------------------------------------------------------|
| ^4.0    | master/v4 | \>=8.1 | \>=8    | Update to include wrap Ip2Location in addition to IpInfoDb, moved to php 8.1 |
| ^3.0    | v3        | \>=7.4 | \>=6    | Facade has been removed and guzzle dependency has been updated to version 7  |
| ^2.0    | v2        | \>=5.6 | \>=5    | Corrects issues with composer 2.0                                            |
| ^1.0    | v1        | \>=5.6 | \>=5    | First release - not compatible with composer 2.0                             |

# Upgrading to v4.0

Please note:

- version 4 brings in the ability to wrap both the IpInfoDb service (as was available in previous versions)
  and the Ip2Location service.  IpInfoDb are not accepting new registrations and are asking users to register at
  Ip2Location instead.
- version 4 minimum requirements are php 8.1 to make use of the additional features php 8.1 brings, such as enums
  and better type safety.
- version 4 has an updated config file. If you are upgrading, I would suggest checking out the
  [config file](/config/geolocation.php) and updating your local instance of it.
- a change has been made to the caching from minutes to seconds.

# Installation

If installing on anything below PHP 8.1, please checkout the v2 or v3 branch and follow the
instructions on the readme for that branch. Please note ip2location is not supported on previous versions of this
package

This package requires PHP 8.1+, and includes a Laravel Service Provider.

To install through composer include the package in your `composer.json`.

    "midnite81/geolocation": "^4.0"

Run `composer install` or `composer update` to download the dependencies, or you can run
`composer require midnite81/geolocation`.

## Laravel Integration

This package makes use of Laravel's auto package loader, so you shouldn't need to add this
to your config/app.php file. However, if you've disabled this then you'll need to add the
GeoLocation service provider to the list of service providers
in `app/config/app.php`.

    'providers' => [
      Midnite81\GeoLocation\GeoLocationServiceProvider::class
    ];

Publish the config and migration files using
`php artisan vendor:publish --provider="Midnite81\GeoLocation\GeoLocationServiceProvider"`

# Configuration File

Once you have published the config files, you will find a `geolocation.php` file in the
`config` folder. You should look through these settings and update these where necessary.

# Env

You will need to add the following to your `.env` file and update these with your own
settings. Please note you will only need to fill in the api key for the service you are using.

```dotenv
GEOLOCATION_IPINFODB_API_KEY=<ip_info_db_api_key>
GEOLOCATION_IP2LOCATION_API_KEY=<ip2location_api_key>
GEOLOCATION_CACHE=<duration_in_seconds>
```

# Get your GeoLocation API Key

Before using this package you'll need to obtain an API Key from either [IpInfoDb](http://ipinfodb.com/register)
which is no longer accepting new registrations or [Ip2Location](https://www.ip2location.io/sign-up).

Once you have signed up you will need to add your api key to the relevant `.env` key; `GEOLOCATION_IPINFODB_API_KEY` for
IpInfoDb or `GEOLOCATION_IP2LOCATION_API_KEY` for Ip2Location.

# Caching

This package allows you to cache responses, however it is your responsibility to ensure you're not breaking any
terms and conditions of use.

# Rate Limiting

This package does not set any rate limiting internally. You should ensure that your application adheres to any rate
limiting set by your chosen provider.

# Example Usage and Available Methods and Properties

- [IpInfoDb example usage and available methods](/readme_ipinfodb.md)
- [Ip2Location example usage and available methods](/readme_ip2location.md)

gha_language: PHP


text:
# CEH - Certified Ethical Hacker

The final version of these materials can be found at my blog [here](https://binarycoders.dev/2020/06/07/ceh-i-preamble-and-index/). This are just the drafts for the different articles.

This repository is not going to be a coding repository. The purpose of this repository is to store my notes about the 'Certified Ethical Hacker' learning and study.

The reason to use this format instead of the usual blog format, [Binary Coders](https://www.binarycoders.dev), is that this is going to be a live project, I wanted to be free to edit, change or redo the different sections and be able to write this in a non-linear way. Be able to review things and add new information to the sections already finished.

I hope, if you have landed here, this document can be of any use for you.

## Sections

0. [Preface](00-Preface/README.md) - _[Blog post](https://binarycoders.dev/2020/06/07/ceh-i-preamble-and-index/)_
1. [Introduction to Ethical Hacking](01-Introduction_to_Ethical_Hacking/README.md) - _[Blog post](https://binarycoders.dev/2020/06/08/ceh-ii-introduction-to-ethical-hacking/)_
2. [Footprinting and Reconnaissance](02-Footprinting_and_Reconnaissance/README.md) - _[Blog post](https://binarycoders.dev/2020/06/09/ceh-iii-footprinting-and-reconnaissance/)_
3. [Scanning Networks](03-Scanning_Networks/README.md) - _[Blog post](https://binarycoders.dev/2020/06/27/ceh-iv-scanning-networks/)_
4. [Enumeration](04-Enumeration/README.md) - _[Blog post](https://binarycoders.dev/2020/06/30/ceh-v-enumeration/)_
5. [Vulnerability Analysis](05-Vulnerability_Analysis/README.md) - _[Blog post](https://binarycoders.dev/2020/07/06/ceh-vi-vulnerability-analysis/)_
6. [System Hacking](06-System_Hacking/README.md) - _[Blog post](https://binarycoders.dev/2020/07/07/ceh-vii-system-hacking/)_
7. [Malware Threats](07-Malware_Threats/README.md) - _[Blog post](https://binarycoders.dev/2020/07/13/ceh-viii-malware-threats/)_
8. [Sniffing](08-Sniffing/README.md) _[Blog post](https://binarycoders.dev/2020/07/14/ceh-ix-sniffing/)_
9. [Social Engineering](09-Social_Engineering/README.md) - _[Blog post](https://binarycoders.dev/2020/07/16/ceh-x-social-engineering/)_
10. [Denial of Service](10-Denial_of_Services/README.md) - _[Blog post](https://binarycoders.dev/2020/07/18/ceh-xi-denial-of-service/)_
11. [Session Hijacking](11-Session_Hijacking/README.md) - _[Blog post](https://binarycoders.dev/2020/07/20/ceh-xii-session-hijacking/)_
12. [Evading IDS, Firewalls, and Honeypots](12-Evading_IDS_Firewall_and_Honeypots/README.md) - _[Blog post](https://binarycoders.dev/2020/07/21/ceh-xiii-ids-ips-firewall-and-honeypots/)_
13. [Hacking Web Servers](13-Hacking_Web_Servers/README.md) - _[Blog post](https://binarycoders.dev/2020/07/22/ceh-xiv-hacking-web-servers/)_
14. [Hacking Web Applications](14-Hacking_Web_Applications/README.md) - _[Blog post](https://binarycoders.dev/2020/07/23/ceh-xv-hacking-web-applications/)_
15. [SQL Injection](15-SQL_Injection/README.md) - _[Blog post](https://binarycoders.dev/2020/07/24/ceh-xvi-sql-injection/)_
16. [Hacking Wireless Networks](16-Hacking_Wireless_Networks/README.md) - _[Blog post](https://binarycoders.dev/2020/07/25/ceh-xvii-hacking-wireless-networks/)_
17. [Hacking Mobile Platforms](17-Hacking_Mobile_Platforms/README.md) - _[Blog post](https://binarycoders.dev/2020/07/26/ceh-xviii-hacking-mobile-platforms/)_
18. [IoT Hacking](18-IoT_Hacking/README.md) - _[Blog post](https://binarycoders.dev/2020/07/27/ceh-xix-iot-hacking/)_
19. [Cloud Computing](19-Cloud_Computing/README.md) - _[Blog post](https://binarycoders.dev/2020/07/28/ceh-xx-cloud-computing/)_
20. [Cryptography](20-Cryptography/README.md) - _[Blog post](https://binarycoders.dev/2020/07/29/ceh-xxi-cryptography/)_

## Information references

This text is a compilation of my thoughts, information that I have collected or learn reading, watching conferences or videos in the past and, obviously, some search over the Internet. For all the information extracted from different sources where someone else has done a good job explaining a concept, below it can be found a list of references:

* [Wikipedia](https://en.wikipedia.org/wiki/Main_Page)
* [CloudFlare Learning](https://www.cloudflare.com/learning)
* [Prilege Escalation](https://www.netsparker.com/blog/web-security/privilege-escalation/)
* [ENISA](https://www.enisa.europa.eu/topics/csirts-in-europe/glossary)
* [OWASP Community Pages](https://owasp.org/www-community/)
* [Rapid7 Blog](https://blog.rapid7.com)
* [Barracuda Glossary](https://www.barracuda.com/glossary)
* [SANS Reading Room](https://www.sans.org/reading-room)
* [Cloud Computing Cyber-attacks](https://www.apriorit.com/dev-blog/523-cloud-computing-cyber-attacks)

repository: fjavierm/ceh

repo_name: fjavierm/ceh