How can we automatically translate sharePoint sites into multiple languages using sharepoint online 2020? ex : english to french?

Stack Exchange Network


Stack Exchange network consists of 176 Q&A communities including Stack Overflow, the largest, most trusted online community for developers to learn, share their knowledge, and build their careers.

Visit Stack Exchange

learning – Understanding C after getting used to scripting languages

I use python and javascript in my daily workflow. I am really excited about understanding c as I am drawn towards contributing to projects that are written in the language but even after weeks of learning I am not able to wrap my head around how certain things work in C

Like, right now I am trying to figure out how to store structured data to a file in c so that I can experiment with building small tools and get a better grasp on the language. but so far I am just able to find the basic file read/write examples and coming from a scripting background I am used to using structured formats like JSON or XML.

Am I just asking the wrong question here or am I yet to find the right tutorial to follow?

So far the guide that I found the easiest to understand was this one

Also searched through a community post on SO for resources but none I was most comfortable with the one mentioned above.

I am really really new to C so any sort of help will be very useful

formal languages – If$A leq_T B$ is given, can you reduce $overline{A}$ to $B$ and vice-versa

If you are given two languages $A$, $B$ and $$A leq_T B.$$ Is it possible to $overline{A} leq_T B$ or $A leq_T overline{B}$?

Here is my shot.

Case 1: $overline{A} leq_T B$

This is only possible if $A leq_m B$ exists and $B=overline{B}$. As you can transform any many-one reduction to its complement, we can show that if $A leq_m B$, then $overline{A} leq_m overline{B}=B$. Thus $overline{A} leq_m B$.

Case 2: $A leq_T overline{B}$

This is the same as above but we need to change the role of $A$ and $B$.

dnd 5e – Does knowing Primordial mean you understand all the different languages of elementals?

Yes. From 5e PHB, p. 123

Some of these languages are actually families of languages with many dialects. For example, the Primordial language includes the Auran, Aquan, Ignan, and Terran dialects, one for each of the four elemental planes. Creatures that speak different dialects of the same language can communicate with one another.

programming languages – Why didn’t == operator string value comparison make it to Java?

Consistency within the language. Having an operator that acts differently can be surprising to the programmer. Java doesn’t allow users to overload operators – therefore reference equality is the only reasonable meaning for == between objects.

Within Java:

  • Between numeric types, == compares numeric equality
  • Between boolean types, == compares boolean equality
  • Between objects, == compares reference identity
    • Use .equals(Object o) to compare values

That’s it. Simple rule and simple to identify what you want. This is all covered in section 15.21 of the JLS. It comprises three subsections that are easy to understand, implement, and reason about.

Once you allow overloading of ==, the exact behavior isn’t something that you can look to the JLS and put your finger on a specific item and say “that’s how it works,” the code can become difficult to reason about. The exact behavior of == may be surprising to a user. Every time you see it, you have to go back and check to see what it actually means.

Since Java doesn’t allow for overloading of operators, one needs a way to have a value equality test that you can override the base definition of. Thus, it was mandated by these design choices. == in Java tests numeric for numeric types, boolean equality for boolean types, and reference equality for everything else (which can override .equals(Object o) to do whatever they want for value equality).

This is not an issue of “is there a use case for a particular consequence of this design decision” but rather “this is a design decision to facilitate these other things, this is a consequence of it.”

String interning, is one such example of this. According to the JLS 3.10.5, all string literals are interned. Other strings are interned if one invokes .intern() on them. That "foo" == "foo" is true is a consequence of design decisions made to minimize the memory footprint taken up by String literals. Beyond that, String interning is something that is at the JVM level that has a little bit of exposure to the user, but in the overwhelming vast majority of cases, should not be something that concerns the programmer (and use cases for programmers wasn’t something that was high on the list for the designers when considering this feature).

People will point out that + and += are overloaded for String. However, that is neither here nor there. It remains the case that if == has a value equality meaning for String (and only String), one would need a different method (that only exists in String) for reference equality. Furthermore, this would needlessly complicate methods that take Object and expect == to behave one way and .equals() to behave another requiring users to special case all those methods for String.

The consistent contract for == on Objects is that it is reference equality only and that .equals(Object o) exists for all objects which should test for value equality. Complicating this complicates far too many things.

learning – Canonical software programs to allow comparison of programming languages?

What canonical programs exist that can be written in one language, then in another language, so that the two programs can be examined side-by-side for the purposes of comparing the different syntax/features of the two (or more) languages?

I can think of one (and, only one), “Hello, World!”

Are there more?

formal languages – If $L$ is regular then $L^{|2|}={w_1w_2 mid w_1,w_2in L, |w_1|=|w_2|}$ is context-free

I have found a problem about proving whether $L^{|2|}={w_1w_2 mid w_1,w_2in L, |w_1|=|w_2|}$ is context-free or not, knowing that $L$ is regular

So far I know that:

  • There are examples where $L$ is regular and $L^{|2|}$ is regular (for example $L={a,b}$)
  • There are examples where $L$ is regular and $L^{|2|}$ is not (for example $L={w mid w=a^N text{ or } w= b^N , Nge0}$)

But I am not sure how to prove that it’s context-free regardless of which regular language I use. I have found similar problems with the same language without imposing restrictions on which words to use, but I am not sure if those apply to this one.

bit manipulation – Are there any languages able to express how different values encoded in some bits of data?

Often, for efficiency reasons, low level languages encode different kind of information in the same set of bits.

  • A simple example is a pointer: the value 0 represents NULL, all other values represent memory addresses.

  • Or floating point numbers (e.g. IEEE 754) can encode decimal values as well as Infinity, -Infinity, +0, -0, NaN etc.

  • Yet other example are UTF8 characters, where the first bit tells us whether the byte is an ASCII character, or the unary-encoded number of bytes the character takes. Even signed integers use the first bit to encod the sign.

Normally values encoded this way are handled by handcrafted pieces of code performing bitwise operations.
But that means that we can’t generalize over it: for instance you can’t express a generic Maybe (aka Optional) type that encodes the Nothing/Empty state on some unused combination of bits.

Are there any languages with a type system able to understand and express how information is stored in the bits at your disposal?

regular languages – How to proove L 2^n with Pumping lemma

Let $Sigma$ is the latin alphabet ({a,b,c…,x,y,z} – 26 letters).

Given language
$L = { alpha in Sigma^{*} |$

if $alpha$ cointaints $a$ then $N_{a}(alpha) = 4$

if $alpha$ cointaints $b$ then $N_{b}(alpha) = 8$

$quad vdots$

if $alpha$ cointaints $b$ then $N_{z}(alpha) = 2^{27}$

Prove that L is reagular.

Note: I did research and I have found that we can use Pumping lemma