Yes! A couple good ones to start with would be:


ㅤ
_This answer was originally posted on [Triality](https://triality.org/question/334)_

Hi. Is there any tutorial for Cairo?


ㅤ
_This question was originally posted on [Triality](https://triality.org/question/334)_

Cairo start.

How would I write if x is not less that y using


`from starkware.cairo.common.math_cmp import is_le`


ㅤ
_This question was originally posted on [Triality](https://triality.org/question/591)_

Writing a "not" operation in Cairo

Are there situations in which we prefer declaring variables as `local` vs `tempvar`?
I understand that both are used to avoid variables being revoked, curious to know if they are different in any way
Thread


_This question was originally posted on [StarkNet Discord](https://www.newton.so/view?tags=discord)_

Are there situations in which we prefer declaring variables as `local` vs `tempvar`?

How do I connect my DAPP to Starknet mainnet using starknetjs?

Can anyone share some articles explaining SNARK/STARK concepts and rollups (Optimism)?

_This question was originally posted on [StarkNet Discord](https://www.newton.so/view?tags=discord)_

Can anyone share some articles explaining SNARK/STARK concepts and rollups (Optimism)?

I am currently running this code

```
func main() {

    let x = [ap];
    [ap] = 1, ap++;

    [ap] = 2, ap++;

    [ap] = x, ap++;
    jmp rel -1;  // Jump to the previous instruction.
}

And what is happening is that "x" is alternating between 1 and 2 and I couldn't figure out why.

Also, it wasn't very clear to me what a "Revoked Reference" means. Is it when you cannot access a certain [ap] when running a specific function?

This is the link to the exercise:
https://www.cairo-lang.org/docs/how_cairo_works/consts.html#revoked-references

Revoked References exercise from Cairo-lang

I’m having a problem where I’m trying to use a Uint256 in a hint, but I keep getting this error


Here is my code:


`%builtins output range_check`


`﻿`


`from starkware.cairo.common.uint256 import (uint256_add, Uint256,`


 `uint256_mul)`


`from starkware.cairo.common.serialize import serialize_word`


`﻿`


`func main{output_ptr : felt*, range_check_ptr}():`


 `alloc_locals`


 `let num1 = Uint256(20000, 0)`


 `%{print(ids.num1)%}`


 `let num2 = Uint256(low=0,high=7)`


 `let (local mul_low : Uint256, local mul_high : Uint256) = uint256_mul(num1, num2)`


 `serialize_word(mul_high.low)`


`﻿`


 `return ()`


`end`


ㅤ
_This question was originally posted on [Triality](https://triality.org/question/378)_

Cairo error "Expected expression of type 'starkware.cairo.common.uint256.Uint256' to have an address."


As I understand it, `let` defines a reference, which can be seen as an alias, so for example `let x = y * y * y` doesn't compute `y * y * y` but the occurrences of `x` will be replaced by `y * y * y`.
Local variables are similar to other languages local variables.


As in <https://www.cairo-lang.org/docs/hello_cairo/dict.html>, what does it mean to write `let (local dict_start : DictAccess*) = alloc()`? That every instance of `local dict_start : DictAccess*` will be replaced by `alloc()`? Why not just `local (dict_start : DictAccess*) = alloc()` or `let (dict_start : DictAccess*) = alloc()`?



ㅤ
_This question was originally posted on [Stack Overflow](https://stackoverflow.com/questions/71738301/what-does-it-mean-to-declare-a-local-variable-inside-a-let)_

Popular tags

Cairo start.

1 answers

Your answer

Related

You may find useful