text:
**STRUCT**

# `SiteCollectionDirectoryBuilder`

```swift
public struct SiteCollectionDirectoryBuilder: SiteDirectoryBuilder
```

## Methods
### `init()`

```swift
public init()
```

### `directory(fromCollection:)`

```swift
public func directory(fromCollection blogs: SiteCollection) -> SiteCollectionDirectory
```

license: MIT

repository: TrendingTechnology/SyndiKit

branch_name: refs/heads/main

repo_name: TrendingTechnology/SyndiKit


text:
# mod_evasive-cookbook

Installs and configures mod_evasive for Apache.

## Supported Platforms

* CentOS/RHEL/Fedora

## Attributes
Descriptions and defaults taken from the config that ships with the EPEL
RPM.

    Key
    Type
    Description
    Default

    <tt>['apache2']['mod_evasive']['dos_hash_table_size']</tt>
    Integer
    The hash table size defines the number of top-level nodes for each
    child's hash table.  Increasing this number will provide faster
    performance by decreasing the number of iterations required to get to the
    record, but consume more memory for table space.  You should increase
    this if you have a busy web server.  The value you specify will
    automatically be tiered up to the next prime number in the primes list
    (see mod_evasive.c for a list of primes used).
    <tt>3097</tt>

    <tt>['apache2']['mod_evasive']['dos_page_count']</tt>
    Integer
    This is the threshhold for the number of requests for the same page (or
    URI) per page interval.  Once the threshhold for that interval has been
    exceeded, the IP address of the client will be added to the blocking
    list.
    <tt>2</tt>

    <tt>['apache2']['mod_evasive']['dos_site_count']</tt>
    Integer
    This is the threshhold for the total number of requests for any object by
    the same client on the same listener per site interval.  Once the
    threshhold for that interval has been exceeded, the IP address of the
    client will be added to the blocking list.
    <tt>50</tt>

    <tt>['apache2']['mod_evasive']['dos_page_interval']</tt>
    Integer
    The interval for the page count threshhold; defaults to 1 second
    intervals.
    <tt>1</tt>

    <tt>['apache2']['mod_evasive']['dos_site_interval']</tt>
    Integer
    The interval for the site count threshhold; defaults to 1 second
    intervals.
    <tt>1</tt>

    <tt>['apache2']['mod_evasive']['dos_blocking_period']</tt>
    Integer
    The blocking period is the amount of time (in seconds) that a client will
    be blocked for if they are added to the blocking list.  During this time,
    all subsequent requests from the client will result in a 403 (Forbidden)
    and the timer being reset (e.g. another 10 seconds).  Since the timer is
    reset for every subsequent request, it is not necessary to have a long
    blocking period; in the event of a DoS attack, this timer will keep
    getting reset.
    <tt>10</tt>

    <tt>['apache2']['mod_evasive']['dos_notify_email']</tt>
    String or nil
    If this value is set, an email will be sent to the address specified
    whenever an IP address becomes blacklisted.  A locking mechanism using
    /tmp prevents continuous emails from being sent.

    NOTE: Requires /bin/mail (provided by mailx)
    <tt>nil</tt>

    <tt>['apache2']['mod_evasive']['dos_system_command']</tt>
    String or nil
    If this value is set, the system command specified will be executed
    whenever an IP address becomes blacklisted.  This is designed to enable
    system calls to ip filter or other tools.  A locking mechanism using /tmp
    prevents continuous system calls.  Use %s to denote the IP address of the
    blacklisted IP.
    <tt>nil</tt>

    <tt>['apache2']['mod_evasive']['dos_log_dir']</tt>
    String or nil
    Choose an alternative temp directory By default "/tmp" will be used for
    locking mechanism, which opens some security issues if your system is
    open to shell users.

      http://security.lss.hr/index.php?page=details&ID=LSS-2005-01-01

    In the event you have nonprivileged shell users, you'll want to create a
    directory writable only to the user Apache is running as (usually root),
    then set this in your httpd.conf.
    <tt>nil</tt>

    <tt>['apache2']['mod_evasive']['dos_white_list']</tt>
    Array
    You can use whitelists to disable the module for certain ranges of
    IPs. Wildcards can be used on up to the last 3 octets if necessary.
    Multiple DOSWhitelist commands may be used in the configuration; just
    add to the array.
    <tt>[ "<IP_ADDRESS>" ]</tt>

## Usage

### mod_evasive::default

Include `mod_evasive` in your node's `run_list`:

```json
{
  "run_list": [
    "recipe[mod_evasive::default]"
  ]
}
```

## License and Authors

Author:: AzTek Native Ltd<EMAIL_ADDRESS>
Copyright 2015, AzTek Native Ltd.

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

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

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

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# Testing CoreRT

