## functional programming – What is the relationship between the formal definition of rigor and its intuitive notion

Intuition: if you run `f(x)` the causes `x` be evaluated, and evaluate `x` does not end, then it will result in `f(x)` do not finish (because evaluate `x` does not end, so the execution of `f(x)` never finish).

So, if you run `f(x)` always provokes `x` to be executed, then `f` will be strict by the formal definition above. That's why "`f(x)` fully evaluate `x`"involved"`f(x)` evaluates basically for all `x` who basically evaluate. "

On the other hand, with a lazy function, evaluate `f(x)` does not necessarily trigger the evaluation of `x`, so it does not necessarily end (even if evaluate `x` would not end). So, for an intuitively lazy function, it will not match the formal definition of strict.

## Please review my relationship forum

Hi all,

I have recently created a forum but I am still working on it.

Can you please give constructive criticism on my site.

Discover it here: http://www.relationshiptalkforum.com

## Can two expressions of different types of types have a subtyping relationship and an equivalence relation?

In Quantification Limited Superior Order ($$F ^ ω _ {<:}$$), introduced in Ch31 in Types and programming languages by Pierce, his subtyping and equivalence rules are as follows:

1. Does the subtyping relationship exist only between two type expressions of the same type? Can Two Expressions of Different Type Types Have a Subtyping Relationship?

2. In good standing (S-TRANS), why `Γ |- U :: K` necessary?

3. In good standing (S-EQ), why `Γ |- S :: K` and `Γ |- T :: K` necessary? Are not they involved by `S ≡ T`?

4. Does the equivalence relation exist only between two type expressions of the same type? Can two types in different types of expressions have the equivalence relation?

Thank you.

## 100 Ebooks for Dating / Relationship / Romance – Titles

Get advanced tips and advice on dating and relationships, and all the support and guidance you need to succeed in dating, romance and romance.

Some titles of this collection:

1. Best date ever

2. Broken heart survival

3. You can not keep your eyes on you

4. Find the ideal partner

5. Get back together

6. How to woo a woman

And much more !

https://marketplace.digitalpoint.com/dating-relationship-romance-ebook-pack-100-quality-ebooks-with-resale-rights.4927/item

## virtual machine – Is my understanding of the relationship between VM, Kubernetes, Docker and Container correct?

My intention with this question / publication is to provide an overview / overview to newcomers who have no idea what Container or Container Orchestrator is. . I hope this will give newcomers positive feedback and achievement. There might be some errors in my understanding, and that's another reason why I created this post (to check my understanding).

Make the process of launching software as simple as possible, so all you have to do is worry about the coding aspect and make sure your program does what you want. No need to ask if what you have coded will work on different computers around the world.

To my knowledge, a container (usually) contains your codes and all the dependencies (such as compiled binaries, libraries, etc., needed to run your codes once compiled). Container exists to solve the problem "It works on my machine, but not on yours". In in most cases container can solve this problem by always having the same development environment on any machine, because all the development environment already exists in the container. Soon almost whatever the machine, the codes will be compiled and will work well. Except when the architecture and operating system of the other computer differ from those of your computer (OS / Hardware environment, such as instructional games, system APIs, the binary format , etc.).

That's where Docker comes in. Docker creates a container (with the help of a docker file, also called a configure file) in the form of an image file. Docker can then run this image file on a virtual machine (must belong to the same system / hardware environment as the machine from which the container was created) with the help of a HyperVisor (HypertVisor such as VirtualBox ). And this solves the problem of the system / hardware environment. To solve this problem, HyperVisor translates any set of instructions / system-APIs and so on. from the virtual machine to the host machine of the virtual machine. Docker's goal is to create "Container as image", so that it can be run on a virtual machine.

So, a quick summary of what has happened so far:

For a container to work as expected ALL machines, you have to go through two steps:

1. It must be associated with source code and dependencies. This solves the problem of the development environment.

2. It must then be in the form of an image so that it can be executed by a virtual machine. And that solves the hardware / operating system problem.

