documentation – Version Control For Figma

Looking for a better way to version-control designs in Figma. The default version control manager doesn’t show versions of a specific artboard and doesn’t show comments made for a specific version. I tried some methods like creating a page for each version but the document gets very big after dozens of iterations.

Is there an alternative to Figma version control having those features?
What’s the best way to take Figma version control to the next level?

integration – Integral from Mathematica’s documentation: $int_0^1 frac{log left(frac{1}{2} left(1+sqrt{4 x+1}right)right)}{x} , dx = frac{pi^2}{15} $

I like to puruse Mathematica’s documentation and look at the ‘Neat Examples’: this is one I managed to figure out. Apparently it’s due to Ramanujan:
$$
I=int_0^1 frac{log left(frac{1}{2} left(1+sqrt{4 x+1}right)right)}{x}
, dx = frac{pi^2}{15}
$$


Here are the steps for my solution:

  1. Make the substitution $x=y^2-y$, yielding
    $$
    I= int _{1}^{phi}frac{log(y)(2y-1)}{y(y-1)},dy,
    $$
    where $displaystyle{phi = frac{1+sqrt{5}}{2}}$ is the golden ratio.
  2. Factor out the $log(y)$ term and use partial fractions to write
    $$I = underbrace{int _{1}^{phi}frac{log(y)}{y},dy}_{I_1} + underbrace{int _{1}^{phi}frac{log(y)}{y-1},dy}_{I_2}
    $$
    $I_1$ can be evaluated using a simple substitution, yielding $displaystyle{I_1 = frac{log ^2(phi )}{2}}$.
  3. Use the Taylor series for $log(y)$ centered at $y=1$ and interchange the sum and integral to show
    $$
    I_2 = -sum_{k=1}^{infty} frac{(1-phi)^{k}}{k^2}= -sum_{k=1}^{infty} frac{(-phi^{-1})^{k}}{k^2}= – text{Li}_2(-phi^{-1})
    $$
  4. $text{Li}_2$ has the following properties:
  • $text{Li}_2(x) + text{Li}_2(-x) = frac{1}{2}text{Li}_2(x^2)$
  • $text{Li}_2(x) + text{Li}_2(1-x) = zeta(2) – log(x)log(1-x)$
  • $text{Li}_2(1-x) + text{Li}_2(1-x^{-1}) = -frac{1}{2}log^2(x)$

Put $x=phi^{-1}$ and use $phi^2=phi+1$; this gives:
$$
text{Li}_2(phi^{-1}) + text{Li}_2(-phi^{-1}) = frac{1}{2}text{Li}_2(1-phi^{-1})
$$

$$
text{Li}_2(phi^{-1}) + text{Li}_2(1-phi^{-1}) = zeta(2) -2 log^2(phi)
$$

$$
text{Li}_2(1-phi^{-1}) + text{Li}_2(-phi^{-1}) =-frac{1}{2}log^2(phi)
$$

5. Relabel for clarity. Let $A=text{Li}_2(phi^{-1})$, $B=text{Li}_2(-phi^{-1})$, $C=text{Li}_2(1-phi^{-1})$, and $L= log^2(phi)$. This gives the system
$$
begin{cases}
A+ B & = frac{1}{2}C\
A+ C&= zeta(2)- 2L\
C+B &= -frac{1}{2}L
end{cases}
$$
Solving gives $B=-I_2=displaystyle{frac{1}{2}L-frac{2}{5}Z}$, whence $displaystyle{I = frac{pi^2}{15}}.$


I’d be curious to see if there are any other methods of proof, perhaps involving simpler substitutions than the ones I used.

documentation – Do same PostgreSQL Limits apply for PostgreSQL 11 version?

