( @mlubin 당, 이것은 관련 변경 사항입니다 https://github.com/JuliaLang/julia/pull/19324)

Stefan은 여기서 이 문제를 해결할 수 있는 한 가지 가능성은 let 블록의 REPL 항목을 자동으로 래핑하는 것이라고 제안 했습니다.

그러나 당신이 할 수 없다는 점에서 혼란스럽지 않습니까?

a = 1

그 뒤에 a 를 사용하시겠습니까? 모든 최상위 할당에 대해 global 가 삽입되지 않는 한 추측할 수 있습니까?

이 동작은 모든 것을 let 블록으로 래핑하는 것이 아니라 그보다 더 복잡합니다. 표현식 내부에 할당된 전역을 let-bind한 다음 표현식 끝에 있는 전역 값을 let-bound 값으로 추출해야 합니다.

따라서 a = 1 를 a = let a; a = 1; end 와 같은 것으로

for i in 1:2
    before = false
end

다음과 같이 바뀔 것입니다.

before = let before = before
    for i in 1:2
        before = false
    end
end

솔직히 지금 사람들이 이런 피드백만 하고 있다는 사실에 짜증이 납니다. 이 변경 사항은 10개월 동안 마스터에 있었습니다.

나는 최근까지 master를 매우 닫지 않은 것에 대한 죄책감이 있어서 이 피드백이 참으로 조금 늦었습니다. 프로그래머를 위한 것 이상(대부분의 for 루프는 라이브러리 코드의 함수 내부에 있을 것입니다) 이것이 가르치는 것에 대한 우려입니다. 종종 for 루프는 함수나 범위보다 먼저 학습됩니다(물론 실제로 무슨 일이 일어나고 있는지 이해하려면 범위를 이해해야 하지만 가르칠 때는 종종 단순화됩니다).

여기서는 함수나 전역 변수를 설명하지 않고 초보자에게 1에서 10까지의 수를 합하는 방법을 가르치는 것이 약간 어려워집니다.

솔직히 지금 사람들이 이런 피드백만 하고 있다는 사실에 짜증이 납니다. 이 변경 사항은 10개월 동안 마스터에 있었습니다.

공정하게 말하자면 Julia 0.7은 13일 전에 출시되었습니다. 이것은 대부분의 Julia 사용자를 위한 새로운 변경 사항입니다.

솔직히 지금 사람들이 이런 피드백만 하고 있다는 사실에 짜증이 납니다. 10개월 동안 마스터에 변경 사항이 있습니다.

불행히도 가장자리에서 생활하는 것을 감당할 수 없는 사람들에게는 불행히도, 우리의 관점에서는 완전히 새로운 것입니다.

솔직히 지금 사람들이 이런 피드백만 하고 있다는 사실에 짜증이 납니다. 이 변경 사항은 10개월 동안 마스터에 있었습니다.

그리고 개발 분야에서 벗어나도록 격려받은 사람들에게는 "우리 관점에서 보면 완전히 새로운 것"입니다.

사람들이 이것을 얼마나 오래 테스트해야 했는지에 대한 메타 토론을 하는 대신 지금 당면한 문제에 집중하기 위해 돌아가도 될까요? 현재 상황이니 기대해 보겠습니다.

나는 최근까지 master를 매우 닫지 않은 것에 대한 죄책감이 있어서 이 피드백이 참으로 조금 늦었습니다. 프로그래머에 대한 관심 이상(대부분의 for 루프는 라이브러리 코드의 함수 내부에 있음) 이것이 교육에 대한 우려입니다. 종종 for 루프는 함수나 범위보다 먼저 학습됩니다(물론 실제로 진행되는 상황을 이해하려면 범위를 이해해야 하지만 가르칠 때는 종종 단순화됩니다).

여기서는 함수나 전역 변수를 설명하지 않고 초보자에게 1에서 10까지의 수를 합하는 방법을 가르치는 것이 약간 어려워집니다.

이것은 큰 포인트입니다. 문제가 실제로 무엇인지 알게 된 후 실제로 얼마나 적게 나타나는지 놀랍습니다. 그것은 야생과 테스트에서 많은 Julia 코드에서 문제가 되지 않으며, 실수로 전역이었던 많은 변수를 드러냈습니다(원래 PR에 따른 Julia Base의 테스트에서, 그리고 대부분의 DiffEq의 테스트). 대부분의 경우 미묘하게 잘못된 행동은 당신이 얻는 것이 아니라(루프의 변화를 기대함), 오히려 루프에서 변수를 사용할 수 있기를 기대하는 것이 내가 발견한 대부분의 것입니다. 여기서 이것은 테스트 스크립트를 v1.0으로 업데이트할 때 나타납니다. 따라서 좋은 점은 대부분의 경우 사용자에게 오류가 표시되고 수정하는 것이 어렵지 않다는 것입니다.

나쁜 점은 루프 내부에 global x 를 넣어야 하는 것이 약간 장황하고 이제 REPL 코드도 함수 코드와 다르다는 것입니다. 이전보다 더 직관적인 동작인지 아닌지 는 하드/소프트 로컬 스코프에 분명히 일부 엣지 케이스가 있었고 설명 하기가 더 쉽기 때문에 어려운 의견입니다. 그러나 동시에 이전의 동작보다 훨씬 더 간결한 설명이 있으면서 범위 지정 규칙을 이해하는 것이 중요한 경우에 더 쉽게 접근할 수 있습니다. 🤷‍♂️.

저는 let 차단 실험을 ​​보고 싶습니다. 이렇게 하면 단순화된 범위 지정 설명과 함께 "당신은 정말로 그렇게 많은 전역을 원하지 않았다"라는 측면을 유지하면서 동시에 REPL 코드가 함수 내부처럼 동작하도록 만들 것입니다(외견상 우리가 항상 원했던 것 같습니다). 또는 그 반대로 사람들이 전역으로 작동하려는 변수를 지정하게 합니다.

global x = 5
for i = 1:5
  println(x+i)
end

명시성을 유지하는 좋은 방법이 될 수 있으며 "REPL 코드가 전역으로 인해 느림"을 훨씬 더 명확하게 만들 수 있습니다. 단점은 다시 한번 함수에 무언가를 던지는 데 global 마커가 필요하지 않다는 것입니다.

그러나 이것이 나타나는 경향을 감안할 때 실제로 게임을 깨거나 쇼스토퍼가 아닙니다. 어떤 워크숍에서나 언급해야 할 사마귀로 분류하고 싶지만 그것 때문에 v1.0을 사용할 수 없는 것은 아닙니다. 이 동작을 변경하는 것이 중단으로 분류되지 않고 v2.0이 필요하기를 바랍니다.

REPL이 함수 내부처럼 동작해야 한다는 생각이 마음에 들지는 않습니다. 분명히 그렇지 않으므로 전역 범위처럼 작동할 것으로 기대합니다. 나에게 REPL이 전역 범위처럼 작동하지 않는 것은 잠재적으로 이 문제를 일으키는 불일치보다 훨씬 더 혼란스러울 것입니다.

그럼에도 불구하고 최소한 문서는 이 문제에 대해 좀 더 명시적이어야 한다고 생각합니다. 자연스럽게 문서를 읽으면 기본적으로 전역 범위에서 동작이 발생하도록 local 키워드를 사용해야 한다고 가정했을 것입니다.

저는 let 차단 실험을 ​​보고 싶습니다. 이렇게 하면 단순화된 범위 지정 설명과 함께 "당신은 정말로 그렇게 많은 전역을 원하지 않았습니다"라는 측면을 유지하는 동시에 REPL 코드가 함수 내부처럼 동작하도록 만들 것입니다(이는 겉보기에 우리가 항상 원했던 것 같습니다)

"REPL은 함수 내부와 동일합니다"라고 생각한다면 outer 에 대해서도 생각해야 합니다.

julia> i = 1
1

julia> for outer i = 1:10
       end
ERROR: syntax: no outer variable declaration exists for "for outer"

대:

julia> function f()
          i = 0
          for outer i = 1:10
          end
          return i
       end
f (generic function with 1 method)

julia> f()
10

솔직히 지금 사람들이 이런 피드백만 하고 있다는 사실에 짜증이 납니다. 이 변경 사항은 10개월 동안 마스터에 있었습니다.

사람들은 대화식 사용이나 교육을 위해 마스터를 사용하지 않고 패키지를 업그레이드하는 데 마스터를 사용하고 있습니다. 패키지는 이것의 영향을 최소화하고 대부분 숙련된 프로그래머가 작성합니다.

(I 주장 어디하지만, # 19324에주고 피드백을했던 몇 사람 중 하나였다 이전 동작을 위해 .)

(이상적으로하지 암시 삽입하여이 중 비 깨는 방법은 이전 동작으로 다시 변경하는 것입니다 let - 그냥 이전 코드 복원 블록 또는 아무것도 julia-syntax.scm 에 옵션으로)를 REPL. 또는 IJulia와 같은 환경에서 사용할 수 있도록 하려면 soft_global_scope=false 플래그를 include , include_string 및 Core.eval 하여 복원하십시오. 오래된 행동.

(저는 #19324에서 피드백을 제공한 몇 안 되는 사람들 중 하나였습니다.

네, 감사합니다. 우리가 선택을 했기 때문에 지금은 별로 중요하지 않습니다. 10개월 동안 굽고 안정성에 대한 장기적인 약속을 가지고 출시했습니다. 그러므로 지금 해야 할 일은 앞으로 무엇을 해야 하는지에 집중하는 것뿐입니다.

이전 동작과 새 동작 중에서 선택할 수 있는 옵션이 있다는 것은 흥미롭지만 매우 해킹된 느낌입니다. 즉, 모든 사람이 분명히 혼란스러워하는 범위 지정 동작이 때때로 있을 뿐만 아니라 항상 있는 것은 아니며 포함 여부는 전역 플래그에 따라 다릅니다. 그것은 꽤 불만족스러운 느낌입니다.

이전 동작과 새 동작 중에서 선택할 수 있는 옵션이 있다는 것은 흥미롭지만 매우 해킹된 느낌입니다.

누군가가 "unbreak me" 소프트 스코프 AST 변환을 구현하면 IJulia, OhMyREPL 등에서 사용하고 싶을 것입니다. 이 시점에서 기본 REPL이 손상된 것으로 보이는 훨씬 더 문제가 되는 상황이 발생합니다.

내가 할 말은 그게 아니야. 분명히 우리는 이러한 모든 상황에서 동일한 솔루션을 사용해야 합니다. 그러나 범위 지정 규칙에 대한 두 가지 다른 변형으로 구현하는 것은 하나의 범위 지정 규칙 집합을 사용하여 코드 변환으로 구현하는 것보다 덜 깨끗해 보입니다. 그러나 아마도 그것들은 기능적으로 동등합니다. 그러나 새롭고 단순한 범위 지정 규칙 + REPL 스타일 입력을 가져와 평가하기 전에 변환하는 변환으로 설명하는 것이 더 쉬운 것 같습니다.

이는 최상위 수준의 비함수 범위 내에 할당된 경우 모듈에 있는 전역에 전역으로 주석을 추가하여 표현식을 변환하는 Meta.globalize(m::Module, expr::Expr) 로 수행할 수 있습니다. 물론 이전 파서가 한 것과 동일하다고 생각하지만 Meta.globalize 직접 호출하고 REPL이 평가하는 것을 볼 수 있기 때문에 조금 더 투명합니다.

이는 최상위 수준의 비함수 범위 내에 할당된 경우 모듈에 있는 전역에 전역으로 주석을 추가하여 표현식을 변환하는 Meta.globalize(m::Module, expr::Expr) 로 수행할 수 있습니다.

실제로 몇 분 전에 이와 같은 것을 구현하기 시작했습니다. 그러나 julia-syntax.jl 옵션으로 구현하는 것이 훨씬 쉬울 것 같습니다.

• 외부 AST 변환을 작성하는 것이 가능하지만, 기본적으로 범위 지정 규칙을 다시 구현해야 하는 까다로운 코너 케이스가 많이 있는 것처럼 보이지만 julia-syntax.scm 올바르게 가져오는 코드가 이미 있습니다.
• 현재 include_string 를 사용하여 전체 코드 블록을 평가하고 마지막 표현식의 값을 가져오는 IJulia와 같은 경우에는 훨씬 더 까다롭습니다. 표현식에 의한 구문 분석으로 전환해야 할 뿐만 아니라 원래 줄 번호(오류 메시지 등의 경우)를 유지하기 위해 약간의 해커가 필요할 수 있습니다. (여기에서도 작동할 수 있는 이런 종류의 ChangePrecision.jl에 대한 해킹을 찾았지만.)
• AST 변환에 의해 포착되지 않는 include 외부 파일의 경우는 말할 것도 없습니다.

그러나 새롭고 단순한 범위 지정 규칙 + REPL 스타일 입력을 가져와 평가하기 전에 변환하는 변환으로 설명하는 것이 더 쉬운 것 같습니다.

나는 이것이 대화식 사용이나 특정 플래그가 있는 include 대해 규칙이 덜 까다롭다고 말하는 것보다 새로운 사용자에게 설명하기가 더 쉬울지 심각하게 의심합니다.

다음은 globalize(::Module, ast) 구현의 대략적인 초안입니다. https://gist.github.com/stevengj/255cb778efcc72a84dbf97ecbbf221fe

좋아, 나는 줄 번호 정보를 보존하는 globalize_include_string 함수를 구현하는 방법을 알아냈고 그것을 내 요점에 추가했습니다.

사람들이 이 접근 방식을 좋아하는 경우 가능한(비중단) 방법:

1. globalize 등의 기능이 있는 SoftGlobalScope.jl 패키지를 릴리스합니다.
2. IJulia(및 Juno, vscode 및 OhMyREPL 가능)에서 SoftGlobalScope를 사용하십시오.
3. SoftGlobalScope 기능을 REPL stdlib 패키지의 향후 릴리스로 접고 REPL에서 사용하십시오.

아니면 즉시 REPL.jl로 롤링하는 것이 실용적입니까? 1.0에서 stdlib 업데이트가 작동하는 방식에 대해 완전히 명확하지 않습니다.

내가 그것을 깨지기 쉬운 원인이 될 무언가를 놓치고 있는 경우를 대비하여 내 구현을 살펴보십시오.

1.1에서 REPL의 기본이 아닌 기능으로 사용할 수 없습니까?

#28523 및 #28750의 중복입니다. 사람들에게 전역 변수에 대해 가르치고 싶지 않다고 말하는 사람들에게는 for 루프 전에 함수를 먼저 가르치는 것이 좋습니다. 어쨌든 함수는 더 기본적이며 코드가 함수로 작성되어야 한다는 기대치를 설정하는 데 도움이 됩니다. 불편함을 이해하지만 이 범위 지정 동작은 교육학적 이점으로 바뀔 수 있습니다. "사실 전역 변수는 특히 루프에서 사용하는 것이 너무 좋지 않아 언어에서 사용하기 위해 뒤로 몸을 굽히게 만듭니다."

이를 위해 REPL에 기본이 아닌 기능을 추가하는 것은 괜찮은 것 같습니다.

@JeffBezanson , 우리 중 많은 사람들이 선형 대수 및 통계와 같은 기술 과정에서 Matlab 등을 대신하여 Julia를 사용하고 싶어한다는 것을 기억하십시오. 이들은 프로그래밍 과정이 아니며 학생들은 프로그래밍 배경이 없는 경우가 많습니다. 우리는 구조적 프로그래밍을 절대 하지 않습니다. 거의 모든 것이 짧은 스니펫과 전역 변수와 상호작용합니다.

게다가 내가 동적 언어를 처음 사용하는 이유는 대화형 탐색과 보다 훈련된 프로그래밍 사이를 유연하게 전환하기 위해서입니다. 전역 및 함수 컨텍스트에서 동일한 코드를 사용할 수 없다는 것은 개념의 범위를 지정하는 데 익숙한 사람에게도 이를 방해하는 요소이며 CS가 아닌 배경의 학생들에게는 훨씬 더 나쁩니다.

우리 중 많은 사람들이 선형 대수 및 통계와 같은 기술 과정에서 Matlab 등을 대신하여 Julia를 사용하고 싶어한다는 것을 기억하십시오. 이들은 프로그래밍 과정이 아니며 학생들은 프로그래밍 배경이 없는 경우가 많습니다. 우리는 구조적 프로그래밍을 절대 하지 않습니다. 거의 모든 것이 짧은 스니펫과 전역 변수와 상호작용합니다.

Julia 사용자 중 많은 사람들은 CS 배경이 절대적으로 0이지만(저를 포함하여) 적절한 태도( 특히 학생의 경우)는 우리의 순진한 사람을 수용하기 위해 더 나쁜 변화를 요구하기보다는 배우려는 의지인 것 같습니다.

지금, 나는 반드시 나는 단지 여기에 무슨 일이 일어나고 있는지의 제한된 이해를 가지고있는이 특별한 변화가 악화 될 것이라고 암시하고 있지 않다, 그러나이 중요한 합병증 인 경우가 아니면 과도하게하면 쉽게 불필요하게 작성 코드를 잘못 수행하면 더 나은 강의 예제를 만들기 위해 변경할 가치가 없어 보입니다. 신입생에게 보여주는 정전기 사례를 실생활에 더 잘 적용할 수 있도록 물리 법칙을 변경할 수는 없습니다.

따라서 성능에도 신경을 쓰는 비 CS 사용자로서 내 질문은 이것이 기본 동작으로 설정되면 어떻게 망칠 것 같습니까? 문자 그대로 우리가 여기서 보고 있는 문제(내가 이미 알고 있었던)인 종류의 예입니까, 아니면 우리가 종종 더 미묘한 방식으로 이것을 나쁘게 망칠 가능성이 있습니까?

그만한 가치가 있기 때문에 코드를 둘러싸는 범위에 따라 다르게 동작하게 하는 것은 일반적으로 바람직하지 않은 기능이라는 데 동의합니다.

코드를 대화식으로 작성하기 어렵게 만들고, 첫 번째 루프를 작성하는 초보자가 모호한 범위 지정 규칙을 이해하도록 하고, 전역 범위에서 작동하지 않는 함수에서 붙여넣은 코드를 만드는 것은 프로그래머가 함수에서 빠른 코드를 작성하는 데 도움이 되지 않습니다. Julia를 대화식으로 사용하기가 더 어렵고 초보자에게는 더 어렵습니다.

1.1에서 REPL의 기본이 아닌 기능으로 사용할 수 없습니까?

"unbreak me" 옵션을 기본값으로 설정하는 것이 더 현명해 보입니다. 특히 초보자를 대상으로 하는 옵션은 더욱 그렇습니다. 기본 옵션이 아닌 경우 가장 필요한 사람들은 활성화되지 않은(그리고 옵션이 있는지도 모르는) 사람들일 것입니다.

제안된 REPL 모드는 include ed 스크립트에 무엇을 합니까? 전역 명령문의 평가는 REPL 모드가 활성화되었는지 여부에 따라 달라집니까? 그렇다면 IMO는 1.0 안정성 약속과 상충됩니다.

우리가 이와 같은 작업을 수행했다면 모듈이 작동 방식을 결정하는 것이 합리적일 것 같습니다. 따라서 Main 는 "소프트 범위" 모듈이 되고 기본적으로 다른 모듈은 "하드 범위" 모듈이 됩니다.

@stevengj 의 globalize 기능을 사용하기 위해 REPL을 원숭이 패치하는 것이 가능한지 확인하는 데 관심이 있었고, 많은 노력을 들이지 않은 것으로 보입니다. 요점을 참조하십시오. 이것은 Juno(또는 Core.eval 직접 호출하는 다른 모든 것)에서는 작동하지 않습니다.

나는 이것을 사람들에게 추천 하지 않을 것이지만, 빠르고 더러운 데이터 분석을 할 때 나에게 꽤 유용합니다. 함수에서 REPL로 코드를 복사하여 붙여넣을 수 없을 때 경험이 없고 종종 꺼려하는 코더(즉, 제 학생)에게는 매우 혼란스럽기 때문에 (더 나은 생각을 가진) 솔루션을 보고 싶습니다. 그것이하는 일과 그 반대의 경우도 마찬가지입니다.

julia> a = 0                                                                
0                                                                           

julia> for i = 1:10                                                         
         a += i                                                             
       end                                                                  
ERROR: UndefVarError: a not defined                                         
Stacktrace:                                                                 
 [1] top-level scope at .\REPL[2]:2 [inlined]                               
 [2] top-level scope at .\none:0                                            

julia> using SoftGlobalScope                                                
[ Info: Precompiling SoftGlobalScope [363c7d7e-a618-11e8-01c4-4f22c151e122] 

julia> for i = 1:10                                                         
         a += i                                                             
       end                                                                  

julia> a                                                                    
55                                                                          

(BTW: 위의 테스트는 거의 테스트한 것입니다!)

제안된 REPL 모드는 포함된 스크립트에 무엇을 합니까?

아무것도. 기본적으로 제안은 대화형 프롬프트에서 입력된 코드에만 해당됩니다. 파일에 무언가를 담기 시작하자마자 "하드 스코프" 규칙을 배워야 합니다. 바라건대, 코드를 파일에 넣을 때 함수 사용을 시작해야 합니다.

프롬프트보다 파일의 전역 코드에 대해 더 엄격한 범위 지정 규칙이 있는 것은 이상적이지 않습니다. 그러나 Julia 1.0 안정성 약속과 결합된 #19324는 우리에게 이상적인 옵션이 없다고 생각합니다.

@stevengj :

@JeffBezanson , 우리 중 많은 사람들이 선형 대수 및 통계와 같은 기술 과정에서 Matlab 등을 대신하여 Julia를 사용하고 싶어한다는 것을 기억하십시오. 이들은 프로그래밍 과정이 아니며 학생들은 프로그래밍 배경이 없는 경우가 많습니다. 우리는 구조적 프로그래밍을 절대 하지 않습니다. 거의 모든 것이 짧은 스니펫과 전역 변수와 상호작용합니다.

Matlab/R/...에 대한 사전 노출이 있는 학생들에게 Julia를 사용하는 과정을 가르쳤던 저는 이러한 우려에 공감합니다. 그러나 동시에 Julia를 Matlab 등의 대체물로만 사용하는 것은 실행 가능한 접근 방식이라고 생각하지 않습니다. Discourse 및 StackOverflow에 대한 질문에서 수없이 입증된 바와 같이 이는 수정하고 이해하기 어려운 성능 함정으로 이어질 수 있습니다. Julia가 이러한 다른 언어와 어떻게 다른지 이해하는 데 투자하는 것보다 훨씬 더 많은 비용이 필요할 수 있습니다("Matlab에서 이 코드를 번역했으며 10배 느림"이라는 주제의 게시물 참조).

핵심 문제는 침묵의 실패라고 생각합니다. 문제 자체 는 이해하고 수정하기 쉽습니다. 새로운 동작을 유지하되 Main 경고를 표시하는 것이 좋습니다(기본적으로 비활성화할 수 있어야 함).

나에게 더 큰 문제는 인지된 불일치입니다. 즉, Julia가 일을 다르게 하는 것은 괜찮지만:

• 함수에서 붙여넣은 코드가 REPL에서 작동하지 않는 이유는 무엇입니까?
• 내가 사용한 다른 언어에는 이 동작이 없으며 채택에 대한 또 다른 장벽입니다.
• for 블록이 begin 및 if 블록과 다르게 작동하는 이유는 무엇입니까? ( if 이해는 하지만 블록은 [반드시] 블록이어야 합니다.).

총알 2에 관해서는 이것이 Julia를 한동안 사용해 온(그리고 언어에 전념하는) 우리가 이해할 수 있는 것보다 더 큰 문제라고 생각합니다. 나는 Julia로 코드를 작성하도록 내 그룹을 설득하는 데 현재 0/7이라고 말할 수 있습니다. 그 중 2개는 이 for 루프 문제로 인한 것이었습니다. 이 문제는 이전에 노출되지 않았기 때문에 설명할 수 없었습니다. 나머지는 내 카리스마 부족을 분필 할 수 있다고 생각합니다.

내가 선호하는 것은 함수에서 REPL로 붙여넣은 코드가 함수와 동일하게 동작하도록 하고 for 루프를 사용하여 데이터를 대화식으로 분석할 때 예상한 대로 수행하는 것입니다. 즉, 특별한 키워드 없이 지시될 때 외부/전역 변수를 변경합니다.

Julia를 Matlab 등의 대체물로 사용하는 것은 실행 가능한 접근 방식이라고 생각하지 않습니다. Discourse 및 StackOverflow에 대한 질문에서 수없이 입증되었듯이, 이는 수정하고 이해하기 어려운 성능 함정으로 이어질 수 있으며 더 많은 비용을 수반할 수 있습니다. Julia가 이러한 다른 언어와 어떻게 다른지 이해하는 데 투자하는 것보다

미안하지만 이 주장은 나에게 우스꽝스럽다. 프로그래밍을 가르치는 수업에 대해 말하는 것이 아닙니다. 간단한 대화형 계산을 위한 장소가 있으며 CS가 아닌 수업에서는 프로그래밍 언어에 처음부터 "영광스러운 계산기"로 소개하는 것이 일반적입니다. Julia에서 성능 컴퓨팅을 가르치는 것은 완전히 다른 프로세스입니다. 하지만 이미 Julia를 "계산기"로 사용하고 있다면 문제가 되지 않습니다.

학생들에게 "계산기"로 Matlab을 소개하는 것부터 시작하면 "실제" 프로그래밍으로 전환하는 것이 훨씬 더 어렵습니다. 왜냐하면 그들의 첫 번째 본능은 배를 타기 전에 Matlab으로 가능한 한 많은 일을 하는 것이고, 이 지점에서 나쁜 습관이 생기기 때문입니다. 그들은 뿌리를 내리고 새로운 언어를 배우는 것을 꺼립니다. 대조적으로, Julia를 영광스러운 계산기로 시작한다면 더 진지한 프로그래밍을 할 때 사용할 수 있는 옵션의 범위가 훨씬 더 넓어집니다. 모든 것을 "벡터" 작업으로 몰아넣거나 제대로 하기 전에 나쁜 일을 하도록 강요할 필요가 없습니다.

선형 대수 과정 에서 Julia를 사용하면 안 된다는 말씀이신가요? 아니면 컴퓨터 과학과 선형 대수학을 가르칠 준비가 된 경우에만 사용해야 합니까?

나는 @stevengj 의 문제(프로그래머가 아닌 사람에게 가르치는 것이 훨씬 더 어려워

이것은 REPL에서의 대화형 디버깅이 필요 이상으로 고통스럽지 않고(또는 신규 사용자에게 더 혼란스러워지지 않기 때문에) 좋은 절충안처럼 들립니다. 반면 스크립트의 일반 코드는 엄격한 범위 지정 규칙을 따라야 하고 일부를 덮어쓰는 버그로부터 안전합니다. 우연히 변수.

선형 대수 과정에서 Julia를 사용하면 안 된다는 말씀이신가요? 아니면 컴퓨터 과학과 선형 대수학을 가르칠 준비가 된 경우에만 사용해야 합니까?

당신은 내가 말한 것을 잘못 이해했을 수 있습니다 (또는 내가 명확하게 표현하지 않았습니다). 나는 Julia를 사용 하여 특정 영역(예: 나는 경제 대학원생들에게 수치적 방법을 가르쳤음)을 가르치기 위해 CS 과정(경험이 없음)이 아닌 과정에 대해 이야기하고 있었습니다.

내가 말하려고 했던 요점은 Julia와 언어 X(Matlab일 수 있음) 사이에 어느 정도의 차이를 예상하는 것이 합리적이라는 것입니다. 반대로 이를 무시하면 문제가 발생할 수 있습니다.

개인적으로, 저는 새로운 언어를 배울 때 이러한 문제에 일찍 직면하는 것을 선호합니다. 또한 장기적으로 다른 언어와의 유사성보다 언어 의미의 단순성과 일관성이 더 중요하다고 생각합니다. 그러나 나는 이러한 선호도가 주관적이라는 것을 알고 있으며 합리적인 사람들은 다른 선호도를 가질 수 있습니다.

(등록되지 않은) 패키지를 만들었습니다. https://github.com/stevengj/SoftGlobalScope.jl

이것이 합리적으로 보인다면 계속해서 패키지를 등록한 다음 IJulia에서 기본적으로 사용할 수 있습니다(아마도 Juno 등에 PR 제출).

내가 말하려고 했던 요점은 Julia와 언어 X(Matlab일 수 있음) 간에 일정 수준의 차이를 기대하는 것이 합리적이라는 것입니다.

확실히. 내가 "Matlab 대신 Julia를 사용하라"고 말할 때 내가 그들에게 Julia에서 Matlab 구문을 가르치려고 하는 것도 아니고 특별히 이전 Matlab 사용자를 대상으로 하는 것도 아닙니다.

나는 이러한 문제에 일찍 직면하는 것을 선호합니다.

Matlab 자체와의 차이점에 관한 것이 아닙니다. 난 정말이 아니라 로컬 범위 대 글로벌과의 유용성에 대해 이야기하지 않을 global 그들이에서 코드를 붙여 정적 분석을위한 키워드 내가 아닌 CS 학생, 또는 처음의 앞에 루프를 작성 처음 기능을 REPL에 삽입하여 대화식으로 시도합니다. 대신 루프를 사용하여 표현하려는 수학에 집중하고 싶습니다.

여기 있는 누구도 부드러운 대화형 범위가 Matlab 사용자가 기대하는 것이기 때문에 논쟁하지 않습니다. "범위"라는 익숙하지 않은 개념에 대해 길게 가 탈선 할 때문에 우리가 이를 주장하는 것 입니다 . (그리고 숙련된 사용자라도 대화식으로 작업할 때 global 키워드를 강제로 추가하는 것은 다소 불편합니다.)

여기에 언급되지 않은 또 다른 수정 사항은 단순히 'for'가 범위 블록을 정의하는 것을 중지하는 것입니다(기능만 사용하고 새 범위를 생성함).

@vtjnash , 나는 Julia 2.0 이전에 우리가 할 수 있는 일에 이 논의를 집중하고 싶습니다. 대화형 모드가 다르게 작동하는 것은 임시방편일 뿐이라는 데 동의하며 몇 년 안에 범위 지정 규칙을 변경하는 것을 진지하게 고려해야 합니다.

좋은 점, 이것도 import Future.scope 😀

(이 모듈/네임스페이스/행동 효과는 이미 예약/존재한다고 생각합니다)

여기에서 상기시키듯이, 변경 사항은 해당 모듈에서 이전에 평가된 다른 항목에 관계없이 코드가 모든 전역 범위 환경에서 동일하게 동작하도록 하는 것이었습니다. 이 변경 이전에는 동일한 코드를 두 번 실행하거나 파일에서 이동하여 완전히 다른 답변(다른 범위 할당으로 인한 결과)을 얻을 수 있었습니다.

이 변경 이전에는 동일한 코드를 두 번 실행하거나 파일에서 이동하여 완전히 다른 답변(다른 범위 할당으로 인한 결과)을 얻을 수 있었습니다.

실제로 (0) 그것에 대해 내가 본 불만의 수는 현재 행동에 대해 보게 될 (그리고 이미보고있는) 불만과 혼란의 수에 비해 확실히 줄어들 것입니다.

이 변경 이전에는 동일한 코드를 두 번 실행하여 완전히 다른 응답(다른 범위 할당으로 인한 결과)을 얻을 수 있었습니다.

아래 코드에서 a 가 첫 번째와 두 번째 for 루프 사이에서 변경된다는 것을 의미합니까? 제 생각에는 버그가 아니라 예상된 동작입니다.

a = 0
for i = 1:5
  a += 1
end

for i = 1:5
  a += 1
end

제안된 REPL 모드는 포함된 스크립트에 무엇을 합니까?

@mauro3 @stevengj 기능 추가(예: exec("path/to/script.jl") )가 마이너 버전 범프로 수행될 수 있다고 생각합니까? exec 'ed 스크립트에서 exec 'ing 다른 파일을 경고한 다음 include 를 사용하도록 유도하기 위해 일부 교육학적 메시지를 거기에 넣을 수도 있습니다.

내가 어젯밤에 이 문제에 대해 머리를 싸매고(다시 한 번) 최선의 행동 방침이 무엇인지 알아 내려고 노력하면서 몇 가지 생각을 적었습니다. 결론은 없지만 이것이 문제를 아주 명확하게 제시한다고 생각합니다. 이 문제에 대해 몇 년 동안 생각해 본 결과 "이상적인 솔루션"이 없다고 생각합니다. 이것은 차선책만 있는 문제 중 하나일 수 있습니다.

사람들은 순진하게 전역 범위를 지역 범위를 둘러싸는 재미있는 종류로 봅니다. 이것이 전역 범위가 Julia 0.6 및 이전 버전에서와 같이 작동한 이유입니다.

• 외부 지역 범위가 지역 변수를 생성하고 내부 지역 범위가 이에 할당되면 해당 할당이 외부 지역 변수를 업데이트합니다.
• 외부 전역 범위가 전역 변수를 만들고 내부 지역 범위가 여기에 할당하는 경우 해당 할당은 이전에 외부 전역 변수를 업데이트했습니다.

그러나 주요 차이점은 다음과 같습니다.

• 외부 지역 변수의 존재 여부는 설계상 외부 지역 범위에 있는 표현식의 출현 순서나 실행에 의존하지 않습니다.
• 그러나 전역 변수의 존재 여부는 전역 범위에서 표현식을 한 번에 하나씩 평가하기 때문에 순서와 무관할 수 없습니다.

게다가, 전역 범위는 종종 꽤 길기 때문에(여러 파일에 자주 퍼져 있지는 않음) 표현식의 의미가 다른 표현식으로부터 임의의 거리에 의존하는 것은 "원거리에서 으스스한 동작" 효과이므로 매우 바람직하지 않습니다. .

이 마지막 관찰은 전역 범위에서 두 가지 다른 버전의 for 루프가 다르게 동작하는 것이 문제가 되는 이유를 보여줍니다.

# file1.jl
for i = 1:5
  a += 1
end

# file2.jl
a = 1



md5-f03fb9fa19e36e95f6b80b96bac9811e



```jl
# main.jl
include("file1.jl")
include("file2.jl")
include("file3.jl")

또한 file1.jl 와 file3.jl 은 동일하며 매번 다른 의미와 동작으로 동일한 파일을 두 번 포함하여 예제를 단순화할 수 있습니다.

또 다른 문제는 장기 실행 REPL 세션입니다. 온라인 어딘가에서 예제를 시도하시겠습니까? 예제가 for 루프 또는 유사한 구성에서 지역 변수에 사용하는 것과 같은 이름의 전역 변수가 있어서 실패합니다. 따라서 새로운 행동이 혼란을 일으킬 수 있는 유일한 행동이라는 개념은 확실히 정확하지 않습니다. 나는 새로운 행동이 REPL의 사용성 문제라는 데 동의하지만 대화를 부드럽게 하고 다른 쪽을 여기에서 명확하게 제시하고 싶습니다.

repl 문제를 다루지는 않지만 최소한 비대화식으로 언어를 가르칠 때 교훈적인 목적으로 유용할 것이라는 나의 작은 제안: 포트란에서 수행할 수 있는 것처럼 "프로그램"이라는 메인 블록을 정의하십시오. 위의 "let...end"와 동일하지만 더 자연스러운 표기법을 사용합니다.

프로그램 테스트
...
끝

범위 세부 사항으로 들어가지 않고 언어를 가르칠 수 있으며 결국에는 그 점에 대해서만 논의할 수 있습니다.

또 다른 문제는 장기 실행 REPL 세션입니다. 온라인 어딘가에서 예제를 시도하시겠습니까? 예제가 for 루프 또는 유사한 구성에서 지역 변수에 사용하는 것과 같은 이름의 전역 변수가 있어서 실패합니다.

화가 난 사용자들이 이에 대해 얼마나 많은 메일링 리스트 불만 사항과 github 문제를 제기했습니까? 제로, 내 계산으로. 왜요? 아마도 이 동작이 근본적 으로 사람들에게

따라서 새로운 행동이 혼란을 일으킬 수 있는 유일한 행동이라는 개념은 확실히 정확하지 않습니다.

나는 이것이 잘못된 동등성이라고 생각합니다. 여기 에는 잠재적인 혼란 수준에 큰 차이가 있습니다. 줄리아 0.6, 나는 초에 학생으로 예를 들어 설명 할 수있다 : "아,이 루프에 따라 달라 참조 a 당신이 여기 변경하는." Julia 1.0에서는 선형대수학 강의를 듣는 중에 한 번도 들어본 적이 없는 학생들 앞에서 미스터리하게 global 키워드를 입력해야 하는 경우 어떻게 해야 할지 솔직히 걱정이 됩니다. CS 의미에서 "범위".

몇 년 안에 범위 지정 규칙을 변경하는 것을 진지하게 고려해야 합니다.

절대적으로하지. 루프 범위의 v0.2 이전 세계(#1571 및 #330 참조)로 돌아가시겠습니까?

우리는 실제로 코드를 한 줄씩 REPL에 복사하여 붙여넣는 기능을 완전히 지원한 적이 없습니다. 그래서 우리는 이것을 일을 할 수 있는 기회로 볼 수 있습니다. 특히 for 루프에서는 "작동"했지만 내부 함수에서는 작동하지 않았습니다.

x = 0
f(y) = (x=y)

함수 내에서 f 는 첫 번째 줄에서 x 를 변경합니다. REPL에서는 그렇지 않습니다. 그러나 SoftGlobalScope.jl에서 이와 같은 변환을 사용하면 작동할 수 있습니다. 물론 독립 실행형 함수 정의를 붙여넣는 작업이 작동하지 않기 때문에 기본적으로 이 기능을 켜고 싶지 않을 것입니다. 가장 먼저 떠오르는 것은 라인별 함수 디버깅을 위한 REPL 모드입니다.

진심으로 v0.2 이전의 세계로 돌아가고 싶습니까?

아니요, 0.6의 세계로 돌아가고 싶습니다. 😉

나는 다음과 같이 더 많이 응답했다고 생각합니다.

여기에 언급되지 않은 또 다른 수정 사항은 'for'가 범위 블록을 정의하지 않도록 하는 것입니다.

우리는 실제로 코드를 한 줄씩 REPL에 복사하여 붙여넣는 기능을 완전히 지원한 적이 없습니다. 그래서 우리는 이것을 일을 할 수 있는 기회로 볼 수 있습니다.

이 감정에 매우 감사하며 사용 사례에 대해 정말 도움이 될 것입니다. 내 관점에서 이것은 언어의 범위 지정 규칙을 직접 변경하는 것보다 REPL을 가능한 한 유용하게 만드는 것에 관한 것입니다.

즉, 이 문제에 대해 더 많이 생각할수록 REPL이 수행해야 하는 작업에 대해 (개인적으로) 가지고 있는 상충되는 견해를 보게 됩니다.

구체적으로 말하면, REPL이 함수 본문의 범위 지정 규칙과 일치한다면 매우 좋아할 것입니다. 즉, 변수는 전역적이기보다는 지역적이며 함수에서 직접 코드를 복사하여 붙여넣을 수 있으며 작동할 것임을 알 수 있습니다. 나는 순진한 구현이 형식의 let-block wrap(이전에 언급했듯이)과 같은 것이라고 상상합니다.

julia> b = a + 1

로 변신 중

let a = _vars[:a]::Float64 # extract the variables used from the backing store
    # Code from the REPL
    b = a + 1
    # Save assigned variables back to the backing store
   _vars[:b] = b
end

제대로(즉, 자신이 무엇을 하고 있는지 아는 사람에 의해) 완료되면 기존 REPL에 비해 많은 이점이 있을 것이라고 생각합니다. 1. 대화형 데이터 분석/계산이 포함된 이전 워크플로가 작동합니다. 2. 기본 응답이 "전역 변수로 벤치마킹을 중지"하는 Discourse의 게시물이 훨씬 적습니다. 모든 것이 지역적이며 빠르기를 바랍니다! :) 3. 함수 본문에서 복사 및 붙여넣기가 예상대로 작동합니다. 4. 백업 저장소가 일종의 Dict인 경우 workspace() 와 같은 기능은 간단합니다. 그냥 지우세요. 5. 전역이 명시적으로 됩니다. 특별히 전역이 되도록 요청하지 않는 한 사물은 지역적입니다. 이것은 내 관점에서 볼 때 큰 장점입니다. 저는 묵시적으로 전역을 만드는 것을 좋아하지 않습니다. 아주 사소한 마지막 요점(그리고 나는 이것을 추가하기를 주저합니다!), 이것은 Matlab의 동작과 일치하여 사람들이 더 쉽게 전환할 수 있도록 합니다. Matlab REPL에서 명시적으로 전역으로 주석이 지정되지 않는 한 모든 변수는 로컬인 것처럼 보입니다.

몇 시간 전까지만 해도 이 이야기는 나에게 훌륭하게 들렸다. 그러나 함수에 대한 Jeff의 의견 이후에 독립 실행형 함수 정의에 붙여넣기에 대해 생각했고 함수 정의가 전역 범위에 들어가야 하기 때문에 이 접근 방식이 기본적으로 이를 방지하는 방법에 대해 생각했습니다. 하지만 그들은 로컬 범위 (내부 기능)로 가서 무엇을 목적으로한다면? 두 가지 가능성을 명확하게 하는 정보가 없습니다. 로컬 범위와 전역 범위가 있는 두 가지 REPL 모드가 필요한 것 같습니다. 한편으로는 매우 혼란스러울 수 있지만(Discourse 게시물을 상상해 보세요...), 다른 한편으로는 매우 유용할 수 있습니다. (두 REPL 모드를 사용하는 것도 새로운 기능을 도입하는 것이기 때문에 문제가 되지 않습니다. :) )

SoftGlobalScope.jl 의 중간 집으로 가는 것이 가장 혼란스러운 절충안이 될 수 있지만 내 걱정은 이것이 기억해야 할 또 다른 규칙이라는 것입니다(REPL에서는 작동하지만 내 함수 본문/전역 범위에서는 작동하지 않으며 반대로).

긴 게시물에 대해 사과하지만 이것이 사용성에 중요하다고 생각합니다.

화가 난 사용자들이 이에 대해 얼마나 많은 메일링 리스트 불만 사항과 github 문제를 제기했습니까? 제로, 내 계산으로. 왜요? 아마도 이 동작이 근본적으로 사람들에게 놀라운 일이 아니기 때문일 것입니다. 전역 범위에서 작업하는 경우 전역 상태에 의존합니다.

흠, 이거 정말 체계적으로 연구하신 건가요? 나는 그것을 놓친 것임에 틀림없다. 그럼에도 불구하고 이것이 이 동작이 버그나 예상치 못한 결과의 원인이 아님을 의미하지는 않습니다. 사용자가 알아낸 후 올바른 동작으로 인식되어 문제/불만 제기하지 않았습니다.

Julia 1.0에서는 선형대수학 강의를 하는 도중에 불가사의하게 전역 키워드를 입력해야 하는 경우 어떻게 해야 할지 솔직히 걱정이 됩니다.

이 문제에 공감합니다. 학생들에게 코스에 필요한 몇 가지 간단한 프로그래밍을 가르쳤을 때 저는 일반적으로 함수에 코드를 래핑하고 function 및 end 를 주석 처리하고 실행하는 것 사이를 왔다 갔다 하라고 제안했습니다. 글로벌 범위에서, 그래서 그들은 무슨 일이 일어나고 있는지 조사할 수 있습니다. 이것은 Julia의 당시 디버깅 인프라 부족을 거의 보완했습니다.

이 접근 방식은 더 이상 실현 가능하지 않은 것 같습니다. 그러나 어쨌든 그것이 정말로 올바른 방법인지 궁금하며 그동안 여러 가지가 많이 개선되었습니다(#265 수정, Revise.jl 및 최근 Rebugger.j 는 워크플로/디버깅을 상당히 개선했습니다).

이 문제는 숙련된 사용자를 크게 괴롭히지 않는 것으로 보이며, 주요 관심사는 교육 환경의 혼란입니다. 나는 아직 이것을 직접 실험해보지 않았지만, 대신에 우리의 교수법을 적용할 수 있는지 궁금합니다. 예를 들어 루프 전에 함수를 도입하고 전역 범위에서 루프를 피하십시오. 이것들은 어쨌든 좋은 스타일의 요소이며 학생들에게 도움이 될 것입니다.

간단한 참고 사항: REPL의 전역 범위를 특수 케이스로 지정하면 함수 안팎으로 코드를 복사하여 붙여넣을 수 있지만 다른 모듈의 전역 범위로 복사하여 붙여넣을 수 없습니다.

예를 들어 루프 전에 기능을 도입하고 전역 범위에서 루프를 피하는 것과 같이 교육에 대한 접근 방식을 조정할 수 있는지 궁금합니다.

이것은 프로그래밍 교육에 중점을 두지 않는 수업에서는 완전히 비실용적입니다. 대화식으로 사용할 수 없거나 먼저 모든 기능을 위한 함수를 작성해야 하는 경우 수업에서 Julia를 사용하지 않는 것이 좋습니다.

(그리고 단순히 교육적인 것이 아닙니다. 글로벌 범위의 루프는 대화형 작업에 유용 합니다. 그리고 사람들이 기술 컴퓨팅을 위한 동적 언어를 좋아하는 주된 이유 중 하나는 대화형 탐색을 위한 시설입니다. 모든 코딩이 성능 지향적이지는 않습니다.)

사람들이 오래된 "소프트/하드 범위" 구분에 대해 혼란스럽거나 불평하는 수년 동안 수십 개의 스레드와 문제가 있었습니다. 사실이 아니다. 나는 그들 중 일부를 파헤칠 수 있었지만 @stevengj 님이 주변에

@StefanKarpinski , 저는 특히 전역 루프가 전역 상태에 의존한다고 불평하는 사람들을 언급하고 있습니다. 나는 이것이 나쁜 행동이라고 불평하는 사람을 기억하지 못하며 이것에 대한 어떤 예도 찾을 수 없습니다.

나는 사람들이 언제 어디서 할당이 새로운 변수를 정의하는지에 대해 혼란스러워한다는 데 동의하지만 일반적으로 다른 방향이었습니다. 그들은 로컬 범위가 (그 반대가 아니라) 더 전역적으로 작동하기를 원하거나 begin 사이의 구별이 없기를 원했습니다 let . IIRC에서 불만은 전역 루프에서 전역 변수에 할당하는 것이 전역을 수정하는 놀라운 부작용이 있다는 것이 아닙니다.

범위 지정의 전체 문제는 새로운 사용자에게 혼란을 주며 앞으로도 그럴 것입니다. 그러나 혼란스러운 부분은 전역 변수 이름에 할당하는 것이 전역 상태에 영향을 미치는 경우가 아닙니다. 현재의 행동은 이것을 더 나쁘게 만드는 것이 아니라 더 나쁘게 만듭니다.

@StefanKarpinski : 이전에는 소프트/하드 범위에 대한 혼동이 (사람들이 예상치 못한 결과를 얻는) 실용적인 것보다는 (매뉴얼을 읽는 사람들의) 이론적인 성격에 더 여기 의 검색 결과가 이것을 뒷받침하는 것입니다. 여기 에서 하나의 반대 예를 찾았

반면에 이 새로운 동작은 매뉴얼을 읽을 때 사람들을 혼란스럽게 하지 않고 REPL을 사용할 때 혼동을 줄 것입니다. 틀림없이 후자가 더 나쁘다.

SoftGlobalScope.jl 은 이제 등록된 패키지입니다. 내 의도는 적어도 이번 학기에 IJulia에 대해 기본적으로 활성화(옵트아웃)하는 것입니다.

@mauro3 , "반대 예"조차도 소프트 범위가 아닌 하드 범위로 혼동되는 사람에 관한 것입니다. 0.7에서 더 많은 범위를 "하드"하게 만드는 것은 이러한 종류의 혼란을 더 많이 일으킬 것이 확실합니다.

IJulia는 기본적으로 변수를 로컬로 할 수 있는 흥미로운 가능성을 가지고 있음을 지적하고 싶습니다. 즉, 단일 블록에서 이 작업을 수행하면 다음과 같이 작동합니다.

t = 0
for i = 1:n
    t += i
end
t

... 그리고 t 는 이 평가 블록 내에서만 볼 수 있습니다. 외부에서 볼 수 있도록 하려면 다음을 수행해야 합니다.

global t = 0
for i = 1:n
    global t += i
end
t

또한 블록이 모듈이 아닌 파일인 Julia에 대해서도 유사한 접근 방식을 고려했습니다. 즉, 최상위 범위에서 t = 0 를 수행하면 전역 변수가 아닌 파일 로컬 변수가 생성됩니다. 진정한 전역 변수를 선언하려면 global t = 0 를 작성해야 합니다. 그러면 모듈 전체에서 볼 수 있습니다. 어쩌면 너무 이상할 수도 있지만 수년 동안 나에게 여러 번 발생했습니다.

IJulia는 기본적으로 변수를 로컬 do 블록으로 만드는 흥미로운 가능성을 가지고 있습니다.

@StefanKarpinski , 나는 이것이 훨씬 더 혼란스럽고 노트북이 일반적으로 사용되는 방식과 반대가 될 것이라고 생각합니다. 동일한 변수가 여러 셀에서 사용/수정되는 것이 일반적이므로 모든 셀 간 변수에 대해 global 키워드를 요구하는 것은 나에게 시작하기 어려운 일입니다. 문제보다 범위 개념에 대한 더 많은 논의가 필요할 것입니다. for 루프와 함께 여기에서 논의했습니다.

우리 모두가 동의하는 한 --- 우리가 생각하는 것처럼 --- 이것이 대부분 또는 전적으로 상호 작용의 문제라고 생각한다면 앞으로 나아갈 수 있는 방법이 있습니다. REPL에서 이것을 특별한 경우(IJulia에 대해 수행되는 것처럼)로 지정하는 경우 유일한 나쁜 경우는 REPL에서 무언가를 개발한 다음 이를 최상위 스크립트 코드로 이동하는 것입니다. 틀림없이 그것이 기능을 도입해야 하는 지점이므로 그렇게 나쁘지 않다고 생각합니다. REPL과 함수 본문 사이에 코드를 복사하여 붙여넣는 것이 (대부분) 작동할 것입니다. 이 정도면 충분할 것입니다.

그런 다음 REPL 변수를 REPL에 로컬로 지정하여 구별을 추가로 정당화/명확하게 하는 옵션도 있습니다. 즉, Main.x 로 사용할 수 없는 일반 전역 변수가 아닙니다. 이것은 @StefanKarpinski 가 위에서 제안한 것과 매우 유사하지만 모든 입력 블록/셀에서 공유됩니다.

실용적인 관점에서 REPL에서 이 "고정"을 얻는 것은
교육/비프로그래머 사용자에게만 중요합니다. 이 행동도
REPL(부분을 복사하여 붙여넣기)을 통해 대화형 디버깅을 수행합니다.
비실용적. 이 디버깅 모드가 때때로 더 나을 수 있습니다(심지어
훌륭한 디버거 및) 경험 많은 프로그래머에게도 (종종
동적 언어를 선호하는 이유). 물론 경험자에게
프로그래머는 선택 사항인 것이 문제가 되지 않습니다. 초보 사용자의 경우
기본값이 바람직합니다.

@StefanKarpinski
순진한 프로그래머로서, 나는 실제로 보는 것이 그렇게 잘못된 것이 무엇인지 알지 못합니다.
특히 동적 영역에서 로컬 범위를 둘러싸는 재미있는 종류의 전역 범위
언어. 나는 컴파일러의 관점에서 그것이 아니라는 것을 이해합니다.
(Julia에서) 반드시 정확하지만 훌륭하고 쉽고 유용한 모델입니다.
(순진한) 프로그래머를 위해. (나는 또한 그것이 실제로 그런 식으로 구현되었을 수도 있다고 생각합니다.
일부 언어).
Julia는 또한 그것을 프로그래머에게 그렇게 제시하는 것 같습니다.
다음 함수 함수는 "정의되지 않음" 오류를 제공합니다.
for 루프 앞에 =1이 있으면 수행되지 않습니다.

기능 검사()
나는 = 1:10
에이=아+나
끝
a=1
@보여줘
끝

내가 완전히 오해하지 않는 한, "
외부 지역 변수는 의도적으로 존재하며, 순서에 의존하지 않습니다.
외부 로컬 범위에서 표현식의 출현 또는 실행".

나는 "원거리에서 으스스한 행동"을 피하는 것에 매우 동의하며,
함수/호출 스택에서 전역 사용에 대한 명시적 정의 선호
수준이며 개인적으로 파일에서 로드하는 것과 같은 것을 갖고 싶습니다.
자체 범위 및 전역 변수 사용에 대한 명시적 정의가 필요합니다.
루프 수준에서 나에게는 약간 멀리 가고 있습니다.
정의/문맥은 일반적으로 매우 가깝습니다.
3개의 파일 예제는 약간 인위적입니다(예상된 "not
정의됨" 오류): 일반적으로 초기 정의를 동일한 위치에 넣습니다.
파일.
여기에는 실제 으스스한 위험이 있습니다(그리고 나는 그것에 물렸습니다.
다른 언어)에서 포함은 전역 범위에서 실행되므로
다른 변수를 방해할 수 있는 전역 변수를 실수로 정의하고 있습니다.
암호. 그러나 루프에서 전역을 사용해야 하는 것은 해결 방법이 아닙니다.
이 문제.

장기 실행 REPL 세션에 wrt:
현재 동작은 매우 드물고 발견하기 쉬운 오류 모드를 대체합니다.
REPL에서 온라인 예제를 실행하기 위해(당신은 복사/붙여넣기를 놓쳤습니다)
루프 전에 변수의 초기 정의 및 이미
이전 항목에서 전역적으로 정의된 동일한 변수)
기능의 일부인 경우 온라인 예제를 올바르게 실행할 수 있음
(모든 곳에 전역을 추가하지 않고) 문제를 해결하지 못하는 경우
그렇지 않음(global이 이미 온라인 코드에 있는 경우에도 계속 사용합니다.
이미 존재하는 전역 변수의 잘못된 값)

나는 이것을 더 일찍 조정했어야 했지만, 잠시 우려한 후에 모든 것이 잘 된 것 같습니다.

우리는 실제로 코드를 한 줄씩 REPL에 복사하여 붙여넣는 기능을 완벽하게 지원한 적이 없습니다. 가장 먼저 떠오르는 것은 줄 단위 함수 디버깅을 위한 REPL 모드입니다.

실제로 Rebugger(정확히 해당)는 0.7의 사용 중단 범위가 부족하고 0.6에서 작동하도록 만들 수 없기 때문에 1.0에서 제대로 작동합니다. 그러나 SoftGlobalScope.jl이 이를 위반하지 않는 것 같다는 것을 확인할 수 있어 기쁩니다. 예를 들어 show([1,2,4]) 대해 충분히 깊이 들어가면 다음과 같이 됩니다.

show_delim_array(io::IO, itr::Union{SimpleVector, AbstractArray}, op, delim, cl, delim_one) in Base at show.jl:649
  io = IOContext(Base.TTY(RawFD(0x0000000d) open, 0 bytes waiting))
  itr = [1, 2, 4]
  op = [
  delim = ,
  cl = ]
  delim_one = false
  i1 = 1
  l = 3
rebug> eval(softscope(Main, :(<strong i="10">@eval</strong> Base let (io, itr, op, delim, cl, delim_one, i1, l) = Main.Rebugger.getstored("bbf69398-aac5-11e8-1427-0158b103a88c")
       begin
           print(io, op)
           if !(show_circular(io, itr))
               recur_io = IOContext(io, :SHOWN_SET => itr)
               if !(haskey(io, :compact))
                   recur_io = IOContext(recur_io, :compact => true)
               end
               first = true
               i = i1
               if l >= i1
                   while true
                       if !(isassigned(itr, i))
                           print(io, undef_ref_str)
                       else
                           x = itr[i]
                           show(recur_io, x)
                       end
                       i += 1
                       if i > l
                           delim_one && (first && print(io, delim))
                           break
                       end
                       first = false
                       print(io, delim)
                       print(io, ' ')
                   end
               end
           end
           print(io, cl)
       end
       end)))
[1, 2, 4]

따라서 1.0에서 잘 작동합니다( softscope 또는 미포함). 0.7에서 이것을 평가하면( softscope 유무에 관계없이) 다음을 얻을 수 있습니다.

┌ Warning: Deprecated syntax `implicit assignment to global variable `first``.
│ Use `global first` instead.
└ @ none:0
┌ Warning: Deprecated syntax `implicit assignment to global variable `first``.
│ Use `global first` instead.
└ @ none:0
[ERROR: invalid redefinition of constant first
Stacktrace:
 [1] top-level scope at ./REBUG:9 [inlined]
 [2] top-level scope at ./none:0
 [3] eval(::Module, ::Any) at ./boot.jl:319
 [4] top-level scope at none:0
 [5] eval at ./boot.jl:319 [inlined]
 [6] eval(::Expr) at ./client.jl:399
 [7] top-level scope at none:0

따라서 0.7/1.0은 확실히 한 단계 더 발전했으며 softscope 가 중요한 기능을 손상시키지 않고 특정 작업을 더 쉽게 만든다면 정말 좋습니다.

따라서 가장 큰 관심사는 다른 패키지를 탱킹하지 않고 이를 적절하게 가로채는 방법입니다(https://github.com/stevengj/SoftGlobalScope.jl/issues/2).

@timholy , SoftScope는 매크로 호출의 인수를 건드리지 않으므로(매크로가 다시 작성하는 방법을 알 수 없기 때문에) :(<strong i="6">@eval</strong> ...) 가 보호됩니다.

"인지 여부와 모순되는 것 같습니다.
외부 지역 변수는 의도적으로 존재하며, 순서에 의존하지 않습니다.
외부 로컬 범위에서 표현식의 출현 또는 실행".

(외부) 지역 변수 a 이 있지만 아직 할당되지 않았습니다. 루프가 읽기 전에 a 에 할당하려고 시도했다면 할당은 외부에서도 볼 수 있습니다.

일반적으로 변수 바인딩을 만들고 값을 할당하는 것은 별도의 단계입니다.

이에 대한 타임라인은 무엇입니까? 사용자 편의성이 크게 향상될 것 같습니다. 그리고 Julia가 1.0을 출시한 이 "중요한" 시기에 이 수정을 최대한 빨리 받고(위의 Jeff가 제안한 방식으로) 새 Julia 버전이나 REPL 버전에 태그를 지정하는 것이 유리할 것 같습니다. (나는 확실히 이것을 고칠 수 없기 때문에이 안락 의자 의견에 대해 유감스럽게 생각합니다!)

@JeffBezanson
나는 이것이 사실이지만(구현/컴파일러의 경우) 순진한 줄리아 프로그래머는 더 단순한 개념적 모델과 다른 행동을 볼 수 없다고 주장하려고 했습니다(변수는 정의되는 순간부터 존재하기 시작합니다). 불행히도 당신이 맞습니다. 다음 코드는 오류를 제공하지 않지만 끝에 a=2를 생략하면 오류가 발생합니다.
기능 검사()
나는 = 1:10
a=1
끝
println(a)
a=2
끝
불행히도 설명하겠습니다. (이전에 컴파일된 언어로 작업한 적이 있기 때문에) 동작을 이해할 수 있지만 여전히 혼란스럽고 예상치 못한 것입니다. 스크립팅 경험이 없거나 프로그래밍이 처음인 사람에게는 얼마나 나쁜 일입니까? 또한 동작을 보여주는 코드를 찾았습니다. 유용한 응용 프로그램이 보이지 않습니다.

REPL:
나는 방금 REPL에서 범위를 "정상"으로 다시 변경하는 것이 우선순위가 높다는 것을 더 확신하게 되었습니다. 그것을 깨닫는 데 시간이 걸립니다. Julia를 이미 꽤 많이 팔로우하고 있고, 문제에 대한 이 스레드도 팔로우하고 있다는 점을 감안할 때, 저는 이것을 쇼스토퍼라고 부르고 싶습니다. 언어를 테스트하는 newbee(Julia에게)는 문제를 해결하고 그냥 포기하십시오.

@jeffbezanson 과 저는 모두 오랫동안 기다려온 휴가 중입니다(이 글을 읽으면 안 됩니다). 우리는 일주일 정도 후에 무엇을 해야 할지 알아낼 수 있습니다.

@derijkp , 피드백은 높이 평가되지만 범위 지정 규칙은 광범위한 토론이나 수정을 위한 것이 아닙니다. 테이블에 있는 유일한 것은 특별한 경우의 대화형 평가입니다. SoftGlobalScope 패키지는 이미 우수한 실험적 구현이며 Base의 해당 부분을 만들고 REPL에서 사용하는 문제일 수 있습니다.

@derijkp 짧은 대답은 변수의 범위가 일부 블록 구성(예: 함수 또는 루프의 본문)에 해당하는 경우 더 쉽다는 것입니다. 귀하의 제안에 따르면 변수의 범위는 블록의 일부 하위 집합이 될 것이며, 이는 궁극적으로 더 복잡하고 혼란스럽다고 생각합니다. --- 변수의 범위에 해당하는 구문 형식을 가리킬 수 없습니다.

예, 나는 이것이 어떤 사람들의 직관에 맞지 않는 것이라고 믿을 수 있습니다. 그러나 특정 시점까지는 언어 사용의 처음 10분 동안만 최적화할 수 있습니다. 진짜 질문은 그것이 작동하는 방식을 가르치고 배우는 것이 얼마나 어려운지, 그리고 장기적으로 어떤 디자인이 시간을 절약할 것인가입니다(언어를 더 단순하게 만들고 도구를 개발하기 쉽게 하는 등)?

(REPL의 동작 수정에 대한 위의 많은 부분에 동의)
이 stackoverflow 질문으로 이어지지 않는 방식으로 REPL을 보고 싶습니다.
그리고 많은 새로운 눈이 Julia를 바라보는 만큼 빠르면 빠를수록 좋습니다.

동의합니다... 또한 범위 지정 규칙이 반드시 변경되어서는 안 된다고 생각합니다. 모든 대화형 인터페이스(예: REPL, Jupyter 및 Juno 컨트롤 입력)만 변경되어야 합니다.

이것은 새로운 규칙을 배우는 초보자에 대한 것이 아닙니다. 코드 조각을 복사하여 REPL, jupyter 등에 그리고 함수에 붙여넣을 수 없다면 중급 프로그래머에게도 큰 골칫거리입니다.

물론, 나는 다른 포스터에도 동의합니다. 초보자는 함수 내에서 보는 코드 조각을 가져 와서 스크립트에 I를 복사하고 함수 내부에서 복사할 때 동일한 동작이 없을 때 완전히 혼란스러워합니다. , juno, repl 및 jupyter에서. 동일한 문제로 이어지는 100개의 스택 교환 질문이 있습니다. 중급 프로그래머는 let 블록 등으로 감싸는 모든 종류의 자체 솔루션을 사용하여 상황을 더욱 혼란스럽게 합니다.

동일한 문제로 이어지는 100개의 스택 교환 질문이 있습니다. 중급 프로그래머는 let 블록 등으로 감싸는 모든 종류의 자체 솔루션을 사용하여 상황을 더욱 혼란스럽게 합니다.

가능할 수도 있지만 이 단계에서 이것은 가설적입니다(또한 연결된 질문의 OP는 범위 지정 규칙에 대한 근거를 묻는 것이 아니라 혼동을 일으키고 있음).

또한 나는 이에 대해 우려하는 모든 사람의 교육 경험을 존중하지만 이것이 교실에서 큰 문제로 판명되는지 여부는 시간이 말해줄 것입니다.

질문자는 그것에 대해 혼란스러워 한 것 같습니다. "이것이 julia 사용자를 시작하는 데 직관적인지 궁금합니다. 저에게는 직관적이지 않았습니다..."

질문자는 그것에 대해 혼란스러워했던 것 같습니다:

이것은 범위의 뉘앙스를 이해할 만큼 프로그래밍 언어에 대해 충분히 알고 있는 사람이라는 것은 말할 것도 없습니다. 이러한 주제에 대해 완전히 무지하고 뉘앙스를 이해하는 데 충분한 시간을 투자하지 않을 모든 matlab 유형 사용자는 어떻습니까?

가능하지만 현 단계에서 이것은 가설입니다.

나는 이미 stackoverflow에서 이와 관련된 여러 질문에 답했는데, 대부분은 신규 사용자이며, 실생활에서는 훨씬 더 많습니다(어제 마지막 질문은 Matlab 사용자가 이것을 안 된다고 본 것입니다).

동일한 문제로 이어지는 100개의 스택 교환 질문이 있습니다.

내 "여가 시간"에 scope , scoping 및 global-variables 태그를 SE 질문에 추가했습니다. 시간이 없어서 그만두는 것이지 시간이 부족해서가 아닙니다.

분류를 포함한 많은 논의 후 결론: 우리는 SoftGlobalScope 라인을 따라 Base에 무언가를 포함하고 REPL 및 기타 모든 대화형 평가 컨텍스트에서 사용할 것입니다. @JeffBezanson 은 이것이 구현되는 방식은 실제로 이전에 소프트 스코프가 구현된 방식과 본질적으로 동일하므로 어느 정도는 완전한 순환을 하고 있다고 지적했습니다. 차이점은 이제 모듈이나 스크립트에는 범위 동작이 없고 REPL과 유사한 컨텍스트에서만 있다는 것입니다. 나는 또한 소스 재작성으로서의 _설명_소프트 스코프가 하드 스코프와 소프트 스코프를 구별하는 것보다 더 명확하다고 생각합니다.

이 두 진술은 약간 모순되는 것처럼 보이기 때문에 약간 혼란스럽습니다.

REPL 및 기타 모든 대화형 평가 컨텍스트에서 사용

[...] 스크립트에는 범위 동작이 없으며 REPL과 유사한 컨텍스트에서만 가능합니다.

이것은 Main 모듈에 때로는 소프트 범위(예: REPL 프롬프트)와 때로는 하드 범위(예 julia -L script.jl )가 있음을 의미합니까? Main 항상 소프트 범위가 있다고 말하는 것이 이치에 맞지 않습니까? 그리고 모듈은 using SoftGlobalScope 까지 소프트 스코프에 옵트인할 수 있습니까?

(내 생각에) 범위 지정 규칙은 이전 버전과 호환되지 않기 때문에 스크립트에서 변경할 수 없습니다. 즉, 1.0용으로 작성된 코드는 모든 1.* 버전에서 실행된다는 약속을 깨뜨릴 수 있습니다. REPL의 범위 지정에 대한 동일한 문제가 스크립트에도 적용된다는 것은 맞습니다(순진한 사용자는 스크립트로 실행할 때 코드가 제대로 작동하지 않는 이유를 완전히 상실함). 주요 비호환성 없이 이 문제를 해결/경감하는 방법은 julia cmdline에 softscope(또는 대안)를 사용하는 옵션을 추가하는 것입니다(예: julia -f programfile). 만나다.
나는 또한 몇 가지 장점이 있을 수 있는 소프트스코프에 대한 잠재적인 대안을 봅니다(단, 나는 아마도 단점을 간과하고 있을 것입니다): 파일(호출된 스크립트)이 항상 자체 로컬 범위를 도입한다면 어떻게 될까요: 범위 지정 규칙은 기능, 그리고 많은 사용자의 기대와 함께. 또한 새로운 사용자에 대한 많은 성능 책임이 제거됩니다.
더 이상 불필요한 전역(전역을 명시적으로 정의해야 함) 및 코드가 컴파일될 수 있음
(함수에 모든 것을 넣고 전역을 사용하지 않으려고 몇 번이나 말해야 했습니까?)

나는 이것을 막 치고 솔직히 말해서 완전히 당황했습니다. 전에는 다른 어떤 언어로도 본 적이 없었습니다. 나는 상황이 안정되면 올해 후반에 우리 대학에서 고급 R 사용자를 위한 Julia 옵션을 도입할 계획이며, 제 학생들은 REPL에서 무작위로 항목을 입력하기 시작하는 0일차에 이 강좌를 듣게 될 것입니다. 그리고 for 루프가 if 문과 다르게 동작한다는 사실은 상처에 염분을 문지르지만 범위 지정 측면에서 논리적일 수 있습니다. 함수 내부의 범위는 생물학 학생들이 이해하도록 하기에는 충분히 어렵습니다. REPL에서 / 스크립트에서 / for 루프에서 / if 문에서 _인식하긴 하지만_ 눈에 띄는 불일치를 설명해야 한다는 아이디어(왜냐하면 그것이 우리가 말하는 것이기 때문입니다. 약 여기) 지구상의 다른 모든 언어와 다른 방식으로 나를 매우 슬프게 만듭니다.

나는 이전 버전과의 호환성 약속을 이해하지만 _지구상의 모든 비 CS 사용자(그리고 내가 의심하는 대부분의 CS 사용자)가 예상한 대로_ 이 작업을 수행하는 것은 이전 버전과의 호환성 문제라기보다는 버그 수정처럼 보입니다. 모든 버그가 영원히 재생산된다는 사실을 알고 계셨나요? REPL 수정은 분명히 필수적이므로 이것을 제안하는 것은 좋지만 REPL에 스크립트를 복사할 수 없으며 동일한 동작이 원래 문제만큼 나쁘거나 더 나빠 보일 것으로 예상할 수 없다고 설명해야 합니다.

제발, 이것을 버그 수정으로 취급하고 스크립트와 REPL로 푸시하는 것에 대해 생각하십시오. "이전" 동작으로 전환하는 스위치가 있더라도 1.0.1에서 가능한 한 빨리 수행하십시오.

줄리아를 배우려고 했던 동료도 방금 이 문제에 부딪쳤습니다. 첫 번째 단계에서 전체 전역 대 지역 변수를 설명하는 것은 이상적이지 않습니다...

1.0 안정성 계약을 깨뜨릴 것이기 때문에 이것을 "버그 수정"으로 취급하는 것은 카드에 있다고 생각하지 않습니다. 그러나 julia -i (예: "대화형" 모드)로 실행되는 스크립트에 softscope를 사용하는 것이 합리적으로 보입니다.

(즉, --softscope={yes|no} 플래그가 있고 기본값은 isinteractive 입니다.)

스크립트 모드 선택을 고려해야 합니다.

그 문제에 대해 모든 "스크립트", 즉 julia foo.jl 대해 기본적으로 --softscope=yes 로 설정하고 모듈 및 include 에 대해 "하드" 범위 지정 규칙만 켜는 것은 제게 미친 일이 아닙니다.

그 문제에 대해 모든 "스크립트"에 대해 --softscope=yes를 기본값으로 설정하는 것은 제게 미친 일이 아닙니다.

저것. 진지하게 고려해야 할 또 다른 사람은 Juno입니다. 그 사람들이 것 기억 <shift-enter> 대화 형 개발을 할 수있는 자신의 코드를 통해 (특히 회귀 테스트 작업을 할 때) 다음 나중에 같은 파일을 실행할 수 있도록 기대합니다. 코드가 @testset 에 있는지 여부가 중요해야 합니까(범위를 도입할 수 있다고 생각합니다)? 동일한 텍스트가 @testset 에서 변경되고 Atom 통합을 사용하지 않을 때 변경되고 ] test 를 수행하는 것과 일치하지 않는 경우 사용자에게 매우 혼란스러울 것입니다.

내가 보기에 가장 좋은 해결책은 하드 스코프가 단순히 옵트인 방식이라는 것입니다. 다른 모든 사용법(스크립트 내 include 포함)은 달리 말하지 않는 한 softscope 를 사용합니다. .

지구상의 다른 모든 언어와 다른

모든 변수를 소개하기 위해 var x = 0 를 작성하시겠습니까? 그것은 또한 이것을 "수정"하고 다른 언어와 비슷합니다.

우리는 모든 버그가 영원히 재현될 것이라고 말하는 것이 아닙니다.

이것이 작동하는 방식은 아닙니다. 현재 동작을 버그라고 부르는 것만으로는 원하는 언어를 변경할 수 없습니다.

나는 이것을 위한 명령줄 옵션이 있어야 한다고 생각하지 않습니다. 그런 다음 줄리아 코드의 모든 부분에는 주석이나 사용할 옵션을 알려주는 내용이 있어야 합니다. 소스 파일의 어떤 종류의 파서 지시문은 조금 더 나을 것이지만 여전히 고정 규칙을 갖는 것이 더 좋습니다. 예를 들어 모듈 내부의 하드 스코프만 의미가 있을 수 있습니다.

교실에서 사람들이 보고 있는 조증, 히스테리, 대학살을 피하는 데 유용할 수 있는 이에 대한 설명을 다시 제공하려고 합니다.

"
Julia에는 지역 변수와 전역 변수의 두 가지 종류가 있습니다. REPL이나 최상위 수준에서 도입한 변수는 전역 변수입니다. 함수 및 루프 내부에 도입된 변수는 로컬입니다. 프로그램에서 전역 변수를 업데이트하는 것은 일반적으로 좋지 않으므로 루프 또는 함수 내부에 있고 전역을 업데이트하려는 경우 global 선언을 다시 작성하여 이에 대해 명시적이어야 합니다.
"

아마도 개선될 수 있습니다. 제안 환영합니다. 나는 당신이 어떤 종류의 설명도 필요로 하지 않는다는 것을 압니다. 나는 그것을 이해한다. 그러나 그것은 나에게 그렇게 나쁘지 않은 것 같습니다.

나는 이것을 위한 명령줄 옵션이 있어야 한다고 생각하지 않습니다. 그런 다음 줄리아 코드의 모든 부분에는 주석이나 사용할 옵션을 알려주는 내용이 있어야 합니다. 소스 파일의 어떤 종류의 파서 지시문은 조금 더 나을 것이지만 여전히 고정 규칙을 갖는 것이 더 좋습니다.

나는 동의한다. 저에게 교육 및 의사 소통의 두통처럼 들립니다.

예를 들어 모듈 내부의 하드 스코프만 의미가 있을 수 있습니다.

IJulia 노트북에서 복사한 .jl 파일에 짧은 스크립트(모듈이 아닌!)가 있는 경우 해당 코드를 REPL에서 직접 실행하거나 shift- Juno에 입력하면 소프트 스코프처럼 일관되게 작동합니다... 하지만 module 블록 대신 복사하면 전역에 대해 소리칠 것입니다. 그러나 모듈 내부의 함수 내부에 해당 코드를 복사하면 작동해야 합니다.

만약 그렇다면 그것은 완전한 의미가 있으며 매우 가르치기 쉽고 일관성이 있습니다. 최상위 스크립트는 탐색 등을 위한 대화형 인터페이스이지만 모듈에 그런 종류의 코드를 넣지 않을 것입니다. 모듈은 전역으로 매우 신중하게 고려되는 함수로 채워야 하는 것입니다. 사람들에게 그 규칙에 대해 말하는 것은 쉬울 것입니다.

모든 변수를 도입하기 위해 var x = 0을 작성하시겠습니까? 그것은 또한 이것을 "수정"하고 다른 언어와 비슷합니다.

아니, 차라리 안 하겠어! 그러나 REPL이 있는 스크립팅 언어는 거의 그렇게 하지 않으며(예: ruby, python, R, ...) Julia v0.6처럼 작동합니다.

Julia에는 지역 변수와 전역 변수의 두 가지 종류가 있습니다. REPL이나 최상위 수준에서 도입한 변수는 전역 변수입니다. 함수 및 루프 내부에 도입된 변수는 로컬입니다. 프로그램에서 전역 변수를 업데이트하는 것은 일반적으로 좋지 않으므로 루프 또는 함수 내부에 있고 전역을 업데이트하려는 경우 전역 선언을 다시 작성하여 이에 대해 명시적이어야 합니다.

나는 당신이 여기에서 말하는 것을 완전히 이해하고, 나는 이 실수를 다시 하지 않을 것입니다. 하지만 내가 걱정하는 모든 문제는 내가 아니다. 함수 내부의 변수가 외부의 변수를 볼 수 없고 그 반대의 경우도 마찬가지라고 설명할 때 범위를 직접 언급하지 않고 비교적 쉽게 소개한다는 것을 알았습니다. 그들 자체는 이미 _상대적으로_ 고급 개념입니다. 그러나 이것은 학습 곡선의 훨씬 더 이른 시점에서 사람들에게 영향을 미치는 범위만큼 원격으로 복잡한 것을 원하지 않는 곳입니다...

또한 "REPL에서 또는 최상위 수준에서 도입한 변수는 전역_입니다." 및 "함수 및 루프 내부에 도입된 _변수는 로컬입니다_"일 뿐만 아니라 REPL 또는 최상위 수준은 전역이지만 @testset 변수는 지역입니다. 우리는 "그냥 시도하고 그것이 지역적이든 세계적이든, 행운을 빕니다"라는 토끼굴에 빠지게 됩니다.

그러나 나는 @jlperla에 동의합니다. "모듈 내부의 하드 스코프만 의미가 있을 수 있다"는 제안은 나에게 완전히 괜찮아 보입니다! 모듈은 다시 충분히 발전된 개념입니다... 소프트 스코프가 REPL 및 스크립트에 대해 작동한다면 절대적으로 괜찮습니다.

우리는 사람들에게 영향을 미치는 범위만큼 원격으로 복잡한 것을 원하지 않습니다 ...
최상위 수준의 변수는 전역이지만 @testset 변수는 지역입니다.

내가 얻으려고 하는 것은 글로벌 대 로컬에 대한 간단한 설명이 초기 단계 교육에 충분하다고 생각한다는 것입니다. --- "범위"라는 단어를 말할 필요도 없습니다(전혀 발생하지 않습니다) 위의 내 설명에서). REPL에서 간단한 표현식과 루프를 보여줄 때 사람들에게 testsets에 대해 가르치는 것이 아니며 언어의 모든 범위 지정 동작에 대한 완전한 목록이 필요하지 않습니다.

내 유일한 요점은 이 변경으로 인해 언어에 대한 많은 세부 사항을 미리 가르쳐야 할 필요가 없다는 것입니다. 범위, 테스트 집합 등에 대한 대부분의 내용은 여전히 ​​무시할 수 있으며 전역 대 로컬에 대한 간단한 줄이면 충분합니다.

전역 대 지역에 대한 간단한 줄이면 충분합니다.

모든 사람이 처음부터 모든 코드를 작성하기 시작한 세상에서는 전적으로 동의합니다.

문제는 학생들에게 범위뿐만 아니라 복사하여 붙여넣은 코드의 범위를 이해하도록 가르쳐야 한다는 것입니다. 함수 또는 let 블록 내의 stackexchange에 있는 코드를 복사하여 붙여넣는 경우 이를 스캔하고 REPL 또는 .jl 붙여넣는 경우 "전역"을 추가할 위치를 찾아야 한다는 것을 가르쳐야 합니다

그리고 나서 학생들은 왜 for 가 걱정해야 하는 범위를 생성하지만 다른 것은 그렇지 않은지 묻기 시작합니다....

우리는 "그냥 시도하고 그것이 지역적이든 세계적이든, 행운을 빕니다"라는 토끼굴에 빠지게 됩니다.

팝 퀴즈: julia 0.6에서 x 글로벌 또는 로컬:

for i = 1:10
    x = i
end

대답은 알 수 있는 방법이 없다는 것입니다. 왜냐하면 전역 x 이 이전에 정의되었는지 여부에 달려 있기 때문입니다. 이제 로컬임을 확신할 수 있습니다.

여러분, 이 논의는 더 이상 생산적이지 않습니다. Jeff는 REPL에서 이전 동작이 좋았다는 것을 잘 알고 있습니다. 누가 처음에 그것을 설계하고 구현했다고 생각합니까? 우리는 이미 대화형 동작을 변경하기로 약속했습니다. "스크립트"가 대화식인지 여부는 여전히 결정해야 합니다. "스크립트"라고 하면 대화식으로 들리지만 "프로그램"이라고 하면 훨씬 덜 대화식으로 들리지만 정확히 같은 것입니다. 답변을 짧고 건설적으로 유지하고 아직 결정해야 할 사항에 집중하십시오. 이와 다른 의견이 있으면 숨겨져 스레드가 잠길 수 있습니다.

내가 가지고 있는 한 가지 생각은 "너무 성가시다" 및 "마을 사람들이 갈퀴에서 나오게 할 가능성이 있다"는 것으로 일축했습니다. 비대화형 컨텍스트에서는 local 또는 global "소프트 범위"의

Julia를 처음 소개받았을 때(얼마 전이고 주로 Fortran 배경에서 왔습니다) "Julia는 컴파일되고 함수 수준에서 빠르므로 효율적이어야 하는 모든 것은 함수 내부에서 수행되어야 합니다. . 메인 '프로그램'에서는 스크립팅 언어처럼 작동합니다." 나는 그 진술을 이해하지 않고는 계산적으로 너무 많은 것을 요구하는 사람을 상상할 수 없기 때문에 충분히 공정하다는 것을 알았습니다. 따라서 기능에서와 동일한 표기법과 구성을 사용하기 위해 메인 프로그램에서 성능에 희생이 있다면 이러한 범위 지정 규칙을 이해하고 가르치려고 노력하고 복사 및 복사를 할 수 없는 것보다 완전히 수용 가능하고 훨씬 더 수용 가능하다는 것을 알았습니다. 한 곳에서 다른 곳으로 코드를 붙여넣습니다.

그건 그렇고, 저는 Julia에서 아직 초보자이며 일부 고등학생 및 학부생에게 물리적 시스템 시뮬레이션의 기본 사항을 가르치기 위해 Julia를 선택했습니다. 그리고 나는 이미 이 문제가 이전 버전의 '정상' 동작으로 돌아가기를 희망하고 있습니다.

이 대화는 현재 잠겨 있으며 Julia 커미터만 댓글을 달 수 있습니다.

@JeffBezanson , 이 담론 스레드 에서 처음에는 REPL에서만 제안한 의미 체계를 구현하고 다른 곳에서는 옵트인할 계획은 무엇입니까?

SoftScope.jl을 다시 작성하는 구문이 아니라 낮추는 코드( julia-syntax.scm )에 직접 넣을 계획인 것 같습니까? 아니면 먼저 구문을 다시 작성하고(SoftScope를 제안된 규칙으로 수정하고 이를 stdlib로 변환) 나중에 Julia 릴리스를 위해 낮추는 코드에 넣는 것을 연기하시겠습니까?