text:
## Debugger Visualizers

Many languages and debuggers enable developers to control how a type is
displayed in a debugger. These are called "debugger visualizations" or "debugger
views".

The Windows debuggers (WinDbg\CDB) support defining custom debugger visualizations using
the `Natvis` framework. To use Natvis, developers write XML documents using the natvis
schema that describe how debugger types should be displayed with the `.natvis` extension.
(See: https://docs.microsoft.com/en-us/visualstudio/debugger/create-custom-views-of-native-objects?view=vs-2019)
The Natvis files provide patterns which match type names a description of how to display
those types.

The Natvis schema can be found either online (See: https://code.visualstudio.com/docs/cpp/natvis#_schema)
or locally at `<VS Installation Folder>\Xml\Schemas\1033\natvis.xsd`.

The GNU debugger (GDB) supports defining custom debugger views using Pretty Printers.
Pretty printers are written as python scripts that describe how a type should be displayed
when loaded up in GDB/LLDB. (See: https://sourceware.org/gdb/onlinedocs/gdb/Pretty-Printing.html#Pretty-Printing)
The pretty printers provide patterns, which match type names, and for matching
types, descibe how to display those types. (For writing a pretty printer, see: https://sourceware.org/gdb/onlinedocs/gdb/Writing-a-Pretty_002dPrinter.html#Writing-a-Pretty_002dPrinter).

### Embedding Visualizers

Through the use of the `#[debugger_visualizer]` attribute, the `url` crate can embed
debugger visualizers into the crate metadata.

Currently the two types of visualizers supported are Natvis and Pretty printers.

For Natvis files, when linking an executable with a crate that includes Natvis files,
the MSVC linker will embed the contents of all Natvis files into the generated `PDB`.

For pretty printers, the compiler will encode the contents of the pretty printer
in the `.debug_gdb_scripts` section of the `ELF` generated.

### Testing Visualizers

The `url` crate supports testing debugger visualizers defined for this crate. The entry point for
these tests are `tests/debugger_visualizer.rs`. These tests are defined using the `debugger_test` and
`debugger_test_parser` crates. The `debugger_test` crate is a proc macro crate which defines a
single proc macro attribute, `#[debugger_test]`. For more detailed information about this crate,
see https://crates.io/crates/debugger_test. The CI pipeline for the `url` crate has been updated
to run the debugger visualizer tests to ensure debugger visualizers do not become broken/stale.

The `#[debugger_test]` proc macro attribute may only be used on test functions and will run the
function under the debugger specified by the `debugger` meta item.

This proc macro attribute has 3 required values:

1. The first required meta item, `debugger`, takes a string value which specifies the debugger to launch.
2. The second required meta item, `commands`, takes a string of new line (`\n`) separated list of debugger
commands to run.
3. The third required meta item, `expected_statements`, takes a string of new line (`\n`) separated list of
statements that must exist in the debugger output. Pattern matching through regular expressions is also
supported by using the `pattern:` prefix for each expected statement.

#### Example:

```rust
#[debugger_test(
    debugger = "cdb",
    commands = "command1\ncommand2\ncommand3",
    expected_statements = "statement1\nstatement2\nstatement3")]
fn test() {

}
```

Using a multiline string is also supported, with a single debugger command/expected statement per line:

```rust
#[debugger_test(
    debugger = "cdb",
    commands = "
command1
command2
command3",
    expected_statements = "
statement1
pattern:statement[0-9]+
statement3")]
fn test() {

}
```

In the example above, the second expected statement uses pattern matching through a regular expression
by using the `pattern:` prefix.

#### Testing Locally

Currently, only Natvis visualizations have been defined for the `url` crate via `debug_metadata/url.natvis`,
which means the `tests/debugger_visualizer.rs` tests need to be run on Windows using the `*-pc-windows-msvc` targets.
To run these tests locally, first ensure the debugging tools for Windows are installed or install them following
the steps listed here, [Debugging Tools for Windows](https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/).
Once the debugging tools have been installed, the tests can be run in the same manner as they are in the CI
pipeline.

#### Note

When running the debugger visualizer tests, `tests/debugger_visualizer.rs`, they need to be run consecutively
and not in parallel. This can be achieved by passing the flag `--test-threads=1` to rustc. This is due to
how the debugger tests are run. Each test marked with the `#[debugger_test]` attribute launches a debugger
and attaches it to the current test process. If tests are running in parallel, the test will try to attach
a debugger to the current process which may already have a debugger attached causing the test to fail.

For example:

```
cargo test --test debugger_visualizer --features debugger_visualizer -- --test-threads=1
```

repository: servo/rust-url

gha_language: Rust

repo_name: servo/rust-url


text:
# ndef

[![pub version](https://img.shields.io/pub/v/ndef)](https://pub.dev/packages/ndef)
![Test](https://github.com/nfcim/ndef/workflows/Test/badge.svg)

`ndef` is a Dart library to decode & encode NDEF records, supporting multiple types including (grouped by Type Name Format):

* NFC Well Known
  * Text
  * URI with well-known prefix
  * Digital signature
  * Smart poster
  * Connection handover
* Media (MIME data)
  * Bluetooth easy pairing / Bluetooth low energy
  * other MIME data
* Absolute URI

**This library is still under active development and subject to breaking API changes and malfunction. Pull requests and issues are most welcomed.**

## Usage

```dart
import 'package:ndef/ndef.dart' as ndef;

// encoding
var uriRecord = new ndef.UriRecord.fromString("https://github.com/nfcim/ndef");
var textRecord = new ndef.TextRecord(text: "Hello");
var encodedUriRecord = uriRecord.encode().toHexString(); /// encode a single record, and use our extension method on [Uint8List]
var encodedAllRecords = ndef.encodeNdefMessage([uriRecord, textRecord]).toHexString(); // encode several records as a message

// decoding
var encodedTextRecord = "d1010f5402656e48656c6c6f20576f726c6421";
var decodedRecords = ndef.decodeRawNdefMessage(encodedTextRecord.toBytes());
assert(decodedRecords.length == 1);
if (decodedRecords[0] is ndef.TextRecord) {
  assert(decodeRecords[0].text == "Hello");
}  else {
  // no we will not reach here
}

// data-binding (by implementing payload as dynamic getter / setter)
var origPayload = uriRecord.payload;
print(origPayload.toHexString());
uriRecord.content = "github.com/nfcim/flutter_nfc_kit";
print(uriRecord.payload.toHexString()); // changed
uriRecord.payload = origPayload;
print(uriRecord.content); // changed back

// decoding by providing parts of a record
var partiallyDecodedUrlRecord = ndef.decodePartialNdefMessage(ndef.TypeNameFormat.nfcWellKnown, utf8.encode("U"), origPayload, id: Uint8List.fromList([0x1, 0x2]));
```

See [examples](example/lib/main.dart) for a more complete example.

Refer to the [documentation](https://pub.dev/documentation/ndef/) for more information.

## TODO

1. handle exceptions
2. add class types
3. add test

Actually, I finish the first version yesterday.
Well, it's not a good job!
Come on!

license: MIT

branch_name: refs/heads/master

extension: md

gha_language: Dart

gha_license_id: MIT

license_type: permissive


text:
## Synopsis

Being able to see a visual timeline of a project provides great value and insight into the designing process. We thought it would be neat to be able to step back and forth between versions of project would be highly beneficial to both developer and various third parties. Project Heh allows you to visit between commits and see the visual state of the project at that time.

## Code Example

You can navigate to the url http://vm64-114.iplantc.org/heh/ in your browser, andenter the owner and repo of a github project you would like to visit. We created a github pages demo for your convenience. At the top of the page, enter:

owner: loukitzanna
repo: website-for-demo

Press "Get My Timeline!" to begin.

When the github pages project renders, using the arrows at the top, you should be able to step back and forth between commits, watching the project change with each commit. Arrows will disappear a result of hitting the end of a timeline.

## Motivation

Github is a staple in the developer's toolbox. However, being able to track changes between projects in a meaningful way, especially with visualization, is functionality that designers and developers miss out on. Imagine a client looking at their designer's project, and being able to point out exactly which things worked in the last iteration, and which things needed to change in order to inform the newst changes. We wanted to be able to track the evolution of visually-based projects in a simple and intuitive way.

## Installation

Make sure a webserver (apache is fine) is installed and edit the gulpfile.js to point to its desired location.

```
npm install
gulp

```

## Contributors

Connor Osborn<EMAIL_ADDRESS>Anna Loukianova<EMAIL_ADDRESS>Andre Mercer<EMAIL_ADDRESS>## License

Copyright (c) 2015, Connor Osborn
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.

The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of the FreeBSD Project.

repository: cdosborn/heh

repo_name: cdosborn/heh


text:
# Vertica Extractor

![Build Status](https://github.com/joeygibson/verticaextractor/workflows/build/badge.svg)
![Release Status](https://github.com/joeygibson/verticaextractor/workflows/release/badge.svg)

A tool to read data from Vertica tables
and write out [Vertica native binary files](https://www.vertica.com/docs/9.3.x/HTML/Content/Authoring/AdministratorsGuide/BinaryFilesAppendix/CreatingNativeBinaryFormatFiles.htm).

This is a companion tool to [Vertica Reader](https://github.com/joeygibson/verticareader),
which can dump the contents of a native binary file to CSV.

**Note:** This is still very early in development, and the code is quite ugly. I'm working
on making it better. And yes, tests are coming.

## Usage

```bash
Usage: verticaextractor [options]

Options:
    -s, --server NAME   server to connect to [default: localhost]
    -p, --port NUMBER   port to connect to [default: 5433]
    -d, --database NAME database to extract from
    -u, --username NAME username for login [default: dbadmin]
    -P, --password PASSWORD
                        password for user [default: none]
    -o, --output NAME   output file name
    -f, --force         overwrite destination file
    -t, --table NAME    table to extract
    -l, --limit NUMBER  maximum number of rows to extract from <table>
    -h, --help          display this help message
```

## Building

This tool interfaces with Vertica through ODBC. This means that you need [unixODBC](http://www.unixodbc.org/) installed when building.

### Linux

```bash
apt-get update && apt-get install unixodbc-dev
```

### macOS

```bash
brew install unixodbc
```

## Runtime

At runtime, the [Vertica ODBC driver](https://www.vertica.com/download/vertica/client-drivers/) is required.

## TODO

* Correctly support `interval` types.

repository: joeygibson/verticaextractor

repo_name: joeygibson/verticaextractor


text:
Python Nexmo
============

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

**Don't use this, it's unmaintained. [Use the official Nexmo lib](https://github.com/Nexmo/nexmo-python).

`Python Nexmo` is a simple python wrapper for the [Nexmo
Api](https://docs.nexmo.com/).

Documentation
-------------

[There is one! And it is there.](http://libnexmo.readthedocs.org/en/latest/)

Installation
------------

Installation using pip is simple:

    $ pip install libnexmo

Testing
-------

`Python Nexmo` uses [tox for testing in multiple
environments](https://pypi.python.org/pypi/tox).

To run the tests, create a new virtualenv, then `pip install tox`. To run the
tests:

    tox

Credits
-------

Crafted with love by [Thibault Jouannic](http://www.miximum.fr). Available for
[Python / Django Freelancing](http://www.miximum.fr/a-propos/).

repository: thibault/libnexmo

gha_language: Python

repo_name: thibault/libnexmo


text:
GitLabKit
====

GitLabKit is an API client library for [GitLab API](https://gitlab.com/help/api/README.md), written in Swift.

Based on [this interesting idea](http://developer.hatenastaff.com/entry/smart-api-client-with-swift-using-enum-and-generics).

Notice: Public interfaces may be changed until the project version reaches into v1.0.

## Description

Followings currently implemented.

### GET

Almost all without Labels, Notes, Deploy Keys, System Hooks, Groups.
Testing is not enough.

### POST

Nothing yet.

### DELETE

Nothing yet.

## Requirement

GitLabKit is written as a Cocoa Framework (for OS X) for now.
Tested on OS X 10.12.5 with Xcode 8.3.3 (8E3004b), self hosted GitLab CE 7.5.3 b656b85.

- [Alamofire](https://github.com/Alamofire/Alamofire)
- [Mantle](https://github.com/Mantle/Mantle)

GitLabKit is using libraries listed above.
All dependencies are resolved by [CocoaPods](http://cocoapods.org/) with its version 1.2.0 or newer.

## Usage

```swift
// Init api client
let client: GitLabApiClient = GitLabApiClient(host: "https://git.example.com", privateToken: "YOUR-PRIVATE-TOKEN")

// Get users
let params = UserQueryParamBuilder()
client.get(params, handler: { (response: GitLabResponse<User>?, error: NSError?) -> Void in
	println(response!.result!.count)
})

// Get user by Id
let params = UserQueryParamBuilder().id(1)
client.get(params, handler: { (response: GitLabResponse<User>?, error: NSError?) -> Void in
    let user: User = response!.result![0]
	println(user.name!)
})
```

see [test sources](https://github.com/toricls/GitLabKit/tree/master/GitLabKitTests) to get more usage.

## TODO

- Implement more apis
- Decide on how to deal with 404 responses. I'm just treating them as normal responses and returning an empty array for [now](https://github.com/toricls/GitLabKit/blob/master/GitLabKit/GitLabApiClient.swift#L79).
- More effective and efficient testing with stub or something like that

## Contribution

1. Fork ([https://github.com/toricls/GitLabKit/fork](https://github.com/toricls/GitLabKit/fork))
2. Create a feature branch
3. Commit your changes
4. Rebase your local changes against the master branch
5. Create new Pull Request

## Licence

[MIT](https://github.com/toricls/GitLabKit/blob/master/LICENCE)

## Author

[toricls](https://github.com/toricls)

repository: ChasiTony/GitLabKit

repo_name: ChasiTony/GitLabKit


text:
# Private

Demo that shows how to create a "private" application that is only accessible
from within the Code Engine product. Meaning, it does not have an external
endpoint/URL that is reachable from the internal.

In this example we'll create 2 apps, `frontend` and `backend`. `frontend`
will be a normal app, accessible from the internet. `backend` is private and
is only accessible to `frontend`. Calling `frontend` will `curl` the `backend`
app and then include its response in the output back to the user.

- - -

As noted in [the main README](../README.md), this sample has two pieces:

- a `build` script which will build the container image(s) used
- a `run` script which deploys resources that use those images

The main purpose of this example is the `run` script, but the `build`
script is included for complete educational (and reuse) purposes.

repository: luisreyesoliva/CodeEngine

branch_name: refs/heads/main

repo_name: luisreyesoliva/CodeEngine


text:
# Mailgun Appender

This appender uses the [mailgun](https://www.mailgun.com) service to send log messages as emails. It requires the [mailgun-js](https://www.npmjs.com/package/mailgun-js) package to be added to your dependencies.

## Configuration

* `type` - `mailgun`
* `apiKey` - `string` - your mailgun API key
* `domain` - `string` - your domain
* `from` - `string`
* `to` - `string`
* `subject` - `string`
* `layout` - `object` (optional, defaults to basicLayout) - see [layouts](layouts.md)

The body of the email will be the result of applying the layout to the log event. Refer to the mailgun docs for how to obtain your API key.

## Example

```javascript
log4js.configure({
  appenders: {
    type: 'mailgun',
    apiKey: '123456abc',
    domain: 'some.company',
    from<EMAIL_ADDRESS>    to<EMAIL_ADDRESS>    subject: 'Error: Developers Need To Be Fired'
  }
});
```


text:
# migration-analysis

How are Laravels migration files used by web developers? This repository investigates 300K migrations to answer that question.

## Installation
First, make sure you have anaconda installed. Then
```
git clone git@github.com:ajthinking/migration-analysis.git
cd migration-analysis
conda env create
conda activate migration-analysis
````
get data using github.comajthinking/github-selective-scraper
````
python src/examples/migration-analysis/01_transform.py
```

## Todo
- [ ] Installation instructions not working
- [ ] Instructions on how to use github-selective-scraper

## License
MIT

repository: ajthinking/migration-analysis

repo_name: ajthinking/migration-analysis


text:
# OpenDigitalPay Use Cases

Built with the community in mind, BTCPay Server is a feature-rich software with **plenty of use-cases** that can solve problems for different types of users.

who want to use opendigitalpay
-companies want to launch mobile payment solutions
<!-- -companies want to become a FayFac. -->

![BTCPay UseCase Infographic](./img/infographics/BTCPayUseCaseInfographic.png "BTCPay Server UseCase Infographic")

The software usage is by no means limited to the groups of users mentioned in this document.

## Merchants

By **choosing BTCPay Server to process payments**, merchants are:

* Saving money (no fees, no subscriptions)
* Cutting out the middle-man (Payments go directly to their wallet)
* Enhancing privacy for their customers (no address re-use, no information leaks to third parties)
* Saving time (easy integration and installation)
* Protecting themselves from interference in their business (self-sovereignty)

### Online Store

Merchants running an **e-commerce business** can easily [deploy BTCPay Server](./Deployment.md) and connect it to their store via integration plugins in just a few clicks.

BTCPay Server checkout is no different to any other payment gateway. The customer gets an invoice. They pay it by scanning a QR code or by copy-pasting the amount and the address. When their payment is confirmed, the merchant is notified via the e-commerce software, and can ship the item.

Take a look at [our demo online store](https://store.btcpayserver.org/).

### Physical Store

For brick and mortar stores, BTCPay Server has a [web-based Point of Sale](./Apps.md#point-of-sale-app). Similarly to the online store, the customer is presented with an invoice that he can pay on the spot. The **POS app** can be run on any web-connected device.

Take a look at [our demo POS app](https://mainnet.demo.btcpayserver.org/apps/3utBTfSKkW4gK7aQMd2hW5Bh9Fpa/pos).

[![BTCPay Server for local communities](https://img.youtube.com/vi/9n81qnzlPf8/mqdefault.jpg)](https://www.youtube.com/watch?v=9n81qnzlPf8 "BTCPay Server for local communities")

## Self-sovereign individuals

**Privacy-minded individuals** can use BTCPay Server internal wallet for their everyday crypocurrency transactions without providing a private key. For self-hosted servers, the [internal wallet](./Wallet.md) relies on a full node, significantly enhances the privacy. [Hardware wallet integration](./HardwareWalletIntegration.md) allows the usage of a hardware wallet with a [full node](https://en.bitcoin.it/wiki/Full_node) and avoids leaks to a third-party server.

## Developers

BTCPay Server community is amiable and open-minded. **Developers** can not only learn a lot and get their name out by working on an open-source project, but also participate in transforming the payment processing business.

---

These are some of the many ways in which you can use BTCPay. Unleash your creativity and feel free to build your own solutions to solve problems.


text:
Metalsmith-excerptor
====================

A Metalsmith plugin to create an excerpt from html data, it truncates correctly
all html tags thanks to [html-truncate](https://www.npmjs.com/package/html-truncate).

Usage
-----

```javascript
var excerptor = require('metalsmith-excerptor');

Metalsmith(__dirname)
    .use( excerptor({
        maxLength: 800,
        keepImageTag: true,
        ellipsis: '…'
    }))

```

`excerptor` will create a new attribute to all object files with a max length of
800 characters, keeping the image tags (`<img>`).

Options
-------

**maxLength** `Number` (optional, default=`300`): Excerpt's max length

**keepImageTag** `Boolean` (optional, default=`true`)

**ellipsis** `String` (optional, default=`''`): String attached to the end of the excerpt

License
-------

Copyright (c) 2016, Elkin Cruz
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright notice, this
   list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
   this list of conditions and the following disclaimer in the documentation
   and/or other materials provided with the distribution.

The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of the FreeBSD Project.

repository: justinhachemeister/metalsmith-excerptor

repo_name: justinhachemeister/metalsmith-excerptor


text:
---
layout: post
title: "Linux is Case sensitive"
subtitle:   "Linux is Case sensitive !"
date:       2015-08-01 21:54:00 +0800
author:     "Dongyupu"
header-img: "img/post-bg-05.jpg"
---
# Linux is Case sensitive !

>C++ : include <>

>shell command

尤其是你在做跨平台应用时更要注意，否则在迁往Linux平台编译时就不得不回头去改那些大小写没匹配的，切记。

extension: markdown


text:
---
permalink: "blog/last-night-was-9/"
tags: posts
title: Last night was
date: 2002-01-08
layout: layouts/post.njk
---

Last night was a good time all around. Me and Steph went to [this kid's][1] apartment to see The Saturdays play, as advertised in his journal. While there, Polk confirmed that I was right all along about his car troubles. It was not his battery, it was his starter. So there, Amy.

Anyhoo, the band was good and it was just interesting to see a concert played in that small a room. I bought their CD, but have yet to listen to it.

After the concert, I went to meet KJ and Fabish at Gorman's, where much beer was consumed. I came home and dicked around on the internet for a while, wasting time so I wouldn't go to sleep drunk. Going to sleep drunk is a sure-fire way for me to be totally and completely hungover. Instead I'm just tired.

Today I have a lot of work to do.

On a completely unrelated note, I can now take credit card payments over the phone or internet. If you want to pay me for something, I'm sure we can work something out.

 [1]: http://www.livejournal.com/users/rad_jose

repository: timwasson/timwasson

gha_language: HTML

repo_name: timwasson/timwasson


text:
# #100DaysOfMLCode

# Overview

This is a progress report of my pledge to [Siraj Raval's](https://www.youtube.com/watch?v=cuQMBj1cWPo) #100DaysofMLCode challenge. I will be updating here to links, activities of my work involving Machine Learning. Let's roll!

Link to my pledge: [here](https://www.linkedin.com/feed/update/urn:li:activity:6420854361001422848)

## Day 0: July 06, 2018

Work: Optimising power consumption of home appliances, study on Regularisation and Feature engineering

Thoughts: It was to fun to start off 100DaysOfMLCode. It was difficult to manipulate pandas using custom functions

Link to work: [Github](www.github.com/nsudhanva/home)

## Day 1: July 07, 2018

Work:
1. Optimising power consumption of home appliances, applied regression and plotted graphs of power consumption
2. Created new dataset for power consumption by date, time, month
3. Devices columns are added and new priority database of devices and weather is created

Thoughts: Because the data in randomly generated, the graphs look similar and symmetric in nature. Will change as real dataset is provided.

Link to work: [Github](www.github.com/nsudhanva/home)

## Day 2: July 08, 2018

Work:
1. Study on GridSearch CV
2. Started the book Hands on Machine Learning with Tensorflow and Scikit

Thoughts: Machine Learning is more complicated than expected. The book that I am reading is pretty awesome!

## Day 3: July 09, 2018

Work:
1. Coded custom algorithm to optimise power consumption of home appliances
2. Plotted power consumption rates and minimised power consumption based on priority

Thoughts: Data generated is run across different trails and multiple regression algorithms are applied

Link to work: [Github](www.github.com/nsudhanva/home)

## Day 4: July 10, 2018

Work:
1. Generated new datasets and applied machine learning algorithms on the previous project
2. Results are calculated and power consumption is compared
3. Started the course, Tensorflow for Beginners

Thoughts: Tensorflow provides low level APIs and is much more complicated than expected. It also helps in creating custom machine learning models and algorithms

Link to work: [Github](www.github.com/nsudhanva/home)

## Day 5: July 11, 2018

Work:
1. Measured real data of Electrical Impedance Tomography
2. New dataset is created for both male and female candidates
3. Understood a couple of TensorFlow tutorials

Thoughts: EIT has high potential and can be used to classify affected human areas

Link to work: [Github](www.github.com/nsudhanva/home)

## Day 6: July 12, 2018

Work:
1. Measured impedance of people and logged real data
2. Dataset is created and is pre-processed

Thoughts: As the real data is small and has high distribution, further investigation and hypothesis has to be made

Link to work: [Github](www.github.com/nsudhanva/home)

## Day 7: July 13, 2018

Work:
1. Analysed parameters for dataset
2. Read through multiple research papers for measuring impedance from people
3. Study on reccurent neural networks and convolutional neural networks

Thoughts: As the real data is small and has high distribution, further investigation and hypothesis has to be made

Link to work: [Github](www.github.com/nsudhanva/home)
Link to work: [Github](www.github.com/nsudhanva/eit)

## Day 8: July 14, 2018

Work:
1. Participated in Target-HR Hackathon 12 hr hackathon
2. Had to analyse and interpret results for a book dataset
3. Completed the task given in time

Thoughts: One of the best hackathon I have ever been to. Kudos to Target HR for the great hackathon!

Link to work: [Github](www.github.com/nsudhanva/target-hr-hackathon)

## Day 9: July 15, 2018

Work:
1. Studied basics of Recurrent neural networks
2. Trained a model on Convolutional Neural networks

Thoughts: Tensorflow GPU is much much faster than Tensorflow CPU

Link to work: [Github](www.github.com/nsudhanva/)

## Day 10: July 16, 2018

Work:
1. Wrote documnetation for my project at work
2. Prepared a presentation for the same
3. Tested out some code to understand a couple of custom functions

Thoughts: Documentation is boring but important!

Link to work: [Github](www.github.com/nsudhanva/eit/docs)

## Day 11: July 17, 2018

Work:
1. Wrote report for the Home automation project
2. Learnt about stock trading using Machine Learning
3. Completed presentation given previously

Thoughts: Stock trading using Machine Learning has huge potential and opened my mind

Link to work: [Github](www.github.com/nsudhanva/eit/docs)

## Day 12: July 18, 2018

Work:
1. Prepared presentation for the Electrical Impedance Tomography Project
2. Read about feature selection and feature engineering
3. Started writing research paper on home automation devices

Thoughts: Writing research paper by using MS Word is a difficult skill!

Link to work: [Github](www.github.com/nsudhanva/eit/docs)

## Day 13: July 19, 2018

Work:
1. Completed two courses on datacamp
2. Network analysis using NetworkX API
3. Research paper on home automation devices

Thoughts: Network analysis is awesome!!

Link to work: [Github](www.github.com/nsudhanva/home/docs)

## Day 14: July 20, 2018

Work:
1. Joining data using SQL on DataCamp
2. Research paper on home automation devices
3. Study on Neural Networks on Fast AI

Thoughts: Lots of work to do on Deep Learning

Link to work: [Github](www.github.com/nsudhanva/)

## Day 15: July 21, 2018

Work:
1. Completed Research Paper
2. Study on Regression evalution metrics
3. Applied Regression evalution metrics to home database

Thoughts: Mean Absolute Error, Mean Squared Error, RMSE are intersting metrics

Link to work: [Github](www.github.com/nsudhanva/home

## Day 16: July 22, 2018

Work:
1. Study on Matrices and Vectors
2. Study on Neural Networks

Thoughts: Mathematics is really important for Machine Learning

Link to work: [Github](www.github.com/nsudhanva/)

## Day 17: July 23, 2018

Work:
1. Completed Joining Data in SQL from DataCamp
2. Completed Data Scientist using Python Track from DataCamp

Thoughts: DataCamp is a great place to get started for Machine Learning

Link to work: [DataCamp](https://www.datacamp.com/statement-of-accomplishment/track/551e08147586c6fa56850e8f301ba3c3d8c0f604)

## Day 18: July 24, 2018

Work:
1. Re-run tests and results for new values on the home automation project
2. Completed research paper on home automation project

Thoughts: It's always great to write research papers

Link to work: [GitHub](https://www.github.com/nsudhanva/home)

## Day 19: July 25, 2018

Work:
1. Read about IBM Quantum computing and its applications
2. Started working on previously created booking app

Thoughts: Quantum computing and AI can do amazing things

Link to work: [GitHub](https://www.github.com/nsudhanva/)

## Day 20: July 26, 2018

Work:
1. Finishing up internship work
2. Started watching Deep Learning AZ

Link to work: [GitHub](https://www.github.com/nsudhanva/)

## Day 21: July 27, 2018

Work:
1. Finishing up internship work
2. Finished report and presentation. Last day of work

Thoughts: Internship was awesome!

Link to work: [GitHub](https://www.github.com/nsudhanva/)

## Day 22: July 28, 2018

Work:
1. Started predictive analytics course
2. Continue watching Deep Learning AZ
3. Started Affine Analytics Challenge ML

Thoughts: Predictive analytics is awesome

Link to work: [GitHub](https://www.github.com/nsudhanva/)

## Day 23: July 29, 2018

Work:
1. Continue watching Deep Learning AZ
2. Previous Code and Starting new project on Data Preprocessing

Link to work: [GitHub](https://www.github.com/nsudhanva/)

## Day 24: July 30, 2018

Work:
1. Continue watching Deep Learning AZ
2. Discuss possible machine learning projects from biotech department

Link to work: [GitHub](https://www.github.com/nsudhanva/)

## Day 25: August 1, 2018

Work:
1. Continue watching Deep Learning AZ
2. Study on AWS Machine Learning

Link to work: [GitHub](https://www.github.com/nsudhanva/)

## Day 26: August 2, 2018

Work:
1. Continue watching Deep Learning AZ
2. Study on LMS and Machine Learning for education

Link to work: [GitHub](https://www.github.com/nsudhanva/)

## Day 27: August 3, 2018

Work:
1. Finished watching Deep Learning AZ
2. Taught SQL to a class of 100

Link to work: [GitHub](https://www.github.com/nsudhanva/)

## Day 28: August 4, 2018

Work:
1. Taught Advanced SQL to a class of 100
2. Study on Recommendation Systems

Link to work: [GitHub](https://www.github.com/nsudhanva/)

## Day 29: August 5, 2018

Work:
1. Study on Recommendation Systems
2. Completed the course from Lynda on Recommendation systems - basics

Link to work: [GitHub](https://www.github.com/nsudhanva/)

## Day 30: August 6, 2018

Work:
1. Study on Recommendation Systems
2. Started recommendation systems using pandas course
3. Tried to implement and relate recommendation systems to assignments

Link to work: [GitHub](https://www.github.com/nsudhanva/)

## Day 31: August 7, 2018

Work:
1. Study on Recommendation Systems
2. Data Analysis for one user and his assingment-submission timings

Link to work: [GitHub](https://www.github.com/nsudhanva/)

## Day 32: August 8, 2018

Work:
1. Study on SVD
2. Data Analysis for all user and his assingment-submission timings

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 33: August 9, 2018

Work:
1. Architect datapoints for DCT platform
2. Implemented SVD to recommend related assignments

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 34: August 10, 2018

Work:
1. SQL to analyze and understand data
2. Merge and Join data with sql and then pandas

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 35: August 11, 2018

Work:
1. Architect datapoints for DCT platform
2. Analyze and recommend assignments for students based on another assignment

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 36: August 12, 2018

Work:
1. Study on Apriori ML algorithms

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 37: August 13, 2018

Work:
1. Built a recommendation system for recommending assignments to students using SVD

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 38: August 14, 2018

Work:
1. Built a recommendation system for recommending assignments to students using KNN

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 39: August 15, 2018

Work:
1. Study on AWS machine learning
2. Study on recommendation systems using Implicit and Explicit feedback systems

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 40: August 16, 2018

Work:
1. Built a recommendation system using Implicit feedback system
2. Used implicit library to improve sparse matrix computation

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 40: August 17, 2018

Work:
1. Built a recommendation system API to serve for DCT Platform
2. API runs on Flask and is deployed to heroku

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 40: August 18, 2018

Work:
1. Study on Explicit recommendation systems

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 41: August 19, 2018

Work:
1. Study on Explicit recommendation systems
2. Retrained model to match with assignments instead of submissions

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 42: August 20, 2018

Work:
1. Study on Implicit recommendation systems
2. Deployed Flask model to Heroku and built and API around it

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 43: August 21, 2018

Work:
1. Used a new confidence metric system to evalute student behavior
2. Deployed new model to Heroku and tested for correctness

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 44: August 22, 2018

Work:
1. API keys and authentication setup for code app
2. Bug fixes and exception handling for the API

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 45: August 23, 2018

Work:
1. Setup API ends points to render json on recommendations
2. Explore new options on recommendations for assignments

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 46: August 24, 2018

Work:
1. Reorder folders and made a common model folder

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 47: August 25, 2018

Work:
1. Wrote documentation on ML API
2. Minor changes on model

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 48: August 26, 2018

Work:
1. Changes to documentation to the DCT ML API
2. Added new algorithm to the request and number of assingments exception fix

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 49: August 27, 2018

Work:
1. Setting up AWS and SageMaker for Jupyter Notebooks

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 50: August 28, 2018

Work:
1. Changes to documentation to the DCT ML API
2. Retrain the model and push the code to Heroku API

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 51: August 29, 2018

Work:
1. Gave a presentation on Recommendation Systems and API
2. Started writing Research Paper on the same project

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 52: August 30, 2018

Work:
1. Gave a presentation on Recommendation Systems and API
2. Started writing Research Paper on the same project

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 53: August 31, 2018

Work:
1. Gave a presentation on Recommendation Systems and API
2. Started writing Research Paper on the same project

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 54: September 1, 2018

Work:
1. Gave a presentation on Recommendation Systems and API
2. Started writing Research Paper on the same project

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 55: September 2, 2018

Work:
1. Gave a presentation on Recommendation Systems and API
2. Started writing Research Paper on the same project

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 56: September 3, 2018

Work:
1. Gave a presentation on Recommendation Systems and API
2. Started writing Research Paper on the same project

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 57: September 4, 2018

Work:
1. Gave a presentation on Recommendation Systems and API
2. Started writing Research Paper on the same project

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 58: September 5, 2018

Work:
1. Gave a presentation on Recommendation Systems and API
2. Started writing Research Paper on the same project

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 59: September 6, 2018

Work:
1. Gave a presentation on Recommendation Systems and API
2. Started writing Research Paper on the same project

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 60: September 7, 2018

Work:
1. Gave a presentation on Recommendation Systems and API
2. Started writing Research Paper on the same project

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 61: September 8, 2018

Work:
1. Gave a presentation on Recommendation Systems and API
2. Started writing Research Paper on the same project

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 62: September 9, 2018

Work:
1. Gave a presentation on Recommendation Systems and API
2. Started writing Research Paper on the same project

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

## Day 63: September 10, 2018

Work:
1. Started learning Node JS
2. Understood the life cycle of a Javascript app

Link to work: [GitHub DCT](https://www.github.com/dctacademy/dct)

---

# Author

[Sudhanva Narayana](www.sudhanva.in)

# Credits

[Siraj Raval](https://www.youtube.com/channel/UCWN3xxRkmTPmbKwht9FuE5A)

license: Unlicense


text:
---
templateKey: blog-post
title: Prefer Custom Exceptions to Framework Exceptions
path: blog-post
date: 2017-05-10T02:59:00.000Z
description: An easy way to make your software easier to work with, both for
  your users and for developers, is to use higher level custom exceptions. Low
  level exceptions like NullReferenceException or ArgumentNullException should
  rarely be returned from business-level classes, where most of your custom
  logic should reside.
featuredpost: false
featuredimage: /img/aspnetcore-logo.png
tags:
  - antipattern
  - clean code
  - ddd
  - dddesign
  - dotnet
  - exceptions
category:
  - Software Development
comments: true
share: true
---
An easy way to make your software easier to work with, both for your users and for developers, is to use higher level custom exceptions. Low level exceptions like NullReferenceException or ArgumentNullException should rarely be returned from business-level classes, where most of your custom logic should reside. By using custom exceptions, you make it much more clear to everybody involved what the actual problem is.

For example, let’s say you’re writing an application that works with a database. Perhaps it’s an [ASP.NET Core application](http://aspnetcorequickstart.com/) in the medical or insurance industry, and it references individual customers as Subjects. Within some business logic dedicated to creating an invoice, recording a prescription, or filing a claim, there’s a reference to the Subject Id that is invalid. When your data layer makes the request and returns from the database, the result is empty.

```csharp
// get subject
var subject = GetSubject(subjectId);
subject.DoSomething();
```

Obviously in the code above, if Subject is null, the last line is going to throw an exception (you can avoid this by using the [Null Object Pattern](http://deviq.com/null-object-pattern/)). Let’s further assume that we can’t handle this exception here – if the subject id is incorrect, there’s nothing else for this method to do but throw an exception, since it was going to return the subject otherwise. The current behavior for a user, tester, or developer is this:

```csharp
Unhandled Exception:
`System.NullReferenceException: Object reference not set to an instance of an object. ...
```

One of the most annoying things about the NullReferenceException is that it is so vague. It never actually specifies which reference, exactly, was not set to an instance of an object. This can make debugging, or reporting problems, much more difficult. In the above example, we’re not specifically throwing any exception, but we are allowing a NullReferenceException to be thrown in the event that we’re unsuccessful in looking up a Subject for a given ID. It’s still a part of our design to rely on NullReferenceException, though in this case it’s implicit. What if instead of returning null from GetSubject we threw a SubjectNotFoundException? Or if we weren’t sure that an exception made sense in every scenario, what if we checked for null and then threw a better exception before moving on to work with the returned subject, like in this example:

```csharp
// get subject var subject = GetSubject(subjectId);
if (subject == null) throw new SubjectNotFoundException(subjectId);
subject.DoSomething();
```

If we don’t follow this approach, and instead we let the NullReference propagate up the stack, it’s likely (if the application doesn’t simply show a Yellow Screen of Death or a default Oops page) that we will try to catch NullReferenceException and inform the user of what might be the problem. But by then we might be so far removed from the exception that even we can’t know for sure what might have been null and resulted in the exception being thrown. Raising a more specific, higher level exception makes our own exception handlers much easier to write.

## Writing Custom Exceptions

Custom exceptions are actually very easy to write. All you need to do is inherit from Exception and name them with an Exception suffix. I recommend for very specific ones that you also provide a default message, so that you don’t need to provide a message every time you throw the exception. You can also include additional parameters if that’s useful. If your exception is in response to a lower level one, be sure to provide a constructor parameter for innerException so that you can pass that in as well. Here’s how you might implement the SubjectNotFoundException described above:

```csharp
public class SubjectDoesNotExistException : Exception
  {
    public SubjectDoesNotExistException(int subjectId)
        : base($"Subject with ID "{subjectId}" does not exist.")
        { }
  }
```

This example uses *constructor chaining* to pass arguments from its constructor to its base constructor (in this case, the base constructor accepts a string message). Now in the example above, with no error handling in place, the user will get a message stating “Subject with ID 123 does not exist.” instead of “Object reference not set to an instance of an object.” which is far more useful for debugging or reporting purposes. In general, you should avoid putting custom logic into your custom exceptions. In most scenarios, custom exceptions should consist only of a class definition and one or more constructors that chain to the base Exception constructor.

If you follow domain-driven design, I recommend placing most of your business-logic related exceptions in your Core project, with your domain model. You should be able to easily unit test that these exceptions are thrown when you expect them to be, from your entities and services.

repository: ShadyNagy/ardalis-com-gatsby

repo_name: ShadyNagy/ardalis-com-gatsby


text:
## Buildstep

|          |           |
| -------- | --------- |
| title    | Buildstep |
| status   | 90        |
| section  | DevOps    |
| keywords | DevOps    |

Buildsteps is an open software developed under MIT license.  It is a
base for Dockerfile and it activates Heroku-style application. Heroku
is a platform-as-service (PaaS) that automates deployment of
applications on the cloud. The program is pushed to the PaaS using git
push, and then PaaS detects the programming language, builds, and runs
application on a cloud platform [@plassnig15].  Buildstep takes
two parameters: a tar file that contains the application and a new
application container name to create a new container for this
application. Build script is dependent on buildpacks that are
pre-requisites for buildstep to run. The builder script runs inside
the new container.  The resulting build app can be run with Docker
using docker build -t your\_app\_name
command. [@github-buildstep].

gha_language: Jupyter Notebook


text:
# lisqp
A Common Lisp quantum library and quantum emulator.

## What's for?
Quantum computation is approaching!
But it's really awkward to define a quantum register with specific content and
then assign a meaning to it, instead I want to directly input a number,
generate a quantum register to represent it (or even call quantum
functions with classic arguments). Then we can have a canonical interface to
handle classical arithmetics and quantum arithmetics.

## How to build?
Current implement and test platform is SBCL. But since I only use ANSI or
standard functions, I guess it will run on other platforms.
In SBCL:

    CL-USER> (:require :cl-lisqp)

will load the quantum library and quantum emulator.
On platforms don't support `:require` function:

    CL-USER> (asdf:load-system :cl-lisqp)

Now it won't run... Still under development...

repository: AugustusHuang/lisqp

repo_name: AugustusHuang/lisqp


text:
# Wyatt

[![Build Status](https://travis-ci.org/arthurlockman/wyatt.svg?branch=master)](https://travis-ci.org/arthurlockman/wyatt) [![codecov](https://codecov.io/gh/arthurlockman/wyatt/branch/master/graph/badge.svg)](https://codecov.io/gh/arthurlockman/wyatt)

The maze wasn't meant for you.

[Go to the project website for installation instructions, usage, and examples.](http://wyatt.rthr.me)

repository: EvilTony/wyatt

repo_name: EvilTony/wyatt


text:
# Functionalities implemented:
* <b>isPrime: </b> Returns a boolean based on given number is prime or not.

# Some important points:
* Argument of type is unsigned int.
* Time: O(log(n)) for n as num.
* Space: O(1)
* Example: bool ans = isPrime(7);


text:
# SwiftUI Environment Overrides

![Platform](https://img.shields.io/badge/platform-iOS%20%7C%20macOS-lightgrey) [![blog](https://img.shields.io/badge/blog-github-blue)](https://nalexn.github.io/?utm_source=nalexn_github) [![venmo](https://img.shields.io/badge/%F0%9F%8D%BA-Venmo-brightgreen)](https://venmo.com/nallexn)

A tiny library that adds a control panel for testing how SwiftUI app adapts for different color themes, accessibility settings, and localizations.

#### Make your QA team happy!

Inspired by "Environment Overrides" pane in Xcode, but allows to QA the actual running app instead of the preview in Xcode.

Supported settings that you can toggle on the fly:

* [Light / Dark mode](https://developer.apple.com/design/human-interface-guidelines/macos/visual-design/dark-mode/)
* [Localization](https://developer.apple.com/library/archive/documentation/MacOSX/Conceptual/BPInternational/Introduction/Introduction.html)
* [Dynamic Type Text Size](https://developer.apple.com/documentation/uikit/uifont/scaling_fonts_automatically)
* [Right-to-Left User Interface](https://developer.apple.com/library/archive/documentation/MacOSX/Conceptual/BPInternational/SupportingRight-To-LeftLanguages/SupportingRight-To-LeftLanguages.html)
* [Accessibility](https://developer.apple.com/documentation/uikit/accessibility/)

You can quickly take screenshots in different languages for iTunes Connect (the panel hides itself).

Attach the control panel with just one line of code:

```swift
ContentView()
    .attachEnvironmentOverrides()
```

Integration with Swift Package Manager:

1. In Xcode select **File ⭢ Swift Packages ⭢ Add Package Dependency...**
2. Copy-paste repository URL: **https://github.com/nalexn/EnvironmentOverrides**
3. Hit **Next** two times
4. Hit **Finish**

repository: BondexApp/EnvironmentOverrides

repo_name: BondexApp/EnvironmentOverrides


text:
#     Zoom

Create a Recording Registrant

Cloud Recordings of past Zoom Meetings can be made [on-demand](https://support.zoom.us/hc/en-us/articles/360000488283-On-demand-Recordings). Users should be [registered](https://marketplace.zoom.us/docs/api-reference/zoom-api/cloud-recording/meetingrecordingregistrantcreate) to view these recordings.

Use this API to register a user to gain access to **On-demand Cloud Recordings** of a past meeting.
**Scopes:** `recording:write:admin`, `recording:write`.

Method: Post

OperationID: meetingRecordingRegistrantCreate

EndPoint:

/meetings/{meetingId}/recordings/registrants

Usage: custom_questions[]

[{
  "title": "%title%",
  "value": "%value%"
}]

url: https://raw.githubusercontent.com/Ayehu/custom-activities/32729dddfbe7fb74dbd0179bba01978dccf84b1b/Zoom/Cloud Recording/ZM Create a Recording Registrant/Readme.md

repository: Ayehu/custom-activities

gha_language: C#

repo_name: Ayehu/custom-activities


text:
# [ARCHIVED]
I highly recommend checking out:
- [bmio](https://github.com/coyote963/bmio). It's a python library that makes rcon scripting for Boring Man way more easy.
- [rcon_scripts](https://github.com/Boring-Man-Tools/rcon_scripts). It's a collection of rcon scripts written using bmio.

I'm archiving this repository because I will not maintain it. Feel free to fork it if you need updates.

# bm-rcon
Library for Boring Man RCON scripting

## Requirements
This project uses .NET Core 2.0. and Json.NET as dependencies.

## Boring Man RCON
RCON stands for Remote CONsole. It is used to send and receive data from Boring Man servers.
The documentation about Boring Man RCON is **[here](https://github.com/Spasman/rcon_example)**.
You can find the different commands to send to the server **[here](https://github.com/coyote963/bm-boilerplate#additional-server-commands-you-can-send-these-packets-via-rcon-besides-the-request-data-ones)**.

## To get started
Check *Program.cs* for a complete example on how to use the library.

## Todo
- Tests (maybe...)
- Update enums for latest beta release

## Licenses
This project is under the MIT license.
.NET Core 2.0 is under the MIT license.
Json.NET is under the MIT license.

repository: ShaigroRB/bm-rcon

repo_name: ShaigroRB/bm-rcon


text:
Forked from https://source.netsyms.com/Netsyms/NiceDirlist.git

# Nice Dirlist

A single-file solution for pretty directory listings

See it in use at https://static.netsyms.net and https://dl.netsyms.net

## Features

* Built-in file type guessing
* FontAwesome icons
* Responsive with Bootstrap 4.0
* Support for adding mirror URLs

## Installing

* Upload `index.php` to the web root
* Upload `htaccess` and rename to `.htaccess`
    * For non-Apache, configure your server to serve /index.php for all subfolders
* Edit the top of `index.php` to customize with your branding
    * Edit the list of ignored filenames
    * Add any mirror URLs you have
    * (Recommended) Change the CDN URLs for Bootstrap and FontAwesome to your CDN of choice

repository: ibiwan/NiceDirList

repo_name: ibiwan/NiceDirList


text:
# Paradiddle

#### What is Paradiddle?

Paradiddle is a lightweight css library for developing websites.

#### Features

- Flexbox based grids
- Mobile-first design
- Built with SASS
- Ability to use only the features needed

#### API
[Paradiddle API](http://ganderzz.github.io/Paradiddle)

#### Log

V0.0.1

- Flexbox grids with offsets
- Form styling
- Typography and base styling
- Utilities

repository: ganderzz/Paradiddle-css

repo_name: ganderzz/Paradiddle-css


text:
# node-todo
Demo Node ToDo App

### Installation

```bash
npm install
```
### Starting application

```bash
npm start
```

### Actions

1. A user can add, edit and delete `todos`
1. Each todo can be marked as complete
1. Each todo can have one optional file attachments
1. One person cannot access the todos of another

repository: nalindak/node-todo

repo_name: nalindak/node-todo


text:
# What is currently in this repo?
This repo contains 2 separate things. On one hand we have implemented a W3C EBNF (yes it is a separate form of EBNF) parser generator which will generate a parser for the EBNF vocabulary passed. The other thing is a SPARQL parser which uses the previous parser generator to ... generate a parser.

## Getting started in iex
to start iex with all files loaded type the following in the root directory:
```
iex -S mix
```

### load the SPARQL EBNF vocabulary
```
> sparql_ebnf = EbnfParser.Forms.sparql()
```

# Code documentation
This section is intended as a hands on code getting started. The key methods of all modules will be illustrated with simple examples. Each time the full method signature will be used as the section title. All examples work in iex.

## Parser.parse(query)
Parsing a query will give the following tree as a result:
```
> query = "SELECT * WHERE { ?s ?p ?o . }"
> Parser.parse(query)
>
> %Generator.Result{
  leftover: [],
  match_construct: [
    %InterpreterTerms.SymbolMatch{
      symbol: :QueryUnit,
      string: "SELECT * WHERE {?s ?p ?o .}",
      submatches: [
        %InterpreterTerms.SymbolMatch{
          symbol: :Query,
          string: "SELECT * WHERE {?s ?p ?o .}",
          submatches: [
            %InterpreterTerms.SymbolMatch{
              symbol: :Prologue,
              string: "",
              submatches: []
            },
            %InterpreterTerms.SymbolMatch{
              symbol: :SelectQuery,
              string: "SELECT * WHERE {?s ?p ?o .}",
              submatches: [
                %InterpreterTerms.SymbolMatch{
                  symbol: :SelectClause,
                  string: "SELECT *",
                  submatches: [
                    %InterpreterTerms.WordMatch{word: "SELECT"},
                    %InterpreterTerms.WordMatch{word: "*"}
                  ]
                },
                %InterpreterTerms.SymbolMatch{
                  symbol: :WhereClause,
                  string: " WHERE {?s ?p ?o .}",
                  submatches: [
                    %InterpreterTerms.WordMatch{word: "WHERE"},
                    %InterpreterTerms.SymbolMatch{
                      symbol: :GroupGraphPattern,
                      string: " {?s ?p ?o .}",
                      submatches: [
                        %InterpreterTerms.WordMatch{word: "{"},
                        %InterpreterTerms.SymbolMatch{
                          symbol: :GroupGraphPatternSub,
                          string: "?s ?p ?o .",
                          submatches: [
                            %InterpreterTerms.SymbolMatch{
                              symbol: :TriplesBlock,
                              string: "?s ?p ?o .",
                              submatches: [
                                %InterpreterTerms.SymbolMatch{
                                  symbol: :TriplesSameSubjectPath,
                                  string: "?s ?p ?o",
                                  submatches: [
                                    %InterpreterTerms.SymbolMatch{
                                      symbol: :VarOrTerm,
                                      string: "?s",
                                      submatches: [
                                        %InterpreterTerms.SymbolMatch{
                                          symbol: :Var,
                                          string: "?s",
                                          submatches: [
                                            %InterpreterTerms.SymbolMatch{
                                              symbol: :VAR1,
                                              string: "?s",
                                              submatches: :none
                                            }
                                          ]
                                        }
                                      ]
                                    },
                                    %InterpreterTerms.SymbolMatch{
                                      symbol: :PropertyListPathNotEmpty,
                                      string: " ?p ?o",
                                      submatches: [
                                        %InterpreterTerms.SymbolMatch{
                                          symbol: :VerbSimple,
                                          string: "?p",
                                          submatches: [
                                            %InterpreterTerms.SymbolMatch{
                                              symbol: :Var,
                                              string: "?p",
                                              submatches: [
                                                %InterpreterTerms.SymbolMatch{
                                                  symbol: :VAR1,
                                                  string: "?p",
                                                  submatches: :none
                                                }
                                              ]
                                            }
                                          ]
                                        },
                                        %InterpreterTerms.SymbolMatch{
                                          symbol: :ObjectListPath,
                                          string: " ?o",
                                          submatches: [
                                            %InterpreterTerms.SymbolMatch{
                                              symbol: :ObjectPath,
                                              string: "?o",
                                              submatches: [
                                                %InterpreterTerms.SymbolMatch{
                                                  symbol: :GraphNodePath,
                                                  string: "?o",
                                                  submatches: [
                                                    %InterpreterTerms.SymbolMatch{
                                                      symbol: :VarOrTerm,
                                                      string: "?o",
                                                      submatches: [
                                                        %InterpreterTerms.SymbolMatch{
                                                          symbol: :Var,
                                                          string: "?o",
                                                          submatches: [
                                                            %InterpreterTerms.SymbolMatch{
                                                              symbol: :VAR1,
                                                              string: "?o",
                                                              submatches: :none
                                                            }
                                                          ]
                                                        }
                                                      ]
                                                    }
                                                  ]
                                                }
                                              ]
                                            }
                                          ]
                                        }
                                      ]
                                    }
                                  ]
                                },
                                %InterpreterTerms.WordMatch{word: "."}
                              ]
                            }
                          ]
                        },
                        %InterpreterTerms.WordMatch{word: "}"}
                      ]
                    }
                  ]
                },
                %InterpreterTerms.SymbolMatch{
                  symbol: :SolutionModifier,
                  string: "",
                  submatches: []
                }
              ]
            },
            %InterpreterTerms.SymbolMatch{
              symbol: :ValuesClause,
              string: "",
              submatches: []
            }
          ]
        }
      ]
    }
  ],
  matched_string: "SELECT * WHERE {?s ?p ?o .}"
}
```

## EbnfParser.Tokenizer.tokenize(string)
Below are some examples of what can be expected when the example string is passed into the method. These input-output pairs should help understand what the tokenizer will produce for a given input.

### Where to situate the inputs
The strings that the tokenize method consumes are the third part of an EBNF rule, the first is the name and the second is the mandatory splitting character series '::='.

### IRIREF ::= '<' ([^<>\"{}|^`\]-[#x00-#x20])* '>'
#### input
```
> input = "  \t'<' ([^<>\\\"{}|^`\\]-[#x00-#x20])* '>'"
```
#### ouput
```
> input |> EbnfParser.Tokenizer.tokenize
>[
  [
    {:single_quote, "<"},
    {:open_paren},
    {:open_bracket},
    {:negation},
    {:character, "<"},
    {:character, ">"},
    {:character, "\\"},
    {:character, "\""},
    {:character, "{"},
    {:character, "}"},
    {:character, "|"},
    {:character, "^"},
    {:character, "`"},
    {:character, "\\"},
    {:close_bracket},
    {:minus},
    {:open_bracket},
    {:hex_character, 0},
    {:range},
    {:hex_character, 32},
    {:close_bracket},
    {:close_paren},
    {:star},
    {:single_quote, ">"}p
  ]
```

### PNAME_NS ::= PN_PREFIX? ':
#### input
```
> input = "  \tPN_PREFIX? ':'"
```
#### output
```
> [{:symbol, :PN_PREFIX}, {:question_mark}, {:single_quote, ":"}]
```

### BLANK_NODE_LABEL ::= '_:' ( PN_CHARS_U | [0-9] ) ((PN_CHARS|'.')* PN_CHARS)?
#### input
```
> input = "  \t'_:' ( PN_CHARS_U | [0-9] ) ((PN_CHARS|'.')* PN_CHARS)?"
```
#### output
```
> [
    {:single_quote, "_:"},
    {:open_paren},
    {:symbol, :PN_CHARS_U},
    {:pipe},
    {:open_bracket},
    {:character, "0"},
    {:range},
    {:character, "9"},
    {:close_bracket},
    {:close_paren},
    {:open_paren},
    {:open_paren},
    {:symbol, :PN_CHARS},
    {:pipe},
    {:single_quote, "."},
    {:close_paren},
    {:star},
    {:symbol, :PN_CHARS},
    {:close_paren},
    {:question_mark}
  ]
```

### EbnfParser.Parser.tokenize_and_parse(rule)
This method takes the right hand side of an EBNF rule and transforms it into a well understood rule format. That well understood format will then be passed on to the methods validating that a certain input adheres to its form or to the generators that will produce output based on this rule.

#### INTEGER   ::=   [0-9]+
The integer rule has as input:
```
> input = "[0-9]+"
```

The parser generators the following output:
```
> input |> EbnfParser.Parser.tokenize_and_parse
> [ one_or_more:
    [ bracket_selector:
      [range:
        [character: "0", character: "9"]
      ]
    ]
]
```

# TODO's

# File structure
* lib
  * sparql.ex -> still the original file, uses erlang parser generators, will take a SPARQL query and then shove it through the parser
  * parser.ex -> W3C EBNF parser (now also sports the new SPARQL parser maybe needs to be separated)
  * benchmark.ex -> single benchmark function, is completely separated from the rest of the source
  * manipulator.ex -> must read the commit or ask Aad :), has a single method that applies manipulators from the regen.ex file
  * regen.ex -> has 1 method make_regenerator that will produce an object that can take a parsed object and regenerate a string thingie from it again
  * regen
    * constructor.ex has a single overloaded method that makes(x) x elementOf (:paren_group, :maybe_many, :one_of, ...)
    * protocol.ex has a bunch of types, need to check the elixir docs for this one
    * result.ex has a lot of SPARQL in its method names, not sure what it is about
    * status.ex has 1 (complicated) method; inspect(elements, produced_content, syntax)
    * processors = a directory that holds a bunch of ex files each of which is capable of generating 1 specific type of base thingie (Array, Many, Maybe, Some, Choice, ...)
  * manipulators, these know about SPARQL btw
    * basics.ex, has 2 functions that walk solutions and decide which get 'emitted'
    * recipes.ex, has basic example manipulators
    * sparql_query.ex, has 2 manipulators: add_graph(element, graph) and add_sub_graph(element, graph)
  * ebnf parser
    * tokenizer.ex, contains a fully functional W3C EBNF tokenizer
    * parser.ex, does parsing, most of the actions takes place in the smart_x methods, entry point is  tokenize_and_parse( string )
    * forms.ex, contains a constant that is equal to the W3C EBNF definition for SPARQL
    * generator_protocol.ex, defines 2 protocols, 1 that creates generators and 1 that emits generated results
    * generator_state.ex, defines helper methods (for state?) is_terminal, drop_spaces, split_off_whitespace, cut_whitespace
    * generator_result.ex, defines helper methods for results, length(generator_result) combine_results(resultA, resultB)
    * interpreter.ex, provides methods that take a string and a rule (as 'parsed' from the EBNF definition passed) and returns possible results
    * intepreter_terms (folder that contains helper methods, each of which is a [type].ex and [typle]_interpreter.ex, only nothing.ex, hex_character.ex, word.ex are not paire
      * array.ex
      * array_interpreter.ex
      * bracket.ex
      * choice.ex
      * choice_interpreter.ex
      * hex_character.ex
      * many.ex
      * many_interpreter.ex
      * maybe.ex
      * maybe_interpreter.ex
      * minus.ex
      * minus_interpreter.ex
      * not_bracket.ex
      * nothing.ex
      * some.ex
      * some_interpreter.ex
      * symbol.ex
      * symbol_interpreter.ex
      * word.ex

repository: mu-semtech/mu-authorization

gha_language: Elixir

repo_name: mu-semtech/mu-authorization


text:
# H&O Magento 2 Advanced Template Hints module

Ho_Templatehints extends the default Magento template hints.

- Easily accessible with with mussle memory `?ath=1`.
- Shows hints for **Templates**, **AbstractBlocks** (Blocks), **Containers** and **UI Components**.
- No layout interference: Using css outline instead of borders of other HTML elements, so it doesn't f'up the layout.

![Usage $0](docs/usage.gif)

## Installation

```
composer require ho-nl/magento2-templatehints
php bin/magento module:enable Ho_Templatehints
php bin/magento setup:upgrade
```

### Development installation (git enabled)
Add the following to your composer.json file in Magento's root (repositories might already exists)
```JSON
"repositories": [
    {
        "type": "vcs",
        "url": "git@github.com:ho-nl/magento2-Ho_Templatehints.git"
    }
],
```

```
composer require ho-nl/magento2-templatehints "dev-master"
php bin/magento module:enable Ho_Templatehints
php bin/magento setup:upgrade
```

## Usage
1. Set your Magento 2 installation to developer mode.
2. Add `?ath=1` to your URL to activate.
3. Open up your console in you Chrome/Firefox/Safari/~IE~ devtools.
4. hold <kbd>⇧</kbd> (shift)
5. Hover over the element you wish to inspect
6. Voila! Hints everywhere!

### Hints for hidden elements
You can't show hints for a hidden element, for that purpose there is `hint($0)`:

```JS
//Select an element in the Elements panel in your devtools, it is now available with $0
hint($0)
```

![Console $0](docs/console.gif)

## Inner Workings
The module adds an additional html-attribute to the outer most element of a layout element.

## Credits
Of course heavily inspired by [Aoe_TemplateHints](https://github.com/AOEpeople/Aoe_TemplateHints) and a bit of love from H&O.


text:
---
id: quick-start
title: Quick Start
sidebar_label: Quick Start
hide_title: true
---

# Quick Start

`RTK Query` is an advanced data fetching and caching tool, designed to simplify common cases for loading data in a web application. `RTK Query` itself is built on top of [Redux-Toolkit](https://redux-toolkit.js.org/) and uses [Redux](https://redux.js.org/) internally for its architecture. Although knowledge of Redux and RTK are not required to use this library, you should explore all of the additional global store management capabilities they provide, as well as installing the [devtools](https://github.com/reduxjs/redux-devtools).

`RTK Query` is currently in an alpha state of development, with the goal of eventually including it directly in the Redux Toolkit library.

## Installation

```sh
yarn add @reduxjs/toolkit @rtk-incubator/rtk-query
```

Or with npm:

```sh
npm i @reduxjs/toolkit @rtk-incubator/rtk-query
```

If you're a React user, make sure that you've installed `react-redux`. If you're a TypeScript user, you should also install `@types/react-redux`.

## Setting up your store and API service

### Create an API service

To get started as a very basic example, let's create a very simple service that queries the publicly available [PokeAPI](https://pokeapi.co/).

```ts title="src/services/pokemon.ts"
import { createApi, fetchBaseQuery } from '@rtk-incubator/rtk-query';

export const pokemonApi = createApi({
  reducerPath: 'pokemonApi',
  baseQuery: fetchBaseQuery({ baseUrl: 'https://pokeapi.co/api/v2/' }),
  endpoints: (builder) => ({
    getPokemonByName: builder.query({
      query: (name: string) => `pokemon/${name}`,
    }),
  }),
});

// Export hooks for usage in functional components
export const { hooks } = pokemonApi;
```

With `rtk-query`, you define your entire API definition in one place _in most cases_. This is most likely different from what you see with other libraries such as `swr` or `react-query`, and there are several reasons for that. Our perspective is that it's _much_ easier to keep track of how requests, cache invalidation, and general app configuration behave in one central location in comparison to having X number of custom hooks in different files throughout your application.

### Add the service to your store

```ts title="src/store.ts"
import { configureStore } from '@reduxjs/toolkit';
import { pokemonApi } from './services/pokemon';

export const store = configureStore({
  reducer: {
    [pokemonApi.reducerPath]: pokemonApi.reducer,
  },
  // Adding the api middleware enables caching, invalidation, polling and other features of `rtk-query`.
  middleware: (getDefaultMiddleware) => getDefaultMiddleware().concat(pokemonApi.middleware),
});
```

### Wrap your application with the `Provider`

```ts title="src/index.tsx"
import * as React from 'react';
import { render } from 'react-dom';
import { Provider } from 'react-redux';

import App from './App';
import { store } from './store';

const rootElement = document.getElementById('root');
render(
  <Provider store={store}>
    <App />
  </Provider>,
  rootElement
);
```

### Use the query in a component

Once a service has been defined, you can import the hooks to make a request.

```ts title="src/App.tsx"
import * as React from 'react';
import { hooks } from './services/pokemon';

export default function App() {
  const { data, error } = hooks.getPokemonByName.useQuery('bulbasaur');

  return (
    <div className="App">
      {error ? (
        <>Oh no, there was an error</>
      ) : !data ? (
        <>Loading...</>
      ) : (
        <>
          <h3>{data.species.name}</h3>
          <img src={data.sprites.front_shiny} alt={data.species.name} />
        </>
      )}
    </div>
  );
}
```

When making a request, you're able to track the state in several ways. You can always check `data`, `status`, and `error` to determine the right UI to render. In addition, `useQuery` also provides utility booleans like `isLoading`, `isSuccess`, and `isError` for the latest request.

#### Basic Example

Okay, that's interesting... but what if you wanted to show multiple pokemon at the same time? What happens if multiple components load the same pokemon?

#### Advanced example

`RTK Query` ensures that any component that subscribes to the same query will always use the same data. RTK Query automatically de-dupes requests so you don't have to worry about checking in-flight requests and performance optimizations on your end. Let's evaluate the sandbox below - make sure to check the Network panel in your browser's dev tools. You will see 3 requests, even though there are 4 subscribed components - `bulbasaur` only makes one request, and the loading state is synchronized between the two components. For fun, try changing the value of the dropdown from `Off` to `1s` to see this behavior continue when a query is re-ran.

Those are the basics of getting up and running with `RTK Query`. For more realistic usage, make sure to read through the sections regarding [mutations](../concepts/mutations), [invalidation](../concepts/mutations#advanced-mutations-with-revalidation), [polling](../concepts/polling) and other features.

## Help and Discussion

The **[#redux channel](https://discord.gg/reactiflux)** of the **[Reactiflux Discord community](http://www.reactiflux.com)** is our official resource for all questions related to learning and using Redux. Reactiflux is a great place to hang out, ask questions, and learn - come join us!

You can also ask questions on [Stack Overflow](https://stackoverflow.com) using the **[#redux tag](https://stackoverflow.com/questions/tagged/redux)**.


text:
# pszt-project-2
XGBoost and logistic regression algorithm comparison

## [Final report](doc/Raport.pdf)

## Dataset
Download the [bank marketing dataset](https://archive.ics.uci.edu/ml/datasets/Bank+Marketing) and place all files (not folders) into `data` folder.


text:
---
tags: [typescript]
title: typescript-pick
created: '2019-08-03T09:49:47.574Z'
modified: '2019-08-03T09:55:57.969Z'
---

# typescript-pick

If we have a type sat.Report and we want a partial type of some of Report for form data entry we can use Pick to create it

```
type FormValues = Pick<
  sat.Report,
  | 'executiveSummary'
  | 'assumptions'
  | 'recommendations'
  | 'approach'
  | 'projectDescription'
>;
```

- Ref: https://medium.com/@curtistatewilkinson/typescript-2-1-and-the-power-of-pick-ff433f1e6fb

```
$TsFixMe = any;
```

repository: pjsvis/react-patterns

repo_name: pjsvis/react-patterns


text:
Change Log
==========

This project honours [Semantic Versioning](http://semver.org).

[v1.2.0]
------------------------------------------------------------------------
**July 2nd, 2021**
* __Added:__ Dedicated scope for identifying empty capturing groups
* __Added:__ Grammar for POSIX.2 (IEEE Std 1003.2) “extended” regexes
* __Added:__ Highlighting of quoted/verbatim characters inside `\Q`…`\E`
* __Added:__ Extended regexp highlighting inside `(?x: …)` groups
* __Added:__ Support for codepoint sequences ([Oniguruma 6.9.5+][3])
* __Added:__ Support for trailing whitespace in `\x{… }` and `\o{… }`
* __Fixed:__ Typo in `.source.regexp`'s `editor.commentEnd` setting
* __Fixed:__ Typo in `(?'named')` capturing group pattern

[3]: https://github.com/kkos/oniguruma/releases/tag/v6.9.5

[v1.1.2]
------------------------------------------------------------------------
**May 4th, 2020**
Adds syntax highlighting for patterns in Bash `[[ =~ … ]]` conditionals.
Note that this only works when [Tree Sitter parsers are disabled][2].

[2]: https://github.com/Alhadis/language-regexp/issues/5

[v1.1.1]
------------------------------------------------------------------------
**September 1st, 2019**
Fixes malformed syntax reported by [`Alhadis/language-regexp#1`][1].

[1]: https://github.com/Alhadis/language-regexp/issues/1

[v1.1.0]
------------------------------------------------------------------------
**July 12th, 2019**
Considerable improvements made to syntax highlighting:

* __Added:__ Patterns for matching script runs (Perl 5.28+)
* __Added:__ Patterns for matching Oniguruma's "absent functions"
* __Added:__ Patterns for matching Oniguruma's `y{…}` text-segment mode
* __Added:__ Patterns for matching Oniguruma callouts
* __Added:__ Patterns for matching Oniguruma's `\y`, `\Y`, and `\O`
* __Added:__ Support for toggling comments and auto-indenting groups
* __Fixed:__ Lack of comment highlighting in "extended" regexp grammar
* __Fixed:__ Incorrect highlighting of `(?R)` and `(?0)` constructs
* __Fixed:__ Missing highlighting for `\R` escapes
* __Fixed:__ Missing highlighting of reset sequence in scoped modifiers

[v1.0.1]
------------------------------------------------------------------------
**March 1st, 2017**
Unexciting patch-release to address trivial highlighting bugs:

* __Fixed:__ "Match-anything" dots not highlighted as metacharacters
* __Fixed:__ Runaway-matching in bracketed classes that end with a dash

[v1.0.0]
------------------------------------------------------------------------
**January 30th, 2017**
Initial release. Adds syntax highlighting for regular expression data.

[Referenced links]:_____________________________________________________
[Staged]: ../../compare/v1.2.0...HEAD
[v1.2.0]: https://github.com/Alhadis/language-regexp/releases/tag/v1.2.0
[v1.1.2]: https://github.com/Alhadis/language-regexp/releases/tag/v1.1.2
[v1.1.1]: https://github.com/Alhadis/language-regexp/releases/tag/v1.1.1
[v1.1.0]: https://github.com/Alhadis/language-regexp/releases/tag/v1.1.0
[v1.0.1]: https://github.com/Alhadis/language-regexp/releases/tag/v1.0.1
[v1.0.0]: https://github.com/Alhadis/language-regexp/releases/tag/v1.0.0

license: ISC

repository: Alhadis/language-regexp

gha_language: CSON

gha_license_id: ISC

repo_name: Alhadis/language-regexp


text:
# Entity: delay_line
- **File:** delay_line.vhd
- **Author:** Imants Pulkstenis
- **Version:** B
- **Date:** 17.03.2020
- **Copyright:** Copyright (c) 2021 Imants Pulkstenis
## Diagram
![Diagram](delay_line.svg "Diagram")
## Description
Project name: Delay line
 Module name: Delay line module
Delay line module for Xilinx 7 series. Its length can be configurable from the top module.
 The Delay line consists of MUXes(CARRY4 primitives) and D flip Flops at the output.
 -------------------------------------------------------------
 ***CARRY4*** (description from *Xilinx 7 Series FPGA Libraries Guide for HDL Designs*)
 Primitive: Fast Carry Logic with Look Ahead
     **Introduction**
 This circuit design represents the fast carry logic for a slice. The carry chain consists of a series of four MUXes
 and four XORs that connect to the other logic (LUTs) in the slice via dedicated routes to form more complex
 functions. The fast carry logic is useful for building arithmetic functions like adders, counters, subtractors and
 add/subs, as well as such other logic functions as wide comparators, address decoders, and some logic gates
 (specifically, AND and OR).
    **Port Descriptions**
 ```
      |  Port  | Direction | Width |                  Function                  |
      | ------ | --------- | ----- | ------------------------------------------ |
      | O      | Output    | 4     | Carry chain XOR general data out           |
      | CO     | Output    | 4     | Carry-out of each stage of the carry chain |
      | DI     | Input     | 4     | Carry-MUX data input                       |
      | S      | Input     | 4     | Carry-MUX select line                      |
      | CYINIT | Input     | 1     | Carry-in initialization input              |
      | CI     | Input     | 1     | Carry cascade input                        |
 ```
 -------------------------------------------------------------
 **Revision:**
 A - initial design
 B - Long delay line test without D-Flip-Flops
 C -
 -----------------------------
## Generics and ports
### Table 1.1 Generics
| Generic name       | Type    | Value        | Description                                                                                |
| ------------------ | ------- | ------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| g_DL_ELEMENT_COUNT | INTEGER | 16           |  Count of delay elements in the module. Four delay elements are in one CARRY4 primitive. The minimal number of CARRY4 blocks are 2, e.i. minimal delay element count are 2*4=8.   |
| g_LOCATION         | STRING  | "SLICE_X1Y1" |  Location of the first CARRY4 block                                                                                |
### Table 1.2 Ports
| Port name | Direction | Type      | Description           |
| --------- | --------- | --------- | --------------------- |
| TriggerIn | in        | STD_LOGIC |  Input of delay line  |
| LoopOut   | out       | STD_LOGIC |  Output of delay line |
## Signals, constants and types
### Signals
| Name | Type                                              | Description                                                 |
| ---- | ------------------------------------------------- | ----------------------------------------------------------- |
| CO   | STD_LOGIC_VECTOR(g_DL_ELEMENT_COUNT - 1 DOWNTO 0) |  CO vector from Carry-out of each stage of the carry chain  |
## Instantiations
- **CARRY4_first**: CARRY4

- **CARRY4_last**: CARRY4
 CARRY4: Fast Carry Logic Component

gha_language: VHDL


text:
---
title: Tooltip
order: 1
group:
  path: /interaction
  title: Interaction Component
nav:
  title: Components
  path: /components
  order: 1
---

# Tooltip

Tooltip is an interactive component for quickly accessing nodes or edges information. By hovering over a node or edge, a display box appears with detailed information about an element. The tooltip disappears on mouse leave.

## Built-in Components

`<Tooltip/>` is a tooltip container, providing information such as position, trigger element, callback function, etc., which can be obtained by the user through `context`. How to render is completely handed over to the user, and the official `<Tooltip.Node />` component is also provided for quick use. The user can customize the content of the display.

<API src='./index.tsx'>

## Custom Component: Popover component integrated with Antd

## ⚠: Popover component integrated with Antd, unable to listen to ContextMenu event

Integrating the Popover component of Antd requires a triggered DOM, and the triggered DOM happens to cover the node. Therefore, our components `<ContextMenu />`, `<DragNode />`, etc. cannot trigger node events, which will lead to failure. The official built-in is recommended `<Tooltip placement='top' hasArrow/>` to use

## Features

- Tooltip is a container component that provides a callback function with coordinate positioning to internal components, with possibly two variants depending on whether a Node or Edge is hovered over.
- Display contents are completely user-defined

## Reference

> We welcome the Github community to discuss the component design and implementation, and build an open-source solution together.

repository: antvis/Graphin

gha_language: TypeScript

repo_name: antvis/Graphin


text:
---
layout: post
title: "OsLAC"
description: ""
category: genes
tags: [grain yield, grain, brassinosteroid, yield]
---

* **Information**
    + Symbol: OsLAC
    + MSU: [LOC_Os05g38420](http://rice.uga.edu/cgi-bin/ORF_infopage.cgi?orf=LOC_Os05g38420)
    + RAPdb: [Os05g0458600](https://rapdb.dna.affrc.go.jp/locus/?name=Os05g0458600)

* **Publication**
    + [Overexpression of microRNA OsmiR397 improves rice yield by increasing grain size and promoting panicle branching](http://www.ncbi.nlm.nih.gov/pubmed?term=Overexpression of microRNA OsmiR397 improves rice yield by increasing grain size and promoting panicle branching%5BTitle%5D), 2013, Nat Biotechnol.
    + [MiR529a controls plant height, tiller number, panicle architecture and grain size by regulating SPL target genes in rice Oryza sativa L.](http://www.ncbi.nlm.nih.gov/pubmed?term=MiR529a controls plant height, tiller number, panicle architecture and grain size by regulating SPL target genes in rice Oryza sativa L.%5BTitle%5D), 2021, Plant Sci.

* **Genbank accession number**

* **Key message**
    + We determined that OsmiR397 increases grain yield by downregulating its target, OsLAC, whose product is a laccase-like protein that we found to be involved in the sensitivity of plants to brassinosteroids

* **Connection**
    + __OsLAC__, __OsLAC10__, [Comprehensive Analysis of Rice Laccase Gene OsLAC Family and Ectopic Expression of OsLAC10 Enhances Tolerance to Copper Stress in Arabidopsis.](http://www.ncbi.nlm.nih.gov/pubmed?term=Comprehensive Analysis of Rice Laccase Gene OsLAC Family and Ectopic Expression of OsLAC10 Enhances Tolerance to Copper Stress in Arabidopsis.%5BTitle%5D), Comprehensive Analysis of Rice Laccase Gene (OsLAC) Family and Ectopic Expression of OsLAC10 Enhances Tolerance to Copper Stress in Arabidopsis.

[//]: # * **Key figures**


text:
# xTextHandler
Xcode Source Editor Extension Toolset

# What is it
[Xcode Source Editor Extension](https://developer.apple.com/videos/play/wwdc2016/414/) based tools, improve text editing for Xcode

# Features

## xEncode
- Base64 Encode
- Base64 Decode
- URL Encode
- URL Decode
- MD5
- Upper Case
- Lower Case
- Escape

## xRadix
- Hex
- Bin
- Oct
- Dec

## xColor
- Hex
- RGB
- Preview

## xSearch
- Google
- Translate
- Developer
- StackOverflow
- GitHub

## xFormat
- JSON

# Usage
1. Install Xcode 8
2. Build & Run
3. Choose Xcode to debug

# Tips
Xcode 8 Beta is completely unstable now, you may see nothing after you build this project

repository: PrinceMei/xTextHandler

repo_name: PrinceMei/xTextHandler


text:
# boot2docker-build-script
An AppleScript to build and run your image.

## Usage
1. Create a directory by a name of image you want to build.
2. Put your Dockerfile and this script into it.
3. Run boot2docker-build-script.applescript.
```
[ImageName]
|-- Dockerfile
|-- boot2docker-build-script.applescript
```

## Mechanism
1. Running commands for boot2docker.
```
$ boot2docker init (if needed)
$ boot2docker up (if needed)
$ boot2docker ssh
```
2. Changing the working directory to the location of this script on host.(Using folder sharing provided by boot2docker)
3. Building an image with directory name as image name.
4. To check the built image, running /bin/bash with -it option.(interactive, Pseudo-tty)

gha_language: AppleScript


text:
# #33: [HIGH] Checkboxes don't seem to be working --- same data shows, but color changes

* Source: https://github.com/CivicActions/nebula/issues/33
* Created by: RobertLRead
* Created at: 2015-06-26T04:52:32Z
* Updated at: 2015-06-29T16:44:41Z
* Closed at: 2015-06-29T16:44:41Z

## Comment

* Source: https://github.com/CivicActions/nebula/issues/33
* Commented by: RobertLRead
* Created at: 2015-06-26T04:52:32Z
* Updated at: 2015-06-29T16:44:41Z

To reproduce, just pick two drugs and play with the checkboxes.

## Comment

* Source: https://github.com/CivicActions/nebula/issues/33#issuecomment-116756171
* Commented by: RobertLRead
* Created at: 2015-06-29T16:44:41Z
* Updated at: 2015-06-29T16:44:41Z

Not working in Firefox

repository: stevecurtis/nebula

detected_licenses: MIT Unlicense BSD-3-Clause

repo_name: stevecurtis/nebula


text:
# Figsvelte
A boilerplate for creating Figma plugins using Svelte.

This starter project has everything you need to start developing a Figma plugin usign Svelte. Your JS, CSS, SVG and image assets can be bundled on build. The package will take care of compiling your typescript + app on save during development, and also minify on build.

Additionally, this package comes preconfigured with [Figma Plugin DS Svelte](https://github.com/thomas-lowry/figma-plugin-ds-svelte) where you have access to a large range of components and icons that match the Figma UI, to get you up and running quickly. Note: installing this boilerplate will install the component library as a dependency.

Only what you import/use will be included in the final build for small bundle size.

## To get started
```bash
npx degit thomas-lowry/figsvelte figma-plugin
cd figma-plugin
npm install
```
_Note that you will need to have [Node.js](https://nodejs.org/) installed._

## Development
During development, watch your project for changes with the following command.

```bash
npm run dev
```
Start building your plugin UI in `'src/Plugin.svelte'`.

## Build
When ready to package up your final Figma Plugin:
```bash
npm run build
```

## Useful info
To include an external CSS file:
```javascript
import styles from './styles.css';
```

To include an SVG:
```javascript
import SvgName from './image.svg';

//use in your markup
{@html SvgName}
```
_For more info on using the Icon component system with SVGs from [Figma Plugin DS Svelte](https://github.com/thomas-lowry/figma-plugin-ds-svelte), refer to the repo._


text:
# Example Datasets

- HRDataset_v13.csv (from [Kaggle](https://www.kaggle.com/rhuebner/human-resources-data-set))
- fruits.json
- Twitter Sentiment ([link](http://help.sentiment140.com/for-students/)) (columns: `polarity id date query user text`)

repository: stephenhky/ml-experiment

repo_name: stephenhky/ml-experiment


text:
## With Docker

```bash
./docker_build.sh
```

This will give you an image tagged with `logproj`

### Docker Compose

`docker-compose up` will give you a working system, once you've built the
prerequisites.

You'll have to fill in the database schema, which brings us to...

repository: qpfiffer/logproj

repo_name: qpfiffer/logproj


text:
# SwaggerClient::AdminProfile

## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**user_id** | **Integer** | ID of the user | [optional]
**create_project** | **BOOLEAN** | Has permission on create Project | [optional] [default to false]
**edit_project** | **BOOLEAN** | Has permission on edit Project | [optional] [default to false]
**archive_project** | **BOOLEAN** | Has permission on archive Project | [optional] [default to false]
**list_project** | **BOOLEAN** | Has permission on view Project | [optional] [default to false]
**manage_client_user** | **BOOLEAN** | Has permission on Invite/Edit Users | [optional] [default to false]
**edit_user_profile** | **BOOLEAN** | Has permission on edit Profiles | [optional] [default to false]
**view_user_profile** | **BOOLEAN** | Has permission on view Profiles | [optional] [default to false]
**manage_client_info** | **BOOLEAN** | Has permission on update Company's information | [optional] [default to false]
**manage_system_conf** | **BOOLEAN** | Has permission on manage System configuration | [optional] [default to false]
**site_level_field** | **BOOLEAN** | Has permission on manage site level field setting | [optional] [default to false]

gha_language: Ruby

gha_license_id: NOASSERTION


text:
# HLR Lookup App

PHP HLR Look up App using [Hlr-lookups](https://www.hlr-lookups.com/) API.

##Requirements

1. PHP 5.6
2. cUrl
3. Composer

## Installation
 Use our Ubuntu Vagrantbox with Ansible : [HLR Boot](https://bitbucket.org/wrcx/hlr-boot) or simply clone the repo.

### License

This app is open-sourced software licensed under the [MIT license](http://opensource.org/licenses/MIT)

repository: nejcio/hlr-lookup

repo_name: nejcio/hlr-lookup


text:
emorylib_clean_subdirectories
=========

Search for and delete subdirectories older than a specified number of days. This role will only delete directories, not files. Will build a report, including when no directories are deleted, and output it to console and optionally Slack.

Requirements
------------

Must have a valid Slack token if using optional Slack feature.

Role Variables
--------------

```yaml
### Main variables
subdirectories_paths: # Required, list, --File paths to check for older subdirectories
subdirectories_age: # Required, integer --Find any subdirectories that have not been modified in these many days

### Optional Slack variables
clean_subdir_slack_token:
clean_subdir_slack_msg:
clean_subdir_slack_channel:
clean_subdir_slack_color:
clean_subdir_slack_thread_id:
clean_subdir_slack_username:
clean_subdir_slack_icon_url:
clean_subdir_slack_icon_emoji:
clean_subdir_slack_link_names:
clean_subdir_slack_parse:
```

Example Playbook
----------------

```yaml

  - hosts: server
    vars:
      subdirectories_paths:
        - /path/to/first/dir
        - /path/to/second/dir
      subdirectories_age: 3
    tasks:
      - include_role: emorylib_clean_subdirectories
```

License
-------

BSD

Author Information
------------------

An optional section for the role authors to include contact information, or a website (HTML is not allowed).

repository: emory-libraries/cor-cm

gha_language: Jinja

repo_name: emory-libraries/cor-cm


text:
bsdiff
=======

A fork of Colin Percival's binary diff utilities, cleaned up and modernized for use during HackDuke 2014.

## Dependencies:
Like the original `bsdiff`, this fork relies on bzip2 to compress its diffs.

## Changes:
* Replaced unportable `u_char` declarations with `uint8_t` types.
* Simplified the makefile.
* Fixed formatting.
* Replaced BSD-style `err` functions with `fprintf()`/`exit()` combinations.

repository: woodruffw-hackathons/bsdiff

repo_name: woodruffw-hackathons/bsdiff


text:
# Jill Klatt Portfolio

#### After struggling to find a template that worked for me, I finally decided to venture out and attempt to create my own!

### Read more about this project

[Dev](https://dev.to/jillklatt/making-a-portfolio-website-from-scratch-5576)

### Color Palette

![#EFF2F9 Alice Blue](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/l5h9x0jgcuztcqvupywb.png)
![#89ABBD Pewter Blue](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/sjubozut4y8lwsiozgy0.png)
![#B07156 Brown Sugar](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/kfi0kkeupapbbs1qw6nh.png)
![#475B63 Deep Space Sparkle](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/0puaahdmllpcdn5s6okq.png)
![#2E2C2F Raisin Black](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4gdhh7dggwunyo90kyxi.png)

### LICENSE

[MIT](https://github.com/JillKlatt/jillklatt.github.io/blob/master/LICENSE.md)

### Contributors Guide

##### If you would like to contribute or fork this repo to repurpose for yourself, feel free! However, please give credit where it is due.

##### If you create something you like from my template, please send me a link! I'd love to see it!

### Special Thanks

#### Inspiration from [Brittany Chiang](https://github.com/bchiang7/v4)

#### Styling wizard [Raquel Román-Rodriguez](https://github.com/raquii)

![Wizard Gif](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/vhz5c1vi8jxnyc3lspf3.gif)


text:
---
layout: post
title: Making Icons for a Capacitor/iOS Application
date: '2019-06-29T15:15:00.002-04:00'
author: Michael D. Callaghan
tags:
- ionic
- capacitor
- ios
layout: post
feature: assets/img/bravo-icons.png
thumbnail: https://walkingriver.com/assets/img/bravo-icons.png
cover_image: https://walkingriver.com/assets/img/bravo-icons.png
canonical_url: https://walkingriver.com/make-icons/
exclude_from_posts: true
published: true
---

I recently upgraded one of my mobile games to Ionic 4 and Capacitor. One of the shortcomings I discovered was the lack of a simple tool to create the icons and splash screens. I imagine the Ionic team will eventually recitify this situation, but in the meantime I wanted to find an alternative. Given that I can be a cheap guy at times, I figured it would be best to build my own solution.

<!--more-->

> You can read about my [Ionic 3 - 4 and Capacitor experience here](https://walkingriver.com/ionic-3-to-4/){:target="_blank"}.

I started with a PNG file of 1280x1280 pixels. I knew the Mac had some built-in command line tools that would do the heavy lifting for me, and Xcode provided me the file names and sizes I needed to generate. Armed with that informtation, the rest was easy.

Here is my admittedly-simple shell script.

```
##################################################################
# Make a bunch of iOS App icons from a Master
# Given an image at least 512x512 pixels named icon.png, resize and create a
# duplicate at each specified size. Add new sizes as needed. When finished,
# copy the resulting images into your Xcode iOS project.

mkdir ./AppIcon.appiconset/
sips -z 20 20 --out<EMAIL_ADDRESS>icon.png
sips -z 40 40 --out<EMAIL_ADDRESS>icon.png
sips -z 40 40 --out<EMAIL_ADDRESS>icon.png
sips -z 60 60 --out<EMAIL_ADDRESS>icon.png
sips -z 29 29 --out<EMAIL_ADDRESS>icon.png
sips -z 58 58 --out<EMAIL_ADDRESS>icon.png
sips -z 58 58 --out<EMAIL_ADDRESS>icon.png
sips -z 87 87 --out<EMAIL_ADDRESS>icon.png
sips -z 40 40 --out<EMAIL_ADDRESS>icon.png
sips -z 80 80 --out<EMAIL_ADDRESS>icon.png
sips -z 80 80 --out<EMAIL_ADDRESS>icon.png
sips -z 120 120 --out<EMAIL_ADDRESS>icon.png
sips -z 1024 1024 --out<EMAIL_ADDRESS>icon.png
sips -z 120 120 --out<EMAIL_ADDRESS>icon.png
sips -z 180 180 --out<EMAIL_ADDRESS>icon.png
sips -z 76 76 --out<EMAIL_ADDRESS>icon.png
sips -z 152 152 --out<EMAIL_ADDRESS>icon.png
sips -z 167 167 --out<EMAIL_ADDRESS>icon.png

```

As I said, pretty straightforward. With a little more time, I could probably come up with something more elegant, but this brute-force solution works well enough. It assumes you have a PNG file named icon.png, and it should be at least 512x512.