Now, to move to another level, the problem now is to manage the containers on a server for deployment, ensuring that they are scalable, optimize hardware resources, and so on.

Kubernetes (or any other container orchestrator, like Docker's Swarm) comes to save the situation! And I'm a bit confused as to how Kubernetes performs his orchestration / management. As a result, the following items are not very detailed. But it should be from a server running a HyperVisor without an operating system, and HyperVisor running Kubernetes. Kubernetes will manage the pods. Pods are a group of one or more containers (such as Docker containers), with a shared storage / network and a specification on how to run the containers. You must then configure the "desired state" for Kubernetes. Then you sit down and let Kubernetes management work for you! 🙂

Here is the roadmap for this whole process imagined in my mind:

Overall: App -> Package application in a container -> Send container to a container orchestrator

### Local computer (application and package in the container)

1. Are you developing an application

2. Use Docker to create a container image (containing all your source codes, dependencies, and operating system / hardware information)

### Server Machine (Container Orchestrator)

Server such as the AWS cloud, which offers Kubernetes servers already operational

1. Server (running HyperVisor without OS, which manages a single virtual machine)

2. This virtual machine runs Kubernetes (which handles pods, that is, groups of one or more Docker containers, as well as instructions on how to use Docker to run the container)

3. Docker runs the container (your application) with the help of another HyperVisor and a virtual machine.

## What is the relationship between the number of permutations and the number of subsets?

How many different ways to fill 100 boxes online with white balls or backpack?
(A box can hold only one ball at a time.)

My attempt:

Different ways to fill the 1st box = 2
Different ways to fill the 2nd box = 2
Different ways to fill the 3rd box = 2
& # 39;
& # 39;
& # 39;
& # 39;
& # 39;
Different ways to fill the 99th box = 2
Different ways to fill the 100th box = 2

SO by method of counting the answer is $$2 ^ {100}$$.

This is the same as the number of subsets that a set of 100 elements has?

What is the link between this type of question and $$2 ^ n$$ at?

## class diagram – how to identify the type of relationship between two classes with UML

I start to study `UML` to be able to document a small software, this to be able to do `my class diagram`. Although I have just read the concepts about the types of relationship that can exist between classes, they are:`association`, `dependence`, `aggregation` and `composition`] I still can not understand and identify when it 's about one type of relationship or another. For example, I have the following relationship between classes:

By and large, I have a class that refers to a breeding sow that may have zero or more births, and each birth certificate only belonged to a sow, so I initially represented graphically my relationship as I just tied it up, after reading a little bit the concepts now interpret the following:

as I now interpret it: if an object of the sow class ceases to exist. all the people linked by the births of the class would also cease to exist. Is my interpretation correct?

## Recurrent relationship for two-step algorithms

I'm trying to make the recurrence relation for my algorithm, but it has two variables $$T (n, m)$$. For small enough $$n$$, $$m$$ is almost the same as $$n$$but $$m$$ can not exceed a certain constant $$k$$. So once $$n$$ develops beyond $$k$$, $$m$$ turns into a constant $$k$$. So, it has two different stages.

I made the relationship in both cases: when $$m$$ is another variable, and when $$m$$ is a constant, but how can I assemble them?

Using $$a = 2, b = 2$$ for example: this relationship of recurrence with $$m$$ as a variable like $$n$$:
$$T (1) = 1$$
$$begin {equation *} begin {split} T (n) & = 2T ( frac {n} {2}) + m \ & = 2T ( frac {n} {2}) + n \ & = n + mlog_2n end {split} end {equation *}$$

treat $$m$$ as a constant:
$$begin {equation *} begin {split} T (n) & = 2T ( frac {n} {2}) + m \ & = n + mn-m end {split} end {equation *}$$

Please do not hesitate to check my maths. Now, how do I represent this as a recurrence relationship? $$m$$ can not exceed the constant $$k$$.

## spring – Inserting data into multiple tables with a one-to-many relationship using jdbctemplate