I’m writing a research paper in which I’ve been using implementation of PostgreSQL, version 11.8 and what bothers me it’s Docs about DB Limitations (at https://www.postgresql.org/docs/12/limits.html) which is given ONLY for versions 12 and newly released 13. Do these same limits apply to version 11.8 ORR only to those two mentioned versions?

Any guide/help is more than welcome.

configuration – What’s the meaning of “resources external to the SQL Server computer are needed” in Microsoft’s SQL documentation?

In Microsoft’s SQL Server documentation on Windows service account configuration, the decision to use either a VA or a MSA hinges on whether

resources external to the SQL Server computer are needed

What exactly does this phrase mean here? I’m seeking an explanation that makes sense to an ‘accidental DBA’ with minimal experience of SQL Server, or Windows Server, configuration. What counts as a ‘resource’ here, and what kinds of ‘need’ are relevant?

Context: I have a fresh SQL Server 2019 VM on Azure, which was configured with VAs out-of-the-box, and I’m trying to decide whether we need to switch to using MSAs. I have found multiple other questions concerning this same documentation page and/or the same basic decision between VAs or MSAs (or regular AD Accounts) – but none really explain this specific phrase in a way that helps me apply it to my particular scenario. Which is essentially a data warehouse use-case: data will be coming into this SQL instance from external sources, but that’ll be managed by a third-party DW automation application running SSIS scripts, not directly by the SQL engine. (This application has its own AD service accounts.)

Whilst I’ve explained my specific scenario here to try to clarify the question, I’m keen for a generic answer so anyone with any SQL Server use case can evaluate this “resources external to the SQL Server” phrase for their needs. Specific answers for my use case are also welcome.

documentation – How to know if a built-in expression is a function or not

Following the comments on the answer here I would like to know if there is a way to deduce from the documentation if a built-in expression is a function or simply “a variable that stores something”

For instance, looking at the docs for graphics, it is not possible to understand that “primitives” and “options” are not parameter to provide to the function “Graphics” but actually what is stored in a Graphics type variable.

I find the documentation extremly confusing to learn, which is why I ask my question.

Thus, my question is precisely:

  • Is there a way from the documentation to know if the expression is a function or a variable storing something
  • If not, can I use some way in Mathematica to know it

documentation – What are some creative ways to ‘document’ UI error messages that are manageable and maintainable for developer handover?

Background

I am a designer working for a large organisation that has thousands of system error codes that are associated with system default error messages.

Sometimes these system default error messages do not fit the UI context in which is used, so we have to adjust these messages with something custom to fit its page context per project.

Approach taken

The approach taken for this was to work with a Business Analyst (BA) to populate an excel spreadsheet with

  • thousands of error codes with default messages and
  • custom messages per the context of usage and
  • URL links to designs that contain placeholder text.

Challenge

The challenge is retaining the consistency of error message usage, document maintainability and developer handover.

The way error messages are being documented is the best we have come up with at the moment and wonder if other UX designers have found a better approach to documenting complex error messages for developer handover.

Are there any creative ways or tooling to handle something like this?

google play services – Is there *full* documentation for adding Admob to Unity anywhere?

The official documentation leaves out really important steps.
Adding ‘cocaopods’ and ‘Google Play Services’
They are just listed as prerequisites without even any links.

Another confusing thing is that, elsewhere I have seen that apparently I dont also need the Unity Google Play Games Services SDK for Admob to work. But in that case then why is ‘Google Play Services’ listed as a prerequisite on the official docs?

enter image description here

Documentation of Finite State Machine / Workflow

In my database, I store task data (id, timestamp, input data), and information about the state of the multi-step processing (e.g. prepare, execute, summarize). The program moves from one state to another. If the program breaks, the last state remains persistent. I am thinking in terms of a finite state machine (fsm).

Now I am looking for an easy text format to document the fsm. I want to be able to define the input (available data) that can be expected for a given state, and several possible next states (e.g. finished, failed).

I was looking for over an hour on common workflow language (cwl) and could not figure out whether they have more than one output states or not and so I am asking here.

Any hints appreciated!

EDIT: According to your answer, I realize that this is a too small problem for a standard text format. I guess I was looking for a ready-to-go solution of this. Thanks!