## vintage – No1 Pocket Kodak opening 1 to 4, f equivalent stop?

I have a cute little pocket Kodak from the twenties or thirties. It is the bottom of the range model with the "single lens". The opening is not marked in numbers f, but is labeled as 1, 2, 3 and 4.

Is there any way to know the equivalent opening of the number f to measure the exposures with the modern and fast film (Ilford Delta 400)?

I would like to use a 35mm camera as a meter, and decipher a conversion for the vintage camera. The most expensive cameras in the same range have lenses f7.9 and f6.3, so I guess it's higher than that. But I could imagine that a cheap one-element lens was quite bright, but sacrificing sharpness.

I've done a lot of searching on Google, but I have not found anything. It seems that the other models in the range may have been more common than the "single lens".

I have the original manual, which includes 3 exposure tables for the 3 different lens options (individual, "Kodar f.7.9" and "Kodak Anastigmat f.6.3"), the page for the single lens is reproduced here. However, I realize that the films of the time were quite slow, so this is likely to over-expose the modern movie.

Other details of the camera. It takes 120 movies, and it seems to work. I executed an Ilford FP4 roll out of date, and I got 4 or 5 really good images, but I was guessing and exposing exhibitions in full sunlight. I think it says more about the latitude of the movie than my ability with the camera.

The plate that surrounds the lens with the shutter and opening marks has the number "27449".

If you are wondering why the bellows look strange in the photo, it is because they have some light leaks, so I put them in a black paper "vest" that seems to block them enough.

I have a new Ilford Delta 400, and I hope to take portraits with natural light indoors (a very well lit room), the same conditions with a 35mm camera, with a cheap f3.9 lens with Ilford FP4, 125 ASA has not had problems.

Interestingly, the opening is in front of the shutter, which are both in front of the lens element. When holding a ruler and squinting, I assume that the opening in setting 1 is about 8 mm in diameter, and in the setting of 4 about 2 mm.

## terminal – How to execute an equivalent function of the Xcode instruments> "File activity" in shell?

Have you tried fs_usage with the -f filesys or diskio option?

DESCRIPTION

The fs_usage utility presents a continuous display of the system's call usage information pertaining to the file system activity. Requires root privileges due to the
Ease of tracking the core you use to operate. By default, the monitored activity includes all system processes, except the running fs_usage process, Terminal,
telnetd, telnet, sshd, rlogind, tcsh, csh, sh and zsh. These default values ​​can be overridden so that the output is limited to include or exclude a list of
Assignments specified by the user.

## co.combinatorics – Circular permutations (bracelets) with similar things (reflections are equivalent) using the enumeration of polia

The circular permutations of N objects of n1 are identical of one type, n2 are identical of another type and so on, so that n1 + n2 + n3 + ….. = N?
There is a similar question but it does not address the case in which the reflections are under the same equivalent class.$$frac {1} {N} sum_ {d | N} phi (d) p_d ^ {N / d}$$ This is when the reflections are not the same. How does the equation change under this new restriction?

Note: I could not comment on that question because of my low reputation, so I asked this question.

## What is the equivalent of the "clicks" of the search console in Google Analytics?

I am investigating some reports in Google Analytics, however, I have been drawn to the fact that I can not find approximate numbers between the Google search console and the Google Analytics traffic numbers, for the same period of time, for the same domain.

I compared the same period of time (April 13 to April 13) in the search console "clicks" with "sessions" in Google Analytics traffic acquisition for `source / medium = "google / organic"`. As seen in the screenshots below, the numbers in GA are 25% HIGHER (not lower) than those in the Search Console.

The domain runs HSTS, so all requests are HTTPS and must be counted in both places.

• Is it the correct metric that I am comparing?
• Why are they different in the way that the GA number is higher? I would understand why the "sessions" would be smaller, but not the other way around
• In which of the numbers should I trust?

## How should I configure Netlify (or equivalent service) for hosting as a freelancer?

Often, customers ask me about hosting if they do not yet have a preferred hosting provider.

I have been interested in using Netlify to host JAM stack sites, but I have not used it in an independent context (only for personal secondary projects).

The options I see are:

• Hosting all the sites in the central account
• Setting up separate accounts for each of my clients and administering them myself
• Pointing to my clients at the Netlify address and asking them to manage it themselves

I suppose that these forms of configuration are generalized to other similar services, but I have not investigated the differences extensively.

I do not know if Netlify has any terms related to this way of working, but I have not been able to find any.