The CoreRT test harness can run in two modes - with the tests local to the CoreRT repo, with tests from the [CoreCLR](https://github.com/dotnet/coreclr) repo or the tests from the [CoreFX](https://github.com/dotnet/corefx) repo. The local tests only provide basic sanity testing and it's recommended to run the CoreCLR and CoreFX tests which are much more thorough.

The tests exercise both the runtime and the ILC compiler, which compiles IL into native code. The harness can test both the RyuJIT code generation backend, or the C++ backend of the ILC compiler.

## Local Tests

Make sure you have the [prerequisites](prerequisites-for-building.md) to build the repo, and run `build.cmd debug clean` at repo root level. This will build the CoreRT repo, compile the local test sources, and use the newly built ILC compiler to compile the tests to native code and run them. These tests also run as part of the CI.

### How To Run

On Windows:
```
cd {corert}
build.cmd
tests\runtest.cmd
```

On Linux / macOS:
```
cd {corert}
./build.sh
tests\runtest.sh
```

If you want to run just single test
```
tests\runtest.cmd /test Pinvoke
```

If you want to run tests only for specific codegen
```
tests\runtest.cmd /test Pinvoke /mode Jit
```

### Verifying tests pass
You should see the below message when you build CoreRT or run the local tests manually, otherwise something is broken.

```
JIT - TOTAL: 12 PASSED: 12
CPP - TOTAL: 2 PASSED: 2
WASM - TOTAL: 1 PASSED: 1
```

## External Tests - CoreCLR

When runtest.cmd is passed the /coreclr switch, the harness will download the CoreCLR project's test suite, compile them to native with the CoreRT compiler, and run them.

### How To Run

Choose the set of tests you want to run. Currently the options are:

* Top200
  * Small set of the suite selected to provide broad coverage quickly (Under 10 minutes). These run as part of the CI when submitting a pull request.
* KnownGood
  * Subset of the suite previously validated to all pass on CoreRT. If these all pass you can be pretty sure you haven't regressed the compiler. We currently only have a KnownGood list on Windows.
* All
  * The entire suite. Many of the tests will fail since CoreRT is still pre-release and some tests don't play well with an ahead-of-time compiler.

On Windows:

```
tests\runtest.cmd /coreclr Top200|All|KnownGood
```

On Linux / macOS:

```
tests/runtest.sh -coreclr Top200|All|KnownGood
```

### Suppress Windows Error Reporting Dialogs

It's advisable to use some sort of a dialog killer tool if you see test regressions as many tests fail with pop-ups for Windows Error Reporting. However, the following regedit scripts have also proven to be useful to mask these pop-ups.

Disable WER *temporarily*:

**Contents of disable-wer.reg**

```
REGEDIT4

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\Windows Error Reporting]
"DontShowUI"="1"
"Disabled"="1"
```

Remember to enable:

**Contents of enable-wer.reg**

```
REGEDIT4

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\Windows Error Reporting]
"DontShowUI"="0"
"Disabled"=-
```

### Filtering Tests

If you know a test is failing for a good reason or you want a clean baseline, please use ```corert\tests\KnownGood.CoreCLR.issues.targets``` to weed out bad tests or infrastructure errors until we fix them.

### Test Logs

When the tests finish execution, the log location will be written out and should be in bin\Logs:

**Example:** ```corert\bin\Logs\TestRun_Windows_NT__x64__debug.html```

## External tests - CoreFX

Similarly to the CoreCLR tests, when runtest.cmd is passed the /corefx switch, the harness will download the CoreFX project's test suite, compile them to native with the CoreRT compiler, and run them.

### How to run

To run CoreFX tests on CoreRT, make sure that `build.cmd` has been run at least once in the configuration you'd like to test (i.e. `Debug` or `Release`), open a new console window and from the repo root execute the following:

On Windows:

```
tests\runtest.cmd /corefx
```

On Linux / macOS:

```
tests/runtest.sh -corefx
```

The tests assemblies to run are defined in `TopN.CoreFX.[Windows/Unix].issues.json` with their respectively excluded test methods, classes or namespaces.

### Reproducing test failures

If you need to reproduce a failing test, navigate to ```test_downloaded\CoreFX``` and then to the folder of the failing test - each test suite is located in its own folder. From the test suite directory run the following:

On Windows:

```
.\native\xunit.console.netcore.exe .\<name of the main test assembly>  @"./<name of the main test assembly>.rsp" -notrait category=nonnetcoreapptests -notrait category=nonwindowstests  -notrait category=failing
```

On Linux / macOS:

```
./native/xunit.console.netcore.exe ./<name of the main test assembly>  @"./<name of the main test assembly>.rsp" -notrait category=nonnetcoreapptests -notrait category=failing
```

Additionally for Linux, add `-notrait category=nonlinuxtests` and for macOS `-notrait category=nonosxtests`.

**e.g.** for System.Collections.Tests on Windows:

Navigate to C:\repos\corert\test_downloaded\CoreFX\System.Collections.Tests.
Open Command Promps and run:

```
.\native\xunit.console.netcore.exe .\System.Collections.Tests.dll<EMAIL_ADDRESS>-notrait category=nonnetcoreapptests -notrait category=nonwindowstests  -notrait category=failing
```

### Enabling tests

To enable a new CoreFX test project to run against CoreRT add its fully qualified name to `TopN.CoreFX.[Windows/Unix].issues.json`.
To remove a test from a test project which is already enabled, in the same file find and delete the definition containing its name.

### Disabling tests

Tests can be excluded from a run in the following ways:

* To exclude a specific test method, add its fully-qualified name in the `method` array of the `exclusions` attribute of relevant test project or pass it as a value to the `-skipmethod` flag when calling `xunit.console.netcore.exe`.

* To exclude all tests in a class, add  its fully-qualified name in the `class` array of the `exclusions` attribute of relevant test project or pass it as a value to the `-skipclass` flag when calling `xunit.console.netcore.exe`.

* To exclude all tests in a class, add  its fully-qualified name in the `namespace` array of the `exclusions` attribute of relevant test project or pass it as a value to the `-skipnamespace` flag when calling `xunit.console.netcore.exe`.

repository: MichalStrehovsky/corert

gha_language: C#

gha_license_id: NOASSERTION

repo_name: MichalStrehovsky/corert


text:
# Stocks

The Website is Live on [stockanalysis4you](https://stockanalysis4you.herokuapp.com/) .

Here's a list of the packages we will use to accomplish this:

-   Django
-   HTML5
-   CSS3
-   Gunicorn
- whitenoise
-   and more .

## Code

### Install Virtualenv
```
pip install virtualenv
cd /path/to/folder
mkdir stocks
cd stocks
python -m venv .
```
### Activate the Virtualenv
```
source scripts/activate
```
### Install Dependencies
```
cd /path/to/folder/stocks
mkdir src
cd src
git clone https://github.com/Arvind-4/Stocks.git .
pip install -r requirements.txt
```

### Run the Code
```
cd /path/to/folder/health_website/src
./run.sh
```

### Create Super User
```
cd /path/to/folder/health_website/src
./superuser.sh
```


text:
# Common debugging on linux

* `w` users logged, days since reboot, load avg
* `df -h` free space
* `df -hi` free nodes
* `netstat -tuple` listening as server, with process id
* `last` last logged users
* `free -m` free memory
* `glances --white-theme` alternative to top/htop

repository: andrea-sdl/today-i-learned

repo_name: andrea-sdl/today-i-learned


text:
# Quantum Circuits using pyQuil

## Installation

Python 3.6+ is recommended.

* Install pyQuil using pip:

    ```bash
    pip install pyquil
    ```

* Downloading the QVM and Compiler:

    The Forest 2.0 Downloadable SDK Preview currently contains:

    * The Rigetti Quantum Virtual Machine (qvm) which allows high-performance simulation of Quil programs

    * The Rigetti Quil Compiler (quilc) which allows compilation and optimization of Quil programs to native gate sets

    Download the Forest SDK from <https://qcs.rigetti.com/sdk-downloads>, where you can find links for Windows, macOS, Linux (.deb), Linux (.rpm), and Linux (bare-bones).

    For further instructions on this step go to <http://docs.rigetti.com/en/stable/start.html#downloading-the-qvm-and-compiler>

* Run the QVM and Compile in server mode:

    ```bash
    ### CONSOLE 1
    $ qvm -S

    Welcome to the Rigetti QVM
    (Configured with 10240 MiB of workspace and 8 workers.)
    [2018-09-20 15:39:50] Starting server on port 5000.

    ### CONSOLE 2
    $ quilc -S

    ... - Launching quilc.
    ... - Spawning server at (tcp://*:5555) .
    ```

## Execute

* Change to the relevant directory:

    ```bash
    $ cd shors_algorithm/shor
    ```

* Run the file:

    ```bash
    $ python shor.py 25
    Factoring 25
    y: 13
    c: 307; r: 10
    factor: 18
    f1: 1; f2: 1
    trivial factor, continuing
    y: 7
    c: 0; r: 1
    r odd; continuing
    ...
    ...
    ...
    y: 19
    c: 607; r: 22
    factor: 19
    f1: 1; f2: 5
    Factorization: (5, 5)
    ```

gha_language: Jupyter Notebook

gha_license_id: MIT


text:
CBot
====

Known as VBot before The Great Rewrite, this is my pet IRC bot framework. It runs on the .NET framework. This is the framework that my helper bot, Angelina, runs on.
It is *by no means* complete.

Built in is:

* support for multiple IRC networks
* support for SSL
* a permission system (inspired by PermissionsEx)
* support for assigning permissions by a password (inspired by Battle Arena), hostmask or channel status flag
* automatic NickServ identification
* an interactive setup wizard

Support for user identification has been demoted to a plugin (Identify).

Of course, it can load different plugins to do much more.

Changelogs can be found in the individual project folders.

Confguration files
------------------

There are three:

* `/config.json` for IRC server data
* `/users.json` for user accounts
* `/plugins.json` for plugins

Plus those used by the plugins themselves, of course.
**To load a plugin** after the setup procedure, add the following to the dictionary in **plugins.json**:

```JSON
	"Key": {
		"Filename": "Plugins/plugin.dll",
		"Channels": [ "irc.example.net/#lobby", "#bots" ]
	}
```

The `Key` is what you type in commands to refer to the plugin instance. Note that you can have multiple instances of the same plugin.
The channels are a list of channels for which this plugin receives events, and is also the list of channels that SayToAllChannels() methods use (excluding wildcards). It can include wildcards like `*/#bots`, `*`, `irc.home.net/*`
The network can be an address (which must match that in the main configuration file), a network name, or omitted to refer to the named channel on any network.

Note that, with Plugin Manager loaded, you can run the following command to load a plugin:
`!loadplugin <key> [filename]`
To set its channels: `!pluginchans <key> <channels>`, where `<channels>` is in the same format as in the INI file.

Important commands from plugins
-------------------------------

* `!id [name] <password>` — identifies you to the bot.
* `!loadplugin <key> [filename]` — loads a plugin.
* `!pluginchans <key> [major|minor] <channels>` — sets a plugin's channel list.

* `!saveplugins` — saves plugins.json and causes all plugins to save data.
* `!saveplugin <plugin key>` — calls `OnSave` on that plugin.

* `!raw <server address> <command>` — sends a raw IRC command.
* `!ircjoin [server address] <channel>` — causes the bot to join a channel.
* `!ircpart [server address] <channel> [message]` — causes the bot to flee a channel.
* `!ircquit <server address> [message]` — causes the bot to quit a server.

IRC channel
-----------

\#andrio on irc.esper.net

Use an IRC client (ircs://irc.esper.net/#andrio) or [webchat](http://webchat.esper.net/?channels=andrio)

repository: AndrioCelos/CBot

repo_name: AndrioCelos/CBot


text:
### managers (handler)
- Applies Business Rules
- Uses Handlers
- Works with Value Objects
- Can use Data Services
- Can work with another Manager

### handlers (parser, utility)
- Handling stuff
- A delegate object
- One way street: from your object to the Handler
- Specializations

### populators

### parsers
- Types of parsing

### validators

### utilities
- Not bound to a specific scope
- Static methods

### controllers
### services
### models
### view

persistence
- dao
 * db

http://patterns.instantinterfaces.nl/current/Refactoring-and-Design-Patterns-MHOPUDO.html#MHOPUDO-DIA-001-MAN

repository: MarcWang/awesome-tools

path: /utilities/design parttern.md

filename: design parttern.md

repo_name: MarcWang/awesome-tools


text:
# Overview

This library is under construction and add many concepts to help maintain and improve the code readability as Collection, Storage, Tasks, ... You can clone my code, i don't care. This is just to make an experience the IA structure and whether it is appropriate to use OOP with the prototype structure instead of OOP with only functions with a procedural structure.

At present development of screeps, I feel that all code is eval() at each tick, and instances are not stored in memory between each tick. The only advantage of using prototypes is that structure your code and improves this readability.

## Collection

This is an object that embed many methods to help manipulating entities.

## Task

A Task is a code that will be run on every n tick.

```javascript
var Task = require('Task');

function MyTask() {
  MyTask.__super__.constructor.call(this, 'set a unique id here', 4);
  // this task will be run every 4 ticks
}

// prototype inheritance
MyTask.__super__ = Task.prototype;
MyTask.prototype = Object.create(MyTask.__super__);
MyTask.constructor = MyTask;

MyTask.prototype.doTask = function () {
  // do what you want here
};
```

## RoomAnalyzer

This object analyzes a room. You can analyze spawns, creeps, structures, extensions, construction sites or sources separatly or not;

if you call the analyze method many times in your code, the room related to the RoomAnalyzer instance will not be calculated again. The result of the room analysis is keep in cache, so you can call the method analyze several times with one of these type, and no more cpu times will be taken to this operation.
The structure of result of the analysis is in dataDefaultRoomAnalyzerResult.js

You can pass several types with the byte operator '|'

```javascript
var analyzer = RoomAnalyzer.getRoom(creep.room);
var result = analyzer.analyze(RoomAnalyzer.TYPE_STRUCTURES | RoomAnalyzer.TYPE_CONSTRUCTION_SITES | RoomAnalyzer.TYPE_CREEPS);
```

## TODO

Make it work. Log a reminder in Game.MODE_SIMULATION to create Spawn1 and some sources.

Game.getRoom() deprecated, use Game.rooms

Method move into behavior: Creep.moveTo() method now reuses the path found along multiple game ticks without recalculation in order to save CPU time. See option reusePath for more info

Creep.say() to specify current action/target/coworker. see inverseState, cancelTransport

Create a changeNextTransporterId, changeNextBlahBlah

Keep in memory instance states if possible

rewrite actions.js, maybe one method by file

Comment more existing code

Memory.rooms[room.name] is Room.memory, something to do with RoomAnalyzer and maxCount of creeps per room, debugMode

Create a method or object, that say easily if the support units are stucked or not. Do something to avoid that in an ideal way.

find usage of Room.mode (Game.MODE_SIMULATION|Game.MODE_SURVIVAL|Game.MODE_WORLD)

create creep Formation with rotate method

guard behavior (lookForAt, lookForAtArea could be good to watch what is going on in creep area)

cpuLimit & getUsedCpu support

Construction priority

road referencing (indexing road position between spawns and sources if spawn already exists)

## Ideas

- Make something to extend instance with mixins
- Something to do with RangeAnalyzer and lookForAt, lookForAtArea methods

repository: Kelgors/screeps

repo_name: Kelgors/screeps


text:
# cookiecutter-csharp-objc-binding
A CookieCutter template for generating a C# binding project for binding an Objective-C static library.

Official cookiecutter repo is available here: https://github.com/audreyr/cookiecutter

It is recommended to first generate the ApiDefinition file using [Objective Sharpie](http://developer.xamarin.com/guides/ios/advanced_topics/binding_objective-c/objective_sharpie/) provided by Xamarin.

Then, execute the cookie cutter using a Python script that will substitute the `api_definition` value in the `cookiecutter.json` file and will copy your static library.

# Example Python Usage:

```
with open('path/to/ApiDefinitions.cs') as apis:
            cookiecutter('gh:SandyChapman/cookiecutter-csharp-objc-binding',
                         extra_context={'api_definition': apis.read().replace('\n', '\n\t'),
                                        'library_name': 'MyLibrary'},
                         no_input=True)
            shutil.copyfile('./libMyLibrary.a', './XamarinBinding/XamarinBinding/libMyLibrary.a')
```

Alternatively, you can manually copy the library file into the project and copy-paste your API definition as desired.


text:
---
layout: post
title:      "Capstone Project: Building a Generative Adversarial Network"
date:       2020-05-14 18:55:27 +0000
permalink:  capstone_project_building_a_generative_adversarial_network
---

Face generated by a GAN
## Goals and Overview

A Generative Adversarial Network (GAN) is a type of neural network for generative modeling. The generative model is trained using two neural network models: a generator and a discriminator. GANs are complex so to put them in laymen's terms, the way they work is there is a generator model that learns to generate plausible samples from a dataset. There is also a discriminator set that is provided with the same dataset and it's goal is to distinguish real data from fake data (data that is produced by the generator model). Both models enter a game, so to speak, where the generator seeks to fool the discriminator by learning and generating data that is so similar to the shared dataset that the discriminator is unable to distinguish generated data from actual data. This game that the models play is where the word "Adversarial" comes from in the network name.

In this research project, I sought to learn about and become more familiar with GANs, and, in particular, image producing GANs. Because GANs are very computationally heavy, the MNIST dataset was selected for because it is a smaller, simpler dataset and thus less computationally taxing.

## Practical Application of GANs

-GANs are practical tool to generate plausible data from a dataset which allows those working on the dataset to have more data to work with.

-GANs can be used to enhance security software: by creating more types of attacks on a security network, the network can adapt to these innocuous attacks preparing it for plausible, new attacks in the future

-GANs can be used for Image Editing, giving artists and graphic designers new ways to modify their work as showcased below:

-GANs can be used for generating images from a learned dataset. Generating new images was the scope of my research project.

## Generated Images

Here is an example of some of the digits that the discriminator model was trained on.

The image above shows digits that have been produced by the generator model after 10 epochs. At this point, the generator has learned from the discriminator where to centralize crude digits.

After 50 epochs, the digits have gained more "curve" and begin to look more like digits.

After 100 epochs, even more smoothening has happened and the figures are resembling more and more like actual digits.

## Future Work

For my future work, I would like to create a GAN to generate faces. The added complexity of the images will pose new challenges with which to improve my knowledge of GANs. I hope to use this new technology in my field of work if ever it is applicable.

Thanks for reading and best of luck to you,

John

extension: markdown


text:
<img src="http://community.neur.io/uploads/default/201/e73a338e371e3192.png" width="350px" alt="Neurio Logo" />

# Automated Web App Selenium Tests

A Selenium based automated test project for the Neurio Web App.

## Installation

Maven and Chrome Web Browser needs to be installed to run this project.

The project uses the following dependencies:
* TestNG 6.10
* Selenium 3.0.1
* Maven Surefire Plugin 2.18.1
* Apache POI 3.15
* Mashape Unirest 1.4.9
* JSON-java v20160810

1. Pull the code from GitHub.

## Usage

Go to the project folder in command prompt.

1. Make sure ChromeDriver is running before running the test suite.
   Go to https://sites.google.com/a/chromium.org/chromedriver/downloads
   to download the latest version if it is not yet installed.
   There is also a folder in the project with chrome driver executable
   files called "chromedriver" if you prefer to use them.

To run the whole test suite:

    mvn integration-test

To run a single test such as "LoginTest":

    mvn -Dtest=LoginTest test

To run specific tests such as "LoginTest" and "SettingsTest":

    mvn -Dtest=LoginTest,SettingsTest test

All test files are located in com.neurio.tests folder.
To change browsers, edit the config.properties file.
After a test run, the HTML Test Report will be located in
/target/surefire-reports/emailable-report.html.
Screenshots will be saved in the /target/web-failure-screenshots folder.
Test Failure Screenshots will be saved in the /target/web-screenshots
folder.

## Contributing

Fork it!
Create your feature branch: git checkout -b my-new-feature
Commit your changes: git commit -am 'Add some feature'
Push to the branch: git push origin my-new-feature
Submit a pull request

## History

Version 1.5 - November 22, 2016
 - Added numerous improvements to the project
 - Updated the Read Me file

Version 1.0 - May 18, 2016

## Credits

Robert T.

## License

Copyright 2016 Robert T<EMAIL_ADDRESS>
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at: http://www.apache.org/licenses/LICENSE-2.0

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

repository: robert-rob/selenium-final

repo_name: robert-rob/selenium-final


text:
---
title: "A Smattering of Selenium #83"
linkTitle: "A Smattering of Selenium #83"
date: 2012-03-14
tags: ["smattering"]
categories: ["general"]
author: Adam Goucher ([@adamgoucher](https://twitter.com/adamgoucher))
description: >
  Well, might not be in Florida, but how about them juggernaut Blue Jays?
---

Well, might not be in Florida, but how about them juggernaut Blue Jays?

*   [WebDriver: capture JS errors while running tests](http://mguillem.wordpress.com/2011/10/11/webdriver-capture-js-errors-while-running-tests/) is a JS way of capturing JS errors on a page
*   [Selenium reports – our take](http://www.deepshiftlabs.com/sel_blog/?p=1840&lang=en-us) is a pretty detailed report on one company’s drive for prettier report output
*   Hmmm. How do we get a Selenium [coderwall achievement](http://coderwall.com/achievements)?
*   [page-objects](https://github.com/iainrose/page-objects) is _A basic framework for running automated tests using WebDriver, TestNG & Gradle_
*   [selenese-runner](https://github.com/DBC-as/selenese-runner) is a js runner of Selenese scripts including a JUnit style reporter. Could be a baby-step towards getting Selenese stuff into a CI server
*   I wonder how much time can be shaved off the average suite by implementing HTTP Compression correctly; [Lose the Wait: HTTP Compression](http://zoompf.com/blog/2012/02/lose-the-wait-http-compression)
*   [LessPainful](https://www.lesspainful.com/) looks interesting for mobile stuff. It uses a Cucumber variant so might have Se under the hood there somewhere.
*   What? You don’t read Etsy’s ‘Code As Craft’? Here is a good starting point; [The Etsy Way](http://codeascraft.etsy.com/2012/02/13/the-etsy-way/)
*   [red, green, refactor – the tools for success](http://highgroove.com/articles/2012/02/07/red%2C-green%2C-refactor---the-tools-for-success.html) shows just how large the toolchain can become. Oh. And step six is critical.

branch_name: refs/heads/trunk

gha_language: HTML


text:
---

copyright:
  years: 2016, 2017
lastupdated: "2017-03-14"

---

{:new_window: target="_blank"}
{:shortdesc: .shortdesc}
{:screen: .screen}
{:codeblock: .codeblock}
{:pre: .pre}

# Integrating {{site.data.keyword.DRA_short}} with {{site.data.keyword.deliverypipeline}}
{: #toolchain_configure_pipeline}

This page has moved. You can view this information at [its new location](/docs/services/DevOpsInsights/insights_risk.html#configuration).
{:shortdesc}

repository: csantanapr/docs

repo_name: csantanapr/docs


text:
# LeNSE: Learning To Navigate Subgraph Embeddings for Large-Scale Combinatorial Optimisation

```
@inproceedings{lense_icml22,
author = {Ireland, David and Montana, Giovanni},
title = {{L}e{NSE}: Learning To Navigate Subgraph Embeddings for Large-Scale Combinatorial Optimisation},
booktitle = {Proceedings of the 39th International Conference on Machine Learning (ICML)},
pages = {9622--9638},
year = {2022}
}
```

links
 - [pmlr](https://proceedings.mlr.press/v162/ireland22a.html)
- [icml](https://icml.cc/Conferences/2022/Schedule?showEvent=18006)
- [arXiv](https://arxiv.org/abs/2205.10106)


text:
# USE CASE: 4 Produce a Report on Population of People, People Living in Cities, and People not Living in Cities in Each Continent, Region and Country

## CHARACTERISTIC INFORMATION

### Goal in Context

As a *user* I want to *view the population of people, people living in cities, and people not living in cities in each continent, region and country*.

### Scope

Project team.

### Level

Primary task.

### Preconditions

We know the role.  Database contains countries data.

### Success End Condition

A report is available for user to view the specific people data.

### Failed End Condition

No report is produced.

### Primary Actor

User.

### Trigger

A request for people information is sent to user.

## MAIN SUCCESS SCENARIO

1. User request people population information.
2. User view all the population of people, people living in cities, and people not living in cities in each continent, region and country.

## SUB-VARIATIONS

None.

## SCHEDULE

**DUE DATE**: Release 1.0

gha_language: Java


text:
---
layout: post
title:  "NYSE Direct Listings"
comments: true
date:   2019-11-26 12:00:00 -0500
categories: general
draft: false
---

The New York Stock Exchange [recently filed paperwork](https://techcrunch.com/2019/11/26/nyse-proposes-big-change-to-direct-listings/) to make direct listings a reality. A lot has been talked about regarding direct listings, especially recently with tech IPO's not turning out as planned. Direct listings allow companies to create a secondary market of existing shares (held by employees, advisors, insiders) available directly to the public. This allows companies to avoid the archaic process of going to banks, but more importantly lets the market decide the price via auction (vs. bankers). Letting the market decide also makes a lot of sense especially for companies that are more well known to individual investors.

repository: tarunsachdeva/blog

branch_name: refs/heads/gh-pages

repo_name: tarunsachdeva/blog


text:
---
title: Hover Effects
platform: sketch
type: prototype
sidebarSorting: 3
categories:
- Prototype
order: 6
---
Adding hover effects to a web site is a great way to draw the attention of the users and make the website to be more engaging.

## Create a Hover Effect

1. Select the layer(s) you want to add the effect to
2. In **Prototype**, expand the **Smart Layers** section, and click **Hover Effect**
3. Select the desired **Hover** effect, or enter your own CSS transition
4. Click Save

![Hover Effect Presets](https://s3.amazonaws.com/animaapp/docs/sketch/Prototype%20-%20Hover%20effect%20presets.png)

>**TIP:**
> - For better results, get to know animation variables such as [Curve, Delay, and Duration](https://support.animaapp.com/launchpad/animation-easing-curve-explained)

## Hover Effect Examples

![Hover Effect Example](https://s3.amazonaws.com/animaapp/docs/sketch/Prototype%20-%20Hover%20effect.gif)
- Preview Live Website: [[Open]](https://Hover-Effects.animaapp.io)
- Sample Sketch File: [[Download]](https://animaapp.s3.amazonaws.com/tutorials/HoverEffectsExampleFile.sketch)

repository: AnimaApp/docs

gha_language: JavaScript

repo_name: AnimaApp/docs


text:
---
layout: relation
title:  'compound:prt'
shortdef : 'phrasal particles'
udver: '2'
---

In UD Irish, the subtype `compound:prt` (phrasal particle) is used in connection with phrasal verbs, where the particle is considered an integral part of the verb expression. The governor of the dependency is the verb, and the dependent is the phrasal particle.

### Example

_Na sonraí atá leagtha amach in Airteagal J_  'The details that are laid out in Article J'

~~~ sdparse
Na sonraí atá leagtha amach in Airteagal J \n The details that are laid out in Article J.
compound:prt(leagtha, amach)

~~~

Here is a list of other examples:

Cur i láthair = to present

Cur i gcoinne = to object

Tabhair suas = to give up

Éirí as = to withdraw

Dul as = to fade

repository: UniversalDependencies/docs

branch_name: refs/heads/pages-source

repo_name: UniversalDependencies/docs


text:
Markov Text Generator
=====================

Why?
----

Because to understand markov chains I needed to hack something together. And to be honest, it produces some pretty interesting little stories, given the right input.

How?
----

After including json2.js and markov.js in your page...

    var test = new markov(text, type, regex);

The text can be anything you so desire.
The type should be "string" or "json".
And the regex should always be global. All matches are used.

Methods
-------

to generate a phrase of a given length:

    test.gen(length);

to see the object containing the data:

    test.data;

to get the JSON generated by JSON2.js of the data:

    test.getJson();

A warning though, you probably only want to use the JSON for making things a bit faster on the processing end with long text, as the JSON tends to be an order of magnitude greater in file size than the input text.

Copyright
---------

This is all open source, you can use it however you like. Especially to learn.

That said, I would enjoy it if you would send me a sample to work produced by this.

Oh, and JSON2.js isn't mine, the source can be found at http://www.json.org/json2.js

repository: rofr/Markov-Generator

repo_name: rofr/Markov-Generator


text:
# README Generator

This is a README generator application

      Github Repository

 |

      Github Pages

     |

      Video Walkthrough

![Screenshot of application demo](img/Capture.PNG)

## Description:
### A node application utilizing inquirer to help users quickly create more detailed READMEs.

![Screenshot of Application](img/Capture.PNG)

## Table of Contents:

 1. [Installation](#installation)
 2. [Usage](#usage)
 3. [License](#license)
 4. [Contributing](#contributing)
 5. [Tests](#tests)
 6. [Questions](#questions)

 ## Installation:
 ### Clone the repo and npm install before starting.

 ## Usage:
 ### Within the terminal type "node index.js" to initialize prompts.

## Technologies:

Javascript, jQuery, JSON

node.js

Github

 ## License:
 ### [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 The Apache License is a permissive free software license written by the Apache Software Foundation (ASF). It allows users to use the software for any purpose, to distribute it, to modify it, and to distribute modified versions of the software under the terms of the license, without concern for royalties."

 ## Contributing:
 ### Tom Mullaney

 ## Tests:
 ###

 ## Questions:
 ### github.com/ThomasMullaney
 ###<EMAIL_ADDRESS>

repository: ThomasMullaney/README-Generator

repo_name: ThomasMullaney/README-Generator


text:
# Footings - A Model Building Library

![tests](https://github.com/footings/footings/workflows/tests/badge.svg)
[![gh-pages](https://github.com/footings/footings/workflows/gh-pages/badge.svg)](https://footings.github.io/footings/master/)
[![license](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
[![codecov](https://codecov.io/gh/dustindall/footings/branch/master/graph/badge.svg?token=SC5BHMYBSN)](https://codecov.io/gh/dustindall/footings)
![version](https://img.shields.io/pypi/pyversions/footings.svg)
[![PyPI version](https://badge.fury.io/py/footings.svg)](https://badge.fury.io/py/footings)

## What is it?

Footings is a model building Python library. No out-of-the box models are provided. Instead it is a framework library that provides key objects and functions to help users  construct custom models.

## Purpose

The footings library was developed with the intention of making it easier to develop actuarial models in Python. Actuarial models are a mix of data engineering and math/calculations. In addition, actuarial models are usually not defined by one calculation, but a series of calculations. So even though the original purpose is actuarial work, if the problem at hand sounds familiar, others might find this library useful.

## Principles

The Footings library was designed as framework library using the below principles -

- Models are a sequence of linked steps
- Models need to be easy to understand
- Models need to have validation built in
- Models need to be easy to audit
- Models need to be self documenting
- Models need to be able to scale up
- Models need to be able to build off other models
- Model environments should not be monolithic

**These all become easier when you can leverage the amazing Python and wider open source ecosystems.**

## Installation

To install from PyPI run -

```
pip install footings
```

To install the latest version on github run -

```
pip install git+https://github.com/foootings/footings-core.git
```

## License
[BSD 3](LICENSE)

## Changelog

[File](./docs/changelog.md)

repository: footings/footings

gha_language: Python

repo_name: footings/footings


text:
# Kubernetes Deployment

This document introduces the architecture, the user cases and the usage of KubeFATE. If you only care about how to use it, then you can jump to [Usage](#usage).

We recommend using [Kubernetes](https://kubernetes.io/) as an underlying infrastructure to create and manage the FATE clusters in a production environment. KubeFATE supports deploying multiple FATE clusters in an instance of Kubernetes with different namespaces for the purposes of development, testing and production. Considering the different IT designs and standards in each company, the actual deployment should be customized. KubeFATE is flexible for the FATE configuration.

## High-level architecture of multiple federated learning parties

The high-level architecture of a multi-party federated learning deployment (e.g. two parties) is shown as follows:

* KubeFATE: Orchestrates a FATE cluster of a party. It offers APIs for FATE-Cloud Manager and other management portals.
* Harbor (Optional): Versioned FATE deployments and images management.
* Kubernetes: Container orchestration engine.

KubeFATE is responsible for:

* Day 1 initialization: Provision a FATE cluster on Kubernetes
* Day 2 operations: Provides RESTful APIs to manage FATE clusters

## High-level architecture of KubeFATE

The high-level architecture of KubeFATE is shown as follows:

The numbers depicted in the diagram:

1. Accepting external API calls of Authentication & authorization
2. Rendering templates via Helm
3. Storing jobs and configuration of a FATE deployment
4. KubeFATE is running as a service of Kubernetes

There are two parts of KubeFATE:

* The KubeFATE CLI. KubeFATE CLI is an executable helps to quickly initialize and manage a FATE cluster in an interactive mode. It does not rely on Kubernetes. Eventually, KubeFATE CLI calls KubeFATE Service for operations with a KubeFATE user token.
* The KubeFATE Service. The KubeFATE service provides RESTful APIs for managing FATE clusters. The KubeFATE service is deployed in Kubernetes, and exposes APIs via [Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/). For the authentication and authorization, the KubeFATE service implements [JWT](https://jwt.io/introduction/), and neutral to other security solutions which can be added to Kubernetes ingress.

KubeFATE is designed to handle different versions FATE. Normally, KubeFATE CLI and KubeFATE service can work with several FATE releases.

## Real-world story

Suppose in an organization, there are two roles:

* System Admin: who is responsible for the infrastructure management as well as Kubernetes administration
* ML Infrastructure Operators: who is responsible for managing the machine learning cluster such as FATE

## Usage

KubeFATE can support deployment on any k8s. As a first-time user or someone who is not familiar with k8s, it is recommended to use Minikube to get started. You can refer to this tutorial [Build Two Parties FATE Cluster in One Linux Machine with MiniKube](../docs/tutorials/Build_Two_Parties_FATE_Cluster_in_One_Linux_Machine_with_MiniKube.md)

### Prerequisite

Recommended version of dependent software:

Kubernetes: [v1.23.5](https://github.com/kubernetes/kubernetes/releases/tag/v1.23.5)

Ingress-nginx: [v1.1.3](https://github.com/kubernetes/ingress-nginx/releases/tag/controller-v1.1.3)

### Creating role, namespace and other resource in Kubernetes

The example yaml can be found in [rbac-config.yaml](./rbac-config.yaml). In this example, we create a kube-fate namespace for KubeFATE service. Resource constraints can be applied to kube-fate namespace, refer to [Kubernetes Namespace](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/), [Configure Memory and CPU Quotas for Namespace](https://kubernetes.io/docs/tasks/administer-cluster/manage-resources/quota-memory-cpu-namespace/).

Run the following command to create the namespace:

```
kubectl apply -f ./rbac-config.yaml
```

Note that, the default username and password of KubeFATE service can be set in `rbac-config.yaml` Secret->kubefate-secret->stringData :

```
stringData:
  kubefateUsername: admin
  kubefatePassword: admin
```

### Preparing domain name and deploying KubeFATE in Kubernetes

Because KubeFATE service exposes RESTful APIs for external access, system admin needs to prepare a domain name for KubeFATE service. In our example, the domain name is `example.com` . Moreover, system admin should create a namespace (e.g. fate-9999) for FATE deployment.

```
kubectl apply -f ./kubefate.yaml
kubectl create namespace fate-9999
```

For more about the configuration of KubeFATE service, please refer to: [KubeFATE service Configuration Guild](../docs/configurations/kubefate_service_configuration.md).

### Preparing cluster configuration and deploying FATE

After the system admin deployed the KubeFATE service and prepared the namespace for FATE. The ML Infrastructure Operator is able to start the deployment of FATE. The `config.yaml` for `kubefate` CLI is required. It contains the username and password of KubeFATE access, and the KubeFATE service URL:

```
log:
  level: info
user:
  username: admin
  password: admin

serviceurl: example.com
safeconnect: false
```

|Name       |Type    |Description                                                       |
|-----------|--------|------------------------------------------------------------------|
|log        |scalars |The log level of command line.                                    |
|user       |mappings|User name and password when logging into KubeFATE service.        |
|serviceurl |scalars |KubeFATE service's ingress domain name, defined in kubefate.yaml. |
|safeconnect|scalars |Whether use HTTPS to connect the KubeFATE service URL. You can refer to: [kubefate_service_tls_enable](../docs/configurations/kubefate_service_tls_enable.md)           |

Create a `cluster.yaml` for FATE cluster configuration. The details of configuration can be found here: [FATE Cluster Configuration Guide](../docs/configurations/FATE_cluster_configuration.md).

**NOTE:** For Chinese user, specifying a local image registry in `cluster.yaml` can accelerate the download of images. The details are as follows:

```yaml
registry: "hub.c.163.com/federatedai"
```

Next, install the FATE cluster,

```bash
$ kubefate cluster install -f ./cluster.yaml
create job success, job id=d92d7a56-7002-46a4-9363-da9c7346e05a
```

*NOTE: If you want to deploy **FATE on Spark**, you can use `cluster-spark.yaml`.*

Deploying FATE with KubeFATE can support many different engine combinations. For more details on the different types of FATE see: [Introduction to FATE Engine Architecture](../docs/Introduction_to_Engine_Architecture.md).

**If you have resource requirements (CPU and memory) for the components, please make sure to check [the example](../helm-charts/FATE/values-template-example.yaml), search for "resources" to know how to define the resource requirements.**

We support such definition for:

1. Eggroll components: cluster manager, node manager and rollsite.
2. Spark components: master and worker.
3. Rabbitmq.
4. Pulsar.

### GPU support

Starting from v1.11.1, KubeFATE can deploy GPU-enabled FATE clusters. Deploying GPU-enabled FATE requires some special preparation and configuration. You can check this document[KubeFATE Deploying GPU-enabled FATE](../docs/KubeFATE_deploys_GPU-enabled_FATE.md)

### Checking the status of "Installing Cluster" job

After the above command has finished, a job is created for installing a FATE cluster. Run the command `kubefate job describe` to check the status of the job, until the "Status" turns to `Success`.

```bash
$ kubefate job describe d92d7a56-7002-46a4-9363-da9c7346e05a
UUID      d92d7a56-7002-46a4-9363-da9c7346e05a
StartTime 2022-04-12 07:34:09
EndTime   2022-04-12 07:48:14
Duration  14m
Status    Success
Creator   admin
ClusterId 24bb75ff-f636-4c64-8c04-1b9073f89a2f
States    - update job status to Running
          - create Cluster in DB Success
          - helm install Success
          - checkout Cluster status [794]
          - job run Success

SubJobs   nodemanager-0        ModuleStatus: Available, SubJobStatus: Success, Duration:    13m, StartTime:
          2022-04-12 07:34:09, EndTime: 2022-04-12 07:47:26
          nodemanager-1        ModuleStatus: Available, SubJobStatus: Success, Duration:    13m, StartTime:
          2022-04-12 07:34:09, EndTime: 2022-04-12 07:47:18
          python               ModuleStatus: Available, SubJobStatus: Success, Duration:    14m, StartTime:
          2022-04-12 07:34:09, EndTime: 2022-04-12 07:48:14
          rollsite             ModuleStatus: Available, SubJobStatus: Success, Duration:    13m, StartTime:
          2022-04-12 07:34:09, EndTime: 2022-04-12 07:47:24
          client               ModuleStatus: Available, SubJobStatus: Success, Duration:    11m, StartTime:
          2022-04-12 07:34:09, EndTime: 2022-04-12 07:45:22
          clustermanager       ModuleStatus: Available, SubJobStatus: Success, Duration:    13m, StartTime:
          2022-04-12 07:34:09, EndTime: 2022-04-12 07:47:11
          mysql                ModuleStatus: Available, SubJobStatus: Success, Duration:    13m, StartTime:
          2022-04-12 07:34:09, EndTime: 2022-04-12 07:47:11
```

### Describing the cluster and finding FATE access information

After the `installing cluster` job succeeded, use `kubefate cluster describe` to check the FATE access information:

```bash
$ kubefate cluster describe 24bb75ff-f636-4c64-8c04-1b9073f89a2f
UUID         24bb75ff-f636-4c64-8c04-1b9073f89a2f
Name         fate-9999
NameSpace    fate-9999
ChartName    fate
ChartVersion v1.11.2
Revision     1
Age          15m
Status       Running
Spec         algorithm: Basic
             chartName: fate
             chartVersion: v1.11.2
             computing: Eggroll
             device: CPU
             federation: Eggroll
             imagePullSecrets:
             - name: myregistrykey
             ingressClassName: nginx
             istio:
               enabled: false
             modules:
             - rollsite
             - clustermanager
             - nodemanager
             - mysql
             - python
             - fateboard
             - client
             name: fate-9999
             namespace: fate-9999
             partyId: 9999
             persistence: false
             podSecurityPolicy:
               enabled: false
             pullPolicy: null
             registry: ""
             storage: Eggroll

Info         dashboard:
             - party9999.notebook.example.com
             - party9999.fateboard.example.com
             ip: <IP_ADDRESS>
             status:
               containers:
                 client: Running
                 clustermanager: Running
                 fateboard: Running
                 fateflow: Running
                 mysql: Running
                 nodemanager: Running
                 nodemanager-eggrollpair: Running
                 rollsite: Running
               deployments:
                 clustermanager: Available
                 rollsite: Available
```

### Access the UI of FATEBoard and Notebook

If the components of fateboard and client are installed, you can use the information `party9999.fateboard.example.com` and `party9999.notebook.example.com` obtained in the previous step to access FATEBoard and Notebook UI, and configure the resolution of these two domain names It can be opened in the browser.

#### FATEBoard

 <http://party9999.fateboard.example.com>

Access to FATEBoard UI requires a login user name and password, which can be found in `cluster.yaml` [Configuration](../docs/configurations/FATE_cluster_configuration.md#fateboard mappings).

![fate_board](../docs/tutorials/images/tkg_fate_board.png)

#### Notebook

 <http://party9999.notebook.example.com>

![notebook](../docs/tutorials/images/tkg_notebook.png)

### Other user scenarios

#### [Manage FATE and FATE-Serving Version](../docs/Manage_FATE_and_FATE-Serving_Version.md)

#### [Update and Delete a FATE Cluster](../docs/Update_and_Delete_a_FATE_Cluster.md)

#### [KubeFATE Examples](examples)

#### [KubeFATE Command Line User Guide](../docs/KubeFATE_CLI_user_guide.md)

## KubeFATE service RESTful APIs reference

**[API Reference](docs/KubeFATE_API_Reference_Swagger.md)**

repository: FederatedAI/KubeFATE

gha_language: Go

repo_name: FederatedAI/KubeFATE


text:
Title: A program to print a single character ‘A’.
Date: 2021-04-23 02:50 PM
Tags: Assembly Language
Category: Programming Exercise
Authors: Alwi

## Objective: Write a program to print a single character ‘A’.

## ource Code

```
.model	        // It is an assembler directive that specifies the size of the program
.stack 100h		// It declares size of stack
.data			// In this segment variables are declared
.code			// It is code segment directive

main proc		// main procedures start from here

mov DL, 'A'		// ‘A’ is moving to Data Register
mov ah, 02h		// Service Routine is being defined here to print the character
int 21h		    // Programs are returned to windows from DOS
mov ah, 4ch		// Using 4ch service routine number to display
int 21h		    // Programs are returned to windows from DOS

main endp		// Main procedures end here
end main		// whole programs end here
```

## Output:

![Assembly Language 1](images/AL-1.1.JPG "AL-1 output")
![Assembly Language 1](images/AL-1.2.JPG "AL-1 output")
![Assembly Language 1](images/AL-1.3.JPG "AL-1 output")

repository: farooqalwi/pelican-web

path: /content/Assembly 1.md

filename: Assembly 1.md

repo_name: farooqalwi/pelican-web


text:
About
=====
This library is a collection of test projects to explore different machine learning methods for predicting moment magnitude (Mw) for earthquakes in Utah.
The proposed models will be under the category of supervised learning (for now). The moment magnitude data are computed via a combination of the methods of [Holt (2019)](https://livrepository.liverpool.ac.uk/3064483/1/200880943_Sep2019.pdf) and [Holt *et al.* (2021)](https://doi.org/10.1785/0220200320)

Fig. 1 - Comparing predicted Mw (from linear regression) with the actual Mw for events in the test 'holdout' Mw dataset.

Table of Contents (Jupyter Notebooks)
=================
1. [Data Preparation](jupyter-notebooks/2021_07_25_jh_1_data_prep.ipynb)
2. [Linear Regression](jupyter-notebooks/2021_07_25_jh_2_linear_models.ipynb)

repository: sgjholt/mlmags

repo_name: sgjholt/mlmags


text:
---
layout: post
title: "Teaching"
date: 2022-11-14
categories:
  - Teaching
description:
image: /images/2015_Spring_3.JPG
image-sm: /images/2015_Spring_3.JPG
---

Faculty Evaluations

 ratemyprofessors.com A great teacher who is excited to teach. However, be prepared as physics isn't the easiest subject.
Most of the time you deal with conceptual things, but Alex does a good job at explaining thoroughly.
As someone who always sucked at physics, this class was a lifesaver. Would recommend.

 ratemyprofessors.com Alex is very passionate about physics and he's always excited to talk about it.
You'd be in a good shape if you read the textbook ahead because his lectures are fast.
I thought he's sarcastic at the beginning but he's actually very nice, understanding, and caring once you talk to him.
Make sure to attend lectures before exams.

 Alex is definitely one of the best teachers I could've asked for. He offered his help so much and
provided us with a lot of feedback and made us feel comfortable with not knowing and coming
forward in asking questions. He'd try and explain in many different ways to
make sure we understood. One of the best teachers ever.

 Alex is great instructor!! Very helpful and makes sure we all understand the lesson.  I love that!
Alex was incredibly helpful and the labs weren't too difficult or confusing. It was a great
course.

 ![Pic8](/images/2017_Fall.JPG){:class="img-responsive"}

 Alex is very helpful and very caring. My group was usually the last one to finish and passed the class time. He would wait for us to finish the lab and never complained about waiting.

 He's understanding, helps us learn, makes sure we understand everything, and he's cute! I had no
clue that was how he spelled his name (Olexiy). Great lab prof :)

 Alex was passionate about the subject and teaching.

 Alex is absolutely wonderful. He's very helpful, friendly, and flexible.

 Alex is a very smart teacher. He explained concepts not simply related to
the class and made abstract ideas as simple as possible. His passion for physics shows in his teaching.

 Alex was very nice and approachable and answered our questions warmly. His grading was very fair.

 Alex extensively helped in and out of class.

 ![Pic11](/images/2018_Spring.JPG){:class="img-responsive"}

 Amazing lab instructor. Really knowledgeable, kind, funny, and cares about his students.

 Would definitely take a class with Alex again! He made class enjoyable.

 Super nice, always grades fairly, tells us exactly what to do.

 Alex is engaging and very interesting.

 Alex was great for his first time teaching. Physics is very complex and he
taught to the best of his abilities.

 Honestly one of the best TA's, I wish he'd teach Summer Session 2!! Great guy. I liked
how he always asked us what we learned in lecture so he could help us brush up the subject.

 I had a good time. Alex did a very good job of explaining and helping us with very complicated and hard to understand lab instructions.

 Alex tried his best to help. He is extremely smart and I wouldn't have understood many parts of the labs without him.

 Alex is a great. He's willing to answer all and any questions, even if he already answered them. He's very patient and explains in detail so that it’s understandable for all.

 Alex grades fast and explains the concepts thoroughly.

 ![Pic4](/images/2015_Fall_3.JPG){:class="img-responsive"}

 Alex is a great TA. Very helpful. He helped students whenever they were struggling and provided his own examples and experiences to help us understand the concepts. I'm not good at physics, but I learned more in this hands on lab.

 Great teacher; passionate and knowledgeable; very helpful; showed concern for all his students.

 Alex was very enthusiastic in helping us learn and creating a fun environment.

 Alex is great. Very kind and helpful.

 Alex made class interesting and fun. Always willing to answer
questions and help with the lab!

 Alex effectively taught me and the rest of the students how to do some of the more
ambiguous aspects of certain labs. He is a skillful instructor that seems to genuinely care about
teaching us. He is the best lab instructor I've ever had.

 Alex was able to explain material that was un-comprehensible to his students very clearly.

 Alex was friendly, helpful, and available for office hours.

 ![Pic3](/images/2016_Fall_3.JPG){:class="img-responsive"}

 Alex helps us a lot during the lab. He gives mini lectures so we know what we are doing. He is amazing.

 Alex is pleasant and great.

 Alex was very approachable, patient, and always answered any questions.

 Alex definitely helped me a lot! Since our lab was on a Monday, we hardly touched the lab
subjects in lecture so he would go over the main concepts.

 He was a nice teacher and helped especially when we needed it. He often stayed overtime and waited for us to finish.

 This class was very enjoyable. Although the concepts were tough, Alex always explained
everything clearly.

 He's very good at helping his student understand the subject.

 This course was challenging on certain days, but I loved it. Alex was very helpful and
explained every lab thoroughly before continuing. He went around the room to help anyone
who had questions.

 Great at simplifying and explaining the relevance of the lab performed. Patient, able to deal with all personalities.
Useful office hours.

 Alex was a great teacher and was very patient in explaining the complexities of physics. He's the best physics lab instructor ever. Helped so much and was always available. Really wanted students to succeed.

 ![Pic6](/images/2015_Fall_2.JPG){:class="img-responsive"}

 He's very helpful and clear when explaining the lab for the day!

 I loved having Alex as a TA. Great teacher, very helpful.

 I hope to work with him again sometime in the future.

 Alex was really cool and helpful during the labs. Great guy.

 Alex definitely conveyed proficiency in physics and helped at any moment with not only the labs, but anything concerning physics.

 Very helpful and really cool.

 Loved Alex.

 Loved the class, loved Alex. He's very smart and helpful.

 Made lab fun and helped with any problems I may have had.

 He was great!

 ![Pic10](/images/2016_Summer_2.JPG){:class="img-responsive"}

 Alex is a super cool guy who advanced my knowledge of physics. When he'd explain things, they often went over my head since he went about them in a different way than I did.

 Great teacher; took time to answer all our questions; very helpful.

 He's a fantastic instructor. Friendly, receptive, extremely knowledgeable.

 He clearly knows his stuff. Alex is an amazing teacher and helped me work through any blocks. I really appreciated that he made physics not scary!

 I liked Alex's vibe and dedication. He knew his material and helped us out whenever we got stuck.

 He is a really nice guy. Give him a raise.

 ![Pic1](/images/2015_Spring_2.JPG){:class="img-responsive"}

 Alex is very knowledgeable, super helpful and patient. Quite an amicable person. Alex really understood the material. He was very helpful, always quick, and extremely efficient with time. He presented everything really clearly and thoroughly.

 Alex gave new perspectives on problems so that they can be solved without constantly asking for help.

 He engaged the class and was very attentive. He would go around and help, ask, answer questions, and share fun facts relevant to the material.

 Alex is an amazing TA. If we were not understanding something, he'd explain until we were able to comprehend. He also made it known that, if we needed help in lecture, his door would always be open during office hours. I appreciated his help so much and thank him. One of the best TA's I have had.

 ![Pic12](/images/2017_Spring_2.JPG){:class="img-responsive"}


text:
# Modernizr [![Build Status](https://secure.travis-ci.org/Modernizr/Modernizr.png?branch=master)](http://travis-ci.org/Modernizr/Modernizr)

##### Modernizr is a JavaScript library that detects HTML5 and CSS3 features in the user’s browser.

- [Website](http://www.modernizr.com)
- [Documentation](http://www.modernizr.com/docs/)

Modernizr tests which native CSS3 and HTML5 features are available in the current UA and makes the results available to you in two ways: as properties on a global `Modernizr` object, and as classes on the `<html>` element. This information allows you to progressively enhance your pages with a granular level of control over the experience.

Modernizr has an optional (*not included*) conditional resource loader called `Modernizr.load()`, based on [Yepnope.js](http://yepnopejs.com). You can get a build that includes `Modernizr.load()`, as well as choosing which feature tests to include on the [Download page](http://www.modernizr.com/download/).

## Test suite

Run the [test suite](http://modernizr.github.com/Modernizr/test/)

## License

MIT license

repository: riddla/Modernizr

repo_name: riddla/Modernizr


text:
# Fraud Services

Provides an overview of the with the monitoring and preventative measures to prevent and discourage fraudulent activities within the Mojaloop ecosystem.

- [Mojaloop Ecosystem Fraud Overview Document](https://github.com/mojaloop/documentation-artifacts/blob/master/fraud-services/Mojaloop-Fraud-20190410.pdf)

repository: brago/documentation

repo_name: brago/documentation


text:
---
layout: page
title: Energon-AI
description: Large Scale Serving System for Large Model Inference
# img: assets/img/3.jpg
importance: 4
category: Projects
---

https://github.com/hpcaitech/EnergonAI

* Build an open server for the OPT-175B, utilizing tensor and pipeline parallelism, along with bucket
batching, past cache and left padding to enhance its performance in serving.
* Design auto-tune CUDA kernel for linear and attention to search best strategy for inference.


text:
# Math2Mathml

The math2mathml.js script converts a (valid) RASH document replacing Math Formulas (defined using both LaTeX and AsciiMath notation) with their MathML equivalent and saves the converted document to the specified path.

## Usage

After opening a terminal and entering the RASH folder, using the math2mathml script is as simple as typing `phantomjs math2mathml.js -o output_path document_path"` where
* output_path is the path where you want to save the converted document and
* document_path is the path of the document you want to convert.

Please note that in order to use this script you need a working network connection as RASH loads MathJax dynamically over the Internet.

## Dependencies

In order to execute math2mathml.js you have to install [PhantomJS](http://phantomjs.org/). You also need a handful more dependencies (notably MathJax and JQuery) but you shouldn't worry about them since they are automatically taken care of by the RASH framework which embeds them in RASH documents as needed.

license: ISC

repository: illbexyz/rash

repo_name: illbexyz/rash


text:
# cordova-plugin-ios-disableshaketoedit

## Description
This plugin disables the infamous "Shake to undo" feature by setting the application's `applicationSupportsShakeToEdit` property to `NO`.

## Version History

### 0.2.0
* Fixed plugin not working anymore with cordova 3.2+.

### 0.1.0
* Initial release.

## License
This code is released under the Apache 2.0 license.

repository: furrm/z-upload

repo_name: furrm/z-upload


text:
---
title: Google TXT record management
description: You can add Google TXT site verification record to all your subdomains used to send emails to GMAIL addresses through the Campaign Control Panel.
feature: Google TXT record management
topics: Control Panel
audience: administrator
kt: 4744
doc-type: feature video
activity: use
team: PM
---

# [!DNL Google] TXT record management

To ensure high inbox rates and low spam rates, some services like [!DNL Google] require that you add a TXT record to your domain setting to verify that you own the domain. TXT records are a type of DNS records used to provide text information about a domain, that can be read by external sources.

The video below describes how you can add [!DNL Google] TXT site verification records to all your subdomains used to send emails to GMAIL addresses with [!UICONTROL Campaign Control Panel].

>[!VIDEO](https://video.tv.adobe.com/v/32369?quality=12)

## Additional resources

* [Documentation](https://docs.adobe.com/content/help/en/control-panel/using/subdomains-and-certificates/managing-txt-records.html)


text:
# Airaria
Made for Ludum Dare 43 - Theme: Sacrifices must be made

#Description:

##Scenario:
You are a captain of an airship that has to transport goods between different air harbours. On your journey you may encounter difficult situations, in which you may have to drop some ballast in order to escape. Because of strong winds or air pirates.

Good luck sailor!!

##Controls:

* The zeppelin can be controled by a steering weehl and a climbing meter (0 = keep height, <0 = go down, >0 = go up)
* First version only with WASD and SPACE to drop weight

#####################

#TODO

##Modelling:

* Zeppelin Model
* Harbour
* Clouds
* Cargo
*

##Sounds:

* Air blowing - strong wind
* Air blowing - light wind
* Zepelling steering
* Arriving in harbour
* Leaving harbour
* Drop cargo

##Coding:

Most Importants mechanisms

### Flying
* Zeppelin flying straight
* Z. flying left
* Z. flying right
* Z. climbing up
* Z. climbing down

### Harbour
* Detecting harbour
* Showing action option
* Detecting action
* Animiation to dock
* Animation to undock

### Questions to answer:
* Can we crash into harbour, xxx?
* Life of zeppelin?
* Do we need fuel?
*

## Cargo
* Load cargo
* Unload cargo
* Drop cargo

# Steps:
* Drop Cargo Slider
* Drop Cargo Slider functionality
* Drop Cargo Animation

repository: matthiasSchedel/Airaria

repo_name: matthiasSchedel/Airaria


text:
---
title: Joel on Reddit
author: ajordens
layout: post
permalink: /2006/06/joel-on-reddit/
categories:
  - General Discussions
---
Came across this [site][1] tonight. Basically, it’s a community site for *Joel on Software *where readers can submit/vote on stories that would likely be of interest to fellow readers.

Normally I wouldn’t link to something like this, but I did read a few of the user-submitted posts and found them to be of fairly high value. I’ve found the signal-to-noise ratio in the blogosphere to be quite high as of late so it’s nice to have the community do a bit of filtering for you.

Check it out.

On that note, I’ve been struggling for weeks to get my unread posts in Bloglines down from 4k to something slightly more manageable… without much success. I’ve successfully gotten it down to 3k a number of times but than I go to JavaOne or something and it jumps to 4500.

 [1]: http://joel.reddit.com/


text:
# How to Make a Robot

#Robot
An electromechanical device which is capable of reacting in some way to its environment, and take autonomous decisions or actions in order to achieve a specific task.

# Let's get started
Instead of building one robot, you should try to learn how to use indidual components with the objective.

Robotics incorporates aspects of many disciplines including engineering (mechanical, electrical, computer), sciences (mathematics and physics) and arts (aesthetics) and users are free to use their imagination.

Step1 :
The first step is to determine what your robot should do(i.e. what its purpose in life).

Step2 :

# Voltage

# Current

# Motor

# Sensors

url: https://raw.githubusercontent.com/codesorter2015/robotics-basics/09bbbbc5894e215397ac68b8ce6f1fe2110da25e/How to Make a Robot.md

path: /How to Make a Robot.md

filename: How to Make a Robot.md


text:
---
layout: post
title: September Meetup Notes
---

We did it! First meetup was a success, thanks to everyone who came and to the presenters who shared. After the presentations we had a good discussion of what everyone was working on including successes and areas of difficulty. Following up with people afterwards I think the format we may use going forward would be the following

1. Presentation (one or two presenters)
2. Prior to the meetup people share code or issues through [twitter] (a gist would work), and we discuss.

Honestly, I feel like those two items would be enough to cover a 1 - 2 hour block of time. Depending on how much community involvement for item 2 would help gauge how often we meet as a group. As always, I'm open to feedback but feel its necessary to say what I'm thinking to start the conversation. :)

Finally, slide decks. They can be found here: https://github.com/kcpsug/kcpsug.github.io/tree/master/_slides

[Robin Haberstroh]: http://www.twitter.com/strohland

[Bryce McDonald]: http://www.twitter.com/_brycemcdonald

[twitter]: http://www.twitter.com/kcpsug


text:
Pixel Vision 8 is fully open source. The [Github repo](http://github.com/PixelVision8/pixelVision8/) contains everything you need to build a bare-bones C# and Lua runner, as well as a C# Runner that supports run-time recompiling via Roslyn. Finally, you can also build the full version of Pixel Vision 8 from scratch. All you need is NodeJS or an IDE capable of compiling the .NET Core framework such as [Visual Studio Code](https://code.visualstudio.com/Download), Visual Studio ([Win](https://visualstudio.microsoft.com/vs/)/[Mac](https://visualstudio.microsoft.com/vs/mac/)), or [Jetbrains’ Rider](https://www.jetbrains.com/rider/).

## Cloning From Github

Before you clone from Github, let’s talk about how the repo is structured, and which branch or tag you should clone. While you can simply check out the master branch, each stable build is tagged based on its version.

![image alt text](images/CloningFromGithub_image_0_v2.png)

Each tag is considered "stable" and will no longer get updated. The master branch will always represent the lastest stable codebase and is updated after each new version is released. That means you’ll need to do a pull to get updates after each release.

![image alt text](images/CloningFromGithub_image_1_v2.png)

Finally, for those looking for nightly builds or patches to bugs as they are closed, the branches offer the most up-to-date fixes. Simply find the latest version if you are looking for patches to issues recently closed.

![image alt text](images/CloningFromGithub_image_2_v2.png)

There is an up-to-date list of issues currently being worked on and each issue is tagged to the version they will be fixed. Feel free to log bugs or submit fixes and we’ll figure out how to handle them.

![image alt text](images/CloningFromGithub_image_3_v2.png)

## Runners

A Pixel Vision 8 Runner is any code wrapper that bridges the gap between the core engine and the host OS. The Runner performs the following tasks:

* Facilitates rendering the `DisplayChip`’s pixel data on the screen.

* It provides a native application wrapper so PV8 can run as a self-contained executable.

* Calls the `GameChip`’s `Init()`method on startup as well as the `Update()` and `Draw()` methods during each frame.

* Feeds the engine input data such as the mouse, keyboard and any connected controllers.

* It provides a way to play audio.

* Manages the loading and playing of games plus their associated files.

Pixel Vision 8 Runners solution files can be found inside of the Projects folder. You'll find several different types of runners as well as the Unit Tests and the main Pixel Vision 8 Project.

![MakingCSharpGames_image_2_v2](images/MakingCSharpGames_image_2_v2.png)

## MonoGame Runners

MonoGame Runners are bare bone wrappers for PV8 games build on top of the MonoGame framework. There are three runners, one for pure C# games, another for Lua games, and a Roslyn Runner. The Roslyn Runner allows you to reload C# games at runtime, similar to how Lua games work in Pixel Vision 8. Each runner helps bridge the gap between the Pixel Vision 8’s C# code and the native operating system. All three runners have the same basic functionality, so you’ll need to figure out the one that best suits your needs base on the programming language you prefer to use.

Each runner has a Game Property you can modify in the .cs project file which points to a path for the game you want to run. By default, they are all set up to load the same background color API example in the Disks/APIExamples/ folder.

```	xml
<PropertyGroup>
	<Game>../../Disks/APIExamples/BackgroundColor</Game>
</PropertyGroup>
```

You can change the path to any game folder you want the Runner to load.

Whiley you can build the Runner in from the solution in VS Code, Visual Code, or Rider directly. There are build scripts that help make this process easier. In order to use them you'll need to have NodeJS installed on your computer. Once installed, open up VS Code's terminal, or the command line on your computer and run the following:

``` > npm install ```

Node will install all of the dependencies you need to run the build script to your local computer.

![compiling_npm_install](images/compiling_npm_install.png)

When everythign is installing, you can run any of the following commands based on what Runner you want to launch:

| Runner        | Command           | Notes                                                        |
| ------------- | ----------------- | ------------------------------------------------------------ |
| C# Runner     | `gulp run-csharp` | Launches the default C# Runner for pure C# game development. |
| Lua Runner    | `gulp run-lua`    | Launches the default Lua Runner with support for live reloading Lua code (`Crtl + 4`) |
| Roslyn Runner | `gulp run-roslyn` | Launches the default Roslyn Runner for C# game development with support for live reloading C# code (`Crtl + 4`) |

From here you can start the build and you will end up with the following based on which Runner you launch.

![charp_runner_bgcolor](images/roslyn_runner_bgcolor.png)

To load another example from the API Example Disk, simply change the `Game` property value in the `.cs` file. The build script will automatically load it for you. Remember that recompiling the Runner will reload the files located in the build’s Contents folder and not found in the solution since they are copied over on each new build.

![image alt text](images/roslyn_content_folder.png)

Any chances you make here will be overwritten if you recompile in Visual Studio, so be sure to copy these back over to your project's Contents folder.

Finally, it’s important to point out that each of the runners has dependencies on MonoGame, which is automatically downloaded from NuGet. and the Lua Runner requires a reference to [MoonSharp](https://www.nuget.org/packages/MoonSharp) which is the Lua Interpritore Pixel Vision 8 uses.

![image alt text](images/MonoGameRunners_image_8.png)

These NuGet projects are not included in the git repo so you may need to force the project to reimport them or install them by hand. This is automtically done if you run the build script.

## Compiling Pixel Vision 8

If you want to recompile Pixel Vision 8's IDE from the source code, you can do so by opening `Projects/PixelVision8/PixelVision8.CoreDesktop.csproj` in Visual Studio or Rider.

Likewise, you can run the following on the command line to use the automated build script:

```	bash
> gulp run-pv8
```

This will compile the file Pixel Vision 8 IDE, and automatically mount the Pixel Vision OS and API Example disks.

![pv8_build_from_script](images/pv8_build_from_script.png)

The Pixel Vision 8 project will automatically create a `Workspace` folder when it boots up. By default this will be created on your computer in one of these paths based on the OS you are running it on:

| Version | Path                                                      |
|---------|-----------------------------------------------------------|
| Windows | C:\\Users\\UserName\\Documents\\PixelVision8\\Workspace\\ |
| MacOS   | /Users/UserName/PixelVision8/PixelVision8/Workspace/      |
| Linux   | /Users/UserName/PixelVision8/PixelVision8/Workspace/      |

By default, Pixel Vision 8's IDE doesn't have an OS installed. Instead, the OS disk is passed in as a command line paramitor in the build script. You can change the default disks by openeing the `Build/Tasks/launch.js` file and replacing the `additionalArgs` in the `build-pv8` task.

```javascript
gulp.task('build-pv8', ()=>{
  return gulp.src(process.env.PROJECT, {read: false})
      .pipe(run({
        additionalArgs: [process.env.DISKS + 'PixelVisionOS/', process.env.DISKS + 'APIExamples/'], //process.env.DISKS + 'TinyCard/'], // APIExamples ['-d', 'Disks/PixelVisionOS/', '-disk', 'Disks/APIExamples/']
        echo: true
    }));
});
```

If you want to use the OS and all of the tools, simply change the second disk path to your own game. Or, you can just have PV8 boot directly into your game by passing in a single disk path. Finally, if you are using Pixel Vision OS, you can drop any `.pv8` disk, or game folder onto the Runner’s window and it will attempt to load it up.

The biggest difference here is that the Pixel Vision 8 Runner creates a mount point for the OS folder which you can access internally at `/PixelVisionOS/` and includes all of the logic needed to access the virtual filesystem (VFS) inside of the user's `Workspace` folder. You'll also have the ability to run both C# and Lua games. So, if your game needs access to a VFS, requires the `GameEditor`, or the ability to export and save files, you can customize the `PixelVision8.CoreDesktop.csproj` project for your own needs.

## Release Build

If you would like to create a release build of Pixel Vision 8, or see how the automated but script works, simply type the following in the command line:

``` bash
> gulp
```

This will run through all of the release tasks and create a new folder called `Releases` in the root of the project folder.

![CloningFromGithub_image_6_v2](images/CloningFromGithub_image_6_v2.png)

There will be two folders. The `Source` folder will contain all of the raw files for each platform that the build script needs to create an optimized final build of the Pixel Vision 8 IDE.

![CloningFromGithub_image_7_v2](images/CloningFromGithub_image_7_v2.png)

The `Final` folder contains the finished builds for each OS and some additional items such as disks, a Unity Runner, and other ideas that are automatically generated when a new release is created on GitHub.

![CloningFromGithub_image_8_v2](images/CloningFromGithub_image_8_v2.png)

You can always get the lates version of Pixel Vision 8 on the [GitHub releases page](https://github.com/PixelVision8/PixelVision8/releases/latest).

## Compiling On Mac

On the latest version of Mac OS you may run into some security warnings when trying to load Pixel Vision 8 after compiling it for the first time.

![CloningFromGithub_image_4_v2](images/CloningFromGithub_image_4_v2.png)

There are several libraries that Pixel Vision 8 relies on that you will need to approve in the security panel. You can do this by opening the Settings > Security & Privacy panel and pressing Allow Anyway.

![CloningFromGithub_image_4_v2.png](images/CloningFromGithub_image_5_v2.png)

You may need to do this a few times before you can run PV8 from the source code without an issue.

license: MS-PL

gha_license_id: MS-PL


text:
---
layout: default
datatable: true
image: /files/images/lab_photo_2021.jpg
---

Publications

Copyright Notice

        The documents distributed here have been provided as a means to ensure timely dissemination of scholarly and technical work on a noncommercial basis. Copyright and all rights therein are maintained by the authors or by other copyright holders, notwithstanding that they have offered their works here electronically. It is understood that all persons copying this information will adhere to the terms and constraints invoked by each author’s copyright. These works may not be reposted without the explicit permission of the copyright holder. (Notice borrowed from Dave Plaut/Randy O’Reilly)

    {% for row in site.data.pubs_table %}
        {% if forloop.first %}

                Authors
                Year
                Title
                Publication
                Links

        {% endif %}

        {% for pair in row %}
            {{ pair[1] }}
        {% endfor %}

    {% endfor %}

gha_language: CSS


text:
# [Tic-Tac-Toe-Game](https://rkm09.github.io/Tic-Tac-Toe-Game)

### [FCC FrontEnd Advanced Projects - 3/4 : Tic-Tac-Toe Game](https://www.freecodecamp.org/challenges/build-a-tic-tac-toe-game)

**Description**: Makes use of the minimax algorithm for ai.

**User Story**:
* I can play a game of Tic Tac Toe with the computer.
* My game will reset as soon as it's over so I can play again.
* I can choose whether I want to play as X or O.


text:
# Shopping App
E-Commerce example for Android with the help of ANdroid Material Design.

### This project have features:-

- Display categories of product (eg Electronic,Furnitures)
- Display products in a given category (TV,Microwave,Vaccum cleaner)
- Show Product Details
- Add any product  to cart and update total item count and amount
- Store cart list in DB

### This project demonstrates

- Reusing Fragments in MVC architecture.
- Material design patterns-Collpsable Toolbar, FAB etc
- Loading and caching image from web URl with help of Glide
- RecyclerView animation with JazzyListAnimation
- View pager 3D cube animation with JazzyView Pager Transformations
- Drag & drop in Recyclerview
- Swipe to dismiss in RecyclerView
- ACRA crash reporting

Screen shots

![Alt text](https://github.com/hiteshsahu/ECommerce-App-Android-/blob/master/Art/nav_drawer.png "Nav")
  ![Alt text](https://github.com/hiteshsahu/ECommerce-App-Android-/blob/master/Art/persistance_storage_onrelaunch.png "Nav")

![Alt text](https://github.com/hiteshsahu/ECommerce-App-Android-/blob/master/Art/home_screen.png "Home")
  ![Alt text](https://github.com/hiteshsahu/ECommerce-App-Android-/blob/master/Art/product_category.png "Products")

![Alt text](https://github.com/hiteshsahu/ECommerce-App-Android-/blob/master/Art/collapsable_header_category.png "Products list")
  ![Alt text](https://github.com/hiteshsahu/ECommerce-App-Android-/blob/master/Art/product_detail_from_cart.png "Products detail")

![Alt text](https://github.com/hiteshsahu/ECommerce-App-Android-/blob/master/Art/checkout_screen_visble_amount.png "Checkout list")
 ![Alt text](https://github.com/hiteshsahu/ECommerce-App-Android-/blob/master/Art/empty_cart.png "Empty cart")

![Alt text](https://github.com/hiteshsahu/ECommerce-App-Android-/blob/master/Art/visivle_total_amount.png "Collapse cart")
  ![Alt text](https://github.com/hiteshsahu/ECommerce-App-Android-/blob/master/Art/visivle_total_amount_from_product_detail.png "Collapsable cart")

![Alt text](https://github.com/hiteshsahu/ECommerce-App-Android-/blob/master/Art/product_detail.png "Collapse cart")
  ![Alt text](https://github.com/hiteshsahu/ECommerce-App-Android-/blob/master/Art/product_detail_suggestions.png "Collapsable cart")

Copyright 2015 Hitesh Kumar Sahu

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

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

repository: arshadalisoomro/ECommerce-App-Android

repo_name: arshadalisoomro/ECommerce-App-Android


text:
# Layouts

Embed or extend views to create a layout.

## Overview

There will be situations, where you would like to use certain views at multiple places in your project and that's where the layout system comes in handy. You can embed the view in another or extend the view to be used for a different view.

### Embed a view

Embed a view by calling an another view in the content body.

```swift
struct ChildView: View {

    var body: Content {
        Paragraph {
            "Hello World!"
        }
    }
}
```

```swift
struct MainView: View {

    var body: Content {
        Document(.html5)
        Head {
            Title {
                "MainView"
            }
        }
        Body {
            /// 1. Embed the child view
            ChildView()
        }
    }
}
```

### Extend a view

Extend a view by using the trailing closure of a view.

```swift
struct MainView: View {

    var content: [BodyElement]

    init(@ContentBuilder<BodyElement> content: () -> [BodyElement]) {
        self.content = content
    }

    var body: Content {
        Document(.html5)
        Head {
            Title {
                "MainView"
            }
        }
        Body {
            content
        }
    }
}
```

```swift
struct ChildView: View {

    var body: Content {
        /// 1. Extend the main view
        MainView {
            Paragraph {
                "Hello World!"
            }
        }
    }
}
```

## Topics

### Layouts

- <doc:View>

repository: vapor-community/HTMLKit

gha_language: Swift

repo_name: vapor-community/HTMLKit


text:
---
app_id: com.github.ryonakano.konbucase
title: "KonbuCase"
summary: "Convert case in your text"
developer: "Ryo Nakano"
homepage: https://github.com/ryonakano/konbucase
help_page: https://github.com/ryonakano/konbucase/discussions
bugtracker: https://github.com/ryonakano/konbucase/issues
dist: flatpak
screenshots:
  - https://raw.githubusercontent.com/ryonakano/konbucase/4.1.0/data/screenshots/pantheon/screenshot-light.png
icons:
  "64": https://flatpak.elementary.io/repo/appstream/x86_64/icons/64x64/com.github.ryonakano.konbucase.png
  "128": https://flatpak.elementary.io/repo/appstream/x86_64/icons/128x128/com.github.ryonakano.konbucase.png
color:
  primary: "#485a6c"
  primary-text: "#fff"
price: false
releases:

redirect_from: /com.github.ryonakano.konbucase.desktop/
---

A small text tool app that allows you convert case in your text.

Features include:

Click "Copy to Clipboard" button to copy the all texts in the text view without selecting them

Convert your text between camelCase, PascalCase, Sentence case, snake_case, kebab-case, and space-separated

license: Unlicense

repository: elementary/appcenter-web

gha_language: Ruby

gha_license_id: Unlicense

repo_name: elementary/appcenter-web