text:
## Deployment options

The following section describes general options for deploying Cloudbreak and Cloudbreak-managed clusters.

### Cloudbreak deployment options

In general, Cloudbreak offers a quickstart option, as well as a production deployment option:

[Source]: <> (Source https://docs.google.com/presentation/d/1vo3aZVMX0vx9gHZ5hALgxkGHw3l1PW-bGbxaYjk57Uo/edit#slide=id.p1)

* The **quickstart option** allows you to get started with Cloudbreak quickly, but offers limited flexibility. Use this option for getting started with Cloudbreak. This option is not suitable a production.
* The **production option** is less automated, but offers more configurability. This option is recommended when your production environments.

#### Deployment option cheatsheet

The following table summarizes the available Cloudbreak deployment options:

[Source]: <> (Source https://docs.google.com/presentation/d/1vo3aZVMX0vx9gHZ5hALgxkGHw3l1PW-bGbxaYjk57Uo/edit#slide=id.p1)

The following operating systems are used when launching by using the quickstart option:

[Source]: <> (Source https://docs.google.com/presentation/d/1vo3aZVMX0vx9gHZ5hALgxkGHw3l1PW-bGbxaYjk57Uo/edit#slide=id.p1)

#### Quickstart option for AWS

The quickstart option allows you to instantiate Cloudbreak by using the CloudFormation template. This is the basic deployment option and the easiest to get started with.

[Source]: <> (Source https://docs.google.com/presentation/d/1vo3aZVMX0vx9gHZ5hALgxkGHw3l1PW-bGbxaYjk57Uo/edit#slide=id.p1)

This option utilizes the following AWS services and provisions the following resources:

| Resource | Description | How it is used by Cloudbreak |
|---|---|---|
| [AWS CloudFormation](https://aws.amazon.com/documentation/cloudformation/) | AWS CloudFormation is used to create and manage a collection of related AWS resources. | Cloudbreak is launched by using a CloudFormation template. |
| [Amazon EC2](https://aws.amazon.com/documentation/ec2/) |  Amazon EC2 is used to launch a virtual machine for Cloudbreak. Security groups are used to control the inbound and outbound traffic to and from the Cloudbreak instance. | Cloudbreak automatically provisions a new VM that runs Amazon Linux, installs Docker, and launches Cloudbreak. |
| [Amazon VPC](https://aws.amazon.com/documentation/vpc/) | Amazon VPC is used to provision your own dedicated virtual network and launch resources into that network. As part of VPC infrastructure, an internet gateway and a route table are provisioned: An internet gateway is used to enable outbound access to the internet from the control plane and the clusters, and a route table is used to connect the subnet to the internet gateway. | Cloudbreak provisions a new VPC and subnet, and launches the Cloudbreak VM within it. |
|  [AWS IAM](https://aws.amazon.com/documentation/iam/) | AWS Identity & Access Management (IAM) is used to control access to AWS services and resources. | Cloudbreak provisions the CloudbreakQuickstartRole IAM role that is used during the quickstart deployment. |
| [AWS Lambda](https://aws.amazon.com/documentation/lambda/) | This is a utility service for running code in AWS. | Cloudbreak uses AWS Lambda is for running code when deploying Cloudbreak. |

**Related links**
[Quickstart on AWS](aws-quick.md)

#### Quickstart option for Azure

[Comment]: <> (This info was pulled from https://hortonworks.github.io/cloudbreak-azure-docs/index.html)

The quickstart option allows you to instantiate Cloudbreak by using Azure Resource Manager (ARM) template.

On Azure, resources are organized by using resource groups. When you launch Cloudbreak, you may either select to use an existing resource group or a new resource group is created. The following Azure resources are provisioned within the selected resource group:

* [Virtual network](https://docs.microsoft.com/en-us/azure/virtual-network/virtual-networks-overview) (VNet) securely connects Azure resources to each other. You may either launch Cloudbreak into an existing VPC, or a new VPC is created and added to the resource group.
* [Network security group](https://docs.microsoft.com/en-us/azure/virtual-network/virtual-network-vnet-plan-design-arm) (NSG) defines inbound and outbound security rules, which control network traffic flow.
* [Virtual machine](https://docs.microsoft.com/en-us/azure/virtual-machines/linux/overview?toc=%2Fazure%2Fvirtual-machines%2Flinux%2Ftoc.json) runs Cloudbreak. Based on the ARM template, Azure automatically provisions a new VM that runs CentOS 7, installs Docker, and launches Cloudbreak.
* [Public IP address](https://docs.microsoft.com/en-us/azure/virtual-network/virtual-network-ip-addresses-overview-arm) is assigned to your VM so that it can communicate with other Azure resources.
* [Network interface](https://docs.microsoft.com/en-us/azure/virtual-network/virtual-network-network-interface) (NIC) attached to the VM provides the interconnection between the VM and the underlying software network.
* [Blob storage container](https://docs.microsoft.com/en-us/azure/storage/common/storage-introduction) is created to store Cloudbreak Deployer OS disk's data.

**Related links**
[Quickstart on Azure](azure-quick.md)

#### Quickstart option for GCP

Based on the Cloud Deployment Manager template, GCP automatically provisions a new VM that runs CentOS 7, installs Docker, and launches Cloudbreak.

The following basic resources are provisioned on you GCP account:

* Network
* Subnetwork (subnet)
* Route (routing table)
* Firewall
* VM instance
* Config
* Config waiter

The config and config waiter are scripts used for deploying Cloudbreak. The startup config script is watched by the waiter script and updated when the deployment in up and running or if it failed to start. The startup waiter script keeps the deployment "in-progress" until the startup script that's running on the created machine update the cbd-deployment-startup-config value to "success" or "failed".

**Related links**
[Quickstart on GCP](gcp-quick.md)

#### Production deployment option

The option to install Cloudbreak deployer manually on your own VM is available for all cloud providers.

This option:

 * Allows you to provide your own VM with CentOS 7, RHEL 7, or Oracle Linux 7
 * Allows you to use your custom virtual network (On Azure this is also possible with the quickstart option)
 * Requires you to install Docker
 * Requires you to download the cbd tarball, extract it, and configure Cloudbreak deployer

**Related links**
[Launch on AWS](aws-launch.md)
[Launch on Azure](azure-launch.md)
[Launch on GCP](gcp-launch.md)
[Launch on OpenStack](os-launch.md)

### Cluster deployment options

On a basic level, Cloudbreak offers three cluster deployment options:

* Basic cluster deployment with prescriptive options
* Advanced cluster deployment with customized options
* Enterprise HDP cluster deployment with a data lake and attached workload clusters:

> The data lake deployment option is technical preview.

**Related links**
[Setting up a data lake](data-lake.md)


text:
# Neel | HTML/JS GUI Library for Nim

Neel is a Nim library for making lightweight Electron-like HTML/JS GUI apps, with full access to Nim capabilities and targets any of the C, C++, or Objective-C backends.

> As of v0.2.0: Neel opens a new Chrome session in app mode and allows the Nim backend and HTML/JS frontend to communicate via JSON and websockets.

Neel is designed to take all the hassle out of writing GUI applications. Current Features:

* Eliminate 99% of boilerplate code
* Automatic routes
* Automatic type conversions (from JSON to each proc’s param types)
* Simple interface for backend/frontend communication
* Cross-platform (tested on Mac, Windows, and Linux)

Neel is inspired by [Eel](https://github.com/samuelhwilliams/Eel), its Python cousin.

----------------------

## Introduction

Currently, Nim’s options for writing GUI applications are quite limited and if you wanted to use HTML/JS instead you can expect a lot of boilerplate code and headaches.

Neel is still in its infancy, so as of right now I don’t think it’s suitable for making full-blown commercial applications like Slack or Twitch. It is, however, very suitable for making all kinds of other projects and tools.

The best visualization libraries that exist are in Javascript and the most powerful capabilities of software can be harnessed with Nim- math, machine learning, etc. The goal of Neel is to combine the two languages and assist you in creating some killer applications.

## Installation

Install from nimble:
`nimble install neel`

## Usage

### Directory Structure

Neel applications consist of various web assets (HTML,CSS,JS, etc.) and various Nim files.

All of the web assets need to be placed in a single directory (they can be further divided into folders inside it if necessary). **As of v0.2.0, Neel serves static files up to 5 directories deep.**

```
main.nim            <---- Nim files
database.nim
other.nim
webAssetsFolder/    <---- Web assets folder
  index.html
  css/
    style.css
  js/
    main.js
```

### Developing the Application

#### Nim / Backend

We begin with a very simple example, from there I'll explain the process and each part in detail.

(main.nim)
```nim
import neel #1

exposeProcs: #2
    proc echoThis(jsMsg: string) =
        echo "got this from frontend: " & jsMsg
        callJs("logThis", "Hello from Nim!") #3

startApp(startURL="index.html",assetsDir="web") #4
```

##### #1 import neel

When you `import neel`, several modules are exported into the calling module. `exposedProcs` and `startApp` are macros that require these modules in order to work properly.

One of the exported modules includes `json`, which is needed should you have params in your procedures that are of type `seq` or `table`. More on this below.

##### #2 exposeProcs

`exposeProcs` is a macro that *exposes* specific procedures for javascript to be able to call from the frontend. When the macro is expanded, it creates a procedure `callProc` which contains **all exposed procedures** and will call a specified procedure based on frontend data, passing in the appropriate params (should there be any).

The data being received is initially **JSON** and needs to be converted into the appropriate types for each param in a procedure. This is also handled by the macro. Unfortunately, due to Nim's static type system there's a limit on what's able to be converted programmatically.

Accepted param types for all *exposed procedures* are:
* string, int, float, bool
* seq[JsonNode]
* OrderedTable[string, JsonNode]

This above macro produces this result:

```nim
proc callProc(jsData: JsonNode): Option[JsonNode] =
    var
        procName = jsData["procName"].getStr
        params = jsData["params"].getElems
    case procName
    of "echoThis": return echoThis(params[0].getStr)
```

Don't worry, you're still able to pass complex data as your params if need be, such as a `seq` within a `seq` containing a `table` of arbitrary types. Just have that param be either of type `seq[JsonNode]` or `OrderedTable[string, JsonNode]` and manually convert them within your procedure. Converting JSON is very simple, refer to the [documentation](https://nim-lang.org/docs/json.html).

I'm sure this is obvious, but it's much cleaner to have your exposed procedures call procedures from other modules.
Example:
```nim
exposeProcs:
    proc proc1(param: seq[JsonNode]) =
        doStuff(param)
```
Just make sure that **ALL** procedures that stem from an exposed procedure is of type `Option[JsonNode]` *unless* the final procedure **will not** be calling javascript. This will make more sense below.

##### #3 callJs

`callJs` is a macro that takes in at least one value, a `string`, and it's *the name of the javascript function you want to call*. Any other value will be passed into that javascript function call on the frontend. You may pass in any amount like so:

```nim
callJs("myJavascriptFunc",1,3.14,["some stuff",1,9000])
```

The above code gets converted into JSON and returned via the `some()` procedure (part of the [Options module](https://nim-lang.org/docs/options.html)). All procedures that stem from an exposed procedure need to be of type `Option[JsonNode]` **if** the the final procedure is calling javascript.

**Currently, `callJs` only works as a return value after a procedure is called from the frontend.**

##### #5 startApp

`startApp` is a macro that handles server logic, routing, and Chrome web browser. As of v0.2.0, `startApp` takes 7 params.
example:
```nim
startApp(startURL="index.html",assetsDir="web",portNo=8000,
            position= [500,150], size= [600,600], chromeFlags= @["--force-dark-mode"], appMode= true)
            # left, top          # width, height
```

* `startURL` : name of the file you want Chrome/Browser to open.
* `assetsDir` : name of your web assets folder.
* `portNo` : specifies the port for serving your application (default is 5000)
* `position` : positions the *top* and *left* side of your application window (default is 500 x 150)
* `size` : sets the size of your application window by *width* and *height*(default is 600 x 600)
* `chromeFlags` : passes any additional flags to chrome
* `appMode` : if "true" (default) Chrome will open a new session/window in App mode, if "false" a new tab will be opened in your **current default browser** - which can be very useful for debugging.

#### Javascript / Frontend

The Javascript aspect of a Neel app isn't nearly as complex. Let's build the frontend for the example above:

(index.html)
```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Neel App Example</title>
    <script src="neel.js"></script> <!-- always include neel.js in your <head>! -->
</head>
<body>
    <h1>My First Neel App</h1>
    <script src="main.js"></script>
</body>
</html>
```
(main.js)
```javascript
neel.callProc("echoThis","Hello from Javascript!")

function logThis(param){
    console.log(param)
}
```
The first thing you'll notice is we've included a script tag containing `neel.js` in the <head> section of our HTML page. This allows Neel to handle all of the logic on the frontend for websocket connections and function/procedure calls.

`callProc` is a function that takes in at least one value, a `string`, and it's *the name of the Nim procedure you want to call*. Any other value will be passed into that Nim procedure call on the backend. **You must pass in the correct number of params for that proc, in order, and of the correct types.** Example:

frontend call to backend:
```javascript
neel.callProc("myNimProc",1,3.14,["some stuff",1,9000])
```
must match the result of the `exposeProcs` macro:
```nim
of "myNimProc": return myNimProc(params[0].getInt,params[1].getFloat,params[2].getElems)
```

Going back to our first example, when `index.html` is served, Javascript will call the `echoThis` procedure and pass "Hello from Javascript!" as the param. This will echo the string in the terminal. Then, Nim will call the `logThis` function and pass "Hello from Nim!". Neel handles the JSON conversion, calls the function and passes in the param.

Now open the console in Chrome developer tools and you should see "Hello from Nim!".

#### Compilation Step

When compiling your Neel application, make sure you compile with `--threads:on`
example:
```nim
nim c -r --threads:on main.nim
```

## Documentation
coming soon
## Examples

A simple Neel app that picks a random filename out of a given folder (something impossible from a browser):

[Random File Picker](https://github.com/Niminem/Neel/tree/master/examples)

## Future Work

The vision for this library is to eventually have this as full-fledged as Electron for Nim. I believe it has the potential for developing commercial applications and maybe one day even rival Electron as a framework.

Overall, Nim is the best programming language in existence. My hope is that while Neel improves in its development, Nim can get exposure that it rightfully deserves.

Neel will receive updates once per month, beginning with v0.3.0 by the end of November with plenty of improvements and added features.

license: MIT

repository: konradmb/Neel

branch_name: refs/heads/master

extension: md

gha_license_id: MIT

license_type: permissive

repo_name: konradmb/Neel


text:
[![996.icu](https://img.shields.io/badge/link-996.icu-red.svg)](https://996.icu)
[![LICENSE](https://img.shields.io/badge/license-Anti%20996-blue.svg)](996.ICULICENSE)
[![LICENSE](https://img.shields.io/badge/license-Noyark-green.svg)](LICENSE)
![LICENSE](https://img.shields.io/badge/version-0.3.0NEW-blue.svg)
![master](https://img.shields.io/badge/build-passing-green.svg)
[![zh](https://img.shields.io/badge/readme-chinese-orange.svg)](chinese.md)
![avatar](logo.jpeg)

### * basic introduction
* This `xml framework` simplifies the operation of the persistence layer configuration file and supports the object's IOC, which greatly simplifies the operation and is compatible with the usual `dom4j` operation, which allows the framework to be used in parallel with the traditional method (of course, the framework already provides The corresponding method, you must use the framework method to add elements, but these methods have a simplified operation of the framework, there are original operations. Because adding elements in the framework can register elements to the mapping factory, and is compatible with the operation of the selector) And added a selector function, a complete element selection mechanism, selector:: with 6 major features::
`Dynamic creation (DC) ` `concurrent read and write (RW) ` `reverse control (RPC) ` `automatic assembly (AA) ` ` select conversion (SC) ` `object pool (OP) ` `search package instance ( SPI)`
---

* DC:
 Chinese (dong tai chuang jian), meaning that objects can be created dynamically and created according to various forms of configuration files, which is very flexible
* RW:
Chinese (jian tong du xie) means that it can be compatible with the newly added elements of the document that has been written, and will not refresh the original created document.
* RPC:
 Chinese (fan lu kong zhi), meaning the rules of the elements are created by path and reflection, thus simply adding elements
* AA:
 Chinese (zi dong zhuang pei), meaning that the maven dependencies can be automatically assembled by loading the framework driver.
* SC:
 Chinese (xuan ze zhuan huan), built-in converter can convert dom4j Element object into SElement recording element geometry information, and then used for selector hash query element
* OP:
Chinese (dui xiang chi), the object pool can store the original object, the previously created object can be reused
* SPI:
 Chinese (sou bao shi li), through the package path of the configuration file, search for the class with annotations, instantiate the object according to the annotation, and create the file at one time
```java
 / / Development use object in EQuery:
/**
Starting with version 028, you must use this method to load the driver. All the driver information is in
Driver.properties
*/
Core.start();

/*
In the process of use, the file directory of the factory method of XMLDomFile can omit the .xml. The second parameter is the root element. If the same object has been created directly, and the document is read again, the parameter can be omitted, namely:
getXMLQuery("a",false), the third is whether to enable thread safety type
If you don't want to create a new document and use an existing document, and you don't want to remove the original element, you can use the getDefaultXml method, then retain the original element, and you can get it. Later addition will only refresh the newly added element. Fill in the file attribute directly, of course, if there is a special path, you can add the input stream in the second parameter, the first parameter plus the path information as clear as possible, most of the special path is to read the resources folder, then the first path Can get the path with getClass
*/
XMLDomFile xdf = InstanceQueryer.getXMLQuery("a.xml","root",false);

XMLDomFile xdf = InstanceQueryer.getXMLQuery("a",this);
/*
At the same time, the development interface of automatic assembly is opened. Its function is to use this method if your jar package is imported, and you can use this method and provide their xml configuration file. This method will automatically read and load into pom.xml.
*/
SetMavenJar.getInstance().setDefaultMaven(this, "fill in the configuration file name, format and System.Maven.xml");
/*
File creation by reflection
There are two ways to create reflections, one class is annotated, and one class is unannotated.
But all need to inherit a ReadingXML class
readingXML has a number of constructors that correspond to the four constructors listed above (getDefaultXML, getXMLQuery...)
Use getXMLQuery demo here
*/
//no annotation type
Class Test1 extends ReadingXML{
Public Test1(String file,String root){
Super(file,root);
}
@path("a.b.c.d")
Public String A = "1";
}
/*
After instantiation, then call the save method
Can create file and xml element build

There are also EQuery expressions:

Note that including ':’

Addnew: Same as addElements function, does not require index attribute, can be omitted

Addchild: Same as addChild, you need to add the index attribute: indexs={}

Addchilds: the same function as addElementsIfExistsParent, requires the indexs property

Addelements: same as the function of addElements, does not require the indexs attribute

Case:
*/
 @Path(path = "a.b.c")

 Public String aString = "1";

 @Path(path="addchild:a.b.c",indexs= {0,0})

 Public String ab = "2";

 @Path(path="addchilds:a.b.c/d/e",indexs= {0,0})

 Public String[] abs = {"1","2","3"};

 @Path(path="addelements:a.b.c/d/e",indexs= {0,0})

 Public String[] absd = {"1","2","3"};

/ / Starting with version 031, support for all array types
```
```java
/*
In addition, there is an annotation form like this
*/
Package simpleXML.test;

Import cn.gulesberry.www.reflect.ReadingXML;
Import net.noyark.www.annocations.Path;
Import net.noyark.www.annocations.XMLFile;

@XMLFile(fileName="a.xml",root="root")
Public class Test extends ReadingXML{

@Path(path = "a.b.c")
Public String aString = "1";

@Path(path="addchild:a.b.c",indexs= {0,0})
Public String ab = "2";

@Path(path="addchilds:a.b.c/d/e",indexs= {0,0})
Public String[] abs = {"1","2","3"};

@Path(path="addelements:a.b.c/d/e",indexs= {0,0})
Public String[] absd = {"1","2","3"};

@Path(path="addelements:a.b.c/d/e",indexs= {0,0})
Public String[] absd1 = {"1","2","3"};

}
```
> _ In addition to the built-in startXML configuration file, write _
> After version 030, support only writes the path of the parent package, the sub-package path is scanned by default
```java
<xml-instance>
<!-- Test-Class -->
<xml-file package="simpleXML.test"/>
</xml-instance>
```
So configured
> In addition, the auto-assembly object can be assembled like this, still in the xmlStart configuration file
```xml
<xml-instance>
<!-- Predefined objects -->
<xml>
<file name="default"></file>
<root name="root" ></root>
<is-sync state="false"></is-sync>
</xml>
</xml-instance>
```

Only need to use after
```java
XMLDomFile xdf = InstanceQueryer.getXMLQuery("default",this);
```
Get the object
# How to select language using epath xml
## epath is divided into 5 language structures:
```
Starting with version 0.0.2, spaces are replaced with with, ie:
Select in a with [name];
Or select in a with name;
```
### 1. Wild match expression
```
The wildcard expression has two keywords: the all and root keywords. Use the all keyword to get all non-root Element objects.
The root keyword can get the root node
All and root combination: all, root Get all nodes
```
### 2. One-dimensional expression
```
One-dimensional expressions are composed of values and groups, also known as single-group expressions, single-stack expressions, describing one-dimensional expressions that require a keyword to be connected.
 The basic syntax is: select in value group
 The following can also be written:
 Select in value [group]
 A single set of expressions has 13 group keywords, which are used to describe the feature information indicated by the value (or type).
 The keyword for a single set of expressions is called a single set of keywords, and most of the keywords here are only used in single-group expressions.
 Single set of expression keywords:
 One elements on under ons unders friends ids e_name text parent
 Name *path
The expression syntax:
Other [selector type]
The selector type is an auxiliary selection type with the following auxiliary selection types.

One Select an example: a[0].b[0] [one];
Elements select multiple a[0].b[0].c [elements];
On selects the upper element of the element (same level) a[0].b[0].c[0] [on];
Under selects the following element of the element (same level a[0].b[0].c[0] [under];
Ons selects all elements above the element (same level) a[0].b[0].c[0] [ons];
Unders selects all elements below the element (same level) a[0].b[0].c[0] [unders];
Friends select all sibling elements a[0].b[0].c[0] [friends];
Ids selects the element IDVALUE [ids] by the ID attribute;
E_name selects ELEMENTNAME [e_name] by the name of the element element;
Text Select ELEMENTTEXT [text];
Parent gets the parent element a[0].b[0].c[0] [parent]
Name Get the element by name name [name]
*path gets the element by the element pointer, plus 1 to the pointer
See getElementByIndexPointer
Method a.b [*path]
Case:
<root>
<a>
<b></b>
<b></b>
</a>
</root>
Select the element with the name a:
a [name]
```
### 3. Two-dimensional expression
```
The expression syntax:
Path/name middle [middleType];
Middle is an attachment selection limit, and middleType is an attachment selection restriction type.
There are the following subsidiary selection restriction types:
Text Select element by text and path a[0].b[0].c[0] ExampleText [text];
Namespace selects the element by namespace a[0].b[0].c[0] prefix,uri [namespace];
Key is selected by the attribute key and supports multiple keys a[0].b[0].c[0] key1, key2, key3 [key];
Value is selected by the value of the attribute, supporting multiple values a[0].b[0].c[0] value1, value2 [value];
Key=value is selected by the attribute and value of the attribute, supporting multiple keys and values a[0].b[0].c[0] key1=value1,key2=value2 [key=value];
Key,only Select by the attribute of the attribute, where the role of the only keyword is to obtain the element of the element must correspond to the specified key one by one, without adding, as long as the specified is required, the syntax is the same as above
Value,only Same as above
Text, name is selected by the name of text and element, a exmapleText [text, name];
Uri queries through the URI of the namespace a[0].b[0].c[0] prefix [prefix];
Prefix queries through the prefix of the namespace a[0].b[0].c[0] uri [uri];
```
### 4. Multidimensional expression
```
Multidimensional expressions can query more complex conditions, where keywords can be spliced at will, except
Grammar:
? is optional
All/path/name middle... [all/name/path,?only,middleType...]
Name and only keywords, regex series must be in front, and name is in front of only, regex is not limited
Key here
textRegex [whether or not text is enabled for regular expressions]
attrRegex [whether key or value is enabled, a single key=value regular expression, currently does not support multiple key=value regulars]
All
Path
Name
Namespace
Prefix
Uri
Only
Key
Value
Basically the same
Select in path with namespace with key with [path,namespace,key]
```
### 5.with keywords
```
The with keyword has the same effect as a space, used to split the grammar, updated from epath 002, thus guaranteeing grammatical freedom
At the same time, the epath syntax states that spaces and with cannot coexist.
Such as:a[0].b[0] with [one]
```
### 6. Prefix words,
```
Select in optional, can have braces
Select in {a[0].b[0] with [one]}
```
### 7.none keyword
```
Select in{all with none with a with [all,only,attrRegex,none,key]}
This sentence is actually looking for a name element from the regular elements of all elements.
```
### 8. Pointer U-turn
```
Seek in path to index can implement pointer turn
Such as:
Seek in a.b to 0;
```
### 9.epathshell
#### EPATHSHELL stipulates that you must use with
```
Call Core.startEPathShell();
You can use the epath code in the console.
Epath shell directive:
Source to import epath file
Use in replace read file
Exit(); exit the program
Print print object, you can directly print the function by print, or print the result of an expression and a string (enclosed by "" or '', does not support splicing);
Alias<name> (on) select in... is an alias for the queried set of element objects, which can be used in the next statement
Select in alias name query element collection by alias
Print select in alias name
...
Pathes get path
Indexs get coordinates
Use the two together to get the path and coordinates
Such as:print select in pathes with indexs with *;
Define function: func name (a,b,c){
Select in @a with @b with @b
};
?: expression, preceded by a boolean expression, followed by two code segments, when true, then executed before, when is false
Execution behind
At the same time, a Boolean expression is specified here.
Sizebig sizesmall == !empty empty
Sizebig left is larger than right a sizebig b
Sizesallall left smaller than right a sizesmall b
== Elements are exactly equal a == b
!empty is not empty a !empty
Empty is empty a empty
Nesting is currently not supported
Import function library
Sh library file path
```
### 10.Function object
```
Bring your own method: excute () method,
Can be executed immediately when the function is declared, but does not support immediate execution of complex statements.
Logical judgment and storage variables do not support immediate execution
```
### 11. Native function table
```
Currently the native function has
Exit function
Excute function
...
```
### 12. Operators [epath only supports native statements]
```
Logical operators: sizebig sizesmall == !empty empty
Function operator: in to
Logical control: ?: (select in *==select in * ?print "1":print "2")
Importer: sh (filename) source (to filename) use (in filename)
Connector: (a) with (b)
Multi-level separator:
Query character: select (in)
Output: print (select in .../""/'')
Memory import character: alias<> func (name(){};)
Memory export character: select in alias (name), name();
````
### 13.Script file
```
The epath script file is a .epath suffix file, which is imported by source. Note that the import only supports epath syntax.
Select in *;
Select in a with name;
The epath shell function script file is .func, imported via sh, note that the import supports the epath shell and epath syntax, and the code segment must be split by function.
#epath shell equery.func
Func test(){
Select in *;
};
Func test1(){
Select in * == select in *?print "1":print '2';
};
```

The final reminder is that you must use the maven project to import the plugin. Finally, the configuration file is in the src/main/resources/ directory. You need to copy the configuration file to your directory.

How to import the plugin?
```xml
<!-- link jar -->
<dependency>
  <groupId>net.noyark</groupId>
  <artifactId>equery-framework</artifactId>
  <version>0.3.3</version>
</dependency>
<!--Link private service-->
<repositories>
 <repository>
    <id>nexus</id>
    <name>Team Neux Repository</name><url>http://www.noyark.net:8081/nexus/content/groups/public/</url>
    </repository>
</repositories>
<pluginRepositories>
    <pluginRepository>
      <id>nexus</id>
      <name>Team Neux Repository</name>
      <url>http://www.noyark.net:8081/nexus/content/groups/public/</url>
    </pluginRepository>
 </pluginRepositories>

```

web: [web]

doc: [doc]

maven: [maven]

[web]: http://magic.noyark.net

[doc]: http://sxml.noyark.net

[maven]: http://www.noyark.net:8081/nexus

[chinese.md]: chinese.md

license: ICU


text:
Ten Ideas a Day
===============

This project comes out of a podcast episode that I was listening to.
An episode from James Altucher, and also an article or two he wrote.
Well, from this guy I find very interesting to listen to, and who is doing things I'd like to be doing but am not. Damn.
Anyway, any journey starts with a first step and this will be it.
Yeah, this readme. Hm. Ok, what is it all about?

Basically, getting into the habit of writing down 10 ideas a day.
Can be about anything, but has to be 10.
And if you have a hard time coming to 10, well, make it 20.
Yes, 20. So that 10 doens't feel like that hard limit that blocks the creative juices.

Here is the plan:

- make a file for each day (named like yyyy-mm-dd_ideas.md)
- write down the contents with one heading per idea (and some content down there)
- add the file to the project
- commit and push to GH.

And then let's see how it goes.

For keeping track, I'll use Habitica and add a "daily" to it. Yeah, let's add more gamification to my life.

Phil

References
----------

(http://www.jamesaltucher.com/2014/05/the-ultimate-guide-for-becoming-an-idea-machine/)

(http://www.chriswinfield.com/ideas/)

(http://www.jamesaltucher.com/2015/01/faq-on-how-to-become-an-idea-machine/)


text:
# JHipster Console Bootstrap

Run the following commands to set up the JHipster Console using the `jhipster/jhipster-console` image from the Docker Hub:
```
mkdir conf
curl -o conf/logstash.conf https://raw.githubusercontent.com/jhipster/jhipster-console/master/log-monitoring/log-config/logstash.conf
curl -o docker-compose.yml https://raw.githubusercontent.com/jhipster/jhipster-console/master/bootstrap/docker-compose.yml
docker-compose up -d
```

repository: nodje/jhipster-console

repo_name: nodje/jhipster-console


text:
# Froglet Theme

## Froglet Plugins

Froglet adds three sets of Theme Plugin helpers to simplify repetitive tasks.
The goal of these is to split some basic theme configuration with the
overrides we'd expect to use in Drupal. The directory structure is here:

```
|-- includes
    |-- admin.theme.inc
    |-- blocks.theme.inc
    |-- content.theme.inc
    |-- field.theme.inc
    |-- form.theme.inc
    |-- layout.theme.inc
    |-- media.theme.inc
    |-- misc.theme.inc
    |-- navigation.theme.inc
    |-- node.theme.inc
    |-- suggestions.theme.inc
    |-- user.theme.inc
    |-- views.theme.inc
|-- src
    |-- CustomTools
        |-- CustomTools.php
    |-- FrogletTools
        |-- FrogletTools.php
    |-- Widgets
        |-- Widgets.php
```

To guarantee this theme is as update-able as possible, all `./includes`,
`src/CustomTools`, `src/Widgets` directory code are considered to be
project-specific code. What this means is that you have a safe assumption of
putting overrides here that have no effect on ongoing development of the Froglet
project as a whole. Simply put, you're safe to "hack Froglet core" here.

### Configuration

`Froglet.php` includes a set of global constants configuration specific to
a installation of Froglet:

* `THEME_NAME`: The Drupal theme name, default is set as Froglet.

Be aware that this configuration should be updated based on your Froglet.
If you change these variables of your theme, these `const` should be updated.

### Usage

If you have an additional helper function you'd like to include in your app,
simply extend the functionality of `FrogletTools.php` in `CustomTools.php`:

```php
class CustomTools extends FrogletTools {};
```

This step will make sure any changes to your theme are not lost if you update
Froglet in the future.

CustomTools have already been added to individual `theme.inc` files, however
if you'd like to use the Tools elsewhere in PHP simply include the namespace to
the file (or your custom Tools):

```php
use Drupal\froglet\CustomTools\CustomTools;
```

Now whenever you wish to use a helper:

```php
CustomTools::yourHelperFunction();
```

Note this usage assumes you've declared a public static function and that it's
return is not tied specifically to the context of the instance. If you need a
more context specific approach, consider using public functions and declaring
your tools as an instance:

```php
$tools = new CustomTools;
$tools->yourHelperFunction();
```

repository: frogletjs/froglet

repo_name: frogletjs/froglet


text:
# react-build-cache
Clean reactjs cache in build version
## Getting started

`npm install react-build-cache -g`

## Usage

After your generate build files just execute react-build-cache on root of reactjs project

## How its works
When a new build is generated, reactjs to improve the process of generating a new build checks the project files and generates only those files that have been modified based on the previous build.
When publishing the project on a server, whether due to the browser or some CDN, even clearing the cache, it may happen that the user continues with an old version of the project on the device.
To solve this problem, I developed a very simple lib.
At the end of the build, using the fs library, I check the linkeds files in the index.html that is located inside the build folder, and add a version code to the links. This will cause both the browser and the CDN to update the website cache.

repository: geeknection/react-build-cache

repo_name: geeknection/react-build-cache


text:
# Mode

## A Help-Seeking Slackbot designed for newcomers to large organizations.

Coming into a large Slack workspace, it can be near-impossible to find the channels or people to reach out to in order to gain relevant info. This app attempts to alleviate this through frequency analysis: in this system, mentions map directly to relevancy.

In Slack, a user can type `/find <query>` to search for the public channels where `query` is most frequently mentioned. Similarly, one can use `/experts <query>` to find the users who most frequently mention `query`.

When a query is made, the bot will return the top few channels or users and the mention count of each.

### Implementation Instructions:

1. [Create a Slack App.](https://api.slack.com)
2. Set Slash Commands to call your routes (e.g. `/find`, `/experts`).
3. Generate an OAuth Access Token.
4. Add the following Permission Scopes: *channels:history*, *channels:read*, *users:read*, *incoming-webhook*.
5. Set the appropriate Environment Variables in your Heroku app (or wherever you choose to run your server) to the Access Token generated in Step 3.
6. Run your server.

repository: cooperbarth/Mode

gha_language: JavaScript

repo_name: cooperbarth/Mode


text:
[Chime](https://github.com/LisiLisenok/Chime) is time scheduler which works on [Vert.x](http://vertx.io/).

_Chime_ is written in [Ceylon](http://ceylon-lang.org/) and to use it with Java _Ceylon verticle factory_
has to be available at class path.

> Note: Vert.x 3.4.1 depends on Ceylon 1.3.0 while Chime 0.2.0 depends on Ceylon 1.3.2.
  It is required to put versions to consistency.

To build the project with Maven it is required:
1. Add dependency on **io.vertx:vertx-core:3.4.1** with excluded dependency on **org.ceylon-lang:ceylon-complete**.
   This is general dependency on Vert.x in Java.
2. Add dependency on **io.vertx:vertx-lang-ceylon:3.4.1** with excluded dependency on **org.ceylon-lang:ceylon-complete**.
   This dependency provides Ceylon verticle factory.
3. Add dependency on **org.ceylon-lang:ceylon-complete:1.3.2**.
   This is required to use Ceylon.

As example, see [pom](pom.xml) in this repository.

This Chime Java example:
* Deploys _Chime_.
* Creates timer with 1 second interval which fires just 3 times.
* Prints timer event to stdout.
* Closes Vert.x when timer completes.

repository: MuhaniAllen/ChimeJavaExample

repo_name: MuhaniAllen/ChimeJavaExample


text:
# MazeProject
Basic maze project with undefined scope

What it does :
  - Generate a 10x15 maze with hexagonal cells
  - Basic interaction with the cells.
    - MouseHover, the cell turns grey
    - MouseClick, the cells turn light grey
    - MouseExit, the cell turn dark grey

 Plan and ideas for future improvement
  - Add a regenerate feature
  - Custumize the size of the maze
  - Add a starting point and an ending point
  - Add a "player" and move throught the maze

repository: ThierryJutras/MazeProject

gha_language: Java

repo_name: ThierryJutras/MazeProject


text:
---
title: Gem-based Plugins and the Frontend
order: 0
top_section: Configuration
category: plugins
---

When authoring a [plugin](/docs/plugins#creating-a-gem){:data-no-swup="true"}
or [theme](/docs/themes) for Bridgetown, you may find
yourself wanting to ensure users of your plugin are able to load in your
frontend assets through esbuild or Webpack (such as JavaScript, CSS, etc.) The best way to
do this is to set up a `package.json` manifest and [publish your frontend code as a package to the NPM registry](https://docs.npmjs.com/creating-node-js-modules#create-the-file-that-will-be-loaded-when-your-module-is-required-by-another-application).

Let's assume you've been building an awesome plugin called, unsurprisingly,
`MyAwesomePlugin`. In your `my-awesome-plugin.gemspec` file, all you need to do is
add the `yarn-add` metadata matching the NPM package name and keeping the version
the same as the Gem version:

```ruby
  spec.metadata = { "yarn-add" => "my-awesome-plugin@#{MyAwesomePlugin::VERSION}" }
```

With that bit of metadata, Bridgetown will know always to look for that package in
the users' `package.json` file when they load Bridgetown, and it will trigger a
`yarn add` command if the package and exact version number isn't present.

The [SamplePlugin demo repo](https://github.com/bridgetownrb/bridgetown-sample-plugin)
includes a `script/release` command you can use to run the test suite, release a
new version of the gem, and release a new version of the NPM package all in one
go. (This will also be present if you set up your plugin using the `bridgetown plugins new` command.)

{%@ Note type: :warning do %}
  #### Make sure you update package.json!

  If you bump up your Ruby version number and forget to bump the NPM package version at the same time, the packages will get out of sync! So remember always to update `version.rb` and `package.json` so they have the same version number.
{% end %}

You will need to instruct your users how to add the plugin's frontend code to their
esbuild/Webpack entry points. For example, they might need to update `frontend/javascript/index.js` with:

```js
import MyAwesomePlugin from "my-awesome-plugin"

const awesomeness = new MyAwesomePlugin()
awesomeness.doCoolStuff()
```

Consider [writing an automation](/docs/automations) to make this process
easier for users.

repository: bridgetownrb/bridgetown

branch_name: refs/heads/main

gha_language: Ruby

repo_name: bridgetownrb/bridgetown


text:
# ccrc-weather-station-uploads
A collection of scripts run to upload images and video from the CCRC weather station.

## Things you'll need
This is missing a couple of external scripts, which should be placed in the same directory and configured by filling in API tokens, secrets, etc.:

- `https://github.com/ohookins/flickr-shell-uploader`
- `https://code.google.com/p/youtube-api-samples/source/browse/samples/python/upload_video.py`

The following scripts use a python2 virtual environment that I've installed at `venv/bin/python`. They also use some music in this directory. I'm using `waltz-flowers-tchaikovsky.mp3` (shut up). Finally, you'll need a fairly new version of ffmpeg for this, as earlier versions don't seem to support passing file metadata using the concat filter. I've tested a static build of 2.8.4. If you'd prefer to change the music or use another copy of python or ffmpeg installed elsewhere, you can change those references in these scripts:

- `custom-youtube.sh`
- `sunrise-youtube.sh`
- `sunset-youtube.sh`
- `overnight-youtube.sh`

The reason I've hardcoded these paths in is that these scripts are scheduled by `get-sun-times.sh`, so they don't have access to $PATH. If you have a better way for me to handle this, please submit a pull request!

Finally, add `get-sun-times.sh` to your crontab using `crontab -e`. Add the following line (I schedule it at 0400, since the overnight script runs at 0410).


text:
# 3d-dataviz

The intention of the project is to create a set of libraries that allow the creation of 3D data visualizations using Python and Blender.

The project will allows you to create basic elements such as chart types, geo-data, labels, grids, etc..


text:
# Monoprice Maker Select v2

```{tags} 3d-printing
```

I bought my first 3D printer from [Amazon](https://www.amazon.com/gp/product/B018GZBC3Y) in 2018 for $300. It's on the
cheaper end but there's a large community behind it.

## Oct '21 Upgrading Parts

First set up parts being upgraded with:

1. [Micro Swiss All Metal Hotend with Slotted Cooling Block](https://www.amazon.com/dp/B01E1HANLS)
1. [DIYE Y Carriage Plate Upgrade](https://www.amazon.com/dp/B07PTD7DHW)
1. [Noctua NF-A4x10 FLX 3-Pin 40x10mm Fan](https://www.amazon.com/dp/B009NQLT0M)
1. [ARCTIC Thermal Pad 120x20x0.5mm](https://www.amazon.com/dp/B086CCPHPP)

I started to get filament jams in the middle of prints. Since I started to take the printer apart I thought it would be a
good idea to get some upgrades in.

I replaced the nozzle and hot end (except for the heat block) with an all-metal version (the original had a small teflon
tube inside the heat break), replaced the carriage plate underneath the bed with a thicker one that better resists warping,
replaced the cheap noisy fans with Noctuas with custom shortened and crimped wires, and added a thermal pad between the
heat sink and the cooling block (there was nothing there before, just metal-on-metal contact).

For crimping the wires I used the following:

* [IWISS IWS-3220M Micro Connector Pin Crimping Tool 0.03-0.52mm² 32-20AWG Ratcheting Crimper](https://www.amazon.com/dp/B078WPT5M1)
* [Glarks 1180 Pieces 2.54mm 2/3/4/5/6/7/8/9 Pin Housing Male and Female Compatible with JST-XHP Connector Kit](https://www.amazon.com/gp/product/B07CTH46S7)
* [Wire Stripper Automatic 3 in 1 Multi-Function Wire Pliers (22AWG-8AWG)](https://www.amazon.com/dp/B08XXL3B7K)

```{imgur-embed} a/X5GBxkk
:og_imgur_id: YJWyMhi
```

## Oct '21 Magnetic Build Plate

I've been using a [220x220mm Borosilicate Glass Bed](https://www.amazon.com/gp/product/B07BHG5HCV) placed on top of the
BuildTak sheet that came with my printer along with glue stick with some success. This upgrade replaces all that with a
magnetic steel sheet which has a layer of PEI on it.

Items needed:

* [FYSETC 3D Printing Buildplate Steel Spring Sheet Bed w/Corner Cut 220x220mm with PEI B Magnetic Mounting Base](https://www.amazon.com/dp/B082WTTD1D)
* Isopropyl alcohol (I used 91%) to remove adhesive residue
* Gloves (I used nitrile gloves) to prevent adhesive from reconstituting on your fingers

```{imgur-embed} a/9dOZSm7
```

https://www.reddit.com/r/3Dprinting/comments/qcfqpk/first_mod_since_buying_my_printer_in_2018/

## Comments

```{disqus}
```

gha_language: Python


text:
# Angular Language Service

The Angular Language Service is a way to get completions, errors,
hints, and navigation inside your Angular templates whether they
are external in an HTML file or embedded in annotations/decorators
in a string. The Angular Language Service autodetects that you are
opening an Angular file, reads your `tsconfig.json` file, finds all the
templates you have in your application, and then provides language
services for any templates that you open.

## Autocompletion

Autocompletion can speed up your development time by providing you with
contextual possibilities and hints as you type. This example shows
autocomplete in an interpolation. As you type it out,
you can hit tab to complete.

There are also completions within
elements. Any elements you have as a component selector will
show up in the completion list.

## Error checking

The Angular Language Service can also forewarn you of mistakes in your code.
In this example, Angular doesn't know what `orders` is or where it comes from.

## Navigation

Navigation allows you to hover to
see where a component, directive, module, etc. is from and then
click and press F12 to go directly to its definition.

## Angular Language Service in your editor

Angular Language Service is currently available for [Visual Studio Code](https://code.visualstudio.com/) and
[WebStorm](https://www.jetbrains.com/webstorm).

### Visual Studio Code

In Visual Studio Code, install Angular Language Service from the store,
which is accessible from the bottom icon on the left menu pane.
You can also use the VS Quick Open (⌘+P on Mac, CTRL+P on Windows) to search for the extension. When you've opened it,
enter the following command:

```sh
ext install Angular.ng-template
```

Then click the install button to install the Angular Language Service.

### WebStorm

In webstorm, you have to install the language service as a dev dependency.
When Angular sees this dev dependency, it provides the
language service inside of WebStorm. Webstorm then gives you
colorization inside the template and autocomplete in addition to the Angular Language Service.

Here's the dev dependency
you need to have in `package.json`:

```json
devDependencies {
  "@angular/language-service": "^6.0.0"
}
```

Then in the terminal window at the root of your project,
install the `devDependencies` with `npm` or `yarn`:

```sh
npm install
```
*OR*

```sh
yarn
```

*OR*

```sh
yarn install
```

### Sublime Text

In [Sublime Text](https://www.sublimetext.com/), you first need an extension to allow Typescript.
Install the latest version of typescript in a local `node_modules` directory:

```sh
npm install --save-dev typescript
```

Then install the Angular Language Service in the same location:
```sh
npm install --save-dev @angular/language-service
```

Starting with TypeScript 2.3, TypeScript has a language service plugin model that the language service can use.

Next, in your user preferences (`Cmd+,` or `Ctrl+,`), add:

```json
"typescript-tsdk": "<path to your folder>/node_modules/typescript/lib"
```

## Installing in your project

You can also install Angular Language Service in your project with the
following `npm` command:

```sh
npm install --save-dev @angular/language-service
```
Additionally, add the following to the `"compilerOptions"` section of
your project's `tsconfig.json`.

```json
  "plugins": [
      {"name": "@angular/language-service"}
  ]
```
Note that this only provides diagnostics and completions in `.ts`
files. You need a custom sublime plugin (or modifications to the current plugin)
for completions in HTML files.

## How the Language Service works

When you use an editor with a language service, there's an
editor process which starts a separate language process/service
to which it speaks through an [RPC](https://en.wikipedia.org/wiki/Remote_procedure_call).
Any time you type inside of the editor, it sends information to the other process to
track the state of your project. When you trigger a completion list within a template, the editor process first parses the template into an HTML AST, or [abstract syntax tree](https://en.wikipedia.org/wiki/Abstract_syntax_tree). Then the Angular compiler interprets
what module the template is part of, the scope you're in, and the component selector. Then it figures out where in the template AST your cursor is. When it determines the
context, it can then determine what the children can be.

It's a little more involved if you are in an interpolation. If you have an interpolation of `{{data.---}}` inside a `div` and need the completion list after `data.---`, the compiler can't use the HTML AST to find the answer. The HTML AST can only tell the compiler that there is some text with the characters "`{{data.---}}`". That's when the template parser produces an expression AST, which resides within the template AST. The Angular Language Services then looks at `data.---` within its context and asks the TypeScript Language Service what the members of data are. TypeScript then returns the list of possibilities.

For more in-depth information, see the
[Angular Language Service API](https://github.com/angular/angular/blob/master/packages/language-service/src/types.ts)

## More on Information

For more information, see [Chuck Jazdzewski's presentation](https://www.youtube.com/watch?v=ez3R0Gi4z5A&t=368s) on the Angular Language
Service from [ng-conf](https://www.ng-conf.org/) 2017.

repository: IgorMinar/angular

gha_language: TypeScript

repo_name: IgorMinar/angular


text:
+++
text = ""
title = "Marriage Preparation"
toggle = false
aliases = [
    "/resources/marriage-preparation/",
]
+++

# About

First and foremost: Contact your parish and your diocese to determine the required marriage preparation procedures (sometimes called Pre-Cana). Typically, Catholic dioceses and parishes require some or all of the following:

* 6 months' notice before your wedding
* meeting(s) with the pastor of your parish
* a workshop/retreat with your diocese
* a FOCCUS Survey
* a workshop on Natural Family Planning

Below are supplemental materials about Catholic marriage, and the domestic life. This list is not comprehensive.

# Classics

Huesman, Rose M. _Saints in Aprons_. Milwaukee: Bruce Pub. Co., 1962. https://archive.org/details/saintsinaprons0000unse

Kelly, George Anthony. _The Catholic Marriage Manual_. Random House, 1958.

Knox, Ronald Arbuthnott. 1957. _Bridegroom and bride_. London: Sheed and Ward.

Sheen, F.J. _Three to Get Married_. Catholic Insight Series. Appleton-Century-Crofts, 1951.

Van Zeller, Hubert. _Holiness for Housewives (and Other Working Women)_. Manchester, N.H.: Sophia Institute Press, 1997.

Von Hildebrand, Alice. _By Love Refined: Letters to a Young Bride_. Sophia Institute Press, 1997.

Lewis, C. S. _The Four Loves._

Pieper, Josef. _Happiness and Contemplation._ Regnery, 1966.

Chesterton, Gilbert Keith. "A Defence of Rash Vows." In _The Defendant_, 1901.

# Popes and Catechisms

Pope Leo XIII. “Arcanum Divinae,” February 10, 1880. http://w2.vatican.va/content/leo-xiii/en/encyclicals/documents/hf_l-xiii_enc_10021880_arcanum.html

Pope Pius XI. “Divini Illius Magistri,” December 31, 1929. http://w2.vatican.va/content/pius-xi/en/encyclicals/documents/hf_p-xi_enc_31121929_divini-illius-magistri.html

"On the Sacrament of Matrimony." _Catechism of the Council of Trent_, pp. 225-236. https://archive.org/details/thecatechismofth00donouoft/page/n241

“The Sacrament of Matrimony.” _Catechism of the Catholic Church_, no. 1601-1666.

_Baltimore Catechism: An Explanation of the Baltimore Catechism of Christian Doctrine_, no. 288-289. http://archive.org/details/baltimorecatechi14554gut

# Etiquette

Fenner, Kay Toy. American Catholic Etiquette. Westminster, Md.: Newman Press, 1965.

Broderick, Robert C. The Catholic Layman's Book of Etiquette. Minnesota, 1959.

Bugg, Lelia Hardin. _The Correct Thing For Catholics_. New York, Cincinnati Benziger Bros., 1892. http://archive.org/details/TheCorrectThingForCatholics

> Page 41 is missing, with the crucial heading, "It is not the correct thing to...". Page 45 is also missing. There is good practical advice in here, but with a heavy caveat that the author had some strong materialistic opinions, like the reception and the engagement ring should be as expensive as possible.

# Prayer books and manuals

Heuser, Herman J. _The Parish Priest on Duty : A Practical Manual for Pastors, Curates, and Theological Students Preparing for the Mission._ New York : Benziger Brothers, 1904. http://archive.org/details/theparishpriesto00heusuoft

Klauder, Alexander Laurence Alphonsus. _Catholic Practice at Church and at Home. The Parishioner's Little Rule Book, a Guide for Catholics in the External Practice of Their Holy Religion._ Boston, Mass., Angel Guardian Press, 1898. http://archive.org/details/catholicpractice01klau

Coomes, A. Francis, and Mary Katherine Murphy. _Mothers' Manual: A Manual of Devotions for Mothers and Expectant Mothers_. St. Louis, Mo.: Queen's Work, 1957.

Pius, Franziskus, and Bertin Roll. _Mother Love: A Manual for Christian Mothers_. New York: F. Pustet, 1951.

Scheuber, Joseph K. _Nazareth: A Book of Counsel and Prayer for the Married_. Dublin, 1948. https://archive.org/details/scheuber-nazareth-1948

Lelen, J. M. _Bride's Manual : A Manual of Catholic Devotions with Mass for Marriage Ceremony and the Nuptial Blessing._ Catholic Book Pub. Co., 1942.

———. _Marriage Sacrament : A Manual of Catholic Devotions with Mass for Bridegroom and Bride._ United States: Catholic Book Publishing Co., 1947.

# Dating and Engagement

"Marriage Preparation Program." CatechismClass. https://www.catechismclass.com/shop/package_detail.php?id=23.

Relyea, Father Isaac Mary. _Honorable Courtship: The Way to a Happy Marriage._ Fatima Youth Conference: Cleveland, OH: The Fatima Center, 2019. https://www.youtube.com/watch?v=3LcQSZ621SQ

Solaro Della Margherita, Giulia, and Charles Constantine Pise. _The Catholic Bride; or Moral Letters Addressed to Julia, Daughter of Count Solaro Della Margarita, on the Occasion of Her Marriage with Count E. Demorri Di Castelmagno._ Translated from the Italian, by C. C. Pise. Baltimore, 1868. http://archive.org/details/TheCatholicBride.

"How to Get Married." The Catholic Columbian, 1881. https://thecatholicnewsarchive.org/?a=d&d=CC18810423-01.2.38&srpos=7

de Blanc, Irvine. _Engagement: The Catholic Way and Engagement: A Guide for Catholic Couples._ 1956.

Grant, Dorothy Fremont. _So! You Want to Get Married._ Milwaukee: The Bruce Publishing Company, 1953.

Kelly, George A. _Dating for Young Catholics._ Garden City, N.Y.: Echo Books, 1965.

Marks, Frederick W. _A Catholic Handbook for Engaged and Newly Married Couples._ 2014.

McEvoy, S. J. Hubert. "Before You Wed." International Catholic Truth Society, 1947 1947. https://lxoa.wordpress.com/2010/09/15/before-you-wed/.

Miller, D. F. _How to Behave with Girl Friends._ 1957.

Miriano, Costanza. _Marry Him and Be Submissive._ St. Benedict, 2016.

———. _Marry Her and Die for Her._ TAN Books, 2017.

Sainte-Foi, Charles. _Mission and Duties of Young Women._ New York: P.J. Kenedy, 1896.

Semmler, Nerius. _For Bride and Groom: A Pre-Nuptial Instruction Based on the Encyclical Letter of Pope Pius Xi, Casti Connubii, December 31, 1930._ Our Sunday Visitor, 1950. https://www.lib.cua.edu/rarebook/node/4391.

# Catechesis/General

“Holy Matrimony.” Fish Eaters (blog). https://www.fisheaters.com/holymatrimony.html.

Solaro della Margherita, Giulia, and Charles Constantine Pise. _The Catholic Bride; or Moral Letters Addressed to Julia, Daughter of Count Solaro Della Margarita, on the Occasion of Her Marriage with Count E. Demorri Di Castelmagno_. Baltimore, 1868. http://archive.org/details/TheCatholicBride

Vuarin, M. _Familiar Instructions on the Holiness and Dignity of the Sacrament of Matrimony: Addressed to Parents and Christian Youth_. Philadelphia : H. & C. McGrath, 1851. http://archive.org/details/FamiliarInstructionsOnTheHoliness

Walter Jewell. _Tell Her You’re a Catholic_, 1949. http://archive.org/details/TellHerYoureACatholic

Cassidy, N. Cronin. _The Nuptial Mass._ The Paulist Press, 1947.

Coakley, Thomas F. "How Catholics Get Married: The Nuptial Mass Explained." International Catholic Truth Society. https://chrcphila.pastperfectonline.com/library/332EFCD1-1CD6-4F79-9D9E-601132994800

———. The Nuptial Mass : Explanation of the Beautiful Rites and Ceremonies of a Catholic Wedding. Catholic Truth Society, 1939.

Kwasniewski, Peter, "New Liturgical Movement: Problems with Weddings and How We Might Remedy Them," New Liturgical Movement, 2019, http://www.newliturgicalmovement.org/2019/04/problems-with-weddings-and-how-we-might.html.

A Vincentian Father. Vocations Explained: Matrimony, Virginity, the Religious State and the Priesthood. Benzinger Brothers, 1897. http://www.gutenberg.org/etext/31311.

Cowan, Louise. "Marriage as a Creative Work." Newsletter of the Thomas More College of Liberal Arts 21 (2003/11/). http://parousians-lsu.blogspot.com/2006/11/marriage-as-creative-work-by-louise.html.

# The Domestic Realm

“The Christian Home: A Guide to Happiness in the Home: Chapter I.” Fish Eaters (blog). https://www.fisheaters.com/home2.html.

“The Domestic Church: The Catholic Home.” Fish Eaters (blog). https://www.fisheaters.com/domesticchurch.html.

Ellis, Alice Thomas. _Home Life_. Royal National Institute of the Blind, 2004.

Trapp, Maria Augusta von. _Around the Year with the Von Trapp Family_. Sophia Institute Press, 2018.

Chesterton, Gilbert Keith. "The Free Family." In _What's Wrong with the World_, 392: Cassell, 1912.

Drouet, F. _Mothers of the Saints_. New York: Paulist Press, 1915.

Gerrard, Thomas J. Schmiedeler Edgar. Marriage and Parenthood: The Catholic Ideal. J.F. Wagner: New York, 1937.

Jarrett, O. P. Bede. "The Catholic Mother." International Catholic Truth Society, 1958. https://lxoa.wordpress.com/2010/09/15/the-catholic-mother/.

Leifeld, Wendy. _Mothers of the Saints : Portraits of Ten Mothers of the Saints and Three Saints Who Were Mothers_. Manila: Paulines, 1991.

Lejeune, P. Ryan Francis A. _Counsels of Perfection for Christian Mothers_. St. Louis: B. Herder, 1913.

# Fertility, Health, & Intimacy

“Allay Women and Family Resources.” https://www.facebook.com/allayresources/

Weschler, T. _Taking Charge of Your Fertility: The Definitive Guide to Natural Birth Control and Pregnancy Achievement_. HarperCollins, 2001.

# Philosophy

Chesterton, Gilbert Keith. **_What’s Wrong with the World_**. Cassell, 1912. http://www.gutenberg.org/ebooks/1717.

Pieper, Josef. **_Happiness and Contemplation_**. Regnery, 1966.

Louise Cowan, “**Marriage As a Creative Work**,” Newsletter of the Thomas More College of Liberal Arts 21 (November 2003), http://parousians-lsu.blogspot.com/2006/11/marriage-as-creative-work-by-louise.html.

# Canon Law

Ayrinhac, H. A., and P. J. Lydon. _Marriage Legislation in the New Code of Canon Law._ New York : Benziger Brothers, 1918. http://archive.org/details/marriagelegislat00ayriiala.

Boyle, David J. _The Juridic Effects of Moral Certitude on Pre‑Nuptial Guarantees._ The Catholic University of America Press, 2014/03/31/, 2014. https://www.amazon.com/Juridic-Effects-Certitude-Pre%E2%80%91Nuptial-Guarantees/dp/0813223393/ref=olp_product_details?_encoding=UTF8&me=.

Viscont, Antonius. _De Matrimonio Rato Et Non Consummato._ Rome, 1928. https://www.worldcat.org/title/de-matrimonio-rato-et-non-consummato/oclc/44946768.

Wells, Samuel Roberts. _Wedlock; or, the Right Relations of the Sexes: Disclosing the Laws of Conjugal Selection, and Showing Who May, and Who May Not Marry._ 1869.

White, Robert J. _The Legal Effect of Ante-Nuptial Promises in Mixed Marriages._ American Ecclesiastical Review, 1932.

———. "Canon Ante-Nuptial Promises and the Civil Law." Vol. 91, Wash., D.C.: Catholic University of America Canon Law Studies, 1934.

Woywod, Stanislaus. _The New Canon Law: A Commentary and Summary of the New Code of Canon Law._ J.F. Wagner, 1918. https://books.google.com/books?id=zTtHAQAAMAAJ.

Wraszczak, Chester Francis. _The Betrothal Contract in the Code of Canon Law (Canon 1017)._ Washington, D.C.: Catholic University of America Press, 1954.

# Mixed Marriages

A mixed marriage is a marriage between a Catholic and a non-Catholic. Before the 1960s, mixed marriages were strongly discouraged across the board by the Church, and required a dispensation. The 1917 Code of Canon Law lists additional requirements (commonly called "The Promises"), such as: a promise from the non-Catholic spouse that any future children would be raised Catholic with no interference, and a promise that the Catholic spouse would do their best to convert the non-Catholic spouse. These conditions, albeit significantly watered down, still appear in the 1983 Code of Canon Law.

A wonderful example of how grave mixed marriages were considered can be found in Walter Jewell's book (citation below).

Walter Jewell. _Tell Her You’re a Catholic_, 1949. http://archive.org/details/TellHerYoureACatholic.

Fish Eater also includes a discussion of mixed marriages on their "Holy Matrimony" page.

“Holy Matrimony.” Fish Eaters (blog). Accessed June 3, 2019. https://www.fisheaters.com/holymatrimony.html.

repository: sharontherese/latin-mass-wedding

gha_language: Shell

repo_name: sharontherese/latin-mass-wedding


text:
  @dotmind/rn-shadow-generator

  React Native Shadow Generator to quickly generate shadow of your components. Builded by .mind.io

## Menu

- [Menu](#menu)
- [🚀 Roadmap](#-roadmap)
- [🔍 Preview](#-preview)
- [💻 Installation](#-installation)
- [👷♂ How it's work](#-how-its-work)
  - [ShadowView usage](#shadowview-usage)
  - [generateShadow usage](#generateshadow-usage)
- [🧪 Example app](#-example-app)
- [⚡ Contributing](#-contributing)
- [🔐 License](#-license)

## 🚀 Roadmap

* [ ] Android full compatibility (shadowOffset support)

## 🔍 Preview

![preview](https://raw.githubusercontent.com/dotmind/rn-shadow-generator/master/examples/preview.png)

## 💻 Installation

```bash
yarn add @dotmind/rn-shadow-generator
```

or

```bash
npm i @dotmind/rn-shadow-generator --save
```

## 👷♂ How it's work

### ShadowView usage

```javascript
import { ShadowView } from '@dotmind/rn-shadow-generator';

const BasicComponent = () => {
  return (
    <ShadowView>
      <Text>My Shadow View</Text>
    </ShadowView>
  );
}

const MyCustomComponent = () => {
  return (
    <ShadowView level={4} shadowColor={'#000'} direction={'bottom'}>
      <Text>My Shadow View</Text>
    </ShadowView>
  );
}

```

| props | description | required | default value |
|-|-|-|-|
| level | Increase shadow dimensions | false | 4 |
| shadowColor | Change shadowColor style attribute | false | #000 |
| direction | Change shadow direction | false | bottom |

### generateShadow usage

Returns a full shadow object depending on OS (iOS or Android).

```javascript
import { generateShadow } from '@dotmind/rn-shadow-generator';

const BasicComponent = () => {
  return (
    <View style={{ ...generateShadow() }}>
      <Text>My Shadow View</Text>
    </View>
  );
}

const MyCustomComponent = () => {
  return (
    <View style={{ ...generateShadow({ level: 4, shadowColor: '#000', direction: 'bottom' }) }}>
      <Text>My Shadow View</Text>
    </View>
  );
}

```

| attributes | description | required | default value |
|-|-|-|-|
| level | Increase shadow dimensions | false | 4 |
| shadowColor | Change shadowColor style attribute | false | #000 |
| direction | Change shadow direction | false | bottom |

**Object returned**

```javascript
{
  ...Platform.select({
    ios: {
      shadowColor,
      shadowOffset,
      shadowOpacity,
      shadowRadius,
    },
    android: {
      shadowColor,
      elevation: level,
    },
  }),
}
```

## 🧪 Example app

To see full app integration example please [refer to here](./examples/ShadowExampleApp/App.tsx).

> ⚠ To run the app please run here `yarn build` that the @dotmind/rn-shadow-generator npm package be able to link itselfs.
## ⚡ Contributing

Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## 🔐 License

[MIT](https://choosealicense.com/licenses/mit/)

repository: dotmind/rn-shadow-generator

repo_name: dotmind/rn-shadow-generator


text:
---
comments: true
date: 2010-02-10 16:38:25
layout: post
slug: installing-network-simulator-2-in-ubuntu
title: 'Installing Network Simulator 2 in Ubuntu '
wordpress_id: 435
categories:
- Current affairs
- Linux
---

_Are you baffled by random errands saying "  ns2 doesn't work on ubuntu " and so ?_

_Are you a linux geek don't wanna boot to windows for network simulator software ?_

_did your lab admin made a mess with your system in the name of installing ns2 :D ?_

_then you are in a right place :)
_

**You can make NS working in your system by putting little effort  on your ubuntu :)**

_**Step 1:**_

Download [network simulator software from here ](http://sourceforge.net/projects/nsnam/files/)

if you prefer other old versions you can swich by viewing files in that page

the file will be of almost 57 MB

_**Step 2: **_

Extract the files to your own desired directory

I did in **/home/karthik/Desktop/ **

_**step 3:**_

now go to your working directory of ns2 by

**cd /home/karthik/Desktop/ns-allinone-2.34**

_**step 4:**_

Run this command to check any unresolved dependencies existing between installation

**sudo apt-get install build-essential autoconf automake libxmu-dev**

run the command **./install** in terminal

it will take around 5 minutes

_**step 5:**_

Well Thats were your installation of ns2 exits :)

now you have to configure to make it alive

you have to edit in the shell

run **gedit ~./bashrc**

add at end of the file this lines

remember change  **/home/karthik/Desktop/ **to your file path say **/home/host-name/**

**
**

_# LD_LIBRARY_PATH
OTCL_LIB=/home/karthik/Desktop/ns-allinone-2.34/otcl-1.13
NS2_LIB=/home/karthik/Desktop/ns-allinone-2.34/lib
X11_LIB=/usr/X11R6/lib
USR_LOCAL_LIB=/usr/local/lib
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$OTCL_LIB:$NS2_LIB:$X11_
LIB:$USR_LOCAL_LIB_

_# TCL_LIBRARY
TCL_LIB=/home/karthik/Desktop/ns-allinone-2.34/tcl8.4.18/library
USR_LIB=/usr/lib
export TCL_LIBRARY=$TCL_LIB:$USR_LIB_

_# PATH
XGRAPH=/home/karthik/Desktop/ns-allinone-2.34/bin: /home/karthik/Desktop/
ns-allinone-2.34/tcl8.4.18/unix : /home/karthik/Desktop/ns-allinone-2.34/tk8.4.18/unix
NS=/home/karthik/Desktop/ns-allinone-2.34/ns-2.34/
NAM=/home/karthik/Desktop/ns-allinone-2.34/nam-1.14/
PATH=$PATH:$XGRAPH:$NS:$NAM_

now save the file and close it

run** source ~/.bashrc**

ignore if any errors ;)

then run** ./validate**

this is the longest step it takes **30-45 minutes** hence you can have a meal during the course of time ;)

_**step 6: **_

this  is editing thing ( optional )

just make  links to the files in **/home/karthik/Desktop/ns-allinone-2.34/bin ** by right click on all files and choose **make link**

copy  all and paste to **/usr/bin/ **directory  by running

**sudo nautilus**

then** rename** the file name for eg) **link to ns ** to **ns** and so on . do this till all files are renamed .

_**step 7: **_

Sample code

now u can check out a demo to test you ns 2 by writing a sample code as below :

_#Create a simulator object
set ns [new Simulator]_

_#Open the nam trace file
set nf [open out.nam w]
$ns namtrace-all $nf_

_#Define a 'finish' procedure
proc finish {} {
global ns nf
$ns flush-trace
#Close the trace file
close $nf
#Execute nam on the trace file
exec nam out.nam &
exit 0
}_

_#Create two nodes
set n0 [$ns node]
set n1 [$ns node]_

_#Create a duplex link between the nodes
$ns duplex-link $n0 $n1 1Mb 10ms DropTail_

_#Call the finish procedure after 5 seconds of simulation time
$ns at 5.0 "finish"_

_#Run the simulation
$ns run_

now copy this code and paste to a file say  **myfirstprogram.tcl**

then run **ns myfirstprogram.tcl**

you must see a window like this :

[![my ubuntu screen running NS2](http://karthikselvakumar.files.wordpress.com/2010/02/my_ubuntu_ns2.png)](http://karthikselvakumar.files.wordpress.com/2010/02/my_ubuntu_ns2.png)

and  ...   You did it , Enjoy   :)

extension: markdown


text:
All types have three fields in common: `id` (`Int64`), a unique identifier, and
`created` and `updated` (both `DateTime`), which give the time of in-database
creation and last modification.

## Core types

```@docs
MangalDataset
MangalNetwork
MangalInteraction
```

## Taxonomy types

```@docs
MangalNode
MangalReferenceTaxon
```

## Additional information

```@docs
MangalTrait
MangalAttribute
```

## Metadata types

```@docs
MangalUser
MangalReference
```

gha_language: Julia


text:
---
title: EGR 190/EGR 590- AI For Everyone
---

Data science, machine learning, and artificial intelligence are making inroads into many aspects of society, with numerous impacts across disparate disciplines with often surprising applications. The ability to understand the capabilities and limitations of these technologies and use them in an appropriate manner is already an important skill and is projected to be increasingly important in the future. The goal of this course is to provide an applied introduction to current techniques in machine learning and how they can be used to make sense of large amounts of data, while allowing students to focus on how machine learning is impacting their discipline of study.

Classes are scheduled on Monday from 4:40-6:10PM in Gross Hall, Room 330. Note that while there are no formal prerequisites for this course, there will be assumptions on the background of the students described below. Most critically, a background in a programming language will be assumed, and Python will be employed in the course.

## Instructors

Matthew Kenney

<EMAIL_ADDRESS>Assistant Research Professor

Computational Media and Visual Studies

David Carlson, Ph.D

<EMAIL_ADDRESS>Assistant Professor

Civil and Environmental Engineering, Biostatistics and Bioinformatics, Duke Clinical Research Institute, Computer Science, Electrical and Computer Engineering

Lawrence Carin

<EMAIL_ADDRESS>James L. Meriam Professor of Electrical and Computer Engineering

repository: dukeplusds/aiforeveryone

repo_name: dukeplusds/aiforeveryone


text:
---
layout: post
title: "Daily Digest #207"
type: digest
tags:
    - daily
    - development

description: ""
publish: true
---

- [Rack middleware to help measure production code line of code usage](https://github.com/danmayer/coverband)
- [The hidden cost of bootstrapping](https://justinjackson.ca/cost/)
- [Is Agile the Enemy (of Good Design)?](https://hackernoon.com/is-agile-the-enemy-of-good-design-14a35806cde7)
- [Learning from Pain](https://benjiweber.co.uk/blog/2018/09/12/learning-from-pain/)
- [Baking Compliance in your CI/CD Pipeline](https://thenewstack.io/baking-compliance-in-your-ci-cd-pipeline/)
- [Scaling your developer community with plugins](https://opensource.com/article/18/10/scaling-your-developer-community-plugins)
- [Kubernetes 1.2 released with Kubelet TLS Bootstrap and Azure Virtual Machine Scale Sets](https://www.itopstimes.com/contain/kubernetes-1-2-released-with-kubelet-tls-bootstrap-and-azure-virtual-machine-scale-sets/)

gha_language: HTML


text:
# sublime-openvpn

[![The MIT License](https://img.shields.io/badge/license-MIT-orange.svg?style=flat-square)](http://opensource.org/licenses/MIT)
[![Package Control](https://packagecontrol.herokuapp.com/downloads/OpenVPN.svg?style=flat-square)](https://packagecontrol.io/packages/OpenVPN)
[![GitHub](https://img.shields.io/github/release/idleberg/sublime-openvpn.svg?style=flat-square)](https://github.com/idleberg/sublime-openvpn/releases)
[![CircleCI](https://flat.badgen.net/circleci/github/idleberg/sublime-openvpn)](https://circleci.com/gh/idleberg/sublime-openvpn/)

Language support, snippets and build-system for [OpenVPN](https://github.com/OpenVPN/openvpn) configuration files

**Note:** I have only started using OpenVPN recently and primarily relied on [examples](https://github.com/OpenVPN/openvpn/tree/master/sample/sample-config-files) and the [documentation](https://openvpn.net/vpn-server-resources/) to create this package. Feel free to contribute additions and improvements!

## Installation

### Package Control

1. Make sure you already have [Package Control](https://packagecontrol.io/) installed
2. Choose *“Install Package”* from the Command Palette (Super+Shift+p)
3. Type *OpenVPN* and press Enter

### Using Git

1. Change to your Sublime Text `Packages` directory
2. Clone repository `git clone https://github.com/idleberg/sublime-openvpn.git 'OpenVPN'`

### Manual installation

1. Download the latest [stable release](https://github.com/idleberg/sublime-openvpn/releases)
2. Unzip the archive to your Sublime Text `Packages` directory

## Related

- [atom-openvpn](https://github.com/idleberg/atom-language-openvpn)
- [vscode-openvpn](https://marketplace.visualstudio.com/items?itemName=idleberg.openvpn)

## License

This work is licensed under the [The MIT License](LICENSE).

repository: idleberg/sublime-openvpn

repo_name: idleberg/sublime-openvpn


text:
# Phone Numbers Code Kata

This repo contains some sample data you could use to help test your solution to the Phone Numbers code kata. It also contains the python script I used to create the sample data. You can tweak it to create data that suits your needs.

To run the generate_data.py script, you'll need to install [Python 3](http://python.org).

The Names.csv file is from ["Generating Random Names as Test Data"](http://www.markrichman.com/2007/09/26/generating-random-names-as-test-data/), and that page says it is adapted from US census data. I have just converted his file from excel to csv to make it easier to handle.

# Kata description

_A description of this Kata is available in my book ["The Coding Dojo Handbook"](http://leanpub.com/codingdojohandbook). The following description is however taken directly from [http://cyber-dojo.com](http://cyber-dojo.com)_

Given a list of phone numbers, determine if it is
consistent. In a consistent phone list no number
is a prefix of another. For example:

- Bob 91 12 54 26
- Alice 97 625 992
- Emergency 911

In this case, it is not possible to call Bob because
the phone exchange would direct your call to the
emergency line as soon as you dialled the first three
digits of Bob's phone number. So this list would not
be consistent.

repository: RuiMarioCosta/Phone-Numbers-Kata

repo_name: RuiMarioCosta/Phone-Numbers-Kata


text:
Tutorial
--------

Over the years, many CSS & JavaScript libraries have been introduced. The CSS libraries ease the process of creating a
beautiful website with little effort, and requires only very basic CSS knowledge to use. Since mastering CSS is a very
hard task, the libraries enabled millions of developers to start creating websites easily, without previous knowledge
in designing websites at all.

Here are a few examples of CSS libraries that were recently introduced and are ranking high on Google:

* Bootstrap, by Twitter ([[http://getbootstrap.com/]])
* Foundation, by Zurb ([[http://foundation.zurb.com/]])
* Pure CSS, by Yahoo ([[http://purecss.io/]])
* Bulma (based on the new CSS3 Flexbox specification - [[http://bulma.io/]])
* Skeleton ([[http://getskeleton.com/]])
* Semantic UI ([[http://semantic-ui.com/]])

Exercise
--------

This page does not have an exercise yet. You are welcome to contribute one by sending me a pull request:

[[https://github.com/ronreiter/interactive-tutorials]]

Tutorial Code
-------------

    <!DOCTYPE html>

Expected Output
---------------

    <!DOCTYPE html>

            <title>Hello, World!</title>

Hello, World!

Solution
--------

    <!DOCTYPE html>

            <title>Hello, World!</title>

Hello, World!

repository: moujahedk/interactive-tutorials

filename: UI Libraries.md

repo_name: moujahedk/interactive-tutorials


text:
---
layout: default
---

# 1996-09-28 - [CRYPTO] (was: sig/noise ratio)

## Header Data

From: Patricia Gibbons<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 92504f60b229f626b2a8c1d8b74ee81c7fecffd19bf8773b4cb8802acd79d6eb

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1996-09-28 07:14:49 UTC

Raw Date: Sat, 28 Sep 1996 15:14:49 +0800

## Raw message

```
{% raw  %}From: Patricia Gibbons<EMAIL_ADDRESS>Date: Sat, 28 Sep 1996 15:14:49 +0800
To<EMAIL_ADDRESS>Subject: [CRYPTO] (was: sig/noise ratio)
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Brian D Williams wrote:
>
> In the interest of those who wish a significant increase in the
> signal/noise ratio I make a proposal. Significant crypto related
> posts could be prefaced with [CRYPTO] on the subject line on a
> strictly volunteer basis, that way those desiring a more topical
> list could have one simply by setting the appropriate filter.
>
> Items crypto related but missing the [CRYPTO] header could be
> reposted by well meaning souls.
>
> Other appropriate headers could of course be used.
>
> Brian

I will be the first on my block to 2nd this excellent idea!
--

Trish<EMAIL_ADDRESS>"The Vertical Skywave Girl" ...
Mobile repair shop supervisor - City of San Jose/ ITD-Communications
PGP Keyserver Webpage: < http://bs.mit.edu:8001/pks-toplev.html >

{% endraw %}
```

## Thread

+ Return to [September 1996](/archive/1996/09)

+ Return to "[Brian D Williams <talon57@well.com>](/authors/brian_d_williams_talon57_at_well_com_)"
+ Return to "[Patricia Gibbons <wa6ube@ix15.ix.netcom.com>](/authors/patricia_gibbons_wa6ube_at_ix15_ix_netcom_com_)"
+ Return to "["Z.B." <zachb@netcom.com>](/authors/z_b__zachb_at_netcom_com_)"

+ 1996-09-27 (Sat, 28 Sep 1996 06:37:04 +0800) - [[SUGGESTION] signal/noise ratio](/archive/1996/09/3dfdf7979a5b39a5e7f2b59589523e30316109eca3a6c58d163ebff45750bfd1) - _Brian D Williams<EMAIL_ADDRESS>  + 1996-09-28 (Sat, 28 Sep 1996 15:14:49 +0800) - [CRYPTO] (was: sig/noise ratio) - _Patricia Gibbons<EMAIL_ADDRESS>    + 1996-09-28 (Sun, 29 Sep 1996 04:48:46 +0800) - [Re: [CRYPTO] (was: sig/noise ratio)](/archive/1996/09/8f6ba6a0e2c86b96092845159c43bf18cab96fcf681d93d1f332fed5574ab5a2) - _"Z.B."<EMAIL_ADDRESS>


text:
## Lambda Expressions

Lambda expressions can be used to create in line functions.

Suppose we have a function as shown below
```
func :: forall a b. (a -> b -> b) -> a -> b -> b
func anotherFunc d1 d2 = anotherFunc d1 d2
```
I admit, it might not be the most useful function around. Or even the best way to write that function, but for learning purposes, it will suffice.

In this function, we have two quantified types "a" and "b". First parameter to the function is a function which takes "a" "b" and returns a "b". Second parameter is of type "a". Third is of type "b" and we return something of type "b".

Inside the function, we're just applying the passed in function and returning whatever it evaluates to.

* Option 1

We could create a function which we want to pass in using regular function creation syntax that we know and love.

```
doCalc :: Int -> String -> String
doCalc i s = s <> (show i)
```

We could then pass in "doCalc" into "func"

```
func doCalc 1 "blah" -- evaluates to "blah1"
```

* Option 2

We could use the hero of our mini story - lambda expressions! We can create anonymous functions inline using lambda expressions.

```
func (\i s -> s <> (show i)) 1 "blah" -- evaluates to "blah1"
```
![Imgur](https://i.imgur.com/VmPRBuw.jpg)

* We create lambda expressions using "\" syntax. Immediately after "\" we specify the arguments. After "->", we tell the expression that the function evaluates to.
* Instead of "=", we use "->"
* Types are automatically inferred to be the most general type. (In our case, forall a. Show a => a -> String -> String)
* Lambda expressions can be assigned to labels
```
myAwesomeFunc = (\first second -> (first + (first * second)))
```

gha_language: PureScript


text:
# asciidoctor-mathematical
Alternative stem processor for asciidoctor based on
[Mathematical](https://github.com/gjtorikian/mathematical).

## Features

asciidoctor-mathematical processes `latexmath` and `stem` blocks and inline
macros and replaces them with generated SVG or PNG images, thus enables `stem`
contents on a much wider range of asciidoctor backends. Currently, it is
tested to works well with the html, docbook, pdf and latex backends. For
`stem` blocks and macros, only the `latexmath` type is supported.

### Package Specific Attributes

These attributes can be set to tweak behaviors of this package:

| attribute           | description                                                           | valid values        | default value |
| ---------           | -----------                                                           | -------------       | ------------- |
| mathematical-format | format of generated images                                            | svg, png            | png           |
| mathematical-ppi    | ppi of generated images, only valid for png files                     | any positive number | 300.0         |
| mathematical-inline | if present will inline equations as svg (only useful for HTML output) | true/false          | false         |

## Usage
`asciidoctor-pdf -r asciidoctor-mathematical -o test.pdf sample.adoc`

## Installation
asciidoctor-mathematical is now available on RubyGems.  Installation is done
by `gem install asciidoctor-mathematical`. Install dependencies first.

### Dependencies
make, gobject, glib, gio, gdk-pixbuf, gdk, cairo, pangocairo, libxml, bison, flex

For the runtime, the following ttf fonts should be installed: cmr10, cmmi10,
cmex10 and cmsy10. They are provided by the lyx-fonts package in fedora, and the
fonts-lyx (or previously ttf-lyx) package in debian/ubuntu. In Arch Linux you can
install the [ttf-computer-modern-fonts](https://aur.archlinux.org/packages/ttf-computer-modern-fonts/)
package from AUR, you also have the [lyx](https://www.archlinux.org/packages/extra/x86_64/lyx/)
package in _extra_ repo though; both are providing required Computer Modern fonts.

#### OS X
Make sure you `brew install glib gdk-pixbuf cairo pango cmake`

You can install the font dependencies by using
```
cd ~/Library/Fonts
curl -LO http://mirrors.ctan.org/fonts/cm/ps-type1/bakoma/ttf/cmex10.ttf \
     -LO http://mirrors.ctan.org/fonts/cm/ps-type1/bakoma/ttf/cmmi10.ttf \
     -LO http://mirrors.ctan.org/fonts/cm/ps-type1/bakoma/ttf/cmr10.ttf \
     -LO http://mirrors.ctan.org/fonts/cm/ps-type1/bakoma/ttf/cmsy10.ttf \
     -LO http://mirrors.ctan.org/fonts/cm/ps-type1/bakoma/ttf/esint10.ttf \
     -LO http://mirrors.ctan.org/fonts/cm/ps-type1/bakoma/ttf/eufm10.ttf \
     -LO http://mirrors.ctan.org/fonts/cm/ps-type1/bakoma/ttf/msam10.ttf \
     -LO http://mirrors.ctan.org/fonts/cm/ps-type1/bakoma/ttf/msbm10.ttf
```
If you experience any compilation errors (caused by Mathematical) try running:
`brew link gettext --force` (you can unlink the libraries later if you want).

### Trouble Shooting

The `mathematical` gem, which is a hard dependency of
`asciidoctor-mathematical`, may fail to build because of its over-writing of
`strdup`. Whether it fail depends on the system. In case it fails, use the
following command to install `mathematical` (see
[gjtorikian/mathematical#64](https://github.com/gjtorikian/mathematical/issues/64)
for the details):

```
MATHEMATICAL_SKIP_STRDUP=1 gem install mathematical
```

repository: fbidu/asciidoctor-mathematical

repo_name: fbidu/asciidoctor-mathematical


text:
---
layout: default
---

# 1994-07-21 - Re: Leaving the Country

## Header Data

From: Blanc Weber<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 6fb0a64c2a138ebeeb2b8bb7857b89dbaed3c9fce2cda50d98f50d545956280f

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1994-07-21 02:28:36 UTC

Raw Date: Wed, 20 Jul 94 19:28:36 PDT

## Raw message

```
{% raw  %}From: Blanc Weber<EMAIL_ADDRESS>Date: Wed, 20 Jul 94 19:28:36 PDT
To<EMAIL_ADDRESS>Subject: Re: Leaving the Country
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

From Duncan:

It is not a matter of tax planning but a matter of psychology.  They
have convinced you to manage your own oppression because it is cheaper
and easier if you do it than if they do it.. . . . .

It is possible to reprogram yourself to disobedience. . . .
..................................................

For those who have seen the light of reason, there is still the problem
of living with the methods used to enforce complicity to the prevalent
political policy.  Disobedience by itself may psychologically help the
individual who imagines themselves to be free, but the disadvantage of
a government administrative clerk's preemption over your own decisions remains.

There is still the need to keep what is one's own, even when there is
no recognition for the sanctity of the self or of personal property.
This problem of efficacy in the face of human forces which are moved by
values contrary to one's own, is what I think of when I imagine what it
takes to "live among them", considering that there is no longer a place
to form a new, improved country.

There are some circumstances at a company I know of (!) where they have
found ways of establishing a "win-win" situation with clients.  It is a
controversial way of arriving at arrangements which are acceptable to
all parties  -  I wonder what sort of compromises go on at meetings
where eventually everyone comes out smiling.   But it is the sort of
calculating in interpersonal, entrepreneural, and political
juxtapositions which sometimes appear to be the only way to make
headway in difficult butt-heading circumstances.

I'm not an advocate of compromising, but I do think that there is much
material for personal advantage in the study of psychology & cognition,
as it relates to understanding what one is up against.  The question
remains, how to navigate in spite of some of these things.

The more that one can live openly in correspondence with the way things
really, really work,
the better it is for the minds which must live with the actual.  I do
think an anarcho-capitalist would rather live/work with the actual,
rather than shrink from it or excuse themselves from the fray (even
while trying to avoid the obstacles).  Judiciously.

Blanc

{% endraw %}
```

## Thread

+ Return to [July 1994](/archive/1994/07)

+ Return to "[Blanc Weber <blancw@microsoft.com>](/authors/blanc_weber_blancw_at_microsoft_com_)"

+ 1994-07-21 (Wed, 20 Jul 94 19:28:36 PDT) - Re: Leaving the Country - _Blanc Weber<EMAIL_ADDRESS>