## graphic isomorphism – Are the lambda expressions isomorphic (without type) semantically equivalent?

"Isomorphic" is defined as having the same form of syntax trees and the same variable links. However, the names of the variables can be completely different. In other words, it is to say that we have a graphical isomorphism between the two expressions (the graph is the syntax tree with the variable link included as edges).
The intuition behind this is that assuming we are given the isomorphism, it is always possible to change the name of the variables and get the other expression.

## Sitemap – What is the equivalent to a & # 39; visual map of the site & # 39; or a & # 39; product flow & # 39 ;?

Basically, if user flows Y workflows delineate forms of interaction between screens (by tree flows or individual linear flows), what is the mapping of all the screens (and interactions) that exist in the product? A map of the site?

Often, site maps are more in the field of information architecture, so they do not necessarily include interactions or visual fidelity?

Is it useless to create this mapping because of its ambiguity? Task flows are used to delineate how a user would perform a task, site maps (as a method for the information architecture) are based on the user's mental models, therefore, is there any reason to build a & # 39; product flow & # 39;

## Equivalent to curry for return values.

There are languages ​​for which functions take exactly one argument and return an argument. This is nice and symmetrical, and there is no need to accept more than one argument because we can use currying: if we want a function to take two arguments, we can take the first and return a new function (which has the fist embedded in it), which Take the second one.

Is there a way to allow returning of more than one value?

## IBM db2 FOR XML equivalent

I have been trying to query an item with its secondary list at one time and one way is to use it for xml and subquery. I have been using this strategy with the SQL server and it works fine.

The relationship is order and order items.

for the sql server, the query might look like this:

``````Select O.OrderId, O.ShippingDate,
(
SELECT OI.ProductId, OI.Description, OI.Cost
OF OrderItems OI
WHERE O.OrderId = OI.OrderId
FOR XML PATH (& # 39; OrderItem & # 39;), ROOT (& # 39; OrderItems & # 39;)
) as order items
OF OR Orders
``````

I just need the list of items in the order to be xml, the details of the order are fine as they are.

Google's ways to apply the xml result in ibm db2, I found in your documentation on your website:
https://www.ibm.com/support/knowledgecenter/en/SSEPGG_9.7.0/com.ibm.db2.luw.xml.doc/doc/c0052638.html

I found a piece of code:

``````                SELECT XMLELEMENT (NAME "saleProducts",
XMLAGG (XMLELEMENT (NAME "prod",
XMLATTRIBUTES (p.Pid AS "id"),
XMLFOREST (p.name as "name",
i.quantity as "numInStock"))))
FROM THE PRODUCT p, INVENTORY iWHERE p.Pid = i.Pid
``````

that I applied as

``````SELECT O.OrderId, O.ShippingDate,
XMLELEMENT (NAME "Order items",
XMLAGG (XMLELEMENT (NAME "Order item",
XMLATTRIBUTES (OI.ProductId AS "ProductId"),
XMLFOREST (OI. Description as "Description",
OI. Cost as "Cost"))))
Of Orders O, OrderItems OI
WHERE O.OrderId = OI.OrderId
``````

But in the run, IBM db gives an error message:

The OLE DB provider "IBMDA400" for the linked server "XXX" returned the message "SQL0104: The token" OrderItems "was not valid. Valid Tokens 🙂 ,.
Why . . . . . : A syntax error was detected in the "OrderItems" token. The "OrderItems" token is not a valid token. A partial list of valid tokens is) ,.
This list assumes that the statement is correct until the token.
The error may be earlier in the declaration, but the syntax of the declaration seems to be valid until this moment. Recovery . . :
Do one or more of the following actions and try the request again:
Verify the SQL statement in the "OrderItems" token area. Correct the statement.
The error could be a missing comma or quote, it could be a misspelled word or it could be related to the order of the clauses.
If the error token is, correct the SQL statement because it does not end with a valid clause. "

Help

## Checking if large lists are equivalent does not work

So I'm working with large lists (more than 500 elements), let's call them `list1` Y `list2`. I have edited the `list1` Y `list2` So that both do not contain repeated elements. I have tried the commands

``````list1 == list2
``````

Y

``````Order[list1]== Order[list2]
``````

to check if both lists are the same, but instead of getting a true or false output, I get an exit from the statement, except that `list1` Y `list2` They are replaced with the physical lists themselves. For example, if I define

``````list1: = {1,2,3}
list2: = {2,3,4}
``````

so

``````list1 == list2
``````

``````{1,2,3} == {2,3,4}