I have two tables an invoice and the other is the table of items. Invoices and articles are in a multi-party relationship. My question is: how to insert multiple articles into invoices using batch (JDBC TEMPLATE).

``````public int insertInvoices(final List b2bInvoices) {
jdbcTemplate.batchUpdate(
"INSERT INTO `b2b_anx1` (`pk_upload_id`, `uu_id`, `ref_gstin_id`, `return_type`, `month_year`, `fyear`, `cp_gstin`, `doc_type`, `reciver_action`, `diffprcnt`, `pos`, `sec7act`, `cp_gstin_name`, `supply_type`, `rfndelg`, `invoice_number`, `invoice_date`, `invoice_value`, `taxable_value`, `tax_amount`, `igst`, `cgst`, `sgst`, `cess`, `is_sync`, `is_transit`, `created_by`, `creation_time`, `updation_time`) VALUES (NULL,?,?, ?, ?, ?, ?, ?, ?, ?, ?, ?,?,?,?,?,?, ?, ?, ?, ?, ?, ?, ?, ?, ?,?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP);"
+ "INSERT INTO `b2b_anx1_items` (`pk_item_id`, `uu_id`, `hsn`, `taxable_value`, `rate`, `igst`, `cgst`, `sgst`, `cess`, `hsn_description`, `unit`, `quantity`, `total_amount`, `ref_gstin_id`, `cp_gstin`, `invoice_number`, `invoice_date`, `month_year`, `fyear`, `b2b_anx1_ref_id`, `created_date`) VALUES (NULL,?, NULL, NULL, NULL, NULL, NULL, NULL, NULL, '', '', '', '', NULL, NULL, NULL, NULL, NULL, NULL, NULL, CURRENT_TIMESTAMP);"
+ "",
new BatchPreparedStatementSetter() {
public void setValues(PreparedStatement ps, int i) throws SQLException {
B2bAnx1 invoice=b2bInvoices.get(i);
ps.setObject(1, 1);
ps.setObject(2, invoice.getRefGstinId());
ps.setObject(3,"xtq");
ps.setObject(4,invoice.getMonthYear());
ps.setObject(5,invoice.getFyear());
ps.setObject(6,invoice.getCpGstin());
ps.setObject(7,invoice.getDocType());
ps.setObject(8,invoice.getReciverAction());
ps.setObject(9,invoice.getDiffprcnt());
ps.setObject(10,invoice.getPos());
ps.setObject(11,invoice.getSec7act());
ps.setObject(12,invoice.getCpGstinName());
ps.setObject(13,invoice.getSupplyType());
ps.setObject(14,invoice.getRfndelg());
ps.setObject(15,invoice.getInvoiceNumber());
ps.setObject(16,invoice.getInvoiceDate());
ps.setObject(17,invoice.getInvoiceValue());
ps.setObject(18,invoice.getTaxableValue());
ps.setObject(19,invoice.getTaxAmount());
ps.setObject(20,invoice.getIgst());
ps.setObject(21,invoice.getCgst());
ps.setObject(22,invoice.getSgst());
ps.setObject(23,invoice.getCess());
ps.setObject(24,invoice.getIsSync());
ps.setObject(25,invoice.getIsTransit());
ps.setObject(26,invoice.getCreatedBy());
List items=   invoice.getB2bitems();
for (B2bAnx1Items b2bAnx1 : items) {
ps.setObject(27, b2bAnx1.getCp_Gstin());
}

}

public int getBatchSize() {
return b2bInvoices.size();
}
});
return b2bInvoices.size();
}
``````

## MySQL recursive query to find all the parents of a many-to-many relationship

I have three tables that define the characteristics of some products:

• Characteristics
``````+----|------------------|----------|--------+
| id |             name |     type | status |
|----|------------------|----------|--------|
|  1 |           height |    float |      0 |
|  2 |            width |    float |      0 |
|  3 |           length |    float |      0 |
|  4 |           weight |    float |      0 |
|  5 |           colour |      int |      0 |
|  6 |         material |      int |      0 |
|  7 |     manufacturer |      int |      0 |
|  8 |       durability |    float |      0 |
|  9 |     battery_type |      int |      0 |
| 10 | battery_capacity |    float |      0 |
| 11 |     connectivity | set |      0 |
| 12 |             page |      int |      0 |
| 13 |             name |   string |      0 |
| 14 |      description |   string |      0 |
+----|------------------|----------|--------+
``````
• groups
``````+----|-------------------|--------+
| id |              name | status |
|----|-------------------|--------|
|  1 |         cellphone |      0 |
|  2 |          notebook |      0 |
|  3 |          portable |      0 |
|  4 |       workstation |      0 |
|  5 |                pc |      0 |
|  6 |          computer |      0 |
|  7 | electronic_device |      0 |
|  8 |              book |      0 |
|  9 |          sizeable |      0 |
| 10 |         volumable |      0 |
| 11 |           general |      0 |
+----|-------------------|--------+
``````
• spécification_groupe
``````+----|----------|------------------|--------+
| id | group_id | specification_id | status |
|----|----------|------------------|--------|
|  1 |       11 |               13 |      0 |
|  2 |       11 |               14 |      0 |
|  3 |       11 |                5 |      0 |
|  4 |       10 |                1 |      0 |
|  5 |        9 |                2 |      0 |
|  6 |        9 |                3 |      0 |
|  7 |        8 |               12 |      0 |
|  8 |        3 |                6 |      0 |
|  9 |        3 |                9 |      0 |
| 10 |        3 |               10 |      0 |
| 11 |        7 |                7 |      0 |
| 12 |        7 |               11 |      0 |
+----|----------|------------------|--------+
``````
• group_groups
``````+----|----------|--------------------|--------+
| id | group_id | group_reference_id | status |
|----|----------|--------------------|--------|
|  1 |        3 |                  1 |      0 |
|  2 |        3 |                  2 |      0 |
|  3 |        3 |                  8 |      0 |
|  4 |        6 |                  4 |      0 |
|  5 |        6 |                  5 |      0 |
|  6 |        7 |                  1 |      0 |
|  7 |        7 |                  2 |      0 |
|  8 |        7 |                  4 |      0 |
|  9 |        7 |                  5 |      0 |
| 10 |        9 |                  7 |      0 |
| 11 |        9 |                  8 |      0 |
| 12 |       10 |                  7 |      0 |
| 12 |       11 |                  7 |      0 |
| 12 |       11 |                  8 |      0 |
+----|----------|--------------------|--------+
``````
• groupes_produits
``````+----|--------|-------|--------+
| id |   name | group | status |
|----|--------|-------|--------|
|  1 | phone1 |     1 |      0 |
|  2 |  book1 |     8 |      0 |
+----|--------|-------|--------+
``````

Ideally, I want to get all the specification attributes of a product whose status along all tree lines is 0, but knowing which groups a product is acceptable to is acceptable.

A result may look like this:

• result
``````+---------|-------------|--------------|-------------------|----------|--------+
| row_num |  product_id | product_name |     product_group | group_id | status |
|---------|-------------|--------------|-------------------|----------|--------|
|       1 |           1 |       phone1 |         cellphone |        1 |      0 |
|       2 |           1 |       phone1 |          portable |        3 |      0 |
|       3 |           1 |       phone1 | electronic_device |        7 |      0 |
|       4 |           1 |       phone1 |           sizable |        9 |      0 |
|       5 |           1 |       phone1 |         volumable |       10 |      0 |
|       6 |           1 |       phone1 |           general |       11 |      0 |
|       7 |           2 |        book1 |              book |        8 |      0 |
|       8 |           2 |        book1 |          portable |        3 |      0 |
|       9 |           2 |        book1 |           sizable |        9 |      0 |
|      10 |           2 |        book1 |           general |       11 |      0 |
+---------|-------------|--------------|-------------------|----------|--------+
``````