제 목:[강좌] Smalltalk에 대한 몇 가지 이야기 관련자료:없음 [3] 보낸이:김찬홍 (안드래아) 1998-11-22 01:19 조회:572 Smalltalk에 대한 몇 가지 이야기 98. 11. 16. 김찬홍 mailto:andrea92@mail.hitel.net 이 글은 Smalltalk라는 프로그래밍 언어에 대한 몇 가지 중요한 이야기를 담고 있습니다. Dolphin Smalltalk 98을 만든 Object Arts라는 회사가 쓴 "Dolphin Smalltalk White pager"의 내용에 제가 생각한 것을 몇 가지 덧붙여서 Smalltalk 에 대한 이야기를 시작해 보려 합니다. 사실 Smalltalk에 관한 국내의 자료는 매우 빈약한 편입니다. 이상하게도 우리 나라에서는 C/C++이 프로그래밍 언어의 주류를 이루고 있으며, 요즈음은 Delphi 와 Visual Basic도 점점 그 중요도를 더하고 있습니다. 그러나 정작 객체지향 프 로그래밍 언어의 조상이자 완결판이라고 할 수 있는 Smalltalk에 대한 자료는 거 의 찾아보기 어렵습니다. 이는 상용 Smalltalk 시스템의 가격이 만만치 않으며, Smalltalk를 전산 교육 기관에서 별로 중요하지 않게 여기고 있기 때문이기도 합 니다. 그러나 90년대에 들어서면서부터 훌륭한 공개용 Smalltalk 시스템이 많이 배포되 고 있으며, 필자가 자료실에 올린 Dolphin Smalltalk 역시 그런 훌륭한 개발 환 경에 속합니다. 이제 미약하나마 저는 Smalltalk에 관한 자료를 조금씩 힘닿는 대로 여러분에게 소개시켜 드릴 것입니다. 물론 한 번에 많은 양을 드리지는 못하겠지만, 앞으로 올리는 자료가 여러분이 Smalltalk를 공부하는데 있어서 작으나마 도움이 되었으 면 하는 바램입니다. 먼저 Smalltalk 언어에 대한 기본적인 생각과 철학을 간단히 소개합니다. 흔히들 Smalltalk에 대해 가지기 쉬운 오해들 또한 여기에서 다루도록 하겠습니다. 그래 서 Smalltalk 언어는 배워볼 만한 가치가 있다는 것과 충분히 실제 응용 (application) 프로그램을 만드는데 사용할 수 있다는 것을 알려드리고자 합니 다. 1. 객체지향, 그리고 Smalltalk ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 90년대 초에는 머지않아 무른모(software)는 객체(object)와 부품(component)를 사용하여 만들어질 것이라는 이야기가 무성했습니다. 과연 오늘날 많은 무른모들 이 객체와 부품으로 만들어지고 있으며, COM이나 CORBA와 같이 객체와 부품을 중 시하는 여러 가지 기술들이 개발 사용되고 있습니다. 80년대 초반에 등장하여 무 른모 개발에 하나의 커다란 사건이 되어버린 "객체 지향"(Object Oriented) 패러 다임은 오늘날에 와서는 사실상 무른모의 모든 영역에 적용되는 패러다임이 되어 버렸습니다. 이제는 어떻게 하면 질 좋은 무른모를 보다 빨리, 그리고 많이 만들 수 있느냐와 더불어 사용자의 요구에 따라 무른모를 얼마나 쉽게 유지.관리할 수 있느냐가 중 요한 문제로 대두되었으며, 객체지향 패러다임은 이런 문제를 해결할 수 있는 하 나의 대안을 제시해 주었습니다. 오늘날 많이 사용되고 있는 C++, Java, Object Pascal 등은 모두 프로그래밍 언 어에 객체 지향 패러다임을 적용시킨 좋은 예라고 할 수 있곘습니다. 그러나 이 러한 시도들은 기존에 존재하는 패러다임 위에 객체 지향 패러다임을 덧씌운 결 과를 초래하여, 필요 이상으로 복잡한 언어 명세를 만들게 되었으며, 기존의 구 조적 프로그래밍 습관에 익숙한 우리들에게 객체 지향 기법을 구현할 수 있는 생 각의 여유를 허용하지 않았습니다. 사람들은 자신이 이미 알고 있는 방식대로 프 로그래밍을 하고, 따라서 객체지향 언어로 만들어진 프로그램이 전혀 객체지향 답지 안은 프로그램이 되고 만 것입니다. 그래서 저는 순수하게 객체지향적인 관 점에서 문제를 바라보는 것이 어떨까 하고 생각하게 되었으며, 그래서 찾아내게 된 것이 바로 Smalltalk 언어입니다. 1980년대 초반에 처음 모습을 드러낸 Smalltalk 시스템은 당시의 무른모 위원회 (software community)에 의해 매우 중요한 객체지향 프로그래밍 환경으로 여겨 졌고, Smalltalk의 언어 명세는 다른 모든 객체지향 프로그래밍 언어의 잣대가 되었습니다. 또한 Smalltalk 환경에서 사용되는 많은 개념들이 우리가 현재 사용 하고 있는 Delphi나 Visual Basic 등에 적용되고 있는 것으로 볼 때, 이러한 객 체지향적인 환경은 매우 높은 생산성을 가지고 있다는 것을 보여주는 좋은 예라 고 하겠습니다. 그럼에도 불구하고 Smalltalk는 범용 프로그래밍 언어로써 사용되기에는 몇 가지 의 장벽을 가지고 있었습니다. Dolphin Smalltalk는 이러한 장벽들을 뛰어넘어서 마침내 Smalltalk도 하나의 훌륭한 개발환경이 될 수 있다는 것을 보여주고 있습 니다. 이는 비단 Dolphin Smalltalk만이 아니라, 널리 사용되고 있는 VisualAge for Smalltalk나 Visual Smalltalk 등의 환경에도 똑같이 적용되고 있으며, 따라 서 이러한 장벽들은 분명히 해결될 수 있다는 것을 보여줍니다. 이제 흔히 평가되고 있는 Smalltalk에 대한 장벽들에는 어떤 것이 있는지 알아보 겠습니다. 대부분 Smalltalk에 대한 평가 중에는 오해해서 비롯된 것들이 많으 며, 이것이 Smalltalk가 범용 프로그래밍 언어로써 쓰이는데 하나의 커다란 장벽 이 되었던 것입니다. 2. Smalltalk는 느리다 ~~~~~~~~~~~~~~~~~~~~~ 1981년 8월에 출시된 "Smalltalk-80"은 첫 번째로 출시된 Smalltalk 시스템으로 써 큰 의미를 가지고 있었습니다. 이 Smalltalk-80이 제대로 돌아가려면 중대형 급 미니컴퓨터 이상의 성능을 가진 시스템이 필요했습니다. 요즘은 아무렇지도 않게 사용되고 있는 점으로 이루어진 그림(bitmap graphic)과 그래픽 사용자 환 경GUI), 모든 것이 객체이며 이 객체들 간에 존재하는 상속성, 그리고 기억 공간 을 효율적으로 관리하기 위한 쓰레기 수집(garbage collection) 등 처음 Smalltalk에서 소개된 이러한 개념을 구현하기 위해서는 그 당시로써는 매우 높 은 사양의 시스템이 필요했던 것입니다. 비록 이러한 기능들이 개인용 컴퓨터 (PC)에서 구현될 수는 있었겠지만, 80년대에 널리 사용되넌 PC에서 돌아가는 Smalltalk를 생각한다면? 아마 명령어 하나를 수행하는데 족히 몇 십초는 걸릴 것이 뻔했을 것입니다. 그러나 지금은 다릅니다. 무른모(hardware)는 눈부신 속도로 발전하여, 현재 우 리가 PC로 쓰고 있는 펜티엄급의 컴퓨터는 과거 80년대에 쓰이던 대형 컴퓨터의 성능을 훨씬 뛰어넘고 있습니다. 또한 무른모 역시 많이 발달하여 같은 시스템일 지라도 보다 효율적인 수행 성능을 보장할 수 있게 되었습니다. 이제 비로소 Smalltalk는 486DX 66 정도의 시스템에서도 충분히 잘 돌아갈 수 있게 되었으며, 흔히 우리들이 사용하고 있는 펜티엄급 컴퓨터에서는 더욱 더 최적의 성능을 발 휘하고 있습니다. 속도에 대해서 이야기할 때 수행 속도(running performance)와 더불어 빠질 수 없는 것으로는 개발 속도가 있습니다. 요즘과 같이 업무 처리 요구가 복잡한 경 우에는 해당 기능을 수행하는 모른모 역시 매우 복잡하게 구성될 수 밖에 없습니 다. 이제는 '쓸만하다'고 생각되는 프로그램을 둘러보면 그 덩치가 어마어마하게 비대해져있음을 볼 수 있습니다. 따라서 이러한 프로그램이 얼만큼 빠르게 실행 되는가도 중요하겠지만, 얼만큼 빨리 이러한 프로그램을 만들 수 있느냐에 대한 것도 상당한 관심의 대상이 되고 있습니다. 여러분은 개발하는데 6개월이 걸리 고, 실행하는데 3분이 걸리는 개발 환경과, 개발하는데 3개월이 걸리고 실행하는 데 6분이 걸리는 개발 환경이 있다면, 어느 쪽을 선택하겠습니까? 아마 대부분의 경우 후자를 선택할 것입니다. 일단 빠른 시간 안에 프로그램의 개발을 끝내 놓 으면, 남는 시간은 프로그램의 수행 속도 향상을 위해 충분히 할예할 수 있기 때 문입니다. Smalltalk가 바로 그러한 시스템입니다. 분명히 몇 줄 안 되는 반복 수행문 (loop)의 수행 시간을 측정하면 Smalltalk는 널리 쓰이는 다른 언어(C, Object Pascal 등)들보다 느린 것은 사실입니다. 그러나 이것은 Smalltalk가 제공하는 생산성과 융통성을 생각하면 충분히 희석되어질 수 있다고 생각합니다. Java 언 어 또한 결코 C 언어와 같은 속도를 내기는 어렵습니다. 그러나 Java가 가지고 있는 특성들은 충분히 많은 사람들이 Java에 빠져들도록 만들고 있습니다. Smalltalk는 큰 시스템을 설계할 때 진가를 발휘합니다. 객체지향 패러다임이라 는 것이 원래는 간단한 문제를 해결하기보다는 큰 시스템을 어떻게 하면 쉽게 설 계하고 만들 수 있는가에 초점을 맞추었기 때문입니다. C에서는 두어 줄로 끝날 프로그램을, C++의 갈래(class)를 사용하여 열 줄로 짰다고 해서, C++ 언어가 C 보다 못하다는 사람은 없을 것입니다. 마찬가지로, Smalltalk 언어는 큰 시스템 을 설계하고 개발하는데 더욱 더 많은 힘을 나타냅니다. 이는 객체지향 패러다임 을 따르는 데서 오는 명확한 설계 때문에 가능한 것입니다. Dolphin Smalltalk와 Delhi에서 원소수가 200만개인 배열 변수에서 어떤 값을 찾 아내는 실험을 했습니다. <바탕글 1> 200만개의 배열에서 특정 원소를 찾는 Delphi 프로그램 ---------------------------------------------------------- var Data: array[1 .. 2000000] of Integer; procedure TForm1.Button1Click(Sender: TObject); var i, Key: Integer; begin // 배열 초기화하기 for i := 1 to High( Data ) do Data[i] := i * 2; Key := 6500000; // 존재하지 않는 값. for i := 1 to High( Data ) do begin if Data[i] = key then begin ShowMessage( IntToStr(i) ); Exit; end; end; ShowMessage('못 찾음'); ----------------------------------------------------------- <바탕글 2> 200만개의 배열에서 특정 원소를 찾는 Smalltalk 프로그램 ----------------------------------------------------------- | data key | "배열 초기화하기" data := Array new: 2000000. 1 to: data size do: [ :i | data at: i put: i * 2. ]. key := 6500000. "존재하지 않는 값" 1 to: data size do: [ :i | (data at: i) = key ifTrue: [ ^MessageBox notify: i displayString ] ]. MessageBox notify: '못 찾음'. ----------------------------------------------------------- 위의 간단한 벤치마크 실험에서, Object Pascal을 사용하는 Delphi의 경우는 실 행하는데 0.5초도 소요되지 않은데 비해, Smalltalk의 경우는 약 5초의 시간이 경과했습니다. 이와 같이 32비트의 완전한 기계어로 번역되는 번역형 언어와 객 체지향 언어인 Smalltalk와의 단순 반복문 실행 성능은 매우 큰 차이를 보였습니 다. 이 비교를 보고 실망하는 여러분이 계시다면, 여러분이 Smalltalk에 대해서 어느 정도 알아갈 때까지, 그 실망을 잠시 접어두기를 권합니다. 정말, Smalltalk에는 여러분이 지금까지 생각하지 못했던 순수 객체지향의 원리가 숨쉬 고 있으며, 이것은 여러분의 무른모 개발 주기를 크게 단축시켜 줄 것입니다. 이 단순한 실험 때문에 Smalltalk에 대한 공부를 중단하신다면, 여러분은 큰 것을 얻을 수 있는 기회를 잃는 것이라고, 다시 한 번 말씀 드립니다. (물론 필자도 처음 이 실험을 해 보고 Smalltalk의 느린 속도에 좀 실망을 했지만, Smalltalk 에는 과연 다른 언어가 제공하지 못하는 Smalltalk만의 그 무엇이 숨어있습니다. 분명히!) 아울러, 위의 예와 같이 극단적인 경우는 실제 프로그래밍에서 극히 드문 일이라 는 것을 참고로 말씀 드립니다. Smalltalk의 속도 때문에 실망하실 분이라면 PowerBuilder를 사용하여 위의 예제를 만들어 보시기를 권합니다. 또한 현재 Smalltalk는 실행 속도를 개선하기 위하여 많은 연구가 이루어지고 있다는 것도 참고로 말씀드립니다. 적어도 실행 속도의 문제에 있어서 Smalltalk는 JAVA와 같 은 문제를 안고 있다고 보시면 이해가 빠를 것입니다. 3. Smalltalk는 배우기 어렵다 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 이 말은 틀린 말입니다. Smalltalk의 언어 명세 자체는 그 이름에서 말해주듯이 매우 작으며, 따라서 C++나 Java언어와 같이 언어 명세와 문법이 복잡한 언어에 비해 익힐 것이 극히 적습니다. 이 사실은 별로 놀라울 것이 없는데, Smalltalk 언어를 설계한 Xerox사의 연구원들은 아이들이 쉽게 배워서 사용할 수 있고, 쉽 게 프로그래밍을 짤 수 있는 시스템을 개발을 원래 목표로 삼고 있었기 때문입니 다. 실제로 Smalltalk 언어를 공부한 지 두 달이 되는 초등학교 5학년 학생이 헬 리콥터 시뮬레이터를 제작했다는 사실이 Smalltalk 시스템이 매우 뒵다는 것을 증명해 줍니다(월간 마이크로소프트, 정보시대). 이런 오해는 아마 다음의 두 가지 영역에서 기인한 것으로 생각됩니다. 우선, Smalltalk 언어는 주로 사용되는 언어들에 비해서 매우 다르다는 것입니 다. C++나 Java와 같이 언어 명세와 문법이 매우 복잡하여, 그것을 익히는데 상 당한 시간을 소비했던 사람들은 몇 가지도 안 되는 개념으로 이루어진 Smalltalk 의 간결한 문법에 적응하기가 어려울 수도 있을 것입니다. Smalltalk 언어는 "객 체에게 지시를 내리면, 객체는 그 지시에 따라 반응한다"는 개념을 토대로 문법 을 형성해 나아갑니다. 즉 다른 언어처럼 문법을 규정짓는 것이 아니라, 객체에 게 보내는 지시가 자연히 Smalltalk의 문법을 이루는 것입니다. 이는 흡사 인간 의 언어 체계와 비슷하다고 할 수 있습니다. (문법이 먼저 생긴 것이 아니라 말 을 하다 보니 거기서 문법이 형성된 것입니다.) 더욱이 Smalltalk 언어의 바탕글(source code)을 보면 다른 언어들과 그 모양이 매우 다름을 알 수 있습니다.(<바탕글 1>과 <바탕글 2>를 비교해 보십시오) 그러 나 모양이 다르기 때문에 어렵게 보일 뿐입니다. 실제로 Smalltalk의 몇 가지 개 념을 알고 나면 바탕글을 매우 쉽게 읽을 수 있습니다. Smalltalk가 어렵다고 느껴지는 이유 중 가장 큰 문제는 Smalltalk가 가지고 있 는 방대하면서도 확장성이 뛰어난 갈래 다발(class library)때문이 아닐까 합니 다. Smalltalk로 쓸만한 프로그램을 만들기 위해서는 필요로 하는 기능이 수백개 가 넘는 방대한 갈래 중에서 도대체 어떤 갈래에 속해 있는지에 대해서 꿰고 있 어야 하는데, 이것이 일반적으로 프로그래밍의 초보자가 정말 넘기 힘든 '장벽' 이 되어버리는 것입니다. Smalltalk를 사용해서 저 유명한 "Hello, world!"를 출 력하는 완전한 프로그램을 만들고 그것을 이해하려면 어느 정도의 시간이 필요합 니다. 그러나 Smalltalk에서 Hello World 프로그램을 만들 수 있다면, 그 다음은 정말 쉽게 쉽게 넘어갈 수 있습니다. C 언어의 경우, Hello World 프로그램을 만 들기는 쉽지만, 이것만 가지고는 C 언어에서 공부해야 할 기능 중에 10%도 안 되 는 내용밖에 알 수 없습니다. Smalltalk에서 Hello World 프로그램을 만들고 그 것을 이해했다면, Smalltalk 언어의 80% 이상을 정복했다고 해도 과언이 아닐 것 입니다. 그런데 갈래 다발을 익히는 것이 어려워서 Smalltalk가 어렵다면, 이는 C++, Java 그리고 쉽다고 여겨지는 Delphi나 Visual Basic을 공부하는 것 역시 어렵다 고 봐야합니다. Visual C++를 가지고 프로그램을 짜려면 적어도 MFC(Microsoft Foundation Classes)라는 갈래 다발을 익혀야 하고, Delphi의 경우에는 VCL (Visual Component Library)을 공부해야 하며, Java의 경우네는 JavaBeans나 여 러 가지의 꾸러미(package)에 대해서 어느 정도의 지식이 필요합니다. 마지막으로, Smalltalk 시스템은 대화식입니다. 예전에 베이식을 공부해 본 분이 라면 대화식 개발 방법이 얼마나 쉬운지를 알 것입니다. Smalltalk에서는 명령어 를 한 줄 단위로 실행시켜볼 수 있으며, 그 결과를 바로 알 수 있습니다. 컴퓨터 와 대화하듯이 어떤 일을 처리할 수 있기 때문에, 익히기가 매우 쉽습니다. 규정 된 문법에 의해 바탕글을 쓰고 그것을 번역(compile)하여 실행해야만 결과를 얻 을 수 있는 언어들에 비해서, Smalltalk의 경우에는 대화식으로 명령어를 수행할 수 있는 언어이기 때문에 특히 초보자들이 배우기가 매우 쉽다고 할 수 있습니 다. 앞서 말씀드렸지만, Smalltalk의 모토는 "어린아이들도 쉽게 프고그램을 짤 수 있는 환경을 만들자"는 것입니다. (물론 그 '어린아이'가 영어권에 익숙해야 한다는 것이 마음이 아픕니다만...) 이런 것들을 공부하면서 동시에 복잡한 언어 명세를 공부하는 것과, 단순한 언어 명세와 대화식 개발를 지원하는 Smalltalk를 공부하는 것 중에, 과연 어떤 것이 더 어려워 보일까요? 그것은 독자 여러분의 판단에 맞깁니다. 4. Smalltalk은 비싸다 ~~~~~~~~~~~~~~~~~~~~~ 이는 아주 간단하게 예를 들 수 있습니다. 공개용 Smalltalk 시스템이 많이 나와 있으며, Dolphin Smalltalk의 경우에도 상용 제품과 공개용 제품을 같이 내놓고 있습니다. 또한 Dolphin Smalltalk 상용판의 경우는 약 $50 정도의 가격으로 충 분히 구입할 수 있으며, 데이터베이스나 응용 프로그램 배포 등의 기능을 포함한 꾸러미 형태로 판매되는 제품의 경우 $219 정도의 가격이면 충분히 구할 수 있습 니다. Smalltalk가 비쌉니까? 5. Smalltalk는 크다 ~~~~~~~~~~~~~~~~~~~ Smalltalk라는 이름 자체가 이 말이 사실이 아님을 증명해 줍니다. Smalltalk는 작은 시스템입니다. 이는 장점이 될 수도 있고 동시에 단점이 될 수도 있습니다. ANSI X3J20표준에 의해 규정된 갈래 씻줄(class hierarchy)은 흔히 볼 수 있는 다른 객체 지향 언어의 갈래 다발보다 더 많은 것을 담고 있습니다. C++의 경우 ANSI에서 표준화된 갈래 다발은 기본적인 것들 뿐이고 대부분 C++를 만들어 파는 회사마다 독자적인 갈래 다발을 만들어 사용하고 있으며, 따라서 이는 흔히 말하 는 것처럼 호환성 좋은 C++를 자꾸 호환성 없는 언어로 만드는 요인이 되고 있습 니다(Visual C++의 MFC와 Borland C++의 OWL을 생각해 봅시다.) ANSI 표준을 따 르는 Smalltalk의경우는 기본적으로 방대한 양의 갈래 다발을 가지고 있지만, 이 는 이미 표준화 된 것이기 때문에 Smalltalk의 호환성을 높여주는 촉매제가 됩니 다. 이러한 방대한 갈래 다발이 표준화됨으로써 생겨나는 단점으로는 Smalltalk로 프 로그램을 개발할 때, Smalltalk 환경 자체가 방대해질 수 있다는 것을 들 수 있 습니다. 물론 실제 응용 프로그램을 배포할 때에는 개발 단계에서보다는 훨씬 작 은 크기로 배포가 가능하지만, 현재의 Smalltalk 구현 기술로는 아직까지 다른 언어로 만들어진 프로그램들보다는 기억 공간의 소비가 크다는 단점을 가지고 있 습니다. 그러나 Dolphin Smalltalk의 경우는 보통 구현되는 Smalltalk의 특성보다 한 단 계 발전된 기술을 사용함으로써, 실행 파일이 차지하는 기억 공간의 점유율을 매 우 낮게 할 수 있었으며, 이는 Dolphin Smalltalk가 다른 Smalltalk에 비해서 월 등한 성능을 보장할 수 있도록 해 준다고 합니다. 기억공간 소비가 심하다는 평가에 대해서, Delphi나 Visual Basic의 경우와 비교 해 보십시오. 자원 측정기를 켜 놓은 상태에서 Delphi 4.0을 실행할 경우, 약 10% 전후의 자원을 소비하며, 이는 개발 프로그램이 커지면 커질수록 더욱 더 많 이 소비하게 됩니다. (프로젝트에 따라서는 약 30%의 자원을 소비할 때도 있었습 니다.) 그러나 Dolphin Smalltalk의 경우에는 기본적으로 약 3%의 자원을 소비합 니다. 이는 이미 모든 갈래 다발과 객체들이 다 생성된 상태에서 차지하는 기억 공간의 점유율입니다. (보통 배포되는 Dolphin Smalltalk에는 약 540개의 갈래와 45,000여개의 객체가 들어있습니다.) 어찌보면 Smalltalk는 큽니다. 그러나 또한 작습니다. 큰 것이 무조건 단점이 될 수만은 없는 것입니다. 그런데, 정말 Smalltalk가 큽니까? 그런지 그렇지 않은지 는 여러분이 직접 Smalltalk를 곱우해 보면 알 수 있을 것입니다. 6. Smalltalk는 연구용 언어이다 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 아마 이 문제는 Smalltalk 언어가 개발된 곳이 Xerox 연구소이며, 따라서 상용 번역기 개발 회사들이 내놓는 것보다는 낮은 실행 속도 때문에 기인한 것이라고 생각합니다. 흔히 Delphi나 Visual Basic, C++ 등으로 Windows 용의 응용 프로그 램을 만들려고 할 때 매우 높은 시스템 사양이 필요합니다. 그러나 Smalltalk는 그렇지 않다고 앞서도 언급한 바 있습니다. 또한 Smalltalk가 개발될 때 원래부 터 사용자 인터페이스를 생성하는 방법이 마련되어 있었으며, 예전에는 Smalltalk를 운영체계로 쓰는 컴퓨터도 있었습니다. 더욱이 Dolphin Smalltalk의 경우에는 WIN32 API를 90% 이상 지원합니다. 따라서 응용 프로그램을 만드는데도 결코 다른 개발 환경에 비해서 뒤떨어지지 않습니다. 7. 요약 ~~~~~~~ Smalltalk, 특히 Dolphin Smalltalk는 다음을 지원합니다. * Dolphin Smalltalk는 학습이나 실제 응용 프로그램을 개발할 수 있는 공개용 Smalltalk를 배포합니다. 이제는 개발 환경의 구입 가격 때문에 망설이는 일 이 없을 것입니다. * 상대적으로 작은 Smalltalk의 개발 환경은 낮은 사양의 컴퓨터에서도 충분히 응용 프로그램을 개발할 수 있도록 할 수 있을 것입니다. * ANSI X3J20에서 Smalltalk의 표준을 정하고 있으며, Smalltalk는 C++와 더불어 산업 표준이 되어가고 있습니다. * Dolphin Smalltalk에서 제공하는 '3계층 응용 프로그램 모형'(three tiered application framework)은 프로그램을 매우 융통성있게 만들어 줍니다. * Dolphin Smalltalk는 Windows 시스템의 모든 자원을 사용할 수 있으며, Windows 운영 체계의 지원을 받을 수 있습니다. 이는 WIN32 API의 사용을 보 장해주며, 따라서 WIndows 응용 프로그램의 개발을 쉽게 해 줍니다. 이제 Smalltalk를 한 번 공부해 보십시오. 작게는 여러분의 객체지향 패러다임을 익히는 도구로써, 크게는 실제 프로젝트를 개발할 수 있는 도구로써, Smalltalk 는 여러분에게 큰 몫을 할 것입니다. 자료실에 올려진 Dolphin Smalltalk와 Dolphin Education Center를 내리받고 Smalltalk 공부를 시작해 보십시오. 그리 고 우리 함께 공부합시다. 그래서 Smalltalk의 자료가 더 이상 빈약하지 않도록 합시다. 아룰로 필자는 Smalltalk도 하나의 도구로 생각합니다. 저는 Delphi를 주로 사용 하는데, Smalltalk를 공부하면서 델파이를 바라보는 시각이 바뀌었습니다. 좀 더 질서있고, 관리하기 쉬운 코드를 쓸 수 있게 되었습니다. 객체 지향이 무엇인지, 정말 진정한 객체지향의 진수를 맛보고 싶으시다면, Smalltalk를 꼭 권해드립니 다. 같이 공부합시다. 제 목:[강좌] Smalltalk 배우기 #0 관련자료:없음 [4] 보낸이:김찬홍 (안드래아) 1998-11-22 03:20 조회:388 Smalltalk 배우기 #0 1998. 11. 16. 김찬홍 mailto:andrea92@mail.hitel.net "Smalltalk 배우기"를 시작하면서 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Smalltalk는 객체지향 패러다임이 순수하게 적용된 첫 번째 프로그래밍 언어로써 그 의미가 매우 크게 대두되었습니다. 그래서 지금도 객체지향 패러다임이 언급 될 때 이 Smalltalk 언어의 이야기가 빠지는 법이 없습니다. 그만큼 Smalltalk 언어는 객체지향 개념을 충실하게 잘 지원하고 있는 몇 안 되는 언어 중에 하나 입니다. 그럼에도 불구하고, 우리 나라에서는 Smalltalk 언어에 대한 자료를 찾아보기가 매우 어렵습니다. 서점에서 변변한 책을 구해볼 수 없으며, 동호회에서 Smalltalk에 관한 강좌나 글을 찾기도 매우 어려운 실정입니다. 이는 우리가 C나 C++와 같이 일부 주류 언어에만 관심을 가지고 나머지 다른 언어나 개념들을 소 흘히 다룬대도 그 원인이 있다고 하겠습니다. C++나 Java 등은 모두 객체지향 프로그래밍 언어입니다. 결과적으로 이들 언어가 구현하고자 하는 기본적인 생각들은 대부분 순수 객체지향 언어인 Smalltalk에서 빌어온 것들이 매우 많습니다. Delphi나 Visual Basic 등의 개발 도구에서 사용 되는 개념 역시 Smalltalk에서 빌어온 것이 상당수입니다. 그러므로 만일 우리가 Smalltalk를 공부하게 된다면, 객체지향 패러다임에 대한 좀 더 올바른 이해를 가지게 될 것이라고 필자는 생각합니다. 비록 Smalltalk를 사용하여 실무 프로젝트를 처리할 수 없는 환경에 있는 분이어도, Smalltalk 공 부는 객체지향 패러다임을 체계적으로 접근할 수 있는 식견을 가질 수 있게 도와 줄 것입니다. 또한 공개용으로 나온 훌륭한 Smalltalk 시스템들이 많이 있기 때문에, 프로그래 밍을 하고싶지만, C나 C++의 복잡한 문법 때문에 어려워하신 분들은 Smalltalk를 공부함으로써 프로그래밍을 공부하는 제미 또한 얻을 수 있을 것입니다. 외국(특히 유럽)의 경우 Smalltalk는 실무 프로젝트에도 충분히 적용되고 있으 며, 따라서 우리 나라에도 Smalltalk를 공부하고 사용하는 분들의 층이 두터워지 면 이는 충분히 가능한 일이라고 생각되어집니다. 특히 저는 Dolphin Smalltalk를 추천합니다. 이는 ANSI에서 정한 표준 Smalltalk 규약에 충실하면서도 공개용 Smalltalk환경을 갖추고 있으며 문법 돋이(syntax highlighting)나 WIN32 API를 훌륭하게 지원하고, 외부 DLL 파일을 사용할 수 있 는 점 등 여러 가지 장점을 가지고 있습니다. 앞으로 제 글을 읽고 Smalltalk를 공부하실 분은 아래의 준비물을 갖추어 주시면 좋겠습니다. 물론 다른 Smalltalk를 가지고도 할 수 있지만, 저는 Dolphin Smalltalk의 기능을 활용하여 좀 더 쉽게 글이 진행되도록 할 것입니다. Dolphin Smalltalk는 자료실에서 구하실 수 있습니다. Dolphin Smalltalk 98 / 1.1 Dolphin Education Center 아울러 이 글 바로 다음에 올려질 글에는 "Smalltalk 배우기"의 차례를 기제할 것입니다. 그러므로 현재 "Smalltalk 배우기"의 상황을 한눈에 알아볼 수 있을 것입니다. 앞으로 저는 Wilf Lalond의 "Discovering Smalltalk"라는 책을 참조하면서 글을 쓸 것입니다. 이 책은 제가 처음 Smalltalk를 공부할 때 큰 도우밍 되어 주었던 책입니다. 여러분도 이 책을 구할 수 있다면 한 번 읽어보시라고 권하고 싶습니 다. 영어로 된 책이기는 하지만 그리 어렵지 않게 설명되어 있습니다. 글을 진행하다가 Dolphin Smalltalk와는 다른 Smalltalk 시스템을 사용하시는 분 이 계시다면 거기에 관련된 자료도 올려 주셨으면 좋겠습니다. 또한 틀린 점이나 건의하실 점이 있으시면 서슴지 마시고 저에게 편지를 보내주시면 제가 할 수 있 는한 반영하도록 노력하겠습니다. 아울러 제 글이 실리는 동안 많은 격려와 관심 부탁드리곘습니다. 그럼 지켜봐주십시오. 이제부터 시작입니다. 제 목:[강좌] Smalltalk 배우기 -차례- 관련자료:없음 [5] 보낸이:김찬홍 (안드래아) 1998-11-22 03:25 조회:387 Smalltalk 배우기 차례 +---------------------------------------------------------------- | <보기> >: 현재 진행되고 있는 글 | !: 별도의 자료파일이 제공되는 글 | *: 현재 쓰여지고 있는 글 | <#번호>: 글 번호 | | | 0. 'Smalltalk 배우기'를 시작하면서 <#0> | | | 1. Smalltalk의 소개 | | 1.1. 프로그램과 프로그래밍 언어 <#1> | | 1.2. Smalltalk의 설치 <#2> | | 1.3. Smalltalk 맛보기 프로그램 | | 1.4. 몇 가지 준비해야 할 것들 <#3> | 1.4.1. Dolphin Smalltalk 등록하기 | 1.4.2. 바탕본 여벌 받기 | 1.4.3. 글꼴 설정하기 | | 1.5. Smalltalk 환경 둘러보기 <#4> | 1.5.1. 알림판 | 1.5.2. 일터 | 1.5.3. 객체 탐색기 | 1.5.4. 갈래씨줄 탐색기 | 1.5.5. 길수 탐색기 | 1.5.6. 꾸러미 탐색기 | 1.5.7. 창맵씨 | 1.5.8. 자원 탐색기 | 1.5.9. 발자취 창과 벌레잡개 | | | 2. 객체들과 나누는 이야기 | | 2.1. 객체? <#5> | | 2.2. 몸으로 느껴보기 | 2.2.1. 글토막 가늠하기 <#6> | 2.2.2. 셈! 셈! 셈! | 2.2.3. 실체와 갈래 | 2.2.4. 지시에 대하여... | 2.2.5. 지시의 우선 순위 | ! 2.2.6. 고급 셈! 셈! 셈! <#11> | | 2.3. 객체의 안쪽 | ! 2.3.1. 탐색기 사용하기 <#13> | ! 2.3.2. 객체의 성분 | ! 2.3.3. 글자와 글줄 | 2.3.4. 진리를 찾아서... <#17> | ! 2.3.5. 무른값, 굳은값, 그리고 바로값 <#19> | | 2.4 정리 및 연습문제 <#21> | 2.4.1. 요약 | 2.4.2. 알아두면 좋은 것들 | 2.4.3. 연습 문제 | | | > 3. 객체로 채워진 세상 | | ! 3.1. 알아보자, 알림판! <#22> | 3.1.1. 알림판 객체 - Transcript | 3.1.2. 알림판에 객체 써내기 | 3.1.3. 잇따름 지시 | | 3.2. 꼬리표 인생 | 3.2.1. 이름이 뭐지? <#24> | 3.2.2. 바로값과 꼬리표 | 3.2.3. 작은 꼬리표 <#25> | 3.2.4. 붙임표에 대하여 | ! 3.2.5. 큰 꼬리표 <#26> | | ! 3.3. 운동장 놀이 | 3.3.1. 일터 꼬리표 <#27> | 3.3.2. 꾸러미에 대해서 | 3.3.3. 운동장 위에서 <#28> | | * 3.4. 초짜들의 합창 | | 3.5. 대화의 장 | .... +---------------------------------------------------------------- 제 목:[강좌] Smalltalk 배우기 #1 관련자료:없음 [6] 보낸이:김찬홍 (안드래아) 1998-11-22 03:26 조회:373 Smalltalk 배우기 #1 1998. 11. 21. 김찬홍 mailto:andrea92@hitel.net ====================================== 1. Smalltalk의 소개 →1.1. 프로그램과 프로그래밍 언어 ........ ======================================= 1. Smalltalk의 소개 ------------------------------ Smalltalk는 프로그래밍 언어입니다. 프로그래밍은 결국 컴퓨터를 내가 생각 하는 대로 움직일 수 있도록 해 주는 하나의 큰 도구입니다. 이제 Smalltalk 를 처음 공부하는 여러분들을 위해, 이 마당에서는 Smalltalk의 한 종류인 Dolphin Smalltalk를 설치하고 실행하고 종료하는 기본적인 방법을 소개할 것입니다. 그리고 이 과정에서 여러분은 간단하지만 재미있는 몇 가지의 Smalltalk 프로그램을 실행시켜보게 될 것이고, Smalltalk에서 어떤 식으로 명령어를 실행하는지에 대해서 공부하게 될 것입니다. 물론 처음부터 '객체지향'은 어떻고 '갈래'(class)가 어떻느니 등과 같이 접 근할 수도 있을 것입니다. 그러나 자전거를 배울 때 우선 자전거의 원리부터 배우려고 하는 사람은 없습니다. 자전거를 직접 타 봄으로써 몸으로 익히려 고 하겠지요. 이 마당에서도 일단은 객체지향에 대한 이론적인 면보다는 Smalltalk 환경 자체에 대해서 다루고자 합니다. 한 마디로 이 마당은 여러분이 Smalltalk에 익숙해지기 위한 곳입니다. 이 마당을 마칠 즈음에 여러분은 앞으로 Smalltalk를 공부하는데 있어서 가장 기본이 되는 몇 가지 사항들을 알 수 있게 될 것입니다. 1.1. 프로그램과 프로그래밍 언어 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 우리는 하루에도 여러 가지 명령을 알게 모르게 주기도 하고 받기도 하며 살 아갑니다. 동생에게 "물 좀 갖다 줘"에서부터 어머니에게 "밥 좀 주세요" 에 이르기까지, 우리는 다른 사람에게 명령을 내리고 또한 그에 따른 결과로써 무언가를 이루어갑니다. 어머니에게 명령을 내린다는 것이 좀 우습게 들리겠 지만, 따지고 보면 우리가 어머니에게 명령을 내릴 때에는 매우 공손한 태도 를 취하는 것입니다. 결국 어머니에게 무언가를 부탁하고 어머니는 그것을 들어주시는 것이므로, 어머니에게 명령을 전달했다고 생각할 수 있습니다. (한낱 컴퓨터를 다루는 사람의 우스운 괴변이 되지나 았았으면 합니다.) 우리는 또한 스스로에게도 자리에서 일어나라거나, 밥을 먹으라거나, 공부를 하라는 등 여러 가지의 명령을 내리며, 그렇게 해서 살아갑니다. 스스로 하 는 것이 무슨 명령이냐고 말할지 모르지만, 밥을 먹을 때에도, 눈과 팔과 손 에 붙어있는 뼈와 근육 등 여러 곳에 명령을 내려야만 제대로 밥을 먹을 수 있습니다. 그뿐입니까? 집에서 기르는 개나 고양이 같은 애완 동물에게도 우리는 명령 을 내립니다. "이리 와!", "손을 다오"처럼 분명히 우리는 애완 동물에게 명 령을 합니다. 물론 그 명령을 제대로 알아듣고 실행하는지 안 하는지는 그 동물을 얼마큼 훈련시켰느냐에 달려있지만 말입니다. :) 또한 우리는 주위에 있는 물건에게도 명령을 내립니다. 흔히 "TV를 끈다"고 말하는데, 정확히 말하면, 우리는 "TV의 전원이 꺼지도록 전원 단추를 누른 것"에 불과합니다. 이 단추를 누르는 동작이 결국은 TV 속에서는 복잡한 동 작으로 바뀌어서 전원이 꺼지게 되는 것이지요. 명령은 꼭 말로만 하라는 법이 없습니다. 앞서 이야기했듯이 TV를 끄는 것도 말로 하는 명령이 아닙니다. 손짓을 하거나 단추를 누르거나 하는 모든 것들 이 명령이 될 수 있습니다. 지금 여러분이 제 글을 보고 있다면, 여러분은 컴퓨터에게 수많은 명령을 내려서 이 글을 볼 수 있게 된 것입니다. 운영 체 계를 시작하고, 통신 프로그램을 띄우고, 전화를 걸고, 이 글이 실려 있는 게시판까지 찾아와서 글을 읽는 모든 것이 마우스를 누르거나 글쇠판을 두드 려서 내려진 여러분의 명령이 실행된 결과라는 사실을 생각하면, 명령은 꼭 말로만 내리는 것이 아니라는 제 말에 동감하실 것입니다. 제가 글머리부터 왜 이리 "명령" 타령을 하느냐고요? 그것은 바로 우리가 앞 으로 다루어야 할 "프로그램"(program)은 결국 이러한 "명령들의 집합"이기 때문입니다. 좀 더 정확히 말한다면, '프로그램'이란 명령이 언제 어떻게 실 행될 지를 늘어놓은 것입니다. 일단 이렇게 프로그램이 만들어지면 명령을 다시 내리지 않더라도 "나중에 언제든지" 다시 그 명령들을 실행할 수 있습 니다. 시계를 매일 아침 여섯 시에 울리도록 설정한다거나, 비디오 녹화기를 특정 시간에 방송되는 TV 프로그램―이것 역시 TV의 내용을 일정한 시간에 방송될 수 있도록 하는 것이겠지요―을 녹화하도록 설정한다거나 하는 것은, 결국은 우리가 바라는 명령들을 실행 순서에 따라 차례대로 늘어놓은 것입니 다. 이러한 프로그램을 짜는 작업을 '프로그래밍'(programing)이라고 부릅니 다. 결국 프로그래밍은 명령이 실행되는 순서를 정하는 것을 의미합니다. 프로그래밍과는 조금 다른 의미로 쓰이는 말 중에 "설계"(designing)란 말이 있습니다. 프로그래밍이 명령이 어떤 순서로 실행되는가를 중요하게 생각하 는 것과는 달리, 설계는 명령을 어떤 식으로 조직할 것인지를 결정하는 일입 니다. 프로그램이 선(線)이나 면(面)과 비유할 수 있다면, 설계는 입체로 비 유할 수 있습니다. 설계는 프로그래밍보다는 조금 상위 수준에 속한다고 보 면 됩니다. 소설을 쓰는 사람은 우선 자기가 쓸 글의 얼개를 짜고 글의 큰 흐름을 조직 합니다(설계). 일단 이렇게 글의 얼개가 짜여지고 목표가 생기면, 이제 그는 자신의 생각을 차례차례 글로 옮겨 적습니다(프로그래밍). 그래서 설계와 프로그래밍은 뗄 수 없는 불가분의 관계라는 말이 있습니다. 어느 한 쪽에만 치우치게 되면 둘 자 제대로 이루어지지 못하고 어그러지고 맙니다. 컴퓨터는 명령을 기억하고 또한 기억된 명령을 실행할 수 있는 장치입니다. 물론 컴퓨터에 기록된 명령은 컴퓨터가 알아들을 수 있는 말로 작성된 것이 겠지요. 프로그래머(programer)는 이렇게 컴퓨터가 알아들을 수 있는 말로 프로그램을 만드는 사람을 가리킵니다. 프로그래머가 컴퓨터에게 명령을 전 달하기 위해서는 방금 말했듯이, 컴퓨터가 알아들을 수 있는 말을 사용해야 합니다. 아직 컴퓨터는 사람이 사용하는 자연어(自然語)를 이해할 수 있을 만큼 똑똑 하지 못합니다. 결국은 사람이 컴퓨터가 알아들을 수 있는 말을 이용하여 프 로그램을 작성하는 수밖에는 없습니다. 이렇게 프로그램을 만들기 위하여 컴 퓨터가 알아들을 수 있는 말을 '프로그래밍 언어'라고 부릅니다. 사람도 여러 가지의 언어를 사용합니다. 우리말, 영어, 일어, 중국어, 프랑 스어 등 세상에는 여러 가지의 말이 있습니다. 마찬가지로 컴퓨터가 알아들 을 수 있는 말, 즉 프로그래밍 언어에도 여러 가지가 있습니다. 주로 사용되 는 C, C++, Java, Pascal, BASIC 등의 언어가 있는가 하면, 주류 언어는 아 니지만 각각의 목적에 따라 사용되고 있는 Forth, Lisp, Prolog, Scheme, 그 리고 우리가 공부하려고 하는 Smalltalk와 같이 정말 많은 종류의 프로그래 밍 언어가 존재합니다. 이들 언어는 나름대로의 장단점들을 가지고 있어서, 어떤 언어가 좋고 나쁨을 가릴 수는 없습니다. 어쨌건 우리가 다루고자 하는 언어는 Smalltalk이므로 앞으로 이 글에서는 다른 언어에 대해서 크게 다루 지는 않을 것입니다. 물론 필요할 때에는 다른 언어에 이미 익숙하신 분들을 위해서 다른 언어에 대해서 필자가 생각하는 것들을 잠깐씩 적을 생각입니 다. Smalltalk를 공부하시는데 도움이 되시기를 바랍니다. 계속... 제 목:[강좌] Smalltalk 배우기 #2 관련자료:없음 [7] 보낸이:김찬홍 (안드래아) 1998-11-23 10:40 조회:332 Smalltalk 배우기 #2 1998. 11. 22. 김찬홍 mailto:andrea92@hitel.net ====================================== 1. Smalltalk의 소개 1.1. 프로그램과 프로그래밍 언어 →1.2. Smalltalk의 설치 1.3. Smalltalk 맛보기 프로그램 ........ ======================================= 1. Smalltalk의 소개 ------------------------------ 1.2. Smalltalk의 설치 ~~~~~~~~~~~~~~~~~~~~~ Smalltalk를 사용하여 프로그램을 짜기 위해서는 우선 여러분의 시스템에 Smalltalk 환경이 설치되어있어야 합니다. 일단 우리들은 Object Arts사의 Dolphin Smalltalk를 사용할 것이므로, 자료실에서 Dolphin Smalltalk를 내 리받읍시다. 원래 Dolphin Smalltalk는 상용과 공개용 Smalltalk 환경을 같이 배포하고 있습니다. Dolphin Smalltalk 1.1판은 공개용이며, 2.1판은 상용입니다. 현 재 필자가 사용하고 있고 또한 자료실에 올려진 환경은 1.1판입니다. 그러므 로 여러분이 마음대로 전송 받아서 사용할 수 있을 것입니다. 원래 Object Arts에서 제공하는 배포판의 파일 이름은 Dolphin981Setup.Exe 이지만, 자료실의 파일명 길이 제한 때문에 위의 실행 파일을 다시 WinZip으 로 압축하여 올린 것입니다. 그러므로 Dolphin Smalltalk를 설치하기 위해서 는 다음과 같은 과정을 거치면 됩니다. 1. 자료실에서 Dolphin Smalltalk와 Dolphin Education Center를 찾 아서 내리받으십시오. 2. 내리받은 파일은 zip 압축파일이므로 WinZip 등과 같이 긴 파일 이름을 지원하는 압축 프로그램을 사용하여 압축을 푸십시오. 3. 압축이 풀리면 실행 파일 하나가 나오는데, 이것을 실행시키십시 오. 자동 풀림 파일이므로 실행파일을 실행하면 바로 설치 화면 으로 넘어갑니다. 4. 다른 응용 프로그램을 설치할 때처럼 그냥 단추를 누르면 바로 바로 넘어갑니다. 고칠 사항이 있는 사람이라면 알맞게 고 치면 됩니다. 5. 설치를 마무리하면 Dolphin Smalltalk의 바로 가기를 시작 메뉴 에 넣을 것인가를 묻습니다. 여러분이 알아서 하면 될 것입니다. 이렇게 하면 설치의 전 과정이 다 끝나게 됩니다. 특별히 설정해 줄 것이 없 기 때문에 매우 쉽게 설치를 할 수 있을 것입니다. 나중에 필요하다면 언제 든지 Dolphin Smalltalk를 제어판의 "프로그램 추가/삭제"를 통해서 제거할 수 있습니다. Dolphin Smalltalk를 시작하기 위해서는 "시작 → 프로그램 → Dolphin Smalltalk 98"을 가리킨 다음 안에 들어있는 "Dolphin Smalltalk 98" 아이콘 을 실행하면 됩니다. ---<잠깐!>----------------------------------------------------------- 처음 Dolphin Smalltalk를 설치하여 실행할 때에 화면에 경고 상자가 나타납 니다. 대강의 내용은, 지금 사용하고 있는 Dolphin Smalltalk는 아직 등록 절차를 거치지 않았기 때문에 프로그램의 실행 결과를 저장할 수 없다는 것 입니다. 저장 기능을 사용하려면 Object Arts사에서 무료로 배부하는 등록 번호를 발급 받아야 하는데, 이에 관해서는 조금 뒤에 자세히 설명합니다. -------------------------------------------------------------------- 1.3. Smalltalk 맛보기 프로그램 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 이제 Smalltalk의 설치를 마쳤으므로 설치된 Smalltalk 환경을 실행시켜 봅 시다. 그러면 "Transcript"와 "Workspace"라는 제목을 가진 두 개의 창이 뜰 것입니다. 이 두 개의 창은 모두 Smalltalk의 명령어를 실행시킬 수 있는 기 능을 가지고 있습니다. 그러나 지금 우리가 주목해야 할 창은 'Untitled - Workspace'라는 이름을 가진 창입니다. 이 창에는 아마 "Welcome to Dolphin Smalltalk/98"이라는 큰 제목과 함께 제법 긴 문장들이 들어 있을 것입니다. 이 문장들에는 여러분이 Smalltalk 프로그램을 실행하는데 익숙해지도록, 그 리고 Smalltalk 프로그래밍에 대한 흥미를 느낄 수 있도록 짤막한 Smalltalk 프로그램들이 실려 있습니다. 이제 여기서는 이 창에 들어 있는 Smalltalk 프로그램을 실행하고 그 결과를 알아보는 방법을 알아봄으로써, Smalltalk 명령의 실행방법과 Smalltalk 프로그래밍의 생김새를 어느 정도 파악할 수 있게 하겠습니다. 여러분이 보고 있는 Workspace를 "일터"라고 부릅니다. 여기는 여러분이 Smalltalk 시스템에 명령을 내리거나, 이미 만들어진 프로그램의 결과를 확 인하는 곳입니다. 일터는 '메모장'이나 '워드패드'와 비슷한 동작 방법을 가 지고 있습니다. 즉 흔히 사용하는 텍스트 문서 편집기와 비슷한 동작 방식을 가지고 있다는 말입니다. 이 창에 여러분은 마음대로 글을 쓸 수 있으며, 덩이(block)를 씌워서 한 번 에 여러 개의 글자들을 복사 또는 이동할 수 있습니다. 단지 일터가 일반 텍 스트 편집기와 다른 점은, 이곳에는 Smalltalk의 명령들이 들어가고, 이 명 령을 실행할 수 있다는 것입니다. 일단 마우스나 글쇠판으로 밀대(scroll bar)를 사용해서 아래와 같은 문장이 보이도록 화면을 아래로 말아 내리십시오. ---------------------------------------------------------- "First evaluated by Smalltalk in October 1972, and by Dolphin in February 1995. With a bit of luck the answer will be 7." 3 + 4. ---------------------------------------------------------- 위에 보이는 문장은 Smalltalk에서 실행할 수 있는 명령입니다. 이 위의 다 른 문장들은 Smalltalk의 명령을 어떤 방식으로 실행하는 것인지, 그리고 실 행 결과를 어떻게 얻어낼 수 있는지에 대해서 설명하고 있습니다. 자, 이제부터 우리는 Smalltalk 명령을 내려보게 될 것입니다. 방향 글쇠를 이용하여 커서를 3 + 4. 가 있는 줄로 이동하십시오. '.' 바로 뒤에 커서를 위치시키는 것입니다. 이제 글쇠판에서 를 누르십시오. 그리고 화면을 살펴봅시다. 커서가 놓였던 자리에 덩이(block)가 씌워진 "7"이라는 글자가 나타났습니다. 3 + 4. ☞ 7 여기서 덩이에 둘러싸인 체로 나타난 "7"은 방금 우리가 실행시킨 명령의 결 과입니다. "3 + 4"라는 명령을 실행하였더니 "7"이라는 결과가 나왔다는 말 입니다. 이처럼 Smalltalk에서는 명령을 실행하면 그 결과가 언제나 덩이가 씌워진 체로 나타납니다. 따라서 이 상태에서 바로 글쇠판의 글쇠나 글쇠를 이용하여 덩이를 지우게 되면, 덩이가 씌워진 명령의 실행 결 과도 역시 지워지게 되는 것입니다. 방금 우리가 실행한 명령은 1972년 10월에 Smalltalk 시스템에게 처음으로 내려진 명령이라고 합니다. Object Arts사는 1995년 2월에 자사의 Dolphin Smalltalk에서 이 명령을 실행했다는군요. 이제 다음 명령을 실행할 차례입니다. 200 factorial. 위의 문장 끝에 커서를 갖다 놓고, 앞서 사용했던 글쇠를 사용해서 명령을 실행시켜봅시다. 어떻게 되었습니까? 200 factorial. ☞788657867364790503552363213932185062295135977687173263294742533244359 44996340334292030428401198462390417721213891963883025764279024263710506 19266249528299311134628572707633172373969889439224456214516642402540332 91864131227428294853277524242407573903240321257405579568660226031904170 32406235170085879617892222278962370389737472000000000000000000000000000 0000000000000000000000 지금 여러분은 200!, 즉 200의 계승을 구한 것입니다. 정말 어마어마한 자릿 수의 결과가 산출되었습니다. 대단하지 않습니까? 아마 C++나 Java 언어에서 기본으로 제공하는 기능만으로 위와 같은 결과를 얻으려면 상당한 노력이 필 요했을 것입니다. ---<잠깐!>---------------------------------------------------------- 계승? 계승(階乘, factorial)이란 n이 하나의 자연수일 때, 1에서 n까지의 모든 자 연수의 곱을 n에 대하여 일컫는 말입니다(한글학회, 1994, 우리말큰사전). 이를테면 5!는 5x4x3x2x1, 즉 120이 되는 것입니다. ---------------------------------------------------------- 그럼 Smalltalk에서 200!을 구하는데 과연 얼마나 시간이 걸릴까요? 바로 다 음의 명령을 실행하면 결과를 알 수 있습니다. 를 사용하십시오. Time millisecondsToRun: [200 factorial]. ☞ 1 와우! 200!을 구하는데 1ms정도의 시간밖에 걸리지 않는다고 그러는군요. 1ms초는 1000분의 1초이므로, 매우 빠른 속도로 200!을 구할 수 있다는 것을 알 수 있습니다. 좀 더 세밀하게 측정할 수도 있습니다. 다음 명령을 실행해 보십시오. (이제 각 명령을 실행하기 위해서는 해당 명령 끝에 커서를 위치하고 글쇠 를 누른다는 것쯤은 기억하고 계시겠지요?) Time microsecondsToRun: [200 factorial]. ☞ 1024 위의 명령은 200!을 구하는데 걸린 시간을 100만 분의 1초 단위로 구하는 명 령입니다. 필자의 경우는 약 1024㎲의 시간이 걸렸습니다. 물론 여기서 여러 분이 직접 실행했을 때의 결과는 다를 수 있습니다. 이 결과는 시간값이기 때문에 명령을 실행하고 있는 컴퓨터의 속도에 매우 민감하게 반응합니다. 여기서 중요한 것은 이러한 시간값이 아닙니다. 필요하다면 Smalltalk에서는 100만 분의 1초 단위로 명령 실행 시간을 측정할 수 있다는 것이 중요한 것 이지요. 이제 Smalltalk의 내부를 한 번 들여다보겠습니다. Smalltalk 환경에는 많은 수의 객체(object)가 있으며, 이들 객체는 저마다의 갈래(class)에 속해 있 습니다. 아래의 명령을 실행시키면 현재 Smalltalk 환경에 어떤 갈래들이 있 는지를 한 눈에 알 수 있습니다. Class allClasses asSortedCollection. ☞ a SortedCollection(_FPIEEE_RECORD AbstractCardContainer AbstractToTextConverter ACCEL AcceleratorPresenter AcceleratorTable ....(중략).... DWORDBytes DWORDField EDITSTREAM ... etc ... 이번에도 참 많은 결과가 화면에 표시되었습니다. 그런데 맨 마지막 줄을 보 십시오. "... etc ..."로 끝났습니다. 이는 지금 화면에 표시된 것보다 훨씬 더 많은 수의 갈래가 존재한다는 말입니다. 또한 방금 실행한 명령의 결과를 제대로 알아보기가 어려웠습니다. 왜 그랬을까요? 그것은 바로 갈래의 이름 들을 그냥 줄줄이 늘어놓았기 때문입니다. 지금까지 살펴본 것처럼 Smalltalk에서 어떤 명령을 실행한 뒤에는 언제나 결과가 남습니다. 그 중에는 "3 + 4."의 경우와 같이 간단한 결과를 남기는 경우도 있지만 지금의 경우처럼 복잡한 결과를 남기는 경우도 많습니다. 이와 같이 복잡한 결과를 좀 더 쉽게 보기 위해서, 지금까지와는 다른 명령 의 명령 실행 방법이 준비되어 있습니다. 위에서 내린 명령을 한 번 더 실행해 봅시다. 역시 명령의 끝에 커서를 놓고 글쇠판에서 를 누르십시오. 가 아니라 라는 점을 주의해 주십시오. Class allClasses asSortedCollection. ☞ "Inspector 창 열림" 어떻습니까? "Inspecting a SortedCollection"이라는 제목의 창이 화면에 나 타났습니다. 지금 나타난 창을 "객체 탐색기"(object inspector), 혹은 간단 히 "탐색기"(inspector)라고 부릅니다. 창의 왼쪽에는 self부터 시작하여 몇 개의 항목들이 있으며, 그 밑에는 1, 2, 3,...처럼 번호가 매겨져 있습니다. 그리고 오른쪽에는 왼쪽에서 돋이된 항목의 결과를 표시하는 부분이 있습니다. 처음에는 "self"라는 항목이 선택 되어있을 것이고, 오른쪽에는 방금 우리가 로 명령을 실행했을 때와 똑같은 결과가 나타났을 것입니다. 다른 항목들은 내버려두고, 1, 2, 3,...처럼 번호가 매겨진 항목들을 돋이해 봅시다. 그러면 각 항목에 하나씩의 낱말이 오른쪽 창에 보일 것입니다. 이 것이 지금 Smalltalk 환경에서 사용할 수 있는 갈래(class)입니다. 맨 마지 막 항목은 은 몇 번입니까? 필자의 경우는 567입니다. 결국 이 말은, Smalltalk 시스템에는 500개가 넘는 갈래가 존재한다는 말입니다. 갈래들을 한 번 쭉 훑어보았으면 이제는 열려있는 탐색기를 닫으십시오. 계속 명령어를 실행시켜봅시다. 아래의 명령은 Smalltalk 환경에 도대체 몇 개의 객체(object)들이 존재하는지를 보여줍니다. 를 쓰지 말고 로 실행하십시오. Object allSubinstances size. ☞ 44121 필자의 경우에는 44121개의 객체가 있다고 보고되었습니다. 여러분의 경우에 는 좀 다른 숫자가 나타날지도 모르겠습니다만, 여하튼 현재 돌아가고 있는 Smalltalk 환경에 적어도 4만개가 넘는 객체들이 서로 맡은 바 임무를 수행 하면서 돌고 있습니다. '객체'니 '갈래'니 하는 말이 생소하십니까? 이제부터 점점 명령의 의미를 파악하기가 어려워집니까? 전혀 신경 쓸 필요가 없습니다. Smalltalk를 공부 하면서 차차 자세하게 알게 될 것이기 때문입니다. 지금은 단지 Smalltalk의 명령을 실행하고 결과를 알아보는 방법에만 초점을 맞춥시다. 지금까지 우리는 몇 가지의 Smalltalk 명령을 실행해 보았습니다. 여기서 Smalltalk 명령을 실행하는 방법에 대해서 지금까지 알아본 것을 간단하게 정리하고 넘어가도록 하겠습니다. 1. 실행해야 할 명령 끝에 커서를 놓는다. 2. 글쇠를 입력하면 명령이 실행되고 결과가 나타난다. 3. 나타난 결과가 지나치게 복잡하면 를 사용하여 "탐색기" 를 통해서 결과를 살펴볼 수 있다. 정리가 되십니까? 아직까지 이해가 잘 안 가시는 분들은 여기서 잠시 휴식을 취하십시오. 그리고 처음부터 차근차근 다시 한 번 제 글을 따라가면서 명령 을 실행시켜 봅시다. 자, 그럼 이제 다음의 명령을 실행시켜보겠습니다. <바탕글 1> 간단한 디지털 시계 ---------------------------------------------------------- digitalClockProcess := [[ Processor sleep: 1000. (DesktopView current canvas) font: (Font name: 'Arial' pointSize: 36) bold; text: Time now printString at: 10@10; free ] repeat] fork. ---------------------------------------------------------- 지금까지 우리는 한 줄 짜리 Smalltalk 명령을 실행해 보았습니다. 그런데 위의 <바탕글 1>은 일곱 줄로 이루어진 명령입니다. 이 명령을 그럼 어떻게 실행할 수 있을까요? 방법은 간단합니다. 위의 일곱 줄에 모두 덩이를 씌우십시오. 덩이를 씌우는 방법은 1. 마우스를 이용하여 끌어서 덩이를 씌우는 방법. 2. 명령의 첫 글자에 커서를 놓고, 를 누르면서 방향 글쇠를 이용하는 방법 등이 있습니다. 둘 중에서 여러분이 편리한 것을 골라서 사용하시기 바랍니 다. 어쨌건 중요한 것은 위의 일곱 줄에서 한 글자도 빼놓지 말고 덩이를 씌 워야 한다는 것입니다. 덩이를 씌웠으면 이제는 앞에서 한 것처럼 를 입력하여 명령을 실행 시켜 보겠습니다. 어떻게 되었습니까? <바탕글 1> ☞ a Process(a CompiledExpression, priority: 5, state: #ready) 일곱 줄에 덩이를 씌운 다음 를 누르자마자 위의 결과를 뿌리면서 화면 왼쪽 구석에 큼지막하게 현재 시간이 표시되는 것을 볼 수 있습니다. 시간이 나타나는 자리에 다른 그림이 그려지더라도 곧 그 그림은 지워지고 그 자리에 시간이 나타납니다. 아주 큼지막하게 말입니다. 결과적으로 <바탕 글 1>은 간단한 디지털 시계를 만들어서 화면에 보이는 프로그램이었습니다. 그렇지만 언제나 저렇게 큼지막한 시계가 표시되어있으면 때로는 불편할 때 가 있을 것입니다. 자, 이제 우리가 방금 표시한 디지털 시계를 없애도록 합 시다. 다음 명령을 실행하십시오. 한 줄 짜리 명령이므로 덩이를 씌울 필요 는 없습니다. 그냥 명령의 끝에 커서를 놓고 를 눌러보십시오. digitalClockProcess terminate. ￢ UserLibrary default invalidate: nil lpRect: nil bErase: true. ☞ true ※ 줄 끝에 '￢' 표시가 되어 있는 것은 한 줄에 쓸 수 있는 글자수의 제한 때문에 어쩔 수 없이 두 줄 이상으로 갈라서 나타낸 것을 의미합니다. 그러므로 이 표시가 있다는 것은 바로 다음 줄과 이어서 한 줄임을 나타 냅니다. 위의 명령을 실행하면 여태껏 표시되던 시계는 없어지고 'true'를 결과값으 로 받게 됩니다. 앞서 우리는 두 가지 명령을 실행해 보았습니다. 하나는 <바탕글 1>로써 화 면에 시계를 보이는 명령이고, 나머지 하나는 동작하고 있는 시계를 멈추어 서 지우는 명령이었습니다. 그런데 이 명령을 실행한 뒤에 나타나는 결과값 은 무엇이었습니까? 둘 다 사실 우리에게는 별로 쓸모 없는 결과입니다. 우 리는 시계를 보이고 없애는 것이 중요하지, 실제로 이 명령이 실행되고 난 뒤에 어떤 결과를 일터에 표시하는지는 별로 관심이 없습니다. 이럴 때 Smalltalk에서 명령을 실행하는 세 번째의 방법이 있습니다. 이것은 바로 글쇠입니다. 명령어를 실행하고 나서 보고되는 결과를 굳이 일터 화면에 표시하고싶지 않을 때 사용합니다. 우리가 방금 실행했던 <바탕글 1>과 "UserLibrary"로 시작하는 명령을, 이번 에는 대신 를 사용하여 실행시켜 보십시오. 한결 깔끔하게 실행되는 것을 볼 수 있습니다. 자, 다시 한 번 정리합시다. Smalltalk에서 명령을 실행하는 방법은... ---<정리>---------------------------------------------------------- Smalltalk의 명령 실행법 * : 가장 일반적인 형태. 명령을 실행하고 나서 결과를 보인다. * : 명령을 실행하고 난 결과가 복잡할 때, 결과값을 탐색한다. * : 명령 실행 자체에 의미가 있고 결과는 무시하고 싶을 때 쓴다. ---------------------------------------------------------- ---<다른 Smalltalk>--------------------------------------- Dolphin Smalltalk가 아닌 다른 Smalltalk 환경의 경우 명령 실행 방법이 다 를 수 있습니다. 일단 이에 대해서는 나중에 명령 실행을 중점적으로 다루는 마당에서 자세하게 설명할 것입니다. ---------------------------------------------------------- 자, 그럼 계속해서 Smalltalk가 어디까지 할 수 있는지를 시험해 봅시다. 아 래 명령은 여러분이 듣고싶은 음성(wave) 파일을 연주해 줍니다. (Sound fromFile: 'xxxxx.wav') woofAndWait; woofAndWait. 위에서 'xxxxx.wav'를 자신이 연주하고 싶은 파일 이름으로 바꾸어 주면 됩 니다. 위의 명령 역시 실행된 후의 결과값 보다는 명령 실행 자체가 중요하 므로, 를 사용하여 실행시켜 봅시다. 필자는 (Sound fromFile: 'C:\Windows\Media\Ding.wav') woofAndWait; woofAndWait. 로 고쳐서 실행해 보았습니다. 여하튼 위의 명령은 우리가 지정한 음성 파일 을 두 번 연주해 주는 일을 합니다. 우와! Smalltalk에서 멀티미디어까지??? 다음 명령은 이미 프로그래밍 언어를 접해본 사람들에게 의미가 있을지도 모 르겠습니다. 100개의 원소를 가진 배열을 만들어 내는 명령입니다. (1 to: 100) collect: [:i | i]. ☞ #(1 2 ...(중략)... 99 100) 결과가 너무 많습니까? 를 사용하지 말고 를 사용하여 탐색 해 봅시다. (배운 것을 잘 써먹는 것이 정말 중요하겠지요?) 위의 명령은 1 부터 100 까의 수 100개가 들어 있는 배열(array)을 만들어 내는 명령입니 다. '배열'은 간단히 말해서 번호가 붙은 '통'이라고 생각하면 되겠습니다. 자, 이제 처음보다는 Smalltalk 명령 실행에 많이 익숙해졌을 것입니다. 이 제는 좀 더 부드럽게 진행해 나갈 수 있겠습니다. 자, 끝까지 해 봅시다. 지금도 일요일이면 TV에서 복권 추첨을 합니다. 이 때가 복권을 산 사람들의 희비가 엇갈리는 순간이겠지요 아래의 명령은 주택복권을 추첨하여 여섯 개 의 번호를 담은 배열―앞에서 배열은 '번호가 붙은 통'쯤으로 이해하라고 말 씀드린 것, 기억하십니까?―을 결과값으로 넘겨줍니다. (Random new next: 6) collect: [:n | (n * 49) rounded]. ☞ #(37 48 22 19 22 24 ) "첫 번째 실행" ☞ #(4 36 20 37 24 5 ) "두 번째 실행" ☞ #(18 43 28 15 41 22 ) "세 번째 실행" ...(중략)... 위의 명령은 실행할 때마다 서로 다른 번호를 나타냅니다. 신기하지 않습니까? 여 러분이 즐겨하던 게임에서 매번 다른 상황이 연출되는 것도 이와 같은 원리가 적 용되었기 때문입니다. 위의 명령은 다 좋지만 한 가지 결점이 있습니다. 가끔가다가 두 개 이상의 같은 수가 나올 확률이 있다는 것입니다. (첫 번째 실행 결과를 잘 보십시오.) 실제로 복권을 추첨할 때에는 같은 숫자가 두 번 이상 나오면 다시 추첨을 합니다. 그래 서 중복된 수가 나오지 않도록 하는데요... 아래의 명령은 바로 이러한 원리를 그 대로 적용한 예입니다. 명령이 두 줄 이상이므로 글쇠판이나 마우스로 덩이를 씌 운 후 실행하십시오. <바탕글 2> 복권 추첨 프로그램 ---------------------------------------------------------- r := Random new. s := Set new. [ s size = 6 ] whileFalse: [s add: (r next * 49) rounded]. s asSortedCollection asArray. [ 실행 결과 ☞ #(15 18 21 25 31 39 ) "첫 번째 실행" ☞ #(6 11 21 26 27 31 ) "두 번째 실행" ...(중략)... ---------------------------------------------------------- <바탕글 2>는 단순히 중복된 숫자만 나오지 않는 것이 아니라, 작은 수에서 큰 수로, 즉 오름차순으로 정렬된 결과를 남깁니다. 이제 정말 복권 추첨 프 로그램 같습니까? 지금까지는 글자들하고만 놀았으므로, 이번에는 여러분의 그림 솜씨를 마음 껏 발휘할 수 있는 기회를 드리겠습니다. 다음 명령을 를 사용하여 실행하십시오. scribble := Scribble show. 화면에 'a Scribble'이라는 제목이 달린 노란색 창이 열릴 것입니다. 주저하 지 말고 이 창 위에 마우스를 끌어서 그림을 그려봅시다. 아주 잘 그려질 것 입니다. 여러분의 그림 솜씨가 여기에서 드러나겠지요? 그림판이 좀 썰렁합니다. 아래의 명령을 한 번 실행시켜 보십시오. 방금 여 러분이 실행했던 명령어의 결과로 만들어진 그림판은 닫지 않도록 하십시오. EtchASketch showOn: scribble model. 위의 명령을 실행하면 "Etch A Sketch"라는 그림판이 열릴 것입니다. 그리고 방금 여러분이 노란색 그림판에 그렸던 그림이 그대로 나타납니다. 아마 Dolphin Smalltalk를 만든 영국에서는 "Etch-a-Sketch"라는 그림판이 보편적 으로 사용되고 있나봅니다. 지금 화면에는 노란 그림판과 Etch-aSketch가 떠 있습니다. 둘 중 아무 곳에 나 여러분이 그림을 그리면 다른 한 쪽에 그것이 바로 반영이 됩니다. 즉 둘 은 모양은 서로 다르지만 같은 자료를 공유하고 있습니다. 이것이 Dolphin Smalltalk에서 응용 프로그램을 만드는 "MVP 짜임새"의 예를 보여주는 것입 니다. "MVP 짜임세"에 대해서 공부하려면 아직도 많은 여정이 남았지만, 그 때까지 지치지 말고 열심히 합시다. 그림을 다 그렸으면 이제 열려있는 두 개의 그림판을 닫으십시오. 아래 명령은 "발자취 창"(walkback window)를 표시하는 명령입니다. 발자취 창에 대해서도 나중에 상세하게 다루겠지만, 여기서는 단지 프로그램이 어떤 자취로 실행되어왔는가를 나타내는 창쯤으로 생각하면 됩니다. self halt. 위의 명령을 실행하면 "발자취 창"이 열립니다. 보통의 경우 그냥 단추를 누르는 것으로 문제가 해결됩니다. 만일 다른 프로그래 밍 언어를 공부해 본 사람이라면 여기서 단추를 누름으로써 Smalltalk 환경의 벌레잡개(debugger)를 구경하실 수 있습니다. 물론 이렇게 해서 열린 벌래잡개는 Smalltalk 환경을 들여다볼 수 있는 중요한 도구입니 다. 그러므로 잘못 다루는 일이 없도록 조심하십시오. 나중에 Smalltalk에 대해서 어느 정도의 지식이 생기면 그 때 벌래잡개에 대해서 깊이 있는 공부 를 할 수 있을 것입니다. 운전도 못하면서 자동차 뚜껑을 열어서 차를 망그 러뜨리는 일이 있어서는 안되겠지요? ^^: 다음 명령은 Smalltalk 환경에서 'Dolphin'이라는 낱말이 포함된 바탕글 (source code)를 찾아내는 명령입니다. 3MB가 넘는 큰 용량의 파일을 뒤져서 내용을 찾는 것이기 때문에 몇 십초 정도의 시간이 걸릴 수도 있습니다. 조 금만 기다리면 'Dolphin'이라는 낱말을 포함하고 있는 여러 가지의 바탕글들 이 나타나게 될 것입니다. SmalltalkSystem current browseContainingSource: 'Dolphin'. "Containing Source: 'Dolphin'"이란 이름이 붙은 창은 두 부분으로 이루어 져 있습니다. 위쪽은 찾아낸 바탕글을 나타내고, 아래쪽은 해당 글의 자세한 내용이 표시되는 곳입니다. 과연 Smalltalk 환경에서 Dolphin이라는 낱말이 몇 번이나 나왔으며, 또 어디서 사용되고 있는지를 한 번 살펴보시기 바랍니 다. (참고로 '바탕글'을 명령을 써넣은 글이라는 뜻입니다.) 이제 마지막 명령입니다. 우리는 지금까지 여러 가지 명령을 실행해 왔는데, 이번 명령처럼 썰렁한 것은 없을 것입니다. 어느 정도로 썰렁하냐고요? 직접 실행을 해 보십시오. 아래의 명령을 실행해 봅시다. View destroyAll. 위의 명령이 실행되자마자 Smalltalk 환경의 열려있던 모든 창이 없어지고 "Transcript"라는 이름의 창만 하나 덜렁 남아 있게 되었습니다. 썰렁하지 않습니까? ^^: 방금 내린 명령은 주로 Smalltalk 환경을 깨끗이 하고 싶을 때 사용하는 명 령입니다. 지금까지 우리는 많은 명령을 실행해서 결과를 출력했으므로 우리 가 가지고 놀았던 흔적(?)을 깨끗이 하는 것이라고 생각하면 되겠습니다. 지금까지 우리는 Smalltalk에서 여러 가지 명령을 실행해 보았습니다. 그리 고 명령을 어떻게 실행하는지에 대해서도 알아보았습니다. 명령을 실행할 때 에는 , , 의 세 가지 글쇠를 사용한다는 것도 알아 보았습니다. 또한 한 줄 짜리 명령과 여러 줄에 걸친 명령을 실행하는 방법 도 알아보았습니다. 이제 Smalltalk에서 명령을 내리는 것이 별로 어렵지 않을 거라고 생각합니 다. 만약 잘 모르겠으면 Smalltalk를 빠져나간 다음 다시 들어와서 이 글에 있는 내용을 다시 한 번 따라해 보시기 바랍니다. 이제 Smalltalk를 끝내야 하는데, 앞서 말씀드렸듯이 저장의 문제가 남아 있 습니다. Smalltalk를 끝낼 때마다 현재 Smalltalk의 상태를 저장하겠느냐고 묻게 됩니다. 지금은 아직 등록 절차를 밟지 않았으므로 저장은 불가능합니 다. 오히려 이것이 더 잘된 일인지도 모르겠습니다. 저장이 안 된다는 말은 여러분이 무슨 실수를 하더라도 그것이 Smalltalk 환경에 영향을 주지 않음 을 의미하기 때문입니다. 그러므로 당분간 Smalltalk에 익숙해질 때까지 저 장 기능 없이 연습해 보는 것도 도움이 될 것입니다. 등록 절차에 관한 것은 바로 다음에 설명을 드리도록 하겠습니다. 계속... 제 목:[강좌] Smalltalk 배우기 #3 관련자료:없음 [8] 보낸이:김찬홍 (안드래아) 1998-11-25 15:28 조회:260 Smalltalk 배우기 #3 1998. 11. 25. 김찬홍 mailto:andrea92@hitel.net ====================================== 1. Smalltalk의 소개 1.1. 프로그램과 프로그래밍 언어 1.2. Smalltalk의 설치 1.3. Smalltalk 맛보기 프로그램 →1.4. 몇 가지 준비해야 할 것들 1.4.1. Dolphin Smalltalk 등록하기 1.4.2. 바탕본 여벌 받기 1.4.3. 글꼴 설정하기 ........ ======================================= 1. Smalltalk의 소개 ------------------------------ 1.4. 몇 가지 준비해야 할 것들 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 지금까지 우리는 Smalltalk를 시작하고 끝내는 방법과 함께, Smalltalk 명령 을 실행하는 방법에 대해서 알아보았습니다. 이제 여기서는 여러분이 앞으로 Smalltalk 공부를 계속 진행하기 전에 준비해야 할 몇 가지 사항에 대해서 다루어보도록 하겠습니다. 1.4.1. Dolphin Smalltalk 등록하기 --------------------------------- 이제까지 우리는 Dolphin Smalltalk를 사용하면서 저장 기능을 사용할 수 없 었습니다. 이는 우리가 아직 등록 절차를 거치지 않았기 때문입니다. Object Arts사(社)는 공개용으로 사용할 수 있는 Dolphin Smalltalk 98 / 1.1판을 배포하면서, 그를 사용하는 사람들이 무료로 등록번호를 발급 받아서 사용하 도록 하고 있습니다. 이는 Dolphin Smalltalk를 사용하는 사람들이 어떤 계 층인지, 그리고 이 사람들이 어떤 것을 원하는지를 조사하기 위한 수단이라 고 생각합니다. 또한 사용자 지원을 위해서도 필요한 사항이라고도 합니다. 등록은 무료입니다. 그러므로 인터넷을 사용할 수 있는 사람이라면 바로 등 록 절차를 거칠 수 있습니다. 앞서 말한 대로, 등록을 하려면 Object Arts사에서 발급하는 등록 번호를 받 아야 합니다. 등록 번호를 발급 받는 방법은 WWW(World Wide Web) 페이지를 사용하는 방법과 전자 우편(e-mail)을 사용하는 방법이 있습니다. 1) WWW를 사용하는 방법 Dolphin Smalltalk를 시작합니다. 그런 다음 File > Exit Dolphin 메뉴를 실 행시켜서 Dolphin Smalltalk를 종료합니다. 이 때 현재 Smalltalk의 상황을 저장하겠느냐고 묻는데, 이 물음에 <예>라고 대답합니다. 그러면 "Locked Image"라는 제목이 붙은 창이 열릴 것입니다. 여기서는 왜 등록을 해야 하는 지, 그리고 어떻게 등록을 해야 하는지가 설명되어있습니다. 여기서 Username 입력 상자에 여러분의 영문 이름을 넣습니다. 그러면 창 아 래에 있는 라는 단추를 누를 수 있게 될 것입니다. 인 터넷에 연결되어있는지 확인하고 이어서 이 단추를 누르면 Object Arts사의 "등록 페이지"로 이동하게 될 것입니다. 이 페이지에는 몇 개의 입력 항목이 있습니다. 간단하게 이 항목들에 대해서 설명합니다. * Product: 사용하고 있는 Dolphin Smalltalk의 종류. 우리는 1.1판을 고르 면 되겠지요? * First Name: 여러분의 이름을 넣습니다. 저의 경우는 ChanHong Kim으로 표 기되므로, First Name에는 ChanHong을 입력하면 됩니다. * Last Name: 여러분의 성씨를 넣습니다. 저의 경우에는 Kim이겠지요? * Stree Address: 우리의 경우에는 시/군, 구/읍면, 동, 번지로 주소를 쓰지 만 외국의 경우는 거꾸로 입니다. Street Address에는 여러분의 동 이름 과 번지수를 씁니다. 저의 경우라면 2288-3, DaeMyung 3 Dong, Nam-Gu 쯤으로 임력하면 되겠지요? * City: 여러분이 사는 도시를 입력합니다. 저는 대구랍니다. Taegu. * State: 미국의 경우는 주를 입력합니다만, 우리는 비워둡니다. * Zip Code: 여러분의 우편번호를 넣습니다. 700-234. * Country: 우리의 자랑스런 "Korea"를 선택합니다. * E-mail: 여러분의 전자우편 주소를 입력하면 됩니다. * Where did you hear about this product? Dolphin Smalltalk에 대해 처음어로 접한 매체를 고릅니다. * Previous experience of Smalltalk? 이전에 Smalltalk를 사용한 경험을 묻고 있습니다. * Intended use of this product? Dolphin Smalltalk를 어떤 목적에 사용할 것인지를 묻습니다. * How many attempts did it take you to download this software?: Dolphin Smalltalk를 몇 번만에 전송받았는지를 묻습니다. * Image Code: 여기에 "Locked Image" 창에 표시된 Image code를 넣습니다. * Usrname: "Locked Image" 창에 입력한 여러분의 Username을 입력합니다. (반드시 일치해야 합니다.) 여기까지 항목의 입력이 끝나면 이제는 아래의 단추를 누릅니다. 그러면 Image Code와 그에 해당하는 Password를 발급 받게 됩니다. "Locked Image" 창에 방금 받은 Password를 입력하면 등록 절차가 끝나게 됩니다. 현 재 여러분이 설치한 Smalltalk에 대해서는 Username과 Password가 그대로 사 용될 수 있으므로, 다음부터는 등록 절차를 거칠 필요가 없습니다. 등록 절차를 마치면 이제부터 여러분의 컴퓨터에 설치되어 있는 Dolphin Smalltalk는 저장 기능을 사용할 수 있게 설정됩니다. 이제 여러분이 Smalltalk에서 실행한 모든 것을 저장할 수 있습니다. 2) 전자우편을 사용하는 방법 WWW를 사용하기 어렵거나 인터넷을 사용하기 어려운 분들은 전자우편을 이용 하면 등록번호를 발급 받을 수 있습니다. 수신: support@object-arts.com 제목: password 내용: Username과 Image code. 위의 형식대로 편지를 보내게 되면 곧 여러분의 사서함으로 등록 번호가 동 봉된 편지가 도착할 것입니다. 이렇게 해서 발급받은 password를 (1)과 마찬가지로 입력하게 되면 Dolphin Smalltalk가 등록판이 됩니다. 일단 등록판이 생성되면 모든 기능을 제한 없이 사용할 수 있습니다. 1.4.2. 바탕본 여벌 받기 ----------------------- Smalltalk를 끝낼 때 여러분은 현재 Smalltalk의 상태를 그대로 저장했다가 나중에 Smalltalk를 실행할 때 똑같이 복원할 수 있습니다. 예를 들어, 여러 분은 저번 "1.3" 마디에서 Smalltalk로 만들어진 디지털 시계를 본 적이 있 을 것입니다. 이제 저장 기능을 사용할 수 있는 여러분의 Dolphin Smalltalk 에서 아래의 명령을 글쇠를 사용하여 실행해서 다시 한 번 디지털 시계를 표시해 봅시다. <바탕글 1> Smalltalk로 만든 디지털 시계 ---------------------------------------------------------- digitalClockProcess := [[ Processor sleep: 1000. (DesktopView current canvas) font: (Font name: 'Arial' pointSize: 36) bold; text: Time now printString at: 10@10; free ] repeat] fork. ---------------------------------------------------------- 여전히 화면에 큼지막한 디지털 시계가 표시되고 있을 것입니다. 이제 File > Exit Dolphin 메뉴를 사용해서 Dolphin Smalltalk를 끝내봅시다. 이 때 Smalltalk는 현재의 상태를 저장하겠느냐고 묻습니다. <예>를 선택하십시오. 그러면 Smalltalk의 실행이 끝나면서 여태껏 잘 돌아가던 시계가 멈춘 것을 볼 수 있습니다. 시계를 돌리던 Smalltalk 환경이 끝났기 때문에 당연히 멈 춘 것이지요. 이 상태에서 시계를 지우려면 현재 화면을 다시 그려줘야 합니 다. Windows의 바탕 화면이 표시되어있다면 글쇠를 눌러서 바탕 화면을 다시 그려줄 수 있습니다. 이제 다시 Smalltalk를 실행시켜 봅시다. 어떻게 되었습니까? Smalltalk가 실행되자마자 여러분이 입력한 <바탕글 1>과 함께 디지털 시계가 다시 움직 이기 시작했습니다. 즉, 여러분이 이전에 Smalltalk를 끝낸 상태를 그대로 유지하고 움직이는 것입니다. 신기하지 않습니까? 이야기를 더 진행하기 전에 다음의 명령을 로 실행시켜서 돌아가는 시계를 멈춥시다. digitalClockProcess terminate. UserLibrary default invalidate: nil lpRect: nil bErase: true. Smalltalk에서는 모든 것이 객체(object)입니다. 우리는 Smalltalk언어를 객 체지향적 언어라고 말합니다. 따라서 Smalltalk에서 모든 것은 객체라는 사 실이 그리 놀랄만한 일은 아닙니다. 그러나 C++나 Delphi 또는 Visual Basic 등 다른 개발 환경을 사용하던 사람이라면 Smalltalk의 객체가 살아있다는 사실을 간과하기 쉽습니다. 보는 바와 같이, Smalltalk의 모든 객체는 살아 있습니다. 그리고 이는 Smalltalk를 종료할 때 그대로 저장되었다가 나중에 Smalltalk 환경이 시작되면 제 상태를 유지하면서 계속 움직입니다. Smalltalk를 끝낼 때에는 현재의 상태를 그대로 기록해 둡니다. 여기서 '현 재의 Smalltalk 상태'를 "본"(image)이라고 부르고, 이러한 본을 저장해 두 는 것을 "본을 뜬다"고 말합니다. 본에는 Smalltalk 환경에서 살아서 돌아가 는 모든 종류의 객체들이 저장되어 있습니다. Smalltalk 환경은 결국 4만여 개의 객체가 어루러져서 돌아가는 곳이므로,'본'에는 Smalltalk의 모든 상태 가 기록되는 것입니다. 그러므로 '본'은 매우 중요한 것입니다. 그야말로 여 러분이 만들어 놓은 모든 것은 '본'에 저장됩니다. 그러므로 Smalltalk를 종 료할 때에는 반드시 "본"을 떠 두도록 합시다. 그래야만 나중에 Smalltalk 환경이 다시 시작될 때 이전에 뜬 본을 그대로 가지고 와서 객체들을 재생시 킬 수 있기 때문입니다. 결국 "본"은 시간이 흐름에 따라 자꾸 자꾸 변한다는 것을 알 수 있습니다. 때로는 새로운 객체가 만들어지기도 하고, 이미 있던 객체가 없어지기도 하 면서 말이지요. 그런데 만약 여러분이 실수로 Smalltalk에서 꼭 필요한 어떤 객체를 지웠다고 생각해 봅시다(물론 이러한 일을 Smalltalk가 묵묵히 지켜 보고 있지는 않습니다. 몇 번의 경고 과정을 거치지요.). 그럼 어떻게 되살 릴 수 있겠습니까? 사실 방법이 없습니다. 지우기는 쉬워도, 그렇게 해서 한 번 지워진 객체는 다시는 복구시킬 수가 없기 때문입니다. 이것이 여러분이 Smalltalk를 설치한 후에 바로 생성되는 '바탕본'(base image)을 한 벌 떠 두어야 하는 이유입니다. 그래야만 만일의 경우에 발생하는 문제를 예방할 수 있는 것입니다. 자, 이제 그럼 어떻게 하면 바탕본을 여벌 받아둘 수 있는지를 알아봅시다. Dolphin Smalltalk가 설치된 폴더를 열어보면 다음과 같은 파일이 있음을 알 수 있습니다. Dolphin.chg Dolphin.img Dolphin.sml 이 세 개의 파일이 여러분이 여벌(back up)을 받아야 하는 파일들입니다. 위 의 파일들을 여벌 받아서 다른 곳에 각각 복사해 두면, 만일 여러분의 실수 로 지워지거나 바뀐 Smalltalk 환경을 되돌릴 수 있을 것입니다. 필자의 경 우 위의 세 파일을 압축하여 따로 보관합니다. 적어도 일 주일에 한 번은 위 의 파일을 여벌 받아두는 것이 매우 좋습니다. (필자는 하루에 한 번 씩 여 벌을 받습니다만...) 그럼 위의 파일들이 각각 무슨 역할을 하는지 간단하게나마 설명을 하도록 하겠습니다. * Dolphin.sml 이 파일은 Dolphin Smalltalk 바탕본의 바탕글(source code)입니다. 여기에 는 기본적으로 Object Arts사에서 만들어 놓은 Smalltalk 환경을 이루고 있 는 모든 구성요소에 대한 바탕글이 실려 있습니다. 용량이 3MB가 넘습니다. * Dolphin.img 이 파일은 Dolphin Smalltalk의 '본'(image)입니다. 앞서 말했지만, 이 본에 는 Smalltalk의 모든 객체들의 상태가 저장되어있습니다. 그래서 다음에 Smalltalk 환경이 다시 실행되면 여기에 저장되어있는 객체들이 재생되어 활 동을 시작하는 것입니다. * Dolphin.chg 이 파일은 '변경 기록 파일'(change log file)이라고 부릅니다. 이 파일 안 에는 여러분이 Smalltalk에서 실행한 모든 명령이 기록됩니다. 새로운 객체 를 만든다 거나 이전에 있던 객체를 지운다거나 하는, 여러분의 모든 동작이 이 파일에 기록되어 있습니다. 다시 말하면 바탕본이 어떻게 변해왔는지를 이 파일에 기록해 두는 것입니다. 여기서 여러분이 궁금해하는 점이 있을지도 모르겠습니다. 바로 본은 무엇이 고, 바탕글은 무엇이냐는 것입니다. 즉 '본'이 있는데 왜 따로 바탕글이 필 요한가가 궁금할 것입니다. '본'에는 객체의 상태가 기억되어 있습니다. 그리고 '바탕글'은 이러한 본에 들어가는 객체를 만들기 위한 명령들이 들어 있습니다. 비유를 들어보면, '본'은 집이고 '바탕글'은 설계도입니다. 설계도대로 만들면 한 체의 집이 생깁니다. 그러므로 집이 있고 그 집을 만들기 위한 설계도가 있는 것입니 다. 마찬가지로 '본'에는 무수히 많은 객체들이 있고, 이 객체들을 만들기 위한 명령은 바탕글에 들어있습니다. 바탕글에 있는 명령을 사용하면 객체를 만들 수 있는 것이고, 이 결과가 바로 '본'에 저장되는 것입니다. 우리가 맨 처음에 3 + 4. ☞ 7 이라고 했는데, 이 간단한 명령도 객체를 만드는 일을 합니다. 즉 '3'과 '4' 라는 객체를 가지고 '7'이라는 새로운 객체를 만들었기 때문입니다. '7'이라 는 객체를 만들기 위해서 "3 + 4."라는 명령을 한 것이고, 이 결과 생겨나는 것이 "7"이라는 객체입니다. 여기서 "3 + 4."는 바탕글이 되는 것이고, '7' 은 그 결과(=본)가 되는 것입니다. 이제 '본'과 '바탕글'의 차이를 아시겠습 니까? 여하튼 Dolphin Smalltalk에서 여러분은 위에서 늘어놓은 세 개의 파일을 반 드시 여벌 받아 놓아야만 합니다. 그리고 여러분이 Smalltalk 환경으로 작업 을 해 나가면서 중간 중간에 여러분만의 본을 떠 두는 것이 좋습니다. 여벌 받기는 아무리 강조해도 지나치지 않으니까요. ---<잠깐!>---------------------------------------------------------- Dolphin Smalltalk가 아닌 다른 Smalltalk 환경에서는 필자가 설명한 것과 다른 방식으로 '본'을 관리할 수 있습니다. 그러나 Smalltalk는 기본적으로 본에 모든 상태를 저장하고, 다음에 Smalltalk 환경이 다시 실행되면 본에 기록된 것을 불러와서 쓴다는 것은 변함이 없습니다. ---------------------------------------------------------- 1.4.3. 글꼴 설정하기 -------------------- Dolphin Smalltalk는 기본적으로 영어권에 맞도록 설정되어 있습니다. 따라 서 한글 Windows에서 사용하는 기본 글꼴인 '굴림'으로 글꼴 설정을 바꾸어 줄 필요가 있습니다. Dolphin Smalltalk의 Tool > Options > Default Font... 메뉴를 사용하여 기 본 글꼴을 '굴림'으로 설정해 놓으면 이 후부터 Smalltalk는 기본적으로 굴 림체의 글꼴을 사용할 것입니다. ('굴림'과 '굴림체'는 다른 글꼴이므로 반 드시 '굴림'을 선택합시다.) 이제부터 여러분이 설정하는 것은 모두 Smalltalk의 본에 반영이 됩니다. 그 러므로 다음부터 Smalltalk를 시작하면 기본 글꼴이 적용될 것입니다. 지금까지 우리는 Dolphin Smalltalk를 등록하고, 바탕본을 여벌 받고, 기본 글꼴을 설정하는 방법을 익혔습니다. 이제 이를 바탕으로 하여 Smalltalk 환 경을 정비해 두면, 이 뒤로는 Smalltalk 공부에 많은 도움이 될 것입니다. 마지막으로 한 마디만 더 하겠습니다. "여벌 받기"는 아무리 강조해도 지나 치지 않습니다! :) 계속... 제 목:[강좌] Smalltalk 배우기 #4 관련자료:없음 [11] 보낸이:김찬홍 (안드래아) 1998-11-27 11:16 조회:246 Smalltalk 배우기 #4 1998. 11. 27. 김찬홍 mailto:andrea92@hitel.net ====================================== 1. Smalltalk의 소개 1.1. 프로그램과 프로그래밍 언어 1.2. Smalltalk의 설치 1.3. Smalltalk 맛보기 프로그램 1.4. 몇 가지 준비해야 할 것들 →1.5. Smalltalk 환경 둘러보기 1.5.1. 알림판 1.5.2. 일터 1.5.3. 객체 탐색기 1.5.4. 갈래씨줄 탐색기 1.5.5. 길수 탐색기 1.5.6. 꾸러미 탐색기 1.5.7. 창맵씨 1.5.8. 자원 탐색기 1.5.9. 발자취 창과 벌레잡개 ........ ======================================= 1. Smalltalk의 소개 ------------------------------ 1.5. Smalltalk 환경 둘러보기 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Smalltalk를 실행해 보면 최소한 두 개의 창이 열려 있음을 볼 수 있습니다. 하나는 "System Transcript"라는 제목이 붙어있는 "알림판"(transcript)이 있고, 나머지 하나는 "untitled - workspace"라는 제목이 붙여진 "일터"가 그것입니다. 물론 Smalltalk 환경에는 이 두 가지 창 말고도 다른 여러 가지 의 창이 있습니다. 각각은 저마다의 독특한 쓰임새를 가지고 있으며, 이들은 모두 Smalltalk로 프로그램을 짜는데 꼭 필요한 역할을 수행합니다. 이제 이 마디[節]에서는 Smalltalk에는 어떤 창들이 있으며 이들이 대충 어 떤 일을 하는지를 알아봄으로써, Smalltalk 환경의 특징들을 여러분이 간단 히 알아볼 수 있도록 하겠습니다. 각 창들에 대해서 나중에 필요할 때 좀 더 자세하게 설명할 것입니다. 여기서는 그냥 이러이러한 창이 있으며, 대충 이 렇게 생겼구나 하는 정도만 이해하도록 합시다. 아직까지 자료실에서 Dolphin Smalltalk를 내리받아 설치하지 않으신 분이라 면 지금부터는 조금 용량이 많기는 하더라도 Smalltalk 환경을 내리받아서 공부를 계속하시라고 권합니다. 세상은 멀티미디어화 되어가고 있지만 아직 도 우리의 정겨운 통신 환경은 파란 바탕에 흰색 글자만 나타낼 수 있기 때 문에, 그림을 곁들이고 싶은 필자의 간절한 마음이 반영되지 못하기 때문입 니다. :) 1.5.1. 알림판 ------------- Smalltalk 환경에서 가장 중요한 창은 "알림판"(transcript)입니다. 원래 'transcript'라는 낱말의 뜻은 '베껴낸 것, 사본, 등본'인데, Smalltalk를 깊이 공부하지 못한 필자로써는 왜 transcript라는 낱말이 이 창에 붙게 되 었는지를 이해하기가 어렵습니다. 아무래도 Smalltalk 시스템의 상태가 이 창에 그대로 반영되기 때문이 아닌가 생각합니다. 여하튼 이 창은 Smalltalk 환경에서 가장 중요한 창입니다. 이 창이 열림으 로써 바로 Smalltalk 환경이 시작되는 것이고, 이 창이 닫힘으로써 Smalltalk가 종료되는 것입니다. 즉 이 창은 Smalltalk 환경과 동고동락한다 고 해도 과언이 아닐 정도로, Smalltalk 환경이 실행되어 있다면 언제든지 열려있는 창입니다. 이 창은 뒤에서 설명할 '일터'(workspace)와 비슷한 기능을 합니다. 그러나 알림판이 '일터'와 구별되는 가장 큰 특성은, Smalltalk 환경에서 사용자에 게 알려야 할 것이 있으면 언제든지 이 창에 표시된다는 것입니다. 프로그램을 실행하는데 중대한 잘못이 생겼다거나, 새로운 꾸러미를 불러왔 다거나 이미 있던 꾸러미나 객체를 지울 때 문제가 있었다는 등 이 알림판에 는 Smalltalk 환경이 우리에게 알려야 할 여러 가지 사항들이 기록됩니다. 물론 여러분이 이 알림판에 지시를 보내어 여러분만의 글줄을 찍게 할 수도 있습니다만, 그것은 조금 뒤로 미루겠습니다. Smalltalk 환경을 끝낼 때 File > Exit Dolphin 명령을 내리는 대신 알림판 을 닫게 되면 Smalltalk 환경을 끝낼 수 있습니다. 1.5.2. 일터 ----------- 일터(workspace)란 Smalltalk 환경에서 알림판 다음으로 중요한 창입니다. 여러분은 일터에서 무엇을 합니까? :) 일을 하지요? 일에 성격에 따라 좀 다 르겠지만, 몸을 많이 움직여야 하는 일이라면, 땀을 흘리면서 물건을 나르기 도 하고 뛰기도 하면서 이 일터를 누빕니다. 머리를 쓰는 일이라면 이 일터 에서 글을 쓰기도 하고 지우기도 합니다. 여러분이 회사의 사장이라면 일터 에서 아랫사람들에게 여러 가지 지시를 내립니다. 그리고 지시를 받은 사람 들은 자신이 처리한 일의 결과를 사장에게 되돌려 보내줍니다. 이렇듯 일터 는 분주한 곳입니다. Smalltalk의 일터 또한 마찬가지입니다. 여기서 여러분은 기본적으로 글을 쓸 수 있습니다. 이 글이 Smalltalk에게 내리는 명령이 될 수도 있고, 명령 을 설명하는 풀이글이 될 수도 있으며, 그냥 아무런 관계없는 글이 될 수도 있습니다. 일터에서 여러분은 Smalltalk에서 명령을 내리고 그 결과를 시험합니다. 그 리고 프로그램의 어떤 부분을 만들기 전에 여기서 기본적으로 여러 가지 명 령을 내려봄으로써 논리를 세워 나갈 수도 있습니다. 새로운 일터를 만들기 위해서는 File > New 메뉴를 사용하거나, 도구 모음에 서 "흰 종이가 그려진 그림"을 누르면 됩니다. 알림판이 오직 하나밖에 존재 할 수 없는데 비해, 일터는 여러분이 필요한 수만큼 많이 만들 수 있습니다. 그리고 각각의 일터에 기록된 글들을 따로따로 저장하거나 불러올 수 있습니 다. 그러므로 어떤 명령을 실행한 뒤에 나타나는 여러 가지 결과와 더불어 여러분이 내린 명령을 따로 하나의 파일로 저장해 둘 수 있다는 말입니다. 앞서 우리는 알림판에 지시를 내림으로써 우리가 원하는 글줄을 찍을 수 있 다고 했습니다. 그럼 다음과 같이 명령해 보십시오. 글쇠를 사용해 서 아래 명령을 실행하십시오. (Smalltalk 명령을 실행하는 방법에 어려움을 겪는 분이라면 "1.3" 마디를 참조하시기 바랍니다.) Transcript show: '안녕하세요?'. ☞ 안녕하세요? "알림판에 이 내용이 표시된다." ---<잠깐!>---------------------------------------------------------- 베끼기는 하지 맙시다! 앞으로 이 글을 진행하면서 무수히 많은 Smalltalk의 명령이 소개될 것입니 다. 그래서 저는 여러분에게 부탁을 드릴까 합니다. 이 글에서 제공되는 Smalltalk 명령을 복사하여 일터에 붙여 넣어서 실행하 시지 말았으면 하는 것이 제 부탁입니다. 좀 번거롭더라도 지금 여러분이 읽고 있는 명령을 그대로 일터에 글쇠판으로 쳐 넣고 실행하여 결과를 관찰하는 것이 훨씬 좋습니다. 단순히 복사해서 붙 여 넣는 것 보다 실제로 글쇠판에서 명령을 치게 되면, 이 글에서 일단 명령 을 읽어서 머리에 기억되게 되고, 기억된 것을 글쇠판으로 치면서 일터에 나 타난 명령을 보게 되고, 명령을 실행하면서 세 번째로 명령을 보게 됩니다. 그러나 명령을 복사하고 붙이는 것은 전혀 이러한 효과를 볼 수가 없습니다. 글을 어떻게 읽고 어떻게 실행하는지는 전적으로 여러분에게 달려있습니다. 그러나 좀 더 효과적인 공부를 위해서는 모든 Smalltalk 명령을 여러분이 스 스로 쳐 넣으며 실행해야 합니다. 맹목적으로 명령을 쳐 넣는 것이 아니라, 도대체 이 명령이 어떤 의미인지를 생각하면서 입력하면 Smalltalk 공부는 생각 외로 매우 쉬워질 것입니다. 이는 필자가 처음 "Smalltalk Tutorial"을 공부할 때 직접 경험한 것이므로, 한 번 믿어보셔도 좋을 것입니다. ---------------------------------------------------------- 어떻습니까? 방금 실행한 명령의 결과가 그대로 알림판에 나타났습니다. 이 렇게 일터에서 여러분은 Smalltalk에게 명령을 내릴 수 있습니다. 또한 다음 과 같은 명령을 사용하여 일터에 명령의 수행 결과를 출력할 수도 있습니다. 3 + 4. ☞ 7 이처럼 일터는 여러분의 Smalltalk 프로그래밍에 있어서 가장 자주 접하게 되는 창이므로, 그 사용 방법을 확실히 익혀두는 것이 좋을 것입니다. 참고로 일터에서 할 수 있는 대부분의 일을 알림판에서도 할 수 있습니다. 그렇지만 관례적으로 Smalltalk에서 대부분의 작업은 알림판이 아닌 일터에 서 수행합니다. 알림판에는 주로 알림 사항이 기록되도록 하고, Smalltalk 환경 전체에 영향을 줄 명령이 있다면 이 '알림판'에서 실행하는 것이 관례 로 되어 있습니다. 1.5.3. 객체 탐색기 ------------------ 객체 탐색기(object inspector)는 명령을 실행할 떄 나 글 쇠 대신 글쇠를 사용할 때 나타나는 창입니다. 이 창은 기본적으로 복잡한 구조를 가지고 있는 객체의 내용을 좀 더 잘게 쪼개어 탐색하기 편리 하도록 만들어진 도구입니다. 앞에서 우리가 탐색기를 사용한 예를 생각해 보십시오. 아래의 명령은 Smalltalk 환경에 들어 있는 모든 갈래(class)들을 가나다 순서로 늘어놓은 모듬을 되돌리는 명령입니다. Class allClasses asSortedCollection ☞ "객체 탐색기 열림" 위의 명령을 글쇠로 실행해 보면 "Inspecting a SortedCollection" 이라는 제목이 붙은 창이 열릴 것입니다. 위의 명령을 실행하게 되면 500 개 가 넘는 원소들이 들어 있는 모듬이 결과값으로 돌아오게 되는데 이를 좀 더 쉽게 탐색하기 위해서는 객체 탐색기를 사용하는 것이 편리합니다. 객체 탐색기는 두 부분으로 이루어지는데, 왼쪽에는 그 객체에 속해있는 부 분 부분들의 이름이 표시되고, 오른쪽에는 현재 돋이된 부분의 값이 표시됩 니다. 맨 위의 "self"는 탐색하고 있는 객체 자신을 나타냅니다. 객체 탐색기는 복잡한 구조의 객체를 효율적으로 들여다보는데 매우 큰 몫을 하고 있습니다. 1.5.4. 갈래씨줄 탐색기 ---------------------- 자, 여러분이 지금 어디에 있던지 Tools > Class Hierarchy Browser 메뉴를 실행시키거나 글쇠판에서 를 누르면 '갈래씨줄 탐색기'Class Hierarchy Browser)를 불러낼 수 있습니다. 갈래씨줄 탐색기를 줄여서 '갈래 탐색기'라고도 부릅니다. 갈래는 홀로 떨어져서 있는 것이 아니라 다른 갈래와 관계를 맺고 있는데, 이 갈래씨줄 탐색기는 이러한 갈래들의 씨줄(hierarchy)을 짚어가며 갈래들 을 탐색할 때 사용하는 도구입니다. 모두 크게 내 부분으로 이루어진 갈래 탐색기가 매우 복잡해 보이겠지만, 이 창에 익숙해질 때쯤이면 여러분은 Smalltalk의 절반 이상을 공부한 셈이 됩니다. Smalltalk에서는 모든 것이 객체입니다. 그러므로 프로그래밍을 할 때에도 이러한 객체를 사용하거나 아니면 새로 만들어야 합니다. 이 일을 이 '갈래 탐색기'에서 할 수 있기 때문에, '일터'와 더불어 프로그래밍을 할 때 가장 자주 사용되는 도구이기도 합니다. 1.5.5. 길수 탐색기 ------------------ 우리가 Smalltalk에게 어떤 명령을 내리면 Smalltalk는 길수(method)를 뒤져 서 이 명령을 어떻게 실행해야할지를 알아냅니다. 길수 탐색기는 이러한 길 수들을 따로 모아서 탐색할 때 쓰이는 도구입니다. 다음의 명령은 길수 중에 서 'Dolphin'이라는 낱말이 들어간 것을 지금 쓰고 있는 본(image)에서 죄다 찾아내는 명령입니다. 약 3M 이상 되는 바탕글(source code)에서 글귀를 찾 는 것이므로 몇 초 정도 시간이 걸립니다. SmalltalkSystem current browseContainingSource: 'Dolphin' ☞ "길수 탐색기 열림" 생각보다 많은 길수에 "Dolphin"이라는 글귀가 포함되어있습니다. 이 길수 탐색기는 크게 두 부분으로 나누어져 있습니다. 위쪽 창에는 길수 이름들이 표시되어 있고 각각의 길수를 돋이할 수 있도록 되어있습니다. 그리고 아래 쪽 창에는 위쪽 창에서 돋이되어있는 길수의 바탕글이 표시됩니다. 길수 탐 색기는 앞서 말한 것과 같이 주로 여러 갈래(class)에서 조건에 맞는 길수를 뽑아내어 내용을 살펴보고자 할 때 사용합니다. 1.5.6. 꾸러미 탐색기 -------------------- Smalltalk 환경의 Tools > Package Browser 메뉴를 선택하면 꾸러미 탐색기 를 열 수 있습니다. 꾸러미(package)에는 Smalltalk의 갈래, 객체, 자원 (resource) 등이 함께 꾸려져서 들어있습니다. 주로 꾸러미는 하나의 커다란 프로그램을 만들 때, 그 프로그램과 관계된 여러 가지 객체들을 넣어놓고 관 리하기 위해서 사용됩니다. 꾸러미 탐색기는 이러한 꾸러미를 새로 만들거나 이미 있던 꾸러미를 들여오거나, 지우거나 고치는 일을 합니다. 꾸러미 탐색기는 크게 세 부분으로 되어있습니다. 왼쪽에 세로로 길게 되어 있는 창은 현재 Dolphin Smalltalk 환경에 설치되어있는 꾸러미들을 늘어놓 느 것입니다. 오른쪽 윗부분은 현재 꾸러미에 들어있는 것들을 살펴보기 위 한 곳으로써, 갈래, 길수, 넓은 꼬리표(global variables), 자원 등을 각각 따로따로 볼 수 있는 고름(tab)이 달려있습니다. 오른쪽 아랫부분은 위에서 돋이된 내용을 실제로 보여주는 곳입니다. 갈래가 돋이되어있다면 갈래꼴 (class definition)을, 길수가 돋이되어 있다면 바탕글 등을 보여줍니다. 꾸러미 탐색기는 Smalltalk 환경에서 움직이는 모든 객체를 관리하는 매우 중요한 도구입니다. 1.5.7. 창맵씨 ------------- 창맵씨(View Composer)는 사용자 접속 환경(User Interface)를 만드는 도구 입니다. Tools > View Composer 메뉴를 선택하면 이 창을 열 수 있습니다. 여기서 여러분은 창(window)이나 대화 상자(Dialog box)를 만들어서 프로그 램을 사용하는 최종사용자가 자료를 입력할 수 있도록 해 줍니다. 넓은 부분이 실제로 창을 설계할 때 사용하는 부분이고, 아래에 위치한 세 개의 창은 각각 현재 창의 뼈대, 현재 선택된 객체가 가지는 꼴(aspect), 그 리고 바로 왼쪽에 돋이되어있는 꼴이 갖고 있는 값을 표시하는 부분입니다. 창맵씨에는 '연모통'(tool box)라고 하는 딸림창이 떠 있습니다. 이 창에는 창을 만들 때 필요한 여러 가지 부품 자원이 들어있습니다. 글씨 꼬리표 (label), 입력 상자(edit box), 단추(push button)는 물론 이미 만들어진 창 도 여기에 표시됩니다. Delphi나 Visual Basic에서는 창을 설계하는 것에 상당히 많은 비중을 둡니 다. 물론 Smalltalk에서도 창 만들기는 매우 중요한 위치를 차지하지만, 기 본적으로 창을 설계하기 전에 먼저 객체를 만들어야 합니다. 따라서 앞으로 창맵씨를 사용하기까지 참으로 긴 여정이 여러분을 기다리고 있을 것입니다. 1.5.8. 자원 탐색기 ------------------ Tools > Resource Browser를 선택하면 자원 탐색기를 열 수 있습니다. 앞서 창맵씨를 설명하면서 '연모통'에 대해서 이야기한 적이 있습니다. 연모통은 창을 만들 때 쓸 수 있는 여러 가지 부품 자원들이 들어있다고 했는데, 자원 탐색기는 이러한 자원을 관리하는 일을 합니다. 새로운 자원을 만들거나 이 미 있는 자원의 이름을 바꾸기도 하고, 자원이 연결된 갈래의 상태를 바꾸기 도 합니다. 창맵씨와 더불어 자원 탐색기도 사용자 접속 환경을 만드는데 매 우 중요한 역할을 수행하고 있습니다. 1.5.9. 발자취 창과 벌래잡개 --------------------------- 사람은 누구나 실수를 하기마련입니다. 저도 그렇고 여러분도 그럴 겁니다. Smalltalk에게 명령을 내릴 때에도 여러분이나 저나 실수를 할 때가 있습니 다. "발자취 창"(walkback window)은 Smalltalk 프로그램이 실행되는 상태에 서 어떤 중대한 문제가 발생했을 때, 지금까지 어떤 길수들이 어떻게 실행되 어왔는지의 자취를 표시하고, 사용자가 알맞은 조치를 취할 수 있도록 돕는 창입니다. 아래의 명령을 글쇠로 실행시켜 봅시다. 5 hello ☞ "발자취 창 열림" 위 명령을 실행하자마자 "SmallInteger does not understand #hello"라는 제 목이 붙은 발자취 창이 표시될 것입니다. 이 내용인즉슨 "SmallInteger는 hello라는 지시를 알아듣지 못했다"는 것입니다. 즉 "5 hello"라는 명령을 Smalltalk가(정확히는 숫자 '5'가) 알아듣지 못했다는 말입니다. 그리고 아래에 나타난 작은 상자 안에 여태까지 명령을 실행한 발자취를 표 시합니다. --------------------------------------- SmallInteger(Object)>>doesNotUnderstand: UndefinedObject>>{unbound}doIt CompiledExpression>>value: SmalltalkWorkspace>>evaluateRange:ifFail: SmalltalkWorkspace>>evaluateItIfFail: SmalltalkWorkspace>>evaluateIt ....(하략) --------------------------------------- 여러분 대부분이 아직 위의 내용이 무엇을 의미하는지 정확하게 이해하지 못 했을 것입니다. 그러나 Smalltalk에 익숙한 사람들은 위의 정보를 보고, 대 체 어떤 경로를 따라서 명령이 실행되었으며 어디서 문제가 발생헀는지를 추 측할 수 있게 됩니다. 물론 대부분의 경우는 발자취 창의 제목만 보고서도 문제의 원인을 파악할 수 있습니다. 지금과 같은 경우에는 우리가 내린 명령 을 알아듣지 못했다는 것이 문제이겠지요. 이 발자취 창의 아래쪽에 네 개의 단추가 있습니다. 이 중에서 은 문제를 무시하고 계속 프로그램을 실행시킬 때 쓰고, 는 지금 실 행시킨 명령 실행을 끝내라는 것이고, 마지막으로 은 현재 실행되고 있는 명령에 대한 정보를 깡그리 지워버리고 명령 실행을 중단할 때 사용합 니다. 여기서 단추를 누르면 "벌레잡개"(debugger) 창이 나옵니다. 이 창 은 여러 개의 명령을 하나씩 하나씩 실행하면서 명령을 실행할 때 마다 바뀌 는 여러 객체의 상태를 관찰하면서 문제의 원인을 탐색할 때 사용하는 도구 입니다. 쉽게 말해서, 탐정들이 사건이 일어난 것을 되짚으면서 원인을 찾는 것과 비슷하다고 하겠습니다. 벌레잡개 창은 그 구조와 동작이 매우 복잡하 게 이루어져 있어서, Smalltalk에서 명령이 어떤 방식으로 실행되는지를 알 아야만 제대로 활용할 수 있는 도구입니다. 그러므로 지금은 단순히 벌레잡 개가 이런 것이구나 정도로만 이해해 두면 될 것입니다. 나중에 벌레잡개를 어떻게, 언제, 왜 사용해야 하는지에 대해서 자세하게 이야기할 기회가 있을 것입니다. ---<잠깐!>---------------------------------------------------------- 다른 Smalltalk에서는... 기본적으로 모든 Smalltalk 환경은 알림판과 일터, 갈래씨줄 탐색기, 객체 탐색기, 발자취 창, 벌레잡개를 가지고 있습니다. 그리고 여기에 더해서 각 각의 Smalltalk마다 조금씩 다른 기능을 가지는 창이 추가되어 있습니다. Dolphin의 경우 꾸러미 탐색기나 창맵씨, 자원 탐색기가 있으며, Smalltalk Express라는 Smalltalk 환경에서는 Disk Browser가 있다고 합니다. ---------------------------------------------------------- ---<잠깐!>---------------------------------------------------------- Windows와 같이 그림 위주의 사용자 환경(GUI)에서는 마우스가 필수적인 입 력장치로 생각되고 있습니다. 물론 이것은 맞는 말입니다. 그러나 마우스가 언제나 편한 것만은 아닙니다. 어떤 때는 글쇠판이 마우스보다 편할 경우가 있으니까요. Smalltalk로 작업을 하다보면 여러 개의 창이 열려있고 각각의 창을 왔다갔 다해야 하는 일이 잦습니다. 이럴 때 일일이 작업 표시줄에 있는 창 제목을 눌러서 이동하는 것보다는 이나 글쇠를 눌러서 이 동하는 것이 훨씬 편합니다. 글쇠를 누른 상태에서 글쇠를 눌러 보십시오. 그리고 글쇠에서 손을 떼어 보십시오. 그러면 화면 가운데 작은 창이 뜨고, 현재 열려 있는 창들이 표시될 것입니다. 은 오른 쪽으로 이동하고, 은 왼쪽으로 이동합니다. 이는 Windows 3.1 때부터 있던 '작업 전환'기능인데, 특히 Smalltalk처럼 많은 창을 가지 고 작업해야 할 때 편리하게 사용할 수 있을 것입니다. ---------------------------------------------------------- ========================================================== 지금까지 우리는 Smalltalk란 대체 어떤 언어이고, 어떻게 동작하며, 또한 Smalltalk 환경을 어떻게 설치하고 유지하는지에 대해서 알아보았습니다. 그 리고 Smalltalk 환경이 어떻게 생겼는지도 둘러보았습니다. 이 과정에서 우 리는 몇 가지 짧지만 Smalltalk의 특징이 잘 드러난 몇 개의 명령들을 실행 해 봄으로써, Smalltalk 환경에 친해질 수 있도록 했습니다. 이제 여기까지 온 여러분은 Smalltalk 환경에 대해서 어느 정도 익숙해 있어 야 합니다. Smalltalk를 시작하고 끝내고, 명령을 내리는 일 등은 Smalltalk 를 공부하면서 가장 기본적으로 알고있어야 할 사항들이기 때문입니다. 이제 이런 것들을 바탕으로 다음 가름[章]에서부터는 Smalltalk 언어와 객체지향 에 대해서 본격적으로 알아보도록 하겠습니다. 계속... 제 목:[강좌] Smalltalk 배우기 #5 관련자료:없음 [12] 보낸이:김찬홍 (안드래아) 1998-11-30 11:15 조회:215 Smalltalk 배우기 #5 1998. 11. 30. 김찬홍 mailto:andrea92@hitel.net ====================================== 2. 객체들과 나누는 이야기 → 2.1. 객체? ...... ======================================= 2. 객체들과 나누는 이야기 ------------------------------------ 앞 가름[章]에서 우리는 Smalltalk 환경에 대한 아주 기본적인 것을 알아보 았습니다. Smalltalk 환경을 설치하고 유지하는 방법에서부터, Smalltalk에 서 명령을 실행시키는 방법, 그리고 Smalltalk 프로그램이 도대체 어떤 모양 을 하고 있으며 이것을 어떤 방법으로 실행시키는지에 대해서 우리는 개괄적 으로 살펴본 셈입니다. 또한 Smalltalk에는 대략 어떤 종류의 창들이 있으 며, 이 창이 각각 무엇을 하는지에 대해서도 살펴보았습니다. 이제 이번 가름에서부터 지금까지 우리들이 공부한 기본적인 것들을 바탕으 로 본격적인 Smalltalk 공부에 들어가게 될 것입니다. 우선 객체란 무엇인지 에 대해서 살펴보고, 이어서 Smalltalk에 이미 있는 여러 가지의 객체에 대 해서 살펴볼 것입니다. Smalltalk에 이미 존재하는 객체들에는 어떤 것들이 있으며 그들은 어떻게 생겼고, 또한 그것들이 하는 일이 무엇이며, 또한 우 리는 그 객체들을 가지고 무엇을 할 수 있는지에 대해서 알아볼 것입니다. 이 가름을 마칠 때쯤이면 여러분은 Smalltalk에서 객체를 다루는 아주 기본 적인 방법에 대해서 익숙해져 있을 것입니다. 2.1. 객체? ---------- 흔히 Smalltalk를 일러 "객체 지향 프로그래밍 언어"(OOPL: Object Oriented Programming Language)라고 부릅니다. 이 글을 읽는 여러분들 중에는 꼭 프 로그래밍을 공부하지 않더라고 컴퓨터를 사용하면서 "객체 지향"이란 말은 한 번쯤 들어본 분들이 많을 거라고 생각됩니다. 솔직히 요즘 많이 쓰이는 "멀티미디어"(multimedia)란 낱말이 유행(?)하기 이전에는 "객체 지향"이란 낱말이 유행했었습니다. "객체 지향 데이터베이스", "객체 지향 운영 체계", "객체지향 분석 및 설계", "객체지향 소프트웨어 공학", "객체지향 동호회" 등등... 요즘은 그 유행의 거품이 거두어지고 슬슬 객체지향의 본연의 모습 을 연구하려는 분위기로 가고 있는 것 같습니다. 어쨌든 Smalltalk가 객체 지향 프로그래밍 언어라면, 도대체 "객체지향이란 무엇인가"에 대해서 한 번쯤은 생각을 해 봐야 할 것입니다. 그리고 객체지 향이런 무엇인가를 생각하려면 먼저 '객체란 무엇인가'라는 근본적인 물음에 대해서 어느 정도의 가닥을 잡고 있어야 할 필요가 있습니다. 일단 객체지향 이라는 것도 알고 보면, 모든 것을 객체 위주로 생각하는 것이기 때문에, 객 체가 무엇이며 그것이 어떤 성질을 가지고 있는지, 또 객체는 어떻게 다루면 되는 것인지에 대한 것을 실제로 부딪히면서 채득하는 것이 좀 더 쉬운 접근 방법이라고 생각됩니다. 자전거를 배우려면 직접 타봐야 하듯이 말입니다. 이제 그러한 마음가짐으로 이제부터는 객체가 무엇인지부터 하나씩 짚어보도 록 하겠습니다. '객체 지향 프로그래밍'이 컴퓨터에서 이루어진다고 해서, '객체'라는 개념 자체가 컴퓨터에만 한정되어 있는 것은 결코 아닙니다. 오히려 객체는 평범 한 우리의 일상 생활에서 그 개념을 잡아야 합니다. 왜냐하면 객체지향이라 는 생각 자체가 우리가 살고 있는 세상에서 일어나는 문제를 컴퓨터로 해결 하기 위해서 대두되었기 때문입니다. 따라서 지금부터는 프로그래밍에 대한 생각을 머리에서 잠시 몰아 내고, 편 안한 마음으로 글을 읽어 나가십시오. 여러분은 지금 제가 쓴 글을 보고 있습니다. 무엇을 통해 보고 계십니까? 대 부분 모니터를 통해 보실 것입니다. 가끔씩 이 글의 다음 쪽을 보기 위해서 여러분은 무엇을 합니까? 대부분 글 쇠판이나 마우스를 누를 것입니다. 글쇠판과 마우스는 무슨 일을 할까요? 여러분의 생각을 컴퓨터로 전하는 일 을 합니다. 모니터는 어떻습니까? 끊임없이 여러분에게 글과 그림을 뿌려 데고 있습니 다. 컴퓨터가 만들어 놓은 결과를 여러분에게 전달하기 위해서일 것입니다. 여러분은 자동판매기를 이용해 본 적이 있습니까? 그럼 자동판매기에서 어떻 게 원하는 음료수를 뽑아 내는지를 가만히 기억해 보십시오. 우선 동전을 필요한 만큼 넣습니다. 그런 다음 원하는 음료수(저는 '커피')의 이름이 적힌 단추를 누릅니다. 그러면? 음료수('커피'?)가 나옵니다. 여러분은 문을 열고 음료수를 꺼낸 다음 마시면 됩니다. 여러분은 개를 기르고 있습니까? 개의 종(種)은 무엇입니까? 털 색깔은 어떻 지요? 몸무게는 어떻게 될까요? 뭐, 제가 이런 것들을 알 필요는 없겠지만, 여하튼 개는 개 나름으로의 특성을 가지고 있습니다. 같은 개라 하더라도... 여러분이 길다란 막대기 하나를 던져 주고 "주워 와!"하면 개는 그 지시를 받아서 행동합니다. 개가 똑똑하면 여러분의 지시를 제대로 수행할 것이고, 그렇지 않으면 엉뚱한 일을 수행할 것입니다. 훈련하기에 달린 거죠. :) 아프면 여러분은 병원에 갑니다. 병원에 가서 여러분은 의사에게 병을 고쳐 줄 것을 부탁합니다. 그러면 의사는 여러분의 상태를 파악하고 진찰한 후 적 절한 처방을 써서 여러분의 병을 고쳐 줍니다. 여러분이 병원에 갈 때 '인체 해부학'이나 '생리학'과 같은 의학을 알 필요 가 있었습니까? 그저 여러분은 의사에게 가서 진찰을 부탁했을 뿐입니다. 그 것으로 족합니다. 여러분이 만일 의사가 되고 싶으면 의학 공부를 하면 됩니 다. 허나 모든 사람이 아플 때마다 의사가 될 수는 없지않겠습니까? 내가 필 요하면 병원에 가서 의사에게 진찰을 부탁하면 되는 것입니다. 객체(object)를 가장 간단한 낱말로 표현한다면 '물건'이 될 것입니다. 넓은 의미에서 살아 있는 생물도 물건에 속합니다. 생물(生物)을 한자로 풀어쓰면 "살아 있는 물건"이란 뜻을 가지고 있습니다. 지금까지 제가 앞에서 예로 든 모든 것이 객체입니다. 모니터, 글쇠판, 마우스, 자동판매기, 음료수, 동전, 문, 좀 더 생각을 넓혀 서 살아 있는 개, 심지어는 '의사'와 같은 사람까지도, 이 모든 것이 '객체' 입니다. 물건은 어느 하나 쓸모가 없는 곳이 없습니다. 모든 것은 자기 나름의 역할 을 가지고 존재합니다. 심지어 필요 없다고 생각되는 쓰레기들도 모두 자신 의 소명을 다하고 있습니다. 다시 말하면, 모든 객체는 자신의 역할을 가지고 있다고 볼 수 있습니다. 객 체가 자신의 역할을 충실히 수행함으로써 세상이 제대로 돌아가고 있는 것입 니다. 이 세상은 참으로 많은 객체로 가득 차있는데, 각각의 객체들이 저마 다 자신의 역할을 충실히 수행해 나간다고 생각해 봅시다. 일사불란하게 움 직이는 자연을 보면, 경이롭기까지 합니다. 요컨대, 객체는 저마다의 역할을 가지고 있습니다. 객체가 어떤 역할을 수행하기 위해서는, 누군가가 그 객체에게 무언가의 __ 지시를 내려 주어야__ 합니다. 글쇠판이 컴퓨터에게 정보를 입력하기 위해서 는 누군가가 글쇠판을 __눌러 주어야__ 합니다. 즉 손으로 글쇠판에게 "누른 다"라는 지시를 내리는 것입니다. 모니터는 컴퓨터의 중앙처리장치(CPU)의 지시를 받아 움직이는 그림판 (graphic card)의 지시로 화면에 여러 가지 정보를 뿌립니다. 자동판매기는 말할 것도 없습니다. 우리가 동전을 넣고 음료수를 마시겠다고 지시하는 것입니다. 그 결과 자동판매기는 음료수를 내놓는 것이지요. 개는 우리의 말을 어느 정도는 알아듣습니다. 우리의 말을 알아들을 수 없는 객체에게 우리는 물리력(物理力)으로 지시를 내립니다. 그러나 말을 알아들 을 수 있는 객체에게, 우리는 '언어'를 통해 지시를 내립니다. 병원의 의사는 말할 것도 없습니다. 같은 사람의 입장에서 '지시를 내린다' 는 표현을 쓰기가 좋지 않으므로, '치료를 부탁한다'라고 말만 바꾼 것뿐이 지, 실재로는 우리가 '의사'라는 __객체에게__ "치료해 달라"고 지시하는 것 과 다를 바가 없습니다. 이와 같이 모든 객체는 지시에 의해 움직입니다. 다시 말하면, 우리가 어떤 객체를 사용하기 위해서는, 반드시 그 객체에게 지시를 내려 주어야만 한다 는 것입니다. 객체는 지시를 받음으로써 어떤 일을 합니다. 객체에는 저마다의 특성이 있습니다. 개의 특성은 "다리가 네 개, 눈이 두 개, 입은 하나..." 등과 같이 열거할 수 있고, 마우스의 특성은 "손에 꼭 맞 도록 설계되어 있고, 두 개 또는 세 개의 단추가 있다"쯤으로 말할 수 있을 것입니다. 객체의 역할은 그 객체가 가지고 있는 특성에 따라 좌우됩니다. '개'와 '의 사'는 같은 생물이라 하더라도 가지고 있는 특성이 서로 다르기 때문에 자기 들만의 역할이 있는 것입니다. 만일 의사와 개가 완전히 똑같은 특성을 가지 고 있다면, 우리는 개에게 병을 치료하라고 지시할 수 있을 것인데, 두 객체 의 특성이 다르기 때문에 감히 개에게 "병 고쳐 달라"는 사람이 없지 않습니 까? :) 따라서 모든 객체는 자신들만의 특성이 있고, 이 특성이 결국 객체의 역할을 규정지어 줍니다. 그런데 여러 개의 객체를 다루다 보면 사로 비슷한 특성을 가진 객체들을 발 견할 수 있습니다. 예를 들어 '글쇠판'과 '마우스'는 "우리의 생각을 컴퓨터 에게 입력시킬 수 있는 특성"을 가지고 있습니다. 또한 '진돗개'나 '푸들'은 서로 다른 특성을 가지고 있는 객체이지만, '개'만이 가지고 있는 공통적인 특성을 가지고 있습니다. 이와 같이 서로 비슷한 특성을 가지고 있는 객체들은 따로 묶어서 갈래 (class)를 지을 수 있습니다. '갈래를 짓는다'는 말은 종류별로 나눌 수 있 다는 말입니다. '마우스'와 '글쇠판'은 "입력 장치"라는 갈래로, '진돗개'와 '푸들'은 "개" 라는 갈래로, 다시 '개'와 '사람'은 "생물"로 갈래를 지을 수 있습니다. 그 리고 '입력 장치', '개', '사람', '생물'은 모두 '물건' 이라는 갈래에 속하 게 됩니다. 요컨대, 모든 객체는 저마다 자신이 속해 있는 갈래(class)가 있습니다. 좀 지루했습니까? 하지만 위의 글들이 흔히 말하는 '객체'의 특성을 대부분 설명해 주고 있습니다. 객체가 가지고 있는 몇 가지 성질들을 정리해 두겠습 니다. 모두 지금까지 읽으신 글과 연결되어 있으니 곰곰이 생각해 보시기 바 랍니다. - 객체는 저마다 맡은 역할이 있다. - 객체는 지시를 받음으로써 자신의 역할을 수행한다. - 객체는 나름으로의 특성을 가지고 있다. → 이 특성이 객체의 역할을 규정짓는다. - 비슷한 특성을 가진 객체들을 모아 '갈래'를 지을 수 있다. → 모든 객체는 저마다 자신이 속한 갈래가 있다. 조금 정리가 되셨습니까? 아직도 좀 애매하다고 생각하실 지 모르겠습니다. 그렇다고 이것을 모두 외우려고 하지는 마십시오. 중요한 것은 위의 사실들 을 무조건 외우는 것이 아니라, 몸으로 느끼는 것입니다. 이제 바로 다음 마디[節]에서 우리는 지금까지 공부한 객체에 대한 여러 가 지 특성이 Smalltalk의 객체에도 적용되는지를 실제로 명령을 내려봄으로써 몸으로 느껴보게 될 것입니다. 계속... 제 목:[강좌] Smalltalk 배우기 #6 관련자료:없음 [13] 보낸이:김찬홍 (안드래아) 1998-12-01 11:10 조회:213 Smalltalk 배우기 #6 1998. 11. 30. 김찬홍 mailto:andrea92@hitel.net ====================================== 2. 객체들과 나누는 이야기 →2.1. 객체? 2.2. 몸으로 느끼기 2.2.1. 글토막 가늠하기 ...... ======================================= 2. 객체들과 나누는 이야기 ------------------------------------ 2.2. 몸으로 느끼기 ~~~~~~~~~~~~~~~~~~ 앞의 마디에서 우리는 객체가 무엇인지에 대해서 대강의 가닥을 잡아보았습 니다. 저는 여기서 한 개의 보기도 들지 않았습니다. 어땠습니까? 구름을 잡 는 것과 같지 않았습니까? 이렇게 백 마디의 말보다는 한 마디의 실행이 진 가를 발휘할 때가 있는 법입니다. 우리들이 전에 모르던 사실을 알고자 할 때 추상적인 개념 설명보다는 이 개 념이 실제로 적용되는 과정을 몸으로 느낄 때, 그것이 머리 속으로 생각한 개념적인 것들보다 훨씬 오래 간다는 것을 알 수 있습니다. 이제 이 마디에서는 Smalltalk의 객체에 대해 여러 가지 명령을 실행시켜보 고 그럼으로써 객체와 객체지향에 대한 개념을 몸으로 익혀보도록 합니다. ---<잠깐!>----------------------------------------------------------- 새 술은 새 부대에... 옛 속담에 "새 술은 새 부대에 담아라"는 말이 있습니다. 이 말이 Smalltalk 를 공부할 때에도 적용됩니다. Smalltalk에서 명령을 실행시키기 위해서는 기본적으로 일터(workspace)가 필요합니다. 그래서 여러분이 새로운 가름이나 마디, 그리고 새로운 나눔을 시작할 때에 는 일터를 새로 열어서 작업을 하면 좋다는 것입니다. 그러면 나중에 여러분 이 작업한 것을 저장하기도 편하고, 여러분이 실행했던 명령어들을 그대로 나누어서 볼 수 있기 때문에 매우 도움이 될 것입니다. 새로운 가름[章, 마디[節], 나눔[部]이 시작될 때에는 항상 새 일터에서 시 작하도록 합시다. ----------------------------------------------------------- 2.2.1. 글토막 가늠하기 ---------------------- 앞의 "1.3"마디에서, 우리는 Smalltalk로 작성된 여러 가지의 간단한 명령을 실행시켜보았습니다. Smalltalk의 명령을 실행할 때, 몇 가지의 방법이 있었 습니까? 기억나십니까? 네, 실행할 명령을 입력하고 덩이(block)를 씌운 후 , , 또 는 중 하나의 글쇠를 눌러서 명령을 실행시켰습니다. 실제로 Smalltalk에서 명령을 실행하는 기본적인 방식은 방금 이야기한 세 가지가 있습니다. 그리고 각각의 쓰임새가 저마다 다릅니다. 이제 이 나눔 [部]에서는 Smalltalk에서의 이러한 명령 실행에 대한 몇 가지 개념을 짚고 넘어가겠습니다. 몸으로 느끼기 위해서는 어떻게 느껴야 하는지를 알 필요가 있지 않겠습니까? 전통적으로 Smalltalk에서는 "명령을 실행한다"(execute the command)라는 말을 쓰지 않습니다. 대신 "글토막을 가늠한다"(evaluate the expression)라 는 말을 사용합니다. 여기서 '글토막'이란 "Smalltalk 명령들로 이루어진 글 의 조각"(the pieces of Smalltalk's code)라는 말입니다. 왜 Smalltalk에서 이러한 말을 쓰는지는 모르겠지만, 필자도 앞으로 Smalltalk의 관례를 따라 글을 쓰도록 하겠습니다. "로마에서는 로마법을!"이라는 말이 있듯이... 여하튼, Smalltalk에서 글토막을 가늠하는데는 아래와 같은 세 가지의 다른 방식이 있습니다. ========================================================== * 가늠하기(Evaluating): 말 그대로 "Smalltalk 명령을 실행한다"는 뜻입니 다. 글토막을 가늠하면, 글토막에 쓰여진 Smalltalk 명령이 실행됩니다. 명 령을 실행한 뒤에 나오는 결과는 무시해버립니다. 명령의 결과보다는 실행하 는 것 자체가 중요할 때 사용하는 방식입니다. Workspace > Evaluate It 메뉴를 사용하거나 글쇠를 사용합니다. * 펴기(displaying): 글토막을 가늠하고, 가늠한 결과를 현재 일터에 덩이를 씌워 나타냅니다. 주로 명령을 실행한 뒤에 내놓는 결과가 중요할 때 사용합 니다. 계산식 등을 가늠할 때 주로 사용되겠지요. Workspace > Display It 메뉴를 사용하거나 글쇠를 사용합니다. * 탐색하기(inspecting): 글토막을 가늠한 뒤에 생기는 결과값을 "객체 탐색 기"(object inspector)를 통해서 보여줍니다. 명령을 실행한 후 내놓는 결과 값이 매우 복잡한 구조를 하고 있을 때, 이를 좀 더 잘게 쪼개어 값을 관찰 하고싶을 때 사용합니다. Workspace > Inspect It 메뉴를 사용하거나 글쇠를 사용합니다. ========================================================== 그럼 이제부터 보기를 통해 글토막을 가늠하는 방법들의 쓰임새를 알아보도 록 하겠습니다.("1.3"마디를 주의 깊게 읽은 사람이라면 매우 쉽게 이해할 수 있을 것입니다.) 우선 다음의 글토막이 있습니다. 1 + 2. 보통 Smalltalk의 글토막을 가늠하기 위해서는 먼저 가늠할 글토막에 덩이를 씌워서 선택해야 합니다. 그런 다음 글토막을 가늠하도록 되어있습니다. 그런데 Dolphin Smalltalk에서는 한 가지 편리한 기능을 제공합니다. 그것은 바로 "한 줄 가늠" 기능입니다. 위의 글토막과 같이 한 줄로 이루어진 글토 막은 덩이를 씌울 필요 없이 바로 가늠할 수 있다는 것입니다. ---<잠깐!>----------------------------------------------------------- Dolphin Smalltalk가 아닌 다른 Smalltalk에서는 기본적으로 한 줄 가늠 기 능을 제공하지 않습니다. Dolphin Smalltalk와 Smalltalk MT의 경우에만 한 줄 가늠 기능이 지원되는 것 같습니다. ----------------------------------------------------------- 자, 그럼 위의 글토막을 가늠해봅시다. Workspace > Evaluate It 메뉴를 고 르던지, 글쇠판의 글쇠를 이용해서 위의 글토막을 가늠해 봅시다. 1 + 2. ☞ "아무 결과도 안 나타남" 아무런 결과도 나타나지 않았습니다. 여기서 우리는 위의 글토막을 가늠하기 나만 했지, 그 내용을 펴지는 않았습니다. 그러므로 이와 같은 결과가 나타 난 것은 당연한 것이지요. 이제 그럼 방금 가늠했던 글토막을 펴 봅시다. Workspace > Display It 메뉴 를 사용하던가, 글쇠판에서 글쇠를 누르면 됩니다. 어떻게 되었습 니까? 1 + 2. ☞ 3 "3"이라는 결과값이 덩이를 쓴 체 나타났습니다. 이와 같이 '펴기'는 글토막 의 내용을 가늠한 후 그 결과로 남는 값을 화면에 뿌려줍니다. 이 경우에는 덩이를 쓴 "3"이라는 값이 바로 결과값인 것입니다. 마지막으로 이 글토막을 탐색해 봅시다. Workspace > Inspect it 메뉴를 사 용하던가, 글쇠를 사용하여 글토막을 탐색해 봅시다. 어떻게 되었습 니까? 1 + 2. ☞ "탐색기 나타남" 위의 글토막을 탐색하면 "Inspecting a SmallInteger"라는 제목을 가진 탐색 기가 나타날 것입니다. 왼쪽 창에는 "self"가, 오른쪽 창에는 "3"이 나타나 있을 것인데, 이것은 지금 우리는 "3"이라는 결과값을 탐색하고 있다는 의미 입니다. 그러면 "1 + 2."의 경우는 가늠하기, 펴기, 탐색하기 중 어떤 방법이 가장 적당하겠습니까? 네, 이번 경우에는 펴기가 제일 적당합니다. 가늠하기의 경 우는 아예 값이 나타나지를 않았기 때문에 사용할 수 없고, 탐색하기의 경우 에는 "3"이라는 결과값을 얻기 위하여 탐색기를 쓰는 것이 되는 것이므로, 결국은 결과값을 덩이에 씌워 일터에 뿌려주는 펴기가 알맞은 방법이 되는 것입니다. 이제 다음의 글토막을 가늠하고, 펴고, 그리고 탐색하여 보십시오. 그리고 셋 중 어떤 것이 가장 적합한 방법인지를 생각해 봅시다. Sound beep. ☞ Sound 위의 글토막은 컴퓨터의 스피커에서 '삑!'하는 신호음을 발생시킵니다. 소리 를 제대로 들으려면 컴퓨터의 소리 카드와 스피커가 제대로 설정되어있는지 를 확인하십시오. 이번 글토막은 가늠하기, 펴기, 탐색하기 중에 어떤 것이 적당하겠습니까? 자, 우리가 지금 무엇을 하려고 하는지 생각해 봅시다. 우리는 신호음을 듣 고싶었습니다. 다른 것은 필요치 않았습니다. 가늠하기의 경우에는 신호음만을 출력하고 다른 반응은 일어나지 않았습니 다. 일단 현재까지는 가장 알맞은 방법인 것 같습니다. 펴기의 경우는 어떠했습니까? 신호음이 들리기는 했지만 "Sound"라는 결과값 을 덩이에 씌워 일터에 폈습니다. Sound? 소리? 이 글토막이 펴졌을 때 분명 히 소리가 났습니다. 그렇다고 화면에도 "Sound"라는 글자가 표시될 필요까 지는 없었습니다. 탐색하기의 경우는 더욱 더 가관입니다. 앞서 탐색하기의 용도에서, "복잡한 값을 간단하게 여러 부분으로 쪼개어 관찰할 때 필요한 도구"라고 했습니다. 그런데 여기서는 어떻습니까? "Sound"라고 하는 결과값을 탐색해보니 오히려 무언지도 알 수 없는 복잡한 값들이 나타났습니다. Oh, my God! 물론 신호음 이 들리기는 헀지만 필요 이상의 정보가 너무 많습니다. 결국 위의 글토막은 그냥 가늠하기만 사용하는 것이 제일 좋은 해결책이었습 니다. 마지막으로 다음의 글토막을 가늠하고, 펴보고, 그리고 탐색해봅시다. 아래 의 글토막은 현재 Smalltalk 환경에 존재하는 모든 갈래(class)들을 가나다 순으로 정렬하여 가름모듬(sorted collection)에 담아내는 일을 합니다. Class allClasses asSortedCollection 일단 위의 경우 단지 글토막을 가늠하기만 하면 아무런 변화도 일어나지 않 게 됩니다. 그러므로 지금처럼 결과값을 알아보아야 할 상황에서는 가늠하기 는 적절하지 못합니다. 그럼 이번에는 위의 글토막을 펴 봅시다. "1.3" 마디에서 나타난 것처럼, 일 터에 결과들이 모두 다 출력된 것은 아닐 것입니다. 이것은 일터에 표시하기 에는 내용이 너무 많기 때문에 발생한 결과로, 결과값의 끝에 "...etc..."라 는 표시가 붙어있으며, 이는 결과들이 일터에 모두 다 표시되지 못했음을 알 려줍니다. 따라서 글토막을 펴 보는 것만으로는 결과를 보기 어려웠습니다. 이제 위의 글토막을 탐색해봅시다. 그러면 "Inspecting a SortedCollection" 이라는 제목이 붙은 탐색기가 열릴 것입니다. 이 탐색기를 이용하면 앞서 글 토막을 폈을 때보다 훨씬 편리하게 내용을 볼 수 있습니다. 이렇게 같은 글토막이라도 어떤 방식으로 결과값을 보느냐에 따라서 가늠하 기, 펴기, 탐색하기의 유용성이 달라집니다. 앞으로 우리는 수많은 Smalltalk의 글토막을 가늠해 볼 것입니다. 그럴 때마 다 여러분은 이 글토막을 어떤 방식으로 가늠할지를 고민하게 될 텐데, 앞으 로 셋째 가름이 끝날 때쯤이면 이제는 생각하지 않고서도 무의식적으로 적당 하게 글토막을 가늠하는 법을 익히게 될 것입니다. 그리고 보통때의 경우 '글토막을 가늠한다'는 말속에는 "글토막을 상황에 따 라 적절하게 가늠하거나 펴거나 탐색한다"는 뜻이 포함되어있다는 것도 참고 로 알아두시기 바랍니다. ---<잠깐!>----------------------------------------------------------- 다른 Smalltalk에서는...? Dolphin Smalltalk가 아닌 다른 Smalltalk에서도 결과적으로 글토막을 가늠 하는 방식에는 "가늠하기", "펴기", "탐색하기"의 세 가지 방식을 취합니다. 그러나 각각을 실행하는 방법이 조금 다를 수 있습니다. 이를테면, Smalltalk Express나 Smalltalk/V의 경우에, "가늠하기"를 'DO It', "펴기" 를 'Show It', "탐색하기"를 'Inspect It'이라고 부릅니다. 그리고 가늠할 때 쓰는 단축 글쇠 역시 , , 를 사용합니다. 그러나 기본적인 개념을 확실히 알고 있으면, Dolphin Smalltalk가 아닌 다 른 환경을 접했을 때에도 당황하지 않게 될 것입니다. 중요한 것은 기초가 튼튼해야 한다는 말입니다. ----------------------------------------------------------- 계속... 제 목:[강좌] Smalltalk 배우기 #7 관련자료:없음 [14] 보낸이:김찬홍 (안드래아) 1998-12-01 20:01 조회:208 Smalltalk 배우기 #6 1998. 12. 1. 김찬홍 mailto:andrea92@hitel.net ====================================== 2. 객체들과 나누는 이야기 2.1. 객체? 2.2. 몸으로 느끼기 2.2.1. 글토막 가늠하기 →2.2.2. 셈! 셈! 셈! ...... ======================================= 2. 객체들과 나누는 이야기 ------------------------------------ 2.2. 몸으로 느끼기 ~~~~~~~~~~~~~~~~~~ 2.2.2. 셈! 셈! 셈! ------------------ 컴퓨터가 처음 만들어진 목적은 "계산을 하기 위함"이었습니다. 한참 세계대 전의 열기가 고조되고 있을 때, 어떻게 하면 목표물을 정확히 겨냥하여 대포 알을 맞출 수 있을까라는 문제를 풀기 위하여 컴퓨터가 개발되었던 것이지 요. 따라서 컴퓨터가 할 수 있는 일 중에 가장 기본외 되면서도 중요한 일은 셈을 하는 것, 즉 "계산"인 것입니다. 이제 우리는 Smalltalk에서는 이러한 중요한 계산 기능이 어떻게 이루어지는지에 대해서 알아보도록 하겠습니다. 여러분은 이제 "1 + 2"라는 식을 계산하여 "3"이라는 결과값을 얻어내는 데 는 자신이 있을 것입니다. 식당 개 삼 년이면 라면을 끓인다는 말이 있듯이 말입니다. ^^: 그런데 우리가 여태껏 가늠해 온 글토막의 모양을 조금 바꾸 어서 가늠해 봅시다. 이를테면 " 1 + 2 . "과 같은 글토막을 Smalltalk는 어떻게 이해하고 가늠할까요? 백견이 불여일행이라, 한 번 위의 글토막을 펴볼까요? 1 + 2 . ☞ 3 어김없이 "3"이라는 결과값이 나왔습니다. 그럼 다음처럼 하면 어떨까요? 아래의 글토막은 세 줄로 되어있기 때문에, 글토막을 가늠하려면 세 줄에 덩 이(block)를 씌워야 한다는 것, 잊어버리지 않았겠지요? ----------------------------------------------------------- 1 + 2. ☞ 3 ----------------------------------------------------------- 어떻습니까? 역시 "3"이라는 결과값이 나타났습니다. 결국 글토막에 빈칸이 들어가거나 줄이 바뀌는 경우라도, 제대로 덩이를 씌 워서 가늠하기만 하면 아무런 문제없이 동작한다는 것을 알 수 있습니다. 그러나 숫자 중간에 빈칸을 집어넣거나, 숫자를 쓰다가 줄을 바꾸고 이어 쓰 는 경우에 Smalltalk는 이 숫자들을 하나의 수로 보는 것이 아니라 __두 개 의__ 수로 보기 때문에 문제가 생깁니다. 다음의 글토막을 펴 보십시오. ----------------------------------------------------------- 1234 5678 + 1. [실행 결과] "no period at end of statement 5678" 잘못 발생 ----------------------------------------------------------- 위의 글토막을 가늠하면 "실행 결과"에 적은 것과 같은 잘못 알림글을 받게 됩니다. 그리고 잘못이 있는 "5678" 부분에 덩이가 씌워집니다. 위의 잘못 알림글을 직역해보면 "5678 문장의 끝에 마침표가 없습니다"라는 뜻이 되는 데, 결국 여기서는 "12345678"이라는 수의 중간에 줄을 바꾸었기 때문에 일 어나는 잘못입니다. 따라서 글토막에 빈칸을 넣거나 줄을 바꿀 때에는 수의 중간에 넣어서는 안 되고, 수, 그리고 '+'와 같은 연산자(operator) 사이에서만 넣을 수 있다는 것을 알 수 있습니다. 지금까지 우리는 덧셈에 대해서 알아보았습니다. 이제부터 덧셈을 제외한 뺄 셈, 곱셈, 나눗셈을 Smalltalk에서 어떻게 수행하는지 알아봅시다. 아래의 글토막을 펴 보고 결과를 확인해 보십시오. 4 - 1. ☞ 3 "뺄셈" 2 * 2. ☞ 4 "곱셈" 6 / 2. ☞ 3 "나눗셈" "+"와 "-"는 수학에서 쓰는 기호를 그대로 사용합니다. 그러나 곱셈의 경우 는 "*"을, 나눗셈의 경우는 "/" 기호를 사용합니다. Smalltalk는 보통 우리들이 사용하는 계산기에는 없는 연산을 수행할 수 있 습니다. 다음의 글토막을 각각 펴 봅시다. 25 // 3. ☞ 8 "나눗셈의 몫" 25 \\ 3. ☞ 1 "나눗셈의 나머지" "//"는 나눗셈을 할 때의 몫을 구합니다. 반면 "\\"는 나눗셈에서 생긴 나머 지를 구할 때 사용합니다. 25 = (3 * 8) + 1 이므로, 위의 글토막들이 왜 "8"과 "1"의 결과를 남겼는지 알 수 있겠지요? 지금까지 우리는 Smalltalk에서 간단한 사칙 연산(덧셈, 뺄셈, 곱셈, 나눗 셈)을 해 보았습니다. 이제 조금 더 복잡한 식을 계산해 봅시다. 아래의 글토막을 각각 펴 보고 결과를 확인해 보십시오. 1 + 1 + 1. ☞ 3 2 * 2 * 2. ☞ 8 5 - 1 - 1 - 1. ☞ 2 12 / 3 / 2. ☞ 2 세 개의 수와 두 개의 연산자를 가지고 있는 식도 Smalltalk는 매우 훌륭하 게 풀 수 있었습니다. 그러면 거꾸로, 이번에는 아주아주 간단한 글토막을 가늠해봅시다. 아주아주 간단하다? 그러면 숫자 하나로 이루어진 글토막을 생각할 수 있습니다. 1 ☞ 1 "1"도 작지만 엄연히 하나의 글토막입니다. "1"을 펴 보면 무엇이 나옵니까? "1"을 펴 봤지 "1" 밖에 더 나오겠습니까? :) 양수(陽數)를 펴 보면 양수가 그대로 나왔습니다. 그럼 음수(陰數)라면? -1 ☞ -1 말할 것도 없이 음수 "-1"을 펴면 똑같이 "-1"이 나타났습니다. (너무 멍청 한 글토막만 가늠하고 있었나요?) 그럼 이번에는 조금 덜 멍청한 글토막을 가늠해보죠. 4 - 6. ☞ -2 2 * -3. ☞ -6 보는 바와 같이, 음수를 결과값으로 남기거나 음수 자신이 계산에 사용되더 라도 Smalltalk는 매우 훌륭하게(!) 계산을 수행해 냅니다. 하긴, 200의 계 승(factorial)도 거뜬히 구할 수 있는 Smalltalk가 한낱 음수 따위에 두려워 하리요? :) 그럼 이제 슬슬 Smalltalk의 머리를 아프게 만들어 봅시다. 지금까지는 덧셈 이면 덧셈, 곱셉이면 곱셈만 했습니다만, 지금부터는 이러한 연산자들을 마 구, 마구 섞어서 계산해 봅시다. 도대체 Smalltalk는 어떤 반응을 보일까요? 자, 식을 계산하기 전에 우선 여러분이 한 번 생각해 보십시오. 아래 두 식 을 Smalltalk로 풀면 똑같은 답이 나올까~~~요? 1 + 2 * 3 2 * 3 + 1 대답은 "땡"! '아니오'올시다. 그런지 안 그런지 직접 위의 식을 글토막으로 만들어서 가늠해 보시지요. 1 + 2 * 3 ☞ 9 2 * 3 + 1 ☞ 7 어라? "1 + 2 * 3"이 "9"야? 음, 이건 뭔가 잘못됐어! Smalltalk의 머리가 이제 슬슬 돌기 시작했나봐! 으악! 자, 당황하는 여러분의 얼굴이 보이지만, 일단 진정하고, 이야기를 계속하기 전에 몇 가지 낱말에 대한 의미를 좀 명확하게 해 둘 필요가 있을 것 같습니 다. 들어보세요. 지금껏 제가 밥먹듯 써 온 "연산자"라는 말, 그게 무슨 뜻인가 하면, '+', '-', '*', '/', '\\', '//'처럼 어떤 연산, 즉 계산을 할 것인지를 나타내는 기호를 '연산자'(operator)라고 부릅니다. 그리고 이러한 계산에 사용되는 값을 '연산수'(operand), 또는 '피연산자'라고 부릅니다. 그러므로 "1 + 2"에서 '+'를 "연산자"라 하고, '1'을 "+의 왼쪽 연산수", '2'를 "+ 연산자의 오른쪽 연산수"라고 부르게 되어있습니다. "1 + 2 * 3"의 경우를 생각해 봅시다. 이 식에서 연산자는 '+'와 '*'로 쉽게 알 수 있는데, 그럼 연산수는 무엇일까요? 이걸 금방 알아내기란 어렵습니 다. 왜냐하면, '+'나 '*' 중에 어느 하나가 먼저 계산되고 난 다음에 비로소 연산수를 확실히 알 수 있기 때문입니다. 위에서 "1 + 2 * 3"을 Smalltalk에게 가늠하라고 했더니 엉뚱하게도 "9"라는 값이 튀어나왔습니다. Smalltalk가 틀린 걸까요? 물론 그렇게 생각할 수도 있지만, 다르게 생각하면 이것은 여러분의 착각일 수도 있습니다. '+'와 '*'라는 두 개의 연산수 중에 어느 것이 먼저 계산이 되느냐에 따라 "1 + 2 * 3"의 결과값이 달라집니다. * 만일 '+'가 먼저 계산된다면...? "1 + 2"가 먼저 계산되고 따라서 위의 식은 "3 * 3"이 되어서 결과적으로 "9"라는 결과값이 나오는 것은 당연한 일! 따라서 이 경우 '+'의 연산수는 "1"과 "2", '*'의 연산수는 "1 + 2"(즉 "3")! * 만일 '*'이 먼저 계산된다면...? "2 * 3"이 먼저 계산되고 따라서 위의 식은 "1 + 6"이 되어서 결과적으로 "7"이라는 결과값이 나오는 것은 역시 당연한 일! 따라서 이 경우 '+'의 연 산수는 "1"과 "2 * 3"(즉 "6"), '*'의 연산수는 "2"와 "3"! 이렇게 "1 + 2 * 3"이라는 식은 '+'를 먼저 계산하느냐 '*'을 먼저 계산하느 냐에 따라 결과값이 달라지게 됩니다. 헷갈리죠? 여러분은 '*'이 '+'보다 당연히 먼저 계산되어야 한다고 주장하겠지만, 앞서 말했듯이 그건 여러분의 착각! 분명히 Smalltalk는 '*' 보다 '+'를 먼저 계 산했다는 이야기! 그럼 Smalltalk가 틀리는가? 그렇지 않습니다. "로마에서는 로마법을!" 그러 므로 Smalltalk에서도 Smalltalk의 법을 지켜야겠죠? 분명히 산수시간에 우리는 '+'보다 '*'를 먼저 계산하라고 배웠습니다. 그러 나 Smalltalk는 '*'보다 '+'를 먼저 계산했습니다. 이러한 차이가 일어나는 까닭은, 바로 "연산의 우선 순위"(operator's precedence) 때문입니다. 산수에서는 여러 가지 연산자가 쓰이는데, 각각은 나름으로의 '우선 순위'를 가지고 있습니다. 이를테면 '+'과 '*'이 같이 있으면 '*'을 먼저 계산한다는 식으로 말입니다. Smalltalk에서는 연산자의 우선 순위가 기본적으로 존재하지 않습니다. 일단 저렇게 계산식이 주어지면 Smalltalk는 무조건 __왼쪽에서 오른쪽으로__ 계 산을 해 나갑니다. 즉, Smalltalk에서는 따로 연산자의 우선 순위를 정하지 않고, 왼쪽에서 시작해서 오른쪽 방향으로 연산수와 연산자들을 차례차례 계 산해 나간다는 말입니다. 그래서.... 1 + 2 * 3 → 3 * 3 ☞ 9 2 * 3 + 1 → 6 + 1 ☞ 7 이라는 값이 나오게 되는 것입니다. 억지라구요? 말도 안 된다고요? 여러분 의 머리뼛속깊이 파고든 "고정 관념"의 벽을 깨지 않으면, 여러분은 절대로 새로운 것을 배울 수 없습니다. Smalltalk가 그렇다는데 여러분이 어떻게 하 겠습니까? Smalltalk의 처리 방식이 마음에 안 들어서 Smalltalk를 포기하겠 습니까? 뭐, 결국 포기하신다면 어쩔 수 없겠지만,... Smalltalk는 적어도 계산식에 있어서 복잡한 것을 따지기 싫어합니다. 그냥 단순하게 앞에 나온 건 먼저 처리하고 그 다음에 나온 것을 처리한다, 그것입니다. 어렵습니까? ---<잠깐!>----------------------------------------------------------- 연산자의 우선 순위 연산자가 많기로 유명한 C와 C++ 언어는 모두 40개가 넘는 연산자를 가지고 있습니다. 이들은 분류에 따라 여러 갈래로 나눌 수 있는데, 각각은 저마다 연산의 우선 순위가 다르게 매겨져 있습니다. 또한 연산수를 취하는 방법도 왼쪽에서 오른쪽으로 취하는 방법도 있으며, 반대로 오른쪽에서 왼쪽으로 취 하는 방법도 있습니다. 이를 "결합성"이라고 부르는데, 여하튼 연산자들을 종류별로, 연산의 우선 순위별로, 결합성 별로 분류하게 되면 종이 한 장을 가득 채우는 표가 하나 만들어집니다. 에고~ 머리야! 다른 언어의 경우도 별반 다를 것이 없습니다. 객체 파스칼도 C/C++ 보다는 적지만 한 연산자 합니다! ^^: 역시 여기에서도 연산의 우선 순위가 있습니 다. 겷합성도 당연히 존재하고요. C/C++과 파스칼을 같이 사용하는 사람이라 면 두 언어에서의 연산의 우선 순위가 미묘하게 다르기 때문에 틀린 문법으 로 바탕글(source code)를 쓰는 경우가 많지요(필자도 물론 속합니다만..) 베이식? 마찬가지입니다. 뭐 파스칼과 별반 다를 것이 없습니다. 이처럼 연산자를 가지고 있는 대부분의 언어들은 연산의 우선 순위를 만들어 놓고 이 규칙대로 바탕글을 쓰도록 하고 있습니다. 이러한 언어의 문법이 몸 에 밴 사람이라면 몰라도, 처음 언어를 공부하는 사람들이라면, 특히 한 연 산자 하는(!) C/C++ 언어를 공부하는 사람이라면, 연산자의 개수와 우선 순 위 때문에 곤혹을 치러야 합니다. 여하튼 필자도 많이 고생한 기억이 나는군 요. 물론 Smalltalk에서도 연산의 우선 순위 비슷한 것은 존재합니다. 바로 뒤에 서 설명할 "길수의 우선 순위"(method's precedence)가 그것인데, 다른 언어 에서처럼 그렇게 복잡하지 않습니다. 그러니 지레 겁먹지 마시길... ----------------------------------------------------------- Smalltalk가 산수에서 쓰는 것과 다른 방식을 취해서 기분이 나쁘십니까? 글 쎄요. 과연 계산식이 다음처럼 복잡해도 그렇게 기분이 나쁠까요? 1 + 2 * 3 - 4 + 5 * 6 - 7 - 8 / 9 ☞ "?" 산수에서 쓰는 방법으로 위의 식을 한 번 계산해 보십시오. ^^: 그러나 Smalltalk에서는 왼쪽에서 오른쪽으로 훑어가면서 계산하면 되므로 매우 간 단합니다. 아래는 Smalltalk가 위의 식을 어떻게 푸는지를 보여줍니다. 1 + 2 * 3 - 4 + 5 * 6 - 7 - 8 / 9 → ~~~~~ 3 * 3 - 4 + 5 * 6 - 7 - 8 / 9 → ~~~~~~~~~ 9 - 4 + 5 * 6 - 7 - 8 / 9 → ~~~~~~~~~~~~~ 5 + 5 * 6 - 7 - 8 / 9 → ~~~~~~~~~~~~~~~~~ 10 * 6 - 7 - 8 / 9 → ~~~~~~~~~~~~~~~~~~~~~ 60 - 7 - 8 / 9 → ~~~~~~~~~~~~~~~~~~~~~~~~~ 53 - 8 / 9 → ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 45 / 9 → ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 5 매우 쉽게 결과값이 나올 수 있다는 것을 느끼실 겁니다. Smalltalk에서도 물론 산수에서 쓰는 것처럼 똑같은 우선 순위의 규칙을 세울 수도 있었지만, 실제로 복잡한 계산식을 써야 하는 경우라면 오히려 우선 순위 규칙 때문에 복잡해질 수가 있습니다. 이는 결국 문법이 복잡해진다는 말이고, 그렇게 된 다면 프로그래밍을 하는 사람의 노력이 더 들어간다고 봐야 옳습니다. 물론 이런 우선 순위 규칙을 처리하기 위해서 Smalltalk(정확히는 컴퓨터)가 해야 할 일도 더 많아질 것이고... 여러모로 Smalltalk는 현명한 선택을 한 것 같 다는 게 필자의 생각입니다만.... 물론 경우에 따라서 '+' 보다 '*'이 먼저 계산되어야 할 필요가 있습니다. 이 때에는 괄호를 사용하면 됩니다. 1 + (2 * 3) → 1 + 6 ☞ 7 이렇게 계산식 중에서 먼저 계산되어야 할 부분에 소괄호를 둘러주면, Smalltalk는 무조건 왼쪽에서 오른쪽으로 값을 계산하지 않고, 괄호가 있는 식을 먼저 계산하게 됩니다. 이것이 오히려 연산의 우선 순위 규칙을 정해주 는 것보다 훨씬 명확한 바탕글을 쓸 수 있게 만들어줍니다. 괄호를 쓰면 연산의 우선 순위가 명확해 진다고 해서 아무 때나 괄호를 쓰는 것이 좋다는 말은 아닙니다. (2 * 3) + 1 → 6 + 1 ☞ 7 이 경우는 괄호가 있으나 없으나 똑같이 "7"이라는 결과값을 남깁니다. 아래에 쓸 데 없는 괄호의 예를 좀 더 들어보겠습니다. (1 + 2 + 3). ☞ 6 (1) + 2 ☞ 3 (((1 + 2) + 3) + 4) + 5 ☞ 15 (((((1))))) ☞ 1 위의 괄호들이 정말 쓸 데 없는지 알아보려면, 위의 글토막에서 괄호란 괄호 는 다 뺀 상태로 다시 가늠해 보면 알 수 있습니다. 아마 똑같은 결과를 얻 을 것입니다. 그러므로 여러분이 실제로 바탕글을 쓸 때에는 저런 짓(?)은 하지 않는 게 정신 건강상, 눈 건강상 좋습니다. (저 많은 괄호를 언제 다 세고 있다니???) 당연한 말이지만 괄호는 제 짝을 맞추어서 써야 합니다. 따라서 다음과 같은 글토막은 말도 안 되는, 그래서 Smalltalk마저도 거부하는 글토막입니다. (1 + 2 오른쪽 괄호는 어디에?? 1 + 2) 왼쪽 괄호는 어디에?? 1) + (2 어라? 왼쪽은 오른쪽이, 오른쪽은 왼쪽이? (1+) 2 "1+"이 숫자인가? 연산수로는 쓸 수 없음. 위의 글토막을 정말 Smalltalk가 거부하는지는 아무거나 하나를 골라서 가늠 해 보면 알 수 있습니다. 실제로 (1 + 2 를 가늠해 보면 "expecting ')'"이라는 잘못이 발생하게 됩니다. Smalltalk 는 친절하게도 어디에서 괄호가 빠졌는지를 알려줍니다. ^^: Smalltalk는 여러분이 어떤 실수를 할 때는 이처럼 잘못 알림글을 나타내거 나, "1.5" 마디에서 잠깐 이야기했던 "발자취 창"(walkback window)를 통해 여러분의 잘못을 알려줍니다. Smalltalk는 매우 안전한 시스템입니다. 여러분이 어지간한 실수를 하더라도 Smalltalk 자체가 죽어버리는 일은 극히 드믑니다. 물론 여러분이 Smalltalk 를 죽이게 할 수는 있습니다만, 고의가 아닌 이상 여러분의 실수로 인해서 Smalltalk가 박살나는 일은 없을 것입니다. 바꾸어 말하면, 실패를 두려워하 지 말고 여러 가지 실험을 해 보라는 말입니다. "이렇게 하면 어떻게 될까?" 하는 탐구심은 Smalltalk처럼 여러분과 객체들이 언제나 자유롭게 대화할 수 있는 환경에서는 꼭 필요한 생각이기 때문입니다. 만약 Smalltalk 죽이기에 동참하고 싶으면 다음 글토막을 가늠해 보십시오. 이 때 여러분이 Smalltalk 본(image)에 저장할 것이 있다면 File > Save Image 메뉴를 사용하여 먼저 저장을 한 뒤에 가늠하도록 합시다. 괜히 저장 하지도 못했는데 Smalltalk가 죽었다고 필자를 원망하지 말구요. Processor := nil. 위의 글토막을 가늠하면 "Unrecoverable Stack Overflow Error..." 운은하면 서 Smalltalk의 실행이 중지될 것입니다. <확인> 단추를 눌러주면 Smalltalk 환경은 끝나고 운영체계로 되돌아가게 됩니다. Smalltalk가 죽기는 했지만 다시 Smalltalk를 실행하면 이전에 여러분이 저 장했던 본을 이용하여 모든 객체를 되살려 놓을 것입니다. 물론 Smalltalk가 죽는다고 운영체계까지 죽음의 수렁으로 몰아넣지는 않습니다. Smalltalk는 자신이 죽을 망정, 운영체계를 먹통으로 만들어버리는 일은 하 지 않습니다. 그러므로 마음껏 실험하십시오. 그리고 실수하십시오. 그러면 여러분이 실수한 만큼 실력이 늘 것입니다. 물론 실수에 대비해서 언제나 깨 끗한 Smalltalk의 본(image)은 두 개 이상 준비해 두어야겠지요? ^^: ("1.4.2" 마디 참조) 계속.. 제 목:[강좌] Smalltalk 배우기 #8 관련자료:없음 [15] 보낸이:김찬홍 (안드래아) 1998-12-03 20:54 조회:205 Smalltalk 배우기 #8 1998. 12. 3. 김찬홍 mailto:andrea92@hitel.net ====================================== 2. 객체들과 나누는 이야기 2.1. 객체? 2.2. 몸으로 느끼기 2.2.1. 글토막 가늠하기 2.2.2. 셈! 셈! 셈! →2.2.3. 실체와 갈래 ...... ======================================= 2. 객체들과 나누는 이야기 ------------------------------------ 2.2. 몸으로 느끼기 ~~~~~~~~~~~~~~~~~~ 2.2.3. 실체와 갈래 ------------------ 우리는 지금까지 '1', '2', 3'처럼 소수점이 없는 수를 다루어 왔습니다. 이 러한 수들을 수학에서는 정수(正數)라고 부릅니다. 즉 우리는 지금까지 정수 갈래(class)에 속하는 여러 가지의 수들을 다루어 온 것입니다. 방금 말했지만 정수는 수(數)의 한 "갈래"입니다. 그럼 정수에는 어떠한 것 들이 있을까요? 산수 시간에 우리가 정수에 속하는 수를 어떻게 나타내었습 니까? ....,-3, -2, -1, 0, 1, 2,.... 처럼 나타내었습니다. 즉 '-3', '1', '2' 등은 모두 정수 갈래에 속한 수들 이라는 뜻입니다. 앞서 필자는 "우리는 지금까지 정수를 다루었다"고 말했는데, 실은 정수를 다룬 것이 아니라 정수 갈래에 속해 있는 실제의 수를 다룬 것입니다. 다시 말하면 "정수"라고 하는 갈래를 직접 다루지는 않았습니다. 조금 복잡하죠? 그럼 다른 예를 들어봅시다. 여러분은 사과를 좋아합니까? 저는 사과를 참 좋아합니다. 그래서 "나는 사과를 먹는다"고 말할 수 있습니다. 그런데 엄밀 하게 따져보십시오. 나는 "사과"라는 __이름__을 먹는 것이 아니라, "사과" 라고 불려지는 실제로 존재하는 어떤 한 과일을 먹었을 따름입니다. 여러분은 개를 좋아합니까? 저는 개를 좋아합니다. 그런데 우리들이 "개를 좋아한다"고 말할 때, "개"라고 하는 갈래(class)를 좋아하는 것이 아니라, '개'라고 불려지는 실체(instance)를 좋아하는 것입니다. 잘 생각해 보십시 오. "개"라고 하는 것은 사람들이 사물(object)과 사물을 구별하기 위해서 붙여놓은 갈래의 이름일 뿐입니다. (이야기가 갑자기 철학적이 되었죠? --:) 여러분은 저마다 이름을 가지고 있을 것입니다. 저는 "김찬홍"입니다. 그런 데 저 찬홍이는 "사람"입니다. 즉 저는 사람이라는 __갈래(class)__에 속해 있으며, 그러므로 찬홍이는 사람이라는 갈래의 __실체(instance)__입니다. 그래도 어렵습니까? 좀 더 머리에 와 닿는 이야기를 해 봅시다. 먹는 이야기입니다. :) 여러분은 붕어빵을 어떻게 만드는지 보셨습니까? 붕어빵을 만들 때에는, 우 선 붕어빵을 만들기 위한 반죽이 필요합니다. 그리고 붕어빵의 속이 필요하 겠지요. 이제 붕어빵을 만들 차례입니다. 우선 붕어빵 모양의 틀에 반죽을 넣고 준비한 속을 넣습니다. 그리고 뚜껑을 닫고 불에서 익히면 붕어빵이 되 는 것이지요.(지금이 요리시간인가? 후후) 자, 여기서 붕어빵을 만들기 위한 틀이 갈래(class)입니다. 그리고 이 틀에 서 만들어낸 붕어빵이 바로 실체(instance)가 되는 것입니다. 어렵습니까? 자, 다시 수 이야기를 해 봅시다. 우리들은 지금까지 정수를 가지고 여러 가 지 실험을 해 보았는데, 사실 '정수' 자체를 가지고 실험을 한 것이 아니라, '1', '2', '3' 따위의 실체(instance)를 가지고 실험을 한 것입니다. 우리는 이러한 수를 정수라는 갈래(class)로 묶어서 부를 뿐입니다. 여기서 우리는 갈래(class)와 실체(實體, instance)에 대해서 이야기를 해야 합니다. 조금 어려운 개념일지는 모르겠지만, 조금만 곰곰이 생각해 보면 그 렇게 어렵지만은 않습니다. 정수라고 하는 갈래에는 여러 개의 실체가 있습니다. 1, 2, 3, 4, -1, -2, -3, -4,... 이런 모든 것이 정수라는 __갈래__의 __실체__가 되는 것입니다. 거꾸로 생각해 봅시다. 우리는 실체들을 모아서 갈래를 짓습니다. 1, 2, 3, 4, -1, -2, -3, 4-,... 등은 모두 "소수점이 없다"는 공통점을 가지고 있습 니다. 그래서 이런 공통점을 가지고 있는 실체들을 "정수"라는 갈래로 이름 지어 부르는 것입니다. 이제 갈래와 실체의 관계를 어느 정도 파악할 수 있겠습니까? 잘 모르겠으면 더 나아가지 말고 처음부터 글을 되읽어봅시다. 그러면 분명히 와 닿는 무엇 인가가 있을 것입니다. 원래부터 실체와 갈래는 조금 추상적인 개념이므로, 여러분이 헷갈리는 것이 오히려 당연할지도 모르겠습니다. 자, 갈래와 실체에 대해서 어느 정도 가닥을 잡았다면, 이제는 실습을 통해 서 몸으로 느껴보도록 합시다. 앞에서 우리가 객체에 대한 이야기를 할 때, "모든 객체는 저마다 나름의 갈 래에 속해있다"는 말을 한 적이 있을 것입니다. 기억나십니까? 우리들이 앞 에서 다루어온 1, 2, 3, -1, -2, -3 등이 바로 객체(object)입니다. 결국 그 말은 1, 2, 3, -1, -2, -3 등이 모두 저마다의 갈래에 속해있다는 말입니다. 그럼 이들 1, 2, 3,...은 도대체 어떤 갈래에 속해있을까요? 말하나마나겠지 요? "정수"라는 갈래에 속해 있다고 바로 조금 전에 이야기했습니다. 그래서 우리들은 이러한 수에 대해서 "도대체 너는 어떤 갈래에 속하느냐"라 고 물을 수 있습니다. 그럼 이제 '1'에 대해서 "너는 어떤 갈래에 속하느냐" 고 물어봅시다. 다음의 글토막을 가늠하여 펴 봅시다. 1 class ☞ SmallInteger 어떻습니까? '1'이 뭐라고 대답했습니까? "SmallInteger"라고 대답했습니다. "Integer", 즉 바로 "정수"라고 대답하지는 않았지만 "작은 정수"라는 썩 비 슷한 대답을 했습니다. 그러므로 수 '1'은 "작은 정수"(SmallInteger)의 실 체(instance)라고 말할 수 있습니다. 여기서 멈출 수는 없습니다. 1이 SmallInteger의 실체라면, 그럼 Smalltalk 에 Integer라는 갈래는 없는 것일까요? 분명히 "작은 정수"보다 "정수"가 좀 더 일반적입니다. 그러므로 분명히 "작은 정수"라는 갈래 위에 좀 더 일반적 인 갈래, 즉 "정수"와 같은 갈래가 있을지도 모릅니다. 이제 그럼 우리는 "정수"에게 "좀 더 일반적인 갈래가 무엇인가"라는 물음을 던질 필요가 있습니다. 이제 우리는 실체에게 묻는 것이 아니라 갈래에게 묻 는 것입니다. 다음 글토막을 펴 봅시다. SmallInteger superclass ☞ Integer "class"가 "너는 어떤 갈래에 속하느냐"고 묻는 것이었다면, "superclass"는 "네 바로 위에 있는 윗갈래는 무엇이냐"고 묻는 것입니다. 윗갈래? 도대체 그게 뭘까요? 쉽게 말하면 윗갈래(superclass)란 지금 현재의 갈래 바로 위에 존재하는 갈 래를 말합니다. "사과", "과일", "식물"이 있을 때, "사과"는 "과일"에 속하 고, "과일"이라는 갈래는 다시 "식물"이라는 갈래에 딸려있습니다. ----------------------------------------------------------- 식물 ↑ 과일 ↗ 사과(실체) ----------------------------------------------------------- 위의 그림과 같이 갈래가 씨줄(hierarchy)로 엮어져 있을 때, "윗갈래"와 "아랫갈래"의 관계가 이루어집니다. 위에서, '과일'은 '사과'가 속한 "갈래"(class)이고, '사과'는 '과일'의 "실 체"(instance)입니다. 이 상태에서 '식물'은 '과일'의 "윗갈래"(superclass)이고, '과일'은 '식물' 의 "아랫갈래"(subclass)입니다. 그러면 위의 보기를 바탕으로, 실체 '1'과 'SmallInteger', 'Integer' 갈래 들의 관계를 아래에 그려봅시다. ----------------------------------------------------------- Integer ↑ SmallInteger ↗ 1(실체) ----------------------------------------------------------- 'SmallInteger'는 '1'이 속한 "갈래"이고, '1'은 'SmallInteger'의 "실체"입 니다. 이 상태에서 'Integer'는 'SmallInteger'의 "윗갈래"(superclass)이고, 반대 로 'SmallInteger'는 'Integer'의 "아랫갈래"(subclass)입니다. 어렵습니까? 위의 그림을 잘 보고 씨줄이 어느쪽으로 흘러가는지를 파악하면 "아랫갈래"와 "윗갈래"를 금방 파악할 수 있을 것입니다. 자, 지금까지 우리는 '1'은 'SmallInteger'의 "실체"라는 것을 알았으며, 'SmallInteger'는 'Integer'의 아랫갈래라는 것을 알 수 있었습니다. 그러면 'Integer'의 윗갈래는 무엇일까요? 그리고 그 위의 윗갈래는...? 우 리는 윗갈래가 무엇인지 묻는 방법을 이미 공부했습니다. 배운 것을 그대로 써먹어 봅시다. Integer superclass ☞ Number Number superclass ☞ ArithmeticValue ArithmeticValue superclass ☞ Magnitude Magnitude superclass ☞ Object Object superclass ☞ nil 보시다시피 우리는 정수(Integer)에서 출발하여 결국은 "객체"(object)에 이 르기까지 씨줄을 더듬어 올라갔습니다. Object에서 멈춘 이유는 "Object"의 윗갈래는 없기 때문입니다. 어떻게 알 수 있느냐구요? "Object" 갈래가 그렇 게 대답했습니다. Object superclass ☞ nil "nil"은 "없다"는 뜻입니다. 즉 "Object" 갈래에서 씨줄이 멈추는 것입니다. 앞으로 우리는 "nil"을 "헛"이라 부릅시다. 그럼 지금까지 알아본 것을 바탕으로 씨줄그림(hierarchy diagram)을 그려보 면 아래와 같이 됩니다. <그림 2-1> SmallInteger 갈래의 씨줄그림 ----------------------------------------------------------- Object(객체) ↑ Magnitude(크기값) ↑ ArithmeticValue(산술값) ↑ Number(수) ↑ Integer(정수 ↑ SmallInteger(작은정수) ↗ 1(실체) ----------------------------------------------------------- 위의 그림을 보고 우리는 다음과 같이 말할 수 있습니다. "1은 작은 정수이고, 정수이고, 수이며, 산술값이고, 크기값이며 객체이다." 즉 우리가 "사과는 과일이며 동시에 식물이다"라고 말할 수 있는 것과 똑같 다고 할 수 있습니다. 그래서 '1'은 정수인 동시에 '수'라는 윗갈래에도 속해있음을 알 수 있습니 다. 또한 '1'은 바로 "객체"라는 것도 확실히 알 수 있습니다.. Smalltalk에서는 모든 것이 객체입니다. 그러면 여기서 의문이 하나 생깁니다. "작은 정수"(SmallInteger)가 있다면 그 어디인가 "큰 정수"(LargetInteger)라는 갈래도 있어야 옳습니다. '1'이 작다? 그럼 '1'보다 더 큰 수를 입력해 보면 어떨까요? 자, 계속 실험을 해 봅시다. 2 class ☞ SmallInteger 3 class ☞ SmallInteger 10 class ☞ SmallInteger 100 class ☞ SmallInteger 100000 class ☞ SmallInteger 100000000 class ☞ SmallInteger 1000000000 class ☞ SmallInteger 9999999999 class ☞ LargeInteger 10000000000 class ☞ LargeInteger 찾았습니다! 역시 SmallInteger의 반대가 되는 LargeInteger라는 갈래가 분 명히 있습니다. 그러므로 정수(Integer)에 대해서 다음과 같은 씨줄그림을 그려볼 수 있습니다. ----------------------------------------------------------- 정수(Integer) ↗ ↖ SmallInteger(작은정수) LargeInteger(큰정수) ----------------------------------------------------------- 이제 우리는 여기까지 오면서 두 가지의 사실을 배울 수 있었습니다. 1) class - 이 실체가 어떤 갈래에 속해있는가? 2) superclass - 이 갈래의 윗갈래는 무엇인가? 여기서 한 가지 재미있는 실험을 해 봅시다. 만일 실체가 아니라 갈래에 대 해서 superclass를 쓰면 어떻게 될까요? 직접 한 번 실험을 해 봅시다. 0 superclass ☞ "발자취 창 열림" 위의 식을 펴 보면 "SmallInteger does not understand #superclass"라는 제 목을 가진 발자취 창(walkback window)이 나타남을 알 수 있습니다. 위의 말 을 우리말로 하면 "작은 정수는 superclass를 알아들을 수 없습니다" 정도로 고쳐볼 수 있습니다. 이는 Smalltalk가 우리들이 글토막을 가늠할 때 어떤 잘못이 있었음을 알려줍니다. 보통의 경우 이렇게 튀어나온 발자취 창은 그 냥 닫아도 상관이 없습니다. 그러나 창을 닫기 전에 도대체 이 창의 제목이 무엇인지 정도는 읽어보도록 합시다. 창의 제목은 왜 이 창이 열리게 되었는 지를 설명해 주기 때문입니다. 앞에서 우리는 또 한가지의 사실을 알았습니다. 바로 superclass는 갈래에만 사용할 수 있고, 실체에는 사용하지 못한다. 는 것입니다. '0'이 실체인지 갈래인지 아직까지 구분이 안 가는 분들은 수 고스럽겠지만 처음부터 글을 다시 읽어보십시오. 실체와 갈래가 자꾸 헷갈리 는 상태에서 계속 글을 진행하면 오히려 더 큰 혼란의 수렁으로 빠져들기 때 문입니다. 그럼 이제 갈래에 "class"를 써먹을 수 있는지 알아봅시다. 다음의 글토막들 을 펴 보고 결과를 확인해봅시다. 1 class ☞ SmallInteger SmallInteger class ☞ SmallInteger class Number class ☞ Number class Object class ☞ Object class 일단 갈래에 대해서 "class"를 써먹을 수 있었습니다. 그러나 그 결과값은 도무지 쉽게 설명하기가 어렵습니다. 갈래더러 "너는 무슨 갈래에 속하느냐?"라고 물은 꼴이 되는데, 이 때 Smalltalk는 갈래 이름 뒤에 "class"를 붙여서 나타냈습니다. 왜 이런 결과 값이 나왔는지 설명하려면 "풀이갈래"(metaclass)에 대해서 이야기를 꺼내야 하는데, 지금 막 Smalltalk를 공부하는 여러분에게 자칫하면 커다란 혼란을 드릴 수 있기 때문에 여기서는 설명하지 않겠습니다. 그리고 지금 당장은 여 러분이 풀이갈래에 대해 모른다고 해서 Smalltalk를 공부하는데 문제가 생기 지는 않을 것이므로, 다음과 같은 사실만 짚고 넘어갑시다. class는 실체와 갈래 모두에 사용할 수 있다. 이정도만 알면 충분합니다. 지금까지 우리는 "class"를 사용하여 어떤 실체가 무슨 갈래에 속하는지를 알아보았습니다. 그런데 종종 우리들은 윗갈래를 모두 포함한 씨줄을 뒤져서 어떤 실체가 무슨 씨줄에 얽혀있는지 알아야할 필요가 있습니다. 다시 말하면, 찬홍이는 "학생"이라는 갈래에 속해있지만, 동시에 '사람'이기 도 합니다. 그래서 "찬홍이는 사람인가?"라고 물을 수 있듯이, Smalltalk의 실체에게도 "1은 정수인가?"라는 식으로 씨줄을 바로 물을 수 있다는 말입니 다. 아래의 글토막을 펴 보십시오. 2 isKindOf: SmallInteger ☞ true 2 isKindOf: Integer ☞ true '2'는 "true"라는 값을 남겼습니다. "true", 즉 "맞다"는 말입니다. "isKindOf:"를 사용하면 <그림 2-1>에 그린 씨줄을 모두 훑어가면서 확인할 수 있습니다. 2 isKindOf: Number ☞ true 2 isKindOf: ArithmeticValue ☞ true 2 isKindOf: Magnitude ☞ true 2 isKindOf: Object ☞ true 그럼 "isKindOf:"를 사용하여 틀린 질문을 해 봅시다. 2 isKindOf: LargeInteger ☞ false 10000000000 isKindOf: SmallInteger ☞ false 역시 실체들은 우리가 틀린 것을 물으면 "false", 즉 "틀렸다"라고 대답합니 다. 이 세상에 과연 이렇게 옳은 것을 옳다, 틀린 것을 틀렸다고 말할 수 있 는 사람이 과연 몇 명이나 될까요? --: 그럼 마지막으로 Smalltalk에게 짓궂은 장난을 해 봅시다. Smalltalk가 알아 들을 수 없는 갈래 이름으로 "isKindOf:"를 사용했을 때 어떤 반응을 보일까 요? 다음의 글토막을 펴 봅시다. 2 isKindOf: Abcd ☞ "Error: undeclared Abcd 잘못 발생" Smalltalk는 "Abcd"라는 갈래 이름을 못알아듣습니다. 그래서 잘못을 일으킨 것이지요. 결국 Smalltalk에는 "Abcd"라는 갈래는 없다는 말이 되는데, 그러 면 Smalltalk에 무슨 갈래가 있는지 어떤 방법으로 알 수 있을까요? 그것은 여러분에게 숙제로 남겨두겠습니다. 힌트는, 지금까지 읽은 글 중에 분명히 답이 있습니다. 제 기억으로는 아마 두 번 정도 답이 나온 것 같은데요.... 한 번 찾아보십시오. :) 지금까지 우리는 실체(instance)와 갈래(class)에 대해서 알아보았습니다. Smalltalk에서 모든 것은 객체(object)이기 때문에 "2.1" 마디에서 이야기했 던 "객체의 특성"이 그대로 적용됩니다. 즉 "모든 객체는 저마나 나름으로의 갈래에 속한다"는 것입니다. 우리는 이번 나눔[部]에서 어떤 객체가 있을 때 이 객체가 도대체 어떤 갈래에 속하는지, 그리고 그 갈래의 윗갈래는 무엇인 지를 아는 방법을 공부해 보았습니다. 어떻습니까? Smalltalk는 언제든지 여 러분이 필요하다면 지금까지 한 것처럼 객체와 매우 쉽게 대화를 할 수 있습 니다. 다음 나눔에서 우리는 '지시'(message)에 대해서 공부하게 될 것입니다. 모 든 객체가 행동을 하려면 어떤 지시를 내려야 합니다. 사실 우리는 벌써 지 금까지 객체에게 무수한 지시를 내렸습니다. "class", "superclass"는 물론 이고 "isKindOf:"도 하나의 지시였습니다. 물론 '+', '-'와 같은 연산자 (operator) 역시 어엿한 지시입니다. 이제 다음 나눔에서 우리가 할 일은 이 런 지시에는 어떤 종류가 있으며, Smalltalk의 객체는 어떤 지시를 어떻게 받아서 결과를 남기는지에 대해서 알아보도록 하겠습니다. ---<잠깐!>----------------------------------------------------------- 다른 언어에서는...? Smalltalk는 순수한 객체지향형 언어입니다. C++, Object Pascal 등의 언어 가 이미 있던 언어에 객체지향의 성격을 더하여 확장한 것에 비해, Smalltalk는 모든 것을 객체지향적 관점으로 새롭게 시작한 언어입니다. 따 라서 객체지향이라는 관점에서 보면 분석과 설계, 그리고 구현이 가장 잘 된 언어가 또한 Smalltalk일 것입니다. 그러므로 Smalltalk에서는 모든 것이 객체라는 사실은 전혀 놀랄만한 일이 아닙니다. '1', '2'와 같은 수도 그래서 객체입니다. 이 객체에게 우리는 알 아들을 수 있는 지시(message)를 내릴 수 있으며, 객체는 우리가 내린 지시 에 대해서 알고있는 길수(method)대로 행동합니다. 이것이 모든 객체지향언 어의 특징인 동시에 Smalltalk의 특징입니다. 필자는 Simula 67에 대해서 잘 모르기 때문에, 최초로 갈래(class)라는 개념 을 사용한 Simula 언어에 이렇게 객체지향적인 특성이 있는지는 모르겠습니 다. 허나, Smalltalk는 객체지향언어의 선두주자로써 한 몫을 차지합니다. 이 후 생겨난 객체지향 언어나, 또는 기존 언어에 객체지향 기법을 더한 언 어들은 크든 작든 간에 Smalltalk의 특징을 수용했습니다. 이번 글에서 이야 기한 것들은 "Object Reflection"이나 "RTTI: Runtime Type Information"이 라는 이름으로 이미 Java나 다른 많은 언어들이 반영하고 있는 부분입니다. C++나 Object Pascal에서는 모든 것이 객체가 아닙니다. 어떤 것은 객체이고 어떤 것은 아닙니다. '1', '2'와 같은 것은 객체가 아니기 때문에, 언어에서 제공하는 객체지향적인 특성을 전혀 사용할 수 없게 됩니다. C++나 Object Pascal에서 '1'에게 어떤 갈래에 속해 있느냐고 물을 수 없는 이유가 여기에 있습니다. C++와 Object Pascal의 문법이 복잡해지는 근본적인 이유 또한 기존 언어에 객체지향 패러다임을 접목시키려는 노력에서 비롯되었습니다. 이들은 새 술 을 헌 부대에 담으려 했습니다. 물론 그것이 꼭 잘못된 것만은 아니지만, 어 쨌건 필요 이상으로 복잡한 문법을 만든 것만은 사실입니다. 앞으로 여러분 이 Smalltalk를 공부하면서 느끼겠지만, Smalltalk에서는 그 문법이 매우 간 결하며 간단합니다. 이것은 '객체지향'이라고 하는 통일되고 잘 정리된 개념 을 쓰기 때문에 가능한 것입니다. 물론 Smalltalk가 이렇게 순수 객체지향 패러다임을 추구하기 때문에 생겨난 단점들도 있다고 생각되며, 실제로도 많은 문제점이 지적되어왔습니다. 바로 이것은 객체지향이 나아가야 할 방향을 제시하고 있다고 필자는 생각합니다. 그렇지만 결국 Smalltalk는 객체지향의 모토이자 바탕이라고 아니할 수 없습 니다. 적어도 대화식이라는 장점으로 인하여 객체지향이라는 개념에 한 발 한 발 접근하기는 번역(compiling) 언어보다도 대화식 언어가 쉽다고 필자는 생각합니다. 물론 이것은 필자의 생각입니다만... ----------------------------------------------------------- 계속... 제 목:[답변/16] 객체지향 프로그래밍 언어 관련자료:없음 [17] 보낸이:김찬홍 (안드래아) 1998-12-06 03:19 조회:413 안녕하십니까? 정훈님께서 객체지향 언어에 대해서 질문을 하셨습니다. 매우 포괄적인 질 문이네요. 질문을 요약해 보면, 객체지향 프로그래밍 언어에는 어떤 것이 있으며, 그리고 그들 중 하나라도 좋으니 정리를 해 달라는 말씀이신 것 같 습니다. 맞습니까? 우선 객체지향 언어가 무엇인지부터 생각해 봅시다. 객체지향 프로그래밍 언어란, 객체(object)를 중심에 두고 프로그래밍을 할 수 있는 언어, 즉 컴 퓨터 프로그래밍에 객체지향의 개념을 사용할 수 있는 언어를 가리킵니다. 우리 옆 방(9번)에 '객체지향 개발 방법론'에 대한 글이 있습니다. 결국 객체지향 프로그래밍 언어 또한 그 바탕이 '객체지향'이라는 개념이므로, 객체지향이라는 개념을 확실히 알아두는 것이 중요하다고 생각합니다. 간단히 말씀드리면, - 세상에 있는 모든 것은 객체이다. - 따라서 어떤 문제가 있으면 그 문제를 풀기 위한 객체를 풀어낼 수 있다. - 객체는 나름대로의 갈래(class)에 속한다. - 객체는 자기가 어떤 일을 해야 할 지를 알고 있다. - 객체에게 어떤 일을 시키기 위해서는 객체가 알고 있는 지시 (message)를 내려주어야 한다. 그러면 객체는 자신이 알고 있는 길수(method)에 따라서 행동을 취하고 결과를 얻어낸다. - 또한 객체는 나름으로의 특성(attribute, property)을 가지고 있다. - 객체는 자기가 무슨 일을 할지를 알고 있기 때문에, 서로 다른 객체라 하더라도, 똑같은 메세지를 줄 수 있다. 이를 다형성 (polymorphism)이라 한다. 학교에서 종을 쳐서 여러 학생들에게 지시를 보내면, 어떤 학생은 집에 가고, 어떤 학생은 다른 교실로 간다. 이는 '종을 친다'는 하나의 지시에 따라 여러 객체가 다르게 반응할 수 있음을 의미한다. - 이미 있는 객체에 다른 기능을 더하고 싶을 때에는, 원래의 객체를 손 델 필요 없이, 그 객체의 모든 것을 물려받아서 새로운 갈래를 지을 수 있다. 이를 상속성(inheritance)라 부른다. 뭐 이런 것들이 객체지향의 가장 기본적인 개념이라고 할 수 있습니다. 이 런 개념 위에 'encapsulation'(캡슐화? 음. 아직 이 말에 대해서 마땅한 우 리 낱말을 찾아내지 못 습니다만...)라던가 객체의 독립성이나 재사용성 등이 생기게 됩니다. 위에서 말한 객체지향의 특성을 지원하는 프로그래밍 언어는 모두 객체지 향 프로그래밍 언어라고 할 수 있습니다. 객체지향 프로그래밍 언어에는 '순수 객체지향 프로그래밍 언어'가 있고, '확장 객체지향 프로그래밍 언어'가 있습니다. 전자는 객체지향적으로만 프 로그래밍을 설계하고 바라보는 것으로써, Smalltalk나 Eiffel, Java 등이 있으며, 후자는 기존 언어에 객체지향 개념을 더한 언어로써, C++, Object Pascal 등이 있습니다. 이들 언어들은 각기 나름대로의 특징이 있지만, 앞에서 살펴본 객체지향적 인 특징들을 나타내기 위해 여러 가지 서로 다른 문법이나 의미를 사용합니 다. 따라서 C++ 에서 객체지향의 기본 개념을 파악하면 Smalltalk 등과 같 은 다른 객체지향 언어를 접하기가 매우 쉽다고 할 수 있습니다. 이 게시판에서 보고계시듯이, 저는 객체지향 넝어의 조상이자 중심인 Smalltalk 언어에 대해서 강좌를 올리고 있습니다. 이 글의 목적은 단순히 Smalltalk를 공부하는 데 있는 것이 아니라, 이 언어를 통해서 좀 더 쉽게 객체지향에 대한 개념을 습득하는데 있습니다. Smalltalk는 다른 언어들에 비해서 매우 간단한 문법을 가지고 있기 문에, 프로그램의 문법을 공부하 기 위해 시간을 많이 투자할 필요가 없습니다. 오히려 Smalltalk는 순수 객 체지향 언어이기 때문에, Smalltalk의 문법적인 사항을 공부하면 저절로 객 체지향 개념이 잡히게 되어 있습니다. 그러므로 제 글을 읽어보시면 미약하 나마 도움이 되실 것입니다. 글은 앞으로도 계속 올라갈 예정입니다. 그럼 도움이 되시기를 바랍니다. 제 목:[강좌] Smalltalk 배우기 #9 관련자료:없음 [18] 보낸이:김찬홍 (안드래아) 1998-12-07 17:47 조회:192 Smalltalk 배우기 #9 1998. 12. 7. 김찬홍 mailto:andrea92@hitel.net ====================================== 2. 객체들과 나누는 이야기 2.1. 객체? 2.2. 몸으로 느끼기 2.2.1. 글토막 가늠하기 2.2.2. 셈! 셈! 셈! 2.2.3. 실체와 갈래 →2.2.4. 지시에 대하여 ...... ======================================= 2. 객체들과 나누는 이야기 ------------------------------------ 2.2. 몸으로 느끼기 ~~~~~~~~~~~~~~~~~~ 2.2.4. 지시에 대하여... ----------------------- Smalltalk에서는 모든 것이 객체(object)입니다. '1', '2' 등과 같은 숫자는 물론이고 심지어는 여러분이 늘 글토막을 짓고, 고치고, 가늠하고 하는 일터 (workspace)며, 글토막을 가늠할 때 생기는 잘못을 알려주는 발자취 창 (walkback window) 등 Smalltalk를 이루는 모든 구성요소들은 객체입니다. 이러한 객체들은 지시(message)를 주고받으며 일을 합니다. 앞서 우리는 주 로 수(數)에 대해서 여러 가지 지시를 내려보았습니다만, Smalltalk에서는 수 말고도 여러 가지 다양한 객체가 준비되어있어 여러분의 지시를 기다리고 있습니다. 먼저 앞서 공부한 것을 복습한다는 생각으로 다음의 글토막을 펴 봅시다. 1 class ☞ SmallInteger 1 + 2 ☞ 3 1 isKindOf: Integer ☞ true 위에서 "class", "+ 2", "isKindOf: Integer"는 모두 객체 '1'에게 보내는 지시입니다. 보다시피 같은 객체에게 내리는 지시라도 상황에 따라 서로 다 른 모양을 하고 있습니다. Smalltalk에는 크게 다음 세 가지 모양의 지시가 있습니다. * 외마디 지시(unary message) * 겹마디 지시(binary message) * 쇠마디 지시(keyworded message) "class"처럼 간단한 낱말로 이루어진 지시를 '외마디 지시'라 부르고, "+ 2"처럼 왼쪽 연산수와 오른쪽 연산수에 의해 겹으로 싸여있는 지시를 '겹마 디 지시'라 부릅니다. 그리고 "isKindOf: Integer"처럼 쌍점을 달고 다니는 지시를 '쇠마디 지시'라고 부릅니다. "isKindOf: Integer" 지시의 경우만 살펴보면 겹마디 지시와 쇠마디 지시가 썩 달라 보이지 않지만, 쇠마디 지시는 필요에 따라 좀 더 복잡해질 수 있습 니다. 5 between: 1 and: 10 ☞ true 위의 글토막은 '5'에게 "1과 10 사이에 있는 숫자냐"고 물어보는 쇠마디 지 시의 또 다른 형태입니다. '5'는 당연히 '1'과 '10' 사이에 들어 있는 숫자 이므로 "true"(맞다)라는 결과값을 남겼습니다. 똑똑한 5! ^^: '쇠마디 지시'에서의 '쇠'는 "열쇠말"을 줄인 말입니다. "열쇠말"(kwyword) 을 사전에서 찾아보면 "문장을 푸는데 열쇠(단서)가 되는 말"(한글과컴퓨터, 1998, 프라임 영한사전)이라고 되어있습니다. 그래서 위의 지시에서 "isKindOf:", "between:", "and:" 등은 모두 바로 뒤에 있는 수가 어떤 의미 인지를 알 수 있는 열쇠말이 되는 것입니다. 그리고 Smalltalk에서의 열쇠말 은 반드시 쌍점(:)으로 끝맺어야 합니다. 요컨데, "쇠마디 지시"는 "열쇠말 로 이루어진 지시"를 말합니다. 따라서 아래와 같은 글토막은 틀린 쇠마디 지시입니다. 5 between 1 10 "열쇠말이 없음" 5 between 1 and 10 "열쇠말은 반드시 쌍점으로 끝나야 함" 5 between: 1 and 10 "'and'도 열쇠말이므로 쌍점이 필요함" 그러므로 쇠마디 지시를 사용할 때에는 각각의 열쇠말들이 쌍점으로 끝나는 지를 반드시 확인해야 합니다. 그리고 쇠마디 지시는 필요하다면 얼마든지 많은 열쇠말을 가지고 만들 수 있습니다. 물론 다시 말하지만, 열쇠말은 반 드시 쌍점으로 끝나야 한다는 것, 잊지 마세요! 앞서 우리는 "1 + 2"라는 글토막에 대해서 다루면서 '연산자'(operator)와 '연산수'(operand)에 대해서 이야기한 적이 있습니다. '연산자'는 어떤 연산 을 나타내는 기호를 말하고, '연산수'는 연산에 필요한 값이라고 했습니다. 그렇다면 1 isKindOf: Integer "(1)" 5 between: 1 and: 10 "(2)" 의 경우를 연산자와 연산수에 빗대어 생각해 봅시다. (1)의 경우 연산수는 '1', 'Integer'가 될 것입니다. 마찬가지로 (2)의 경우 연산수는 '5', '1', '10'이라고 생각할 수 있습니다. 그런데 (2)의 경우 연 산자는 무엇일까요? 이 때의 연산자는 "between:and:"입니다. 즉 쇠마디 지 시에서의 연산자는 바로 열쇠말이라는 것을 알 수 있습니다. Smalltalk에서는 수식이 아닌 곳에 '연산자'와 '연산수'라는 말을 쓰지 않습 니다. 대신 "보낸이"(sender)와 "받는이"(receiver), "인자"(parameter)라는 말을 사용합니다. 일반적으로 5 class 5 + 2 5 between: 1 and: 10 이라는 글토막이 주어졌을 때, '5'라는 한 개의 정수를 "받는이"(receiver) 라 하고, "class", "+ 2", "between: 1 and: 10"을 각각 지시(message)라 부 릅니다. 또한 지시는 길표(selector)와 인자(因子, parameter)로 이루어져 있는데, 이 중에서 "class", "+", "between:and:"를 "길표"라 하고, 길표에 딸려서 받는이의 연산자 역할을 하는 '2', '1', '10'을 "인자"라 부릅니다. "class" 라는 길표는 외마디 지시이기 때문에 아무런 인자도 갖지 않습니다. 말로 설명하니까 많이 복잡해졌는데, 위에 설명한 것을 쉽게 표현하면 다음 그림과 같습니다. <그림 2-2> 받는이, 보낸이, 길수, 길표, 인자의 관계 ----------------------------------------------------------- 받는이 지시 _____ _____ 5 class ~~~~~ 길표 받는이 지시 _____ _____________ 5 + 2 ~~~~~ ~~~~~ 길표 인자 받는이 지시 ______ __________________________________________ 5 between: 1 and: 10 ~~~~~~~~ ~~~~~ ~~~~ ~~~~~ | 인자 | 인자 +-----------[길표]-----+ 그림으로 설명하니까 더 모르겠다구요? (!) 음, 여하튼 여러분은 머리가 좋 으시기 때문에 이 정도로 설명하면 충분히 알아들으시겠지요? :) 자, 다시 한 번 정리해 봅시다. * 받는이: 실제로 지시를 받는 객체를 말합니다. Smalltalk에서는 받는이가 제일 앞머리에 나오게 되어있습니다. * 지시: 받는이에게 보내야 할 내용을 말합니다. 글토막이 있을 경우 보통은 받는이를 뺀 나머지 부분이 지시가 됩니다. * 길표: 지시의 구성요소 중 하나로, 객체에게 어떤 길수(method)를 골라서 행동할 것인지를 알려주기 위해 사용됩니다. 길표 역시 지시의 종류에 따라 외마디 지시에 사용되는 "외마디 길표"(unary selector), 겹마디 지시에 사 용되는 "겹마디 길표"(binary selector), 쇠마디 지시에 사용되는 "쇠마디 길표"(keyword selector)로 나누어 부를 수도 있습니다. * 인자: 길표와 함께 넘겨주는 추가적인 정보입니다. 받는이는 길표를 보고 무엇을 해야 할지를 결정하고, 주어진 인자를 바탕으로하여 어떤 일을 합니 다. 이처럼 Smalltalk의 글토막은 여러 부분으로 이루어져 있으며, 각 부분은 나 름대로의 이름과 역할을 가지고 있다는 것도 알 수 있습니다. 이제 앞으로 우리는 많은 Smalltalk의 글토막들을 보게 될 터인데, 이들은 한결같이 받는 이와 길표, 인자로 이루어진 지시로 되어 있습니다. 지금까지 가늠해본 여러 가지 글토막들을 살펴보면서 받는이, 지시, 길표, 인자로 나누어 봅시다. 그 래서 글토막을 이루고 있는 부분들과 그 이름들에 익숙해지도록 노력합시다. ---<잠깐!>----------------------------------------------------------- 다른 언어에서는...? C++, Object Pascal, Java에서도 앞서 이야기한 받는이, 지시, 길표, 인자라 는 말이 그대로 적용됩니다. 물론 문법은 좀 다르지만 말입니다. 우선 C++에서 살펴봅시다. cout << "Hello, World!"; 위의 경우에 'count'이 받는이가 되고, '<< "Hello, World!"'는 지시가 됩니 다. 또한 '<<'는 길수이며(ostream::operator<<()), "Hello, World"는 '<<' 에 딸린 인자입니다. 위에서 ';'는 문장을 끝내는 마침표 역할을 합니다. aPoint.create(1, 2); 위에서 'aPoint'는 받는이이며 나머지는 지시, 그리고 'create'를 길표, '1' 과 '2'는 인자가 됩니다. C++에서 포인터가 어떤 객체를 가리키고 있을 때에는... pCar->go(FORWARD); 의 경우는 pCar가 가리키는 객체가 받는이이며, 나머지 부분이 지시가 됩니 다. '.'이 아니라 '->'를 쓴 것은, 위에서 'pCar'가 포인터 변수이기 때문 에, 포인터가 가리키는 객체를 끄집어내기 위해서 쓰인 것입니다. 파스칼과 자바의 경우도 대동소이한데, Application.CreateForm(MainForm, TMainForm); System.println("Hello, World"); 위에서 'Application', 'System'은 모두 받는이미여, 나머지 부분은 지시가 됩니다. 괄호 속에 있는 MainForm, TMainForm, "Hello, World!"는 모두 인자 이며, CreateForm과 println은 모두 길표입니다. 이처럼 각 언어마다 형성되는 문법은 다르지만 객체지향의 개념 적용은 같다 는 것을 알 수 있습니다. 이것이 C++, Java, Object Pascal이 '객체지향 언 어'라고 불릴 수 있는 중요한 요소가 됩니다. 즉 언어의 문법은 다르지만 모 두 '객체지향'이라는 개념이 적용되는 것이지요. ----------------------------------------------------------- ---<잠깐!>----------------------------------------------------------- 쇠마디 지시와 바탕글의 기독성 다른 언어에는 Smalltalk에서와 같이 "외마디 지시", "겹마디 지시", "쇠마 디 지시"라는 개념이 없습니다. 대부분 객체에 딸린 함수(function)나 절차 (procedure)를 부른다는 개념을 가지고 있습니다. 그래서 객체에게 넘겨주어 야 할 인자가 많을 때에는 Smalltalk의 쇠마디 지시가 훨씬 바탕글을 읽기 좋게 만듭니다. aSubString := originalString.Copy( 10, 5 ); 보다는 aSubString := original copyFrom: 10 to: 15 쪽이 바탕글을 쉽게 읽을 수 있습니다. 또한 between(5, 1, 10); 보다는 5 between: 1 and: 10 이 훨씬 읽기가 쉽습니다. 너무 길어 보인다고 생각하시는 분이 계시다면 저 는 이런 말씀을 드리고 싶습니다. 바탕글(source code)은 한 번 쓰여지고 여 러번 읽혀집니다. 그러므로 바탕글이 길어져도 읽기가 편하면 유지하고 관리 하는데 매우 편합니다. 헝가리안 표기법을 왜 사용하는지를 생각해 보세요. ----------------------------------------------------------- 계속... 제 목:[강좌] Smalltalk 배우기 #10 관련자료:없음 [19] 보낸이:김찬홍 (안드래아) 1998-12-09 21:27 조회:174 Smalltalk 배우기 #10 1998. 12. 9. 김찬홍 mailto:andrea92@hitel.net ====================================== 2. 객체들과 나누는 이야기 2.1. 객체? 2.2. 몸으로 느끼기 2.2.1. 글토막 가늠하기 2.2.2. 셈! 셈! 셈! 2.2.3. 실체와 갈래 2.2.4. 지시에 대하여 →2.2.5. 지시의 우선순위 ...... ======================================= 2. 객체들과 나누는 이야기 ------------------------------------ 2.2. 몸으로 느끼기 ~~~~~~~~~~~~~~~~~~ 2.2.4. 지시의 우선 순위 ----------------------- 바로 앞 나눔에서 우리는 Smalltalk의 지시를 세 가지의 서로 다른 종류로 나눌 수 있다는 것을 공부했습니다. 무엇 무엇이 있었습니까? 5 class 외마디 지시(unary message) 5 + 2 겹마디 지시(binary message) 5 between: 1 and: 10 쇠마디 지시(keyword message) 또한 외마디 지시를 나타내기 위해서 사용하는 길표를 "외마디 길표"(unary selector), 겹마디 지시를 나타내려면 "겹마디 길표"(binary selector)를, 쇠마디 지시를 나타내기 위해서 사용하는 길표는 "쇠마디 길표"(keyword selector)라고 부른다는 것도 공부했습니다. 우리가 Smalltalk로 문제를 풀기 위해서는 위에서 설명한 여러 종류의 지시 를 섞어서 써야 합니다. 이 말은 글토막 하나가 한 개의 지시로 이루어진 것 이 아니라 두 개 이상의 지시를 함께 포함하고 있을 수 있다는 말입니다. 가 장 간단한 예를 들면 1 + 2 * 3 이 있습니다. 위의 경우 '+'와 '*'라는 두 개의 길표(selector)가 있기 때문 에, 결국 위의 글토막은 두 개의 지시를 포함하고 있다는 것을 알 수 있습니 다. 앞에서 우리는 '+', '-', '*', '/'와 같은 겹마디 지시를 두 개 이상 사용했 을 때 1 + 2 * 3 위의 글토막을 가늠하면 산수에서는 '7'이 되지만 Smalltalk에서는 '9'가 된 다고 했습니다. 즉 겹마디 지시가 두 개 이상 있을 때에는 왼쪽에서부터 오 른쪽으로 처리된다는 규칙을 공부했습니다. 그렇다면 종류가 서로 다른 외마디 지시와 겹마디 지시, 그리고 쇠마디 지시 를 한꺼번에 사용했을 때에는 어떤 식으로 처리될까요? 이번 나눔에서 알아 볼 중요한 문제는 바로 이러한 여러 가지 지시들의 우선 순위(precedence)입 니다. 이야기를 진행하기 전에, 우선 정수 갈래(Integer class)에 속한 객체에게 보낼 수 있는 외마디 길표 두 개를 알아보겠습니다. 다음 글토막을 펴 보십시오. 1 negated ☞ -1 -1 negated ☞ 1 0 negated ☞ 0 123 negated ☞ -123 길표 "negated"는 이 지시를 받는이(receiver)의 부호(符號)를 바꾸어줍니 다. 즉 양수에게 "negated"를 보내면 음수를 남기고, 음수에 "negated"를 보 내면 양수를 남깁니다. '0'의 경우에는 부호가 없기 때문에 "negated" 지시 에 대해서 아무런 변화 없이 그대로 '0'을 남깁니다. 다음은 우리가 이미 "1.3"마디에서 가늠해 본 길표 "factorial"입니다. 0 factorial ☞ 1 1 factorial ☞ 1 2 factorial ☞ 2 3 factorial ☞ 6 4 factorial ☞ 24 5 factorial ☞ 120 6 factorial ☞ 720 길표 "factorial"은 받는이에 대한 계승(階乘, x!)을 구합니다. 예를 들어 "6 factorial"은 "5 * 4 * 3 * 2 * 1"과 같은 결과값을 남깁니다. 그래서 "200 factorial"의 경우는 결과값이 기하급수적으로(물론 수학적으로는 틀린 말이겠지만) 늘어나게 되는 것입니다. 시험삼아 "2000 factorial"이라는 글 토막을 펴 봅시다. 과연 Smalltalk가 "200"도 아닌 "2000"의 계승을 구할 수 있을까요? :) 자, 앞서 우리는 겹마디 길표를 두 개 사용하여 다음과 같은 글토막을 만들 어 편 일이 있습니다. 1 + 2 * 3 ☞ 9 그렇다면 겹마디 길표에서 했던 것처럼, 외마디 길표로 나온 결과에 다시 외 마디 길표를 적용할 수 있을까요? 다음의 글토막을 펴 봅시다. 1 negated negated ☞ 1 결과값으로 "1"이 남겨졌습니다. 보다시피 위의 글토막은 외마디 지시를 두 개 이상 사용하는 것이 가능하다는 것을 보여줍니다. 그럼 어째서 위의 글토막이 "1"이라는 결과값을 낼 수 있었을까요? 가장 쉽 게 알 수 있는 방법은, Smalltalk가 하는 방식대로 우리가 스스로 글토막을 가늠해 보는 것입니다. 1 negated negated → ~~~~~~~~~ -1 negated → ~~~~~~~~~~~~~~~~~ 1 먼저 "1 negated"가 가늠되고 결과값으로 '-1'이 남게 됩니다. 그러므로 결 국은 "-1 negated"가 되어서 최종 결과값은 "1"이 되는 것입니다. 위에서 볼 수 있듯이 외마디 지시를 연달아 사용하면 겹마디 지시의 경우와 마찬가지로 __왼쪽에서부터 오른쪽으로__ 처리되는 것을 볼 수 있습니다. 그렇다면 이번에는 factorial과 negated 길표를 섞어서 아래처럼 글토막을 만들어 봅시다. 3 factorial negated ☞ -6 결과값으로 "-6"이 나왔는데, 위의 글토막 역시 우리가 스스로 가늠해보도록 합시다. 3 factorial negated → ~~~~~~~~~~~ 6 negated → ~~~~~~~~~~~~~~~~~~~ -6 위의 경우는 먼저 왼쪽의 "3 factorial"이 가늠됩니다. 그 결과 "6"이라는 결과값이 나오고, "6 negated"가 되어서 "-6"이라는 결과값을 내게 됩니다. 즉 외마디 길표나 겹마디 길표 모두 왼쪽에서부터 오른쪽으로 차례로 길표를 처리합니다. 왼쪽에 있는 길표를 처리한 다음 그 결과를 다시 그 다음에 있 는 길표를 이용하여 처리하는 것입니다. 지금까지는 왼쪽에 있는 길표부터 차례로 처리되었습니다. 그럼 이번에는 종 류가 다른 두 개의 길표를 섞어서 사용해 봅시다. 우선 외마디 길표와 겹마 디 길표를 아래처럼 섞어서 써 보면 어떤 결과값을 얻게될까요? 1 negated + 2 ☞ 1 위의 경우는 "1 negated"가 가늠되어 '-1'을 남기고 결과적으로 "-1 + 2"가 되어서 "1"이라는 결과값이 남게 되었습니다. 여기까지 실행된 것으로 보아 서는 왼쪽 길표가 처리되고 난 다음에 오른쪽 길표가 처리되는 규칙이 똑같 이 적용되는 듯 합니다. 그러나.... 1 + 2 negated ☞ -1 어라? 길표 "negated"의 위치를 바꾸면 우리가 생각하는 결과가 나오지 않 았습니다. 만약 왼쪽에 있는 길표부터 차례로 처리한다면 위의 글토막은 "-3"이라는 결과값을 내야 마땅합니다. 그러나 답은 "-1"입니다. 그럼 왜 이 런 일이 일어날까요? 이제부터 머리가 조금 복잡해지기 시작하는데.... Smalltalk가 위의 글토막을 만나면 아래처럼 가늠합니다. 1 + 2 negated → ~~~~~~~~~ 1 + -2 → ~~~~~~ -1 모든 길표(selector)에는 길표의 종류에 따라 우선권(priority)이 매겨져 있 습니다. 이 경우에는 겹마디 지시보다 외마디 지시가 더 높은 우선권을 갖고 있습니다. 그래서 1 + 2 negated 의 경우는 겹마디 길표 "+"와 외마디 길표 "negated", 이렇게 두 종류의 길 표가 섞여 있기 때문에 외마디 길표인 "negated"가 먼저 처리되는 것입니다. 그럼 다음의 글토막에서 제일 먼저 가늠되는 부분은 어디겠습니까? 1 + 2 + 3 factorial 겹마디 길표보다 우선권이 높은 "factorial"이 먼저 가늠될까요, 아니면 가 장 왼쪽에 있는 "+" 길표가 먼저 가늠될까요? Smalltalk는 아래와 같이 가늠 합니다. 1 + 2 + 3 factorial → ~~~~~ 3 + 3 factorial → ~~~~~~~~~~~ 3 + 6 → ~~~~~~~~~ 9 위의 경우는 또 맨 왼쪽에 있는 '+'가 먼저 처리되었습니다. "factorial"은 왼쪽의 '+' 길표가 처리되고 난 뒤에 처리되었습니다. 그렇다면 단순히 우선 권이 높다고 해서 먼저 처리되는 것만은 아니라는 이야기인데.... Smalltalk에서 여러 종류의 길표들이 있을 때에는 다음과 같은 규칙으로 처 리됩니다. << 우선권 규칙 >> ----------------------------------------------------------- * 글토막의 맨 왼쪽부터 길표를 하나씩 꺼내서 바로 인접한 오른쪽의 길표와 우선권을 비교한다. * 두 길표의 우선권이 같거나 왼쪽 길표의 우선권이 높으면, 왼쪽 길표 를 먼저 처리한다. * 오른쪽 길표의 우선권이 왼쪽 길표보다 높다면, 이제는 오른쪽 길표 와 그 바로 옆에 있는 길표의 우선권을 비교하여 위와 같이 처리한다. * 이 작업을 글토막이 끝날 때까지 되풀이한다. ----------------------------------------------------------- 위와 같은 규칙을 "우선권 규칙"이라고 부르는데, 이는 Smalltalk가 글토막 을 가늠해야 할 상황이라면 언제든지 어디에서건 적용되는 규칙이므로 잘 기 억해야 할 필요가 있습니다. "1 + 2 + 3 factorial"에서 왜 "factorial"이 아니라 "+"가 먼저 처리되었는 지 이해가 되십니까? 바로 글토막의 왼쪽에서부터 길표를 비교하여 그 중에 서 우선권이 높은 것을 먼저 처리해 나가기 때문입니다. 위의 경우 처음 두 개의 길표는 "+"와 "+"이고 우선권이 같으므로 왼쪽에 있는 "+"가 먼저 처리 된 것입니다. 그래서 "1 + 2"가 먼저 계산된 것이지요. 그 결과 "3 + 3 factorial"이 되었을 것이고, 이번에는 앞서와는 반대로 "+"와 "factorial" 중 외마디 길표인 "factorial"이 먼저 가늠되어 "3 + 6"이 됩니다. 결국 결 과값 "9"가 남게되겠지요. 이제 각각의 길표가 어떤 우선 순위를 갖는지 아래에 정리해 두겠습니다. 우선권 길표 ----------------------------------------------------------- 1 외마디 길표(unary selector) 2 겹마디 길표(binary selector) 3 쇠마디 길표(keyword selector) ----------------------------------------------------------- 위의 표에서 정리한대로, "외마디 길표"가 가장 높은 우선권을 가지고 있으 며, 다음이 "겹마디 길표", 마지막으로 "쇠마디 길표"가 가장 낮은 우선권을 갖게 됩니다. Smalltalk를 공부하면서 반드시 알고 넘어가야 할 중요한 사항이 몇 가지 있 는데, 앞서 설명했던 갈래(class)와 실체(instance)의 관계를 알아야하고, 지금 설명하고 있는 "우선권 규칙" 역시 매우 중요한 것이기 때문에 소흘이 넘어갈 수 없습니다. 우선권 규칙을 제대로 알고 있어야만 여러분이 객체에 게 마음대로 지시를 내릴 수 있고, 또 다른 사람이 써 놓은 바탕글(source code)도 틀리지 않고 읽을 수 있기 때문입니다. 이제 조금 복잡한 보기를 들어봅시다. 아래 보기는 외마디 길표, 겹마디 길 표, 그리고 쇠마디 길표 등 모든 종류의 길표가 다 등장합니다. 25 between: 10 + 3 factorial and: 5 factorial + 3 여러분이 "우선권 규칙"을 제대로 이해하고 있다면 위의 글토막이 어떤 순서 로 가늠되는지를 알아맞힐 수 있어야 합니다. 이제 머릿속으로 위의 글토막 을 차근차근 가늠해 봅시다. 그리고 아래 나와 있는 정답과 어느 정도 비슷 한지를 살펴보도록 합시다. 25 between: 10 + 3 factorial and: 5 factorial + 3 → ~~~~~~~~~~~ 25 between: 10 + 6 and: 5 factorial + 3 → ~~~~~~ 25 between: 16 and: 5 factorial + 3 → ~~~~~~~~~~~ 25 between: 16 and: 120 + 3 → ~~~~~~~~~~~~~~~ 25 between: 16 and: 123 → ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ true 복잡합니까? 여러분이 생각한 것과 비슷했습니까? 자, 위의 순서를 따라가면 서 좀 더 꼼꼼하게 따져봅시다. 첫 번째 줄을 봅시다. 25 between: 10 + 3 factorial and: 5 factorial + 3 위에서 첫 번째로 나오는 길표는 무엇입니까? 쇠마디 길표인 "between:and:" 입니다. 쇠마디 길표의 경우는 여러 개의 열쇠말이 모여서 하나의 길표를 이 루는데, 글토막을 가늠할 때에는 하나의 열쇠말을 길표 하나처럼 생각해도 무방합니다. 그러므로 여기서는 "between:" 글쇠말이 처음으로 나오는군요. 그럼 두 번째 나오는 길표는 무엇입니까? 겹마디 길표인 "+" 입니다. 처음 길표는 쇠마디 길표이고, 두 번째는 겹마디 길표입니다. 어느 쪽이 우 선권이 높습니까? 겹마디 길표가 우선권이 높습니다. 그러므로 "between: and:"보다 "+"쪽이 우선권이 높기 때문에 이 경우 "+" 길표가 먼저 처리되어 야 합니다. 이제 "+"를 처리하기 위해서 또다시 바로 옆에 있는 길표와 우선권을 비교해 야 합니다. "+" 다음에 있는 길표는 무엇입니까? 외마디 길표 "factorial"입 니다. 그럼 "+"보다 우선권이 높은 "factorial"이 먼저 처리되어야 합니다. "factorial" 오른쪽에는 무엇이 있습니까? 쇠마디 길표 "between:and:"의 두 번째 열쇠말인 "and:"가 있습니다. 이 열쇠말 역시 쇠마디 길표의 한 부분이 므로, "factorial"의 우선권이 높습니다. 결과적으로 "factorial"이 맨 처음 처리되어야 합니다. 그렇다면 "factorial"의 지시를 받는이는 누구입니까? 네, 정수 "3"입니다. 그래서 정수 객체 "3"에 "factorial"지시가 내려지고, 객체는 결과값으로 "6"을 냅니다. 모진 고생 끝에 "factorial"이 처리되어 얻어진 결과는 다음과 같습니다. 25 between: 10 + 6 and: 5 factorial + 3 이제 위의 글토막을 다시 왼쪽에서부터 가늠합니다. 처음 길표는 "between:and:"의 열쇠말인 "between:"이고, 두 번째는 "+"입니 다. 우선권이 높은 "+"가 먼저 처리되어야 합니다. "+"를 처리하기 위해서 바로 옆에 있는 길표를 찾습니다. 열쇠말 "and:"로군 요. 그렇다면 겹마디 길표인 "+"의 우선권이 높으므로 "+"를 처리합니다. "+" 길표의 지시를 받는 객체는 무엇입니까? 이 경우 "10"이 됩니다. 인자는 방금 "factorial"에 의해서 처리된 "6"입니다. 그래서 정수 객체 "10"에게 "+ 6"이라는 지시가 내려지고 다음과 같은 결과를 얻게 됩니다. 25 between: 16 and: 5 factorial + 3 자, 위의 결과를 보면 두 개의 열쇠말 중 "between:"열쇠말에 걸린 인자는 모두 처리되어 하나의 객체 "16"이 되었음을 알 수 있습니다. 그렇기 때문에 이제는 "and:" 열쇠말에 걸려있는 인자를 처리해야 합니다. 처음 등장하는 길표는 "between:and:"의 두 번째 열쇠말인 "and:"입니다. 바 로 오른쪽에 있는 길표는 "factorial"이군요. 이 경우 "factorial"이 높은 우선권을 갖기 때문에 먼저 처리됩니다. 보다나마 "factorial"은 외마디 길표이므로 오른쪽 길표를 볼 것도 없이 그 냥 처리해 버리면 됩니다. 여기서 "factorial" 길표로 지시를 받는 객체는 정수 "5"입니다. 그래서 아래와 같은 결과가 나옵니다. 25 between: 16 and: 120 + 3 어느새 글토막이 매우 간단해 졌습니다. 앞서 한 것처럼 앞의 "between:"에 걸린 객체는 하나 뿐이므로, 뒤의 "and:" 열쇠말에 걸려있는 나머지 인자를 풀어봅시다. 이제부터는 아주 쉽습니다. 이 경우 남아있는 길표는 열쇠말 "and:"와 겹마디 길표 "+"이므로 당연히 "+"가 먼저 처리됩니다. 아울러 "+"는 이 글토막에서의 마지막 길표이므로 "+"의 다음 길표를 찾을 필요가 없겠지요. "+" 지시를 받는이는 "120"이며 인자는 "3"입니다. 정수 객체 "120"에 "+ 3"이 지시되었고, 그 결과가 다음 처럼 나왔습니다. 25 between: 16 and: 123 이제 남아있는 길표는 "between:and:" 뿐이므로 이 길표를 처리하면 글토막 을 모두 가늠한 셈이 됩니다. 정수 객체 "25"에게 "between: 10 and: 123"이라는 지시가 내려지고, 객체 "25"는 "16"과 "123" 사이의 값을 가지고 있기 때문에 당연히 "true"를 결과 값으로 냅니다. 이로써 글토막 하나를 다 풀었습니다. 확실히, 처음 Smalltalk를 배우는 사람들에게는 복잡한 글토막을 머릿속으로 풀어보는 일이 쉽지만은 않습니다. 그러나 머릿속으로 글토막을 풀어보는 것 은 "우선권 규칙"을 익히는데 매우 큰 도움이 됩니다. 나아가 이렇게 익힌 우선권 규칙은 여러분이 어떤 객체에게 복잡한 지시를 내려야할 때 위력을 발휘합니다. 어떤 글토막이든지 __한 번에 하나씩__ 길표가 처리되어 지시가 내려집니다. 그러므로 앞에서 우리가 헀던 것처럼 왼쪽에서부터 길표들의 우선권을 차근 차근 하나씩 비교하고 어떤 길표가 처리될지를 생각한다면 어렵지 않게 글토 막을 풀어낼 수 있을 것입니다. 여러분이 글토막 풀이를 좀 더 연습할 수 있도록 아래에 몇 개의 글토막을 준비해 보았습니다. 여러분 스스로 글토막을 풀어서 결과를 가늠해 보십시 오. 그런 다음 Smalltalk에 글토막을 쳐 넣고 펴서, 여러분이 풀어낸 결과값 과 같은지를 확인해 봅시다. 만약 여러분이 생각한 결과와 일터에서 편 결과 가 다르다면 어디서 실수를 했는지를 찾아보기 바랍니다. 1 + 2 + 3 factorial 10 factorial factorial + 1 1 + 2 factorial negated 1 between: 0 + 0 and: 2 factorial 1 negated between: 0 + 1 and: 5 2 factorial + 3 factorial 아래에 위의 글토막에서 제일 먼저 처리되는 지시와 그 지시를 받는 객체를 밑줄로써 표시해 놓았습니다. 여러분이 글토막을 가늠하는데 도움이 되기를 바랍니다. 만약 여러분이 생각한 것과 다르다면, "우선권 규칙"을 제대로 이 해하지 못한 것이기 때문에, 번거롭더라도 글을 처음부터 다시 한 번 읽어보 도록 합시다. 1 + 2 + 3 factorial ~~~~~ 10 factorial factorial + 1 ~~~~~~~~~~~~ 1 + 2 factorial negated ~~~~~~~~~ 1 between: 0 + 0 and: 2 factorial ~~~~~ 1 negated between: 0 + 1 and: 5 ~~~~~~~~~ 2 factorial + 3 factorial ~~~~~~~~~~~ 자, 마지막으로 알아볼 것은 "괄호"에 대한 것입니다. 우리는 "2.2" 마디에 서 괄호에 대한 이야기를 하면서 다음의 글토막을 가늠해 본 적이 있습니다. 1 + (2 * 3) → 1 + 6 ☞ 7 즉 괄호를 둘러준 식이 먼저 계산된 다음 나머지 식이 계산됩니다. 그렇다면 "우선권 규칙"은 괄호에 대해서 어떤 영향을 받게 될까요? 답은 아주 간단합니다. 괄호가 있는 글토막의 경우도 마찬가지로 똑같이 우 선권 규칙이 적용됩니다. 그러나 다음의 규칙 하나가 더 첨가됩니다. ----------------------------------------------------------- * 우선권에 의해서 처리되는 길표의 인자가 괄호를 둘러쓰고 있으면 그 괄호 안에 있는 식을 모두 풀어서 하나의 객체로 만든 뒤에 해당 길표 가 처리된다. ----------------------------------------------------------- 말로 하니까 매우 어려워 보이지만, 다음의 보기를 보면 어려운 규칙이 아니 라는 것을 금방 알게됩니다. "1 + (2 * 3)"의 경우를 생각해 봅시다. 일단 괄호 밖에는 "+" 길표밖에 없 습니다. 그러므로 이 길표를 처리해야할텐데, "+" 길표의 인자가 괄호를 둘 러쓰고 있습니다. 그러므로 "+"를 처리하여 "1"에게 지시를 보내려면 괄호를 풀어야 합니다. 따라서 괄호 안에 있는 "*" 길표가 먼저 처리된 것입니다. 좀 더 복잡한 예를 생각해 봅시다. 1 + 2 * (3 - 4 + (5 * 6)) + 3 위의 경우 괄호가 있기는 하지만 똑같이 우선권 규칙을 적용합니다. 그럼 "+"와 "*" 길표를 보면 되는데, 두 길표의 우선권이 같으므로 "+"가 먼저 처 리됩니다. 3 * (3 - 4 + (5 * 6)) + 3 이제 다시 글토막을 가늠해 보면, 괄호 밖에 있는 길표들만 생각해 볼 때, 처음 나오는 길표는 "*"이고 다음으로 "+"가 나옵니다. 역시 두 길표의 우선 권이 같으므로 "*"가 먼저 처리되어야 합니다. 그런데... "*" 길표는 "3"에게 지시를 보내는데, 인자로 "(3 - 4 + (5 * 6))"을 가지고 있습니다. 그런데 이 인자가 괄호를 둘러쓰고 있으므로 "*"가 처리되려면 먼 저 괄호를 풀어야 합니다. 자, 잠시 다른 것은 생각하지 말고 괄호 안에 있는 3 - 4 + (5 * 6) 만 생각합시다. 이 경우 괄호 안에 있는 길표는 생각하지 말고 밖의 길표만 살펴보면 "-", "+" 이렇게 두 개가 있습니다. 우선권 법칙에 의해서 앞에 나 온 "-"가 먼저 처리되면 -1 + (5 * 6) 의 결과가 남게 됩니다. 이제 "+"를 처리해야하는데 역시 괄호가 걸립니다. 그래서 괄호를 풀어버리면 -1 + 30 → 29 가 남게 됩니다. 이제 괄호를 다 풀고 남은 "29"를 원래 식에 그대로 붙이면 3 * 29 + 3 이 됩니다. 이 상태에서 두 개의 길표는 모두 우선권이 같으므로 "*"가 먼저 처리될 것이고 따라서 87 + 3 → 90 을 결과값으로 얻게 됩니다. 정리하면, 괄호가 들어있는 글토막이라도 보통 다른 글토막처럼 우선권 규칙 을 적용합니다. 이 때 괄호 안에 들어있는 길표들은 무시해 버립니다. 그러 면 훨씬 쉽게 생각할 수 있습니다. 즉 괄호를 하나의 덩어리(=수) 정도로 생 각하라는 말입니다. 그리고 우선권 규칙에 의해서 그 괄호가 길표의 인자가 될 때 해당 괄호를 풀어버리면 쉽게 해결할 수 있습니다. Smalltalk보다 훨 씬 더 복잡한 "연산자의 우선 순위 규칙"도 수학을 배울 때 잘 써먹던 여러 분이기 때문에 Smalltalk의 "지시 우선권 규칙"은 아무 것도 아니라는 생각 이 들 것입니다. 맞습니까? :) 이번 나눔에서는 여러 종류의 길표가 섞여있는 지시가 어떻게 처리되는지에 대해서 공부했습니다. 앞으로 여러분이 Smalltalk 프로그래밍을 쓰게 될 때 매우 중요한 내용이기 때문에 조금 지루하실 거라는 생각을 하면서도 글이 길어지게 되었습니다. 여하튼 "갈래와 실체"의 관계를 파악하는 것처럼 "우 선권 규칙"을 제대로 파악하는 것도 매우 중요하다는 것을 기억해 두시기 바 랍니다. ---<잠깐!>----------------------------------------------------------- 다른 언어에서는...? 설명이 길어지다 보니 "우선권 규칙"에 대해 매우 어렵게 느끼시는 분들이 있을 것 같은데, 실제로 "우선권 규칙"은 매우 간단합니다. 여러분은 "우선 권 규칙"보다 몇 배나 더 복잡한 C/C++, Java, Object Pascal과 같은 복잡한 언어의 문법도 소화해 내지 않았습니까? 물론 지금 이 글을 읽는 분께서 프 로그래밍에 경험이 없으시거나 아주 적다면, 여러분은 "우선권 규칙"보다 더 어려운 문법들이 다른 언어에 존재한다는 것을 위안(?)으로 삼아서 조금 힘 들더라도 "우선권 규칙"을 공부해 두는 것이 좋습니다. 할 수만 있다면 C++ 언어에서 제공하는 40여개의 연산자를 우선순위별로 정리해 놓은 표를 첨부 해드리고 싶지만, 제 힘이 너무 달리는군요. 누가 올려주실 분 없어요???? 어쨌건 "우선권 규칙"은 Smalltalk의 문법을 아주 간단하게 만들면서 동시 에 매우 자유로운 표현을 할 수 있도록 만들어주는 거라고 저는 생각합니다. 여러분은 동의하지 않으십니까? :) ----------------------------------------------------------- 계속... 제 목:[강좌] Smalltalk 배우기 #11 관련자료:없음 [20] 보낸이:김찬홍 (안드래아) 1998-12-11 17:59 조회:169 Smalltalk 배우기 #11 1998. 12. 11. 김찬홍 mailto:andrea92@hitel.net ====================================== 2. 객체들과 나누는 이야기 2.1. 객체? 2.2. 몸으로 느끼기 2.2.1. 글토막 가늠하기 2.2.2. 셈! 셈! 셈! 2.2.3. 실체와 갈래 2.2.4. 지시에 대하여 2.2.5. 지시의 우선순위 a→2.2.6. 고급 셈! 셈! 셈! ...... ======================================= 2. 객체들과 나누는 이야기 ------------------------------------ 2.2. 몸으로 느끼기 ~~~~~~~~~~~~~~~~~~ 2.2.6. 고급 셈! 셈! 셈! ----------------------- Smalltalk에는 "정수"(integer) 말고도 "분수"와 "소수"라고 하는 두 개의 수 갈래가 있습니다. 이번 나눔에서는 이들 새로운 두 개의 갈래가 어떤 것 이며, 이 갈래에 속한 객체들은 어떤 지시를 알아들을 수 있는지에 대해서 공부합니다. 아마 이번 나눔을 끝내게 되면 여러분은 Smalltalk 프로그래밍 에서 수를 처리하는 대부분의 사항에 대해서 공부했다고 할 수 있습니다. 우리는 "2.2.2" 나눔에서 정수 갈래에 속하는 여러 개의 실체(instance)에 대해서 다양한 지시를 내려보았습니다. 기본적으로 정수 객체들이 이해할 수 있는 지시는 어떤 것이 있었습니까? 아래에 지금까지 우리가 정수에게 여러 가지 지시를 내리기 위해 사용했던 길표들을 정리해 보았습니다. ---------------------------------------------------------- 길표 설명 ---------------------------------------------------------- x + y 두 수를 더한다 x - y x에서 y를 뺀다. x * y 두 수를 곱한다. x / y x를 y로 나눈다. x // y x를 y로 나눈 몫을 얻는다. x \\ y x를 y로 나눈 나머지를 구한다. x negated x의 부호를 바꾼다. x factorial x의 계승(x!)을 구한다. ---------------------------------------------------------- "2.2.2"에서 우리는 이들 대부분의 길표에 대해서 다루어보았습니다. 그리고 "우선권 규칙"을 공부할 때에도 이러한 여러 가지의 지시를 내렸었습니다. 그러나 유독 우리는 나눗셈에 대해서는 많은 예를 들지 않았습니다. 그것은 나눗셈이 덧셈, 뺄셈, 곱셈 등의 다른 계산과는 달리 좀 유별난 구석을 가지 고 있는, 한 마디로 말하면, 천덕꾸러기이기 때문입니다. 자, 그럼 이제부터는 이 천덕꾸러기 나눗셈에 대해서 집중적으로 알아보도록 합시다. 우선 다음 글토막을 펴 봅시다. 2 / 2 ☞ 1 8 / 4 ☞ 2 10 / 5 ☞ 2 120 / 5 ☞ 24 보다시피 나눗셈을 하기 위해서는 객체에게 "/" 길표를 사용하여 지시를 내 리면 됩니다. 그런데 위에서 가늠했던 네 개의 수식은 모두 나누어 떨어지는 것들이었습니다. 그러나 나눗셈은 반드시 딱 나누어 떨어지라는 법은 없습니 다. 다음 글토막을 펴 봅시다. 이 글토막은 나누어떨어지지 않는 식입니다. 1 / 2 ☞ 1/2 어라? "1 / 2"를 가늠했더니 결과값으로 "1/2"가 나왔습니다. 이게 무엇일까 요? 일단 정수 "1"은 "/ 2"라는 지시를 받아서 "1/2"라는 객체를 내놓기는 했습니다. 그럼 도대체 "1 / 2"라는 글토막을 가늠해서 나온 "1/2"라는 녀석 은 도대체 어떤 갈래에 속할까요? 다음과 같이 해 봅시다. (1 / 2) class ☞ Fraction 위에서 왜 괄호를 사용했는지 아시겠습니까? 바로 앞 나눔에서 설명했듯이 외마디 길표인 "class"가 먼저 실행되는 것을 막기 위함입니다. (잘 모르겠 으면 앞 나눔부터 글을 다시 읽으시는 수 밖에....) "Fraction"을 사전에서 찾아보면 바로 "분수"(分數)라고 되어있습니다. 즉 "1 / 2"처럼 딱 나누어떨어지지 않는 경우, 정수 객체는 결과값으로 분수를 남긴 것입니다. 결과적으로 "1 / 2"를 가늠해서 나온 "1/2"는 "이 분의 일" 라고 읽는 분수인 것입니다. 물론 수학에서 분수를 쓸 때에는 1 - 2 처럼 쓰겠지만, 한 줄에 분수를 나타내고 싶을 때에는 분자와 분모 사이에 빗금표(/)를 넣어서 씁니다. 그러므로 "1/2"는 틀림없이 분자와 분모를 가지 고 있는 "분수"입니다. 그렇다면 여기서 한 가지 의문이 생깁니다. 언뜻 보면 분수 "1/2"와 식 "1 / 2"는 매우 비슷해 보입니다. 물론 "1 / 2"를 가늠하면 "1/2"가 되기 때문에 둘이 같건 다르건 무슨 상관이냐고 생각하는 사람이 있을는지 모르겠습니다. 그러나 "1/2"가 정말 완전한 분수냐 아니냐는 매우 중요합니다. 만일 "1/2" 가 분수라면 이는 "1/2"도 어엿한 한 개의 객체가 될 것입니다. 그러나 만약 "1/2"가 분수가 아니라 "1 / 2"를 다르게 쓴 것에 불과하다면? 즉, 이것은 "1"이라는 객체에게 "/2"라는 지시를 보내는 글토막에 지나지 않는다는 말입 니다. 어렵게 생각할 것 없이 일단 아래 글토막을 펴서 실험을 해 봅시다. 1/2 class ☞ "발자취 창 열림" 만일 "1/2"가 하나의 객체라면 이 객체에게 "class"라는 지시를 내릴 수 있 어야 옳습니다. 그러나 결과는 그렇지 않았습니다. 엉뚱하게도 발자취 창이 열리면서 "SmallIntege는 #divideIntoInteger:를 알아듣지 못합니다"라는 알 림글을 받게 됩니다. 도대체 위의 글토막에 SmallInteger라고는 없어 보이는 데.... 더구나 우리는 "divideIntoInteger:"라는 지시를 내린 적이 없는데 어찌 된 일일까요? 자, 덩이를 씌워 가늠했던 글토막을 자세히 살펴봅시다. 분명히 우리가 처음 일터(workspace)에 입력한 글토막과 비교해 보면 무언가 다른 것이 보일 것 입니다. 무엇일까요? 네, 바로 "색깔"입니다. 우리는 글토막을 쳐 넣을 때 색깔에 대해서는 전혀 신경 쓰지 않았습니다. 그러나 Smalltalk가 글토막을 가늠하자마자 각각의 말마디에 색을 입히기 시작했습니다. 위의 경우 "1", "2"는 보라색이, "/"와 "class"는 파란색이 입혀졌습니다. 그럼 잠시 분수 얘기는 젖혀두고, 다음 몇 개의 글토막을 가늠해 봅시다. 이번에는 결과값보 다는 가늠된 글토막에 Smalltalk가 어떻게 색깔을 입히는지에 주의를 기울이 고 보기 바랍니다. 5 class "5"는 보라색, "class"는 파란색. 5 + 2 "5", "2"는 보라색, "+"는 파란색. 5 between: 1 and: 10 "5", "1", "10"은 보라색, "between:", "and:"는 파란색. 잘 보면 Smalltalk가 가늠한 글토막에 색을 입히는데는 어떤 규칙이 있어 보 입니다. 무슨 규칙이 숨어있을까요? 아마 한참 전부터 눈치를 채신 분들도 계실지 모르겠습니다. 바로 글토막을 이루는 여러 가지 성분들을 각기 다른 색으로 표시하는 것입니다. 글토막은 보통 객체와 길표로 구성되어 있습니다. 바로 Smalltalk에서 객체는 보라색 으로, 길표는 파란색으로 표시한 것입니다. 이렇게 글토막을 구성하는 여러 가지 성분들에 각기 다른 색을 입혀서 바탕글을 읽기 쉽게 만들어주는 기능 을 "문법 돋이"(syntax highlight)라고 부르는데, 바로 우리가 사용하고 있 는 Dolphin Smalltalk가 이 문법돋이를 지원해 주는 것입니다. 그러므로 글 토막을 보면 어떤 것이 객체이고 어떤 것이 길표인지를 좀 더 쉽게 확인할 수 있습니다. ---<잠깐!>---------------------------------------------------------- 요즘 출시되고 있는 대부분의 개발 환경들이 문법 돋이를 지원합니다. 그러 나 처음부터 모든 개발환경이 문법돋이를 제공하지는 않았습니다. 그것은 우 리가 지금 사용하고 있는 Smalltalk도 마찬가지인데, 최근에 들어서 Smalltalk에도 문법돋이의 바람이 불고 있는 듯 합니다. 제가 써 본 Smalltalk 시스템은 Smalltalk Express, Smalltalk/V, Smalltalk MT, Dolphin Smalltalk 정도입니다. 그 중에서 정확하고 확실하게 문법돋이 를 제공하는 환경은 Dolphin 뿐이었습니다. 제가 Smalltalk를 배우기 위해서 여러 가지 환경을 탐색했지만, 그래도 Dolphin을 선택한 이유는 이처럼 만들 어 놓은 바탕글을 읽기가 매우 쉬웠다는 것도 하나의 큰 이유가 됩니다. ---------------------------------------------------------- 다시 분수 얘기로 되돌아옵시다. 앞서 우리는 다음과 같은 글토막을 가늠해 보았습니다. 1/2 class 물론 위의 경우 발자취 창이 나타나기는 했지만, 분명히 Smalltalk는 글토막 을 가늠하기 위해서 나름대로 해석을 하기는 했습니다. 위의 경우 "class"는 누가 머래도 객체에게 보내지는 길표이기 때문에 파란색으로 표시되었습니 다. 그러나 '1/2'의 "/"을 자세히 보면 역시 파란색으로 표시됨을 알 수 있 습니다. 이 말은 무슨 말일까요? 바로 '1/2'의 '/'는 "길표"로 해석했다는 것을 보여줍니다. 결국 우리는 "1 / 2"나 "1/2" 모두 똑같은 계산식임을 알 수 있습니다. 단지 길표 앞뒤에 빈칸이 있는지 없는지의 차이일 뿐입니다. 실은 "/" 뿐만 아니 라 모든 겹마디 지시는 붙여서 써도 아무런 상관이 없습니다. 1+2 ☞ 3 5-3 ☞ 2 6//4 ☞ 1 6\\4 ☞ 2 단지 위와 같이 쓰게 되면 바탕글을 읽기 어렵게 되기 때문에 Smalltalk에서 는 관례적으로 겹마디 길표의 앞뒤에는 한 칸의 빈칸을 넣을 뿐입니다. 그러 므로 "1 / 2"와 "1/2"는 당연히 똑같은 식임을 알 수 있습니다. 그러나 결국 "1 / 2"를 가늠하면 "1/2"라고 하는 분수값이 나오게 됩니다. 그러므로 Smalltalk에서 분수를 쓸 때에 다음의 관례를 따르게 되면 바탕글 을 읽고 쓰는데 헷갈리지 않을 것입니다. << Smalltalk에서 분수를 나타내는 방법 >> ---------------------------------------------------------- * 분자와 분모를 빗금표(/)로 나누어 쓰되 '/' 앞뒤에 빈 칸을 두지 않 고 붙여서 쓴다. * 수식에서 분수가 등장하면 괄호를 두른다. ---------------------------------------------------------- 위의 규칙에 따라 식을 써 보면 아래와 같습니다. 1 + (2/3) * (3/4) + 1 ☞ 9/4 이렇게 하면 Smalltalk는 괄호를 먼저 풀고 결과값으로 분수를 사용하게 될 것입니다. 그런데 이 앞에서도 이야기했듯이 나눗셈을 해서 남겨진 결과는 분수일 수도 있고 정수일 수도 있습니다. 그런데 이번에는 나눗셈을 한다는 생각을 하지 말고 분수를 쓴다는 기분으로 다음의 글토막을 가늠해 봅시다. 1/3 ☞ 1/3 2/3 ☞ 2/3 3/3 ☞ 1 4/3 ☞ 4/3 5/3 ☞ 5/3 6/3 ☞ 2 위의 식을 나눗셈 식이 아니라 한 덩어리의 분수라고 생각하면 재미있는 것 을 발견할 수 있습니다. 바로 "약분"(約分, reducing)이 성립한다는 것입니 다. 그럼 모든 경우에 있어서 분수 객체가 약분될 수 있는지 실험해봅시다. 다음의 글토막들을 하나씩 일터에 입력하고 펴 봅시다. 2/4 ☞ 1/2 3/6 ☞ 1/2 4/8 ☞ 1/2 6/9 ☞ 2/3 12/18 ☞ 2/3 120/150 ☞ 4/5 1024/8192 ☞ 1/8 1024/8194 ☞ 512/4097 어떻습니까? 신기하지 않습니까? 아무리 복잡한 수라 하더라도 필요하다면 약분을 합니다. 이렇게 분수(Fraction) 갈래에 속한 객체들은 분수에서 할 수 있는 모든 일을 다 합니다. 분수 객체는 정수 객체가 알아들었던 여러 가지 연산자인 '+', '-', '*', '/', '//', '\\', 'factorial', 'negated' 들을 모두 그대로 알아들을 수 있 습니다. (2/3) + (4/5) ☞ 22/15 (6/8) * (9/10) ☞ 27/40 그뿐이 아닙니다. 정수와 분수를 섞어서 계산할 수도 있습니다. 1 + (2/3) ☞ 5/3 (14/5) - 2 ☞ 4/5 (6/7) * 3 ☞ 18/7 이 경우 정수는 계산되기 전에 먼저 분수로 바뀌어집니다. 그런 다음 필요하 면 통분을 통해서 계산을 하고, 가능하면 남은 결과를 약분 등을 통하여 간 단하게 합니다. 한 마디로 말해서 Smalltalk는 초등학생이 하듯이 분수와 정 수에 관한 문제라면 아무런 어려움 없이 모두 다 풀어낼 수 있는 특징을 가 지고 있습니다. 물론 분수에 지시를 보낼 떼에는 반드시 나눗셈식을 괄호로 둘러주는 것을 잊으면 안되겠습니다. 그럼 분수 객체만 알아들을 수 있는 지시는 없을까요? 이를테면 분수에게 "분모는 뭐냐?"라던가 "역수를 한 번 구해봐라" 등과 같은 지시를 내릴 수 있을까요? 당연히 가능합니다. 분수 객체는 자신이 분수라는 것을 너무나 잘 알고있기 때무에 분수가 할 수 있는 모든 것을 할 수 있습니다. 다음의 글토 막을 펴 보십시오. (2/3) denominator ☞ 3 "분모 구하기" (2/3) numerator ☞ 2 "분자 구하기" (2/3) reciprocal ☞ 3/2 "역수 구하기" 분수 갈래에 속한 객체는 특별히 분모를 구하는 "denominator", 분자를 구하 는 "numerator", 역수(逆數)를 구하는 "reciprocal"이라는 세 개의 지시를 알아들을 수 있습니다. 영어로 써서 어려운 것처럼 보이겠지만 처음 본 낱말 들이라서 어렵게 보일 뿐입니다. 실제로 우리말로 하면 "분모", "분자", "역 수"인데 어려울 게 무엇이겠습니까? :) 그런데 산수에서는 "모든 정수는 (정수/1)로 나타낼 수 있다"는 규칙이 있습 니다. 즉 "6"은 정수이지만 분수로 생각하면 "6/1"이 된다는 것이지요. 그렇 다면 정수 "6"에게 앞서 사용한 denominator, numerator, reciprocal 지시를 보내면 어떤 반응을 보일까요? 정수 객체가 위의 세 지시를 알아듣기나 할 수 있는 걸까요? 백견이 불여일행! 실제로 실행해 보면 알 수 있을 것입니 다. 다음 글토막을 펴 봅시다. 6 denominator ☞ 1 "분모" 6 numerator ☞ 6 "분자" 6 reciprocal ☞ 1/6 "역수" 어떻습니까? 놀랍게도 보통의 정수 객체도 분수나 알아들을 수 있다고 생각 했던 지시들에 알맞게 반응합니다. 이야! 똑똑하지 않습니까? 이와 같이 Smalltalk의 수 체계는 참으로 산수의 체계를 너무나도 충실하게 구현하고 있습니다. 물론 연산의 우선 순위는 빼야겠지만요. :) 그런데 앞에서 분수 객체에게 지시를 보낼 때에는 반드시 분수 객체를 괄호 로 둘러싸라고 했는데, 만약 둘러싸지 않는다면 어떻게 될까요? 2/3 denominator ☞ 2 2/3 numerator ☞ 2/3 2/3 reciprocal ☞ 6 전혀 엉뚱한 값이 나왔습니다. 그럼 도대체 왜 저렇게 황당한 값이 나왔을까 요? 그것은 바로 앞의 마디에서 설명한 "길표의 우선권"과 매우 깊은 관계를 가지고 있습니다. 위의 글토막들이 어떤 순서로 가늠되는지 스스로 살펴보시 기 바랍니다. 물론 위의 경우는 그래도 결과값이 나타나지만, 아래의 경우는 더 심각합니 다. 결과값은커녕 발자취 창이 나타나서 아예 아무것도 할 수 없다고 Smalltalk가 투덜거리기 때문이지요. 2/3 class ☞ "발자취 창 열림" 그러므로 다시 한 번 강조합니다. 분수 객체에게 어떤 지시를 내리고자 할 떄에는 반드시 분수식을 괄호로 둘러주는 것을 잊지 맙시다. #12에 계속... 제 목:[강좌] Smalltalk 배우기 #12 관련자료:없음 [21] 보낸이:김찬홍 (안드래아) 1998-12-16 16:46 조회:169 Smalltalk 배우기 #12 1998. 12. 16. 김찬홍 mailto:andrea92@hitel.net ====================================== 2. 객체들과 나누는 이야기 2.1. 객체? 2.2. 몸으로 느끼기 2.2.1. 글토막 가늠하기 2.2.2. 셈! 셈! 셈! 2.2.3. 실체와 갈래 2.2.4. 지시에 대하여 2.2.5. 지시의 우선순위 b→2.2.6. 고급 셈! 셈! 셈! ...... ======================================= 2. 객체들과 나누는 이야기 ------------------------------------ 2.2. 몸으로 느끼기 ~~~~~~~~~~~~~~~~~~ 2.2.6. 고급 셈! 셈! 셈! ----------------------- #11에서... 때때로 계산을 하다 보면 분수보다는 소수를 포함한 수를 다루어야 할 필요 가 생기게 됩니다. 특히 분모와 분자로 나타내기가 곤란한 무리수의 경우는 더욱 그렇습니다. 이럴 경우는 정수에 소수점(小數點)을 더하고, 소수를 함 께 적는 표현 방법이 있습니다. 다음 글토막을 펴 보십시오.. 0.1 ☞ 0.1 -0.25 ☞ -0.25 1.23 ☞ 1.23 위에서 가늠한 세 개의 글토막은 모두 소수입니다. "소수"(小數)란 0보다는 크고 1보다는 작은 수를 의미합니다. 그렇기 때문에 "1.23"과 같은 수는 엄 밀히 말하면 "정수 1에 소수 0.23을 더한 수"로 불러야 옳습니다. 그러나 보 통 소수점을 가지고 있는 수를 소수라고 간단히 부르는 것이 일반적입니다. 바로 위에서 확인한 바와 같이 Smalltalk에서는 정수나 분수를 다룬 것처럼 소수 역시 다룰 수 있습니다. 정수를 쓰고 붙여서 바로 소수점을 찍어준 다 음 소수점 아랫자리에 해당하는 수를 써주기만 하면 됩니다. 그리고 필요에 따라서 부호를 사용할 수도 있습니다. "-0.25"를 보면 알 수 있을 것입니다. Smalltalk에서는 모든 것이 객체이므로 앞서 살펴본 정수와 분수는 모두 나 름의 갈래(class)에 속해있었습니다. 그렇다면 소수 역시 어떤 갈래에 속해 있을 것입니다. 객체에게 자신이 속한 갈래를 물어보는 길표가 "class"라는 것쯤은 이제는 쉽게 아실 수 있어야 할터인데.... 어쨌든 아래 글토막을 펴 보십시오. 0.1 class ☞ Float -0.25 class ☞ Float 1.23 class ☞ Float 어떻습니까? 각각의 소수들이 뭐라고 대답했습니까? 바로 "Float"이라고 대 답했습니다. 그럼 도대체 이 "Float"란 어떤 것일까요? 사전에서 "Float"을 찾으면 "떠다니는"의 뜻을 가지고 있는데, 이는 컴퓨터 속에서 소수가 어떻게 표현되는 지와 관계가 있습니다. "class" 지시를 받은 소수 객체가 남긴 "Float"라는 말은 원래 "floating-point number"(부동소 수점 수)라는 말을 줄인 것입니다. 여기서 부동(浮動)이라는 말은 "떠다닌 다"는 뜻입니다. 따라서 "부동소수점 수"를 풀이하면 "점이 떠다니면서 나타 나는 수"라는 뜻인데, 이것은 컴퓨터 속에서 간단한 몇 개의 값만 바꾸어주 는 것만으로 쉽게 소수점을 움직일 수 있다는 말입니다. 예를 들면 "0.1"을 "0.01"이나 "1.0"으로 만드는 것은 부동소수점수를 사용하는 컴퓨터에게는 매우 쉬운 일입니다. 여하튼 컴퓨터는 소수를 저장하기 위해서 부동소수점수를 사용하고, 이제 우 리는 이것을 간단히 "소수"(Float)라 부르겠습니다. 자, 그럼 이 소수 객체, 즉 "Float" 갈래의 실체(instance)들은 도대체 어떤 지시를 알아들을 수 있을까요? Smalltalk를 공부하면서 제가 늘 드리는 말 씀! 바로 실험이 제일의 왕도(王道)라는 것입니다. 아래 글토막들을 펴 보고 어떤 결과가 나오는지 주시해보시기 바랍니다. 0.1 + 0.2 ☞ 0.3 -1.2 - 0.3 ☞ -1.5 2.5 * 10.1 ☞ 10.25 2.8 / 1.4 ☞ 2.0 6.5 // 4.3 ☞ 1 6.5 \\ 4.3 ☞ 2.2 5.1 negated ☞ -5.1 5.1 factorial ☞ "발자취 창 열림" 결과를 살펴보았습니까? "Float" 갈래에 속한 객체들이 위에서 사용한 지시 를 모두 다 알아들었습니까? 그렇지 않았을 것입니다. 앞서 우리가 살펴본 분수 갈래인 "Fraction"처럼 "factorial"을 제외한 다른 모든 길표를 알아들 었습니다. 다시 한번 말하지만 "factorial"은 정수를 기반으로 하는 계산이 기 때문에 분수나 소수에는 계승이라는 연산이 없습니다. 그러므로 분수나 소수 갈래에 속한 수들은 "Factorial"을 구하는 길수(method)를 모르니 우리 가 내린 지시를 이해하지 못하는 것은 어쩌면 당연한 일입니다. 여하튼 소수 에도 "factorial"을 제외한 모든 길표(selector)를 사용할 수 있다는 것을 기억하면 충분합니다. 그런데 앞서의 글토막을 가늠하는 중에 우리는 흥미로운 사실을 알아낼 수 있습니다. 바로 "2"와 "2.0"이 서로 같은지 다른지에 대한 문제입니다. 소수 점이 붙은 정수와 그렇지 않은 정수를 Smalltalk는 어떻게 알아들을까요? 산수에서라면 "2.0"과 "2"는 같은 값을 가지는 수입니다. 그럼 Smalltalk는 어떻게 생각하는지 물어보도록 합시다. Smalltalk에서 두 객체를 비교할 때 에는 같음표(=)를 사용합니다. 2.0 = 2 ☞ true "2.0"이 "= 2"라는 지시를 받아서 자신과 객체 "2"를 비교합니다. 두 객체는 모양이 다르지만 나타내는 값은 같기 때문에 당연히 위의 물음에 대해서 "맞 다"(true)라는 대답이 나오겠지요. 그럼 "2"를 쓰는 곳에 "2.0"을 대신 쓸 수 있을까요? 직접 가늠해 봅시다. 2 factorial ☞ 4 2.0 factorial ☞ "발자취창 열림" "2"와 "2.0"에게 각각 계승을 구하라고 "factorial"지시를 보내주었습니다. 이 경우 정수 객체 "2"는 순순히 결과값을 내놓았는데, "2.0"의 경우에는 "Float does not understand #factorial"이라는 제목을 가진 발자취 창이열 렸습니다. 결국 Smalltalk는 "2.0"을 정수가 아닌 "소수"(float로 알아듣는 다는 말인데.... 2 class ☞ SmallInteger 2.0 class ☞ Float 분명히 두 객체는 서로 다른 갈래에 속해있습니다. 그렇기 때문에 같은 값이 라 하더라도 "2.0"은 Smalltalk 입장에서는 정수가 아니기 때문에 길표 "factorial"을 알아들을 수 없었던 것입니다. 지금까지 우리가 나눗셈을 할 경우 결과는 항상 정수 아니면 분수였습니다. 그런데 나눗셈의 결과로 소수가 필요할 경우도 분명히 있습니다. 즉 필요하 면 정수나 분수를 소수로 바꾸어주어야 할 때도 있다는 말입니다. 정수나 분수 갈래에 속한 모든 객체들은 "asFloat"이란 외마디 길표를 알아 듣습니다. 여기서 "as~"란 "...로"라는 뜻으로, "asFloat"하면 "소수로" 정 도의 뜻이 될 수 있습니다. 다음을 살펴봅시다. 2 asFloat ☞ 2.0 3 asFloat ☞ 3.0 (1/2) asFloat ☞ 0.5 (1/10) asFloat ☞ 0.1 (128/97) asFloat ☞ 1.31958763 정수나 분수 객체가 "asFloat" 지시를 받으면 자신의 값과 동일한 값을 나타 내는 소수를 결과값으로 남기게 됩니다. 이 경우에도 분수를 표현하기 위하 여 사용한 나눗셈 식은 괄호를 둘러주어야 합니다. 단순히 정수나 분수만을 소수로 바꿀 수 있는 것은 아닙니다. 아래와 같이 좀 더 복잡한 식의 결과 또한 소수로 바꾸어 나타낼 수 있습니다. 이 때 계 산할 식 전체에 괄호를 둘러주어야만 "asFloat" 길표가 바르게 전달됩니다. ((3/2) * (2/7)) asFloat ☞ 0.428571429 이처럼 Smalltalk에서는 필요에 따라 정수나 분수 객체를 소수로 바꾸어줄 수 있습니다. 그런데 왜 굳이 Smalltalk가 정수와 분수를 사용하고, 소수의 경우는 특별한 지시를 통해야만 사용할 수 있도록 만들어 놓았을까요? 그것 은 바로 "소수의 부정확성" 때문입니다. 소수가 얼마나 부정확한지 몇 가지 실험을 해 보겠습니다. 아래 글토막을 펴 보고 결과를 비교해 보십시오. (1 - 0.9) * 2 ☞ 0.2 위의 경우에는 제대로 결과가 나왔습니다. "1"에서 "0.9"를 빼면 "0.1", 여 기에 다시 "2"를 곱하기 때문에 "0.2"라는 바른 결과값을 남겼습니다. 그러나 소수는 조금만 자릿수가 많아져도 계산에 착오를 일으킵니다. (1 - 0.999999999999999999999999) * 2 ☞ 0.0 어라? 0.0? 이게 어떻게 된 일일까요? 1에서 0.999999999999999999999999를 빼면 0.0000000000000000000000001이 될 터이고, 여기에 2를 곱하면 당연하 게 결과값으로 0.0000000000000000000000002가 되는 것이 당연한데, 이건 뭔 가 이상하다는 생각이 듭니다. 지금 보신 것이 소수의 취약점입니다. 컴퓨터는 정수를 계산할 때보다 소수 를 계산할 때가 더 많은 기억 공간과 시간을 필요로 합니다. 따라서 컴퓨터 가 처리할 수 있는 소수의 자릿수에도 자연히 제한이 가해집니다. 만약 계산 의 중간값이나 결과값이 모두 정해진 자릿수 범위 안에서 처리된다면 문제가 없지만, 컴퓨터가 처리할 수 있는 자릿수 이상이 되어버리면, 계산에 착오를 일으키게 됩니다. 그럼 컴퓨터가 처리할 수 있는 부동소수점의 자릿수는 얼마나 될까요? 다음 글토막을 사용해서 알아봅시다. 마음대로 만들어낸 긴 소수 한 개와 원주율 (phi)을 이용하면 다음과 같은 결과값을 얻을 수 있습니다. 3.1415926535898 ☞ 3.14159265 1.23456789123456789 ☞ 1.23456789 위의 결과로 미루어볼 때 Smalltalk에서는 대략 아홉 자리의 소수를 인식하 고 처리할 수 있음을 볼 수 있습니다. 이 전에 가늠했던 다음의 식을 다시 한 번 생각해 봅시다. (1 - 0.999999999999999999999999) * 2 ☞ 0.0 위의 경우 계산에 사용된 소수의 자릿수는 15자리인데, Smalltalk는 9자리까 지만 인식을 합니다. 그러므로 위와 같이 정밀한 계산은 착오를 일으키는 것 입니다. 그렇지만 정수와 분수는 아무런 에누리없이 값을 처리하고 계산할 수 있습니 다. 분수 역시 "분자"와 "분모"라는 두 개의 정수를 가지고 수를 표현하는 것이므로 자릿수에 제한을 받지 않는다는 것입니다. 실제로 다음의 글토막을 펴 보면...? ----------------------------------------------------------- 10 factorial / 100 factorial ☞1/2571820310955251121078572499345973889184192247144555265338209983884 96472644482792132224051962512451185663850090463028434334174412800000000 00000000000000 ----------------------------------------------------------- 위와 같은 결과를 얻게됩니다. 즉 아무리 큰 수라고 하더라도 분수로 표현하 게 되면 아무런 손실이 없이 계산을 할 수 있는 것입니다. 이러한 이유 때문 에 Smalltalk에서는 될 수 있으면 부정확한 소수보다는 정확한 계산을 수행 할 수 있는 분수를 사용하도록 권하고 있습니다. ---<잠깐!>----------------------------------------------------------- 다른 언어에서는...? Smalltalk가 아닌 기존의 다른 언어들에서는 정수와 소수를 대상으로 연산을 합니다. 즉 나누어떨어지지 않는 나눗셈의 경우 결과값으로 소수를 사용합니 다. 또한 대부분의 언어들은 분수를 기본 자료형으로 지원하지 않고 있으며, 분수가 필요하다면 따로 갈래(class)를 만들어서 사용해야 합니다. 물론 갈 래를 만들 수 있고, 갈래에 딸린 연산자도 다중정의(overloading)할 수 있는 C++ 같은 언어를 사용해야하지만, 이 경우에도 역시 많은 제한이 따르게 됩 니다. 기본적으로 이들 언어는 정수와 소수를 기본 연산으로 하고 있기 때문 입니다. 이에 비해 Smalltalk는 매우 합리적인 선택을 했다고 볼 수 있습니다. 필요 할 때에는 언제든지 분수를 소수로 바꿀 수 있기 때문에, 굳이 연산의 정확 도가 떨어지는 소수를 연산 대상에서 제외한 것은 상당히 합리적이라고 필자 는 생각합니다. ----------------------------------------------------------- 물론 계산이 부정확하게 된다는 단점은 있지만, 실제로 소수를 사용하여 문 제를 해결해야 할 필요성이 있기 때문에 여기서는 소수의 표현 방법에 대해 서 좀 더 짚고 넘어가도록 하겠습니다. 소수를 표현할 때에는 두 가지의 서로 다른 방법을 사용할 수 있습니다. 하 나는 지금까지 우리가 사용해 온 방법이고, 나머지 하나는 "공학적 표기법", 또는 "멱법"(冪法)이라고 하는 것인데, 여기서는 이 방법을 알아보도록 하겠 습니다. 자릿수가 많은 소수를 표현 할 때 우리는 다음과 같은 표현방법을 씁니다. 1x10^-20 2x10^-3 3x10^3 4x10^20 (단, '^'는 "제곱'). 즉 자릿수를 나타내는 "0"을 늘어놓는 것이 아니라 수를 간단히 하여 여기에 "10"을 밑으로 하는 멱수를 곱해서 자릿수를 나타내는 방법입니다. 이를 이 용하면 "0"이 줄줄이 늘어서 있기 때문에 생기는 혼란을 막을 수 있습니다. Smalltalk에서 공학적 표기법을 사용하려면 다음과 같이 합니다. 1e-20 2e-3 3e3 4e20 위에서 "e"는 "10의 거듭제곱"을 뜻합니다. 그러므로 아래의 세 개의 값은 모두 같은 의미입니다. 2e3 20e2 2000e1 2000 공학적 표기법을 좀 더 쉽게 이해할 수 있는 두 가지 관점이 있습니다. 먼저 수학적인 방법입니다. 여기서는 앞서 이야기했듯이 "e"를 "10의 x승"으 로 생각하여 계산하면 매우 쉽게 읽을 수 있습니다. 0.0314159e2 =0.0314159 * 10^2 = 0.314159 * 100 = 3.14159 314.159e-2 = 314.159 * 10^-2 = 314.156 / 10^2 = 314.159 / 100 = 3.14159 다음으로는 수학적 방법이 아닌 좀 더 간단하고 직관적인 방법이 있습니다. 이 방법은 소수점을 "e" 뒤에 있는 숫자만큼 옮기라는 것입니다. 즉 "e" 다 음의 수가 양수이면 소수점을 오른쪽으로, 음수이면 왼쪽으로 옮기면 원래의 값을 계산할 수 있다는 것입니다. 0.0314159e2 = "소수점을 오른쪽으로 두 칸 옮긴다." = 3.14159 314.159e-2 = "소수점을 왼쪽으로 두 칸 옮긴다." = 3.14159 앞서 우리는 정수와 분수와의 관계를 알아보았습니다. 정수와 분수가 하나의 계산식 안에 섞여있으면, 계산을 하기 전에 정수가 우선 분수로 바뀌어지는 것을 볼 수 있었습니다. 그럼 정수와 분수, 그리고 소수가 함께 섞여있으면 Smalltalk는 어떤 반응을 보일까요? 다음의 글토막을 가늠해 보십시오. 1 + (1/2) + 0.3 ☞ 1.8 위의 식을 Smalltalk는 다음처럼 가늠합니다. 1 + (1/2) + 0.3 → 1.0 + 0.5 + 0.3 → 1.8 위의 결과로써 우리는 Smalltalk가 정수, 분수, 소수가 섞여있는 식을 어떻 게 계산하는지를 알 수 있게 됩니다. 정수, 분수, 소수가 식에 함께 섞여 있 을 때는 다음과 같은 순서로 변환이 일어납니다. ------------------------------ 정수 → 분수 → 소수 ------------------------------ 그래서 결국 계산식에 소수가 섞여있으면 전체 식을 계산한 후 남는 결과값 역시 소수가 된다는 것을 기억해 두어야 할 것입니다. Smalltalk에서는 언제 나 수에 대해서 위와 같은 변환 규칙이 적용되기 때문입니다. 그런데 계산을 하다보면 분수나 소수를 정수로 바꾸어주어야 할 때가 있습니 다. 이럴 경우 표현하고자 하는 소수에 소수점 아래 자릿수가 0이면 괜찮지 만, 소수점 아래에 숫자가 있게 되면 자연히 이런 소수는 잘라버려야 합니 다. 왜냐하면 정수는 소수점이 없는 수이기 때문이지요. 소수나 분수를 정수 로 만드는 방법에는, 소수점 아래 숫자를 무조건 잘라내는 방법과 반올림을 하는 방법 두 가지가 있습니다. 소수점 아래 숫자를 무조건 잘라버리는 지시는 "truncated"이며, 반올림을 하라는 지시는 "rounded"입니다. 이 두 가지 지시는 분수(Fraction)와 소수 (Float) 객체가 모두 알아들을 수 있습니다. 5.4 truncated ☞ 5 5.7 truncated ☞ 5 6.3 truncated ☞ 6 8.8 truncated ☞ 8 위의 네 경우 모두 소수값에 관계 없이 소수 아랫자리의 수는 모두 버려졌습 니다. 이것이 "truncated" 지시의 결과입니다. 반면 "rounded"지시는 다릅니 다. 다음을 가늠해 보십시오. 5.4 rounded ☞ 5 5.7 rounded ☞ 6 6.3 rounded ☞ 6 8.8 rounded ☞ 9 "rounded"지시는 소수의 값에 따라 반올림을 합니다. 즉 소수의 값이 0.5보 다 작으면 버리고, 0.5보다 크면 버린 값에 1을 더합니다. 그래서 "5.4"와 "6.3"의 경우는 각각 "5"와 "6"이 되었고, "5.7"과 "8.8"의 경우는 버린 값 에 1이 더해져서 "6"과 "9"가 되었던 것입니다. 분수에 있어서는 조금 다르게 생각해 보아야 합니다. 일단 분수에 앞서 설명 한 "truncated"와 "rounded"지시를 적용하려면 계산할 연산수가 가분수(假分 數)여야 하며, "truncated"와 "rounded"는 주어진 가분수를 대분수(帶分數) 로 바꾸어서 계산을 수행합니다. 다음 글토막을 펴 보십시오. (5/4) truncated ☞ 1 (7/4) truncated ☞ 1 가분수 "5/4"를 대분수로 고치면 "1과 1/4"가 되고, "7/4"을 대분수로 고치 면 "1과 3/4"가 됩니다. 이 대분수에서 정수부분이 한결같이 "1"이기 때문에 "truncated"지시는 분수 부분을 잘라버리고 정수 부분만 결과값으로 남기는 것입니다. 이제 "rounded"를 설펴봅시다. (5/4) rounded ☞ 1 (7/4) rounded ☞ 2 "rounded"는 분수 부분의 분자가 분모의 절반을 넘게 되면 정수 부분에 1을 더한 다음 분수 부분을 버리고, 만약 분수 부분의 분자가 절반에 미치지 못 하면 분수 부분만 버립니다. 위의 경우 "5/4"는 "1과 1/4"인데, 분수 부분의 분자가 "1", 즉 분모 "4"의 절반이 아니므로 정수 부분 "1"을 남겼지만, "7/4"의 경우 대분수로 고치면 "1과 3/4"가 되고, 분자 "3"이 분모 "4"의 절 반이 넘으므로 정수 "1"에 하나를 더하여 "2"를 결과값으로 남깁니다. 이처럼 분수나 소수를 정수로 바꾸고자 할 경우에는 원래의 값이 손실될 수 밖에 없다는 것을 기억하고, 어떤 경우에 버릴 것인지, 아니면 반올림을 할 것인지를 신중하게 생각해 보는 것이 중요합니다. 지금까지 우리는 분수와 소수에 대해서 여러 가지의 성질을 알아보았습니다. 그러면 마지막으로 분수와 소수가 여태껏 우리가 알아낸 갈래 씻줄(class hierarchy)과는 어떻게 얽어져 있는지 알아봅시다. 우리가 정수 갈래의 씻줄을 알아내기 위해서 "class"와 "superclass"라는 두 개의 지시를 사용했듯이, 분수와 소수에도 똑같은 방법을 사용해 봅시다. 아 래에 있는 글토막들을 하나씩 차례로 가늠해 봅시다. (1/2) class ☞ Fraction Fraction superclass ☞ Number Number superclass ☞ ArithmeticValue ArithmeticValue superclass ☞ Magnitude Magnitude superclass ☞ Object 분수(Fraction)는 바로 수(Number)에 속해있습니다. 그리고 Number 갈래는 앞에서 우리가 살펴보았듯이 산술값(ArithmeticValue)과 크기값(Magnitude) 에 딸려있으며, 결과적으로는 객체(Object)에 얽혀있습니다. 그러므로 결국 분수 갈래는 Number 갈래에 딸려있다고 보면 됩니다. 이번에는 소수(Float)입니다. 3.5 class ☞ Float Float superclass ☞ Number Number superclass ☞ ArithmeticValue ArithmeticValue superclass ☞ Magnitude Magnitude superclass ☞ Object 소수 역시 분수와 똑같은 씻줄을 가지고 있습니다. 즉 Float(소수) 갈래는 분수(Fraction)와 같이 Number(수)에서 갈라져 나온 아랫갈래인 것입니다. 그러므로 정수(Integer), 분수(Fraction), 소수(Float) 모두 Number(수)라는 갈래에서 갈라져 나온 셈입니다. 그럼 지금까지 우리가 알아낸 갈래씻줄을 그림으로 그려봅시다. <그림 2-3> Number 갈래를 포함한 갈래씻줄 (stp2-3.gif) 위에서 알수 있듯이, 정수, 분수, 소수는 모두 수(Number)라는 갈래에 속해 있으므로, 우리들은 Smalltalk에서의 수에 대한 것은 거의 다 공부했다고 볼 수 있습니다. 정수와 분수, 그리고 소수는 수를 구성하는 중요한 갈래이며, 각 갈래들의 실체(instance)는 독특한 성질을 가지고 있습니다. 이들 성질을 제대로 간파 하여 이용하는 것이 수를 잘 다룰 수 있는 길이 될 것입니다. 결국 모든 것이 객체인 Smalltalk에서는 각 객체의 특성은 무엇이고, 각 객 체가 알아들을 수 있는 지시에는 어떤 것들이 있으며, 그 객체들이 속한 갈 래는 다른 갈래와 어떤 씻줄로 얽혀있는지를 파악해야만 제대로된 Smalltalk 프로그램을 작성할 수 있는 것입니다. 계속... 제 목:[강좌] Smalltalk 배우기 #13 관련자료:없음 [22] 보낸이:김찬홍 (안드래아) 1998-12-21 01:07 조회:159 Smalltalk 배우기 #13 1998. 12. 21. 김찬홍 mailto:andrea92@hitel.net ====================================== 2. 객체들과 나누는 이야기 2.1. 객체? 2.2. 몸으로 느끼기 2.3. 객체의 안쪽 2.3.1. 탐색기 사용하기 ...... ======================================= 2. 객체들과 나누는 이야기 ------------------------------------ 2.3. 객체의 안쪽 ~~~~~~~~~~~~~~~~ 지금까지 우리는 여러 가지 객체와 그들이 속한 갈래를 알아보았습니다. 대 부분 우리들이 알아본 객체는 수(Number)에서 출발하는 것들이었으며, 정수 (Integer), 분수(Fraction), 그리고 소수(Float)의, 세 개의 갈래가 Number 갈래에 씻줄로 얽혀있었습니다. 이런 것들은 모두 객체의 표면적인 것들이었 습니다. 이제부터 우리는 객체의 안쪽으로 깊이 들어가 보겠습니다. 우리들이 눈으로 보고 지시를 주고받음으로써 대화를 나눈 객체들의 안쪽은 어떻게 생겼을까 요? 그리고 또한 그런 객체들은 어떤 성분으로 이루어져있을까요? 이제 우리 는 그러한 객체의 내적인 면에 대해서 알아볼 것입니다. 그래서 이 마디를 끝내고 나면 여러분은 객체의 속이 어떻게 이루어져 있으며, 또한 이것들이 어떻게 유기적으로 연결되어 객체를 구성할 수 있는지에 대한 줄거리를 잡을 수 있을 것입니다. 먼저 이러한 객체의 안쪽을 들여다보기 위하여 우리는 "객체 탐색기"의 사용 법부터 공부해야 합니다. 2.3.1. 탐색기 사용하기 ----------------------- 모든 객체는 "inspect"라는 지시를 알아듣습니다. 사전에서 "inspect"를 찾 아보면 "면밀하게 살피다, 검사하다, 점검하다 검열하다, 탐색하다" 등의 뜻 을 가지고 있습니다. 즉 "inspect" 지시를 받은 객체는 자신의 속을 들여다 볼 수 있도록 열어줍니다. 이 때 나타나는 창이 바로 "객체 탐색기"(object inspector)입니다. 다음 세 개의 글토막들을 모두 가늠해 보십시오. 27 inspect (1/3) inspect 32.1 inspect 그러면 다음 <그림 2-4>와 같이 세 개의 객체 탐색기를 볼 수 있을 것입니 다. 이렇게 해서 열린 탐색기는 여러분이 닫을 때까지 남아있게 됩니다. <그림 2-4> 객체 탐색기가 열린 모습 (stp2-4.gif) 그림에서 볼 수 있듯이 객체 탐색기는 크게 두 널(pane)로 되어있습니다. 왼 쪽 널에는 "self"에서부터 시작해서 "numerator", "denominator", "1", "2" 등과 같은 선택 가지들이 있고, 오른쪽 널에는 무언지는 모르지만 어떤 값이 나와있습니다. 그럼 도대체 각각의 널에 표시된 것은 무엇을 의미하는 것일 까요? 먼저 왼쪽 널에 있는 "self"부터 살펴봅시다. "self"가 무슨 뜻입니까? 바로 "자기 자신"이란 말입니다. 탐색기에서의 "self"는 현재 탐색하고 있는 객체 자체를 의미합니다. 세 개의 탐색기 모두에서 "self"가 현재 선택되어있음을 알 수 있습니다. 이 상태에서 오른쪽 널을 보십시오. 어떤 결과가 나타났습니까? "27", "1/3", "32.1", 바로 탐색하고 있는 객체가 그대로 표시되었습니다. 여기서 오른쪽 널의 기능을 확실히 알 수 있습니다. 바로 왼쪽 널에서 선택 된 항목의 값을 오른쪽 널에 나타낸다는 것입니다. 그럼 이제 "1/3"을 탐색하고 있는 "Inspecting a Fraction" 창을 살펴봅시 다. 왼쪽 널에 무엇이 있습니까? "numerator"와 "denominator"가 있습니다. 이것은 무엇을 말합니까? 바로 "분자"와 "분모"를 나타냅니다. 그럼 이제 한 번 "numerator"를 선택해서 돋이되게 만들어 봅시다. 화면에 어떤 결과가 나 타났습니까? 오른쪽 널에 있던 "1/3"이 없어지고 "1"이라는 값으로 바뀌어 있을 것입니다. 그럼 "denominator"는 어떨까요? 역시 왼쪽 널에서 분모를 나타내는 "denominator"를 선택하면 오른쪽 널에 "3"이 나타날 것입니다. 지 금 이야기한 것을 그림으로 정리하면 다음과 같습니다. <그림 2-5> 객체 탐색기의 왼쪽 널과 오른쪽 널의 관계 (stp2-5.gif) 말로 풀어 놓았기 때문에 어렵게 들릴지 모르겠지만, 실제로 탐색기를 몇 번 움직여 보면 매우 직관적으로 동작한다는 것을 알 수 있습니다. 탐색기의 왼쪽 널은 객체와 그 객체를 이루고 있는 성분(part)들을 나타냅니 다. 그리고 오른쪽 널에는 현재 선택된 성분이 가지는 값이 표시됩니다. 그럼 여기서 "27"의 경우는 왼쪽 널에 "self"만 나타났기 때문에, "27"이, 아니, 좀 더 크게 생각하여 SmallInteger 갈래에 속한 모든 객체는 성분이 없는 것일까 하는 의문을 가져볼만 합니다. 만약 이런 생각을 가진 사람이라 면 이제 슬슬 객체에 대해서 어느 정도 눈을 떴다고 해도 좋을 것입니다. 그렇습니다. SmallInteger 갈래의 실체는 성분을 가지지 않습니다. 이것은 물리에서 수소(H)나 산소(O) 등의 원자는 그들을 이루는 성분을 가지고 있는 것이 아니라, 그들 자체로써 완전히 존재하는 것과 같습니다. Smalltalk의 객체에도 이렇게 성분을 가지는 객체와 그렇지 않은 객체가 있는데, 객체의 성분에 대해서는 조금 있다가 알아보도록 하겠습니다. 일단 지금 중요한 것 은 그러한 객체의 내부를 들여다볼 수 있는 탐색기의 사용법을 익히는 것이 기 때문입니다. 여태까지 우리는 객체에게 "inspect"란 지시를 보냄으로써 탐색기를 열었지 만 앞("1.5.3", "2.1")에서 우리는 객체 탐색기를 여는 다른 방법을 이미 알 아본 적이 있습니다. 기억하십니까? 네, 바로 글토막을 가늠할 때 탐색기를 여는 방법이었습니다. 어떤 글토막을 가늠할 때 "Workspace > Inspect It" 메뉴를 사용하던지 단축 글쇠인 를 사용하면 글토막이 가늠된 결과로 남은 객체를 탐색해볼 수 있다고 했습니다. 그러므로 객체에게 "inspect" 지시를 내리는 것과 해당 객체에 덩이(block)를 씌워 나 "Workspace > Inspect It"을 사용하 는 것은 똑같은 결과를 나타냅니다. 탐색기는 객체의 내부를 세밀하게 조사하는데 사용하는 도구답게 "연계 탐색 기능"(drill down inspecting)이라는 것을 가지고 있습니다. 앞에서 객체는 자신을 구성하고 있는 성분을 가진 것과 그렇지 않은 것이 있다고 했는데, 연계 탐색 기능은 어떤 객체의 성분까지 탐색해 볼 수 있는 기능을 말합니 다. 방금 열어놓았던 세 개의 탐색기 중에 "1/3"을 탐색하고 있는 "Inspect a Fraction"이라는 제목이 달린 창을 살펴봅시다. 왼쪽 널에는 "self", "numerator", "denominator"라는 세 개의 선택 가지가 있습니다. 이 세 개의 가지들 중에 "numerator" 가지를 돋이되게 만든 다음, 메뉴의 "Workspace > Inspect It"을 실행시하거나 를 눌러봅시다. 어떻게 되었습니까? <그림 2-6> 연계 탐색 기능을 통해 열린 탐색기 (stp2-6.gif) "Inspecting a SmallInteger"라는 또 하나의 탐색기가 열렸습니다. 새로 열 린 탐색기는 어떤 객체를 보여주고 있습니까? 네, "1"입니다. 이 "1"은 어디 서 나온 것이겠습니까? 그렇죠. 바로 "1/3" 객체의 분자(numerator)입니다. 이렇게 탐색기의 왼쪽 널에 표시된 객체의 성분 중에서 하나를 돋이되게 받 는 다음 나 "Workspace > Inspect It" 메뉴를 실행하면 돋이된 가지 의 객체에 대해서 다시 탐색기가 열리게 됩니다. 이와 같이 어떤 객체를 구 성하고 있는 성분을 다시 탐색해 들어가게 되면 결국에는 자기 자신이 성분 인 객체―이를 '홀객체'라 하는데 이는 잠시 뒤에 설명하겠습니다.―까지 내 려가게 됩니다. 이 연계 탐색 기능을 이용함으로써 객체의 안쪽을 속속들이 살펴볼 수 있는 것이지요. 위에서 소개한 방법 말고도 연계 탐색 기능을 동작시킬 수 있는 방법이 하나 더 있는데 ,그것은 왼쪽 널에 표시된 선택 가지를 두 번(double click) 누르 는 것입니다. 보통은 이 방법이 간편하기 때문에 많이 사용됩니다. 아래에 연계 탐색기능을 동작시키는 방법을 정리해 두겠습니다. <연계 탐색기능 사용하기> ---------------------------------------------------------- * 탐색하고자 하는 성분을 돋이되게 만든 후 "Workspace > Inspecting It" 메뉴를 사용한다. * 탐색하고자 하는 성분을 돋이되게 만든 후 글쇠를 누른다. * 탐색하고자 하는 객체의 성분을 두 번 누른다. ---------------------------------------------------------- 이러한 연계 탐색은 구조가 매우 복잡한 객체를 탐색하는데 매우 편리합니 다. 지금은 별로 사용할 일이 없겠지만, 나중에 여러분이 복잡한 객체를 만 들고 그 내용을 탐색할 때에 이 기능을 사용하게 될 것입니다. 이제 여러분의 화면에는 많은 탐색기들이 떠 있을 것인데, 이들을 하나도 남 김 없이 다 닫아주십시오. 이제부터 탐색기의 또 다른 기능을 공부해야 하는 데, 너저분한 책상에서 시작할 수는 없지 않겠습니까? ^^: 이제 다음 글토막을 탐색해서 새로운 객체 탐색기가 열리도록 합시다. 2/3 자, 다시 한 번 탐색기를 유심히 살펴봅시다. 지금까지는 탐색기의 왼쪽 널 을 주로 살펴보았는데, 이제부터는 탐색기의 오른쪽 널을 살펴볼 것입니다. 오른쪽 널을 주의 깊게 살펴보십시오. 뭔가 느껴지는 것이 없습니까? 자, 지 금 탐색기 옆에 있는 일터(workspace)와 가만히 비교해 보십시오. 뭔가 똑같 은 것이 있습니다. 찾을 수 있겠습니까? <그림 2-7> 탐색기와 일터 (stp2-7.gif> 네, 이미 눈치 챈 분들도 있을는지 모르겠습니다. 바로 일터의 화면 바탕색 과 탐색기의 오른쪽 널의 바탕색이 같다는 것입니다. Dolphin Smalltalk를 만든 사람이 왜 이렇게 일터와 탐색기의 오른쪽 널을 같은 색깔로 만들었을 까요? 단순한 미적 감각일까요? 그렇지 않습니다. 여러분이 지금 보고 있는 탐색기의 오른쪽 널은 일터가 할 수 있는 일을 모두 할 수 있기 때문에 그 것을 보여주기 위해서 일부러 바탕색을 같게 만들어 놓은 것입니다. 어라? 그렇다면 탐색기의 오른쪽 널을 일터로 쓸 수 있다는 말이라면, 정말 그런지 그렇지 않은지 실험해 봐야 할 일입니다. 앞서 "2/3"를 탐색해서 연 탐색기의 오른쪽 널을 보십시오. 지금 왼쪽 넓에는 "self"가 돋이되어 있고, 오른쪽 널에는 "self"의 값인 "2/3"이 표시되어있을 것입니다. 이제 오른쪽 널에 있는 "2/3"을 "(2/3) class"처럼 고친 뒤에 방금 고친 글토막을 펴 보 십시오. 어떻게 되었습니까? <그림 2-8> 일터로 사용된 탐색기의 오른쪽 널 (stp2-8.gif) 그림에서 볼 수 있듯이 일터에서 했던 것과 똑같은 결과로 "Fraction"이란 값이 덩이를 쓴 체로 나타났습니다. 이상의 결과들을 미루어볼 때 탐색기의 오른쪽 널은 일종의 일터로 생각해도 좋을 것입니다. 그런데 왼쪽 널에는 "self"가 돋이되어있습니다. 따라서 지금 우리가 오른쪽 널에 무언가를 입력했다면 왼쪽 널에 있는 "self"에 어떤 영향을 주었을지도 모르는 일입니다. 자, 잠시 "self" 아래에 있는 "numerator"를 돋이되게 만 든 다음 다시 "self"를 돋이되게 만듭시다. 어떻게 되었습니까? "self"에는 아무런 변화가 없는 것입니다. 즉 우리는 탐색기의 오른쪽 널을 자유롭게 일터로 삼아 여러 가지 글토막을 가늠해볼 수 있습니다. 그렇지만 우리가 탐색기에서 내놓은 값들을 가지고 여러 가지 일을 한다고 해서 탐색기의 원래 값이 변하는 일은 없습니다. 따 라서 탐색기의 오른쪽 널은 여러분이 사용하고싶은 대로 마음껏 써도 좋다는 결론이 나옵니다. 이것은 Smalltalk에서 객체의 속을 들여다보고 문제를 해 결하는데 있어서 매우 뛰어난 기능을 제공합니다. 이제 탐색기가 할 수 있는 일 한 가지를 마지막으로 더 알아보고 이번 나눔 을 닫을까 합니다. 우리는 지금까지 탐색기가 보여준 객체의 값을 확인하기만 했습니다. 그렇지 만 필요에 따라서 우리는 이러한 객체들의 값을 바꾸어줄 수 있습니다. 그럼 이제 탐색기가 표시하는 객체의 값을 어떻게 바꾸어줄 수 있는지 실험을 통 해서 알아봅시다. 지금 여러분 화면에는 객체 "2/3"의 값을 담은 탐색기가 열려있을 것입니다. 여기서 선택 막대를 "denominator"에 위치하여 오른쪽 널에 "2/3"의 분모인 "3"이 표시되도록 만듭시다. 이제 오른쪽 널에 있는 "3"을 지우고 "4"를 써 넣습니다. 이렇게만 하면 "2/3"의 값을 "2/4"로 바꿀 수 있을까요? 그렇지 않습니다. 바로 앞에서 살펴보았듯이, 탐색기의 오른쪽 널은 일터처 럼 자유롭게 값을 지우기도 하고 쓸 수도 있다고 했습니다. 따라서 지금과 같은 상황에서 선택 막대를 "self"나 "numerator" 처럼 다른 가지로 옮기게 되면 우리가 방금 써 넣은 "4"라는 값은 지워지고 맙니다. 그렇기 때문에 방 금 우리가 써넣은 것을 현재 돋이된 성분의 값으로 바꾸라는 지시를 특별히 탐색기에게 내려줄 필요가 있습니다. 오른쪽 널의 "3"을 "4"로 바꿔준 후에 "Workspace > Accept"나 글쇠판의 를 눌러봅시다. 화면에는 아무런 변화가 없어 보입니다. 그렇지만 여러분이 "Workspace > Accept" 메뉴를 실행하거나 글쇠를 눌렀을 때 "denominator"는 이미 "3"에서 "4"로 바뀌어 있습니다. 확인하기 위해서 "self"를 다시 한 번 돋이되게 해 봅시다. 오른쪽 널에 무엇이 나타났습니 까? 바로 "2/4"가 나타났습니다. 우리가 앞에서 한 조작으로 인해서 "2/3"이 었던 객체가 "2/4"로 바뀐 것입니다. 이렇게 탐색기를 이용하여 값을 탐색하다가 어떤 성분의 값을 바꿀 필요가 있다면, 먼저 값을 바꿀 성분을 돋이되게 만든 다음 성분의 값이 표시된 오 른쪽 널에 원하는 값을 넣고 "Workspace > Accept" 메뉴를 실행하거나 글쇠 판에서 글쇠를 누르면 돋이된 성분의 값이 바뀌게 됩니다. ---<잠깐!>---------------------------------------------------------- Smalltalk에서 분수를 다룰 때는 언제나 기약분수(旣約分數)의 형태를 취하 게 됩니다. 이는 분수의 분자나 분모가 바뀌면 분수 객체가 스스로 알아서 약분을 해 주기 때문입니다. 그러나 탐색기에서 분자나 분모의 값을 바꾼 경 우 분수 객체는 값이 바뀌었다는 사실을 통보 받지 못합니다. 즉 우리가 탐 색기에서 어떤 값을 바꾸더라도 실제로 값이 바뀐 객체는 자신의 값이 바뀌 었다는 것을 직접적으로 알 수 없습니다. 따라서 "2/4"는 약분이 되지 않은 상태로 존재하게 되는 것이지요. ---------------------------------------------------------- 객체 성분의 값을 바꿀 때에 Smalltalk의 글토막을 사용할 수 있습니다. 앞 에서 우리는 "3"을 "4"로 바꾸기 위해서 탐색기의 오른쪽 널에 직접 "4"라는 값을 적어 넣었으나, 이 자리에 Smalltalk에서 사용할 수 있는 글토막을 적 어넣을 수 있다는 말이 됩니다. 실험을 해 봅시다. 열려있는 탐색기에서 다시 "denominator"를 돋이되게 만 듭니다. 오른쪽 널에는 방금 우리가 바꾼 "4"라는 값이 나타나 있을 것입니 다. 이 상태에서 이미 있던 "4"를 지우고 다음과 같은 글토막을 오른쪽 널에 적어 넣습니다. 3 factorial 이 상태에서 "Workspace > Accept" 메뉴를 실행하거나 글쇠판의 글 쇠를 눌러봅시다. 어떻게 되었습니까? 글쇠를 누르자마자 "3 factorial"이라 는 글토막이 "6"으로 바뀌었습니다. 이렇게 어떤 객체의 값을 바꾸기 위해서 는 단순히 값을 써 줄 수도 있고, Smalltalk가 가늠할 수 있는 글토막을 쓸 수도 있습니다. 이제까지 우리는 객체 탐색기에 대한 사용법을 알아보았습니다. 탐색기는 기 본적으로 어떤 객체의 값을 자세하게 살펴볼 수 있었으며, 그 객체의 값을 바꿀 수도 있었습니다. 더불어 탐색기는 일터의 역할까지 겸할 수 있다는 것 도 알아보았습니다. 이제 여기서 공부한 것들이 바로 다음에 이어질 객체의 성분을 알아보는 데에서 큰 도움이 될 것입니다. ---<잠깐!>---------------------------------------------------------- 다른 언어에서는...? 요즘 출시되는 모든 개발 도구들은 자체적으로 객체의 내부를 탐색해 볼 수 있는 탐색기를 준비하고 있습니다. 이는 모두 Smalltalk의 영향을 받은 것입 니다. 필자가 탐색기를 처음 본 것이 "Turbo C++ 1.0"이었을 것입니다. 여기 서는 벌래잡이(debugging) 시간에 탐색기를 사용할 수 있었습니다. Turbo C++의 탐색기 역시 Smalltalk의 탐색기처럼 연계 탐색 기능을 지원했습니다. 처음 필자가 이 기능을 보고는 상당히 대단하다는 생각이 들었었지요. 물론 그 전의 "Turbo C 2.0"에서도 "Watch"나 "Evaluate/Modify"라는 기능이 있어 서 객체(정확히는 "변수")의 값을 살펴보거나 바꿀 수 있었습니다. 그러나 객체와 갈래의 개념을 지원하는 C++ 언어에서 동작하는 탐색기보다는 기능이 떨어졌습니다. 세월은 흘러 이제는 시각적(visual) 개발 도구가 나왔고, 이 도구들은 실행 시간이나 벌레잡이 시간에 객체의 상태를 검사하고 값을 바꿀 수 있는 탐색 기를 갖추었습니다. 더욱이 창이나 객체를 설계할 때(designe time) 값을 변 경하여 화면에 그 결과가 바로 반영되는 기능을 모두 다 구현하고 있습니다. 결국 이것은 모두 Smalltalk에서 10년도 훨씬 전에 개발되어있었습니다. 더 욱이 Smalltalk의 탐색기에서는 Smalltalk가 실행할 수 있는 글토막을 기반 으로 객체의 값을 바꿀 수 있었습니다. 그러므로 다른 언어에서 지원하는 탐 색기보다 Smalltalk의 탐색기는 한 차원 더 높은 기능을 제공한다고 해도 과언이 아닐 것입니다. 물론 겉으로 보기에 Smalltalk의 탐색기는 다른 개발 도구의 탐색기보다 초라해 보이겠지만 말입니다. ---------------------------------------------------------- 계속... 제 목:[강좌] Smalltalk 배우기 #14 관련자료:없음 [23] 보낸이:김찬홍 (안드래아) 1998-12-31 17:16 조회:146 Smalltalk 배우기 #14 1998. 12. 31. 김찬홍 mailto:andrea92@hitel.net ====================================== 2. 객체들과 나누는 이야기 2.1. 객체? 2.2. 몸으로 느끼기 2.3. 객체의 안쪽 2.3.1. 탐색기 사용하기 2.3.2. 객체의 성분 ...... ======================================= 2. 객체들과 나누는 이야기 ------------------------------------ 2.3. 객체의 안쪽 ~~~~~~~~~~~~~~~~ 2.3.1. 객체의 성분 ------------------ 바로 앞 나눔에서 우리는 객체 탐색기에 대해서 알아보았고, 몇 가지 실험을 통해서 탐색기에 익숙해졌을 것입니다. 지금부터는 객체를 구성하고 있는 성 분에 대해서 조금 더 자세히 알아보겠습니다. 그러면서 우리는 수(數)가 아 닌 다른 갈래에 속해 있는 객체들도 다루어보게 될 것입니다. 먼저 다음 세 개의 객체를 탐색해봅시다. 다음의 글토막을 글쇠를 눌러서 가늠하거나, 객체에게 "inspect" 지시를 보내면 앞서 보았던 <그림 2-4>와 같이 세 개의 탐색기가 열릴 것입니다. 27 1/3 32.1 탐색기의 왼쪽 널(pane)을 주의깊게 살펴봅시다. 정수 "27"의 경우는 "self" 라는 선택 가지 하나만 있고, 분수 "1/3"의 경우는 "self" 선택가지와 더불 어 "numerator", "denominator"라는 선택 가지가 있습니다. 소수 "32.1"의 경우는 "self"와 함께 "1"부터 "8"까지의 여덟 개의 선택 가지가 표시되고 있습니다. 앞에서도 이야기한 것과 같이 탐색기의 왼쪽 널에는 현재 탐색하고 있는 객 체 자신(self)과 함께 그 객체의 성분이 표시된다고 했습니다. 따라서 정수 "27"의 경우는 아무런 성분을 가지지 않고 있음을 알 수 있습니다. 반면 "1/3"과 "32.1"의 경우는 나름으로의 성분을 가지고 있습니다. Smalltalk의 객체는 크게 성분을 가지지 않는 "홀객체"와 하나 이상의 성분 으로 이루어져 있는 "핫객체"로 나누어볼 수 있습니다. 과학에서도 더 이상 쪼갤 수 없는 원자가 있는가 하면 여러 가지 성분으로 하나의 물체를 이루는 것들도 있습니다. Smalltalk에서도 객체 자체로써 존재하는 것들이 있는가 하면 하나 이상의 성분으로 구성된 객체가 있는 것입니다. 위의 결과를 보면 정수, 정확히 말하면 작은 정수(SmallInteger) 갈래에 속 한 실체들은 성분을 가지지 않으며, 분수와 소수의 경우는 성분을 가진다는 것을 발견할 수 있습니다. 그런데 이러한 객체를 이루는 성분에도 두 가지 종류가 있습니다. 먼저 분수 "1/3"을 관찰해 봅시다. 분수의 경우는 분자를 나타내는 "numerator"와 분모 를 나타내는 "denominator"라는 두 개의 성분이 있습니다. 이 성분에는 이름 이 붙어 있습니다. 이렇게 객체의 성분 중에 이름이 붙은 성분을 "이름 붙은 성분"(named part)이라고 부릅니다. 반면 "32.1"과 같은 소수 객체는 "1"부 터 "8"까지 여덜 개의 성분이 존재합니다. 이들 성분에는 나름대로 번호가 붙어 있는데, 이렇게 객체를 이루는 성분에 번호가 붙은 것을 "번호 붙은 성 분"(indexed part)이라 부릅니다. 이름붙은 성분의 경우 대부분 우리는 이 성분이 무엇을 의미하는지를 쉽게 알 수 있습니다. "1/3" 객체의 "numerator"는 분자 "1"을 가리킨다는 것을 우리는 쉽게 알 수 있습니다. 반면 "32.1"을 구성하고 있는 여덜 개의 번호 붙은 성분을 탐색기를 이용하여 탐색해 봅시다. 전혀 알 수 없는 값으로 이 루어져 있습니다. 이는 번호 붙은 성분의 경우는 객체 자체를 컴퓨터가 처리 하기 쉽게 분해하여 저장해 놓기 때문입니다. 실제로 소수의 경우는 여덜 개 의 바이트(byte)로 이루어진 객체입니다. 바이트는 컴퓨터에서 정보를 기억 시킬 때 기본 단위로 사용하는 것인데, 주로 번호 붙은 성분의 경우는 이렇 게 객체를 바이트별로 분해해서 저장해 놓습니다. 각각의 바이트에 들어있는 값이 무엇을 의미하는지, 그리고 또한 이런 바이트와 정보 저장의 관계는 무 엇인지 등은 지금 당장은 알아둘 필요가 없습니다만, 컴퓨터 프로그래밍의 깊은 곳을 공부한다거나 컴퓨터 구조를 알아야 하는 경우에는 필요할지도 모 르는 기법입니다. 아무튼 Smalltalk를 공부함에 있어서 이러한 세부적인 사 항을 알 필요는 없기 때문에 여기서도 그냥 번호 붙은 성분이 이런 것이구나 정도만 알아두면 되겠습니다. 여기까지 오면서 필자가 걱정되는 것이 하나 있습니다. 바로 여러분이 Smalltalk에 대한 흥미를 조금씩 잃지나 않을까 하는 것입니다. 사실 아무리 좋은 것이라도 하루 이틀이 지나면 지겨워지기 마련입니다. 하기야 "200 factorial"을 아무렇지도 않게 구해내는 Smalltalk가 처음에는 매우 신기해 보이겠지만, 계속 이렇게 수만 다루다 보니 이제는 슬슬 흥미를 잃게 되는 것도 어쩌면 당연한 일일지도 모르겠습니다. 물론 어떤 프로그래밍 언어를 막론하고 기본적으로 수를 제대로 다룰 수 있어야만 하기 때문에 우리도 예 외 없이 수를 많이 다루어왔습니다. 그러나 이제부터는 수 아닌 다른 객체들 에 대해서 조금씩 알아보도록 하겠습니다. 앞서 우리는 어떤 객체에게 지시를 내렸을 때 "그렇다"(true)나 "아니 다"(false)와 같이 참값이나 거짓값으로 된 결과를 얻은 적이 있습니다. 기 억나십니까? 바로 아래의 글토막들은 모두 참이나 거짓의 값을 나타내게 됩 니다. 10 isKindOf: Integer ☞ true 0 between: 1 and: 10 ☞ false 2 = 2.0 ☞ true 참을 나타내는 "true"나 거짓을 나타내는 "false" 역시 당당한 Smalltalk의 객체입니다. 따라서 이들 객체 또한 "inspect" 지시를 알아들을 수 있으며, 이는 곧 이들 객체들도 탐색기를 통해 속을 들여다볼 수 있음을 의미합니다. 이제 말이 난 김에 "true"와 "false"에 "inspect" 지시를 내려서 이들 객체 의 속을 들여다보도록 합시다. true inspect false inspcet 위의 글토막을 가늠하면 다음 <그림 2-9>와 같은 결과를 얻게 됩니다. <그림 2-9> 탐색기로 들여다 본 true와 false (Stp2-9.gif) <그림 2-9>를 보면 "Inspecting a True"와 "Inspecting a False"라는 제목을 가진 두 개의 탐색기가 있습니다. 여기서 우리는 "true"는 "True" 갈래에 속 하고, "false"는 "False" 갈래에 속한다는 것을 짐작할 수 있는데, 뭔가 좀 이상한 것 같습니다. 이것은 Smalltalk에서 "부울 값"(boolean)이라고도 불 리는 논리값을 표현하기 위해서 사용하는 하나의 방법입니다. 이미 눈치를 채신 분이 있을지도 모르겠지만, Smalltalk에서는 대문자와 소문자를 구별합 니다. 그래서 "false"와 "False"는 같은 철자로 이루어진 낱말이라 하더라도 대소문자를 구분하는 Smalltalk는 이를 서로 다른 의미를 가진 낱말로 알아 듣습니다. Smalltalk에서 모든 갈래의 이름은 대문자로 시작하게끔 되어있기 때문에 "false"는 정확하게 "False"라는 이름을 가진 갈래에 속한 실체인 것 입니다. 이렇게 장황하게 설명은 했지만, 실제로 "false"와 "true"의 속을 들여다 보 면 별 것이 없습니다. 왜냐하면 "true"와 "false"는 성분을 가지고 있지 않 은 홀객체이기 때문입니다. :) 이 두 개의 객체들에 대해서도 "class"와 "superclass" 지시를 사용하여 갈 래씻줄(class hierarchy)을 더듬어봅시다. true class ☞ True True superclass ☞ Boolean Boolean superclass ☞ Object false class ☞ False False superclass ☞ Boolean Boolean superclass ☞ Object "true"와 "false"는 모두 "Boolean" 갈래에 씻줄로 얽혀있다는 것을 알 수 있습니다. 뒤에서 살펴보겠지만 논리값(Boolean)은 어떤 사실의 판단을 통하 여 얻을 수 있는 값이기 때문에, 이 논리값이 알아들을 수 있는 여러 가지 지시를 통하여 프로그램의 실행 흐름을 자유롭게 조절할 수 있게 됩니다. 일 단 논리값이 알아들을 수 있는 지시에 대해서는 조금 있다가 생각해 보기로 히고, 여기서는 참값과 거짓값이 어떤 갈래씻줄로 얽혀있는지를 살펴보기 바 랍니다. 마지막으로 알아볼 객체는 "헛"(nil)입니다. 다음과 같이 하면 "헛"을 결과 값으로 얻을 수 있습니다. Object superclass ☞ nil "nil"은 "아무 것도 없는, 비어 있는, 공허한"의 뜻을 가지고 있습니다. Smalltalk에서는 객체에게 어떤 지시를 내렸을 때 해당하는 값이 없거나 잘 못되었다는 의미로 사용됩니다. 모든 갈래씻줄의 뿌리가 "Object" 갈래이기 때문에 결국 "Object" 갈래의 윗갈래는 있을 수 없습니다. 따라서 "Object" 갈래에게 "superclass" 지시를 내리면 당연히 결과값으로 "헛"(nil)을 남기 게 되는 것입니다. "nil"도 엄연한 객체이기 때문에 "inspect" 지시를 알아듣습니다. nil inspect 위의 글토막을 실행시키면 <그림 2-10>과 같이 "Inspecting a Undefind Object"라는 제목을 가진 탐색기가 나타날 것입니다. "nil" 객체 역시 아무 런 성분을 가지고 있지 않는 홀객체라는 것을 알 수 있습니다. <그림 2-10> 탐색기로 들여다 본 nil (Stp2-10.gif) "nil" 역시 갈래씻줄을 가지고 있습니다. Smalltalk의 모든 것이 객체라는 것과, 객체는 각각의 갈래에 속해있으며, 그 갈래는 다른 갈래들과 씻줄로 얽혀있다는 것, 이제는 귀가 따감도록 들어 온 사실이기에, 잊어버리지 않을 것입니다. :) nil class ☞ UndefinedObject UndefinedObject superclass ☞ Object "nil"이 속해 있는 "UndefindObject"라는 갈래는 "알 수 없는 객체"쯤으로 번역해볼 수 있습니다. "nil"이라는 객체의 성질을 참으로 잘 표현하고 있는 갈래라는 것을 알 수 있습니다. 여하튼 "nil" 역시 엄연한 객체이며, 이 객 체 역시 "UndefinedObject"라는 갈래에 속해있다는 것을 알 수 있었습니다. 그런데 혹 Object superclass ☞ nil 의 결과를 보고, "nil"에게 "superclass" 지시를 내릴 수 있을까 하는 의문 을 갖는 사람들이 있을지도 모르겠습니다. "nil"은 갈래가 아니기 때문에 당 연히 "superclass" 지시를 알아듣지 못합니다. 실제로 실험을 해 보면 "UndefinedObject does not understand #superclass"라는 제목이 달린 발자 취창이 나타남을 알 수 있을 것입니다. nil superclass 여하튼 "nil"은 객체이기는 하지만 갈래는 아니기 때문에 갈래가 알아들을 수 있는 "superclass" 지시는 알아듣지 못합니다. ---<잠깐!>----------------------------------------------------------- 갈래 씻줄의 의미와 객체의 성분 이 나눔을 닫기 전에 한 가지 짚고 넘어갈 것이 있습니다. 그것은 갈래 씻줄 과 겉으로 드러나는 실제 객체의 모양은 큰 상관이 없다는 것입니다. 조금 애매한 말처럼 들린다면 아래와 같이 따져서 생각해 봅시다. 다음 글토막을 펴 보십시오. 10 factorial class ☞ SmallInteger 100 factorial class ☞ LargeInteger "10 factorial"의 결과값은 분명히 "SmallInteger" 갈래에 속한 실체이고, "100 factorial"의 결과값은 "LargeInteger"에 속한 실체일 것입니다. 물론 작은 정수와 큰 정수는 모두 같은 정수 무리이기 때문에 10 factorial isKindOf: Integer ☞ true 100 factorial isKindOf: Integer ☞ true 은 너무나도 당연한 결과입니다. 그러나 10 factorial inspect 100 factorial inspect 위의 글토막을 가늠하여 작은 정수와 큰 정수의 실체를 탐색해 보면 두 객체 의 구조는 서로 다르다는 것을 알 수 있습니다. <그림 2-11> SmallInteger와 LargeInteger의 구조 작은 정수가 홀객체인데 반해서 큰 정수는 번호 붙은 성분을 여럿 가지고 있 는 핫객체인 것입니다. 이 경우는 68개의 번호 붙은 성분을 가지고 있지만 실제로 큰 정수의 경우에는 값의 크기에 따라 서로 다른 수의 번호 붙은 성 분을 가지고 있습니다. 여하튼 의미론적으로 볼 때 작은 정수와 큰 정수는 모두 정수라는 갈래에 딸 려 있지만, 그렇다고 해서 두 객체의 구조가 같다는 말은 아니라는 것을 알 아두면 좋겠습니다. Smalltalk에서는 겉으로 드러나는 모습은 같지만 속은 전혀 다른 객체들이 여럿 존재합니다. ----------------------------------------------------------- 지금까지 우리는 객체를 이루는 성분에 대해서 알아보았습니다. 정수, 참, 거짓, 헛(nil)처럼 성분을 가지지 않는 홀객체가 있는가 하면, 분수처럼 이 름 붙은(named) 성분으로 이루어진 객체가 있고, 또한 소수처럼 번호 붙은 (indexed) 성분으로 이루어진 객체도 있다는 것을 알 수 있었습니다. 사실 앞으로 우리들이 다루는 대부분의 객체는 홀객체가 아닌, 성분을 가지고 있 는 핫객체입니다. 성분이 있다는 것은 그만큼 객체가 복잡하고 또한 하는 일 이 많음을 의미합니다. 바로 다음 나눔에서 알아볼 글자(character)와 글줄 (string)부터는 수 갈래에 속하지 않은 또 다른 객체의 세계에 대해서 경험 할 수 있게 될 것입니다. 계속... 제 목:[강좌] Smalltalk 배우기 #15 관련자료:없음 [24] 보낸이:김찬홍 (안드래아) 1999-01-03 17:38 조회:153 Smalltalk 배우기 #15 1999. 1. 3. 김찬홍 mailto:andrea92@hitel.net ====================================== 2. 객체들과 나누는 이야기 2.1. 객체? 2.2. 몸으로 느끼기 2.3. 객체의 안쪽 2.3.1. 탐색기 사용하기 2.3.2. 객체의 성분 a→2.3.3. 글자와 글줄 ...... ======================================= 2. 객체들과 나누는 이야기 ------------------------------------ 2.3. 객체의 안쪽 ~~~~~~~~~~~~~~~~ 2.3.1. 글자와 글줄 ------------------ 컴퓨터(computer)는 그 이름에서도 알 수 있듯이 "계산을 하기 위해서" 만들 어졌습니다. 처음 컴퓨터가 만들어질 때는 세계가 전운에 휩싸였던 때이고, 어떻게 하면 대포를 정확한 각도에서 발사하여 목표물을 맞출 수 있을지를 계산하기 위해서 바로 컴퓨터가 사용되었습니다. 지금은 멀티미디어 시대인 만큼 컴퓨터로 처리할 수 있는 자료의 범위가 대단히 많아졌습니다. 그러나 실제로 이러한 자료들은 컴퓨터 내부에서는 모두 수(數)로 바뀌어 처리됩니 다. 그래서 이러한 수로 이루어진 자료들을 '디지털 자료'(digital data)라 고 부릅니다. '디지털'은 수를 구성하는 낱낱의 자리를 의미하는 "digit"에 서 나온 말이라는 것을 생각하면, 컴퓨터가 모든 자료를 수로 바꾸어 처리하 는 것은 당연한 일이라고 하겠습니다. 프로그래밍 언어를 처음 공부할 때에 수를 매우 중요하게 생각하고, 수를 다 루는 방법을 많이 다루는 것도, 결국은 컴퓨터의 모든 자료들이 기본적으로 수로 처리되기 때문입니다. 이는 Smalltalk에서도 마찬가지입니다. Smalltalk가 여러 가지 객체를 다루기는 하지만, 실제로 컴퓨터는 이들을 모 두 수로 바꾸어 처리합니다. 앞서 정수, 소수, 분수와 같은 여러 종류의 수 들을 다룬 것도, 기본적으로 이런 수(Number) 갈래에 속한 객체들이 가장 다 루기 쉽고 기본적인 지시들을 알아들을 수 있기 때문입니다. 이제 여러분은 Smalltalk에서 객체를 다루는 여러 가지 방법을 공부해 보았으므로, 이제부 터는 수가 아닌 다른 종류의 객체들을 다루어보도록 합시다. 컴퓨터에서 수 다음으로 중요한 자료를 꼽으라면 바로 글자와 글줄을 들 수 있겠습니다. 지금 필자가 글을 쓰기 위해서 사용하고 있는 문서 편집기 역시 글자를 다루고 있으며, 여러분이 통신상에서 필자의 글을 읽을 수 있는 것도 바로 컴퓨터가 글자를 다룰 수 있기 때문입니다. 이 나눔에서 여러분들은 Smalltalk에서는 이러한 글자와 글줄을 어떻게 나타내고, 또한 이들 객체를 이용해서 어떤 일을 할 수 있는지를 알아보도록 하겠습니다. Smalltalk에서 한 개의 글자는 다음과 같이 나타냅니다. 아래 글토막을 펴 보십시오. $a ☞ $a $b ☞ $b $A ☞ $A $! ☞ $! $1 ☞ $1 $2 ☞ $2 보는 바와 같이, Smalltalk에서 글자 한 개를 나타내려면 "$"와 함께 표시하 고싶은 글자를 적어주면 됩니다. $A, $B, $a, $b 의 경우는 영문자가이고, $1 이나 $2 의 경우는 숫자이며, $! 의 경우는 '느낌표'를 나타냅니다. 그럼 Smalltalk는 ㄱ, ㄴ, ㄷ과 같은 한글의 낱글자를 어떻게 알아들을까요? 다음 글토막을 펴 봅시다. $ㄱ "Invalid expression start 잘못 발생" 위의 글토막을 펴게 되면 "Invalid expression start"라는 잘못을 내게 됩니 다. 이 말은 결국 한글의 낱글자는 글자로써 다룰 수 없음을 의미합니다. 만 약 Smalltalk가 우리 나라에서 만들어졌다면 한글도 하나의 글자로 처리할 수 있겠지만, 불행하게도 Smalltalk를 비롯한 컴퓨터의 여러 가지 산물은 영 어권 문화에서 만들어졌기 때문에 한글에 대한 처리는 상대적으로 미약한 편 입니다. 물론 바로 다음에 이야기할 글줄을 이용하여 한글을 나타낼 수는 있 습니다만, 이에 관해서는 조금 뒤에 알아보도록 하겠습니다. 그럼 이제 이 글자는 어떤 갈래에 속해 있으며, 어떤 씻줄로 얽혀있는지를 살펴봅시다. 글자 역시 엄연한 객체라는 사실을 잊지 않도록 합시다. $a class ☞ Character $b class ☞ Character $A class ☞ Character $B class ☞ Character $! class ☞ Character $1 class ☞ Character $2 class ☞ Character Character superclass ☞ Magnitude Magnitude superclass ☞ Object 영문자나 숫자, 또는 느낌표와 같은 여러 가지 기호들은 모두 "Character" 갈래의 실체(instance)입니다. 따라서 이들 글자에게 "class" 지시를 보내면 결과로써 "Character" 갈래를 남기게 됩니다. 이렇게 해서 남겨진 "Character" 갈래에 "superclass" 길표를 이용해서 씻줄 을 더듬어 올라갈 수 있습니다. 결국 "Character"(글자)는 "Magnitude"(크기 값)이고, 동시에 "Object"(객체)입니다. 모든 객체는 "inspect" 지시를 알아들을 수 있기 때문에, 글자 역시 똑같이 "inspect" 지시를 알아들을 수 있습니다. $a, $A, $! 세 개의 글자를 탐색해 봅시다. $a inspect $A inspect $! inspect 위의 세 개의 글토막을 하나씩 가늠하거나 $a, $A, $! 객체를 각각 글쇠를 이용하여 탐색하게 되면 다음 <그림 2-12>와 같이 세 개의 탐색기가 열린 화면을 볼 수 있을 것입니다. <그림 2-12> $a, $A, $! 를 탐색한 모습 (Stp2-12.gif) 탐색기에서 볼 수 있듯이 "Character" 갈래에 속한 객체들은 모두 "ascii Value"라고 하는 성분을 가지고 있는 핫객체입니다. 이 "asciiValue" 성분에 는 어떤 값이 들어있을까요? $a 객체의 "asciiValue"를 탐색해 봅시다. $a를 표시하고 있는 탐색기의 왼쪽 널(pane)에서 "asciiValue" 선택가지를 돋이시 키면 다음 그림과 같이 "asciiValue"의 값을 볼 수 있을 것입니다. <그림 2-13> $a 객체의 성분 "asciiValue"의 탐색 (Stp2-13.gif> ---<잠깐!>---------------------------------------------------------- Dolphin Smalltalk의 심각한 문제 그런데 여기서 필자를 당황하게 하는 일이 일어났습니다. 바로 탐색기의 오 른쪽 널에 무언가 심상치 않은 값이 나타났기 때문입니다. 다음과 같은 글귀 가 나타났는데, 과연 이것이 "asciiValue"의 값일까요? ---------------------------------------------------------- an invalid UndefinedObject [should not implement] Evaluate the following expression to debug: asciiValue printString ---------------------------------------------------------- 위의 말을 풀이해 보면 탐색기가 "asciiValue"의 값을 표시하는 데에 무언가 문제가 있으며, 문제를 해결하기 위해서는 "asciiValue printString"이라는 글토막을 가늠해 보라는 것입니다. 필자가 처음 이 상황을 만났을 때 매우 당황했습니다. 그 당시는 모든 것이 낯설었던 Smalltalk를 처음 배우는 시기였으므로, 도대체 뭐가 어떻게 된 건 지를 알 수 없었습니다. 한 술 더 떠서 이 상태에서 "asciiValue"를 두 번 눌러서 연계 탐색 기능을 동작시키면 발자취 창이 표시되었으니, 황당했던 것은 이루 말할 수 없었습니다. 그러나 침착하게 일단 Smalltalk가 하라는 대로 다음의 글토막을 가늠해 보았습니다. asciiValue printString ☞ '97' 위의 글토막을 펴 본 화면이 다음의 <그림 2-14>입니다. <그림 2-14> Smalltalk가 제시한 글토막으로 얻은 asciiValue의 값 (Stp2-14.gif) 비로소 필자는 $a 객체의 성분인 "asciiValue"의 값을 얻을 수 있었습니다. $a 객체의 "asciiValue"의 값은 97이었던 것입니다. 원래 "asciiValue" 성분은 정수값을 가지고 있어야 합니다. 따라서 제대로 되었다면 오른쪽 널에 정수값 97이 표시되어야 옳습니다. 그러나 어찌된 일 인지 Dolphin Smalltalk는 잘못된 결과를 출력했으며, 사용자에게 직접 이 성분의 값을 출력하도록 하고 있습니다. 인터넷의 뉴스그룹에 이 사실을 통보했었습니다. 그래서 얻은 답은 바로 이 것이었습니다. 현재 Dolphin Smalltalk는 한글과 같이 여러 나라의 글자들을 처리하기 위해서 제정된 UniCode라는 것을 구현하고 있는 중이랍니다. 일단 급한 대로 UniCode가 지원되지 않은 Smalltalk를 내놓았는데, 글자를 다루는 일부 기능에서 문제가 생겼다는 것이 Object Arts사의 주장입니다. 결국 "Character" 갈래에 속한 객체의 "asciiValue" 값을 제대로 표시하지 못하는 것도 이러한 이유 때문이라고 합니다. 어쨌건 좀 불편하더라도 "Character" 갈래에 속한 객체의 "asciiValue" 값을 탐색할 때에는 조금 불편하더라도 Smalltalk가 제시해 주는 글토막을 가늠하는 수밖에는 없을 것입니다. 하루 빨리 이 문제가 해결되기를 바랄 뿐이지요. 필자가 실험해 본 결과 Smalltalk Express의 경우는 제대로 결과를 나타내는 것으로 확인되었습니다. ---------------------------------------------------------- $a의 "asciiValue" 값은 97이었습니다. 그럼 $A의 경우는 얼마일까요? 역시 앞서와 같은 방법으로 $A 객체의 "asciiValue" 성분의 값을 알아보면, 65라 는 것을 알 수 있습니다. 마찬가지로 $! 의 경우는 33이라는 것을 알 수 있 습니다. 자, 과연 이 "asciiValue"는 무슨 의미를 가지고 있는 성분일까요? 앞에서 컴퓨터는 모든 자료를 수로 바꾸어서 처리한다고 이야기했습니다. 정 수는 물론이고 소수나 분수 모두 결국은 수로 이루어진 객체들이었습니다. 이는 글자도 예외가 아니어서, 컴퓨터가 글자를 처리하기 위해서는 역시 글 자도 수로 다루어야 했고, 결국 글자에 번호를 붙여서 나타내게 되었습니다. 그런데 글자에 번호를 붙이는 방법이 한 가지만 있는 것이 아니라는 것입니 다. 컴퓨터가 처음 만들어졌을 때만 하더라도, 컴퓨터를 만들어서 팔던 회사 들은 저마다 나름대로 글자에 번호를 붙였습니다. 이렇게 컴퓨터마다 글자에 번호를 붙이는 약속이 달랐기 때문에, 가령 "가"라고 하는 컴퓨터에서 다루 었던 글자를 "나"라는 컴퓨터는 전혀 다른 글자로 알아듣게 된 것입니다. 이 렇게 되면 정보의 호환성이 떨어지게 되고, 이런 폐단을 없애기 위해서 여러 사람이 똑같은 약속으로 글자에 번호를 붙이게 되었습니다. 마침내 미 국립 표준 위원회(ANSI: American National Standard Institute) 에서는 ASCII(American Standard Code for Information Interchange, 정보 교환용 미국 표준 코드)를 제정하게 됩니다. 따라서 ASCII라는 약속을 따르 는 컴퓨터에서는 글자에 번호를 붙이는 방식이 모두 똑같이 되었습니다. "Character" 갈래에 속한 모든 글자의 실체(instance)들이 가지고 있는 성분 인 "asciiValue"는 바로 위에서 말한 글자의 ASCII 값이 들어 있습니다. 따 라서 글자 $a의 ASCII 값은 97, $A의 경우는 65이며, $!의 경우는 33이 되는 것입니다. 모든 글자에 ASCII 값이 부여되어 있으므로, 탐색기를 통해서 각 글자에 매 겨진 ASCII 값을 정리하여 표로 만들어볼 수 있을 것입니다. 그러나 모든 글 자에 대한 번호표를 일일이 만드는 것은 지루한 일이므로, 여러분의 수고를 필자가 덜어드리겠습니다. 아래 표는 글자와 ASCII 값의 대응을 정리한 것입 니다. ---------------------------------------------------------- 글자 ASCII 값 ---------------------------------------------------------- $a ... $z 97 ... 122 $A ... $Z 65 ... 90 $0 ... $9 48 ... 57 $( 40 $) 41 $$ 36 $. 46 $, 44 $<빈칸> 32 $<줄바꿈> 13 ---------------------------------------------------------- 위의 번호료를 보면 몇 가지 재미있는 사실을 발견할 수 있습니다. 우선, 대문자에 붙여진 번호가 소문자의 글자 번호보다 크다는 것입니다. 즉 대문자 $A의 경우는 65, 소문자 $a의 경우는 97이라는 것이 이를 증명해 줍 니다. 더욱이 대문자와 소문자 사이에는 정확하게 32라는 차이가 있습니다. 97에서 65를 빼 보면 32라는 값이 나옴을 알 수 있는 것이지요. 그래서 만약 대문자 $A의 값인 65에 32를 더하면 소문자 $a의 값인 97이 됩니다. 숫자의 경우도 생각해 봅시다. 수는 기본적으로 영문자보다 더 낮은 번호를 가지고 있습니다. 그리고 이러한 숫자들과 실제의 값에는 아무런 관계가 없 다는 것을 알 수 있습니다. $0의 경우 컴퓨터는 이를 "0"이라는 값으로 처리 하는 것이 아니라 "48"이라는 값으로 처리합니다. 그러므로 숫자와 그 숫자 가 의미하는 값은 서로 차이가 있다는 것을 알아야 합니다. 또한 모든 글자에는 ASCII 값이 부여되어 있습니다. $$, $., $, 등과 같은 모든 글자에는 나름으로의 번호가 붙어 있으며, 심지어는 눈에 보이지 않는 빈칸과 줄을 바꿀 때 사용하는 줄바꿈 글자 역시 번호를 가지고 있습니다. 글자가 컴퓨터 내부에서 다루어질 때에는 이렇게 번호가 붙은 값으로써 처리 됩니다. 따라서 글자 객체에게 그 자신을 나타내는 ASCII 값이 몇인지를 물 어볼 수 있습니다. 이는 글자 객체에게 "asciiValue"라는 지시를 보냄으로써 가능합니다. 다음의 글토막을 펴 봅시다. $a asciiValue ☞ 97 $A asciiValue ☞ 65 $0 asciiValue ☞ 48 $( asciiValue ☞ 40 앞서 빈칸과 줄바꿈 글자 역시 번호를 가지고 있다고 했으므로, 다음과 같이 실험을 해 봅시다. $ asciiValue ☞ 32 $ 다음에 빈칸이 있습니다. 우리 눈에는 이 빈칸이 보이지 않지만 컴퓨터는 이를 엄연히 하나의 글자로 처리합니다. 이는 줄바꿈 글자도 마찬가지입니 다. 다음의 글토막을 펴 봅시다. 글토막이 두 줄이므로 덩이를 씌운 다음 펴 야 한다는 것쯤은 이제는 아시겠지요? --------------------------------------- $ asciiValue ☞ 13 --------------------------------------- 글쇠판에서 "$"를 누른 다음 바로 글쇠를 눌러서 줄을 바꾸고 이어 서 "asciiValue"를 입력한 다음 방금 입력한 두 줄에 덩이를 씌웁니다. 마지 막으로 글쇠판에서 를 입력하면 위와 같이 글토막을 가늠할 수 있습 니다. 필자가 정리한 대로 빈칸의 경우는 32가, 줄바꿈의 경우는 13이 결과 값으로 나타났습니다. 글자에게 "asciiValue" 지시를 보냄으로써 해당하는 ASCII 값을 얻을 수 있 었다면, ASCII 값을 해당하는 글자로 바꾸어줄 수 있는 방법은 없을까요? 물 론 있습니다. 똑똑한 정수는 "asCharacter"라는 지시를 알아듣고, 지시를 받 은 값에 해당하는 글자를 결과값으로 남깁니다. 다음 글토막을 펴봅시다. 97 asCharacter ☞ $a 65 asCharacter ☞ $A 48 asCharacter ☞ $0 42 asCharacter ☞ $* 43 asCharacter ☞ $+ 따라서 필요하면 수를 글자로 다룰 수도 있으며, 글자에 해당하는 수로 바꾸 어서 다룰 수도 있습니다. 이런 특성을 이용하면 다음과 같은 글토막을 만들 수 있습니다. ($a asciiValue + 1) asCharacter ☞ $b 위의 글토막은 $A라는 글자의 바로 다음 글자를 얻는 바탕글입니다. 우선 $A 에 "asciiValue" 지시를 보내서 수로 바꿉니다. 이렇게 바뀌어진 수는 계산 에 사용할 수 있으므로, 이 수에 1을 더합니다. 그런 다음 이렇게 해서 계산 된 수에 "asCharacter" 지시를 보내면, 결국 $A의 다음 글자인 $B를 얻을 수 있는 것입니다. 길표의 우선권 규칙을 제대로 따져서 생각하면 위의 글토막 이 왜 $B를 결과값으로 남겼는지를 따져서 생각할 수 있을 것입니다. "Character" 갈래에 속한 객체들은 "asciiValue"와 더불어 여러 가지 많은 지시를 알아들을 수 있습니다. 주로 해당 글자가 어떤 종류의 것인지를 검사 하거나, 영문자의 경우 대소문자의 변환 등을 처리하는 역할을 하고 있습니 다. 이제부터는 글자 객체아 알아들을 수 있는 몇 가지 지시들을 알아보도록 하겠습니다. $A isUppercase ☞ true $A isLowercase ☞ false $a isUppercase ☞ false $a isLowercase ☞ true "isUppercase", "isLowercase"는 "대문자인가", "소문자인가"로 읽을 수 있 습니다. 즉 이 지시를 받은 글자가 대문자인지 혹은 소문자인지를 검사해서 참값(true)이나 거짓값(false)을 결과값으로 돌려줍니다. 만약 영문자가 아닌 숫자가 기호에 "isUppercase"나 "isLowercase" 지시를 내리면 어떤 반응을 보일까요? $+ isUppercase ☞ false $+ isLowercase ☞ false 두 경우 모두 거짓값을 남겼습니다. 영문자가 아니라는 말은 결국 대문자도 아니고 그렇다고 소문자도 아니라는 말입니다. 그러므로 영문자가 아닌 글자 들이 "isUppercase"나 "isLowercase"에 대해서 거짓값을 남기는 것은 당연한 것이겠지요. 영문자에게 "asUppercase"와 "asLowercase"라는 지시를 보냄으로써 대문자는 소문자로, 소문자는 대문자로 바꿀 수 있습니다. 다음을 보십시오. $a asUppercase ☞ $A $A asUppercase ☞ $A $+ asUppercase ☞ $+ $A asLowercase ☞ $a $A asLowercase ☞ $a $+ asLowercase ☞ $+ 대문자에게 "asLowercase" 지시를 보내면 결과값으로 소문자를 남기고, 소문 자에게 "asUppercase" 지시를 보내면 결과값으로써 대문자를 남깁니다. 그리 고 대문자에게 "asUppercase"지시를 보내거나, 소문자에게 "asLowercase" 지 시를 보내거나, 영문자가 아닌 글자에 이들 지시를 보내면 결과값은 변화가 없습니다. 이처럼 "asUppercase", "asLowercase" 지시는 영문에 대해서 대문 자와 소문자의 변환을 수행하는 중요한 길표입니다. 이제 마지막으로 세 개의 길표를 더 알아보고자 합니다. 아래의 글토막들을 차례로 가늠해 보고 각 지시가 어떤 일을 하는지를 눈여겨 보시기 바랍니다. $a isLetter ☞ true $A isLetter ☞ true $+ isLetter ☞ false $0 isLetter ☞ false "isLetter"는 지시를 받은 글자가 영문자이면 참을, 그렇지 않으면 거짓을 남깁니다. $a isDigit ☞ false $A isDigit ☞ false $+ isDigit ☞ false $0 isDigit ☞ true "isDigit"는 지시를 받은 글자가 숫자이면 참을, 그렇지 않으면 거짓을 남깁 니다. $a isVowel ☞ true $A isVowel ☞ true $x isVowel ☞ false $X isVowel ☞ false "isVowel"은 지시를 받은 글자가 영어의 모음(a, e, i, o, u, A, E, I, O, U)이면 참을, 그렇지 않으면 거짓을 남깁니다. Smalltalk에서 "is~"로 시작하는 길표는 객체의 어떤 상태를 조사하는 일을 합니다. 해당하는 상태가 맞으면 참을, 그렇지 않으면 거짓을 남깁니다. 또 한 "as~"로 시작되는 지시는 한 객체를 다른 객체로 바꾸는 일을 합니다. 이 를태면 정수 객체에게 "asCharacter" 지시를 보낸다는 것은, "Character" 갈 래에 속한 객체로 바꾼다는 말이며, "asLowercase"는 대문자로 바꾼다는 의 미를 가지고 있습니다. 지금까지 우리는 글자 객체에 대해서 여러 가지 지시를 내려보았습니다. Smalltalk에서의 글자는 매우 간단한 객체이기는 하지만, 바로 다음에 살펴 볼 글줄을 이루는 매우 중요한 요소입니다. 이제 글자에 대해서 여러 가지를 알아보았으므로, 다음에는 글줄에 대해서 알아보도록 하겠습니다. ---<잠깐!>---------------------------------------------------------- Smalltalk의 이식성 흔히 C나 C++ 언어의 특징을 설명할 때 "이식성이 좋다"는 말을 많이 합니 다. 이식성이 좋다는 말은 한 시스템에서 작성된 프로그램을 다른 시스템으 로 옮기기가 쉽다는 말인데, Smalltalk 역시 이러한 이식성이 매우 좋은 언 어에 속합니다. 실제로 Smalltalk 시스템에 따라서 글자를 나타내거나 구현하는 방법이 조금 씩 다릅니다. 일례로 Dolphin Smalltalk의 경우에는 "Character"에서 ASCII 값을 저장하기 위해서 "asciiValue"라는 성분을 사용하고 있지만, Smalltalk Express의 경우에는 "asciiInteger"라는 성분을 사용합니다. 그러나 글자의 ASCII값을 알아보기 위해서는 똑같이 "asciiValue"라는 지시를 사용합니다. 즉 객체의 내부가 어떻게 이루어져있는지는 프로그래머에게 문제가 되지 않 습니다. 단지 그 객체를 다루는 방법만 알고 있으면 되는 것입니다. Smalltalk의 이러한 특성은 한 시스템에서 만든 프로그램을 다른 시스템으로 올미기 쉽도록 합니다. 양쪽 시스템에 동일한 객체가 존재하면, 그 객체의 성분이 어떻든 서로 똑같은 프로그램을 돌릴 수 있습니다. 즉 "asciiValue"를 성분으로 갖는 Dolphin Smalltalk의 경우나 "ascii Integer"를 성분으로 갖는 Smalltalk Express의 경우 모두 "asciiValue"라는 지시는 변함이 없으므로, 두 Smalltalk 시스템에서 똑같이 $a asciiValue 라는 지시를 이용할 수 있습니다. 따라서 이와 같은 특성은 C나 C++보다 Smalltalk가 보다 더 이식성을 좋게 만드는 특징이라 하겠습니다. ---------------------------------------------------------- 계속... 제 목:[답변/26] 스몰토크에 대해서 관련자료:없음 [27] 보낸이:김찬홍 (안드래아) 1999-01-09 01:38 조회:179 ---------------------------------------------------------- 안녕하세요, 한 재윤입니다. 선생님의 스몰토크 강의를 열심히 청강중인 착한 학생입니다. 선생님께 칭찬받으려고 이렇게 질문도 합니다. 질문드립니다. ---------------------------------------------------------- 안녕하십니까? 우선 제 글을 읽어주셔서 감사합니다. 글을 쓰는 제 입장 으로는 한 분이라도 제 글을 읽어주시고, 그로써 무엇인가 얻어 가시는 것이 있다면 정말 기쁜 일이 아닐 수 없습니다. 여태껏 강좌를 진행하면 서 질문을 받아본 게 처음이군요. 여하튼 제가 알고있는데까지 대답해 드리겠습니다. ---------------------------------------------------------- 첫번째! 쇠마디 지시에서 중간에 끼는 and: 나 to: 등은 그 자체로서 어떤 지시인가요? 지시라면 도대체 뭐라고 대답하는거죠? 그게 아니면 isKindOf: 와 and: 가 합쳐져서 하나의 지시인가요? 이런 지시를 정의할때는 어떻게 하는지 무지 궁금하네요. ---------------------------------------------------------- 쇠마디 지시(keyword message)에 대해서 물으셨습니다. 일단 쇠마디 지 시가 들어있는 글토막을 살펴봅시다. 5 between: 1 and: 10 ☞ true 를 보면 정수 객체 "5"에게 "between: 1 and: 10"이라는 지시가 전달된 것입니다. 일단 위의 글토막을 아래처럼 잘라서 생각해 봅시다. 받는이 지시 ______ __________________________________________ 5 between: 1 and: 10 ~~~~~~~~ ~~~~~ ~~~~ ~~~~~ | 인자 | 인자 +---------[열쇠말]-----+ 위의 경우 "between:"과 "and:"는 각각 "1"과 "10"이라는 인자의 쓰임을 꾸며주는 열쇠말(keyword)입니다. 그리고 이 두 개의 열쇠말이 모여서 하나의 길표(selector)가 됩니다. 즉 위의 경우 "between:and:"는 두 개 의 열쇠말을 가지는 길표인 것입니다. 쇠마디 지시는 이처럼 하나 이상의 열쇠말로 이루어져 있습니다. 이는 C++나 객체 파스칼에는 없는 Smalltalk만의 특징으로, 여러 개의 열쇠말 이 모여서 하나의 길표를 이루는 예라고 하겠습니다. 정리하면, 쇠마디 지시는 한 개 이상의 열쇠말로 이루어지고, 열쇠말은 바로 다음에 나오는 인자를 꾸며줍니다. 따라서 "between:"이나 "and:" 는 그 자체로써 지시가 아니고, 쇠마디 지시를 구성하는 요소입니다. 따 라서 쇠마디 지시는 여러 개의 열쇠말과 인자가 모여서 하나의 지시를 꾸미고, 그 지시가 객체에 전달되어 결과를 남깁니다. 그래서 Smalltalk 에서 쇠마디 지시를 나타낼 때에도 "between:and:"처럼 해당 길표에 쓰 인 열쇠말을 한데 모아서 표시합니다. 그리고 "isKindOf:"와 "between:and:"는 서로 다른 지시이므로, "isKind Of:"와 "and:"는 아무런 관계도 없습니다. 아마 "between:and"와 "isKindOf:"를 함께 생각하시면서 혼동을 하신 것이 아닌가 생갂됩니다. 다음으로 재윤님께서는 새로운 지시를 어떻게 정의하는지에 대해서 물으 셨습니다. 객체가 지시를 받으면 해당 지시에 응답하기 위해서 어떻게 그 지시를 처리할 것인지에 대한 길수(method)를 찾습니다. 만약 해당 지시를 처리 할 길수가 있다면 그 길수에 따라 지시를 처리하여 결과값을 남기지만, 길수가 존재하지 않는다면 결국은 해당 객체는 지시를 처리할 수 없는 것입니다. 즉 지시를 알아들을 수 없다는 것은, 그 지시를 처리할 수 있 는 길수를 객체가 모르기 때문입니다. 따라서 우리가 내리는 지시를 알 아들을 수 있도록 객체에게 길수를 가르쳐주어야 합니다. 이미 있는 객체에 새로운 길수를 더하기 위해서는 해당 객체가 속한 갈 래에 해당 지시를 실행할 수 있는 길수를 만들어주면 됩니다. 이 때 사 용하는 도구가 바로 "갈래 씻줄 탐색기"(class hierarchy browser)입니 다. 새로운 길수를 만들기 위해서는 Smalltalk에 대해서 좀 더 알아보는 것 이 필요하지만, 일단 다음의 과정을 따르면 새로운 길수를 만들 수 있습 니다. 지금 일터를 열고 다음처럼 입력해 봅시다. 5 isPrime ☞ "SmallInteger does not understand #isPrime" 잘못 발생 우리는 지금 "5"라는 객체에게 "너, 소수(素數, prime) 맞아?"하고 지시 를 내렸습니다. 그런데 객체는 "너, 소수 맞아?"라는 지시를 어떻게 처 리해야 할지 그 길수를 모르고 있습니다. 따라서 우리는 정수 객체에게 어떻게 하면 자신이 소수인지 아닌지를 구분할 수 있는 길수, 곧 방법을 가르쳐주어야 합니다. 1) 새로운 길수를 만들기 위해 Tools > Class Hierarchy Browser 메뉴를 실행하여 갈래 씻줄 탐색기를 엽니다. 2) 우리는 "Integer" 갈래(class)에 새로운 지시를 추가할 것이므로, Class > Find 메뉴를 실행하여 열린 대화상자에 "Integer"를 입력합니 다. 이렇게 하면 "Integer" 갈래가 선택되고, 아래와 같은 갈래 꼴 (class definition)을 볼 수 있을 것입니다. --------------------------------------- Number subclass: #Integer instanceVariableNames: '' classVariableNames: 'PrintBuf ' poolDictionaries: '' --------------------------------------- 3) 이 상태에서 Method > New 메뉴를 실행해서 새로운 길수(method)를 만들 준비를 합니다. 갈래 탐색기의 아래쪽 널(pane)에 커서가 반짝거리 면서 여러분이 길수를 가르쳐주기를 기다리고 있습니다. 4) 이제 아래의 글토막을 그대로 입력합니다. ---------------------------------------------------------- isPrime "받는이(receiver)가 소수인지를 검사하여 논리값을 남긴다." self < 2 ifTrue: [ ^false ]. 2 to: self - 1 do: [ :i | (self \\ i) = 0 ifTrue: [ ^false ]. ]. ^true ---------------------------------------------------------- 5) 입력한 것을 적용하기 위해서 를 누르거나 Workspace > Accept 메뉴를 실행합니다. 명령을 실행하면 여러분이 입력한 글토막이 Smalltalk에 의해 번역되어 문법 돋이(syntax highlight)가 적용됩니다. 6) 갈래 씻줄 탐색기를 닫습니다. 이제 "Integer" 갈래와 이 갈래에 딸린 아랫갈래(subclass)의 모든 실체 (instance)들은 "isPrime" 지시를 알아들을 수 있습니다. 일터에서 다음 과 같이 실험하면 결과를 확인할 수 있습니다. 5 isPrime ☞ true 7 isPrime ☞ true 3 isPrime ☞ true 2 isPrime ☞ true 4 isPrime ☞ false 6 isPrime ☞ false 9 isPrime ☞ false 100 factorial isPrime ☞ false 200 factorial isPrime ☞ false 결국 Smalltalk에서 프로그램을 작성한다는 것은 이렇게 객체가 알아들 을 수 있는 여러 가지 길수를 가르쳐 주는 것이라고 해도 과언이 아닐 것입니다. ---------------------------------------------------------- 두번째! 스몰토크에서는 다른 OOP언어들의 Dynamic Binding 그러니까 같은 지시에 대해 서로 다르게 반응하는 것을 어떻게 구현하나요? 스몰토크도 상속을 통해서 구현할 수 밖에 없나요? 아니면 구지 신경안써도, 즉 같은 부모를 가지고 있지 않아도, 특별히 뭔가 키워드를 써주지 않아도 저절로 되나요? (아무래도 그렇게 될 것 같은 불길한 예감이..) ---------------------------------------------------------- 결합(binding)은 어떤 이름에 특정한 의미를 부여하는 것을 말합니다. 말씀하신 대로 동적 결합은 프로그램이 실행될 때(run-time) 결합하는 방법이고, 정적 결합은 프로그램이 번역될 때(compile-time) 결합하는 방법입니다. 정적 결합은 바탕글(source code)을 한 번에 기계어로 번역 한 다음 실행되는 일괄 처리형 언어에서 사용되고, 동적 결합은 BASIC과 같이 통역기(interpreter)를 사용하거나 Smalltalk 언어와 같이 점층적 번역(incremental compiling) 기능을 사용하는 대화식 언어에서 주로 사 용됩니다. C++, 객체 파스칼의 경우는 virtual 이라고 하는 특별한 지시를 내려주 어야만 동적 결합이 수행되고 기본적으로는 모든 이름이 정적으로 결합 됩니다. 동적 결합의 경우는 프로그램을 실행할 때 특정한 이름에 어떤 의미를 부여할지를 판단해야 하기 때문에 정적 결합에 비해 상대적으로 실행 시간이 늦고 기억공간을 조금 더 소비하기 때문입니다. 그러나 Smalltalk의 경우는 모든 이름이 동적으로 결합됩니다. 즉 번역 할 때에는 의미가 정해져 있지 않지만, 번역된 바탕글이 실행될 때에 이 름에 의미가 부여됩니다. 재윤님께서 말씀하신 것처럼 특별한 조치를 취하지 않더라도 어떤 객체 가 지시를 알아들을 수만 있다면 이름(길표)에 대해서는 상관하지 않습 니다. 이를테면 제 글에서도 볼 수 있듯이, 분수(Fraction) 객체와 정수 (Integer) 객체는 똑같이 "numerator"와 "denominator"를 알아듣습니다. 그러나 정수와 분수의 경우 모두 각각의 길수를 다르게 처리합니다. 또한 윗갈래(superclass)에 어떤 길수가 있다고 해도, 아랫갈래에서 같 은 이름의 길수를 사용하면 얼마든지 윗갈래의 길수를 번복(override)할 수 있습니다. Smalltalk에서의 변수(variable)은 모든 종류의 객체를 가리킬 수 있으 므로, 결국 어떤 변수가 가리키는 객체에게 지시를 보내면, 어떤 길수가 실행될 지는 실제로 실행 시간에만 알 수 있습니다. 그러므로 동적 결합 을 사용하는 것입니다. 그런데 이러한 사실이 왜 불길하지요? 동적 결합이 정적 결합에 비해서 실행 속도가 늦고 기억공간을 많이 사용하기는 하지만, 객체지향의 진정 한 의미인 "재사용성"과 "융통성"을 높이는 하나의 방법입니다. 또한 Smalltalk는 구현 시스템에 따라서 여러 가지 최적화 기법을 사용합니 다. 기본적으로 Smalltalk의 모든 지시는 동적으로 결합되는 것이 원칙 이지만, 어떤 시스템의 경우는 갈래 씻줄에서 번복된, 즉 특정한 이름을 가진 길수가 한 번만 정의되었다면 정적 결합을 수행하고, 번복된 길수 가 있을 경우에만 동적 결합을 수행하기도 합니다. 제가 알고 있기로는 Java에서도 동적 결합을 기본으로 지원한다고 하기 때문에, 이것이 프로 그램의 성능에 큰 영향을 주지는 않는다고 생각합니다. ---------------------------------------------------------- 세번째! 스몰토크는 Type이 없다고 들었는데, 그럼 실행중에 에러가 나면 꼭 창이 뜨나요? 컴파일된 바이너리가 실행중에 그런 상황이 발생하면 어떻게 되나요? 에러를 방지하기 위해서 일일이 타잎체크를 직접 해줘야만 하나요? ---------------------------------------------------------- Smalltalk에는 말씀하신 대로 자료형(type)이 존재하지 않습니다. 그러 나 이러한 자료형의 기능을 가지고 있는 갈래(class)가 있습니다. 원래 자료형이라는 개념 자체는 절차 지향적 언어에서 나온 것이기 때문에, 객체지향 언어인 Smalltalk에서는 type 자체를 지원하지 않는 것입니다. 물론 C++나 객체 파스칼의 경우 갈래를 하나의 자료형으로 취급하기는 하지만, 이로 인해서 발생하는 문법의 복잡성이나 여러 가지 혼란은 피 할 수 없는 것입니다. Smalltalk에서 말씀하신 문제가 생길 수 있는 소지는 다른 데 있습니다. 그것은 Smalltalk에서 사용하는 소위 변수(variables)의 경우에 특정한 자료형이 고정되어있지 않다는 것입니다. 즉 널널한 자료형 검사를 수행 합니다. 쉽게 이야기하면 베이식에서 사용하는 변수와 비슷한 특정을 가 지고 있다는 말인데, 바로 이것이 Smalltalk의 유연성과 강력함을 가져 다 줍니다. Smalltalk에서 | a b c | 처럼 선언하면, 꼬리표―필자는 "변수"보다는 "꼬리표"가 더 적당하다고 생각합니다― a, b, c를 어떤 객체에도 갖다 붙일 수 있습니다. 즉 a := 'Hello!'. a := 3. a := Array new: 10. a := a asSortedCollection. a := [ 3 + 4. ]. 위와 같은 것이 모두 실행된다는 것입니다. 이렇게 꼬리표는 어떤 객체 에든 붙일 수 있기 때문에 말씀하신 것처럼 잘못이 발생할 수 있습니다. 그러나 Smalltalk가 이렇게 널널한 자료형 검사를 하는 것은 나름대로 믿는 구석이 있기 때문입니다. 앞서 Smalltalk에서 모든 객체는 갈래(class)에 속해있다고 헀습니다. 따라서 어떤 객체에게 사용자가 지시를 보낼 때, 해당 지시를 전혀 알아 들을 수 없으면 잘못(exception)이 발생합니다. 이를테면 Smalltalk에서 '우리' + '나라'. 처럼 하면 글줄(string) 객체는 아예 "+" 지시를 알아들을 수 없으므로 잘못을 냅니다. 또한 3 + '나라' 의 경우는 "String does not understand #addToInteger:"처럼 바로 알아 듣기는 어려운 지시가 나오지만, 어쨌든 잘못된 자료형으로 인해서 시스 템에 피해를 주지는 않도록 되어 있습니다. 더구나 Smalltalk의 경우는 작은 글토막을 가늠하여 결과를 확인하기 때 문에 문제가 생겼다고 해도 쉽게 그것을 발견할 수 있고, 갈래 씻줄만 충실하다면 굳이 유연성을 제한하는 자료형 검사 기능을 넣을 필요가 없 는 것입니다 물론 재윤님께서 말씀하신 대로 어떤 경우에는 자료형을 매우 깐깐하게 따져야 할 때가 있습니다. 그럴 때는 갈래를 만드는 사람이 자로형을 검 사해 주면 됩니다. 즉 self assert: [x isKindOf: Number]. 라고 하면 자료형 확인을 할 수 있습니다. 소위 자료형 검사를 하는 언 어의 경우는 검사의 강도는 지정할 수 없지만, Smalltalk의 경우에는 프 로그래머의 필요에 따라서 자료형 검사의 강도를 정할 수 있습니다. 위 의 경우는 꼬리표(변수) "x"가 Number 갈래에 딸린 실체이기만 하면, x 가 정수(Integer)이건, 분수(Fraction)이건, 소수(Float)이건 상관 없이 조건이 만족됩니다. 만약 좀 더 꼼꼼하게 검사하고 싶다면 self assert: [x class = SmallInteger]. 위와 같이 하면 됩니다. 위의 경우 "x" 꼬리표는 반드시 정수 갈래에 속 한 객체여야만 합니다. 자료형을 검사해서 생긴 잘못이건, 또는 지시 처리의 오류로 생긴 잘못 이든, 일단 잘못이 생기면 그것을 따로 처리할 수 있습니다. 이는 다른 언어에서의 예외 처리(exception handling) 기법과 동일한데, 만약 어떤 부분에서 잘못이 발생할 경우 특정한 처리를 하기를 원하면 [ 실행할 명령들 ..... ] on: Exception do: [ 잘못이 있을 경우 처리할 명령들 .... ] 의 구조를 사용할 수 있습니다. 위에서 "Exception"은 모든 잘못이나 예 외를 나타내는 갈래의 뿌리 갈래이고, 이 갈래에서 모든 잘못이나 예외 를 나타내는 갈래의 씻줄이 출발합니다. 따라서 좀 더 구체적인 잘못을 잡아내기 위해서는 해당 잘못을 나타내는 갈래(예를 들면 "ZeroDivided" 와 같은)를 사용할 수 있습니다. 이렇게 발생한 잘못을 처리해 주지 않으면 해당 잘못은 기본 잘못 처리 기에 넘겨지고, 잘못 처리기는 발자취 창을 표시하여 사용자에게 프로그 램의 문제를 해결할 수 있는 기회를 제공합니다. 물론 독립 실행 파일의 경우는 해당 잘못이 생기면 메시지 박스 등을 통해서 잘못이 발생한 사 실을 통보해 주는 처리가 있을 것입니다. 예를 하나만 들겠습니다. 아래의 글토막을 펴 보십시오. ---------------------------------------------------------- [ 3 isUppercase ] on: MessageNotUnderstood do: [ :e | MessageBox notify: '그것도 못하냐?'. ]. ---------------------------------------------------------- 위의 경우는 어떤 객체가 지시를 알아듣지 못할 때 그 잘못만을 잡아내 어서 처리를 하는 보기입니다. 이렇게 Smalltalk에서 발생하는 여러 가 지 잘못은 얼마든지 사용자에 의해 처리될 수 있으며, 이것이 바로 Smalltalk의 커다란 특징이자 장점입니다. C건 C++이건 long l = 10; int I = 20; printf("%d %d", l, I); 위의 문장은 (라이브러리의 제작자가 처리해 주지 않는 이상) 전혀 잘못 을 잡아낼 수 없습니다. 자료형 검사가 까다롭기로 소문이 난 C/C++이지 만 그런 검사를 한시라도 게을리 하면 시스템 다운이라는 치명적인 상황 을 야기할 수도 있는 것입니다. 이에 비해 Smalltalk는 기본적으로 자료형 검사를 하지 않지만, 각각의 자료들(정확히 말하면 객체들)은 자기가 어떤 갈래(class, 즉 type)에 속해있는지를 잘 알고 있으며, 자기가 할 수 있는 일이 무엇이고 할 수 없는 일이 무엇인지를 너무나 잘 알고 있습니다. 즉 살아있습니다. 절차 지향적 관점에서는 죽어있는 자료를 절차라는 통에 넣어서 가공한 다음 새롭게 자료를 만들지만 이것 역시 죽어 있는 자료일 뿐입니다. 그 러나 객체 지향 개념에서는 모든 것을 객체로 생각합니다. "1"이라고 하 는 숫자 하나라도 객체지향의 세계에서는 살아있으며, 자기가 누구이며 어떤 갈래에 속하는지, 자기는 어떤 일을 할 수 있는지를 누구보다도 잘 알고 있는 살아있는 객체인 것입니다. 이 객체에게 설령 잘못된 지시를 내렸다 하더라도 시스템이 다운되거나 하지는 않습니다. 그래서 자료형 검사가 까다롭지 않은 Smalltalk이지만 매우 안전하다는 말을 듣는 것입 니다. C++의 문법이 이토록 복잡해 진 대에는 정적 결합과 동적 결합을 구분해 놓고, 객체를 처리하는 변수에 굳이 자료형을 매기기 시작한 데서 출발 하는 것입니다. Smalltalk의 경우는 template이나 virtual 함수가 전혀 없지만 똑같은 일을 C++보다 훨씬 간결하게 처리할 수 있습니다. 물론 그렇다고 C++의 이러한 특징을 나쁘다고 말하는 것은 아니며, 나름대로 쓰임새가 다르기 때문에 일어나는 현상입니다. 다만 이러한 특징이 Smalltalk에 그대로 적용되지 않는다고 해서 Smalltalk가 낮게 평가되어 서는 안된다는 것입니다. ---------------------------------------------------------- 뭐랄까, 씨줄, 갈래, 실체, 지시, 헛(?)... 좋은 우리이름인건 분명하지만 너무 직역이 아닌가 싶네요. 선생님의 독자적인 창작이신지 아니면 우리는 이런 이름을 쓰자고 주장하는 그룹이라도 있는지 궁금하군요. ---------------------------------------------------------- 마지막으로 제가 쓰고 있는 한글 용어에 대해서 이야기하겠습니다. 제가 쓰고 있는 낱말 중에는 이미 "객체", "절차" 등과 같이 이미 알려져서 널리 쓰이는 말이 있는가 하면 "씻줄", "갈래", "지시"처럼 우리가 익히 알고있지만 객체 지향 영역에서는 사용되지 않았던 낱말이 있고, 마지막 으로 "바탕글", "길수", "쇠마디" 처럼 사전에는 없지만 두 개 이상의 낱말을 조합해서 만든 낱말도 있습니다. 저는 예전에 한글 언어 "씨앗"으로 프로그래밍을 공부한 적이 있습니다. 그래서 한글 용어가 얼마나 편리한지를 누구보다도 잘 알고 있습니다. 아쉽게도 Smalltalk가 한글 이름을 지원하지 않기 때문에 길수의 이름에 한글을 사용할 수는 없지만, 일단 우리가 널리 사용하고 있는 외래어들 만이라도 우리말로 고쳐서 알아듣기 쉽게 부르는 것이 좋다고 생각했기 에, 과감하게 시도를 해 본 것입니다. "생성자", "소멸자", "계승", "다형성" 등과 같은 낱말이 사용되기 시작 한 것이 그리 오래되지 않았습니다. 이전에는 전부 "constructor", "destructor", "inheritance", "polymorphism"처럼 표기했습니다. 실제 로 필자가 처음 C++을 공부할 때에는 우리 나라의 책보다는 차라리 원서 를 읽는 게 더 편할 정도였습니다. 처음부터 "생성자", "소멸자"와 같은 낱말이 자리매김을 한 것은 아니었 을 것입니다. 누군가 알맞은 낱말을 찾아내서 써왔고, 이런 것들에 동감 하는 여러 사람들이 함꼐 씀으로 인해서 언어의 사회성이 적용되기 시작 한 것이지요. 처음 "글쇠"(key)라는 말이 나왔을 때에도 매우 어색해 하 던 사람들이지만, 요즘은 어색하지 않게 이 말이 통용되고 있습니다. 사 전에서는 분명히 찾아볼 수 없는 말입니다. 그러나 이 말이 얼토당토않 게 만들어지지는 않았습니다. "글쇠"는 "글자 박음쇠"의 준말입니다. 마찬가지로 제가 스스로 만들어 본 낱말은 나름대로 사전에서 이미 존재 하는 낱말입니다. 제가 "method"를 대신해서 쓰는 "길수"라는 낱말은 "길"과 "수"를 합친 것입니다. 둘 다 "어떤 일을 처리하기 위한 (묘한) 방법"을 나타냅니다. "nil"을 "헛"이라고 번역한 것은 이미 "씨앗"에서 그렇게 했기 때문입니다. 사전에서 "헛"을 찾아보십시오. "nil"과 놀라 울 정도로 똑같은 뜻을 가지고 있습니다. 컴퓨터를 공부하는 것 못지 않게 우리말을 찾아서 쓰는 것도 중요하다고 생각합니다. 우리가 우리말을 찾아서 쓰지 않으면 우리의 생각이 바뀌고 정신이 흔들립니다. "유도"에서 일본 말을 놔두고 왜 "그쳐" 등과 같은 우리말을 사용할까요? :) 자, 이쯤에서 글을 닫을까 합니다. 이것 저것 많은 내용을 쓰다 보니 글 이 많이 길어졌지만, 이것도 제가 정기적으로 올리는 강좌 못지 않게 매 우 중요한 내용을 담아보려고 노력을 했습니다. 진도를 앞서신다는 것은 매우 즐거운 일입니다. 사실 프로그래밍을 많이 접해보시고 공부하신 분 이라면 지금까지의 제 글은 무척 쉽게 이해하실 수 있으실 것입니다. 실 제로 Smalltalk의 더 깊은 곳을 공부해 보고 싶으신 분이 많으실 텐데, 마땅한 자료가 없는 것을 정말 안타깝게 생각합니다. 일단 저도 더욱 분 발하겠습니다. 그래서 어서 빨리 여러분에게 Smalltalk, 그리고 객체 지 향에 프로그래밍에 대한 여러 가지 생각들을 정리해 드리고 싶습니다. 앞으로 많은 관심 부탁드립니다. 아, 그리고 혹시, 제 글에서 틀린 부분 이 있으면 서슴지 마시고 시적해 주십시오. 그래서 제가 잘못 알고 있는 것을 고칠 수 있는 기회를 주시면 저에게도 큰 도움이 되겠습니다. 다시 한 번 제 글을 읽고 질문해 주신 재윤님께 감사드리고, 제 글이 "현문우답"이 되지나 않았는지 모르겠습니다. 그럼 날씨 추운데 건강 조심하세요. 제 목:[강좌] Smalltalk 배우기 #16 관련자료:없음 [28] 보낸이:김찬홍 (안드래아) 1999-01-10 14:32 조회:155 Smalltalk 배우기 #15 1999. 1. 10. 김찬홍 mailto:andrea92@hitel.net ====================================== 2. 객체들과 나누는 이야기 2.1. 객체? 2.2. 몸으로 느끼기 2.3. 객체의 안쪽 2.3.1. 탐색기 사용하기 2.3.2. 객체의 성분 b→2.3.3. 글자와 글줄 ...... ======================================= 2. 객체들과 나누는 이야기 ------------------------------------ 2.3. 객체의 안쪽 ~~~~~~~~~~~~~~~~ 2.3.1. 글자와 글줄 ------------------ #15에서... Smalltalk에서 글자 못지 않게 중요한 자료로써 글줄(string)이 있습니다. 글줄은 하나 이상의 글자로 이루어져 있으며, 지금 필자가 쓰고 있는 것과 같은 글을 다루는 매우 중요한 자료입니다. 이제 여기서는 이러한 글줄에 대 해서 알아보도록 하겠습니다. 우선 Smalltalk에서 글줄을 나타내는 방법을 알아보겠습니다. 'Hello' ☞ 'Hello' 'ghostly' ☞ 'ghostly' '우리 나라' ☞ '우리 나라' 위에서 예로 든 'Hello, 'ghostly', '우리 나라'는 모두 글줄(string)입니 다. 위에서 볼 수 있듯이 Smalltalk에서는 작은따옴표(' ') 안에 들어가 있 는 모든 것을 글줄로 처리합니다. 글줄 역시 객체이기 때문에 "inspect" 지시를 알아듣습니다. 위의 세 개의 글줄에 "inspect" 지시를 보내거나, 또는 위의 글줄을 글토막으로 생각하고 글쇠를 이용하여 탐색해 봅시다. <그림 2-15> 'Hello', 'ghostly', '우리 나라'의 탐색 (Stp2-15.gif) 글줄은 번호 붙은(indexed) 성분을 가지고 있는 핫객체입니다. 그런데 앞서 살펴본 소수(Float) 와는 달리 글줄(string)의 경우는 성분의 개수가 저마다 다 다릅니다. 앞서 탐색한 글줄들의 성분은 각각 몇 개였습니까? 'Hello'의 경우는 5개, 'ghostly'는 7개, '우리 나라'의 경우는 9개의 성분 들을 각각 가지고 있습니다. 그럼 이러한 성분들에는 무엇이 들어있을까요? 이미 짐작한 사람들도 있을지 모르겠습니다만, 글줄의 성분에는 바로 글자들 이 들어있습니다. 앞서 글줄은 글자의 모임이라는 말을 한 적이 있습니다. 그럼 실제로 탐색기에서 각각의 글자들이 어떤 성분으로 되어있는지를 알아 봅시다. 'Hello'의 경우에는... ------------------------------ 성분 글자 ------------------------------ 1 $H 2 $e 3 $l 4 $l 5 $o ------------------------------ 와 같이 되어 있고, 'ghostly'의 경우는 ------------------------------ 성분 글자 ------------------------------ 1 $g 2 $h 3 $o 4 $s 5 $t 6 $l 7 $y ------------------------------ 처럼 되어있습니다. 즉 글자를 이루는 각각의 번호 붙은 성분에는 해당 글줄 을 구성하는 글자들이 들어있습니다. 그런데 여기서 의문을 가지는 사람들이 있을지 모르겠습니다. 그것은 바로 글줄을 구성하는 성분 중에 왜 작은따옴표(' ')가 없느냐는 것입니다. 우리 는 실제로 글줄을 나타낼 때 'Hello'처럼 나타내었고, 따라서 글줄에 당연히 작은따옴표가 들어가야 한다고 생각하는 사람들이 있을 수 있습니다. 그러나 여기서의 따옴표는 단순히 글줄의 시작과 끝을 나타내는 기호일 뿐입니다. 그러므로 실제로 글줄의 내용이 아니라는 것을 기억해 두시기 바랍니다. 이 는 마치 "A"라는 글자를 나타내게 위해서 $A라고 쓰는데, 여기서 "$"는 글자 의 성분이 아닌 것과 같은 이치라고 생각하면 되겠습니다. 그렇다면 '우리 나라'의 경우는 어떨까요? 실제로 탐색기를 통해 확인해 보 면, 엉뚱하게도 각각의 성분에 들어있는 글자를 제대로 표시하지 못한다는 것을 알 수 있습니다. 이는 앞에서 한글은 두 개의 Smalltalk 글자로 이루어 져 있다고 말한 것과 깊은 관계가 있습니다. 즉 Smalltalk처럼 영어권에서 개발된 프로그래밍 언어의 경우 하나의 글자로는 한글을 나타낼 수 없음을 가리키는 좋은 보기가 되는 것입니다. 그렇다고 글줄에 한글을 담아서 나타낼 수 없는 것은 아닙니다. 옛날에 만들 어진 몇몇 프로그램의 경우는 한글 자체를 처리할 수 없는 경우가 많았는데, 다행이 우리의 Dolphin Smalltalk는 한글을 어렵지 않게 처리할 수 있습니 다. 그러므로 한글을 다룰 때에는 항상 두 개의 Smalltalk 글자를 한 묶음으 로 해야 한다는 것만 기억해 두도록 합시다. ---<잠깐!>----------------------------------------------------------- Smalltalk에서의 한글 Smalltalk에서도 한글은 한 바이트(byte)에 처리되지 못하기 때문에 하나의 글자로 처리될 수 없는 어려움을 그대로 가지고 있습니다. 이것은 한글의 낱 글자로 조합하여 나타낼 수 있는 글자의 수가 한 바이트로는 도저히 감당하 기 어렵기 때문에 생긴 일입니다. 따라서 현재는 한글로 이루어진 글줄을 낱 글자로 탐색하는 방법은 없다고 보는 것이 옳습니다. 다만 다음의 글토막을 이용하면 글줄을 구성하고 있는 글자들의 ASCII코드를 16진수로 보여줄 수는 있습니다. 아래의 <바탕글 1>에 모두 덩이를 씌워서 글쇠로 펴 보 면 결과를 얻을 수 있습니다. <바탕글 1> 글줄을 이루는 바이트의 코드 확인하기 ----------------------------------------------------------- | result | result := String new. '우리 나라' do: [ :ch | result := result , (ch asciiValue printStringRadix: 16 showRadix: false). result := result , ' '. ]. result. [실행 결과] ☞ 'BF EC B8 AE 20 B3 AA B6 F3 ' ----------------------------------------------------------- 여하튼 제대로 한글 처리가 이루어지기 위해서는 UniCode를 지원하는 Smalltalk를 사용하는 수밖에는 없는데, 앞서도 말했듯이 Dolphin에서는 현 재 UniCOde를 지원하지 않으므로 당분간은 기존 프로그래밍 언어에서 겪었던 불편함을 그대로 치러야 할 것 같습니다. 사족을 달자면, 한글이 한 바이트로 표현되지 못하기 때문에 후진 글자가 절 대로 아닙니다. 오히려 낱글자를 가지고 만들 수 있는 글자의 수가 256 가지 를 넘는 문자가 있다는 것을 간파하지 못한 컴퓨터 개발자들의 탓일 것입니 다. 이는 단지 기억공간의 낭비를 막기 위해 세기(世紀)를 표기하지 않아서 생기는 "Millenium bug"와도 같은 것입니다. 먼 앞을 내다보지 못해서 허우 적대는 것이 어디 "Y2k" 뿐이겠습니까? 우리가 늘 사용하는 컴퓨터이지만, 한글을 제대로 표현할 수 없는 이 문제는, 정말 "Y2k" 만큼이나 중대한 문제 라는 것을, 사람들은 제대로 느끼지 못하는 모양입니다. ----------------------------------------------------------- 글줄(string) 역시 탐색기에서 값을 바꿀 수 있는 객체입니다. 'ghostly'를 탐색하고 있는 탐색기를 이용하여 글줄을 한 번 바꾸어보도록 합시다. 만약 앞서 'ghostly'를 탐색하고 있는 탐색기를 닫았다면 일터에 'ghostly' 글줄 을 입력하고 덩이를 씌운 후 글쇠로 탐색해서 탐색기를 여십시오. 이제 우리는 6, 7번 성분을 $l, $y에서 $', $s로 바꿀 것입니다. 다음 절차 를 따르면 됩니다. 1) 선택 막대를 "6"으로 옮겨서 6번 성분이 표시되게 한다. 2) 오른쪽 널에 $l 이 표시되었는지 확인한다. 3) $l에서 'l'을 지우고 작은따옴표(')로 바꾼다. 4) 오른쪽 널의 변경을 적용하기 위하여 를 누르거나 Workspace > Accept 메뉴를 실행한다. 5) 마찬가지로 선택 막대를 "7"로 옮긴다. 6) 오른쪽 널에 표시된 $y를 $s 로 바꾼다. 7) 변경을 적용하기 위해서 글쇠를 누르거나 Workspace > Accpet 메뉴를 실행한다. 이제 우리가 변경한 것을 확인해 보기 위해서 왼쪽 널의 "self"를 돋이시켜 봅시다. 그러면 다음 그림과 같은 결과를 볼 수 있을 것입니다. <그림 2-16> 'ghost''s' 글줄을 탐색하는 화면 (Stp2-16.gif) 어떻게 되었습니까? 화면에 'ghost''s'라고 나타났습니다. 우리는 분명히 작 은따옴표를 하나만 넣었는데 화면에는 두 개의 작은따옴표가 있는 것으로 나 왔습니다. 여기서 우리는 한 가지 중요한 사실을 알 수 있습니다. 바로 글줄 안에 작은 따옴표를 넣기 위해서는 두 개의 작은따옴표가 필요하다는 것입니다. 만약 'ghost's'처럼 나타낸다면 Smalltalk는 $t의 다음에서 글줄이 끝난다고 생각 하고, $s의 다음에서 새로운 글줄이 시작된다고 판단하게 됩니다. 따라서 컴 퓨터가 글줄 속에 들어있는 따옴표를 제대로 판단하게 하기 위해서, 글줄 속 에 있는 두 개의 잇따른 작은따옴표를 하나의 작은따옴표로 처리하도록 한 것입니다. 여기서 "잇따른"이라는 말이 매우 중요합니다. 만약 'ghost' 's'처럼 두 개 의 작은따옴표 사이에 빈칸이 들어가면 이는 하나의 글줄이 아니라 두 개의 글줄이기 때문입니다. 그러므로 Smalltalk에서 글줄과 함께 작은따옴표를 다 룰 때에는 특히 주의가 필요합니다. 작은따옴표의 사용법을 어느 정도 익혔다면, 이제 아래의 글토막들을 탐색해 보고 결과를 살펴봅시다. 여러분이 생각한 결과와 같다면 작은따옴표의 사용 법에 대해서 완전히 익숙해진 것입니다. 'God''s car' 'It''s a boy!' '''hi''' 글줄에서 잇따른 작은따옴표는 하나의 작은따옴표(')로 취급한다는 것을 바 로 앞서 알아본 바 있습니다. 그렇다면 다음 글토막을 가늠하면 어떤 결과를 얻을 수 있을까요? '' ☞ '' 편 글줄이 그대로 나타났습니다. 그렇다면 이제는 위의 글줄을 펴지 말고 탐 색해 봅시다. 그러면 다음 그림과 같은 결과를 보게 될 것입니다. <그림 2-17> 빈 글줄('')의 탐색 (Stp2-17.gif) 탐색기의 제목을 보십시오. "Inspecting a String"이라고 되어있습니다. 그 러므로 우리는 지금 분명히 글줄(string)을 탐색하고 있는 것입니다. 그런데 열린 탐색기의 왼쪽 널에는 "self"만 덩그러니 나와 있습니다. 아무런 성분 도 없습니다. 이것은 ''이 아무런 글자도 들어있지 않은 "빈 글줄"(empty string; null string)이기 때문입니다. 정리하면, 글줄 속에 따옴표가 잇따라 두 번 나오면 하나의 작은따옴표로 알 아듣지만, 단순히 작은따옴표 두 개가 잇따라 나오면 그것은 아무런 글자도 들어있지 않는 빈 글줄을 나타냅니다. 글자가 아무 것도 없으니 탐색을 해 봐도 아무런 성분도 보이지 않는 것은 너무나 당연하겠지요? 그렇다면 작은따옴표 하나만 들어있는 글줄을 나타내려면 어떻게 하면 될까 요? 이것은 여러분의 몫으로 남겨둡니다. 객체와 언제든지 대화하고 여러 가 지 결과를 직접 시험할 수 있는 Smalltalk의 특징을 살려서 여러분이 일터에 서 직접 글토막을 입력해서 펴보거나 탐색해 보면 쉽게 문제를 풀 수 있을 것입니다. :) 이제 글줄의 특성을 어느 정도 파악했으니, 남은 것은 글줄의 갈래를 알아보 고 어떤 씻줄로 얽혀있는지를 조사해 볼 차례입니다. :) 언제나 그렇듯이 Smalltalk에서는 모든 것이 객체이므로, 객체의 성질을 제대로 파악하기 위 해서는 먼저 그 객체가 어떤 갈래에 속해 있으며, 어떻게 씻줄에 얽혀있는지 를 알아야만 합니다. 우리가 늘 하던 대로 실체(instance)에 "class" 지시를 내려서 일단 글줄의 갈래를 얻고, 얻어진 갈래에 "superclass" 지시를 내려 서 씻줄을 더듬어 올라가 봅시다. '우리 나라' class ☞ String String superclass ☞ ArrayedCollection ArrayedCollection superclass ☞ SequenceableCollection SequenceableCollection superclass ☞ Collection Collection superclass ☞ Object 글줄의 씻줄을 따라 올라가다 보면 꽤나 이상한 갈래들을 만날 수 있습니다. 여태껏 우리가 접해보지 못한 이상 야릇(?)한 갈래들. 저런 것들은 뭘까? 영 어로 되어있어서 어려울 뿐입니다. 쉽게 우리말로 풀어쓰면 아래와 같이 쓸 수 있습니다. String 글줄 ArrayedCollection 배열 모듬 SequenceableCollection 나란한 모듬 Collection 모듬 "모듬"(collection)이란 하나 이상의 객체들의 모임을 말하고, 그 아랫갈래 인 "나란한"(sequenceable) 모듬은 객체들이 나란히 늘어서 있는 모듬이며, "배열"(arrayed) 모듬은 객체들이 줄지어 있는 모듬을 의미합니다. 물론 각 모듬들의 특성이 매우 다르고 또한 나름대로의 쓰임이 있기 때문에, 이런 모 듬들에 대해서는 나중에 알아보도록 하겠습니다. 여기서는 글줄이 여러 글자 들이 줄줄이, 그리고 나란히 늘어서 있는 모듬이라는 정도로만 이해하면 될 것입니다. 이제 글줄의 갈래와 씻줄도 어느 정도 파악했으니, 이러한 글줄이 알아들을 수 있는 몇 가지 지시들을 살펴보도록 하겠습니다. 글줄로 할 수 있는 일을 생각해 보면 어떤 것들이 있을까요? 두 개의 글줄을 더해서 하나의 글줄로 만들 수도 있을 것이고, 글줄의 길이도 알아낼 수 있으면 좋겠군요. 이러한 일을 하려면 글줄에게 어떤 지시를 내려야 할까요? 다음 글토막들을 펴 보십시오. 'yes', 'ter', 'day' ☞ 'yesterday' '우리', '나라' ☞ '우리나라' 여기서 쉼표(,)는 말과 말 사이를 갈라주는 가름표(delimiter)가 아니라 어 엿한 하나의 겹마다 길표(binary selector)입니다. 위의 예에서도 볼 수 있듯이 글줄이 "," 지시를 받으면 인자로 전달된 글줄 과 자신을 합쳐 하나의 글줄을 만듭니다. 즉 "," 길표는 두 개의 글줄을 더 하는 역할을 합니다. ","를 연달아 쓸 수 있는 까닭은, 우선권이 같은 길표 의 경우 언제나 왼쪽에서부터 오른쪽으로 가늠하기 때문입니다. 다음으로는 "at:"이라는 길표에 대해서 알아봅시다. 다음을 펴 보십시오. 'yes' at: 1 ☞ $y 'yes' at: 2 ☞ $e 'yes' at: 3 ☞ $s 길표 "at:"은 한 개의 인자(parameter)를 가지고 있는 쇠마디(keyword) 길표 로, 인자로 넘겨준 번호가 붙은 성분에서 글자를 뽑아내는 일을 합니다. 이 "at:" 길표는 번호 붙은 성분의 값을 뽑아낼 수 있다는 점에서 매우 중요한 역할을 수행합니다. 보는 바와 같이, 첫 번째 글자는 1, 두 번째 글자는 2, 이런 식으로 글줄에 들어 있는 글자를 마음대로 뽑아낼 수 있는 "at:" 지시 는 생각보다 쓰임이 매우 많습니다. 이번에는 글줄에서 한 글자가 아닌 특정 부분을 뽑아내는 지시입니다. 'frankly' copyFrom: 2 to: 5 ☞ 'rank' '우리나라 대한민국' copyFrom: 5 to: 8 ☞ '나라' "copyFrom:to:"는 두 개의 인자를 가진 쇠마디 지시입니다. 첫 번째 인자로 주어진 번호에서 시작하여 두 번째 인자로 주어진 번호에 이르는 글줄을 지 시를 받는 글줄에서 빼내어 새로운 글줄을 만듭니다. 즉 이미 존재하는 글줄 의 글줄 토막(substring)을 구하는 것입니다. 위에서 보다시피 한글로 이루어진 글줄에도 똑같이 "copyFrom:to:" 지시를 적용할 수 있습니다. 그러나 조심할 것은 번호를 셀 때 한글을 반드시 두 글 자로 쳐서 계산해야 한다는 것을 있지 말아야 한다는 것입니다. 위에서 왜 "5"와 "8"이라는 번호가 쓰였는지를 생각해 보십시오. 마지막으로 글줄의 길이를 구하는 지시를 알아보겠습니다. 'hello' size ☞ 5 '우리 나라' size ☞ 9 길표 "size"는 지시를 받은 글줄의 길이를 결과값으로 남깁니다. "Hello"의 경우는 다섯 개의 글자로 이루어져 있으므로 "5"라는 값을 남기는 것은 당연 하겠지요? 그런데 "우리 나라"의 경우는 한글 한 글자가 두 개의 영문자로 이루어져 있 다고 했으므로, 한글 네 글자와 빈 칸 하나를 더하면 정확히 아홉 개의 글줄 로 이루어져 있는 것입니다. 따라서 "9"를 결과값으로 남겼습니다. 지금까지 알아본 ",", "at:", "copyFrom:to:", "size"는 모두 글줄을 다룰 때 기본적으로 꼭 필요한 기능을 제공하는 아주 중요한 길표들입니다. 그런 데 만약 다음과 같이 조금은 엉뚱한 실험을 해 봅시다. 아래 세 개의 글토막 을 하나씩 가늠해 보면, Smalltalk는 과연 어떤 반응을 보이겠습니까? 1000, '원' 'no' at: 3 'yes' copyFrom: 2 to: 4 한결같이 발자취 창(walkback window)을 띄우는, 즉 잘못된 지시들입니다. 그럼 Smalltalk가 위의 지시를 제대로 처리하지 못한 것은 무엇 때문이었을 까요? 하나씩 차례대로 따져 봅시다. 1000, '원' 위의 경우는 "SmallInteger does not understand #,"라는 알림글을 내놓았습 니다. 즉 작은 정수 갈래에 속하는 "1000"은 아예 "," 지시를 알아듣지 못하 는 것입니다. 만약 위의 경우에 '1000원'이라는 글줄을 만들고 싶으면 다음 처럼 글토막을 고쳐야 합니다. '1000', '원' ☞ '1000원' 즉 정수 객체가 "," 지시를 알아들을 수 없기 때문에 글줄 객체를 사용해야 한다는 것입니다. 'no' at: 3 위의 경우는 "Index 3 is out of bounds"라는 알림글을 받습니다. 이는 "3 번은 범위를 넘어간 값입니다"라는 뜻인데, 위의 경우 글줄은 두 개의 성분 을 가지고 있으므로 당연히 "3"번 성분은 존재하지 않는 것입니다. 따라서 'no'라는 글줄이 "at:"이라는 지시는 이해했지만, 인자로 잘못된 값을 넘겨 주었기 때문에 처리할 수 없었던 것입니다. 'yes' copyFrom: 2 to: 4 위의 경우도 마찬가지입니다. 'yes'라는 글줄에게 두 번째부터 네 번째까지 의 성분을 뽑아내 달라고 하는 것인데, 글자 세 개로 이루어진 글줄이므로 눈을 씻고 찾아봐도 "4"번 성분은 없는 것입니다. 역시 'yes' 객체는 우리가 전달한 "copyFrom:to" 지시를 알아듣기는 했지만 두 번째 인자가 잘못된 번 호를 가지고 있기 때문에 글토막을 제대로 가늠할 수 없었던 것입니다. 이왕 실험을 시작했으니 다음과 같은 글토막을 펴보고 어떤 결과를 남기는지 지켜봅시다. 'me', '', 'et' ☞ 'meet' "(1)" 'yes' copyFrom: 2 to: 2 ☞ 'e' "(2)" 'yes' copyFrom: 2 to: 1 ☞ '' "(3)" 위의 세 개의 글토막은 모두 제대로 실행되어 나름대로 결과값을 남겼습니 다. 앞에서 했던 것처럼 이번에도 하나씩 따져가면서 생각해 봅시다. (1)의 경우는 보통 글줄 사이에 빈 글줄이 들어가 있었고, 이 세 개를 하나 의 글줄로 만드는 것입니다. 빈 글줄은 당연히 아무것도 없기 때문에 빈글줄 을 더한대도 결과는 변하지 않습니다. 즉 'me'와 'et'라는 두 개의 글줄을 더한 것과 같은 결과를 남긴다는 것입니다. 이는 "3 + 0 + 4"는 "3 + 4"와 같은 결과를 내는 것과 같다고 할 수 있습니다. 빈 글줄은 수에서의 "0"과 상등한 의미를 가집니다. (2)의 경우는 "yes" 객체에게 두 번쨰에서 시작해서 두 번째에 이르는 글줄 을 꺼내달라고 지시하는 것인데, 따라서 "copyFrom:to:"는 정확히 두 번째 글자를 글줄로써 되돌려 주었습니다. (2)번 글토막이 "at:"과 다른 점이 있 는데, 그것은 바로 "at:"의 경우는 글줄에서 한 개의 글자를 뽑아내는 것이 었지만, "copyFrom:to:"에 (2)와 같은 인자를 주면 한 개의 글자가 담긴 __ 글줄__을 결과값으로 남긴다는 것이 다른 것입니다. (3)의 경우는 조금 이상하다는 생각이 들것입니다. 인자로 주어진 "2"나 "1" 은 모두 올바른 번호들이지만, 시작과 끝이 서로 바뀌어 있습니다. 처음보다 나중의 번호가 더 크기 때문에, 결국 아무 것도 없는 빈 글줄을 되돌렸습니 다. 따라서 "copyFrom:to:"에 인자를 줄 때에는 처음값 보다는 끝값이 항상 커야 한다는 것을 알 수 있습니다. 이제 우리는 Smalltalk에서 글줄을 어떻게 나타내고, 이런 글줄이 어떤 일을 할 수 있는지를 알아보았습니다. 그런데 한결같이 글줄은 작은따옴표를 달고 다닙니다. 그럼 큰따옴표(" ")는 쓸데가 없는 것일까요? 그렇지 않습니다. Smalltalk에서 작은따옴표가 글줄을 나타내는 중요한 일을 하듯이, 큰따옴표 (" ")역시 매우 중요한 일을 합니다. 이 마디를 닫기 전에 마지막으로 큰따 옴표의 쓰임에 대해서 알아보도록 하겠습니다. 다음 글토막을 가늠해 보십시오. "hello" ☞ nil (1) 1000 "원" ☞ 25 (2) 1 "and" + "and" 2 ☞ 3 (3) Smalltalk는 큰따옴표(" ") 안에 들어있는 모든 것을 __무시합니다.__ 즉 큰 따옴표 안에 어떤 글줄이 들어가 있던지 Smalltalk는 이것을 무시하고 아무 것도 없는 것으로 생각합니다. 그래서 (1)의 경우에 Smalltalk는 아무런 글토막도 없다고 생각하여 헛(nil) 을 결과값으로 남겼습니다. (2)의 경우 Smalltalk는 25라는 값은 알아듣지만 바로 뒤에 있는 "원"은 큰따옴표에 둘러싸여 있으므로 역시 무시해 버립니 다. 그래서 결과값으로 25만 덩그러니 나온 것입니다. (3)의 경우 역시 글토 막 중간에 있는 "and"는 Smalltalk에 있어서는 아무런 의미가 없는 것이기 때문에, 결과값으로 "3"을 나타낸 것입니다. 이렇게 Smalltalk가 큰따옴표 안에 있는 모든 것을 무시해 버리기 때문에 우 리는 이런 특성을 이용해서 바탕글에 풀이글(comment)을 달아둘 수 있습니 다. 풀이글이란 말 그대로 바탕글에 있는 어떤 사실을 풀어 쓴 글을 말하는 데, 이는 나중에 바탕글을 읽을 때 도움을 주기 위한 것입니다. 다음 글토막 을 펴 보십시오.. $a isLetter ☞ true $1 isLetter ☞ false 여기서 "letter"라는 낱말을 어떤 사람은 "글자"라고 읽기도 할 것입니다. 따라서 위와 같은 결과가 나오게 되면 $a와 $1은 모두 다 글자인줄 알았는 데, 결국 $1은 글자가 아니라는 결론을 내어버릴 수도 있는 것입니다. 그러 나 여기에 다음처럼 풀이글을 달아두면 어떨까요? "isLetter는 지시를 받는 객체가 영문자인지를 가려낸다." $a isLetter ☞ true $1 isLetter ☞ false Smalltalk는 어차피 큰따옴표 안에 있는 모든 것을 무시해 버리기 때문에 위 와 같이 해 두면 결국 바탕글을 쉽게 읽을 수 있는 것입니다. 물론 1 + 2 ☞ 3 "1과 2를 더하는 글토막" 처럼 너무나 당연한 것인데 일일이 풀이글을 달아준다고 해서 다 좋은 것은 아닙니다. 풀이글은 꼭 필요할 때 달아주는 것이 중요합니다. 지금이야 우리 가 작은 글토막들을 다루고 있지만, 앞으로 우리가 큰 바탕글을 써 내려갈 때쯤이면 이 풀이글의 중요함을 더욱 더 절실하게 깨달을 수 있을 것입니다. 아울러 Dolphin Smalltalk에서는 풀이글을 초록색의 기울임 글씨로 나타내어 다른 글토막과 쉽게 구분할 수 있도록 하는 문법 돋이(syntax highlighting) 기능을 제공하고 있습니다. 이런 기능은 매우 바탕글을 쉽게 읽을 수 있도록 도와줍니다. 이제 우리는 글자와 글줄에 대해서 알아보았습니다. 글자는 "asciiValue"라 는 이름 붙은 성분을 가지고 있었고, 동시에 글줄(string)을 이루는 매우 중 요한 원소였습니다. 글줄은 번호 붙은 성분을 가지고 있었으며, 여러 가지의 지시를 통해서 많은 일을 할 수 있다는 것을 알아보았습니다. 글자와 글줄이 중요한 이유는, 프로그램을 실행하고 난 다음에 생기는 결과들을 의미 있게 나타내어주기 위해서 바로 글자와 글줄을 사용해야 한다는 것입니다. 이제 앞으로 여러 가지 프로그램을 짜 보면서 여러분은 글자와 글줄의 중요함을 알게 될 것입니다. 이제 다음부터 우리는 Smalltalk에서 논리값을 다루는 방법에 대해서 알아볼 것입니다. 컴퓨터가 가지고 있는 중요한 특징 중에 하나를 꼽으라면 바로 "판단을 할 수 있다"는 것일 것입니다. 논리값은 바로 이런 판단의 기준이 되는 것입니다. 논리값을 다루어봄으로써 여러분은 지금과는 또 다른 객체의 세계를 접해볼 수 있을 것입니다. 계속... 제 목:[강좌] Smalltalk 배우기 #17 관련자료:없음 [30] 보낸이:김찬홍 (안드래아) 1999-01-24 12:07 조회:170 Smalltalk 배우기 #17 1999. 1. 11. 김찬홍 mailto:andrea92@hitel.net ====================================== 2. 객체들과 나누는 이야기 2.1. 객체? 2.2. 몸으로 느끼기 2.3. 객체의 안쪽 2.3.1. 탐색기 사용하기 2.3.2. 객체의 성분 2.3.3. 글자와 글줄 a→2.3.4. 진리를 찾아서... ...... ======================================= 2. 객체들과 나누는 이야기 ------------------------------------ 2.3. 객체의 안쪽 ~~~~~~~~~~~~~~~~ 2.3.4. 진리를 찾아서... ----------------------- "진리란 무엇인가?" 이 글을 읽는 여러분 중에도 한 번쯤은 이런 고민을 해 본 사람이 있을 것입니다. 필자도 잘 모르겠습니다. 무엇이 진리인지. 어떤 이는 진리를 절대적인 것이라 보기도 하고, 또 어떤 이는 상대적인 것이라 보기도 합니다. "진리"(眞理)란 "참 되게 통하는 것", 즉 참된 것을 가리킵 니다. 무엇이 진리인지를 알려면 우리는 언제나 "참"과 "거짓"을 가리지 않 을 수 없습니다. "참되다", "거짓되다"라는 것은 이처럼 우리 생활 속에 깊 이 뿌리를 내리고 있습니다. 우리는 하루에도 수 십 번 "참"과 "거짓"에 대 해서 생각하고 무의식중에도 수없이 "참"과 "거짓"을 가리면서 살아갑니다. 그만큼 이 것은 우리의 생각과 행동을 결정짓는 중요한 요소라고 필자는 생 각합니다. 프로그래밍에 있어서도 이러한 "참"과 "거짓"은 매우 중요한 위치를 차지합 니다. 컴퓨터가 가지고 있는 특징을 나열해 보면, "계산", "기억", "판단"이 있는데, 이 중에서 "판단"을 매우 중요하게 생각하는 것은, 이 "판단"을 통 해서 컴퓨터 프로그램이 수행되고 결과를 처리하기 때문입니다. 만약 컴퓨터 프로그램이 판단을 하는 능력이 없다면, 이렇게까지 컴퓨터가 발달하지는 못 했을 것입니다. 사람이 설정해 둔 여러 가지 사항을 판단하여 그에 맞는 결 과를 내는 것. 이것은 컴퓨터가 나오기 이전에는 상상하기 어려웠던 일인 것 입니다. 물론 컴퓨터가 내리는 판단이라는 것은 결국은 사람들이 세운 기준에 따른 것이지만, 우리가 어떤 사실을 가르쳐 준다면 컴퓨터는 그 사실들을 기억하 고 있다가 참과 거짓을 가려냅니다. 이제 이번 나눔에서는 이러한 판단의 준 거가 되는 "참"과 "거짓", 그리고 이를 둘러싼 여러 가지 사실에 대해서 알 아보도록 하겠습니다. [1] 논리값의 특성 Smalltalk에는 많은 객체가 있고, 각각의 객체는 저마다 알아들을 수 있는 여러 가지 지시를 가지고 있습니다. 그 중에 어떤 지시는 결과값으로 "참"이 나 "거짓" 등의 논리값을 남기는 것도 있습니다. 어떤 것이 있었습니까? 앞서 정수(Integer)와 소수(Float)를 공부할 때 "="라는 지시를 써먹은 적이 있습니다. 기억나십니까? 아마 우리는 다음의 글토막을 폈을 것입니다. 2 = 2.0 ☞ true 정수 객체 "2"에게 "=" 지시를 보냈는데, 인자로 "2.0"을 함께 보냈습니다. 위의 물음에 정수 객체 "2"는 "참"(true)이라고 대답했습니다. 다시 말하면, "2"라는 객체는 "=" 지시의 인자로 넘어온 객체가 자신과 같은지 다른지를 알 수 있는 능력이 있는 것입니다. 이는 비단 정수 객체뿐만이 아니라 우리 가 다루는 모든 객체, 즉 Smalltalk에 있는 모든 객체가 할 수 있는 기능입 니다. 아래 몇 가지 보기가 있습니다. 2.0 = 2 ☞ true (2/4) = (1/2) ☞ true $a = $b ☞ false $b = 2.0 ☞ false 'hello' = 'hello' ☞ true 'Hello' = 'hello' ☞ false 3 class = 3.0 class ☞ false true = false ☞ false 객체는 겉으로 보기에는 모양이 달라 보이더라도 그 의미가 같으면 "=" 지시 에 모두 "참"으로 대답합니다. 위에서 "2.0"과 "2"는 서로 갈래가 다름에도 불구하고 "=" 지시에 의해서 "참"값을 남겼습니다. 분수 객체인 "2/4"와 "1/2"의 경우 역시 두 객체의 분모와 분자가 다름에도 "참"이라는 결과값을 남겼습니다. 이는 분수의 경우 계산을 하기 전에 언제나 약분이 된다는 것을 생각하면 쉽게 이해할 수 있을 것입니다. 물론 이는 글자(Character)의 경우도 예외는 아니어서, 보기에서와 같이 $a 와 $b처럼 완전히 다른 글줄의 경우는 "=" 지시는 "거짓"이라는 결과를 남깁 니다. 글줄(string) 역시 "=" 지시에 똑같이 대답합니다. 자신과 같은 글줄을 인자 로 가지고 "=" 지시를 보내면 당연히 'hello' 객체는 "참"으로 대답할 것입 니다. 수(Number)의 경우에는 모양이 다르나 의미가 같은 경우 "=" 지시가 "참"을 남겼습니다. 그러나 글줄은 매우 엄격하게 따집니다. 글줄 'hello'와 'Hello'의 경우 우리들이 보기에는 같아 보입니다. 그러나 컴퓨터는 글줄에 들어 있는 대문자와 소문자를 엄격하게 구분합니다. 따라서 'hello'는 글줄 첫 글자가 대문자로 시작하는 'Hello'와 서로 다르다고 보는 것입니다. 같고 다름을 판단할 수 있는 것은 갈래(class) 역시 마찬가지입니다. 갈래 또한 엄연한 객체이기 때문에 똑같이 "=" 지시를 알아들을 수 있습니다. 3 class = 3.0 class 위의 경우 왼쪽의 경우는 SmallInteger가 되고, 오른쪽의 경우는 Float이 됩 니다. 즉 두 개의 갈래가 서로 다르기 때문에 "거짓"값을 남기는 것입니다. "trau"와 "false" 역시 객체이기 때문에 "=" 지시를 알아들을 수 있습니다. 위의 경우 "true"와 "false"는 둘 다 엄연히 다른 값이기 때문에 둘은 서로 다른 값을 가지고 있습니다. 결과값으로 "false"가 남겨지는 것은 당연하겠 지요. 이처럼 어떤 객체에게 "="를 지시하면 인자로 넘어온 객체와 자신을 비교하 여 "참" 또는 "거짓"으로 응답합니다. 이와 같이 같고 다름을 판단할 수 있 는 것은 컴퓨터가 할 수 있는 기능 중에서 매우 중요한 위치를 차지합니다. [2] 크기값과 관계 연산자 앞서 우리는 작은 정수와 큰 정수를 포함한 정수(Integer), 분수(Fraction), 소수(Float), 글자(Character)에 대한 갈래 씻줄을 알아보았습니다. 가만히 살펴보면 위의 다섯 가지의 갈래들은 한결같이 "Magnitude"라는 갈래에 씻줄 로 얽혀있다는 것을 알 수 있습니다. 이 "Magnitude"는 "크기를 가지고 있는 값"이라는 뜻입니다. 즉 두 개의 값이 있을 때 그 값들 사이에 크고 작음을 가려낼 수 있다는 말입니다. 즉 앞서 "=" 지시가 같고 다름을 가릴 수 있다 면 크기값에 내릴 수 있는 지시는 두 객체 사이의 크고 작음을 비교할 수 있 다는 말입니다. 이렇게 크고 작음을 가려낼 수 있는 지시를 통틀어 "관계 연 산자"(relational operator)라고 부릅니다. Smalltalk에서 사용할 수 있는 관계 연산자는 다음과 같은 것들이 있습니다. 2 > 5 ☞ false "2가 5보다 크다" 2 < 5 ☞ true "2가 5보다 작다" 2 >= 5 ☞ false "2가 5보다 크거나 같다" 2 <= 5 ☞ true "2가 5보다 작거나 같다" 관계 연산자는 위에서도 볼 수 있듯이 크기값(Magnitude) 사이의 크기 관계 를 비교할 때 사용합니다. ">", "<"의 경우는 산수에서 쓰는 것과 같은 기호 를 사용하고, "작거나 같다"와 "크거가 같다"의 경우는 "<=", ">="처럼 사용 합니다. "=>", "=<"는 사용할 수 없으므로 주의가 필요합니다. 아울러 앞서 살펴보았던 "="의 경우 "상등(equality) 연산자")라고 부르는 데, 상등 연산자에는 "=" 말고도 "~="이라는 지시가 하나 더 있습니다. 2 = 5 ☞ false "2와 5는 같다" 2 ~= 5 ☞ true "2와 5는 같지 않다" 즉 "="은 왼쪽과 오른쪽이 모두 같음을 의미하고, "~="은 두 값이 서로 다르 다는 것을 나타냅니다. 즉 "="와 "~="는 서로 반대되는 결과를 나타냅니다. 물론 "="와 "=~"는 상등 연산자이므로 어떤 객체에든지 적용할 수 있고, 관 계 연산자의 경우는 크기값(magnitude)의 경우에만 적용할 수 있습니다. 계속... 제 목:[부탁] 경문님, 저도 강좌 부탁요. 관련자료:없음 [34] 보낸이:김찬홍 (안드래아) 1999-01-27 16:49 조회:81 전 에전에 Ada에 대한 몇 가지 이야기를 읽은 적이 있습니다. 그 당시 Ada에 대해서 별로 좋지 않은 평이 있었구요, 무어소다 개발 환경을 구하기가 어려 워서(아니 제가 게을러서) Ada를 배우지 못했어요. 한참 C++에서 허우적대고 있을 때 Delphi(Object Pascal)을 알게 됐고, 인젠 O-Pascal의 탄탄함에 푹 빠져있습니다. 그런데 Ada9x의 경우 OOP가 포함되엉 다구요? 정말 한 번 공부해보고 싶습니다. 일단 저에게 맞는 도구는 Delphi이 지만, Ada도 나름대로 공부해 볼 가치가 있다고 생각합니다. 제가 Smalltalk 를 공부하면서 객체지향에 대해 어렵게 느껴졌던 부분을 속시원하게 정리할 수 있었듯이, 분명히 Ada강좌도 저에게 큰 도움이 될 것 같아요. 경문님, 수고스러우시겠지만 강좌 올려주세요. 열심히 청강하겠습니다. 물론! 저도 게으름 피우지 않고 Smalltalk 강좌를 꾸준히 진행하겠습니다. 그럼, 경분님 부탁드려여~!! 제 목:[강좌] Smalltalk 배우기 #18 관련자료:없음 [44] 보낸이:김찬홍 (안드래아) 1999-02-04 17:05 조회:202 Smalltalk 배우기 #18 1999. 2. 4. 김찬홍 mailto:andrea92@hitel.net ====================================== 2. 객체들과 나누는 이야기 2.1. 객체? 2.2. 몸으로 느끼기 2.3. 객체의 안쪽 2.3.1. 탐색기 사용하기 2.3.2. 객체의 성분 2.3.3. 글자와 글줄 b→2.3.4. 진리를 찾아서... ...... ======================================= 2. 객체들과 나누는 이야기 ------------------------------------ 2.3. 객체의 안쪽 ~~~~~~~~~~~~~~~~ 2.3.4. 진리를 찾아서... ----------------------- [2] 크기값과 관계 연산자 #17에서 계속... 관계 연산자는 모든 크기값에 적용할 수 있다고 했습니다. 그럼 관계 연산자 를 가지고 다음과 같은 몇 가지 실험을 해 봅시다. 2.0 > 5.0 ☞ false "(1)" (2/4) < (3/4) ☞ true "(2)" (12/43) >= (7/9) ☞ false "(3)" 2 > 2.0 ☞ false "(4)" 3 <= 3.0 ☞ true "(5)" 10 > (8/9) ☞ true "(6)" (3/4) > 1.2 ☞ false "(7)" 우선 (!)부터 (3)까지를 생각해 봅시다. 이 경우 소수와 소수, 분수와 분수 끼리 계산이 되기 때문에 당연히 아무런 문제가 없습니다. 분수의 경우는 언 제나 그렇듯이 계산을 하기 전에 약분이 이루어집니다. 따라서 (1), (2), (3) 세 경우 모두 알맞은 결과값을 얻을 수 있는 것입니다. 다음, (4)부터 (7)까지의 경우를 생각해 볼 터인데, 그 전에 앞에서 우리가 정수, 분수, 소수를 섞어서 계산했을 때 어떤 변환 규칙이 있었는지 기억하 십니까? 정수, 분수, 소수가 하나의 계산식에 섞여 있으면 언제나 다음 순서 로 값의 형태(=갈래)가 바뀌게 되어 있습니다. ----------------------------------------------------------- 정수(Integer) → 분수(Fraction) → 소수(Float) ---------------------------------------------------------- (4)의 경우 계산식에 "정수", "소수"가 섞여 있으므로 앞의 "2"가 소수, 즉 "2.0"으로 바뀌어 계산됩니다. (5)의 경우 역시 "3"이 "3.0"으로 값이 바뀌 어 계산됩니다. (6)은 "정수"와 "분수"로 이루어진 식이므로, "정수" 10이 "분수"로 바뀌어 계산됩니다. (7)의 경우는 "분수"와 "소수"로 이루어진 식 이므로, "분수"가 "소수"로 먼저 값이 바뀐 다음에 계산이 이루어집니다. 이제 조금 더 복잡한 예를 들어볼까 합니다. (2 + 3) < (4 + 2) ☞ true ((2/5) + 3) >= (1.0 * 2) ☞ true 위의 경우는 계산식을 일단 계산한 다음에 그 결과를 가지고 관계 연산자로 비교하는 글토막입니다. 역시 길표의 우선 순위에 따라서 비교할 식에는 적 당히 괄호를 둘러줘야 합니다. 물론 꼭 괄호가 필요 없을 때도 있습니다. 아 래의 두 경우가 그런 보기입니다. 3 < 4 ☞ true 2 + 4 < 3 ☞ false 위의 경우는 당연히 계산이 끝난 완전한 객체이므로 괄호가 필요 없습니다. 그런데 바로 아래의 경우는 계산식이 있음에도 불구하고 괄호가 필요하지 않 았습니다. 왜 그럴까요? 오랜만에 Smalltalk가 평가하듯이 계산식의 흐름을 따라가 봅시다. 2 + 4 < 3 → ~~~~~ 6 < 3 → ~~~~~~~~~ ☞ false 즉 겹마디 지시(binary message)의 경우는 언제나 왼쪽에서 오른쪽으로 식을 가늠하기 때문에 위의 경우 정확하게 계산이 되었습니다. 그러나 아래의 경 우는 잘못을 냅니다. 2 > 3 + 4 ☞ "False does not understand #+" 위의 글토막이 왜 제대로 가늠되지 못하는지 확인해 봅시다. 2 > 3 + 4 ~~~~~ false + 4 ~~~~~~~~~ "false" 객체는 "False"(첫 글자가 대문자) 갈래에 딸린 실체이고, 이 실체 에 결국 "+"라는 지시를 보내는 격이 됩니다. 논리값은 덧셈 계산식을 알아 듣지 못하기 때문에 결국 위의 글토막은 잘못된 결과를 얻을 수밖에 없습니 다. 따라서 이런 경우 괄호를 적당히 둘러주면 계산식을 올바르게 가늠할 수 있는 것입니다. 앞에서 살펴본 대로 수(Number)에서는 우리가 사칙 연산(+, -, *, /)을 공부 할 때와 비슷한 규칙이 적용됩니다. 그런데 크기값(magnitude)에는 숫자만 있는 것이 아닙니다. 바로 '글자'(Character)도 엄연한 하나의 크기값입니 다. 아래의 글토막을 펴 봅시다. 3 isKindOf: Magnitude ☞ true 3.0 isKindOf: Magnitude ☞ true $a isKindOf: Magnitude ☞ true 위에서 볼 수 있듯이 정수(3)와 소수(3.0) 그리고 분수는 모두 크기값입니 다. 또한 글자($a) 역시 크기값입니다. 따라서 $a, $b와 같은 글자에 대해서 도 관계 연산자를 사용할 수 있다는 말이 됩니다. 그렇다면 Smalltalk는 글자들을 어떻게 비교하고 처리할까요? 아래의 글토막 을 펴 봅시다. $a > $b ☞ false "(1)" $a < $b ☞ true "(2)" $a < $A ☞ false "(3)" $1 < $a ☞ true "(4)" $! > $1 ☞ false "(5)" 위의 다섯 가지의 경우를 잘 생각해 봅시다. (1)과 (2)를 생각해 보면 $a는 $b보다 작다고 나옵니다. 또한 (3)을 보면 대문자 $A가 $a보다 작다고 나옵 니다. 더구나 (4)는 숫자인 $1 역시 $a 보다 작다고 알려줍니다. 마지막으로 (5)에서 $!는 $1보다도 작다고 나옵니다. 자, 도대체 Smalltalk 에서는 어떤 기준으로 글자들의 크기가 정해지게 되는 것일까요? 글자들이 서로 크기를 비교할 때에는 그들이 가지고 있는 고유 번호, 즉 코 드(code)로써 비교됩니다. 앞서 글자가 가진 고유 번호는 어떤 것이라고 했 습니까? 네, ASCII 코드가 그것이죠. 위의 경우를 코드를 사용해서 생각해 봅시다. 위에서 사용된 글자들을 글자의 고유 번호로 바꾸어서 나타내면 아 래 글토막들을 얻을 수 있습니다. 97 > 98 ☞ false 97 < 98 ☞ true 98 < 65 ☞ false 49 < 97 ☞ true 33 > 49 ☞ false 이제 위에서 가늠해 본 글토막의 결과가 어떤 이유로 나타났는지를 짐작할 수 있을 것입니다. 이렇게 글자끼리의 비교는 글자의 번호를 사용합니다. "컴퓨터"가 "수"를 주로 다룬다고 생각하면 별로 이상할 것도 없겠지요? 공교롭게도 ASCII 코드는 사전 배열 순서와 일치합니다. 따라서 사전에서 앞 에 나오는 글자는 크기가 작고, 뒤에 나오는 글자는 크기가 크다는 것입니 다. $a보다는 $b가, $1보다는 $A가 사전에서 뒤에 나오기 때문에 크기가 큰 것입니다. [3] 논리값을 남기는 다른 연산자들 지금까지 우리는 "=", "~="의 상등 연산자(equality operator)와 "<, <=, >, >="의 "관계 연산자"(relational operator)에 대해서 알아보았습니다. 이들 은 모두 다른 객체들을 인자로 취하여 결과값으로 "참"이나 "거짓" 등의 논 리값을 내놓는 것들이었습니다. 그런데 어떤 객체를 인자로 취하여 논리값을 남기는 연산자는 상등 연산자나 관계 연산자만은 아닙니다. 여러분도 짐작했겠지만 우리는 이미 이런 종류의 연산자들을 써 봤고 또 알고 있습니다. 다음을 보십시오. 3 isKindOf: Integer ☞ true $a isUppercase ☞ false $o isVowel ☞ true 5 between: 1 and: 10 ☞ true "is-"가 붙은 길표(selector)들은 대게 그 길표를 통해 지시를 받은 객체의 상태를 파악하는 "묻는 지시"(query message)인 경우가 많습니다. 이를테면 객체가 어떤 갈래 붙이인지를 알아보기 위한 "isKindOf:"라던가, 글자가 대 문자인가 혹은 소문자인가 등을 조사하는 여러 지시들은 모두 "is-"로 시작 하고, 따라서 해당 객체의 상태를 "참" 또는 "거짓"으로 나타냅니다. 물론 논리값을 내놓는 지시들이 모두 "is-"로 시작하지는 않는데, 가장 대표 적인 것이 "between:and:" 지시입니다. 이 지시를 받은 객체는 주어진 두 개 의 인자 사이에 있으면 "참"을 남기는 지시입니다. 따라서 "between:and:" 역시 논리값을 결과값으로 남기는 연산자라고 할 수 있습니다. Smalltalk에는 이밖에 논리값을 결과로 남기는 지시들이 많이 있습니다. 이 런 것들은 상등 연산자, 관계 연산자와 함께 논리값을 다루는데 매우 중요한 역할을 하고 있습니다. [4] 논리 연산자 논리 연산자는 지금까지 다루었던 논리값을 남기는 연산자들에 적용하여 "참"이나 "거짓" 등의 값을 다룰 수 있게 해줍니다. 여기서는 논리 연산자란 무엇이고, 그것이 왜 필요한지에 대해서 알아보도록 합시다. 산수에서 아래와 같은 조건을 본 적이 있을 것입니다. 1 < 5 < 10 이것은 "5는 1보다는 크고, 10보다는 작다"는 말입니다. 그럼 위의 문장을 Smalltalk에서 그대로 쓰면 어떻게 될까요? 1 < 5 < 10 ☞ "True does not understand #<" 짐작했겠지만 잘못이 발생했습니다. Smalltalk에서 겹마디 지시는 항상 왼쪽 과 오른쪽, 이렇게 두 개씩 객체들을 취합니다. 따라서 위의 경우는 1 < 5 < 10 → true < 10 → 이라는 결과가 나오는 것입니다. treu는 당연히 "<" 지시를 알아들을 수 없 으므로 잘못을 발생한 것입니다. 그렇다면, 위의 경우 Smalltalk에서는 어떻 게 표현해야 할까요? 위에서 우리가 살펴본 식은 두 개의 조건이 합쳐져 있다고 생각하면 됩니다. 1 < 5 5 < 10 즉 위의 두 개의 조건이 모두 참이어야만 "1 < 5 < 10"의 조건이 만족되는 것입니다. 결과적으로 두 개의 조건을 이어서 하나의 결과값을 만들어 내야 합니다. 바로 이것이 "논리 연산자"(logical operator)의 역할입니다. 다음 글토막을 펴 보십시오. (1 < 5) & (5 < 10) ☞ true 위에서 "&" 기호가 바로 논리 연산자의 한 종류입니다. 이 "&" 기호는 "그리 고"라고 읽습니다. 굳이 영어로 하면 "and"가 되겠지요. 그리고 "&"의 연산 수가 되는 두 개의 식들이 먼저 계산되어야 하기 때문에 괄호를 둘렀습니다. Smalltalk에서 미리 마련된 논리 연산자에는 두 연산수가 모두 참일 때 결과 값도 참이 되는 "논리곱"(and, 그리고)과 한 쪽의 값만 참이어도 결과값이 참이 되는 "논리합"(or, 또는)이 있습니다. 더불어 현재의 논리값을 반대로 뒤집는 "부정"이 있습니다. 아래에서 "a", "b"는 "참" 혹은 "거짓"값을 가지는 것으로 합니다. a & b 두 값이 모두 참이면 "참", 그 밖은 "거짓". a | b 두 값 중 하나라도 참이면 "참", 그 밖은 "거짓". a not a가 참이면 "거짓", 거짓이면 "참". 이 세 개의 논리 연산자들을 이용하여 여러 가지 조건을 연결해서 하나의 결 과값을 나타낼 수 있습니다. 그런데 위의 연산자들이 하는 일에 대해서 매우 생소한 사람이 있을지도 모르겠습니다. 그래서 아래에 표를 통하여 결과를 정리해 놓았습니다. ----------------------------------------------------------- 값 &(논리곱) |(논리합) ---------------------------------------------------------- 참 참 참 참 참 거짓 거짓 참 거짓 참 거짓 참 거짓 거짓 거짓 거짓 ---------------------------------------------------------- 위의 표처럼 논리 연산자의 참과 거짓값을 규정해 놓은 표를 "진리표"(truth table)라고 부릅니다. 위의 표를 보면 "참 & 거짓"의 경우 결과값으로 "거 짓"이 나옴을 알 수 있습니다. 그럼 이제 아래의 몇 가지 글토막들을 통하여 논리합과 논리곱이 어떻게 적 용되는지를 살펴보도록 합시다. 우선 "true"와 "false"를 직접 사용합시다. true & true ☞ true true & false ☞ false true | false ☞ true false | true ☞ true false & false ☞ false 잘 보면 위의 결과들은 앞에서 필자가 제시한 진리표와 일치한다는 것을 알 수 있습니다. 그런데 실제로 프로그램을 작성할 때에는 위와 같이 논리 연산 자의 연산수로 직접 "참"이나 "거짓"을 사용하는 경우는 극히 드뭅니다. 대 신 앞서 우리가 살펴본 논리값을 결과값으로 산출하는 연산자나 지시 등을 사용합니다. 그럼 이제 조금 더 복잡하면서도 일반적인 예를 들어봅시다. (2 > 3) & (4 > 3) ☞ false ($a isVowel) | (3 < 1) ☞ true 식이 조금 복잡해 보이기는 하지만, 어차피 모든 길표(selector)들은 "우선 권 법칙"을 따르기 때문에 차근차근 살펴보면 결코 어려운 식은 아닙니다. 위의 예에서 첫 번째 글토막을 함께 따라가며 가늠해봅시다. (2 > 3) & (4 > 3) → ~~~~~~ false & (4 > 3) → ~~~~~~~ false & true → ☞ false 즉 복잡한 식의 경우라도 길표의 우선권을 잘 생각하면서 가늠하면 어렵지 않게 생각할 수 있습니다. 자, 그럼 아래의 글토막은 어떤 결과를 낼까요? (3 isKindOf: Object) & (100 factorial between: 1 and: 1000 factorial) 역시 매우 복잡해 보이는 글토막이지만 차근차근 풀어보면 결과를 알 수 있 을 것입니다. (논리 연산의 법칙을 아는 사람은 위의 식을 다 가늠해 보지 않고도 결과를 알 수 있을지도 모르겠습니다. ^^:) 이제 마지막으로 "부정"에 대해서 알아봅시다. 부정은 논리값을 뒤지는 일을 합니다. 아래를 보십시오. true not ☞ false false not ☞ true (2 < 3) not ☞ false (2 > 3) & (4 > 3) not ☞ false 논리값 객체에 "not" 지시를 보내면 지시를 받은 객체와 반대되는 값을 남깁 니다. 즉 "참"은 "거짓"으로, "거짓"은 "참"으로 뒤바꾸는 역할을 합니다. 주로 이 "not" 지시는 어떤 논리 연산으로 나온 결과를 부정하여 조건을 세 울 때 사용합니다. 지금까지 우리는 "논리합", "논리곱", "부정"의 세 가지 논리 연산자를 공부 해 봤는데, 이들은 프로그램에서 여러 가지 조건을 나타내는데 사용됩니다. 이제 이렇게 해서 판가름된 진리(참이나 거짓)는 후에 프로그램의 실행 흐름 을 바꾸는 매우 중요한 역할을 하게 됩니다. 프로그램의 실행 흐름에 대해서 는 훗날 이야기를 나눌 기회가 있을 테니, 그 때 가서 더 자세한 이야기를 하도록 합시다. [5] 짧은 경로 계산과 채온 경로 계산 앞서 우리는 &(논리곱)과 |(논리합)에 대해서 공부한 적이 있습니다. 그런데 이 두 개의 연산자는 독특한 특성을 가지고 있습니다. 자, 다음의 계산 결과 가 무엇인지 생각해 봅시다. Smalltalk를 쓰지 말고 반드시 암산으로 풀어야 합니다. (2 > 3) & ((3 * 13243 / 32 + 1.23 - 4) < (3 + 30000 * 2132323 - 78 * 33 ) 위의 식을 푸는 사람들을 보면 대게 두 부루류 나뉘어집니다. 우선 첫 번째 부류는 한참 동안 머릿속으로 식을 계산하는 사람들이고, 두 번째는 위의 식 을 보자마자 바로 결과를 말하는 사람입니다. 자, 여러분은 위의 두 부류 중 에 어떤 부류입니까? 단순히 여기서는 암산의 속도 문제가 아닙니다. 위와 같은 차이가 나게 되는 이유는 다른데 있는 것입니다. 그 이유가 무얼까요? 위에서 사용된 논리 연산자는 "&", 즉 "논리곱"입니다. 논리곱은 무엇입니 까? "주어진 두 개의 연산수 모두가 '참'이면 결과값도 '참'"인 연산입니다. 이 말은, 결국 주어진 두 개의 연산수 중에 "거짓"이 하나라도 있으면 결과 역시 당연히 "거짓"이 된다는 말입니다. 이제 이해가 가십니까? 위의 경우 "&" 지시를 받는 객체는 (2 >3), 즉 "false"입니다. 따라서 위의 경우는 "&" 길표에 딸려오는 인자를 생각할 필 요도 없이 위 식의 결과가 "거짓"이 되는 것입니다. 그런데 Smalltalk는 불행하게도 위의 경우 왼쪽과 오른쪽 연산수를 모두 다 가늠합니다. 왼쪽 연산수를 가늠하는 것은 "&" 지시를 보낼 객체를 가늠하기 위한 것이므로 당연한 것이곘지만, 위와 같이 결과가 뻔한 경우에는 굳이 오 른쪽 연산수까지 가늠해서 아까운 시간을 쓸 필요가 없는 것입니다. 물론 Smalltalk는 오른쪽에 주어진 연산수(인자)까지도 충실하게(!) 가늠하여 결 과를 처리합니다. 그런데 Smalltalk에는 이렇게 충실한(나쁘게 말해서 멍청한?) 지시가 있는가 하면, 상황 판단을 아주 잘해서 계산이 필요 없을 때는 굳이 계산하려고 하 지 않는 똑똑한 지시가 있습니다. 바로 "and:"와 "or:"이 그것입니다. 아래 를 보십시오. true or: [true] ☞ true false or: [true] ☞ true false and: [true] ☞ false true and: [false] ☞ false 여기서 처음 보는 기호가 나왔습니다. "[ ]"은 "대괄호"라고 부르는데, 나중 에 이야기하겠지만 "덩이"(block)를 나타낼 때 사용하는 기호입니다. 여하튼 앞서 살펴본 "&", "|" 지시가 겹마디 지시였다면 "and:"와 "or:"은 "쇠마디 지시"입니다. 거기다가 넘겨받는 인자 역시 보통의 식이 아니라 "덩이"입니 다. "&", "|" 지시가 자신에게 주어진 연산수, 즉 지시를 받는 객체(receiver)와 인자(parameter)를 모두 가늠하는 것에 비해 "and:"와 "or:"는 지시를 받는 객체를 가늠하여 그 값에 따라 덩이(block)로 주어진 인자를 가늠하기도 하 고 가늠하지 않고 넘어가기도 합니다. 즉, false and: [?] "?"가 무엇이건 무조건 "거짓" true and: [?] "?"의 결과가 계산식의 값이 됨. true or: [?] "?"가 무엇이건 무조건 "참" false or: [?] "?"의 결과가 계산식의 값이 됨. 이와 같이 주어진 모든 식을 계산하는 "&", "|"을 "채운 경로 계산"(full circuit operation)이라 하고, 필요에 따라 주어진 인자(오른쪽 연산수)를 계산에서 제외하는 "and:", "or:"을 "짧은 경로 계산"(short circuit operatorion)이라고 부릅니다. 채운 경로 연산과 짧은 경로 연산의 차이를 가장 잘 느낄 수 있는 것은 복잡 한 연산수를 다룰 때입니다. 아래에 채운 경로 연산의 보기를 들겠습니다. (2 > 3) & (1000 factorial between: 100 factorial and: 10000 factorial) ☞ false 위의 글토막을 가늠하려면 대략 2~4초 정도의 시간이 필요합니다. 그것은 "&"의 인자를 계산하기 위해서 큰 수의 계승(factorial)을 구해야하기 때문 입니다. 그런데 다음 식을 가늠해 봅시다. (2 > 3) and: [100 factorial between: 100 factorial and: 10000 factorial] ☞ false 위의 경우 계산에 필요한 시간은 매우 짧습니다. 거의 나 "Workspace > Display It" 메뉴를 실행한 것과 동시에 결과가 나왔습니다. 무엇이 이렇게 계산 시간의 차이를 가져왔을까요? 네, 바로 "짧은 경로 계산"의 똑똑함 때문입니다. 앞서 필자가 낸 문제를 풀 때 여러분은 짧은 경로 계산을 햿습니까, 아니면 채운 경로 계산을 했습니까? ^^: 물론 짧은 경로 계산이 시간을 단축할 수 있으므로 효율적인 방법이 되기는 하지만, 반드시 가늠해야 할 지시가 들어있는 식의 경우 는 오히려 채운 경로 계산이 좋습니다. 덧붙이자면 채운 경로 계산을 사용한 글 토막이 짧은 경로 계산을 쓴 글토막보다 읽기가 좀 더 좋습니다. 지금까지 우리는 Smalltalk에서 논리값을 다루는데 필요한 여러 가지에 대해 서 알아보았습니다. 상등 연산자, 관계 연산자를 비롯하여 Smalltalk에는 객 체들을 이용하여 참이나 거짓을 얻는 많은 종류의 지시가 존재합니다. 또한 이렇게 얻어진 결과값을 엮어서 하나의 조건을 만드는 논리 연산자가 있었습 니다. 물론 이러한 논리 연산자는 그들이 가지는 특성에 따라, 주어진 모든 연산수를 가늠하는 "채운 경로 연산"과 필요할 경우에는 연산수를 가늠하는 "짧은 경로 연산"이 있다는 것도 알아보았습니다. 지금은 이 논리와 진리에 대해서 여러분이 그 유용성을 깨닫지 못할지도 모 르곘습니다. 그러나 이렇게 익혀둔 진리 찾기는 앞으로 여러분이 프로그래밍 에서 문제를 풀기 위해서, 또한 컴퓨터에 생각할 수 있는 힘(!)을 불어넣어 주기 위해서 반드시 필요한 것입니다. 사실 Smalltalk의 객체들이 똑똑하게 자신이 해야 할 일을 제대로 할 수 있는 이유 또한, 이런 객체들이 언제나 진리를 찾아서 자신히 가야할 바른 길을 가기 때문입니다. 우리도 언제나 이 런 마음가짐으로 프로그램을 짜고, 공부하고, 우리들의 생활 속에서 살아가 다보면, 훌륭한 하나의 객체로써, 또한 전체를 이루는 중요한 요소로써 자리 매김할 수 있을 것 같습니다. 계속... 제 목:[강좌] Smalltalk 배우기 #19 관련자료:없음 [76] 보낸이:김찬홍 (안드래아) 1999-05-06 16:53 조회:148 Smalltalk 배우기 #19 1999. 2. 9. 김찬홍 mailto:andrea92@hitel.net ====================================== 2. 객체들과 나누는 이야기 2.1. 객체? 2.2. 몸으로 느끼기 2.3. 객체의 안쪽 2.3.1. 탐색기 사용하기 2.3.2. 객체의 성분 2.3.3. 글자와 글줄 2.3.4. 진리를 찾아서... a→2.3.5. 무른값, 굳은값, 그리고 바로값 ...... ======================================= 2. 객체들과 나누는 이야기 ------------------------------------ 2.3. 객체의 안쪽 ~~~~~~~~~~~~~~~~ 2.3.5. 무른값, 굳은값, 그리고 바로값 ------------------------------------ Smalltalk 세상에는 많은 객체들이 존재합니다. 아니, Smalltalk 자체가 바 로 객체이며, 보잘것없다고 생각되는 작은 수 하나라도 Smalltalk를 이루고 있는 중요한 객체입니다. 이 객체는 그들이 가지는 특성에 따라 여러 가지로 분류할 수 있는데, 이번 나눔에서는 객체들의 변화성에 따라서 분류해 보고, 새로운 특징을 지니는 두 갈래의 객체에 대해서도 알아보도록 하겠습니다. [1] 굳은값과 무른값 Smalltalk에 있는 모든 객체는 그 자신이 가지고 있는 값이 바뀔 수 있는 "무른값"(mutable object)과 어떤 경우에도 객체가 가지는 값이 바뀔 수 없 는 "굳은값"(immutable object)으로 나뉘어집니다. 예를 들어 작은 정수(SmallInteger) "3"을 생각해 봅시다. 3은 3이지 결코 4 나 5가 될 수 없습니다. 어떤 이는 "3 + 1"이라는 글토막을 가늠하면 결과값 으로 "4"를 얻을 수 있다고 하겠지만, 이는 "3"이 "4"로 바뀐 것이 아닙니 다. 결국 "3" 객체가 "+ 1"이라는 지시를 이해하고 실행하여 "3"과는 __전혀 다른__ "4"라는 객체를 새로 만들어 내는 것이지, "3"이라는 객체 자체의 의 미가 바뀌는 것은 아니라는 말입니다. 반면 앞에서 살펴본 글줄(string)의 경우는 필요하면 언제든지 글줄을 구성 하는 글자들을 바꿀 수 있습니다. 'Hello' inspect 로 객체 탐색기를 열고, 여기서 마음대로 글줄의 글자를 바꾸고 나면 실제로 글줄 자체의 값이 달라지게 됩니다. 지금 열려있는 객체 탐색기에서 두 번째 글자 $e를 $a로 바꾸어 봅시다. 앞서 "글자와 글줄"에 대해서 알아볼 때 탐 색기에서 분명히 글줄을 구성하고 있는 글자 성분을 바꿀 수 있었습니다. 그 때를 기억하면서 다시 한 번 아래에 'hello'를 'hallo'로 바꾸는 과정을 적 어봅니다. 1) 왼쪽 널(pane)에 있는 선택 막대를 "1"로 옮겨서 1번 성분이 표 시되게 한다. 2) 오른쪽 널에 $e가 표시되었는지 확인한다. 3) $e에서 'e'를 지우고 $a로 바꾼다. 4) 오른쪽 널의 변경을 적용하기 위하여 를 누르거나 Workspace > Accept 메뉴를 실행한다. 위의 과정을 거친 뒤 실제로 글줄이 바뀌었는지를 확인하기 위해서 왼쪽 널 에 있는 "self"로 선택 막대를 옮겨보면 오른쪽 널에 'hallo'가 표시되는 것 을 볼 수 있습니다. 이처럼 무른값은 객체의 성분을 바꿀 수 있습니다. 그런데 Smalltalk에는 글줄과 비슷한 속성을 가지고 있으면서도 동시에 정수 (Integer)와 같은 굳은값의 성질을 갖는 객체가 있습니다. 이런 갈래의 객체 를 "이름값"(symbol)이라 합니다. 즉, 이름값은 글줄의 성질을 가지고 있지 만, 그 글줄을 구성하는 성분의 값을 바꿀 수 없는 굳은값인 것입니다. 아래에 이름값의 몇 가지 보기를 들겠습니다. #Smalltalk #Hello #class #isKindOf: #between:and: #+ 이름값은 위에서 보다시피 우물 정(#)으로 시작해서 빈칸으로 끝납니다. 즉 우물 정이 이름값의 시작표시가 되고 빈칸이 나오기까지의 모든 글자들을 이 름값으로 삼습니다. 그러므로 이름값에는 빈칸이 들어갈 수 없겠지요? 나중에 좀 더 자세하게 알아보겠지만, 이름값(symbol)은 Smalltalk 언어에서 사용하는 이름을 저장할 때 쓰입니다. 이를테면 #class, #isKindOf: 등은 모 두 객체에게 보내는 지시(message)의 이름들입니다. 이런 이름들을 나타내기 위한 것이 주로 이름값이 하는 일입니다. 이름값에 대해서 몇 가지 실험을 해 보겠습니다. #hello class ☞ Symbol Symbol superclass ☞ String 위의 글토막들을 가늠해보면 흥미로운 사실을 알 수 있습니다. 즉 이름값의 윗갈래는 결국 글줄이라는 것입니다. 앞서 우리가 갈래에 대해서 이야기할 때를 기억해 봅시다. SmallInteger, LargeInteger는 모두 Integer의 아랫갈 래였고, 이들 갈래의 윗갈래는 Number였습니다. 그렇다면 SmallInteger도, LargeInteger도 결국은 Number가 되는 것입니다. 3 class ☞ SmallInteger 300 factorial class ☞ LargeInteger 3 isKindOf: Number ☞ true 300 factorial isKindOf: Number ☞ true 그렇다면 아래의 글토막을 가늠해 봅시다. 'hello' class ☞ String #hello class ☞ Symbol #hello isKindOf: String ☞ true 결국 이름값은 '굳은값'이라는 특성을 갖는 글줄(string)의 한 종류라는 것 을 위의 실험에서 알 수 있습니다. 지금까지 제가 계속 이름값은 굳은값이라고 했는데, 그럼 실제로 실험을 통 해서 알아보도록 합시다. 다음과 같이 해 봅시다. #hello inspect 위의 글토막을 가늠하면 객체 탐색기가 열릴 것입니다. 이제 왼쪽 널에서 두 번째 성분을 가리키는 "2"를 선택합시다. 그러면 오른쪽 널에는 $e가 나타날 것입니다. 이제 오른쪽 널에 있는 $e를 $a로 바꿉시다. 그런 다음 변경된 내용을 Smalltalk에게 알리기 위해 글쇠를 누릅시다. 글쇠를 누르자 마다 다음 그림과 같이 Smalltalk가 불평을 늘어놓을 것입니다. <그림 2-18> 탐색기에서 #hello의 성분을 바꾸려는 모습 (Stp2-18.gif) 객체에게 알아들을 수 없는 지시를 내렸을 때 나타났던 것처럼 이번에도 발 자취 창(walkback window)이 열리면서 탐색기에서 우리가 취한 동작에 대해 서 "should not implement"라고 투덜거리는 Smalltalk를 볼 수 있을 것입니 다. 결국 우리가 굳은값인 이름값의 성분을 바꾸려고 하면 Smalltalk는 해당 기능을 실행할 수 없다는 표시로 발자취 창을 열어 보인 것입니다. 잠시 발자취 창을 닫지 말고 중간쯤에 여러 줄로 나타나 있는 글줄 묶음을 유심히 살펴봅시다. ---------------------------------------------------------- Symbol(Object)>>error: Symbol(Object)>>shouldNotImplement Symbol>>at:put: ← SequenceableCollectionInspector>>setField:to: SequenceableCollectionInspector(Inspector)>>accept SequenceableCollectionInspector(Presenter)>>performCommand: CommandQuery>>perform ...(생락)... ---------------------------------------------------------- 이 글줄들은 앞의 "1.5.9" 도막에서도 이야기했듯이 Smalltalk가 잘못이 일 어나기까지 어떤 길수(method)들을 실행했는지를 보여주고 있습니다. 이 길 수들의 자취를 읽을 줄 알면 문제의 원인을 쉽게 파악할 수 있습니다. 위에서 화살표(←)를 달아놓은 줄을 봅시다. Symbol>>at:put: Smalltalk에서 어떤 갈래에 들어 있는 길수를 표시할 때에는 위와 같이 "갈 래이름>>길수이름"과 같이 표시합니다. 따라서 위의 경우에는 "Symbol"이라 는 갈래의 "at:put:"이라는 길수를 나타냅니다. "at:put:"은 앞서 글줄을 설 명할 때 나왔던 쇠마디 길수(keyword message)였습니다. 이를테면 'hello' at: 2 put: $a 와 같은 지시를 내리면 'hello'가 'hallo'로 바뀝니다. 그런데 지금까지 늘 이야기했듯이 이름값은 굳은값이기 때문에 at:put: 지시를 내릴 수 없는 것 입니다. 결국 이름값은 그 성분을 바꿀 수 없는 굳은값이라는 것이 증명됩니 다. 이제 이름값의 특성을 알았으니, 단추를 눌러서 열려 있는 발자취 창을 닫으십시오. Smalltalk에 관한 글에서 길수(method)의 이름을 쓸 때에는 이름값의 형태로 나타내는 관습이 있습니다. 지금부터 필자도 이 관습을 존중하여, 앞으로 글 에서 길수의 이름이 나오게 되면 이름값의 형태로 적겠습니다. 이를테면 객 체 3에 #class 지시를 보낸다는 식으로 적을 것입니다. 처음에는 이상해 보 이겠지만, 익숙해지면 길수의 이름을 매우 쉽게 알아볼 수 있을 것입니다. [2] 이름 짓기 이름값 이야기가 나온 김에 여기서 Smalltalk에서 이름을 붙이는 방법에 대 해서 이야기를 해 볼까 합니다. 지금까지 우리들은 많은 이름들을 접해왔습니다. 그 중에는 Object, Number, Integer, String처럼 갈래의 이름도 있었고, #class, #superclass, #isKindOf:, #between:and: 처럼 길수의 이름도 있었습니다. 이러한 모든 것 은 Smalltalk에서는 이름값으로 처리되며, 이름값은 나름대로의 규칙을 가지 고 있습니다. 쉽게 생각합시다. 아기가 태어나면 이름을 지어줍니다. 그런데 이름을 아무 렇게나 지어주는 부모는 없을 것입니다. 왜냐하면 이름은 그 아이의 일생에 큰 영향을 주기 때문입니다. 따라서 매우 신중하게, 그리고 어떤 규칙을 가 지고 이름을 지어줍니다. 보통 사람의 이름은 "성씨"와 "이름"으로 나뉘어집 니다. 저의 경우에 성씨는 김(金)이고 이름은 찬홍(燦洪)입니다. 물론 요즘 에는 우리말 이름을 지어주는 경우도 많이 볼 수 있지만, 그래도 역시 이 "성씨"와 "이름"의 관계를 무시하지는 않습니다. 마찬가지로 Smalltalk에서도 이름을 짓는데 나름의 규칙이 있습니다. 이 규 칙을 특별히 "이름 짓기 규칙"이라고 부르며, Smalltalk에서 쓰이는 모든 이 름들에 적용됩니다. 아울러 이 이름짓기 규칙이 바로 이름값을 만드는데 필 요한 규칙이기도 합니다. 아래에 Smalltalk의 이름 짓기 규칙을 설명합니다. << 이름 짓기 규칙 >> =========================================================== 1. 이름에는 기본적으로 영문 알파벳과 숫자, 그리고 밑줄(_)을 사용한다. 2. 첫 글자가 숫자여서는 안 된다. 3. 영문 알파벳의 경우는 대문자와 소문자가 엄격하게 구별된다. 4. 겹마디(binary) 지시에 한해서 다음의 기호를 사용할 수 있다. ! @ % * ( [ { } < > = | \ / ? + - : =========================================================== 처음에는 위의 규칙들이 조금 딱딱하게 느껴지겠지만 Smalltalk로 많은 글토 막을 가늠해보고 또한 여러 가지 프로그램을 작성하다보면 어느새 위의 규칙 자체가 큰 걸림돌이 되지는 않을 것입니다. 위의 규칙에 더해서 몇 가지 이야기를 해 둘 것이 있습니다. 우선 영문자의 대소문자 구별에 대한 이야기입니다. 앞서 이야기한 바와 같 이 Smalltalk에서는 철저하게 영문자의 대문자와 소문자를 구별합니다. 그래 서 만약 Smalltalk와 smalltalk라는 두 개의 이름이 있다면 두 개는 서로 다 르게 취급됩니다. 마찬가지로 SmallInteger와 Smallinteger 역시 서로 다른 이름입니다. 여러분이 실수로 3 isKindOf: Smallinteger 라고 했을 경우 Smalltalk는 "Undeclared Smallinteger"라는 잘못알림글을 뿌릴 것입니다. 이처럼 Smalltalk에서는 이름에 대소문자를 구별하기 때문에 특히 대소문자가 섞여있는 이름을 입력할 때 철자를 틀리지 않도록 조심해야 합니다. 이제 아래에 옳은 이름과 잘못된 이름의 보기를 들고 이름 짓기에 대한 이야 기를 마무리할까 합니다. < 정확한 이름의 보기 > a A IAmABoy YouAreAGirl Hello_Smalltalk The3rdRoad class isKindOf: between:and: do:to:by: + ++ - -- ** & ~= != < 잘못된 이름의 보기 > 1Copy 숫자로 시작할 수 없다. Good Name 이름에는 빈칸을 사용할 수 없다. Good! 숫자, 영문자 및 밑줄(_)만 쓸 수 있다. +++ 특수기호는 두 개 까지만 사용할 수 있다. ---<잠깐>---------------------------------------------------------- 밑줄 이야기 전통적으로 Smalltalk에서 이름을 지을 때에는 철저히 영문자와 숫자만을 사 용했습니다. 그러나 최근에 발표된 Smalltalk들은 대부분 영문자, 숫자와 함 께 밑줄(_)까지 이름 짓기에 사용할 수 있게 되었습니다. 이는 C/C++ 등 다 른 언어에서 만들어진 부분들을 불러서 쓰거나, 반대로 Smalltalk에서 만든 것을 다른 언어에서 쉽게 사용할 수 있도록 해 줍니다. 아무튼 Dolphin의 경 우는 밑줄(_)까지 이름에 쓸 수 있기 때문에 매우 바탕글을 쉽게 알아볼 수 있습니다. ---------------------------------------------------------- [3] 배열 앞에서 우리는 글줄(String)과 이름값(Symbol)을 공부했습니다. 이들은 모두 글자로 이루어진 번호 붙은 성분(indexed part)을 가지고 있습니다. 그런데 Smalltalk에서는 글자뿐만 아니라 서로 다른 갈래의 객체를 성분으로 가질 수 있는 핫객체도 있습니다. 이런 갈래의 객체들을 우리는 배열(array)이라 부릅니다. 즉 글줄이나 이름값은 글자로만 이루어져 있지만 배열은 그 성분 에 어떠한 객체라도 다 담을 수 있는 것입니다. 다음 글토막을 펴봅시다. #(1 2 3) class ☞ Array 위에서 #(1 2 3)은 1, 2, 3이라는 세 개의 정수 갈래 객체를 담고 있는 배열 입니다. 이 배열에 #class 지시를 보내면 "Array"라고 응답합니다. 그러면 배열의 속은 어떻게 생겼는지 역시 객체 탐색기를 이용해서 알아보도 록 합시다. 다음 글토막을 가늠해 보십시오. #(1 2 3) inspect <그림 2-19> 배열 #(1 2 3)을 탐색하는 모습 (Stp2-19.gif) 탐색기의 왼쪽 널에는 현재 탐색하고 있는 객체 자신을 나타내는 "self"와 객체의 번호 붙은 성분인 "1", "2", "3"이 나타나 있습니다. 각각의 성분을 마우스로 눌러 보면 오른쪽 널에 해당 성분에 들어 있는 값을 확인할 수 있 습니다. 이렇게 배열값을 나타내려면 #( ) 속에 필요한 성분을 넣으면 됩니다. 성분 과 성분 사이는 빈칸으로 갈라줍니다. 배열에는 여러분이 생각하고 있는 모든 객체들이 다 들어갑니다. 객체 탐색 기를 이용해서 아래 배열들을 탐색해 봅시다. 글쇠판에서 를 누르면 바로 객체 탐색기가 열린다는 것은 잊어버리지 않으셨지요? 1. #($a $b $c) 2. #(3.14 1.414) 3. #('우리 나라' '대한 민국') 4. #(true false nil) 5. #(#red #blue #green) 6. #(apple banana true) 7. #(100 $a 'hello' true false nil #red #green #blue black ) 편의상 각 배열값에 대해서 번호를 붙였습니다. 앞으로 이 번호를 가지고 이 야기를 진행할까 합니다. (1)의 경우는 $a $b $c, 이렇게 세 개의 글자로 이루어진 배열입니다. 배열 의 성분이 글자라고 해서 이 배열이 곧 글줄(String)이 될 수는 없습니다. 왜냐하면 글줄과 배열은 겉모양이 분명히 다르기 때문입니다. 어쨌든 (1)은 글자들로 이루어진 배열입니다. (2)의 경우는 실수(Float) 두 개로 이루어진 배열입니다. (3)은 글줄 두 개로 이루어진 배열입니다. 배열의 성분을 가르기 위해서 빈 칸이 쓰였지만, 글줄을 나타내는 따옴표(' ') 속에 들어 있는 빈칸은 배열에 상관없이 글줄을 이루는 성분이 됩니다. 즉, 위의 경우 '우리 나라'와 '대한 민국'이라는 두 개의 글줄을 성분으로 갖게 됩니다. (4)는 논리값인 "참"(true)과 "거짓"(false), 그리고 아무런 의미도 가지고 있지 않은 "헛"(nil)으로 이루어진 배열값입니다. 논리값과 헛 역시 배열의 성분으로 사용할 수 있습니다. (5)는 방금 알아본 이름값(Symbol)으로 이루어진 배열입니다. 역시 세 개의 이름값이 성분으로 들어 있습니다. (6)은 조금 특별한 경우입니다. 여기에는 apple, banana, 그리고 true라는 세 개의 성분이 있습니다. 여기서 true는 논리값의 "true"를 가리킵니다. 그 러나 apple이나 banana는 Smalltalk에서 미리 어떤 의미를 부여한 값이 아니 기 때문에 여기서는 이름값(symbol)으로 처리됩니다. 탐색기를 통해 보거나 글토막으로 펴 보면 #(#apple #banana true)로 나옵니다. 즉 apple과 banana 는 이름값으로 처리되었다는 것을 보여줍니다. #(apple banana true) ☞ #(#apple #banana true) (7)의 경우는 많은 수의 성분을 가진 배열입니다. 정수 100, 글자 $a, 글줄 'hello', 논리값인 true와 false, 아무런 의미도 없는 헛(nil), 그리고 이름 값인 #red #green #blue #black, 이렇게 모두 열 개의 성분을 가지고 있습니 다. 배열의 성분이 많다고 해도 각각의 성분을 빈칸으로 제대로 갈라주기만 하면 얼마든지 많은 수의 성분을 배열에 나타낼 수 있습니다. ---<잠깐!>---------------------------------------------------------- 배열 성분에 대한 해석 #( )을 사용하여 배열값을 만들 때 어떤 성분이 들어갈 수 있는가에 대한 문 제는 생각보다 복잡합니다. 왜냐하면 각 Smalltalk 시스템마다 조금씩 다르 게 배열 성분을 처리하기 때문입니다. Dolphin Smalltalk의 경우에는 앞에서 이야기한 대로 true, false, nil을 제 대로 처리합니다. 즉 배열값을 만들 때 true, false, nil을 정확하게 논리값 인 참, 거짓, 그리고 헛(nil)으로 처리한다는 말입니다. 그렇지만 Smalltalk Express와 Smalltalk-MT에서는 #( )안에 있는 모든 영문 자 낱말들을 이름값으로 처리해 버립니다. 즉 #(true false nil)이 #(#true #false #nil)과 똑같은 의미로 쓰이게 됩니다. 이를 알아보기 위해서 아래 글토막을 각각 Dolphin Smalltalk, Smalltalk Express, 그리고 Smalltalk-MT에서 펴보았습니다. <바탕글 1> 배열 성분의 갈래들을 알아보기 ---------------------------------------------------------- #(true false nil) do: [ :element | Transcript cr. element printOn: Transcript. Transcript nextPut: $ . element class printOn: Transcript. ]. [실행 결과] (Dolphin Smalltalk) true True false False nil UndefinedObject (Smalltalk-MT) #true Symbol #false Symbol #nil Symbol (Smalltalk Express) true Symbol false Symbol nil Symbol ---------------------------------------------------------- 위의 [실행 결과]에서 살펴볼 수 있듯이 Dolphin을 제외한 다른 Smalltalk 시스템에서는 #( )안에 들어 있는 영문자 낱말을 모두 이름값으로 간주합니 다. 어느 것이 더 직관적인지는 개인에 따라 다르겠으나, 제 생각에는 Dolphin Smalltalk의 처리방법이 좀 더 타당하지 않을까 생각합니다. 만약 여러분이 배열값을 이용하여 프로그램을 작성한다면 이러한 Smalltalk간의 사소한 차이를 제대로 간파하고 있어야 할 것입니다. ---------------------------------------------------------- 계속... 제 목:[강좌] Smalltalk 배우기 #20 관련자료:없음 [81] 보낸이:김찬홍 (안드래아) 1999-05-13 10:25 조회:139 Smalltalk 배우기 #19 1999. 5. 13. 김찬홍 mailto:andrea92@hitel.net ====================================== 2. 객체들과 나누는 이야기 2.1. 객체? 2.2. 몸으로 느끼기 2.3. 객체의 안쪽 2.3.1. 탐색기 사용하기 2.3.2. 객체의 성분 2.3.3. 글자와 글줄 2.3.4. 진리를 찾아서... b→2.3.5. 무른값, 굳은값, 그리고 바로값 ...... ======================================= 2. 객체들과 나누는 이야기 ------------------------------------ 2.3. 객체의 안쪽 ~~~~~~~~~~~~~~~~ 2.3.5. 무른값, 굳은값, 그리고 바로값 ------------------------------------ #19에서 계속... [4] 모듬 갈래의 씻줄 이번 마디에서 우리는 이름값(Symbol)과 배열(Array)이라는 두 갈래의 새로 운 객체를 알아보았습니다. 이름값이 성분을 바꿀 수 없는 굳은값(immutable object)인데 반해 배열은 성분을 마음대로 바꿀 수 있는 무른값(mutable object)이고, 더구나 성분으로 어떤 갈래의 객체이든 마음대로 담을 수 있는 유연함을 가지고 있습니다. 그럼 이 두 가지의 객체들에 대해서 조금 더 깊 이 생각해 보도록 합시다. 앞서 수(Number)에 대해서 이야기할 때, 우리는 #class와 #superclass라는 두 개의 지시를 사용해서 갈래의 씻줄을 더듬어 올라간 적이 있습니다. 마찬 가지로 여기서는 이름값과 배열의 갈래 씻줄을 더듬어 올라가 봅시다. 아래 의 글토막을 펴 봅시다. #hello class ☞ Symbol Symbol superclass ☞ String String superclass ☞ ArrayedCollection ArrayedCollection superclass ☞ SequenceableCollection SequenceableCollection superclass ☞ Collection Collection superclass ☞ Object 생각보다 이름값(symbol)의 갈래 씻줄이 길다는 것을 알 수 있습니다. 갈래 씻줄 중간에 걸친 갈래들은 모두 "2.16"에서 글줄을 이야기할 때 다루었습니 다. 어차피 이름값은 글줄의 아랫갈래이므로 결국 이름값은 글줄의 씻줄을 그대로 달고 올라가는 것입니다. 앞에서 살펴보았듯이 이름값은 결국 글줄이므로, 글줄이 할 수 있는 대부분 의 일을 할 수 있습니다. 이는 객체의 상속성(inheritance) 때문에 가능하게 되는 것인데, 상속성에 대해서는 나중에 따로 이야기할 기회가 있을 것입니 다. 아무튼 글줄이 어떤 지시를 알아듣는다면 이름값 역시 글줄의 한 종류이 므로 대부분의 지시를 알아듣고 처리할 수 있습니다. 그럼 이를 증명하기 위 해 지금부터 몇 개의 글토막을 펴 보도록 합시다. #hello = #hello ☞ true #hello = 'hello' ☞ false 먼저 첫 번째 글토막을 봅시다. "=" 왼쪽의 #hello와 오른쪽의 #hello는 어 디를 봐도 똑같은 객체입니다. 따라서 #hello는 #= 지시에 대해서 당연히 "참"이라고 응답합니다. 그런데 두 번째의 경우는 조금 생각을 해 보아야 합니다. #hello와 'hello' 는 똑같이 $h, $e, $l, $l, $o라는 다섯 개의 글자로 이루어진 객체이지만, 두 객체를 비교했을 때에는 "거짓"이라는 결과값이 나왔습니다. 즉 같은 글 자로 이루어진 성분이라도 글줄은 글줄이고 이름값은 이름값이라는 말입니 다. 그럼 몇 가지의 실험을 더 해 보도록 합시다. 아래 글토막들을 펴 보십시오. 'hello' = #hello ☞ false #hello = #bye ☞ false #hello , #bye ☞ 'hellobye' #hello at: 1 ☞ $h #hello copyFrom: 1 to: 4 ☞ 'hell' #hello size ☞ 5 위의 결과를 살펴보면 글줄(string)이 알아들을 수 있는 대부분의 지시를 이 름값도 알아듣는다는 것을 알 수 있습니다. 그러나 이름값과 글줄은 엄연히 다른 갈래의 객체이기 때문에, 반응하는 것 역시 똑같지는 않습니다. #at:이 나 #=, 그리고 #size 등의 지시는 글줄에서와 똑같이 반응하지만, 두 글줄을 합치는 #, 지시와 이름값에서 글줄 토막을 뽑아내는 #copyFrom:to 등의 지시 는 조금 다르게 반응했습니다. 즉, #, 지시와 #copyFrom:to의 경우 이름값에 보내진 지시의 결과로 이름값이 나오는 것이 아니라 글줄로 응답했습니다. 이제까지 이름값의 갈래씻줄을 더듬어 올라가서 여러 가지 지시를 내려보았 습니다. 그럼 배열의 갈래씻줄은 어떻게 얽혀있을까요? 그리고 배열은 어떤 지시를 알아들을 수 있을까요? 아래의 글토막을 펴 보십시오. #(1 2 3) class ☞ Array Array superclass ☞ ArrayedCollection ArrayedCollection superclass ☞ SequenceableCollection 배열의 윗갈래는 배열 모듬(arrayed collection)입니다. 그런데 재미난 것은 이름값과 글줄 역시 이 배열 모듬에 씻줄로 얽혀있다는 것입니다. 바로 위에 서 우리는 이름값의 갈래씻줄을 더듬어 올라갔고, 그 중간에 분명히 배열 모 듬(arrayed collection) 갈래가 있었습니다. 결국, 이름값, 글줄, 배열, 이 세 갈래의 객체들은 "배열 모듬"인 것입니다. <그림 2-20> 이름값, 글줄, 배열의 갈래씻줄 그림 (Stp2-20.gif) 그러면 이름값과 글줄에서 그랬듯이, 배열에도 우리가 자주 사용했던 #size, #=, #copyFrom:to 등의 지지를 사용할 수 있을까요? 자, 아래의 글토막을 펴 봅시다. #(2 #hello $+) = #(2 #hello $+) ☞ true #(2 #hello $+) = #(2 #hello $-) ☞ false #(2 #hello $+) = #(2 #hello) ☞ false #(2 #hello $+) , #(4 #bye $-) ☞ #(2 #hello $+ 4 #bye $- ) #(2 #hello $+) at: 1 ☞ 2 #(2 #hello $+) at: 2 ☞ #hello #(2 #hello $+) copyFrom: 1 to: 2 ☞ #(2 #hello ) #(2 #hello $+) size ☞ 3 신기하지 않습니까? 우리가 글줄과 이름값에 내렸던 지시를 배열도 고스란히 그대로 알아듣습니다. 물론 글줄과 이름값에서처럼 나타난 결과는 달랐지만, 배열에 보낸 지시의 의미를 정확히 이해하고 그대로 실행했습니다. 이것은 바로 글줄, 이름값, 그리고 배열이 "배열 모듬"(arrayed collection)의 아랫 갈래들이고, 결과적으로 우리가 사용했던 여러 지시들은 모두 아랫갈래들에 그대로 적용될 수 있음을 보여줍니다. 배열 모듬에 #at: 지시를 보내서 각각의 번호 붙은 성분의 값을 꺼낼 수 있 다면 반대로 번호 붙은 성분의 값을 바꿀 수 있는 길수가 있을까요? 네, 당 연히 있습니다. 바로 #at:put:이라는 길수입니다. 아래의 글토막을 펴 보십 시오. 'hello' at: 1 put: $j ☞ $j #(2 #hello $+) at: 3 put: $- ☞ $- 결과가 좀 이상하지요? #at:put: 길수는 자신이 방금 번호 붙은 성분에 집어 넣은 객체를 넘깁니다. 즉 지시를 받은 객체(receiver)를 넘기는 것이 아니 라 방금 번호 붙은 성분에 들어간 객체를 그대로 내놓습니다. 따라서 지시를 받은 객체가 실제로 변했는지를 알아볼 방법이 없습니다. 물론 그렇다고 전 혀 방법이 없는 것은 아닙니다. 아래 글토막을 펴 보십시오. 'hello' at: 1 put: $j; yourself ☞ 'jello' #(2 #hello $+) at: 3 put: $-; yourself ☞ #(2 #hello $- ) 위의 바탕글에서 처음 보는 ";"이라는 기호와 "yourself"라는 낱말이 있습니 다. 여기에 대해서는 나중에 다시 이야기할 기회가 있을 것입니다. 아무튼 #at:put: 지시를 보내면 해당 객체의 번호 붙은 성분에 새로운 값을 집어넣 을 수 있습니다. 그럼 다음과 같이 입력해 보십시오. #hello at: 1 put: $j ☞ (잘못) 어떻게 되었습니까? <그림 2-18>과 비슷하게 "should not implement"라는 알 림글과 함께 발자취 창이 나타났습니다. 꼭 객체 탐색기에서 이름값의 성분 을 바꿀 때와 똑같은 일이 일어난 것입니다. 역시 이름값은 배열 모듬이기는 하지만 굳은값이기 때문에 #at:put: 지시를 수행할 수 없었던 것입니다. [5] 바로값 지금까지 우리는 여러 갈래의 객체들을 조사해보았습니다. 각각의 객체는 저 마다 나름대로의 갈래에 속해있고, 또한 객체의 갈래에 따라서 겉모습도 달 랐습니다. 1, -235 등의 정수, 3.14 같은 소수, '우리 나라'와 같이 생긴 글 줄, $a처럼 생긴 글자.... 이들은 모두 한결같이 객체 자체가 가지는 값을 바로 나타낼 수 있습니다. 예컨대, "3"이라고 하면 바로 정수 객체 "3"을 나 타내는 것입니다. 이처럼 어떤 표현 방법을 사용해서 객체의 값을 바로 나타 낼 수 있는 객체를 "바로값"(literal)이라고 합니다. 어렵습니까? 간단히 생각합시다. "1". 이것은 하나의 객체입니다. 즉 "1"이라고 쓰는 것 만으로 바로 "객체"를 나타낼 수 있습니다. 이런 객체를 바로값이라고 부르 는 것입니다. 반면 어떤 방법을 사용해서 그 객체를 바로 나타낼 수 없는 경우, 그 객체를 "바로 아닌 값"(non-literal)이라고 합니다. 바로 아닌 값의 대표적인 예로 는 분수(fraction)가 있습니다. 분수는 어떤 방법을 사용해서 바로 나타낼 수 없습니다. 물론 (3/4)와 같이 쓰면 분수 "4분의 3"을 나타낼 수는 있지 만, 엄밀히 말해서 "(3/4)"는 정수 3과 4, 그리고 겹마디 길표인 #/이 모여 서 이루어진 글토막입니다. 이는 일터(workspace)에서 (3/4)를 펴 보면 알 수 있습니다. 3과 4는 보라색으로, '/'은 파란색으로 나타납니다. 즉 (3/4) 는 바로 아닌 값인 것입니다. 분수와 같이 간단하게 나타낼 수 있는 경우는 그래도 다행이라고 할 수 있습 니다. Smalltalk에 존재하는 객체들 중 대부분은 숫자나 글자 등을 이용해서 직접 나타낼 수 없는 "바로 아닌 값"들입니다. 필자가 뜬금없이 바로값과 바 로 아닌 값을 이야기하는 것은, 이것이 Smalltalk의 객체가 가지고 있는 또 하나의 성질이기 때문이고, 실제로 프로그램을 작성하다 보면 이와 같은 성 질에 영향을 받는 경우가 있기 때문입니다. 앞서 우리는 배열에 대해서 알아보았는데, 이 때 우리는 무심코 배열 바로값 (array literal)을 사용했습니다. 글줄 바로값을 만들 때 ' '을 사용한 것과 같이, 배열 바로값을 만들 때에도 #( ) 기호를 사용했습니다. 그런데 여기서 배열에 분수를 넣으려면 어떻게 할까요? #(1 2 3/4) ☞ #(1 2 3 #/ 4 ) #(1 2 (3/4)) ☞ #(1 2 #(3 #/ 4 ) ) 어떤 방법을 사용하든지 배열 바로값에 분수를 포함할 수는 없습니다. 왜냐 하면 분수는 바로값이 아니기 때문입니다. 즉 바로값을 나타내는데 바로 아 닌 값을 사용할 수는 없습니다. 물론 배열에 바로 아닌 값을 넣는 다른 방법이 있습니다. 그러나 여기서는 그것보다는 바로값과 바로 아닌 값이 있고, 상황에 따라서 이 성질이 중요하 게 여겨지는 경우가 있다는 것입니다. 보통 바로 아닌 값은 쉽게 글자나 숫 자로 나타내기 어렵기 때문에, 보통은 이런 객체에 꼬리표(variable)를 붙여 서 쉽게 나타내는 것이 일반적입니다. 꼬리표에 대해서는 바로 다음 마당에 서 이야기를 할 수 있을 것입니다. ---<잠깐!>---------------------------------------------------------- 다른 언어에서의 배열 흔히 많이 쓰이고 있는 C/C++이나 파스칼, 또는 베이식과 같은 언어들은 모 두 배열 바로값을 지원하지 않습니다. 이런 언어들은 기본적으로 "배열변수" 라고 해서 배열을 변수의 한 종류로 간주하고 있습니다. 그러나 Smalltalk를 비롯한 몇몇 언어들은 배열을 바로값을 이용해서 나타낼 수 있는 능력을 가 지고 있습니다. 물론 파스칼의 경우에 집합(set)을 바로값으로 나타낼 수 있 지만, 집합보다는 배열이 훨씬 유연하다고 할 수 있습니다. 또한 다른 언어에서의 배열변수는 한결같이 동일한 자료형의 모임이기 때문 에 Smalltalk보다 훨씬 제한적인 기능을 가지게 되어 있습니다. Smalltalk를 공부하다보면 유연한 배열이 얼마나 막강한 힘을 발휘하는지를 알 수 있을 것입니다. ---------------------------------------------------------- 지금까지 우리는 객체의 변화성에 따라 객체를 "굳은값"과 "무른값"으로 나 누어보았고, 객체 그 자체를 글자나 숫지 또는 기호 등을 이용해서 직접 나 타낼 수 있는가에 따라서 "바로값"과 "바로 아닌 값"으로 나누어 보았습니 다. 이제까지 우리는 Smalltalk에서 다루어지는 여러 가지 객체들의 성질을 알아보았습니다. Smalltalk는 객체지향 언어이기 때문에, 조금은 지루했을지 모르지만 객체들의 성질을 파악하는 것은 매우 중요한 작업이었습니다. 이제 다음부터는 보다 더 깊은 객체들의 세계를 탐험하게 될 것입니다. 그 전에 이번 마당에서 알아본 것들을 정리하는 것이 필요할 것이므로, 다음 가름에 서 다시 한 번 복습할 수 있는 기회를 만들어볼까 합니다. 계속... 제 목:[잡담] C/C++에서 포인터가 중요한 이유 관련자료:없음 [84] 보낸이:김찬홍 (안드래아) 1999-05-18 09:47 조회:456 + 찬미 예수님! 음, 여기 들어와 보니깐 포인터에 대해 이야기가 나오고 있는데요, 사실 포인터라고 하는 것은 프로그래밍 언어라면 정도의 차이는 있지만 모두 다 지원하는 걸로 알고 있습니다. 그것을 어떻게 부르느냐, 또한 문법적 으로 어떻게 나타내느냐가 다를 뿐이지요.(베이식에도 VarPtr(), Peek()함수, 그리고 Poke 명령을 사용하여 포인터를 구현하고 있습니다.) 그런데 C/C++을 애용하시는 분들은 한결같이 포인터를 매우 중요한 존재 로 생각하고, 포인터가 없이 프로그래밍을 한다는 것은 말도 안 되는 것 처럼 포인터에 대해 상당한 비중을 두고 계십니다. 물론 이는 맞는 말 씀입니다. C++, 특히 C의 경우는 포인터를 빼 놓으면 도저히 프로그래밍 을 하기 어렵게 되어 있습니다. 그런데 여러분들 중에는 C/C++에서 프인 터가 왜 그토록 중요한 위치를 차지해야만 하는지, 그리고 반드시 그래야 만 하는지에 대해서 의문을 제기하는 사람들은 드뭅니다. 실제로 Java나 Smalltalk과 같은 언어에서는 포인터가 아예 표면적으로 존재하지 않습니다. 그뿐만 아니라 Object Pascal의 경우도 포인터가 표 면적으로 등장하고는 있지만, Ada와 같이 포인터 연산에 심한 제한을 가 지고 있습니다. 만일 포인터의 사용이 그렇게 필수적인 것이었다면, 왜 이들 언어가 한결같이 포인터에 대해서 제제를 가했을까요? 제 생각부터 말씀드리면, 사람들이 흔히 생각하는 것처럼 포인터를 그렇 게까지 기를 쓰고 사용해야할 만큼 용도가 많지는 않으며, 극히 제한되어 야 하고, 또한 그러는 것이 시스템의 안전에도 도움이 된다는 것입니다. 그럼 여기서 C/C++이 왜 포인터를 쓸 수 밖에 없었는지를 생각해 봅시다. 1. 참조자(reference)의 부재 ~~~~~~~~~~~~~~~~~~~~~~~~~~ 처음 C언어가 발표되었을 때에는 참조자가 없었습니다. 이 참조자는 함수 나 절차를 호출할 때 인자의 전달 방법 중 "가리킴 전달"(call-by-reference) 기법을 구현하기 위하여 필요한 것입니다. 즉 하나의 객체(object, 여기서는 "대상물"이라고 번역해도 되겠습니다)에 둘 이상의 이름이 붙을 수 있다는 것을 조건으로 합니다. 즉 어떤 객체가 있을 때, 이 객체를 "A"라고 부를 수도 있고 "B"라고 부를 수도 있다는 것을 전재로 한 것이며, 이 경우 객체에 또 다른 이름을 부여하는 역할은 참조자(reference)가 맡는 것입니다. 즉 이렇게 하면 함수나 절차를 부른 쪽과 불린 쪽 모두 똑같은 객체에 접근할 수 있게 되고, 이것이 결국 "가 리킴 전달"인 것입니다. 물론 의미론 적으로 보면 이런 것이고, 이것을 구현할 때 주소를 사용하건 다른 방법을 사용하건, 그것은 언어 구현상의 문제인 것이지요. 파스칼의 경우는 일찍부터 참조에 의한 호출을 사용할 수 있었으며, C++의 경우도 하나의 객체에 다른 이름을 붙일 수 있는 참조자를 두어서 이를 해결하고 있습니다. 그러나 C의 경우는 참조자가 없기 때문에, 이미 있던 객체에 다른 이름으로 접근하기 위해서는 결과적으로 포인터를 사용 할 수 밖에 없는 것입니다. C++이 참조자를 지원하기는 하지만, 오히려 포인터를 사용해서 구현되는 방식과 혼용해서 쓰게 되면 문맥상의 혼란만 더 가중시키게 됩니다. 또한 이미 C언어를 기반으로 구축되었던 라이브러 리 함수에서는 한결같이 포인터를 사용하여 가리킴 전달을 구현하였기 때 문에, 오히려 참조자를 사용하여 가리킴 전달을 하게 되면 함수의 사용자 들은 참조자를 쓸 때와 포인터를 쓸 때를 분간하기 어렵게 되고, 차라리 예전 그대로 포인터를 사용한 가리킴 전달의 구현을 더 편하게 생각하는 풍토가 생긴 것입니다. 그러므로 C++의 참조자는 포인터 사용을 줄이기는 커녕, 오히려 혼란만 가중시켰다는 것이 필자의 생각입니다. 포인터, 그것이 C언어가 선택한 것이고, 이것이 모든 제앙의 시작이 되었 던 것입니다. 2. 배열을 인자로 전달할 수 없는 문제 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C/C++에서 포인터를 사용할 때 몇 가지 변환 규칙이 있습니다. 그 중에 "배열 변수의 이름은 그 배열의 첫 번째 원소를 가리키는 포인터이다"(임 인건, 1991)라는 법칙이 그것입니다. 이 말은 결국 함수나 절차에 배열을 인자로 넘겨줄 수 없다는 말입니다. 실제로 C/C++에서 배열 변수를 인자 로 받을 수 없기 때문에, 이를 포인터로 받고, 따라서 배열의 크기를 알 수 없으므로 따로 크기를 명시해 두거나 자료 자체에 꼬리표(null-terminator 등)를 두어 처리하는 방식을 체택하고 있습니다. 파스칼이나 Smalltalk, Ada 등 배부분의 언어에서는 배열을 인자로 사용 할 수 있으며, 따라서 포인터 연산이라는 것이 필요치 않습니다. 배열이 인자로 전달될 때에는 엄연한 하나의 자료형이고, 따라서 배열의 위치 뿐 만 아니라 배열의 크기 및 기타 다른 속성들도 함께 전달받을 수 있도록 되어 있습니다. 특히 Object Pascal이나 Ada에 도입된 "열린 배열"은 배 열 변수의 원소수에 대한 제한을 없애주어, 결과적으로 C/C++에서보다 더 유연하면서도 안전하게 배열을 처리할 수 있도록 하고 있습니다. Smalltalk의 경우 배열은 어떤 자료형(갈래)를 가진 객체라도 다 가질 수 있으므로 일찍부터 열린 배열을 사용하고 있다고 해도 과언이 아닐 것입 니다. 아무튼 배열 변수를 절차나 함수에 인자로 사용할 수 없다는 것은 큰 제 한이며, 따라서 배열의 경계성 검사와 같은 시스템 안전에 직결된 결함을 안게 된 원인이 여기에 있는 것입니다. 3. 배열 원소수의 접근은 곧 포인터 연산이다. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ C/C++에서 배열 변수를 함수나 절차에 넘겨줄 수 없다보니, 그리고 원래 C를 고안한 K&R의 경우 당시의 요구 사항에 따라서 고급언어이면서도 저 급언어의 기능을 유치하기 위해서 모든 배열 연산을 포인터 연산으로 처 리하도록 했습니다. 이 말은 만약 배열의 크기보다 큰 이은 번호를 부여 하더라도, 아무런 경고나 잘못 없이 번역 및 실행이 됨을 말합니다. 결과 적으로 이것은 프로그램에 벌레가 살고 있게 될 소지를 다분히 안고 있었 으며, 이를 검사하기 위해서 "BoundsChecker" 등의 디버깅 보조 도구가 필요하게 되었습니다. C언어가 나올 당시에는 언어 명세와 언어 구현이 따로 생각되지 않고 함 께 다루어졌습니다. 그러므로 어떻게 하면 효율적인 코드를 만들어 낼까 하는 것이 언어 명세에 영향을 주게 된 것입니다. 결국 배열의 경계값 검 사 기능 역시 이것이 프로그램 전체의 속도를 떨어뜨릴 수 있기 때문에 C언어에서 배제된 것인데, 오늘날의 대부분의 번역기들은 번역기 지시어 를 통해서 사용자가 선택적으로 배열 경계값을 검사할 수 있도록 지정해 놓고 있습니다. 또한 최적화 기술의 발달로, Object Pascal 번역기의 경 우 배열 변수의 연산을 자동으로 포인터 연산으로 바꾸어 주고 있습니다. 물론 이 경우 C/C++처럼 배열과 포인터의 연산을 문법적으로 동일하게 만 들어 놓지 않고 포인터 연산과 배열 연산이 문법적으로 엄연히 구분이 되기 때문에 혼란이 없는 것입니다. 아무튼 언어 명세와 이를 구현하는 것이 밀접한 관계를 가졌던 70년대에 C언어의 선택은 합당했을지 몰라도, 현재와 같이 프로그램이 대형화되고 복잡해지는 경우 배열 경계값의 검사 미비로 인해 발생되는 문제와, 이를 교정하기 위해서 출시되는 여러 가지 프로그램들을 보면, C언어에서 포인 터 남용으로 인한 폐해를 쉽게 찾아볼 수 있을 것입니다. 명세가 정형화 되어있다고해서 구현 역시 정형화될 필요는 없 지요. a[3]은 a[3]이지 만, 이를 *(a+3)으로 고치는 일은 번역기가 맡아야 합니다. 사용자가 일 일이 *(a+3)과 a[3]을 혼용해서 사용하게 된다면, C언어와 같은 문법 혼 란은 피할 수 없는 것이겠지요. 4. 단순 객체 모형의 폐해 ~~~~~~~~~~~~~~~~~~~~~~~ C에서 포인터와 배열을 마구 뒤섞어 놓음으로써 한 번의 큰 홍역을 치렀 는데, C++에서는 설상 가상으로 "단순 객체 모델"을 도입함으로써 그 심 각성을 배가시켰다고 말하면, 필자가 지나칠까요? C++는 어찌됐건 기존 C언어에 객체지향 프로그래밍의 패러다임을 적용시 키기 위해서 C에서 문법적으로 규정된 사항을 대부분 그대로 받아들였습 니다. 그러다보니 포인터와 배열의 모호한 관게에다 참조자의 도입으로 인한 또 한번의 혼란은 결국 C++언어의 문법을 헌법처럼 만들어 버린 셈 입니다. 그런데 여기에 더하여, 객체 지향 프로그래밍에서의 핵심적인 표 현 방법인 "객체의 표현 방법"에서 C++는 또 한번의 실수를 거듭하게 되 었는데, 그것이 바로 "단순 객체 모형"이라는 것입니다. 단순히 겉으로 드러난 것을 보면 분명히 "단순 객체 모형"이 "객체 참조 모형"보다는 __단순해__ 보입니다. 그러나 이 "단순"이라는 낱말 때문에 결국은 포인터를 사용하지 않고는 객체를 제대로 표현하지 못하는 지경에 이르고 있습니다. 제가 여태껏 접해본 객체지향 언어로는 C++, Java, Smalltalk, 그리고 Object Pascal이 있었습니다. Objective-C의 경우는 C 언어에서 특정 부 분을 Smalltalk의 문법을 빌어서 처리하기 때문에, 일단은 Smalltalk의 문법 형식과 돌일하다고 생각하면 됩니다. 그런데 이들 언어에서 C++만 제외하고는 객체를 표현하는데 있어서 한결 같이 객체 참조 모델을 사용하고 있습니다. 즉 변수(variable)가 어떤 값 을 저장하는 "창고"의 개념이 아니라, 어떤 객체에게 이름을 붙여주는 꼬 리표(tag)의 역할을 한다는 것입니다. 즉, 이는 묵시적으로 퍼인터의 개 념을 도입했다고 생각하면 됩니다. 그러나 C++의 경우는 단순 객체 모형 을 사용합니다. 즉 어떤 갈래(class)를 만들어 놓고, 그 갈래를 자료형으 로 하는 변수를 만들게 되면, 해당 갈래만큼의 크기를 가진 변수가 만들 어지게 됩니다. 이럴 경우 객체는 정적 모형으로 생성 및 파괴되고, 따라 서 가상함수를 이용한 다형성을 구현하지 못하게 됩니다. 결과적으로 가 상 함수나 기타의 객체지향적 요소의 이득을 얻기 위해서는 포인터를 쓰 지 않을 수 없게 되는 것입니다. Delphi에서 작성된 프로그램을 동일하게 C++Builder에서 작성해 보면 이 를 확연히 알 수 있습니다. 객체 참조 모형을 사용하는 Object Pascal의 경우는 바탕글을 읽는 것 만으로도 그 의미를 쉽게 파악할 수 있지만, C++Builder에서 생성한 바탕글의 경우는 객체를 참조할 때 일일이 포인터 를 사용해야 하므로 여간 불편한 것이 아닙니다. 물론 포인터를 쓰기 좋 아하는 사용자들이라면 별 어려움이 없겠지만, 바탕글을 유지하고 관리하 는 측면에서 볼 때, 그리고 기독성을 생각하면 단순 객체 모형보다는 확 실히 객체 참조 모델이 더 편리합니다. Java나 Smalltalk에서도 마찬가지입니다. 이들 언어에서의 변수는 해당 객체 자체가 저장되는 창고가 아니라, 해당 객체에 붙은 꼬리표인 것입니 다. 따라서 해당 변수는 묵시적인 포인터로 처리되고 있는 것이며, 가상 함수나 모듬(collection) 등과 같이 객체지향적인 요소를 아무런 제한 없이 그대로 나타낼 수 있는 것입니다. Set *aSet = new Set; aSet->add(3); aSet->add(4); aSet->add(5); cout << *aSet; delete aSet; Set aSet = new Set(); aSet.add(3); aSet.add(4); aSet.add(5); var ASet: TSet; begin ASet := TSet.Create; with ASet do Add(3); Add(4); Add(5); end; ASet.Free; end; | aSet | aSet := Set new. aSet add: 3; add: 4; add: 5; 위에서 보면 분명히 객체 참조 모델을 사용하는 것이 단순 객체 모델을 사용하는 것보다 바탕글을 쉽게 알아볼 수 있음을 알 수 있습니다. C++의 경우는 늘 객체를 참조하때 이것이 포인터인지 일반 변수인지를 생각해야 하고, 함수에 인자로 객체를 넘길 경우 역시 포인터인지의 여부를 늘 프 로그래머가 신경을 써 주어야 합니다. 여러모로 객체 참조 모형이 단순 객체 모형보다 훨씬 편리하다고 필자는 생각합니다. 결론적으로 말하자면, C/C++언어에서의 포인터는 편리하기는 하지만 오용 및 남용의 경우에는 무시할 수 없는 문제가 생기며, 따라서 비교정 안전 성을 추구하는 Ada나 기타 다른 언어에서는 포인터에 많은 제한을 가하고 있습니다. 물론 포인터가 나쁘다고만은 할 수 없지만, 무분별한 포인터의 사용은 좀 자제해야 할 것입니다. 특히 Object Pascal의 경우에는 C/C++ 수준과 거의 비슷하게 포인터 연산이 가능하지만, 포인터를 사용하지 않 고도 충분히 문제를 해결할 수 있다면, 굳이 포인터를 쓰지 않는 것이 좋 을 것입니다. 포인터 만능론을 주장하는 사람들은 Java나 Smalltalk에 왜 명시적인 포 인터 개념을 넣어놓지 않았는지를 생각해 봅시다. 흡사 이전 BASIC의 GO TO 논쟁처럼, 결국은 GO TO를 쓰지 않고도 프로그래밍이 가능하다는 것을 인정하기에는 꽤나 많은 시간이 걸렸지만, Smalltalk나 Forth처럼 아예 GOTO가 없는 경우도 있으므로, 포인터의 사용에 대해서도 신중을 기해야 할 것입니다. 제 목:[강좌] Smalltalk 배우기 #21 관련자료:없음 [85] 보낸이:김찬홍 (안드래아) 1999-05-20 20:44 조회:147 Smalltalk 배우기 #21 1999. 5. 21. 김찬홍 mailto:andrea92@hitel.net ====================================== 2. 객체들과 나누는 이야기 2.1. 객체? 2.2. 몸으로 느끼기 2.3. 객체의 안쪽 2.4. 정리 및 연습 문제 2.4.1. 요약 2.4.2. 알아두면 좋은 것들 2.4.3. 연습 문제 ======================================= 2. 객체들과 나누는 이야기 ------------------------------------ 2.4. 정리 및 연습 문제 ~~~~~~~~~~~~~~~~~~~~~~ 이 마당에서 우리들은 Smalltalk에 대한 아주 기본적인 것들을 알아보았습니 다. 어찌보면 지루했을지도 모르겠지만, Smalltalk가 가지고 있는 특성들을 제대로 파악해야만 앞으로 공부할 객체지향 프로그래밍의 개념을 쉽게 받아 들일 수 있을 것입니다. 필자는 C++언어를 공부했기 때문에 감히 단언합니 다. 지금까지 우리가 알아본 것들은 결코 C++ 언어의 문법보다 어렵지 않습 니다. 놀라실지도 모르지만, 지금까지 우리는 Smalltalk의 문법 중에 70%를 공부한 것이나 다름이 없습니다. 그만큼 Smalltalk의 문법은 단순합니다. 그 러므로 지나치게 문법에만 의존하지 말고, Smalltalk의 살아 있는 객체들이 움직이는 모습을 지켜보면서, 객체지향 프로그래밍의 개념에 익숙해지시기 바랍니다. 2.4.1. 요약 ----------- 이제 이 마당에서 공부한 것을 간단히 요약해 보도록 합시다. 앞서 공부한 것을 되새기면서 한 줄 한 줄 읽어보면 도움이 될 것입니다. * Smalltalk 글토막의 겉 모습(문법)과 그 의미 * 지시를 이루는 요소: 지시(message), 받는이(receiver), 길표(selector), 인자(parameter) * 서로 다른 지시의 종류: 외마디(unary) 지시, 겹마디(binary) 지시, 쇠마 디(keywored) 지시 * 둘 이상의 길표가 있는 글토막의 가늠 순서. 우선권 규칙. * 갈래(class)와 실체(instance)의 차이 * 실체와 그 실체를 이루는 구성 요소(부분) * 객체 탐색기를 사용하여 객체 안쪽 들여다 보기 * 정수, 소수, 분수, 글자, 글줄, 이름값, 배열, 논리값, 헛 등이 알아들을 수 있는 지시들. * 각종 객체의 속 구조(개체의 성분) * 굳은값과 무른값의 다른 점. * Smalltalk 글토막의 입력, 수정, 편집 및 실행방법들. 2.4.2. 알아두면 좋은 것들 ------------------------- [1] Object 갈래에 딸린 객체들이 알아듣는 지시들 anObject class anObject가 속한 갈래를 넘긴다. anObject isKindOf: aClass anObject가 속한 갈래가 aClass의 갈래 씻줄에 얽혀있는지 조사하 여, 얽혀있으면 참을, 그렇지 않으면 거짓을 넘긴다. anObject isNil anObject가 헛(nil)값이면 참을, 그렇지 않으면 거짓을 넘긴다. anObject notNil 위의 경우와 반대이다. anObject inspect anObject 객체를 구성하는 성분들을 탐색한다. [2] 갈래(class)가 알아듣는 지시 aClass superclass aClass 갈래의 윗갈래를 넘긴다. [3] 수(Number) 객체가 알아듣는 지시 aNumber1 + aNumber2 덧셈 aNumber1 - aNumber2 뺄셈 aNumber1 * aNumber2 곱셈 aNumber1 / aNumber2 나눗셈 aNumber1 // aNumber2 정수 나눗셈의 몫을 구한다. aNumber1 \\ aNumber2 정수 나눗셈의 나머지를 구한다. aNumber negated aNumber의 부호를 바꾼다. aNumber numerator aNumber의 분자를 구한다. aNumber denominator aNumber의 분모를 구한다. aNumber reciprocal aNumber의 역수를 구한다. aNumber between: a to: b aNumber 숫자가 a와 b사이에 있으면 참을, 그렇지 않으면 거짓을 넘긴다. [4] 정수가 알아들을 수 있는 지시 anInteger factorial anInteger 정수의 계승(x!)을 구한다. anInteger asCharacter anInteger를 글자 번호로 하는 글자를 넘긴다. anInteger asFloat anInteger 정수를 소수(floating-point number)로 바꾼다. [5] 소수(float)가 알아들을 수 있는 지시 aFloat rounded 소수 aFloat을 반올림한다. aFloat truncated 소수 aFloat의 소수점 이하를 잘라버린다. [6] 논리값(Boolean)이 알아들을 수 있는 지시 aBoolean | aBoolean 두 논리값 중에 어느 하나라도 참이면 참을 넘긴다. aBoolean & aBoolean 두 논리값이 모두 참일 때 참을, 그렇지 않으면 거짓을 넘긴다. aBoolean not aBoolean이 참이면 거짓을, 거짓이면 참을 넘긴다. aBoolean and: [aBlock] aBoolean이 참이면 aBlock을 실행하고, aBlock의 값이 참인 경우에 는 참을, 그렇지 않으면 거짓을 넘긴다. 만약 aBoolean의 값이 거짓 이면 aBlock이 실행되지 않고 거짓을 넘긴다.(#&의 짧은 경로 계산) aBoolean or: [aBlock] aBoolean이 거짓이면 aBlock을 실행하고, aBlock의 값이 거짓인 경 우에는 거짓을, 그렇지 않으면 참을 넘긴다. 만일 aBoolean의 값이 참이면 aBlock이 실행되지 않고 참을 넘긴다.(#|의 짧은 경로 계산) [7] 글줄, 이름값, 배열이 알아듣는 지시 container size 해당 객체(container)가 몇 개의 원소로 되어 있는지를 구한다. container , anotherContainer 두 객체를 합한다. container at: anInteger container 객체의 anInteger 번째의 원소를 꺼낸다. container at: anInteger put: anObject container 객체의 anInteger 번째 성분에 anObject 객체를 넣는다. container copyFrom: a to: b container 객체의 번호붙은 성분 중 a에서 b까지의 부분 원소를 뽑 아낸다. [8] 글줄이 알아들을 수 있는 지시 aCharacter isUppercase 글자가 대문자이면 참을 넘긴다. aCharacter isLowercase 글자가 소문자이면 참을 넘긴다. aCharacter isLetter 글자가 영문자이면 참을 넘긴다. aCharacter isDigit 글자가 숫자(0-9)이면 참을 넘긴다. aCharacter isVowel 글자가 모음(a,e,I,o,u)이면 참을 넘긴다. aCharacter asciiValue 글자가 가진 글자 번호를 넘긴다. [9] 우선 순위 규칙 하나의 글토막에 여러 종류의 지시가 섞여 있을 경우는 왼쪽으로부터 오른쪽 으로 가늠되며, 다음의 순서를 가지고 가늠됩니다. * 외마디 지시 * 겹마디 지시 * 쇠마디 지시 [10] Smalltalk에서의 풀이글 풀이글은 " "안에 쓰고, Smalltalk는 내용을 무시한다. 2.4.3. 연습 문제 ---------------- [1] 일터에 자유로게 글을 입력한 다음 "Test.st"라는 파일에 저장하고 일터 를 닫은 뒤에, 새로운 일터를 열고 방금 저장했던 파일을 열어 봅시다. [2] Smalltalk에는 날짜를 나타내는 "Date"갈래가 있습니다. 이 Date 갈래의 씻줄을 더듬어 봅시다. 그리고 Date today 와 같은 문장으로, 즉 Date 갈래에 #today 지시를 보내면 오늘 날짜가 담긴 객체를 얻어낼 수 있습니다. 이 객체들이 비교될 수 있는지 알아보 고, 마지막으로 글줄과 날짜 객체 역시 서로 같은지 다른지를 비교해 봅 시다. [3] 작은 정수(SmallInteger) 중에서 제일 큰 값은 얼마일까요? [4] 풀이글에 큰 따옴표(")를 사용하려면 어떻게 해야 할까요? [5] 어떤 수를 0으로 나눌 수 있을까요? Smalltalk에서 직접 실행해 봅시다. 만약 0으로 나눌 수 없다면 Smalltalk는 어떤 알림글을 뿌려줍니까? [6] 큰 정수(LargeInteger)를 탐색해 봅시다. 이 객체가 핫객체인지 홀객체 인지를 알아보고, 만약 핫객체라면 번호 붙은 성분을 가졌는지, 이름 붙 은 성분을 가졌는지 조사해 봅시다. [7] 아래 진리표를 완성해 보십시오. & 참 거짓 -------------------------------- 참 거짓 -------------------------------- | 참 참 -------------------------------- 참 거짓 -------------------------------- =========================================================== 이제 두 번째 마당이 끝났습니다. 여기까지 온 여러분은 이제 Smalltalk가 어떻게 객체를 처리하고, 또한 객체에게 어떻게 지시를 보내며, 또한 객체가 응답하는 것을 어떻게 처리할 수 있는지에 대해서 공부했습니다. 그리고 또 한 Smalltalk에는 많은 종류의 객체가 존재한다는 것도 알 수 있었습니다. 결국 Smalltalk는 이러한 객체들의 모임으로 이루어진 시스템이기에, Smalltalk를 이해하려면 먼저 이러한 객체들의 특성을 파악하는 것이 중요하 다는 말은 여러 번 했습니다. Smalltalk의 모든 객체는 살아있으며, 자신이 어떤 일을 해야할지도 알고 있다는 말은, 이제는 지겨울 때도 되었을 만큼 많이 언급한 것입니다. 두 번째 마당까지 오게 된 여러분은 이제 Smalltalk의 기본적인 환경인 일터 (workspace)와 객체 탐색기(object inspector)에 대해서 공부했습니다. 이 두 가지의 도구는 앞으로 여러분이 Smalltalk의 객체를 다룰 때 늘 옆에 두 고 있어야 하는 친구일 것입니다. 이제 다음 마당에서는 여러분들에게 보다 재미있고 또한 유용한 객체들에 대 해서 알아보려고 합니다. 또한 객체에 이름을 붙여놓고 그 이름을 통해서 객 체를 여러 가지 방법으로 제어할 수 있는 방법도 알아볼 것입니다. 지금까지 의 마당이 주로 단순한 글자와 글줄, 그리고 숫자 정도만 다루어본 것에 비 해 이제 다음 마당부터는 좀 더 복잡하면서도 재미있는 객체들에 대해서도 알아볼 것입니다. 이로써 여러분은 서서히 객체지향 패러다임을 몸으로 느껴 보게 될 것입니다. 기대하셔도 좋습니다. :) 계속... 제 목:[답변] 객체지향 언어의 자격...? 관련자료:없음 [89] 보낸이:김찬홍 (안드래아) 1999-05-26 05:15 조회:440 + 찬미 예수님! 안녕하세요? 음, 객체지향 언어라면, 일단 객체지향 패러다임을 제대로 지원해야 할 줄 로 압니다. 사람들마다 생각하는 것이 조금씩 다르겠지만, 일단 제가 공부 했었고, 또한 느낀 것을 바탕으로 아래의 조건들이 만족되어야 한다고 생각 합니다. - 포장성(encapsulation) - 다형성(polymorphism) - 상속성(inheritance) 졸면서 쓰는 것이라서 철자가 제대로 맞는지... 우선 포장성부터. 이것은 하나의 객체에 그 상태를 나타내는 자료와 객체의 행동을 규정하는 길수(method)를 함께 포장해 넣을 수 있느냐 하는 문제입 니다. 보통은 객체의 모형인 갈래(class)를 만들어 놓고, 이 갈래에 길수와 성분(member)들을 규정해서 이 규정 대로 객체를 생성해 냅니다. 이 때 객 체의 외부에서 함부로 객체의 성분을 바꿀 수 없도록 하는 것이 포장성인 데, 대부분의 언어에서는 가무림(private), 터놓음(public), 보호됨 (protected) 등의 접근권을 제한하는 방식으로 포장성을 구현합니다. 물론 다 그런건 아니고 Smalltalk와 같은 경우는 모든 성분들은 가무려지고, 반 대로 모든 길수들은 드러내 놓는 방식을 취하기도 합니다. 어쨌건 포장성이 란 객체를 조작할 때 객체를 만든 사람이 마련해 놓은 규칙(이를 interface 또는 protocol이라 하지요)을 통해서만 접근할 수 있다는 것이 중요합니다. TV의 속을 마음대로 만져서 조작하느 게 아니라 지정된 스위치를 눌러서 조 작하는거랑 같다고 보면 됩니다. 다음은 다형성. 이는 어떤 지시(message)를 서로 다른 객체에게 보냈을 때, 그 지시를 받은 객체(receiver)의 갈래에 따라 서로 다르게 반응하는 성질 을 말합니다. 동적 결합(dynamic binding), 길수의 중복 정의 (overloading), 다중 뽑아내기(dispatching) 등이 다형성을 구현하기 위한 몇 가지의 방법으로 사용됩니다. 상속성. 이는 어떤 갈래의 특성을 그대로 물려받아서 새로운 갈래를 지을 수 있다는 말입니다. 이를태면 "사람"이라고하는 갈래에 들어 있는 성분과 길수를 그대로 물려받아서 새롭게 "학생", "교수" 등의 갈래를 만들어 내는 것입니다. 아마 JavaScript는 포장성과 상속성을 지원하지 않는다고 알고있습니다. 이 를태면 사용자가 마음대로 갈래를 지어서 객체를 만들어내지 못한다고 알고 있습니다. 따라서 상속성도 지원받지 못한다고 하고요. Visual Basic을 객 체지향 언어라고 보기 어려운 것은 바탕글(source) 수준의 상속성을 지원하 지 않고 있기 때문이라고 합니다. 뭐, 이에 대해 이의를 제기사힐 분이 있 으실 테지만요... 제가 혹 잘못 알고 있는 것이 있다면 바로잡아 주십시오. 그럼. 제 목:[강좌] Smalltalk 배우기 #22 관련자료:없음 [93] 보낸이:김찬홍 (안드래아) 1999-07-14 16:31 조회:128 Smalltalk 배우기 #22 1999. 7. 14. 김찬홍 mailto:andrea92@hitel.net ====================================== 3. 객체로 채워진 세상 3.1. 알아보자, 알림판! a→ 3.1.1. 알림판 객체 - Transcript 3.1.2. 알림판이 알아듣는 지시 ..... ======================================= 3. 객체로 채워진 세상 --------------------------- 앞의 마당에서 여러분은 Smalltalk의 객체에 대해서 아주 기본적인 것들을 공부했습니다. 우선 객체란 무엇인지, 그리고 이런 객체에게 어떻게 명령을 내리는지, 또한 객체가 우리의 지시를 실행하고 나서 만들어진 결과를 어떻 게 처리하는지에 대해서도 알아보았습니다. 또한 Smalltalk에서 프로그래밍 을 할 때 언제나 중요한 역할을 하고 있는 일터(workspace)와 객체 탐색기 (object inspector)에 대해서도 알아보았습니다. 이를 바탕으로 이제 이번 마당에서 여러분은 보다 복잡하면서도 재미있고, 또한 프로그래밍에 유용한 여러 가지 객체들에 대해서 공부하게 될 것입니 다. 앞의 마당에서 다루었던 객체들이 주로 숫자, 글줄, 글자 등과 같이 단 순한 객체들인데 비해, 이번 마당부터는 알림판(transcript)이나 글줄 입력 상자처럼 눈에 보이고 실제적으로 유용한 기능을 수행하는 객체에 대해서 알 아볼 것입니다. 또한 몇 개의 그림 객체에 대해서도 알아볼 것입니다. 이 마당을 공부하는 중에 여러분은 Smalltalk에서 매우 중요한 문법 몇 가지 를 공부하게 될 것입니다. 물론 이러한 문법 사항들이 C/C++처럼 복잡하고 방대한 것은 아닙니다. 그냥 보기로 제시되는 글토막들을 가늠하다보면 충분 히 이해할 수 있을 것입니다. 어찌 보면 멀기도 먼 과정이겠지만, 한 걸음씩 진행하다보면 어느덧 셋째 마당의 끝에 다다랐을 것입니다. 힘을 냅시다. 그럼 먼저 Smalltalk 환경의 알림 창구라고 할 수 있는 "알림판"에서부터 시 작합시다. 3.1. 알아보자, 알림판! ~~~~~~~~~~~~~~~~~~~~~ 지금 Smalltalk를 실행하지 않은 사람들은 Dolphin Smalltalk를 실행시켜 봅 시다. 그러면 몇 개의 창이 눈에 보일 것입니다. 지금까지 우리가 여러 가지 글토막을 가늠했던 일터(workspace)와 함께 "알림판"(transcript)라고 하는 창이 눈에 들어올 것입니다. 겉으로 봐서는 알림판은 일터와 크게 달라 보이 지 않습니다. <그림 3-1> 일터와 알림판 (Stp3-1.gif) 사실 알림판에서도 똑같이 Smalltalk의 글토막을 넣을 수 있고, 넣은 글토막 을 가늠하고 펴보고 탐색할 수 있습니다. 즉 일터에서 제공하는 기본적인 글 토막 가늠 기능을 그대로 제공하는 것입니다. 그러면 도대체 왜 "알림판"이 Smalltalk 환경에 존재해야 하는 것일까요? 이 알림판은 Smalltalk환경이 사용자에게 알려야 할 사항이 있으면 그것을 정리하여 출력해 주는 중요한 곳입니다. 이를테면 Smalltalk로 작업하는 도 중에 기억공간이 모자란다거나, 갈래나 길수, 또는 기타 여러 가지 객체들이 들어있는 꾸러미(package)를 읽어들였다던가 하는 정보가 모두 이 알림판에 나타납니다. 그러므로 사용자는 늘 알림판을 주시하고, 여기에 기록된 사항 들이 있으면 제대로 살피고 넘어가는 습관을 기르는 것이 좋습니다. 알림판이 이렇게 Smalltalk환경과 밀접한 관계를 가지고 있기 때문에, 보통 우리들이 프로그래밍을 하거나 작업을 할 때에는 일터에서 하는 것이 좋습니 다. 관례적으로 알림판에서는 Smalltalk 환경에 전체적으로 영향을 줄 수 있 는 글토막을 기록하고 가늠하는 것이 좋습니다. 그런데 이 알림판은 Smalltalk 시스템만 사용할 수 있는 것은 아닙니다. 바 로 여러분들이 이 알림판에 직접 글을 쓸 수 있습니다. 물론 글쇠판을 이용 해서 쓰는 것이 아니라, 알림판이 알아들을 수 있는 지시를 통하여 글을 쓰 는 것입니다. 이제 알림판에 글을 쓰기 위하여, 도대체 알림판이 어떤 지시 를 알아들을 수 있는지 살펴봅시다. Smalltalk의 모든 것은 객체입니다! 3.1.1. 알림판 객체 - Transcript ------------------------------- 객체에게 지시를 보내기 위해서는 그 객체를 불러야 합니다. 이를테면 "3 + 4"라고 하는 지시를 내려야 할 때에는 "3"이라는 객체를 불러야 하고, 10의 계승을 구하기 위해서는 "10"을 명시해 주어야 합니다. 3 + 4 ☞ 7 10 factorial ☞ 3628800 마찬가지로 알림판에 어떤 지시를 내리기 위해서는 우선 알림판 객체를 글토 막에 명시해야 합니다. Smalltalk에서 알림판은 "Transcript"라고 부릅니다. 우리가 정수 갈래를 Integer라고 불렀고, 글줄 갈래를 String이라고 부른 것처럼, 알림판 역시 Transcript라고 부르면 되는 것입니다. 아래와 같이 일터에 Transcript라고 쓴 후 이 글토막을 펴 봅시다. (Smalltalk에서 낱말을 쓸 때 대문자와 소문자를 가려야 한다는 것은 앞에서 말한 바 있습니다.) Transcript ☞ a TranscriptShell 위와 같이 "Transcript", 곧 알림판을 펴 보면 "a TranscriptShell"이라는 결과를 얻을 수 있습니다. 알림판의 껍데기(transcript shell)라는 조금은 묘한 결과가 나왔습니다. 아무튼 여기서 중요한 것은 Transcript 역시 Smalltalk에서 하나의 객체라는 것입니다. 그럼 이번에는 "Transcript"를 탐색해 봅시다. 그러면 아래 <그림 3-2>와 같 은 화면을 볼 수 있을 것입니다. <그림 3-2> "a TranscriptShell"을 탐색하는 모습(Stp3-2.gif) 보시다시피 Transcript는 여러 개의 성분을 가지고 있는 핫객체입니다. 물론 여러분 중에 Transcript를 구성하고 있는 성분의 의미를 아직까지 제대로 이 해하는 분이 드물겠지만, 아무튼 알림판에 지시를 내리기 위해서는 Transcript를 사용해야 한다는 것만 기억해 두면 되겠습니다. 3.1.2. 알림판이 알아듣는 지시 ----------------------------- 알림판(Transcript) 역시 Smalltalk에서 하나의 객체입니다. 따라서 알림판 에 글씨를 쓰기 위해서는 도대체 이 알림판이 어떤 지시를 알아들을 수 있는 지를 먼저 살펴보아야 합니다. 알림판이 알고 있는 길수들은 아래의 네 가지 입니다. Transcript nextPut: aCharacter aCharacter 글자를 알림판에 써 낸다. Transcript nextPutAll: aString aString 글줄을 알림판에 써 낸다. Tanscript space 알림판에 빈 칸 한 개를 써 낸다. Transcript cr 알림판에서 줄을 바꾼다. 우선 알림판에 지시를 내리기 전에 깨끗한 새 일터를 만듭시다. "File > New" 메뉴를 선택하면 새 일터가 열릴 것입니다. 새로운 마당을 시작할 때 우선 새 일터를 열어놓고 시작하는 것이 좋습니다. 그런 다음 방금 연 일터 와 알림판을 <그림 3-1>처럼 동시에 볼 수 있도록 위치를 맞춥시다. 이렇게 하면 일터에서 내린 지시가 바로 알림판에 전달되어 반응하는 것을 볼 수 있 습니다. 그런 다음 알림판에 있는 모든 내용을 깨끗이 지웁시다. 이제 일터에서 다음 글토막을 입력해 봅시다. Transcript nextPutAll: '안녕하세요?'. Transcript nextPutAll: '저는 지금 알림판에 글을 씁니다.'. 위의 글토막은 두 개의 Smalltalk 명령이 들어 있습니다. 따라서 위의 글토 막을 가늠하는 방법도 두 가지입니다. 먼저 한 줄씩 글토막을 가늠하는 방법입니다. 이 경우에는 가늠하고 싶은 명 령이 들어 있는 줄에 커서를 위치한 다음 가늠하거나(Ctrl-E), 펴거나 (Ctrl-D) 탐색할 수(Ctrl-I) 있습니다. 두 번째 경우는 위의 글토막 전체에 덩이를 씌워서 한꺼번에 가늠하거나 펴 거나 탐색하는 방법이 있습니다. 아래 <그림 3-3>을 살펴보면 두 개의 명령 에 덩이를 씌운 것을 볼 수 있습니다. <그림 3-3> 일터에서 글토막에 덩이를 씌운 모습 (Stp3-3.gif) 그런데 여기서 두 개 이상의 명령을 한꺼번에 실행하기 위해서는 각각의 명 령을 마침표(.)로 나누어주어야 합니다. Smalltalk에서는 "명령과 명령 사이를 구분하기 위해서 마침표를 사용한다" 는 대(大) 명제가 있습니다. 만약 한 개의 명령이 들어있는 경우라면 굳이 명령어의 끝에 마침표를 둘 이유가 없지만, <그림 3-3>처럼 두 개 이상의 명 령들로 이루어진 글토막의 경우는 위의 명령과 아래 명령을 구분하기 위해서 반드시 마침표가 필요한 것입니다. 대개의 경우 한 줄씩 글토막을 가늠하는 것이나 덩이를 씌워서 가늠하는 것 이나 별반 다를 것은 없지만, 어떤 경우에는 반드시 덩이를 씌워서 여러 개 의 명령을 한번에 실행해야 하는 경우도 있습니다. 이는 상황에 따라 적절하 게 가려서 사용하면 될 것입니다. 아무튼 우리의 경우는 덩이를 씌워서 가늠해 보겠습니다. <그림 3-3>처럼 두 줄의 글토막에 덩이를 씌운 후 글쇠를 눌러서 글토막을 가늠해 보 십시오. 그러면 알림판에 <그림 3-4>와 같이 글줄이 써져 있음을 발견하게 될 것입니다. <그림 3-4> 일터에서 내린 명령으로 알림판에 써 진 글 (Stp3-4.gif) 글토막을 가늠하자마자 일터에 다음과 같이 글줄이 써져 있을 것입니다. ---------------------------------------------------------- 안녕하세요?저는 지금 알림판에 글을 씁니다. ---------------------------------------------------------- 그런데 조금 이상한 것이 있습니다. 우리는 분명히 두 개의 명령을 내렸지 만, 알림판을 보면 한 줄에 글줄이 쓰여졌습니다. 왜 그런 것일까요? #nextPutAll: 지시는 알림판에 글줄을 쓰기는 하지만 줄을 바꾸어주지는 않 습니다. 결국 알림판에서 줄을 바꾸기 위해서는 우리가 스스로 알림판에게 줄을 바꾸라는 지시를 내려주어야 합니다. 아래를 보십시오. <바탕글 1> 알림판에 글을 쓰는 프로그램 ---------------------------------------------------------- Transcript nextPutAll: '안녕하세요?'. Transcript cr. Transcript nextPutAll: '저는 지금 알림판에 글을 씁니다.'. ---------------------------------------------------------- 위의 바탕글을 가늠해 봅시다. 이제부터 위와 같은 모양의 바탕글이 나오면. 이는 한꺼번에 가늠해야 함을 나타냅니다. 위와 같이 되어 있다면 이제부터 는 한꺼번에 덩이를 씌워서 가늠하십시오. 위의 바탕글을 가늠한 다음 알림판을 보면, 과연 두 문장 사이에 줄이 바뀌 어 있다는 것을 알게 됩니다. 바로 #cr이라는 지시를 Transcript 객체에게 내려주었기 때문입니다. 여기서의 cr은 Carriage Return을 말하는 것으로, 줄을 바꾸어라는 뜻입니다. Transcript 객체가 알아듣는 지시로 space가 있다고 했습니다. 그러면 위의 <바탕글 1>을 아래처럼 고쳐서 가늠해 봅시다. <바탕글 2> #space 지시를 알아듣는 알림판 ---------------------------------------------------------- Transcript nextPutAll: '안녕하세요?'. Transcript space. Transcript nextPutAll: '저는 지금 알림판에 글을 씁니다.'. ---------------------------------------------------------- 위의 글토막을 한꺼번에 펴 보면 알림판에 아래와 같은 결과가 나타날 것입 니다. ---------------------------------------------------------- 안녕하세요? 저는 지금 알림판에 글을 씁니다. ---------------------------------------------------------- 물음표(?)와 "저" 사이에 한 칸의 빈칸이 생겼습니다. 이렇게 #space 지시를 내려주면 한 칸의 빈칸을 만들어 냅니다. Transciprt는 #nextPut: 이라는 지시도 알아듣습니다. 이 지시는 지금까지 우리가 사용헀던 #nextPutAll:과는 달라서 한 개의 글자만을 인자로 받아들 입니다. 아래의 <바탕글 3>을 펴 봅시다. <바탕글 3> #nextPut:의 시험 ---------------------------------------------------------- Transcript nextPut: $A. Transcript nextPut: $B. Transcript nextPut: $C. ---------------------------------------------------------- 'A', 'B', 'C'라는 세 개의 글자가 다닥다닥 붙어서 나타났습니다. 그러니까 nextPut:은 한 개의 글자를 알림판에 써내는 일을 합니다. 'A'와 $A는 엄연 히 다른 객체라는 것을 벌써 잊지는 않으시겠지요? 이 두 개의 객체가 다른 지 같은지 잘 모르겠다면 여러분이 직접 물어보십시오. 'A'와 $A에게 각각 #class라는 지시를 내려주면 확실히 두 객체가 속한 갈래가 다르다는 것을 알 수 있을 것입니다. 그러면 여기서 잠깐 생각해 볼 것이 있습니다. Transcript nextPutAll: 'A'. ← (1) Transcript nextPut: $A. ← (2) 위의 두 개의 문장의 실행 결과는 같을까요, 다를까요? 결론부터 말씀드리면 똑같습니다. 그러면 #nextPut:이란 길수가 왜 필요한 것일까요? 그것은 바로 #nextPutAll:보다 #nextPut:이 훨씬 적은 일을 하기 때문입니다. 즉 똑같은 결과를 얻어내는데 있어서 #nextPutAll:은 #nextPut:보다 컴퓨터에게 많은 일을 시켜야 하고, 결과적으로 성능이 떨어진다는 것입니다. 그래서 글자 한 개를 나타내기 위해서는 #nextPutAll:보다는 #nextPut:을 사용하도록 권합니 다. 파리 한 마리를 잡는다고 핵폭탄을 쓸 수는 없지 않겠습니까?(임인건, 1992) 계속... 제 목:[강좌] Smalltalk 배우기 #23 관련자료:없음 [94] 보낸이:김찬홍 (안드래아) 1999-07-14 16:31 조회:99 Smalltalk 배우기 #23 1999. 7. 14. 김찬홍 mailto:andrea92@hitel.net ====================================== 3. 객체로 채워진 세상 3.1. 알아보자, 알림판! 3.1.1. 알림판 객체 - Transcript 3.1.2. 알림판이 알아듣는 지시 b→3.1.3. 알림판에 객체 써내기 3.1.4. 잇따름 지시 ..... ======================================= 3. 객체로 채워진 세상 --------------------------- #22에서... 3.1.3. 알림판에 객체 써내기 --------------------------- 지금까지 우리는 알림판에 간단한 문장을 써 보았습니다. 이제 조금 복잡한 문장을 써 보도록 합시다. 아래와 같은 문장을 알림판에 쓰려면 어떻게 해야 할까요? ---------------------------------------------------------- 지금부터 재미있는 '계산'을 해 봅시다. 1 + 2는 3입니다. 2의 10제곱은 ****입니다. 10의 계승은 얼마일까요? 바로 *******입니다. 'abc'는 $a $b $c로 이루어져 있고, 길이는 3 입니다. ---------------------------------------------------------- 그럼 위의 내용을 알림판에 써냅시다. 일단 그 전에 지금까지 알림판에 들어 있던 모든 글자들을 지웁시다. (※ 쉽게 지우려면 (전체선택)을 한 다음 글쇠를 누르면 됩니다.) 처음 문장을 봅시다. 지금부터 재미있는 '계산'을 해 봅시다. 자, 글줄 안에 작은따옴표가 들어가 있습니다. 어떻게 하면 좋을까요? 앞서 글줄에 대해서 공부할 때 글줄 속에 작은따옴표를 넣는 방법을 공부한 바 있 습니다. 기억나십니까? 아래와 같이 하면 됩니다. Transcript nextPutAll: '지금부터 재미있는 ''계산''을 해 봅시다.' Transcript cr. 다음 문장은 어떻게 써야 하겠습니까? 1 + 2는 3입니다. 간단합니다. Transcript nextPutAll: '1 + 2는 3입니다.'. 위와 같이 하면 될 것입니다. 그런데... 다음과 같은 경우는 어떻게 해야하 겠습니까? 2의 10제곱은 ****입니다. 간단한 계산식 같으면 우리가 답을 직접 써넣을 수 있지만, 이와 같은 경우 는 조금 어려운 상황입니다. 어떻게 해야할까요? 일터에서 2 ** 10 ☞ 1024 와 같이 글토막을 만들어서 결과를 얻고, 그 결과를 그대로 이용해서 Transcript nextPutAll: '2의 10제곱은 1024입니다.'. Transcript cr. 이라고 할 수도 있습니다. 물론 그렇게 해도 괜찮겠지만, 만약 2의 20제곱이 라던가 30제곱처럼 값이 바뀌게 되면, 글토막을 새로 만들어서 결과를 얻고, 그 결과를 이용해서 다시 알림판으로 결과를 보내야 합니다. 이것은 너무나 비효율적이지요? 만약 어떤 식을 계산한 결과를 바로 알림판으로 써 낼 수 있다면 매우 편리할 것입니다. 물론! 방법이 있습니다. 모든 객체는 자신이 화면에 표시되는 모양 그대로 알림판에 내용을 써 낼 수 있습니다. 즉 1이나 3 등과 같은 정수는 물론 'abc' 등과 같은 글줄 역시 그대로 써 낼 수 있습니다. 아래의 글토막을 펴 보십시오. 3 printOn: Transcript. ☞ 3 (알림판에) 3이라는 객체에게 #printOn:이라는 지시를 내렸습니다. 그랬더니 알림판에 '3'이 쓰여졌습니다. 이렇게 어떤 객체에게 #printOn: 지시를 내리면 그 객 체를 그대로 #printOn:에 전달된 인자로 그 내용을 써냅니다. 이 경우에는 알림판(Transcript)을 지정했으므로 당연히 '3'이라는 객체가 알림판에 써넣 어진 것입니다. 그러면 다음과 같이 해 봅시다. $a printOn: Transciprt ☞ $a (알림판에) 알림판에 "3$a"라고 적혀 있을 것입니다. 여기서 앞의 '3'은 객체 3에게 #printOn: 지시를 내렸을 때의 값이고, 바로 뒤이어 나온 '$a'가 실제로 우 리가 내린 명령의 결과가 됩니다. 즉 $a 객체에게 printOn: 지시를 내리면 그 객체 모양 그대로의 모습으로 알림판에 나타납니다. 물론 여기서도 알림 판에게 #cr 지시를 내리기 전까지는 줄을 바꾸지는 않습니다. 이것을 이용하면 앞에서 이야기헀던 계산식의 결과를 그대로 알림판으로 내 보낼 수 있습니다. 아주 간단합니다. 아래와 같이 시험해 보십시오. 일단 아 래 글토막을 가늠하기 전에 "3$a"라고 적혀있는 부분을 지워서 깨끗이 만듭 시다. (2 ** 10) printOn: Transcript ☞ 1024 (알림판에) 알림판에 2의 10제곱을 계산한 결과가 그대로 나왔습니다. 위에서 왜 2의 10 제곱을 구하는 부분에 괄호를 둘렀을까요? 물론 이 경우 길표의 우선순위만 놓고 보면 쇠마디(keyword) 지시인 #printOn:보다는 겹마디(binary) 지시인 #**이 먼저 가늠되기 때문에 괄호가 필요하지 않습니다. 그러나 위와 같이 괄호를 둘러주면 바탕글을 보다 쉽게 알아볼 수 있습니다. 자, 이렇게 해서 객체를 알림판에 그대로 써 내는 방법을 알아보았습니다. 방금 알림판에 찍힌 "1024"를 지우고, 이제 본격적으로 우리가 쓰려고 헀던 문장을 써 봅시다. <바탕글 4> ---------------------------------------------------------- Transcript nextPutAll: '2의 10제곱은 '. (2 ** 10) printOn: Transcript. Transcript nextPutAll: '입니다.'. Transcript cr. ---------------------------------------------------------- 그렇다면 아래의 문장도 똑같은 방법을 이용하여 쓸 수 있습니다. 10의 계승은 얼마일까요? 바로 ***** 입니다. <바탕글 5> ---------------------------------------------------------- Transcript nextPutAll: '10의 계승은 얼마일까요? 바로 '. (10 factorial) printOn: Transcript. Transcript nextPutAll: '입니다.'. Transcript cr. ---------------------------------------------------------- #printOn: 지시를 알아들을 수 있는 객체는 숫자만이 아닙니다. 이제 'abc'는 $a, $b, $c로 이루어져 있고, 길이는 3입니다. 를 써낼 차례입니다. 어떻게 하면 가장 효율적으로 바탕글을 만들 수 있을까 요? 여러분이 생각한 것과 제가 쓴 것이 어떻게 다른지 한 번 비교해 보십시 오. <바탕글 6> ---------------------------------------------------------- 'abc' printOn: Transcript. Transcript nextPutAll: '는 '. $a printOn: Transcript. Transcript nextPutAll: ', '. $b printOn: Transcript. Transcript nextPutAll: ', '. $c printOn: Transcript. Transcript nextPutAll: '로 이루어져 있고, 길이는 '. ('abc' size) printOn: Transcript. Transcript nextPutAll: ' 입니다.'. Transcript cr. ---------------------------------------------------------- Smalltalk에서는 명령과 명령을 마침표로 구분하기 때무에, 위와 같이 두 개 의 명령을 한 줄에 써넣을 수도 있습니다. 물론 이 때에는 바탕글이 읽기 어 려워질 수 있기 때문에 신중하게 생각해서 글을 써야 합니다. 그럼 이제까지 쓴 것을 한 데 모아서 아래에 적어보겠습니다. <바탕글 7> 알림판에 문장과 객체 써내기 ---------------------------------------------------------- Transcript nextPutAll: '지금부터 재미있는 ''계산''을 해 봅시다.' Transcript cr. Transcript nextPutAll: '1 + 2는 3입니다.'. Transcript nextPutAll: '2의 10제곱은 '. (2 ** 10) printOn: Transcript. Transcript nextPutAll: '입니다.'. Transcript cr. Transcript nextPutAll: '10의 계상은 얼마일까요? 바로 '. (10 factorial) printOn: Transcript. Transcript nextPutAll: '입니다.'. Transcript cr. 'abc' printOn: Transcript. Transcript nextPutAll: '는 '. $a printOn: Transcript. Transcript nextPutAll: ', '. $b printOn: Transcript. Transcript nextPutAll: ', '. $c printOn: Transcript. Transcript nextPutAll: '로 이루어져 있고, 길이는 '. ('abc' size) printOn: Transcript. Transcript nextPutAll: ' 입니다.'. Transcript cr. ---------------------------------------------------------- 우리가 본 것 중에 가장 긴 바탕글이 되었습니다. 물론 필자가 쓴 것이 가장 좋다는 말은 아닙니다. 여러분 나름대로 좀 더 간결하게 다른 방법으로 바탕 글을 만들 수 있습니다. 글을 많이 써 보면 좀 더 다듬어진 바탕글을 만들어 낼 수 있을 것입니다. 아무튼 이렇게 알림판을 나타내는 Transcript 객체에게 #nextPutAll:, #nextPut:, #cr, #space라는 네 개의 지시를 이용함으로써 알림판에 전혀 손 을 데지 않고 글줄을 써 낼 수 있습니다. 아울러 모든 객체는 #printOn: 지 시를 알아듣기 때문에, 이 지시를 이용해서 알림판에 객체의 내용을 표시할 수도 있었습니다. 그러면 여기서 다음의 두 글토막을 살펴봅시다. Transcript nextPutAll: 'I am a boy.'. ← (1) 'I am a boy.' printOn: Transcript. ← (2) 위의 두 글토막은 똑같은 일을 할까요, 다른 일을 할까요? 실제로 직접 위의 글토막을 가늠해 보면 서로 다른 결과를 얻게 됨을 알 수 있습니다. (1)의 경우는 I am a boy. 가 알림판에 나타나고, (2)의 경우에는 'I am a boy.' 가 알림판에 나타납니다. 즉 #nextPutAll:은 글줄을 구분하기 위해서 사용하 는 작은따옴표를 나타내지 않지만, #printOn:의 경우는 객체가 나타나는 모 습 그대로를 표시하기 때문에 작은따옴표까지 포함해서 나타내게 됩니다. 마 찬가지로 Transcript nextPut: $a. ← (1) $a printOn: Transcript. ← (2) 의 경우를 살펴봅시다. (1)의 경우는 당연히 A 가 나타날 것이고, (2)의 경우는 $A 가 나타납니다. 즉 #nextPut:의 경우는 글자 한 개만 나타내지만, #printOn: 의 경우는 글자임을 나타내는 $표시까지 함께 알림판에 나타냅니다. 따라서 주로 알림판에 사용자에게 알려줄 글을 쓸 때에는 #nextPutAll:이나 #nextPut:을 사용하고, 객체의 내용을 나타내 줄 때에는 #printOn:을 사용하 면 좋습니다. ---<잠깐>---------------------------------------------------------- #printOn: 과 한글 필자가 실험을 하다가 한 가지 놀라운 사실을 발견했습니다. 아래의 글토막 을 가늠해 봅시다. '우리 나라' printOn: Transcript. 알림판을 살펴보면 달랑 두 개의 작은따옴표만 있고 정작 그 속에 들어가야 할 한글은 나타나지 않습니다. 더욱 더 재미있는 것은 '1과 3은 홀수' printOn: Transcript. 위의 글토막을 펴보면 달랑 '1 3'이라는 결과만 나타납니다. 즉 한글을 무시 해 버립니다. 도대체 어떻게 된 것인지... 다행이 사용자가 읽어야 할 글을 출력할 때에는 #nextPutAll:을 사용하고 있기는 하지만, 뭔가 문제가 있습니 다. 필자가 이 글을 끝내는 즉시 Object Arts사에 문의를 해 볼 생각입니다. 아무튼 뭔가 좀 찜찜하다는 생각을 감출 수가 없습니다. ---------------------------------------------------------- 3.1.4. 잇따름 지시 ------------------ Smalltalk로 프로그래밍을 하거나 바탕글을 만들 때 하나의 객체에게 여러 개의 지시를 연속적으로 내려야 하는 경우가 있습니다. 그런데 이렇게 객체 에게 지시를 내릴 때마다 일일이 지시를 받는 객체(receiver)의 이름을 써 준다는 것은 어찌 보면 상당히 귀찮은 일이라 할 수 있습니다. 아래 바탕글 을 봅시다. <바탕글 8> 한 객체에게 여러 개 지시 내리기 ---------------------------------------------------------- Transcript nextPutAll: '우리는 민족 중흥의 역사적 사명을 띄고 '. Transcript nextPutAll: '이 땅에 태어났다. '. Transcript cr. Transcript cr. Transcript nextPutAll: '이상은 국민교육헌장의 첫머리다.'. Transcript cr. ---------------------------------------------------------- 그냥 보기만 해도 상당히 짜증나는 바탕글이 아닐 수 없습니다. 더구나 위의 바탕글을 글쇠판으로 치려고 하면 더욱 더 힘이 듭니다. 위와 같은 경우에 바로 잇따름 지시(cascaded message)를 사용하면 매우 편리합니다. 보통 글토막에서 하나의 명령이 끝나면 마침표를 찍어주고, 그 뒤에 계속해 서 지시를 받을 객체의 이름과 지시의 내용을 적어줍니다. 그러나 잇따름 지 시는 명령문의 끝에 마침표를 찍지 않고 쌍반점(;)을 찍습니다. 그리고 연이 어서 지시를 받을 객체의 이름을 적는 대신 바로 지시를 적습니다. 이렇게 하면 쌍반점 다음에 씌여진 지시는 바로 앞의 명령에서 지시를 받은 객체에 게 그대로 전달됩니다. 말이 어렵지 실제로 보기를 보면 그렇지 않습니다. 위의 <바탕글 8>을 잇따름 지시를 사용해서 다시 써 보면 아래와 같습니다. <바탕글 9> 잇따름 지시를 사용한 바탕글 ---------------------------------------------------------- Transcript nextPutAll: '우리는 민족 중흥의 역사적 사명을 띄고 '; nextPutAll: '이 땅에 태어났다. '; cr; cr; nextPutAll: '이상은 국민교육헌장의 첫머리다.'; cr. ---------------------------------------------------------- 여기서 두 번쨰 #nextPutAll:로부터 #cr 등의 모든 지시는 첫 번째 명시된 Transcript 객체에게 잇따라 보내지게 됩니다. 이렇게 하면 바탕글을 훨씬 깔끔하게 작성할 수 있게 됩니다. 그런데 이와 같은 잇따름 지시는 잘못 쓰게 되면 바탕글을 매우 혼란하게 만 듭니다. 다음 글토막을 가늠해서 펴 보면 어떤 결과가 나오곘습니까? 3 + 2 - 1; * 100 ☞ ? 400이 될까요, 500이 될까요? 실제로 일터에서 위의 글토막을 입력하고 펴 보면 500을 값으로 내놓게 됩니다. 위에서 일단 정수 "3"에 "+ 2" 지시가 보 내지고 5라는 결과를 얻습니다. 그런 다음 이 "5"에 "- 1" 지시가 내려지는 데, 여기서 잇따름 지시인 "* 100"이 함께 내려집니다. 즉 "- 1"의 경우 "5" 로 보내지기는 하지만 실제로 계산된 결과인 4는 무시해 버리고 마침내 "5" 에 "* 100"이 보내지게 되어 "500"이라는 결과값을 얻게 됩니다. 실제로 프로그램을 작성할 때에는 이렇게 애매한 바탕글을 작성하면 곤란합 니다. 그렇지만 잇따름 지시를 잘만 이용하면 바탕글을 훨씬 깔끔하고 읽기 쉽게 만들 수 있습니다. ---<잠깐>---------------------------------------------------------- 바탕글의 기독성 프로그램을 작성하기 위해서는 일단 바탕글(source code)를 써야 합니다. 바 탕글에는 컴퓨터에게 내릴 여러 가지 명령문들이 들어갑니다. 그런데 바탕글 은 한 번 쓰여지고 여러 번 읽혀지기 때문에 바탕글을 읽기 좋게 쓰는 것은 매우 중요합니다. 만약 바탕글을 아무렇게나 쓰면 한참 후에 다시 바탕글을 읽어서 프로그램의 흐름을 분석하려고 할 때 매우 곤란을 겪게 됩니다. Dolphin Smalltalk에서 바탕글의 글토막에 문법 돋이(syntax highlighting) 를 적용하는 것도 바로 이런 이유 때문입니다. 바탕글은 지나치게 길어져서는 안됩니다. 특히 Smalltalk처럼 객체지향 언어 의 경우는 바탕글을 매우 짧게 쓰더라도 충분히 프로그램을 작성할 수 있기 때문에 지나치게 바탕글이 길면 곤란합니다. 또한 바탕글을 쓸 때에는 적당하게 들여 쓰기(indentation)를 해야 합니다. <바탕글 9>를 보면, Transcript 아래에 있는 모든 문장 앞에 빈칸이 들어가 있음을 볼 수 있습니다. 이는 잇따름 지시의 특성상 모든 지시들이 하나의 객체에게 잇따라 전해지는 것을 쉽게 표현한 것입니다. 이와 함꼐 앞으로 이 렇게 여러 가지의 들여 쓰기 방법들이 소개될 것입니다. 또한 바탕글이 길어질 경우, 바탕글을 몇 개의 작은 부분으로 나누고, 각 부 분마다 빈줄을 한 줄 정도 삽입해 두면 훨씬 읽기가 편합니다. 필자도 글을 쓸 때 여러분이 쉽게 읽을 수 있도록 가끔 빈 줄을 삽입하듯이, 여러분이 바 탕글을 쓸 때에도 프로그램이 하는 일을 보고 적당히 빈줄을 넣어 주면 훨씬 읽기 좋은 바탕글이 됩니다. 다시 한 번 말씀드리지만, 바탕글을 한 번 쓰여지고 여러 번 읽혀지기 때문 에 조금 번거롭더라도 바탕글의 기독성(readability)을 높이기 위해서 들여 쓰기와 여러 가지 표현 방법들을 잘 활용해야 할 것입니다. ---------------------------------------------------------- =========================================================== 지금까지 우리는 알림판에 대해서 알아보았습니다. 이 알림판은 Smalltalk 환경이 여러분에게 중요한 사실을 알려줄 때 이용하는 창구의 역할을 수행할 뿐만 아니라, 여러분이 직접 프로그램에서 필요한 문장을 적어줄 수도 있다 는 것을 공부했습니다. 아울러 모든 객체는 #printOn: 지시를 알아듣는다는 것도 알아보았습니다. 또한 하나의 객체에게 두 개 이상의 지시를 잇따라 내 려야 할 때 일일이 지시를 받는 객체(receiver)의 이름을 적어주는 것보다는 잇따름 지시를 이용하는 것이 훨씬 편리하다는 것도 알아보았습니다. 다음에는 프로그래밍에서 매우 중요하게 다루어지게 될 꼬리표(variable)에 대해서 알아보도록 하겠습니다. 이 꼬리표를 사용하면 비로소 Smalltalk에 의미 없이 존재하는 수많은 객체에게 여러분 나름대로의 이름을 붙여줄 수 있습니다. 계속... 제 목:[강좌] Smalltalk 배우기 #24 관련자료:없음 [95] 보낸이:김찬홍 (안드래아) 1999-07-20 16:52 조회:87 Smalltalk 배우기 #24 1999. 7. 20. 김찬홍 mailto:andrea92@hitel.net ====================================== 3. 객체로 채워진 세상 3.1. 알아보자, 알림판! 3.2. 꼬리표 인생 a→3.2.1. 이름이 뭐지? 3.2.2. 바로값과 꼬리표 3.2.3. 작은 꼬리표 ..... ======================================= 3. 객체로 채워진 세상 --------------------------- 3.2. 꼬리표 인생 ~~~~~~~~~~~~~~~~ 지금까지 우리는 셀 수 없을 정도로 많은 객체에게 여러 가지 지시를 내려보 았습니다. 또한 이렇게 해서 역시 셀 수 없는 많은 객체들을 결과물로 되돌 려 받았습니다. 그러나 이런 객체들은 대부분 자신이 맡은 일을 수행하고는 그냥 그대로 사라져 가고 말았습니다. 3 + 4 ☞ 7 위와 같은 아주 간단한 글토막에서도 "3", "4", "7"이라는 객체는 그냥 한 번 저렇게 쓰여지고는 어디론가 사라져 가버린 것입니다. 그것은 저런 객체 들이 오래 두고 보관하기에는 별다른 가치가 없기 때문입니다. 그러나 어떤 객체는 우리에게 중요한 의미로 다가옵니다. 복잡한 계산이나 여러 개의 명령을 통해서 얻어낸 객체라면 그것은 나름대로 큰 의미를 가지 고 있습니다. 이렇게 Smalltalk에는 많은 객체가 존재하지만, 그 중에서 우 리에게 특별하게 의미가 있는 객체들이 있고, 그렇지 않은 객체들도 있는 것 입니다. 이제 우리는 여기서 이렇게 나름대로 의미를 가지고 있는 객체들에게 이름을 부여하는 방법을 배우게 됩니다. 수많은 객체 중에 어느 하나에 나만의 이름 을 붙여준다면, 이제 그 객체는 적어도 나에게는 매우 큰 의미를 가지는 것 입니다. 3.2.1. 이름이 뭐지? ------------------- 필자는 어릴 적에 어머니를 따라서 길을 가다보면 "이름이 뭐니?" 하고 물으 시는 어른들을 자주 뵈었었습니다. "김찬홍", 이는 누구와도 다른 저만의 이 름입니다. 그 누구도 제 이름을 바꿀 수 없고, 또한 "김찬홍"이라고 하는 그 이름의 의미를 바꿀 수는 없습니다. 왜냐하면 "김찬홍"은 지금 글을 쓰고 있 는 바로 "저 자신"이기 때문입니다. 이름은 그만큼 중요한 것입니다. 그런데 이런 저에게도 단지 "김찬홍"이라는 이름만 있는 것이 아닙니다. 집 에서 어머님은 저를 "막내야"라 부르십니다. 학교에 오면 "선배님"이란 소리 도 듣습니다. 길을 가다보면 "아저씨"라는 소리도 듣게 됩니다. 좀 기분이 나쁘기는 하지만, 아저씨는 아저씨이니 별 수 없이 "아저씨" 소리를 듣고도 다른 말을 하기가 어렵습니다. :) 그 뿐인가요? 성당 주일학교에 가면 여지 없이 나는 "선생님"으로 통합니다. 그러고 보니 성당에서 신부님은 저를 세 례명으로 "안드레아"라고도 부르십니다. 보십시오. "김찬홍"이라는 한 사람에게도 "막내", "선배", "아저씨", "선생 님", "안드레아"라는 여러 가지의 이름이 있습니다. 제가 "안드레아"라고 불 린다고 해서 "찬홍"이 아니겠습니까? 그것은 아니겠지요? 이런 모든 이름들 은 단 한 사람, 바로 저를 부르기 위해서 쓰인 것입니다. 사람들이 이름을 쓰는 이유는 무엇일까요? 그것은 이름이 가리키는 대상을 부르기 위함입니다. "찬홍아!", "막내야!", "안드레아야!"라고 부르는 것은 바로 저를 부르기 위해서입니다. 그래서 사람들은 자기 이름이 불리면 가장 큰 관심을 갖고 지켜보게 됩니다. 그 뿐 아니라 세상에 있는 모든 사물에는 저마다의 이름이 있습니다. 이는 사람들이 모두 그 사물을 가리켜 일컫기 위함입니다. 심지어는 길에 굴러다 니는 쓸모 없는 것들도 "쓰레기"라는 이름을 가지고 있습니다. 물론 우리가 부르고 싶은 사물의 중요도가 올라가면 이름도 훨씬 구체적으로 부르게 됩니 다. 그냥 "종이"가 아니라 "일기장"이라고 부르듯이 말입니다. Smalltalk에서도 마찬가지입니다. Smalltalk는 하나의 작은 세상입니다. 이 세상에는 헤아릴 수 없이 많은 객체가 존재합니다. 그리고 Smalltalk 환경에 들어와 있는 사람(프로그래머)이 이런 객체들에게 어떤 지시를 내리고 싶을 때에는 먼저 그 객체의 이름을 불러주어야 합니다. 따라서 Smalltalk의 모든 객체에는 저마다의 이름이 부여되어 있습니다. 3.2.2. 바로값과 꼬리표 ---------------------- Smalltalk에서 쓰이는 이름에는 두 가지 종류가 있습니다. 그 하나가 "바로 값"(literal)입니다. 이 바로값은 우리가 앞의 2.3.5 마디(#20)에서 다루어 본 적이 있는 객체입니다. 그러나 "바로값이 무엇인가?"하고 물었을 때 시원 하게 대답할 수 있는 정의를 내리지는 않았습니다. 그것은 이 바로값과 객체 에게 붙은 이름이 관련되어있기 때문입니다. "어떤 객체가 변하지 않는 이름을 가지고 있다면 그 객체는 바로값이다." 이 말을 바꾸어 말하면 "이름으로 __바로__ 객체를 지칭할 수 있다면 이 객체는 바로값이다." 라고 말할 수도 있습니다. 즉 바로값은 고유의 이름을 가진 객체들을 가리키 는 말입니다. $a 글자 a를 나타내는 이름. 'I''m' 세 개의 글자($I, $', $m)로 이루어진 글줄에 붙는 이름. #red $r, $e, $d 세 개의 글자로 이루어진 이름값 2000 정수 "이 천"을 나타내는 이름 1.2e2 소수 "1200.0"을 나타내는 이름 true "참"을 나타내는 이름 false "거짓"을 나타내는 이름 nil "헛"(아무 의미 없음)을 나타내는 이름 #(1 2) 정수 1과 2가 들어 있는 배열을 나타내는 이름. 보다시피 바로값은 객체에게 따로 이름을 붙일 필요가 없이 바로 나타낼 수 있습니다. 이렇게 일정한 규칙에 따라서 글자나 숫자를 늘어놓게 되면 바로 값을 나타내는 이름이 되는 것입니다. 즉, 이런 바로값의 이름은 __결코__ 변하지 않습니다. "3"은 언제까지나 "3"인 것입니다. Smalltalk에서 쓰이는 이름 가운데 두 번째가 바로 "꼬리표"(variables)입니 다. 우리가 어떤 물건에 이름을 붙이고 싶을 때 꼬리표(딱지, sticker)에 이 름을 써 붙이듯이, 객체에게 우리 나름대로 이름을 지어주고 싶을 때에도 꼬 리표를 붙여주면 됩니다. 바로값을 가리키는 객체의 이름은 어떠한 일이 있 어도 바뀔 수 없지만, 꼬리표가 붙은 객체는 다릅니다. 필요하면 언제든지 다른 꼬리표를 붙여서 객체의 이름을 다르게 부를 수 있습니다. 바로값에 나름대로의 규칙이 있듯이 꼬리표를 쓰는 데에도 나름대로의 규칙 이 있습니다. "2.3.5." 마디(#19)에서 우리는 이미 "이름값"(symbol)에 대해 서 공부한 적이 있습니다. 바로 이 이름값이 꼬리표를 쓰는데 사용됩니다. 이름값을 어떻게 만드는지 벌써 잊어버리셨습니까? 여러분을 위해서 이름 붙 이는 방법에 대해서 다시 한 번 정리해 드리겠습니다. 중요한 내용이니깐 꼭 이해하고 넘어가시기 바랍니다. << 이름 짓기 규칙 >> =========================================================== 1. 이름에는 기본적으로 영문 알파벳과 숫자, 그리고 밑줄(_)을 사용한다. 2. 첫 글자가 숫자여서는 안 된다. 3. 영문 알파벳의 경우는 대문자와 소문자가 엄격하게 구별된다. 4. 겹마디(binary) 지시에 한해서 다음의 기호를 사용할 수 있다. ! @ % * ( [ { } < > = | \ / ? + - : =========================================================== 꼬리표는 다시 큰 꼬리표(global variables)와 작은 꼬리표(local variable) 로 나누어집니다. 큰 꼬리표의 이름은 대문자로 시작하고, 작은 꼬리표의 이 름은 소문자로 시작합니다. 우리는 벌써 몇 개의 큰 꼬리표를 사용해 왔습니 다. 믿어지지 않는다고요? 다음을 보십시오. Integer superclass ☞ Number #red isKindOf: String ☞ true Transcript nextPutAll: '하하하!'. (10 factorial) printOn: Transcript. 위에서 "Integer", "String", "Transcript"는 모두 큰 꼬리표입니다. 자세히 보면 모두 꼬리표 이름의 첫 글자가 대문자로 시작하고 있음을 알 수 있습니 다. 놀라셨습니까? 그렇지만 엄연히 위의 세 개는 꼬리표입니다. 여태껏 우 리가 자주 보아왔던 Integer, String, Object 등은 물론이고 Smalltalk에 존 재하는 모든 갈래(class)들은 결국 큰 꼬리표가 붙어 있었던 것입니다. 꼬리표의 값이 바뀔 수 있다고 앞에서 이야기한 적이 있는데, 당연히 이런 갈래에 붙어 있는 큰 꼬리표 역시 다른 객체에 붙일 수 있습니다. 즉 String 이 지금은 "String 갈래"에 붙어 있지만, 마음만 먹으면 언제든지 이 꼬리표 를 떼어다가 "3"이나 $a 처럼 하찮은 객체에게 붙여버릴 수도 있다는 말입니 다! Transcript도 마찬가지입니다. Transcript를 일터에서 펴 보면 Transcript ☞ a TranscriptShell 이 뜨는데, 결국 이 Transcript 꼬리표를 "Integer 갈래"에 붙여도 되는 것 입니다. 그러나... 실험 정신이 투철한 사람이 아니고서는, 그리고 이러한 꼬리표에 붙어 있는 객체들이 Smalltalk에서 얼마나 중요한 객체인지를 알고 있는 사람은 함부로 이런 꼬리표를 건드리지 않습니다. (여러분에게 부탁합니다. 제발 이런 꼬리 표를 건드리지 마십시오. Smalltalk에 어떠한 영향을 미칠지 저도 장담 못합 니다. ^^:) 3.2.3. 작은 꼬리표 ------------------ 여기서는 일단 작은 꼬리표에 대해서 먼저 알아보도록 하겠습니다. 실제로 꼬리표를 사용할 때에는 작은 꼬리표나 큰 꼬리표나 별반 차이가 없습니다. 그렇지만 Smalltalk로 프로그램을 작성하는 경우에 큰 꼬리표보다 작은 꼬리 표를 훨씬 더 많이 사용하게 될 것입니다. 작은 꼬리표이건 큰 꼬리표이건, Smalltalk에서 꼬리표를 사용하려면 먼저 "이러이러한 이름의 꼬리표를 쓰겠노라"고 Smalltalk에게 알려주는 과정이 필요한데, 이를 "꼬리표를 선언한다"라고 부릅니다. 즉 내가 꼬리표를 쓰고 싶다면 꼬리표를 쓰기 전에 Smalltalk에게 꼬리표를 쓰겠다고 알려주어야 한 다는 것입니다. 꼬리표를 선언하는 방법은 작은 꼬리표와 큰 꼬리표가 서로 다릅니다. 우리는 지금 작은 꼬리표에 대해서 알아보고 있으므로, 여기서는 작은 꼬리표를 어떻게 선언하는지 알아봅시다. 작은 꼬리표는 글토막의 맨 처음에 다음과 같이 선언합니다. | a b c | 보다시피 새로 막대(vertical bar) 사이에 꼬리표로 쓸 이름들을 빈칸으로 구분해서 늘어놓기만 하면 됩니다. 위의 경우는 a, b, c라는 세 개의 꼬리표 를 쓰겠다고 Smalltalk에게 알려주고 있군요. 물론 두 글자 이상의 꼬리표도 사용할 수 있습니다. | apple anInteger temperatureToday anInternetAddressBook | 위와 같이 한 개의 단어로 이루어진 꼬리표는 물론 두 개 이상의 단어로 이 루어진 꼬리표도 사용할 수 있습니다. 다만 이 때 새로운 단어의 첫 글자에 는 반드시 대문자를 사용하도록 합시다. 물론 작은 꼬리표의 첫 글자는 소문 자이기 때문에 첫 번째 오는 단어에는 이 규칙이 적용되지 않습니다. 만약 anInternetAddressBook을 aninternetaddressbook이라고 쓰게 되면 어떻게 알 아볼 수 있겠습니까? 그러므로 조금 번거롭더라도 단어와 단어를 쉽게 구분 하고 바탕글을 쉽게 읽을 수 있게 하기 위해서 이름을 신중하게 짓는 것이 매우 중요합니다. 아, 그리고 Smalltalk에서 꼬리표나 이름의 길이에는 제한 이 없습니다만, 지나치게 이름이 길어지면 글쇠판을 많이 눌러야 하기 때문 에 귀찮아지고, 읽기에도 좋지 않으므로 비교적 짧으면서도 뜻이 분명한 이 름을 짓도록 해야 할 것입니다. 이제 작은 꼬리표를 선언하는 방법을 알았으니, 선언된 꼬리표를 객체에 붙 이는 방법을 알아봅시다. 작은 꼬리표나 큰 꼬리표 모두 똑같은 방법을 사용 합니다. 꼬리표이름 := 계산식. 위와 같이 하면 ":=" 오른쪽에 있는 계산식을 모두 가늠하여 그 결과로 남겨 진 객체에 왼쪽의 꼬리표를 붙이게 되는 것입니다. 위에서 ":=" 기호를 "붙 임표"(binder)라고 부릅니다. ":=" 오른쪽에 있는 객체에게 왼쪽에 있는 꼬 리표를 붙이기 때문에 이런 이름이 붙게 되었습니다. 이렇게 해서 객체에 꼬리표를 달게 되면 이제부터 꼬리표가 바로 객체의 새 로운 이름이 되는 것입니다. 만약 | a | a := 3. 이라는 글토막이 있다면, 이제부터 a라고 부르면 "3"을 가리키게 되는 것입 니다. 그럼 이제부터 꼬리표를 사용하는 방법에 대해서 실제로 바탕글들을 가늠해 보면서 알아보도록 합시다. 바탕글을 가늠하기 전에 알림판의 모든 내용을 지워주십시오. <바탕글 1> 꼬리표와 붙임표의 사용법 ---------------------------------------------------------- | a | a := 3. a printOn: Transcript. [실행 결과] 3 (알림판에) ---------------------------------------------------------- 알림판에 "3"이 나타났습니다. 왜냐하면 3에 a를 붙였고, 따라서 이제부터 "3"은 "a"라는 새로운 이름으로 부를 수 있게 된 것입니다. 즉 a printOn: Transcript. 는 3 printOn: Transcript. 와 완전히 같은 글토막이 되는 것입니다. 이제 a라고 하면 언제나 3을 가리 키게 됩니다. 왜냐하면 3에 a가 __붙어있기__ 때문입니다. 그럼 다음 바탕글을 가늠해 보십시오. <바탕글 2> 계산식 사용하기 ---------------------------------------------------------- | a | a := 3 + 4. a printOn: Transcript. Transcript cr. [실행 결과] 37 (알림판에) ---------------------------------------------------------- 알림판을 보면 "37"이라는 글자가 쓰여 있을 것입니다. 여기서 앞의 "3"은 < 바탕글 1>의 결과이고, 뒤의 "7"이 <바탕글 2>의 결과입니다. 눈여겨보십시 오. <바탕글 2>에서 a := 3 + 4. 라고 했습니다. 붙임표(:=)에 대해서 설명할 때, 붙임표 오른쪽의 계산식을 가늠하여 얻은 결과에 := 왼쪽의 꼬리표를 붙인다고 했습니다. 위에서 붙임 표 오른쪽의 계산식을 모두 가늠하면 당연히 7이 될 것이고, 결과적으로 위 의 글토막은 a := 7. 이 됩니다. 그럼 이제부터 a는 7에 붙어 있게 됩니다. 결국 a printOn: Transcript. 문장은 7 printOn: Transcript. 와 똑같은 문장이 되는 것입니다. 이것이 바로 꼬리표의 특성입니다. <바탕글 2>의 마지막에 Transcript에게 #cr 지시를 보낸 것은 결과를 좀 더 확인하기 쉽게 하기 위함입니다. 즉 하나의 결과를 표시한 다음 줄을 바꾸어 주면 다음 바탕글을 가늠할 때 편리하지 않겠습니까? 그럼 이번에는 꼬리표를 이용해서 의미 있는 일을 해 봅시다. 이 글을 쓰고 있는 지금은 매우 더운 여름입니다. 하루에도 기온이 30도가 넘는 경우가 매우 많습니다. (여기는 대구거든요.) 그런데 어제의 기온은 28 도였고, 오늘의 기온은 32도였습니다. 그러면 기온의 평균은 얼마나 될까요? 이제 그것을 Smalltalk에서 꼬리표를 사용해서 알아보도록 합시다. <바탕글 3> 꼬리표를 이용해서 기온 평균 구하기. ---------------------------------------------------------- | temperatureToday temperatureYesterday temperatureAverage | temperatureToday := 32. "섭씨" temperatureYesterday := 28. "섭씨" temperatureAverage := ((temperatureToday + temperatureYesterday) / 2). Transcript nextPutAll: '어제의 기온은 '. temperatureYesterday printOn: Transcript. Transcript nextPutAll: '도이며, 오늘의 기온은 '. temperatureToday printOn: Transcript. Transcript nextPutAll: '도 입니다.'; cr. Transcript nextPutAll: '오늘과 어제의 기온 평균은 '. temperatureAverage printOn: Transcript. Transcript nextPutAll: '도 입니다.'; cr. [실행 결과] 어제의 기온은 28도이며, 오늘의 기온은 32도 입니다. 오늘과 어제의 기온 평균은 30도 입니다. ---------------------------------------------------------- 오랜만에 긴 바탕글을 만나게 되었습니다. 그렇지만 바탕글이 길어도 내용이 어렵지는 않습니다. 많은 양에 겁먹지 말고, 차근차근 바탕글을 위에서부터 분석해 나가다 보면 나중에는 전체 바탕글을 이해할 수 있습니다. 그럼 먼저 <바탕글 3>의 첫 줄을 보십시오. | temperatureToday temperatureYesterday temperatureAverage | 꼬리표 세 개를 쓰겠다고 Smalltalk에게 알려주는 것입니다. 꼬리표의 이름 이 아무리 길어봤자 결국에는 꼬리표입니다. 우리의 바탕글에서는 오늘의 기 온(temperatureToday), 어제의 기온(temperatureYesterday), 그리고 기온의 평균(temperatureAverage), 이렇게 세 개의 꼬리표를 달았습니다. 다음에는 이렇게 만든 꼬리표를 각각 적당한 객체에 붙이면 됩니다. temperatureToday := 32. "섭씨" temperatureYesterday := 28. "섭씨" "32"와 "28"은 평범하게 이를 데 없는 정수 객체입니다. 그러나 여기에 의미 가 부여되기 시작합니다. 바로 "32"에는 "오늘의 기온"이, 그리고 "28"에는 "어제의 기온"이라는 의미가 부여되게 됩니다. 32와 28을 Smalltalk 세상에 존재하는 수많은 객체들 중의 일부이지만, 이제 이 객체에 꼬리표가 붙었으 므로 두 개의 객체들은 충분한 의미가 있는 것입니다. 그런데... 위에서 큰따옴표(" ")안에 들어 있는 글자는 무엇일까요? 기억 나십니까? 바 로 풀이글입니다. "2.3.3."에서 글자와 글줄을 다룰 때(#16) 우리는 잠시 풀 이글에 대해서 알아본 적이 있습니다. 다시 말하자면, Smalltalk는 큰따옴표 안에 들어 있는 모든 내용을 무시해 버립니다. 따라서 큰따옴표 안에 어떤 문자를 넣어도 상관이 없다는 것입니다. 그래서 보통은 바탕글에 설명을 달 아줄 때 풀이글을 사용합니다. <바탕글 3>에서는 우리가 꼬리표를 붙인 객체들이 다름아닌 "섭씨 온 도"(degree centigrade)임을 나타냅니다. 온도에는 섭씨와 화씨(fahrenheit) 두 가지의 종류가 있다는 것은 아시지요? 그래서 여기서는 그런 혼동을 피하 기 위해서 풀이글로써 명시 해 둔 것입니다. 아무튼 위의 두 문장이 실행되 면 비로소 "32"와 "28"은 의미를 갖게 됩니다. temperatureAverage := (temperatureToday + temperatureYesterday) / 2. 위의 문장은 온도의 평균을 구하는 부분입니다. 즉 어제의 온도와 오늘의 온 도를 더해서 그것을 다시 2로 나누게 되면 평균값이 구해집니다. 이렇게 해 서 얻어진 결과에 다시 temperatureAverage라는 꼬리표를 붙이게 됩니다. 만 약 위의 계산식이 단순히 지시를 내리기 위한 인자(parameter)에 실려서 전 달되고 말았다면 아무런 의미를 가지지 못헀을 것입니다. 그러나 저렇게 계 산된 객체에 temperatureAverage 꼬리표를 붙여 둠으로써, 저 객체는 사라지 지 않고 필요할 떄 언제든지 부를 수 있게 된 것입니다. 이렇게 꼬리표는 원 하는 객체에게 바로 붙여서 의미를 부여할 때에도 쓰이지만, 계산의 결과값 으로 생기는 객체에게 붙여두어서 그 객체(=계산의 결과)를 나중에 다시 사 용할 때에도 필요합니다. 이제 어제의 온도, 오늘의 온도, 온도의 평균을 모두 구했으니, 이것을 알림 판에 뿌려주기만 하면 됩니다. 이는 #nextPutAll:과 #printOn:지시를 이용하 면 어렵지 않게 할 수 있습니다. 간간히 줄을 바꾸어주기 위해서 #cr지시도 필요하겠지요? Transcript nextPutAll: '어제의 기온은 '. temperatureYesterday printOn: Transcript. Transcript nextPutAll: '도이며, 오늘의 기온은 '. temperatureToday printOn: Transcript. Transcript nextPutAll: '도 입니다.'; cr. 위에서 #nextPutAll:이 실행되는 것은 별반 다를 것이 없습니다. 오히려 꼬 리표가 가리키는 객체에 #printOn: 지시가 내려지는 것이 중요합니다. 앞서 우리는 temperatureToday와 temperatureYesterday에 각각 32와 28을 붙였고, 그것을 여기에서 그대로 알림판에 써 낸 것입니다. 마지막 줄에 있 는 #cr 지시는 줄을 바꾸기 위해 주어진 것이고, Transcript에 보내지게 될 것이므로, 잇따름 지시(cascaded message)를 사용했습니다. Transcript nextPutAll: '오늘과 어제의 기온 평균은 '. temperatureAverage printOn: Transcript. Transcript nextPutAll: '도 입니다.'; cr. 역시 위의 문장도 별로 어려울 것이 없습니다. #nextPutAll: 지시를 이용해 서 뼈대가 될 글줄을 출력하고, 계산에 의해서 생성된 객체에 temperatur Average 꼬리표를 붙여 두었으니 그것을 그대로 사용하기만 하면 됩니다. 역 시 줄을 바꾸기 위해서 있다름 지시로 #cr을 내렸습니다. <바탕글 3>이 아직도 복잡해 보입니까? 만약 여기까지 읽었는데 무슨 말인지 제대로 이해가 가지 않으면 처음부터 다시 이 글을 읽어봅시다. 여기서 만약 제대로 개념을 잡지 못하게 되면 앞으로 많은 혼동을 일으키게 될 것입니다. 그러니 서두르지 말고 천천히 꼬리표와 붙임표에 대해서 이해하도록 합시다. 앞에서 꼬리표는 여기 저기에 마음대로 떼었다 붙였다 할 수 있다고 헀습니 다. 아래의 바탕글을 살펴봅시다. <바탕글 4> 꼬피표가 가리키는 값은 바뀔 수 있음 ---------------------------------------------------------- | temperature | temperature := 28. Transcript nextPutAll: '어제의 기온은 '. temperature printOn: Transcript. Transcript nextPutAll: '도 입니다.'; cr. temperature := 32. Transcript nextPutAll: '오늘의 기온은 '. temperature printOn: Transcript. Transcript nextPutAll: '도 입니다.'; cr. ---------------------------------------------------------- 위에서 temperature printOn: Transcript. 라는 똑같은 명령이 수행되었지만, temperature 꼬리표에 어떤 객체가 붙어 있는지에 따라서 다른 값이 알림판에 나타났습니다. 이렇게 한 번 어떤 객체 에 꼬리표를 붙여놓아도 다른 객체에 꼬리표를 붙이면 예전에 붙어 있던 객 체는 떨어져 나가고 새로운 객체가 붙게 됩니다. 즉 굳이 객체를 떼어내지 않아도 옛날 객체는 Smalltalk가 알아서 떼내어 줍니다. 중요한 것은 이렇게 꼬리표에는 필요에 따라서 여러 가지 객체들을 붙여둘 수 있다는 것입니다. 그런데 만약에 꼬리표를 쓴다고 선언해 놓고 아무런 객체도 붙이지 않았다면 어떻게 될까요? 다음 바탕글을 펴 봅시다. <바탕글 5> 아무 것도 붙지 않은 꼬리표 ---------------------------------------------------------- | temperature | Transcript nextPutAll: '오늘의 기온은 '. temperature printOn: Transcript. Transcript nextPutAll: '도 입니다.'; cr. [실행 결과] 오늘의 기온은 nil도입니다. ---------------------------------------------------------- 실행 결과에서도 볼 수 있듯이 어떤 꼬리표가 처음에 만들어질 때, 즉 어떤 객체에도 붙이지 않은 꼬리표는 기본적으로 헛(nil) 객체에 붙어 있습니다. nil class ☞ UndefinedObject nil은 위에서 보시다시피 UndefinedObject 갈래의 실체인데, "아무 것도 없 는, 허무한, 허공의, 비어 있는, 의미 없는"이라는 뜻을 가지고 있습니다. 원래 UndefinedObject라는 갈래 이름 자체가 "의미 없는"이라는 뜻이기 때문 에 nil의 속성을 잘 나타내고 있습니다. 위에서 보다시피 꼬리표를 만들었으면 반드시 그 꼬리표를 어떤 객체에 붙인 다음에 사용해야 합니다. 그렇지 않으면 꼬리표는 nil에 붙에 되고, nil이 알아들을 수 없는 지시를 사용하게 되면 Smalltalk가 발자취 창을 표시하면 서 잘못된 동작을 수행하게 됩니다. 다음 바탕글을 가늠해 봅시다. <바탕글 6> 아무 것도 붙지 않은 객체 그대로 사용하기 ---------------------------------------------------------- | temperature | (temperature + 3) printOn: Transcript. Transcript cr; [실행 결과] "UndefindedObject does not understand #+" 잘못 발생 ---------------------------------------------------------- 위와 같은 경우 temperature는 아직 아무런 객체에도 붙여지지 않았으므로 nil에 붙어 있을 것입니다. 결국은 (temperature + 3) printOn: Transcript. 는 (nil + 3) printOn: Transcript. 와 같은 꼴이 될 것이고, UndefinedObject의 실체인 nil은 덧셈을 할 줄 모 르기 때문에 #+ 지시를 이해할 수 없다고 하는 어의 없는 결과를 낳게 됩니 다. 그러므로 꼬리표를 사용할 때에는 먼저 제대로 객체를 붙였는지를 확인 할 필요가 있습니다. 계속... 제 목:[강좌] Smalltalk 배우기 #25 관련자료:없음 [96] 보낸이:김찬홍 (안드래아) 1999-07-21 18:08 조회:89 Smalltalk 배우기 #25 1999. 7. 21. 김찬홍 mailto:andrea92@hitel.net ====================================== 3. 객체로 채워진 세상 3.1. 알아보자, 알림판! 3.2. 꼬리표 인생 3.2.1. 이름이 뭐지? 3.2.2. 바로값과 꼬리표 b→3.2.3. 작은 꼬리표 3.2.4. 붙임표에 대해서 ..... ======================================= 3. 객체로 채워진 세상 --------------------------- 3.2. 꼬리표 인생 ~~~~~~~~~~~~~~~~ 3.2.3. 작은 꼬리표 ------------------ #24에서... 작은 꼬리표가 기구한 운명을 가지고 있다는 사실을 여러분은 모를 것입니 다. 작은 꼬리표는 글토막이 가늠될 때, 오직 그 때만 존재합니다. 세로 막 대 속에서 작은 꼬리표가 선언되고 바탕글에서 그 꼬리표가 할 일을 모두 수 행하고 나면, 즉 바탕글의 실행이 끝나면 작은 꼬리표는 흔적도 없이 사라져 버리게 됩니다. 다시 말하면 작은 꼬리표는 바탕글이 가늠될 때에만 존재하 는 것입니다. 이런 까닭으로 작은 꼬리표를 일컬어 "하루살이 꼬리표" 또는 "잠깐 꼬리표"(temporary variables)라고도 부릅니다. 예를 들어봅시다. <바탕글 7> ---------------------------------------------------------- | color | color := #red. color. [실행 결과] ☞ #red ---------------------------------------------------------- <바탕글 7>에 덩이를 씌워서 펴(display) 보면, 결과로 #red를 남깁니다. 그 러니까 color라는 꼬리표를 이름값 #red에 붙인 다음 바로 그 꼬리표의 이름 을 적어 주면 글토막의 결과값은 당연히 이름값 #red일 것입니다. 그런데 이 상태에서 <바탕글 8> ---------------------------------------------------------- | color | color [실행 결과] nil ---------------------------------------------------------- <바탕글 8>을 실행하면 그 결과로 nil이 나타납니다. 보다 시피 Smalltalk는 <바탕글 7>에서 color 꼬리표를 분명히 이름값 #red 에 붙였지만, <바탕글 8>의 color에는 nil이 붙어 있습니다. 그러니까 <바탕 글 7>과 <바탕글 8>에는 똑같이 color라는 이름을 가진 꼬리표가 있었지만, 그 둘은 전혀 다른 꼬리표라는 것입니다. 왜냐하면 <바탕글 8>이 실행되기 전에 <바탕글 7>의 실행이 끝났을 것이고, <바탕글 7>의 color 역시 바탕글 의 실행이 끝남과 동시에 소멸해 버렸기 때문입니다. 이제는 왜 작은 꼬리표 를 "하루살이 꼬리표"라던가 "잠깐 꼬리표"라고 일컫게 되었는지 이해가 되 시나요? 작은 꼬리표의 이러한 특성으로 인해, 작은 꼬리표는 주로 바탕글에서 여러 가지 계산을 하여 그 결과로 얻은 객체를 붙잡아 매어두고 나중에 필요할 때 쓰기 위한 목적으로 사용됩니다. 어차피 바탕글 안에서만 의미를 가지는 꼬 리표이기 때문에 바탕글 밖의 상황에 신경을 쓸 필요가 없는 것입니다. 앞으 로 여러분이 많은 프로그램을 작성하게 되면 약방의 감초처럼 등장하는 작은 꼬리표의 활약을 지켜볼 수 있을 것입니다. 3.2.4. 붙임표에 대하여 ---------------------- 큰 꼬리표에 대해서 알아보기 전에 잠시 붙임표에 대한 몇 가지 특징을 짚고 넘어가기로 합시다. 붙임표(:=)는 생각보다 꽤 독특한 특성을 가지고 있으 며, 이런 특성들은 우리가 바탕글을 쓸 때 알고 있어야 할 것들이라고 생각 합니다. 붙임표는 크게 두 가지 성질을 가지고 있습니다. 1. 오른쪽에 있는 식을 모두 가늠하여 그 결과에 왼쪽 꼬리표를 붙인다. 2. 꼬리표를 붙인 객체 자체를 결과값으로 넘겨준다. "1"의 경우에는 어렵지 않게 이해할 수 있을 것입니다. 그러나 "2"의 경우는 선뜻 이해가 되지 않을 것입니다. "2"번과 같은 특성을 이용한 바탕글을 보 는 것이 더 쉬울 지도 모르겠군요. 앞서 <바탕글 3>과 같은 일을 하지만 붙 임표의 두 번째 특성을 이용한 바탕글을 아래에 제시하겠습니다. <바탕글 9> 기온 평균 구하기 (붙임표 특성 사용) ---------------------------------------------------------- | temperatureToday temperatureYesterday | Transcript nextPutAll: '오늘의 기온은 '. (temperatureToday := 32) printOn: Transcript. Transcript nextPutAll: '도이며, 어제의 기온은 '. (temperatureYesterday := 28) printOn: Transcript. Transcript nextPutAll: '도 입니다.'; cr. Transcript nextPutAll: '오늘과 어제의 기온 평균은 '. (temperatureToday + temperatureYesterday) / 2 printOn: Transcript. Transcript nextPutAll: '도 입니다.'; cr. ---------------------------------------------------------- 위의 바탕글이 <바탕글 3>과 어떻게 다른지를 비교해 보십시오. 일단 | temperatureToday temperatureYesterday | 꼬리표가 세 개에서 두 개로 줄었습니다. 그리고 다른 곳은 크게 바뀌지 않 았지만 아래와 같은 모양의 문장이 있습니다. (temperatureToday := 32) printOn: Transcript. 위와 같이 바탕글을 쓸 수 있는 것은 바로 붙임표의 두 번째 특성 때문입니 다. 오랜만에 글토막이 가늠되는 과정을 따라가 볼까~~요? (temperatureToday := 32) printOn: Transcript. ~~~~~~~~~~~~~~~~~~~~~~~ → 32 printOn: Transcript. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 결국 temperatureToday는 32에 붙여지고, 그 결과로 32를 되돌리게 됩니다. 마침내 우리의 자랑스런(?) #printOn: 지시는 바로 방금 붙여진 32 객체에게 전달되어 알림판에 "32"를 뿌리게 되는 것입니다. 물론 이는 temperature Yesterday에서도 마찬가지입니다. 이렇게 붙임표를 사용하여 어떤 객체에게 꼬리표를 붙이면 그 결과값으로 꼬 리표가 붙은 객체를 다시 되돌려 준다는 것은 바탕글을 매우 간결하게 짤 수 있도록 도와줍니다. 꼬리표에 객체를 붙인 다음 계산을 수행하는 것이 아니 라 꼬리표를 붙임과 동시에 그 값을 이용하여 계산을 하게 되면 두 줄 짜리 문장을 한 줄로 줄일 수 있지 않겠습니까? 물론 이런 방법을 사용해서 작성 한 바탕글의 경우 간결하기는 하지만 바탕글을 읽기가 어려워진다는 문제점 또한 가지고 있습니다. 붙임표에 객체를 붙이면 붙인 객체를 그대로 돌려준다는 이 특성을 사용하여 다음과 같은 글토막을 생각할 수 있습니다. 아래 글토막을 펴 봅시다. | sonAge fatherAge | fatherAge := 25 + sonAge := 10. ☞ "UndefinedObject does not understand #addToInteger:" 발생. 위의 글토막을 가늠해 보면 잘못이 생깁니다. UndefinedObject의 실체는 #addToInteger:라는 지시를 이해할 수 없다는 말인데, 왜 저런 잘못이 일어 났을까요? 역시 바탕글을 추적해 가면서 문제를 알아보도록 합시다. fatherAge := 25 + sonAge := 10. ~~~~~~~~~~~ 여기서는 붙임표가 있으므로, 일단 붙임표의 오른쪽에 있는 계산식을 먼저 가늠합니다. 따라서 붙임표 왼쪽에 있는 fatherAge 꼬리표에 대해서는 아직 신경을 쓰지 않아도 됩니다. 위에서 보는 바와 같이 먼저 "25 + sonAge"가 가늠됩니다. 그런데... 지금 sonAge는 어떤 객체에 붙어있습니까? 위의 글토막을 보게 되면, sonAge가 10 에 붙는 것은 이 다음의 일입니다. 즉 아직 sonAge는 그 어떤 객체에도 붙지 않았습니다. 결과적으로 sonAge는 nil을 가리키고 있을 것입니다. 네, 그것 이 답입니다. nil은 바로 UndefinedObject 갈래의 실체입니다. 즉 nil은 #addToInteger:라는 지시를 이해할 수 없다는 말입니다. 우리가 직접 nil에 #addToInteger:라는 지시를 내려주지는 않았지만, #+ 지시가 수행되면서 발 생한 것입니다. 아무튼 nil은 덧셈을 할 수 없기 때문에 문제가 생긴 것이 고, 결국 이 문제는 sonAge에 아무런 값이 들어가 있지 않은 상태에서 글토 막을 실행하려고 헀기 때문입니다. 그럼 위의 문제를 어떻게 고칠 수 있을까요? 네, 바로 괄호를 사용하면 됩니 다. 글토막이 가늠되는 순서만 바꾸어주면 아무런 문제도 생기지 않는 것입 니다. 이렇게 말입니다. | sonAge fatherAge | fatherAge := 25 + (sonAge := 10). ☞ 35 이렇게 하면 먼저 sonAge 꼬리표가 10에 붙게 되고, 이 결과로 나오게 된 10 과 + 왼쪽의 25가 더해져서, 결국 fatherAge는 35에 붙게 되는 것입니다. 붙임표를 사용한 다음에는 언제든지 꼬리표가 붙은 객체의 값이 그대로 전달 된다는 이런 특성은 다음과 같은 바탕글을 만들어낼 수 있게 합니다. | a b | a := (b := 10). ☞ 10 위의 경우 b를 10에 붙이게 되면 결과값으로 당연히 10이 남게 되고 결과적 으로 a도 10에 붙게 되는 것입니다. 즉 b와 a는 똑같이 10에 붙어있게 되는 것입니다. 그런데 위의 글토막을 아래처럼 쓸 수도 있습니다. | a b | a := b := 10. ☞ 10 Smalltalk에서 글토막은 언제너 왼쪽에서 오른쪽으로 가늠된다고 앞에서 이 야기한 적이 있습니다. 그러나 붙임표에 대해서만은 예외가 적용됩니다. 왜 그럴까요? 그것은 바로 붙임표의 특성이기 때문입니다. 붙임표는 언제나 := __오른쪽__에 있는 계산식을 먼저 가늠해야 합니다. 즉 a := b := 10. 의 경우 첫 번째 붙임표를 가늠하기 위해서는 먼저 "b := 10"을 가늠해야 합 니다. 따라서 결과적으로 "붙임표가 여러 개 있을 경우는 오른쪽에서부터 먼저 처리한다." 라는 규칙이 생기게 된 것입니다. 명심하십시오. 붙임표는 언제나 오른쪽에 서 왼쪽으로 처리됩니다. 따라서 다음과 같은 글토막도 당연히 쓸 수 있습니 다. | a b c d e f g | a := b := c := d := e := f := g := 0. 이는 a, b, c, d, e, f, g의 일곱 개의 꼬리표를 전부 객체 "0"에 붙이는 역 할을 합니다. 이처럼 붙임표가 나란히 있을 때에는 가장 오른쪽에 있는 것부 터 처리합니다. 그럼 이제 마지막으로 붙임표에 대해서 조금 어려운 부분을 이야기할까 합니 다. 바로 붙임표의 본질에 대한 것입니다. 우리는 지금까지 여러 가지의 글토막을 가늠하면서 "+"는 덧셈을 하기 위한 연산자이면서 동시에 지시에 사용되는 길표(selector)라는 것을 알고 있습니 다. 만일 우리가 다음과 같은 글토막을 지었다면 | smallInteger largeInteger | smallInteger := 1. largeInteger := 10000000000. smallInteger + largeInteger. ☞ 10000000001 "+ 10000000000"이라는 지시는 결국 "1"에 보내지게 됩니다. "1"은 "+"를 보 고는 "덧셈을 해야겠다"고 생각하고, 뒤에 인자로 따라오는 "10000000000"을 가지고 덧셈을 하게 되는 것입니다. 그래서 결과로 "10000000001"을 남기는 것이구요. 그런데 말일... | smallInteger largeInteger | smallInteger := 1. largeInteger := 10000000000. smallInteger := largeInteger. 위와 같은 글토막이 있다고 생각해 봅시다. 여기서 달라진 것은 맨 마지막 줄에 "+"가 있어야 할 자리에 ":="이 있다는 것입니다. 그러면 위의 글토막 에서 ":= largeInteger"라는 지시가 "smallInteger"에 보내지게 되는 것일까 요? 즉 ":= 10000000000"이 "1"에게 보내지게 될까요? 단도직입적으로 물어 서, ":="은 지시를 나타내는 길표일까요? ":="이 길표인지 아닌지에 대해서 알아내려면 약간의 생각이 필요합니다. 만 약에 ":="이 길표라면, 즉 객체 "1"에 ":= 10000000000"이 지시로써 내려지 게 된다면, smallInteger 꼬리표에 영향을 주지 말아야 합니다. 그러나 분명 히 ":=" 왼쪽에 있는 smallInteger 꼬리표는 바뀌고 맙니다. 즉 ":= 10000000000"이라는 지시는 결코 "1"에게 보내질 수 없습니다. 왜냐하면 붙 임표에서 중요하게 여기는 것은 smallInteger가 붙어있는 객체 "1"이 아니라 "smallInteger" 자체이기 때문입니다. 따라서 ":="은 분명히 "+"와는 다른 동작을 합니다. 그 어떤 지시라도 지시를 받은 객체 자체를 __깡그리__ 다른 객체로 바꿔칠 수는 없습니다. 이는 하극상이지요! 또 하나, ":="이 만약 "+"와 같이 길표라면, 어떤 객체라도 ":="이라는 지시 를 받을 수 있어야 합니다. 그런데. ":=" 왼쪽에는 반드시 꼬리표만 와야 합 니다. 따라서 ":="은 길표가 아닙니다. ":=은 길표가 아니라 특별한 동작을 하는 연산자이다." 만약 ":="이 지시라면 ":=" 왼쪽에는 어떠한 객체가 와도 상관이 없어야 합 니다. 그러나 ":=" 왼쪽에는 오직 꼬리표만 와야 합니다. ---<잠깐!>---------------------------------------------------------- Dolphin Smalltalk에서의 ":=" Smalltalk의 붙임표를 문법적으로 살펴보면 당연히 위와 같이 동작해야 합니 다. 그런데 Dolphin Smalltalk의 경우는 조금 이상하게 동작합니다. 3 := 4. 와 같이 명령하면 엉뚱하게도 "SmallInteger does not understand #:="라는 잘못이 발생합니다. 이는 무엇을 말합니까? 비록 위의 글토막이 실행되지는 않지만 문법적으로 Dolphin Smalltalk가 ":="을 길표로 해석했다는 이야기입 니다. 문법 돋이를 보면 ":="가 길표를 나타내는 푸른색으로 바뀌어 있음을 알 수 있습니다. 그리고 false := 3. ☞ 3 위의 글토막은 아무런 이상 없이 제대로 가늠되고, 결과값으로 "3"이라는 값 까지 나왔습니다. 헉! 이럴 수가! 그렇지만 더 이상한 것은 false ☞ false 라는 것입니다. 이는 Dolphin Smalltalk를 제작한 Object Arts사에서 문법적 으로 조금 혼동을 일으켰던지, 아니면 번역기의 벌레라고밖에는 볼 수 없습 니다. 쓰는데 큰 문제는 없다고 하지만, 아주 기본적인 문법 사항이 적용되 지 않으니 좀 찜찜한 기분은 어찌할 수 없군요. 물론 프로그램을 작성하는데 에는 별반 문제가 되지는 않습니다. 아무튼 문법적으로 볼 때 ":="은 절대로 길표로 사용될 수 없습니다. 다만 객체에 꼬리표를 붙이기 위한 목적에만 사용할 수 있는 붙임표라는 것만 기 억해 두시기 바랍니다. ---------------------------------------------------------- 계속... 제 목:[강좌] Smalltalk 배우기 #26 관련자료:없음 [97] 보낸이:김찬홍 (안드래아) 1999-07-21 18:08 조회:106 Smalltalk 배우기 #26 1999. 7. 21. 김찬홍 mailto:andrea92@hitel.net ====================================== 3. 객체로 채워진 세상 3.1. 알아보자, 알림판! 3.2. 꼬리표 인생 3.2.1. 이름이 뭐지? 3.2.2. 바로값과 꼬리표 3.2.3. 작은 꼬리표 3.2.4. 붙임표에 대해서 c→3.2.5. 큰 꼬리표 ..... ======================================= 3. 객체로 채워진 세상 --------------------------- 3.2. 꼬리표 인생 ~~~~~~~~~~~~~~~~ #25에서... 3.2.5. 큰 꼬리표 ---------------- 큰 꼬리표(global variable)는 꼬리표의 이름 첫 글자가 대문자인 꼬리표를 말합니다. 이 꼬리표는 작은 꼬리표와는 좀 다른 특징을 가지고 있습니다. 작은 꼬리표가 바탕글이 실행될 때에만 존재하고 실행이 끝나는 즉시 소멸되 어버리는 것과는 달리 큰 꼬리표는 한 번 만들어 놓으면 사용자가 그 꼬리표 를 없애기 전까지 남아 있습니다. 심지어는 Smalltalk를 끝내고 난 다음 다 른 일을 하나다, 한 일주일 쯤 뒤에 다시 Smalltalk 환경에 들어와도 여전히 살아 있습니다. 대단하지요? 작은 꼬리표를 쓸 때 우리는 언제나 꼬리표를 선언해 주어야 했습니다. 큰 꼬리표도 마찬가지입니다. 큰 꼬리표를 쓰려면 그 전에 "내가 이러이러한 큰 꼬리표를 사용할 것이다"라고 Smalltalk에게 알려주어야 합니다. 그럼 어떻 게 하면 큰 꼬리표를 선언할 수 있을까요? 다음을 보십시오.. Smalltalk at: #MyName put: '김찬홍'. ☞ '김찬홍' 여기서 우리는 Smalltalk라고 하는 새로운 객체를 사용하게 됩니다. 이 객체 에게 #at:put 지시를 내려서 큰 꼬리표를 선언하게 됩니다. 작은 꼬리표의 경우에는 선언만 할 수 있지만, 큰 꼬리표의 경우에는 선언과 함께 그 꼬리 표에 어떤 객체를 붙일지도 정해야 합니다. 위의 글토막에서 "MyName"이라는 새로운 큰 꼬리표를 선언했고, 여기에 '김찬홍'이라는 글줄을 넣었습니다. 이제 일터에서 MyName ☞ '김찬홍' 위의 글토막을 펴보면 '김찬홍'이라는 결과를 얻을 수 있습니다. 즉 큰 꼬리 표 MyName에 붙어 있는 '김찬홍'이라는 객체를 그대로 편 샘이 되는 것입니 다. #at:put:에서 "at:" 열쇠말에는 새로 만들 큰 꼬리표의 이름을 넣어주 고, "put:" 열쇠말에는 만들어지게 될 꼬리표를 붙일 객체를 표시해 줍니다. 조심할 것은, "at:"에 들어가는 큰 꼬리표의 이름 앞에는 반드시 우물 정(#) 표를 붙어야 한다는 것입니다. 이것은 앞서 말했듯이 Smalltalk에서 꼬리표 에 이름을 붙일 때에는 이름값을 사용한다는 것과 일치합니다. 만약 Smalltalk at: MyName put: '김찬홍'. 이라고 하게 되면 위의 문장은 "MyName이라는 꼬리표가 가리키고 있는 객체 를 이름으로 하는 새로운 꼬리표"를 만든다는 것이 됩니다. 그러므로 새로운 큰 꼬리표를 만들 때에는 반드시 이름값을 넣어야 함을 잊지 말도록 합시다. MyName이 꼬리표이기 때문에 언제든지 다른 객체에 바꿔 붙일 수 있습니다. MyName := '홍길동'. ☞ '홍길동' 위와 같이 하면 역시 MyName 꼬리표는 '홍길동'이라는 글줄에 붙게 됩니다. 이것은 작은 꼬리표나 큰 꼬리표나 다를 바가 없는 내용입니다. 앞에서 큰 꼬리표는 Smalltalk를 끝내더라도 없어지지 않는다고 했습니다. 그러면 실험을 해 봅시다. Smalltalk를 지금 당장 끝내십시오. File > Exit Dolphin 메뉴를 사용하여 Smalltalk를 끝냅시다. 그 전에 잠깐!! Smalltalk를 끝낼 때 언제나 "현재의 상태를 본에 저장하겠 느냐"고 물어볼 때 "예"(Yes)로 답해야 합니다. 그렇지 않으면 여러분이 만 들어 놓은 큰 꼬리표를 저장하지 못하게 됩니다. 이제 다시 Dolphin Smalltalk를 실행시켜 봅시다. 그리고 일터에서 MyName ☞ '홍길동' 위의 글토막을 펴 보면 Smalltalk를 끝내기 전에 붙여 두었던 '홍길동'이라 는 객체가 그대로 표시됨을 알 수 있습니다. 즉 MyName은 두 눈 시퍼렇게 뜨 고 살아 있는 것입니다. 이렇게 Smalltalk에 들어 있는 큰 꼬리표는 다름 아닌 Smalltalk의 본 (image)에 그대로 저장됩니다. 우리가 Transcript, SmallInteger, Smalltalk 등의 큰 꼬리표를 언제나 사용할 수 있는 것도, 바로 이렇게 큰 꼬리표와 거 기에 붙어 있는 객체들이 Smalltalk의 본(image)에 그대로 저장되기 때문입 니다. 그렇기 때문에 Smalltalk에서는 큰 꼬리표보다는 작은 꼬리표를 많이 사용합 니다. 대부분의 사람들은 Smalltalk를 쓰다 보면 큰 꼬리표를 써야 할 때는 1년에 몇 번 안 된다고 하는 경우도 있습니다. 그만큼 Smalltalk에서는 큰 꼬리표를 만들어 쓰지 않습니다. 왜냐하면 큰 꼬리표보다 더 편리한 방법들 이 많기 때문입니다. 보통 계산의 결과값을 잠시 보관해 두는데는 앞서 말했듯이 작은 꼬리표가 훨씬 편리합니다. 그리고 굳이 큰 꼬리표를 사용하고 싶으면 보통의 큰 꼬리 표가 아닌 "갈래 꼬리표"(class variable)를 사용합니다. 이것은 갈래에 포 장되어 있기 때문에 보통의 큰 꼬리표보다 안전합니다. 아무튼 큰 꼬리표는 되도록 새로 만들어서 사용하지 않는 것이 바람직합니다. 큰 꼬리표는 이렇게 한 번 선언해 주면 사용자가 지우기 전까지는 절대로 없 어지지 않습니다. 그러면 이런 큰 꼬리표를 어떻게 지울까요? 어렵지 않습니 다. Smalltalk 객체에게 #removeKey:라는 지시를 내려주면 됩니다. Smalltalk removeKey: #MyName. ☞ '김찬홍' #removeKey: 지시는 MyName이라는 큰 꼬리표를 없애고 난 다음 그 꼬리표에 붙어 있던 객체를 결고값으로 남깁니다. 즉 꼬리표를 떼어 낸 다음 그 꼬리 표가 붙어 있던 객체를 그대로 돌려줍니다. 당연한 말이지만, 이렇게 큰 꼬 리표를 지우고 난 다음에는 그 꼬리ㅍ는 사용할 수 없게 됩니다. MyName ☞ "Error: Undeclared MyName" 발생 위와 같이 없는 꼬리표를 사용하게 된다면 당연히 "선언되지 않은 꼬리표"라 고 Smalltalk가 투덜거릴 것입니다. 그런데 아무리 봐도 큰 꼬리표를 선언하는 것이 너무나 귀찮다고 생각하지 않습니까? 일일이 Smalltalk 객체에게 #at:put: 지시를 내린다는 것도 귀찮 고요. 그래서 Smalltalk에서는 큰 꼬리표를 선언할 수 있는 또 다른 방법을 준비해 놓고 있습니다. 자, 이미 앞에서 MyName이라는 큰 꼬리표를 지웠습니다. (지우지 않았다면 위에 있는 글토막을 가늠해서 지워주십시오.) 그 상태에서 아래의 글토막을 입력해 봅시다. MyName := '김찬홍'. 그러면 다음 <그림 3-6>처럼 MyName을 큰 꼬리표로 만들 것인지를 붇는 대화 상자가 표시됩니다. <그림 3-6> 큰 꼬리료를 만들지 물어보는 모습 (Stp3-6.gif) 즉 MyName이라는 꼬리표에 어떤 객체를 붙이려고 하는데, Smalltalk에는 현 재 해당하는 꼬리표가 없고, 따라서 사용자에게 이 꼬리표를 만들 것인지를 물어보고 있습니다. 여기서 "예"(Yes)라고 답하면 MyName이라는 꼬리표를 만든 다음 여기에 '김 찬홍'을 붙이게 되고, "아니오"(Mo)나 "취소"(Cancel)를 선택하면 MyName은 존재하지 않는 꼬리표가 되어 "Error: Undeclared MyName"이라는 잘못을 일 으키게 됩니다. 즉 사용자의 선택에 따라서 위의 글토막이 실행될 수도 있 고, 잘못을 일으킬 수도 있는 것입니다. 그렇다면 왜 큰 꼬리표를 만들 때 일일이 사용자의 확인 과정을 거치게 했을 까요? 그것은 앞서도 말했듯이, 큰 꼬리표는 한 번 만들어지면 고의로 지우 기 전까지는 그 내용이 보존되어 있고, 또한 프로그래머가 원래는 작은 꼬리 표를 만들도록 했는데 실수로 꼬리표 이름 첫 글자를 대문자로 적을 수도 있 기 때문입니다. 아무튼 보통은 Smalltalk 객체에게 #at:put: 지시를 이용해서 꼬리표를 선언 하는 것이 정석이고, 그것을 간단하게 하기 위해서 붙임표를 바로 사용할 수 있는 선택적 선언 방법이 있다는 것을 알아두면 좋겠습니다. 그런데 우리가 큰 꼬리표를 만들고 지울 때 사용헀던 Smalltalk 객체를 잠시 생각해 봅시다. 도대체 이 객체가 무엇이기에 우리가 큰 꼬리표를 만들 때 이 객체에게 지시를 내렸을까요? 다음과 같이 해서 Smalltalk 객체가 어떤 것인지 알아봅시다. Smalltalk ☞ a SystemDictionary(#MourningWeakArray -> MourningWeakArray #STBFiler -> STBFiler ... 하략) Smalltalk 객체는 SystemDictionary 갈래의 실체입니다. SystemDictionary는 Smalltalk의 모듬(collection)의 한 종류로써, 사전(Dictionary)를 윗갈래로 하고 있습니다. 사전에는 보통 올림말(표제어, keyword)과 그 올림말을 설명 해 주는 내용(value)이 들어 있는데, SystemDictionary도 이런 역할을 합니 다. 아무튼 나중에 모듬을 공부하게 될 때 이 Dictionary에 대해서도 함께 알아보게 될 터인데, 아무튼 지금으로써는 Smalltalk를 펴 보는 것만으로 도 저히 어떤 값이 들어있는지 알기가 어렵습니다. 아무래도 객체 탐색기를 이 용해야 할 것 같습니다. <그림 3-7> Smalltalk 객체를 탐색하는 모습 (Stp3-7.gif) 탐색기의 왼쪽 널을 가만히 살펴봅시다. 뭔가 눈에 익은 것들이 보이지 않습 니까? Array부터 시작해서 ArrayedCollection, Boolean, Dictionary,... 어 라? False, Float, Integer, Magitude, Number까지? MyName도 보이는군요. 방금 우리가 만들어 두었던 큰 꼬리표인데... SmalltInteger도 있군요. 그리 고 Smalltalk까지? 어허~ 더구나 Transcript도 있습니다. 이제 Smalltalk 객체의 실체를 알았습니까? 바로 이 객체는 Smalltalk에 존 재하는 모든 큰 꼬리표를 담아두고 관리하는 곳입니다. 물론 Smalltalk 객체 는 이것 말고도 다른 중요한 일들을 하지만, 아무튼 객체 탐색기를 통하여 살펴본 결과로 우리가 사용하는 모든 꼬리표가 여기에 다 들어가 있게 되는 것입니다. 따라서 우리들이 Smalltalk 객체에게 #at:put을 이용해서 새로운 항목을 만들어 주면 역시 그 항목이 큰 꼬리표가 되는 것이고, #removeKey: 를 통하여 어떤 항목을 지우게 되면 큰 꼬리표 역시 따라서 없어져 버리는 것입니다. 신기하지 않습니까? 자, 그럼 이제 한 가지 재미있는 실험을 해 봅시다. 일단 이 실험을 하기 전 에 "File > Save Image"를 사용해서 현재의 상태를 본에 받아 두십시오. 그 렇지 않으면 크게 후회할지도.... 준비가 되었으면 다음 글토막을 가늠해 봅시다. Processor := nil. Processor 역시 큰 꼬리표인데, Smalltalk에서 명령 수행을 처리하는 중요한 객체가 이 꼬리표에 붙어 있습니다. Processor는 컴퓨터의 CPU와도 같은 중 요한 꼬리표인데... 위와 같이 이 꼬리표를 허망하게 nil에 붙여버리면 Smalltalk는 그 즉시 다운 되어버리고 맙니다. 정말 허망하게 말입니다... 이처럼 Smalltalk에서 이미 사용하고 있는 큰 꼬리표에 다른 객체를 붙이는 것은 매우 위험합니다. 그러므로 큰 꼬리표를 사용할 때에는 세심한 주의가 필요합니다. ---<잠깐!>---------------------------------------------------------- 변수라고 해야 옳다! 꼬리표? 말도 안돼! 프로그래밍 언어를 한 번이라도 접해본 분들이 이 글을 읽으면서 아마 몇몇 분은 저를 많이 비난하셨을 지도 모른다고 생각하니 등골이 오싹합니다. 그 것은 바로 "꼬리표"라는 말 때문입니다. Smalltalk에서는 variables이라고 부릅니다. 엄밀히 말하면 이는 "변수"가 맞습니다. 그러나 소위 다른 프로그래밍 언어에서 쓰는 "변수"와 Smalltalk 의 "variable"과는 너무너무 다른 개념이 흐르고 있습니다. 보통 다른 언어 에서는 "변수"를 "방"이라고 생각합니다. 그래서 "변수 a에 3을 넣는다"라는 말을 곧잘 합니다. 그러나 Smalltalk에서의 variable은 방이 아닙니다. Smalltalk의 variable은 철저히 다른 객체를 가리키고 있습니다. 이런 개념 이 달라지는 이유는 바로 "값 의미"와 "가리킴 의미"의 차이 때문입니다. "값 의미"(value semantic)란 어떤 값이 변수에 대입될 때 그 "값" 자체가 이동하는 것으로 봅니다. 즉 a := 3; 이라는 문장이 수행되면 3이라고 하는 값이 a라는 방 안에 들어가 있다는 생 각입니다. 이것은 결국 값 자체가 이동한다는 것을 말해주고 있습니다. "가리킴 의미"(reference semantic)는 반면에 어떤 값이 변수에 대입될 때 해당하는 값 자체가 움직이는 것이 아니라 다만 변수가 값을 가리키는 바늘 과 같은 의미를 지니고 있습니다. 따라서 a := 3. 이라고 명령했을 때 이는 "a라는 변수는 3을 가리킨다"고 보면 됩니다. 바꾸 어 말하면 "a라는 변수가 3이라는 값에 붙어 있다"고 표현할 수 있습니다. 즉 "3"이라고 하는 값이 이동하는 것이 아니라는 것입니다. Smalltalk에서의 variable은 이러한 "가리킴 의미"를 가지고 있습니다. 그래 서 variable을 "변수"가 아니라 "꼬리표"라고 부른 것입니다. 우리는 지나칠 정도로 값 의미에 익숙해져 있습니다. 그래서 저는 처음부터 값 의미가 아닌 가리킴 의미를 제대로 전달하기 위해서 "꼬리표"라는 말을 사용했습니다. 즉 꼬리표를 어떤 객체에게 붙여서 그 꼬리표가 객체를 가리키게 하는 의미를 나타내려고 한 것입니다. 값 의미와 가리킴 의미를 아직까지 제대로 파악하지 못하신 분이 있는 것 같 은데, 다음의 글토막을 살펴봅시다. | a b | a := #(1 2 3). b := a. b at: 1 put: 1000. a. 위의 글토막을 펴 보면 결과값으로 무엇이 나오겠습니까? 바로 #(1000 2 3) 이라는 결과가 나옵니다. 분명 글토막의 끝에는 a가 기록되어 있습니다. 그 러므로 꼬리표 a는 #(1000 2 3)에 붙어있다는 말입니다. a := #(1 2 3). 의 경우에는 물론 여지 없이 a라는 꼬리표를 #(1 2 3)이라는 배열에 붙인 것 입니다. 그 다음 b := a. 라고 헀습니다. 문제는 여기서부터 비롯됩니다. 만일 위의 문장을 값 의미로 해석한다면 b와 a는 서로 다른 객체여야 합니다. 즉 a의 값이 그대로 b에 전 해지는 것입니다. 다시 말하면 a의 값이 그대로 b로 복사되는 것입니다. 그 러나 Smalltalk의 꼬리표는 철저히 가리킴 의미를 지킵니다. 즉 위의 경우 b 는 a가 가리키는 객체를 가리킵니다. 여기서 절대로 b를 위해서 새로운 객체 가 만들어지지 않습니다. 이것은 바로 다음에서 여실히 드러납니다. b at: 1 put: 1000. b는 현재 #(1 2 3)이 들어있는 배열이고, 여기에 #at:put: 지시를 내려서 배 열 성분의 값을 바꿀 수 있습니다. 그런데 만약 값 의미였다면, a와 b는 전 혀 다른 객체이므로 b를 아무리 바꾸어도 a에는 아무런 영향이 없어야 합니 다. 그러나 a. 위의 경우 #(1000 2 3)이라는 결과를 얻고 말았습니다. 즉 b를 바꾸었는데 왜 a의 값이 바뀌느냐 이겁니다. 바로 이것이 가리킴 의미의 특성을 전적으 로 나타내어 주는 예제입니다. b := a. 는 "a 꼬리표가 붙어 있는 객체에 b라는 꼬리표를 붙인다"라고 해석하면 이 해하기가 쉽습니다. 즉 하나의 객체에 a라는 꼬리표도 붙이고, b라는 꼬리표 도 붙입니다. 결국 부르는 이름만 다르지 a라고 부르건 b라고 부르건 결국 똑같이 #(1 2 3)을 부르게 되는 것이고 b가 붙어있는 객체에 어떤 지시를 내 린다는 것은 결국 a에 붙어 있는 객체에게 지시를 내린다는 것과 다를 바 없 는 것입니다. 그래서 a의 값이 바뀌게 되는 것입니다. 그러면 다른 언어들에서는 값 의미와 가리킴 의미를 어떻게 사용하고 있는지 알아봅시다. <베이식> 베이식의 경우에는 변수에 어떤 값을 대입할 때에는 언제나 값 의미가 적용 됩니다. Visual Basic의 경우에는 함수나 절차의 형식 인자에 실인자를 대입 할 때에는 특별한 지시가 없는 이상 가리킴 의미가 적용지만, ByVal을 이용 해서 값 의미라고 명시해줄 수 있습니다. 그렇지만 Basic에서는 원칙적으로 포인터가 없기 때문에 가리킴 의미를 구현할 수 없습니다. C에서는 모든 것이 값 의미로만 전달됩니다. 변수를 대입할 때도 그렇고, 함 수의 실인자가 형식인자에 대입될 때에도 마찬가지로 값 의미가 부여됩니다. 그러나 포인터를 사용해서 가리킴 의미를 구현할 수는 있습니다. C언어에서 포인터가 왜 그렇게 중요한 위치를 차지하게 되었는가 하면, 바로 가리킴 의 미를 구현하기 위해서인 것입니다. 실제로 프로그래밍에서는 값 의미보다는 가리킴 의미가 더 효율적이고 더 자주 사용됩니다. C의 배열이 함수에 전달 될 때에는 언제나 포인터로써 전달됩니다. 그러므로 C에서의 배열 변수는 가 리킴 의미가 어느 정도 적용된다 하겠습니다. 그러나 이는 값 의미밖에 부여 되지 않은 언어에서 가리킴 의미를 구현하기 위한 하나의 술수에 불과합니 다. C에 가리킴 의미를 적용하지 않았기 때문에 발생하는 문제점을 해결하기 위 해서 C++에서는 '참조자'(reference)를 만들었습니다. 이 참조자를 이용하면 비로소 가리킴 의미를 부여할 수 있습니다. 함수의 실인자를 형식인자에 전 달할 때는 물론 하나의 변수에 참조자를 사용하여 다른 이름을 부여할 수 있 습니다. 즉 꼬리표를 만들 수 있는 것입니다. 그러나 C++의 참조자는 매우 제한적이고, 프로그램의 실행 중에 자유롭게 참조자의 값을 바꿀 수는 없습 니다. 즉 한 번 꼬리표가 붙으면 다른 대상물에 꼬리표를 바꾸어 붙일 수 없 습니다. 또한 이런 참조자가 있다고는 하지만 class에서 생성한 객체의 경우 에는 여전히 포인터에 의해서만 가리킴 의미를 구현할 수밖에 없고, 설상가 상으로 참조자가 쓰이고 쓰이지 않음에 따라 똑같이 보이는 문장이라도 어떨 때에는 값 의미가, 또 다른 경우에는 가리킴 의미가 부여되어 매우 혼란스럽 습니다. 여기에 한 술 더 떠서 "="이라고 하는 대입 연산자의 행동을 사용자 가 마음대로 바꿀 수 있기 때문에, 값 의미와 가리킴 의미가 언제 어느 때 적용되는지에 대한 규칙이 없게 됩니다. 그야말로 기름에 불을 지른 격이나 마찬가지입니다. 따라서 왠만하면 C++를 쓰는 사람들도 참조자 쓰기를 기피 합니다. 차라리 조금 위험 부담이 있기는 하지만 포인터를 사용해서 일관되 게 가리킴 의미를 표현해 내는 것이 더욱 일관성 있고 덜 헷갈리기 때문입니 다. → C++언어의 문법에 예외가 많고 복잡한 것이 많은 이유가 여기에 있습 니다. 정통 파스칼의 경우 변수를 대입할 때에는 값 의미가 부여되고, 형식 인자에 실인자가 전달될 때에도 값 의미가 부여됩니다. 다만 형식 인자를 선언할 때 "var"이라는 지정어를 사용해서 값 의미를 적용시킬 수 있습니다. 그러나 이 는 매우 제한적입니다. 객체 파스칼의 경우는 이러한 전통적인 파스칼의 속성을 그대로 물려받습니 다. 여기에 객체를 다룰 때에는 값 의미가 아닌 가리킴 의미가 적용됩니다. 즉 같은 대입문이라도 a := 3; 의 경우에는 값 의미가 적용되고 a := TButton.Create(Self); b := a; 등과 같이 객체를 다룰 때에는 가리킴 의미가 사용됩니다. 따라서 사용자는 객체를 다루고 있는지 그렇지 않은지를 제대로 파악해서 값 의미가 적용되는 지 아니면 가리킴 의미가 적용되는지를 명확하게 꿰뚫고 있어야 합니다. 그 리고 Delphi 2.0부터 등장한 '긴 문자열'(long string)과 Delphi 4.0부터 등 장한 동적 배열(dynamic array) 역시 가리킴 의미를 가지고 있습니다. 논리 적이고 명확한 파스칼 문법을 흩어놓는 주된 원인이 객체 파스칼에서의 "객 체"라니, 아이러니하지 않습니까? Java의 경우도 객체 파스칼과 별반 다르지 않습니다. Java에서는 자료형이 크게 두 부류로 나누어지는데 하나는 "원시형"(primitive type)이라 하고, 다른 하나는 "객체형"(object type)이라 합니다. 원시형의 경우 철저히 값 의미가 적용되고 객체형의 경우에는 가리킴 의미가 적용됩니다. 함수에 실인 자를전달할 때에도 원시형의 경우는 언제나 값 의미가 적용되고, 객체형의 경우에는 언제나 예외없이 가리킴 의미가 부여됩니다. 객체 파스칼에서처럼 원시형의 경우에 가리킴 의미로 인자를 전달할 수 없습니다. 이제 우리가 공부하고 있는 Smalltalk를 살펴봅시다. Smalltalk에서는 모든 대입문이 가리킴 의미를 가지고 있습니다. "3", "4" 등과 같은 경우도 물론 똑같은 의미가 부여됩니다. 길수(method: 다른 언어에서의 함수나 절차와 같 음)의 인자를 전달할 때에도 어김없이 가리킴 의미를 사용합니다. 그 어디에 도 값 의미를 사용하는 법이 없습니다. 따라서 Smalltalk는 C언어와는 반대 로 값 의미를 구현하기 위한 지시를 가지고 있습니다. 이를테면 위에서 예 로 들었던 글토막을 조금만 고쳐서 | a b | a := #(1 2 3). b := a copy. "객체의 복사본 생성" b at: 1 put: 1000. a. 이와 같이 바꾸게 되면 a와 b는 서로 영향을 받지 않는 완전히 다른 값을 가 지게 됩니다. 즉 명시적으로 b가 붙어 있는 것은 a가 붙어있는 객체가 아니 라 b의 복사본입니다. 어떤 객체에게 #copy 지시를 내리면 해당 객체와 똑같 은 값을 가진 객체를 하나 더 만들어 내는, 즉 지시를 받은 객체의 복사본을 만들어 냅니다. 따라서 b를 아무리 건드려도 a에는 영향을 미칠 수 없게 되 는 것입니다. 즉 명시적으로 값 의미를 구현한 것입니다. 결론적으로 Smalltalk에는 일관된 철학이 있습니다. 상황에 따라서 이렇게 바뀌고 저렇게 바뀌는 것이 아니라 언제나 일관된 철학과 통일된 개념이 흐 르고 있으며, 이 개념 위에서 문법이 규정됩니다. Smalltalk에서는 언제나 가리킴 의미를 사용합니다. 이는 정말 탁월한 선택이라고 할 수 있습니다. 값 의미는 변수에 따라서 값이 이리 갔다가 저리 갔다가 하지만, 가리킴 의 미에서는 객체는 가만히 있고 여기에 꼬리표가 붙듯이 변수가 붙어서 명령을 수행합니다. 정말 이 하나의 상황만을 보아도 모든 것을 객체 중심적으로 (Object Oriented) 생각하는 객체 지향 철학이 베어나지 않습니까? 자, 이제 왜 필자가 "variable"을 "변수"라고 번역하지 않고 "꼬리표"라고 번역했는지 이해하실 수 있습니까? 앞으로 이 글에서는 계속 "꼬리표"라는 말을 사용하겠습니다. 이것이 더 자연스럽습니다. 값 의미와 가리킴 의미, 조금 혼동되는 개념이기는 하지만 Smalltalk에서 "꼬리표"의 존재를 제대로 이해하기 위해서 꼭 필요한 요소라고 생각하십시 오. 그리고 기존 언어에서 사용하고 있던 개념을 Smalltalk에 그대로 적용하 려고 하지 마십시오. 오히려 혼동만 초래할 뿐입니다. Smalltalk를 공부할 때에는 늘 새로운 개념에서 바라보는 습관을 기르십시오. 그래야 제대로 알 수 있습니다. 아무것도 모르는 초등학생이 두 달 만에 Smalltalk 환경에서 헬리콥터 시뮬레이터를 만들었다는 사실을 상기하십시오. 기존에 가지고 있 던 고정 관념은 우리들을 옭아매는 오랏줄이 됩니다. ---------------------------------------------------------- =========================================================== 지금까지 우리는 Smalltalk에서 매우 중요한 개념인 "꼬리표"에 대해서 알아 보았습니다. 꼬리표는 무수히 존재하는 객체들 중에 필요한 곳에 붙여서 객 체가 의미를 갖게 하고, 계산 결과로 남는 객체들에 붙여 두고 나중에 참조 할 수 있도록 하며, 또한 바탕글을 쉽게 읽을 수 있도록 해 줍니다. 아무튼 이러한 꼬리표는 작은 꼬리표와 큰 꼬리표로 나뉘어지게 되고, 각각은 그 쓰 임에 따라서 적절하게 활용해야 합니다. 여기까지 이해했으면 이제 여러분은 Smalltalk의 문법 중에 90%를 익힌 것과 다름이 없습니다. 이제 앞으로 오늘 공부한 꼬리표가 정말 큰 역할을 하게 될 것입니다. 지금까지는 글자들만 가지고 놀았으니 다음 가름에서부터는 그래픽 적인 요 소를 다루어보도록 합시다. 이제 꼬리표를 알았으니, 여차 하면 객체에 꼬리 표를 붙여서 여러분의 것으로 만드시기 바랍니다. 그리고 한 가지 더! 언제 어디서 어떤 일이 발생할 지 모르는 법이므로, Smalltalk를 사용할 때에는 늘 본(image)을 잘 떠 두는 것을 잊지 않도록 합시다. 계속... 제 목:[참고] Objective-C의 개략적 개념 관련자료:없음 [103] 보낸이:김찬홍 (안드래아) 1999-08-03 10:50 조회:239 음, 저도 Objective-C가 구체적으로 어떤 문법을 가지고 있는지는 잘 모 릅니다. 그저 간단하게 제가 알고있는 사항을 정리해드린다면... 우선 Objective-C는 보통 C언어에다가 Smalltalk를 합쳐놓았다고 생각하 면 쉽습니다. 즉 C++는 OOP를 표현하기 위해서 C언어의 문법을 확장했지 만, Objective-C는 C언어의 문법을 거의 그대로 사용하면서 OOP를 표현하 고 싶을 때에는 Smalltalk의 형식을 빌었다고 생각됩니다. 이를태면 if ( [anObject isKindOf: Integer] ) return -1; 뭐 이런 식으로 코드가 적용된다고 알고 있습니다. 즉 C언어식으로 코딩 을 하다가 OOP의 방식을 사용해야 할 경우에는 대괄호[ ] 안에 명령을 적 어주는 식입니다. 흡사 Smalltalk에서 대괄호 안에 명령문을 적어넣어서 덩이(block)를 만드는 것과 같다고 보면 됩니다. 그런데 이 Objective-C는 두 개의 패러다임이 전혀 융화되지 않은 상태이 고, 즉 물과 기름을 섞어놓은 듯한 상태이고, 또한 사용자들은 C라는 철 학과 OOP라는 철학을 함께 익히고 있어야 하므로 문법이 매우 복잡해 진 다는 단점을 가지고 있습니다. 즉 이거면 이거, 저거면 저거가 아니라 물 에 물 탄듯, 술에 술탄듯 하는 형상이라는 것이지요. 뭐 C++도 별반 칭찬해줄 것은 없지만, 그래도 C++는 나름대로 C언어 안에 서 OOP를 표현해보려고 시도를 한 셈이지요. 그러나 Objective-C의 경우 는 그게 그렇지가 않았으니까요. 한 가지 예를 더 들자면, 대괄호 안에서 는 Smalltalk처럼 자료형에 대한 개념이 없으며(즉 변수에 자료형을 지정 하지 않음), 대괄호 밖에서는 C언어처럼 자료형을 따집니다. 아무튼 C++과 맞먹을 정도로 황당한 언어가 Objective-C라고 생각합니다. 제 목:[참고] Objective-C의 셈플코드 관련자료:없음 [104] 보낸이:김찬홍 (안드래아) 1999-08-03 15:52 조회:187 Objective-C의 셈플 소스코드랍니다. 저도 아직 다 이해는 못해봤지만, 도움이 되셨으면 좋겠습니다. http://www.cis.ohio-state.edu/hypertext/faq/usenet/Objective-C/sample/faq.html 의 내용을 발췌한 것입니다. // This is a comment, just like the previous line. Everything to the right // of a double slash is ignored. /* Classes are the one real extension which Objective-C adds to C. A class is a description of a collection of data, like a C structure, and the methods by which that data may be accessed or manipulated. Instances of a class are called objects, and methods are invoked by sending messages to either the class itself, to produce objects, or to those objects. The recipient of a message is called a "receiver". The form of a message is: [receiver method andMaybeSomeArguments] the receiver and method components are mandatory, as are the square brackets surrounding the message. Additional arguments may or may not be present, depending upon the method definition. Messages may appear anywhere a statement is allowed in C. The first thing we do is bring in some include files, as in C. On the NeXT, it is customary to use the "import" statement which guarantees that the file isn't included more than once. Using GNU CC this is not all that nice sinds it generates a huge warning for every file being compiled. So, since it does not really matter, we'll stick to `#include'. */ #import #import #import "Queue.h" #import "Stack.h" /* That brought in class definitions for Objects, Queues, and Stacks. The Object class is the basis for all other classes, which is why it gets brought in first. It provides basic functional behavior which is inherited by all derived classes. All user created classes normally have Object somewhere in their ancestry. Queue and Stack are classes of our own construction, and provide FIFO and LIFO storage capabilities, respectively. I'm not going to go into implementation details here. It's irrelevant how they work, all that is important is that they both respond to 'put:' and 'get'. If you want to inspect them, look into the Queue.m, Stack.m, Queue.h and Stack.h files. A simple Class definition follows. It inherits directly from the base class "Object". This gives it lots of nice properties, not the least of which is the ability to be referenced by any pointer of the generic object type "id". All objects can be pointed to by any id variable, and the default return type from methods is id. This allows messages to be embedded in other messages, either as receivers or arguments. An Int object allocates space for a single integer. The "report" message causes it to report its value. Everything between the @implementation and the @end is part of the class definition. Note - It is *highly* unusual to have a class implementation in your main program. Since the object is fully defined before it gets used, no interface description is required. There is nothing illegal about doing things this way, but it is so unusual that the compiler will produce a warning for this class. The Int class implementation is here solely for expository purposes. */ @implementation Int: Object // Int is derived from Object { int value; // This is the data portion. Like a struct. } /* The following are the method definitions. A `+' prefix means it is a factory method, i.e., how to manufacture instances of the class. The body of the method is between braces, like a C function. This class doesn't define any factory methods. It relies on the +alloc method defined in class Object. For examples of factory methods, look at the +new method defined in the Stack or Queue implementations. Self is a special variable, which refers to the object currently being manipulated. Super refers to the parent class of self. The following method asks the parent class (Object) to hand us a new instance, which becomes self. Then we update the instance variables and return a pointer to the new object. It is standard for methods that do not need to return any special value to instead return self. This allows for a nested syntax of method calls. The "-" in front of init means that it's an instance method, i.e., something a particular object should respond to. */ -init: (int) i { /* Have our superclass initialize its part of us. After that, initialize the part of us introduced by this class (Int). */ [super init]; value = i; return self; } -report { printf ("%4d", value); return self; } @end /* We have implemented Float and Char classes more traditionally, using separate files for the interface (.h) and implementation (.m). The Float and Char objects are like the Int object, but with the obvious difference that they work with floats and characters. We include the interface definitions at this point. */ #import "Float.h" #import "Char.h" /* If you inspect those files, note polymorphism -- methods have same names as in the Int class. */ int main (void) { /* First create instances of "Stack" and "Queue" data structures. */ id queue = [[Queue alloc] init]; id stack = [[Stack alloc] init]; int i, reply; fprintf (stderr, "Include the Char class in the demo? (y/n): "); /* Anything not matching `y.*' means no. */ reply = getchar (); for (i = 5; i > -6; --i) { /* Depending on which version of the demo we're running, we alternately put Ints and Floats onto the queue and stack, or Ints, Floats, and Chars. */ if (reply == 'y') { /* If I is odd we put an Int on the queue and a Char on the stack. If I is even we put an Char on the queue and a Float on the stack. Since there is more than one method `-init:' and since `+alloc' returns a plain, typeless, `id', the compiler doesn't know the type of the object returned by alloc. An explicit cast (i.e. static type indication) ensures that the compiler knows which `init:' is invoked---the one accepting a char or the other one accepting an int. Another solution, which avoids the static type indication, is to put typing information on the method in the method's name. This is done for the Float class. */ id my_char = [(Char *) [Char alloc] init: 'm' + i]; if (i & 1) { [queue put: [(Int *) [Int alloc] init: i]]; [stack put: my_char]; } else { [queue put: my_char]; [stack put: [[Float alloc] initFloatValue: i]]; } } else { /* If I is odd we put an Int on the queue and a Float on the stack. If I is even we put a Float on the queue and an Int on the stack. */ [queue put: ((i & 1) ? [(Int *) [Int alloc] init: i] : [[Float alloc] initFloatValue: i])]; [stack put: ((i & 1) ? [[Float alloc] initFloatValue: i] : [(Int*) [Int alloc] init: i])]; } } while ([queue size] && [stack size]) { /* The following illustrates run-time binding. Will report be invoked for a Float object or an Int object? Did the user elect for Char objects at run time? We don't know ahead of time, but with run-time binding and polymorphism it works properly. The burden is on the class implementer rather than the class user. Note that the following lines remain unchanged, whether we are using the Char class or not. The queue and stack hand us the next object, it reports itself regardless of its type, and then it frees itself. */ printf ("queue:"); [[[queue get] report] free]; printf (", stack:"); [[[stack get] report] free]; putchar('\n'); } return 0; } __EOF__ 제 목:[알림] Dolphin Smalltalk 업그레이드 관련자료:없음 [106] 보낸이:김찬홍 (안드래아) 1999-08-16 22:03 조회:137 안녕하세요? 김찬홍 안드레아입니다. Object Arts사가 Dolphin Smalltalk 3.0 정식판을 발표했습니다. 이번에 발표한 3.0은 기존의 개발 환경을 많이 확장해서 좀 더 사용하기 쉽고 강력한 Smalltalk가 되었다고 합니다. 그런데 여기서 반가운 일은, 여태껏 상용으로 판매되던 Dolphin Smalltalk 2.1이 무료로 전환되었다는 사실입니다. 즉 3.0이 발표되면서 2.1은 무료로 되었다는 말입니다. 그래서 여러분들께서도 Dolphin Smalltalk 2.1 무료버전을 다운로드하시라고 권합니다. 이 버전은 1.1에 비해서 여러 가지 향상된 내용을 담고 있고, Smalltalk 표준안에서 권고 하고 있던 '덩이 꼬리표'(block temporary variable)을 지원합니다. 그래서 훨씬 프로그래밍하기가 편리해 졌습니다. 1.1판을 쓰시는 여러분들꼐서는 2.1판을 쓰시기 바랍니다. 2.1판의 개선사항에 대해서는 추후에 게시판에 올려드리도록 하겠습니ㄷ3ㅏ. 그럼 여러분, 안녕히 계십시오. 제 목:[강좌] Smalltalk 배우기 #27 관련자료:없음 [107] 보낸이:김찬홍 (안드래아) 1999-08-26 15:18 조회:125 Smalltalk 배우기 #27 1999. 8. 26. 김찬홍 mailto:andrea92@hitel.net ====================================== 3. 객체로 채워진 세상 3.1. 알아보자, 알림판! 3.2. 꼬리표 인생 3.3. 운동장 놀이 a→3.3.1. 일터 꼬리표 3.3.2. 꾸러미에 대해서 ..... ======================================= 3. 객체로 채워진 세상 --------------------------- 3.3. 운동장 놀이 ~~~~~~~~~~~~~~~~ 바로 앞 가름에서 우리는 객체에게 꼬리표(variable)를 붙이고 그것을 객체 의 이름으로 부르는 법을 알아보았습니다. 이제 이 꼬리표를 사용하게 되면 객체를 만들어서 그것을 헛으로 날려버리지 않아도 된다는 말입니다. 지금까지 우리는 Smalltalk를 "공부"해 왔습니다. 시험을 따로 본다거나 하 는 부담이 없기는 하지만, 그래도 공부를 한다는 것은 힘든 일입니다. 실은 필자도 한 편의 글을 완성하기 위해서는 상당히 많은 생각이 필요합니다. 그 래서 이제 필자도 문자나 숫자만 나오는 그런 것보다는 좀 더 재미있는 그림 을 가지고 놀고 싶어졌습니다. 놀아봅시다. "놀이는 바로 학습이다"라는 말 이 결코 헛된 말이 아니니까요. 우리가 놀 때 주로 운동장에서 놉니다. 공을 가지고 놀건, 몸으로 부대끼는 놀이를 하건 아무튼 운동장이라는 장소에서 마음껏 놉니다. 우리도 비록 공 을 차고 몸을 움직이는 놀이는 아니지만 운동장을 만들어서 놀 것입니다. 열 심히 놀고 있는데 다른 곳에서 방해를 받으면 썩 기쁜 일은 아닐 테니까요. 그런데 Smalltalk에서는 모든 것이...? -이제 여기까지 하면 "또 그 소리 야?"라고 핀잔을 주시겠지만, 아무튼- 네, 그렇습니다. "객체"(object)입니 다. 따라서 우리가 놀아야 할 운동장 역시 Smalltalk에서는 하나의 객체입니 다. 우리는 Smalltalk에서 운동장을 만들고 여기에 동그라미, 세모, 네모와 같은 그림들을 올려놓고 이것들을 가지고 놀 것입니다. 이러한 그림들은 아 이들이나 가지고 노는 것이 아니냐는 분들이 혹시 계실지도 모르겠는데, 여 러분은 적어도 Smalltalk에서는 아직도 아이입니다. 불만 있습니까? :) 아무튼 이번 가름에서는 운동장을 만들고 여기에 여러 가지 도형들을 올려놓 고 놀아볼 것입니다. 그 전에 먼저 일터 꼬리표와 꾸러미에 대해서 알아봅시 다. 아직 우리는 운동장이랑 도형을 어디에서 어떻게 꺼내와야 할지도 모르 기 때문에, 일단 일터 꼬리표와 꾸러미에 대해서 알고 나면 그 다음부터는 정말 재미있게 놀 수 있을 것입니다. 3.3.1. 일터 꼬리표 ------------------ 꼬리표(variables)는 크게 "큰 꼬리표"(global variable)와 "작은 꼬리 표"(local variable)의 두 가지가 있다고 말씀드린 바 있습니다. 그런데 큰 꼬리표와 작은 꼬리표는 또다시 그 특성에 따라 여러 가지로 나누어집니다. 그 중에서 오늘은 "일터 꼬리표"(workspace variable)에 대해서 알아볼까 합 니다. 우선 일터 꼬리표를 어떻게 선언하고 사용하는지 알아봅시다. 일터 꼬리표도 꼬리표의 일종이므로 당연히 꼬리표를 쓰기 전에는 선언을 해야 합니다. 일 터 꼬리표를 선언하는 방법은 아주 간단합니다. 우선 "File > New" 명령을 실행해서 새 일터를 하나 열어봅시다. 이제 당분간은 이렇게 열린 일터에서 작업하도록 합시다. 일터에서 아래 글토막을 펴 보십시오. 일터 꼬리표는 작은 꼬리표의 일종이 므로, 꼬리표 이름의 첫 글자는 반드시 영어 소문자이어야 함을 기억합시다. a := 3. ☞ 3 우리는 지금 "a"라는 꼬리표를 전혀 선언하지 않았습니다. 그저 정수 "3"에 "a"라는 꼬리표를 붙여놓기만 했습니다. 만일 "a"가 작은 꼬리표였다면 분명 히 잘못이 있어야 합니다. 그러나 이렇게 해서 생긴 "a"는 이제 일터 꼬리표 가 된 것입니다. 꼬리표 "a"는 어떤 객체에 붙어있을까요? a ☞ 3 a는 분명히 3에 붙어 있습니다. a가 평범한 작은 꼬리표였다면 글토막의 실 행이 끝났을 때 그 값은 없어져야 옳았습니다. 그러나 지금 a는 당당하게 살 아있고, 3이라는 객체에 붙어있습니다. 이는 우리가 a를 작은 꼬리표가 아닌 일터 꼬리표로 선언했기 때문입니다. 이렇게 일터 꼬리표를 선언하려면, 그냥 평범하게 일터 꼬리표에 객체를 붙 여주기만 하면 됩니다. 큰 꼬리표를 선언할 때 Smalltalk객체에게 #at:put: 지시를 내릴 필요 없이 MyName := '김찬홍'. 이라고만 해도 자동으로 큰 꼬리표가 만들어졌던 것을 기억해 보십시오. 물 론 큰 꼬리표를 만들 때에는 사용자의 확인 과정을 거치지만, 일터 꼬리표의 경우는 그 확인 과정을 생략하고 바로 꼬리표를 만듭니다. 아무튼 이렇게 해서 만들어진 일터 꼬리표는 사용자가 이 꼬리표를 없애기 전까지 그대로 남아 있습니다. 그렇지만 일터 꼬리표는 다른 일터에서는 전 혀 그 존재를 알 수 없습니다. 즉 현재 일터 꼬리표가 선언된 그 일터에서만 의미가 있다는 말입니다. "File > New"를 이용해서 새 일터를 연 다음 아래 글토막을 펴 보십시오. a ☞ "Undeclared a" 잘못 발생 이 일터에서는 "a"라는 꼬리표를 사용하지 않았기 때문에 잘못이 일어난 것 입니다. 이처럼 일터 꼬리표는 그 꼬리표가 만들어진 일터 안에서만 의미가 있습니다. 결과를 확인했다면 바로 전에 열었던 일터는 닫읍시다 그런데 이러한 일터 꼬리표를 쓸 수 없는 곳이 있습니다. 바로 알림판인데, 지금 알림판을 열고 아래의 글토막을 가늠해 보십시오. a := 3. ☞ "Undeclared a" 잘못 발생 알림판에서는 일터 꼬리표를 쓸 수 없습니다. 왜냐하면, 알림판은 그 어떤 경우에도 소멸되지 않는 객체이기 때문입니다. 일터나 객체 탐색기 등은 언 제든지 그 창을 닫아서 없애버릴 수 있지만, 알림판은 절대로 없애버릴 수 없습니다. 왜냐하면 알림판을 닫아 버리면 알림판이 없어지는 것이 아니라 Smalltalk 환경이 종료되기 때문입니다. 따라서 한 번 만들어진 일터 꼬리표 를 지울 방법이 없는 것입니다. 그래서 알림판에서는 일터 꼬리표를 사용할 수 없습니다. 그럼 이러한 일터 꼬리표는 왜 사용하는 것일까요? 그것은 바로 객체의 값을 좀 더 오래 보존해야 할 경우가 있기 때문입니다. 작은 꼬리표의 경우는 글 토막이 가늠될 때에만 의미가 있고 글토막의 실행이 끝나면 그 꼬리표가 없 어지게 됩니다. 그렇다고 큰 꼬리표를 사용하는 것도 바람직하지 않습니다. 왜냐하면 큰 꼬리표는 Smalltalk 환경의 어느 곳에서나 사용해야 하는 중요 한 객체에게만 붙여야 하기 때문입니다. 그래서 작은 꼬리표와 비슷한 성질 을 가지고 있지만, 동시에 큰 꼬리표처럼 한 번 만들어지면 지우기 전 까지 는 없어지지 않게 하기 위해서 일터 꼬리표가 사용됩니다. 그런데 일터 꼬리표와 작은 꼬리표의 이름이 같다면 어떻게 될까요? 지금 우 리가 열어 놓은 일터에는 "a"라는 이름의 일터 꼬리표가 있으며, 3이라는 객 체에 붙어 있습니다. 그런데 이 상태에서 아래의 글토막을 가늠해 보십시오. | a | a := 3 + 4. ☞ "Cannot redefine shared variable a" 잘못 발생 위에서는 a라는 이름의 작은 꼬리표를 쓰려고 했습니다. 그러나 이미 a라는 일터 꼬리표가 있기 때문에 작은 꼬리표를 만들 수 없다는 것입니다. 그러면 어떻게 해야할까요? 방법은 "a"라고 하는 일터 꼬리표를 없애는 것입니다. 그런데 공교롭게도 한 번 만들어진 일터 꼬리표를 없애기는 그리 쉽지가 않 습니다. 다만 일터 꼬리표는 일터가 닫힐 때 모두 없어지기 때문에 이를 이 용하는 수밖에는 없습니다. 다음의 순서를 따르십시오. 1) "Edit > Select All"을 실행하여 일터의 모든 내용을 선택한다. 2) "Edit > Cut"을 실행하여 선택한 내용을 잘라둔다. 3) 일터를 닫는다. 4) "File > New"를 실행하여 새 일터를 만든다. 5) "Edit > Paste"를 실행하여 잘라둔 내용을 붙인다. 이렇게 하면 예전에 있던 일터는 이미 지워졌기 때문에 그 안에 딸려있던 일 터 변수 또한 없어지게 되지만, 일터에 있었던 글은 잘라내기를 통하여 임시 기억장소(clipboard)에 저장되어 있기 때문에 기존에 일터에서 작업하던 글 토막들은 고스란히 남게 됩니다. 만약 실수로 일터 꼬리표를 만들어서 지워 야 할 때에는 위의 방법을 사용하면 됩니다. 조금 번거롭기는 하지만 지금으 로써는 위의 방법이 가장 현명한 방법이라고 생각됩니다. ---<잠깐!>---------------------------------------------------------- 일터 꼬리표 원래의 Smalltalk에는 일터 꼬리표라는 것이 존재하지 않았습니다. 따라서 개발된 지 오래된 Smalltalk 시스템은 일터 꼬리표를 지원하지 않았습니다. 그러나 Dolphin을 비롯한 Smalltalk-MT 등의 경우는 일터 꼬리표를 사용할 수 있습니다. 예전처럼 간단한 계산 결과를 보관해 둔다거나 문자 위주의 자 료 처리를 주로 하던 시스템에서는 굳이 일터 꼬리표가 필요 없겠지만, 그래 픽, 멀티미디어 등을 다루어야 하고, 또한 여러 개의 창(window)을 사용자가 직접 만들어서 꼬리표를 붙여 사용해야 할 경우에는 이러한 일터 꼬리표는 매우 편리한 도구라고 생각됩니다. ---------------------------------------------------------- 3.3.2. 꾸러미에 대해서... ------------------------- 집 안에 물건이 많아지면 통이나 수납장을 이용해서 정리해 둡니다. 그래야 만 물건을 찾기도 쉽고 필요 없는 물건을 버리기도 쉬울 뿐만 아니라, 너저 분해지지 않기 때문입니다. Smalltalk에도 많은 수의 객체가 존재합니다. 그런데 이러한 객체들은 서로 가 독립적인 존재들이기는 하지만, 어느 정도의 연관성은 가지고 있습니다. Smalltalk 시스템의 밑바닥을 이루는 시스템 객체들, 사용자와 대화하기 위 해서 필요한 객체들, Smalltalk의 계산을 담당하는 객체들 등 여러 가지 객 체들이 있습니다. 그 뿐인가요? Smalltalk로 프로그램을 만들다 보면 필요에 의해서 여러 가지의 객체들을 만들게 됩니다. 이런 객체들이 만약 아무런 대 책 없이 이곳 저곳에 널브러져 있다면 심각한 문제가 아닐 수 없습니다. 다행이 Dolphin Smalltalk에서는 이럴 때를 대비하여 "꾸러미"라는 것이 준 비되어 있습니다. 꾸러미(package)는 쉽게 말해서 가방이라고 생각하면 됩니 다. 관련 있는 물건들을 한 곳에 모아두고 필요할 때 찾아서 쓰거나 필요 없 는 것은 버릴 수 있는 것처럼 꾸러미에 객체를 담아두었다가 필요하면 버릴 수 있고, 또한 꾸러미에서 객체들을 쉽게 찾아서 쓸 수 있는 것입니다. Dolphin Smalltalk가 설치되면 처음에는 네 개의 꾸러미가 등록되어 있습니 다. 그 중 "Dolphin"이라는 꾸러미는 Dolphin을 구성하는 기본적인 객체들과 갈래들이 들어 있으며, "Ole COM"은 Windows에서 프로그램간에 자료를 교환 하거나 다른 언어에서 만들어진 객체에게 지시를 내리기 위해서 필요한 객체 와 길수들이 들어있습니다. "Scribble"과 "Etch-A-Sketch"는 Smalltalk로 만 들어진 "그림판"의 예제이며, 이 그림판을 구성하는 객체들이 들어 있습니 다. 아무튼 이러한 꾸러미들을 관리하기 위해서는 "꾸러미 탐색기"(package browser)라는 도구가 필요합니다. "Tools > Package Browser" 메뉴를 실행하 면 <그림 3-8>과 같은 꾸러미 탐색기를 볼 수 있을 것입니다. <그림 3-8> 꾸러미 탐색기 (Stp3-8.gif) 꾸러미 탐색기는 크게 세 부분으로 구성되어 있습니다. 왼쪽 널(pane)은 현재 Dolphin에 설치되어있는 꾸러미를 나타내는 것이고, 오른쪽 널에는 해당 꾸러미에 들어있는 갈래(class), 길수(method), 큰 꼬리 표(global), 자원(resource), 기타 명령(script) 등을 보여줄 수 있습니다. '자원'은 간단히 말하면 메뉴, 글자, 그림, 창을 이루는 화면 구성 등 프로 그램을 실행하는데 필요한 자료를 말하며, 기타 명령은 주로 꾸러미를 설치 할 때나 제거할 때 실행되어야 할 명령들을 써 놓는 곳입니다. 아래쪽 널에서는 꾸러미의 등록 정보, 갈래꼴(class definition), 길수꼴 (method definition) 등을 볼 수 있으며, 선택된 꾸러미에 대해서 설명을 달 아줄 수도 있습니다. 꾸러미 탐색기에 있는 메뉴를 통해서 새로운 꾸러미를 만들 수도 있고, 만들 어진 꾸러미를 디스크에 보관할 수도 있으며, 보관된 꾸러미를 Dolphin에 설 치하거나 설치된 꾸러미를 제거할 수도 있습니다. 필요 없는 꾸러미는 제거 해 두는 것이 기억 공간을 넓게 사용할 수 있는 방법이겠지요? 우리가 놀아볼 운동장과 그 안에 필요한 여러 가지 객체들은 바로 이러한 꾸 러미에 들어있으며, 꾸러미 탐색기를 통해서 꺼내야 하는 것들입니다. ---<잠깐!>---------------------------------------------------------- Dolphin Smalltalk의 꾸러미 꾸러미(package)라는 개념이 처음 Smalltalk가 나올 때부터 등장했던 것은 아니었습니다. 그러나 시간이 갈수록 많은 수의 객체가 생겨나게 되고, 이러 한 객체를 정리해 둘 필요가 생기게 되었습니다. 아울러 다른 사람이 만든 갈래나 객체를 배포할 때에도 나름대로의 방법이 필요했습니다. 예전에는 단 순히 갈래꼴(class definition)과 길수꼴(method definition) 등을 .st 라는 파일에 담아서 배포하였지만, 이는 죽어있는 글자들일 뿐이지 살아있는 객체 는 아닙니다. Smalltalk 환경을 직접 만드는 여러 회사들은 자신들만의 독특한 방법으로 객체를 포장하는 기술을 개발해 왔습니다. Dolphin Smalltalk의 Package도 그 중에 하나입니다. 필자가 다른 Smalltalk를 많이 사용해보지 않아서 잘 모르겠지만, 비교적 최근에 만들어진 Smalltalk 환경들은 어떤 방법으로든지 Dolphin Smalltalk의 꾸러미처럼 객체를 보관하거나 정리할 수 있는 방법을 제공한다는 것을 알 수 있을 것입니다. 여러분이 Dolphin Smalltalk를 계속 해서 사용하게 된다면 꾸러미는 여러분에게 매우 중요한 요소가 될 것입니 다. 나중에 이러한 꾸러미에 객체나 갈래들을 담는 방법을 설명해야 할 때가 있을 것입니다. 그 때까지는 꾸러미 탐색기에서 열심히 꾸러미를 설치하고 제거하는 것을 익혀두는 것이 좋겠습니다. ---------------------------------------------------------- 계속... 제 목:[강좌] Smalltalk 배우기 #28 관련자료:없음 [108] 보낸이:김찬홍 (안드래아) 1999-08-26 15:18 조회:154 Smalltalk 배우기 #28 1999. 8. 26. 김찬홍 mailto:andrea92@hitel.net ====================================== 3. 객체로 채워진 세상 3.1. 알아보자, 알림판! 3.2. 꼬리표 인생 3.3. 운동장 놀이 3.3.1. 일터 꼬리표 3.3.2. 꾸러미에 대해서 b→3.3.3. 운동장 위에서 ..... ======================================= 3. 객체로 채워진 세상 --------------------------- 3.3. 운동장 놀이 ~~~~~~~~~~~~~~~~ #27에서... 3.3.3. 운동장 위에서 -------------------- 지금까지 일터 꼬리표와 꾸러미에 대해서 어느 정도 알아보았으니, 이제는 정말로 운동장을 가지고 놀아봅시다. 우리의 장난감은 "Playground"라는 꾸 러미에 들어있습니다. 일단 장난감을 꾸러미에서 꺼내어 Dolphin에 설치하는 작업을 먼저 해 봅시다. 1) "Tool > Package Browser"를 실행하여 꾸러미 탐색기를 연다. 2) "Package > Install"을 실행하여 'Open Package' 상자를 연다. 3) Dolphin Smalltalk가 설치된 폴더로 이동한다. ☞ 보기) C:\Program Files\Dolphin Smalltalk 98\ 4) 해당 폴더 아래에 위치하는 Samples 폴더를 연다. 5) Playground 폴더를 선택해서 연다. 6) 'Playground.pac'파일을 클릭해서 선택하고 "열기"를 누른다. 여기까지 하면 "Playground" 꾸러미가 Dolphin에 설치되고, 화면 아래쪽 널 에는 꾸러미에 대한 간략한 설명(comment)이 표시될 것입니다. <그림 3-9> Playground 꾸러미를 설치한 화면 (Stp3-9.gif) 이 꾸러미에는 운동장과 그 속에 들어갈 도형을 만들기 위한 갈래들이 들어 있습니다. 우리는 이제 이 갈래에게 지시를 내림으로써 운동장을 만들고, 운 동장에 동그라미, 세모, 네모 등의 각종 도형을 올려놓을 수 있게 됩니다. 여기서 잠시 알림판(transcript)을 보면, "Loading in Playground package from D:\Progr..."와 같은 글이 쓰여있음을 볼 수 있는데, 이는 Playground 꾸러미를 성공적으로 설치했다는 것을 알려주기 위한 것입니다. 그럼 이제 필요 없는 일터는 모두 닫고 "File > New" 메뉴를 실행해서 새로 운 일터를 하나 만들어 봅시다. 앞으로 운동장에서 행해지는 여러 가지 작업 들은 모두 여기서 실행하게 될 것입니다. 먼저 해야할 일은 운동장을 만드는 것이겠지요? 바로값의 경우에는 그 객체 를 나타내는 이름만 적어주면 객체가 만들어졌습니다. "3"이라고 써 주면 정 수 객체 3이 만들어지는 것입니다. 그렇지만 운동장은 바로값이 아닙니다. 그래서 결국은 우리가 사용할 객체는 우리 스스로가 만들어야 합니다. 일터에서 아래 글토막을 가늠해 보십시오. Playground new. "Playground"는 방금 우리가 Playground 꾸러미를 설치할 때 생겼던 갈래입 니다. 이 갈래에 #new라는 지시를 내렸습니다. 그랬더니 어떻게 되었습니까? "a Playground"라는 제목을 가진 창이 하나 생겼습니다. 지금 생긴 창은 엄 연한 하나의 객체입니다. 즉 Playground 갈래의 실체(instance)인 것입니다. 지금 생긴 창을 이리 저리 움직여 보고 크기도 바꾸어 보십시오. 신기하게도 방금 우리가 Playground 갈래에 #new 지시를 내려서 만든 창은 기본적으로 창이 갖추어야 할 모든 것을 가지고 있습니다. 그런데... 지금 우리가 Playground 갈래에 #new라는 지시를 내려서 운동장을 만들었지 만, 이것을 어떻게 해야할지 도무지 알 수가 없습니다. 마우스를 이용해서 창을 조절할 수는 있지만, 정작 Smalltalk로는 어떠한 명령도 줄 수가 없습 니다. 바로, 객체를 만들어 놓고는 그 객체에 아무런 꼬리표도 붙여주지 않 았기 때문에 이런 일이 생긴 것입니다. 창이 화면에 표시되어 있기는 하지만 이 창에 어떤 명령을 주려고 해도 우리는 꼬리표를 붙이지 않았기 때문에 아 무런 지시도 내려줄 수 없는 것입니다. 일단 열려 있는 창을 닫고, 앞에서 공부한 대로 꼬리표를 붙여봅시다. 새로 만들어진 객체에게 우리는 'aPlayground'라는 이름의 꼬리표를 붙일 것입니 다. 아래의 글토막을 가늠해 보십시오. aPlayground := Playground new. 방금 나타났던 것처럼 똑같이 "a Playground"라는 제목의 창이 표시될 것입 니다. 그러나 이렇게 해서 만들어진 운동장에는 이제 'aPlayground'라는 일 터 꼬리표가 붙어 있습니다. 이제 언제든지 이 꼬리표를 이용하면 열려 있는 창에 지시를 내릴 수 있습니다. aPlayground는 일터 꼬리표이기 때문에 이렇 게 꼬리표를 붙여놓기만 하면 자동으로 꼬리표가 만들어지고, 사용자가 일터 를 닫기 전까지는 없어지지 않습니다. 우리의 운동장에게 "화면의 왼쪽 귀퉁이로 가라"고 지시를 내려봅시다. 아래 의 글토막을 가늠해 보십시오. aPlayground position: 0@0 . #position:은 쇠마디 지시로써, 바로 뒤에 인자로 넘겨주는 자리로 창의 위 치를 바꾸는 역할을 합니다. 창의 위치나 크기를 지정하는 방법에 대해서는 나중에 좀 더 자세히 알아보겠지만, 여기서 중요한 것은 "Playground" 갈래 에게 #new 라는 지시를 내려서 객체 하나를 얻었으며, 여기에 'aPlayground' 라는 꼬리표를 붙였고, 이렇게 해서 붙여진 꼬리표를 사용해서 객체에게 명 령을 내렸다는 것입니다. 이런 일련의 과정들을 이해하는 것이 중요합니다. 운동장을 만들었으니 이제는 가지고 놀 모양들을 만들어 봅시다. 우리는 동 그라미, 세모, 네모를 만들 것입니다. 아래의 글토막을 가늠해 봅시다. dongle := Circle new. semo := Triangle new. nemo := Square new. 앞서 우리가 운동장을 만들 때 "Playground" 갈래에 #new라는 지시를 보냈던 것을 기억하십니까? 마찬가지로 우리가 동그라미, 세모, 네모 모양을 만들기 위해서는 원하는 갈래에 #new라는 지시를 내려주어야 합니다. 우리는 동그라 미를 만들고 'dongle' 꼬리표를 붙였고, 세모를 만들어서 'semo'를 붙였으 며, 네모를 만들어서 'nemo'를 붙였습니다. 이렇게 세 개의 객체를 만들고 그 객체를 가장 적당하게 부를 수 있도록 꼬리표를 붙여주었습니다. 이렇게 어떤 객체를 만들고 싶을 때에는 그 객체가 속해 있는 갈래에게 #new 라는 지시를 내려주면 됩니다. 물론 지금까지 우리가 다루어온 대부분의 객 체들은 바로값이었습니다. 그러나 운동장, 동그라미, 세모, 네모 등은 결코 바로값으로 나타낼 수 없는 객체들이고, 이런 종류의 객체들을 만들어 내기 위해서 우리는 그 객체가 속한 갈래에 "새로운 실체를 만들어 내라"는 뜻으 로 #enw 지시를 내린 것입니다. 이렇게 생각하면 갈래는 실체를 만들어 내는 공장이라고 할 수도 있겠습니다. 운동장을 봅시다. 그런데 우리가 만들어 놓은 모양들은 아무데도 보이지 않 습니다. 어찌된 일일까요? 그것은 우리가 모양만 만들어 놓고 운동장에 그것 들을 넣지 않았기 때문입니다. 아래 글토막을 가늠해 보십시오. aPlayground add: dongle. aPlayground add: semo. aPlayground add: nemo. 우리가 Playground 갈래에 #new 지시를 내려서 만든 운동장 객체는 #add:라 는 지시를 알아듣습니다. #add: 는 쇠마디 지시이고, 인자로 모양을 넘겨주 면 그 모양을 운동장에 집어넣습니다. 우리는 방금 동그라미, 세모, 네모를 운동장에 넣었습니다. 운동장을 보면 <그림 3-10>과 같이 글토막이 가늠될 때마다 각각의 모양이 생기는 것을 볼 수 있습니다. 신기하지 않습니까? :) <그림 3-10> 운동장과 동그라미, 세모, 네모 (Stp3-10.gif) 이번에는 운동장에 있는 모양을 없애봅시다. 아래와 같이 해 보십시오. aPlayground remove: dongle. aPlayground remove: semo. aPlayground remove: nemo. 어떻습니까? 위의 글토막이 하나씩 가늠될 때마다 운동장에 있었던 모양들은 자취를 감추게 됩니다. 즉 운동장 객체는 #remove: 라는 쇠마디 지시를 알아 듣는다는 말입니다. 우리는 운동장에서 모양을 없앤 것뿐입니다. 즉 dongle, semo, nemo라는 꼬 리표가 붙어있는 객체들은 아직 없어지지 않았습니다. 그러므로 마음만 먹으 면 언제든지 다시 운동장에 넣을 수 있습니다. 이번에는 앞에서 배운 "잇따 름 지시"(cascaded message)를 이용해서 도형을 한꺼번에 집어넣겠습니다. <바탕글 1> 잇따름 지시를 이용해서 운동장에 도형 넣기 ---------------------------------------------------------- aPlayground add: dongle; add: semo; add: nemo. ---------------------------------------------------------- 지금까지는 글토막을 하나씩 가늠해도 되었지만, 위의 바탕글은 잇따름 지시 이기 때문에 덩이(block)를 씌워서 한꺼번에 가늠해야 합니다. 아무튼 위의 바탕글을 실행하면 운동장에서 다시 동그라미, 세모, 네모의 도형을 볼 수 있습니다. 이제 운동장도 만들었고 거기에다가 동그라미, 세모, 네모의 도형도 집어넣 었으니, 지금부터 이들 도형을 가지고 놀아봅시다. 우선 도형을 움직이는 것 부터 시작합시다. 화면은 수많은 점으로 이루어져 있습니다. 이런 점을 화소(畵素, pixel)라 부르는데, 화면상에서 거리나 크기를 젤 때에는 이런 화소를 사용합니다. 그 래서 우리가 도형을 움직일 때에도 "오른쪽으로 몇 화소만큼 움직여라"는 식 으로 지시를 내려주어야 합니다. 지금 운동장에 있는 네모에게 "30 화소만큼 오른쪽으로 움직여라"고 지시를 내려봅시다. 네모 객체에는 nemo라는 꼬리표가 붙어 있기 때문에 nemo moveRight: 30. 위의 글토막을 가늠하면 <그림 3-11>처럼 빨간색 네모가 오른쪽으로 약간 움 직였다는 것을 볼 수 있을 것입니다. 잘 구분이 가지 않으면 <그림 3-10>과 비교를 해 보시기 바랍니다. 분명히 네모는 오른쪽으로 30화소를 이동했습니 다. 우리가 네모 객체에게 #moveRight: 지시를 내려주었기 때문입니다. 이번에는 파란색 삼각형을 위로 옮겨보도록 하겠습니다. 도형을 위로 움직이 려면 #moveUp: 지시를 사용합니다. 역시 움직일 거리를 화소 단위로 넣어 줍 니다. dongle moveUp: 100. <그림 3-12> #moveUp: 지시에 반응하는 삼각형 (Stp3-13.gif) 화면에서 100화소의 거기가 어느 정도 되는지 짐작이 가십니까? 처음에는 화 소와 실제의 거리가 대칭이 잘 되지 않을 것입니다. 그렇지만 화소 좌표를 많이 이용하게 되면 어느 정도 거리를 계산할 수 있을 것입니다. 도형의 크기를 바꿀 수도 있습니다. 크기를 늘리려면 #growBy: 지시를 내려 주면 되고, 반대로 크기를 줄이려면 #shrinkBy: 지시를 사용하면 됩니다. 역 시 크기의 단위는 화소를 사용합니다. semo growBy: 50. nemo shrinkBy: 30. <그림 3-13> 도형의 크기를 조절하는 #growBy: 와 #shrinkBy: (Stp3-13.gif) 원래의 크기로 되돌리고 싶으면 늘였던 것은 줄이고, 줄였던 것은 늘리면 됩 니다. 그러니까 semo에게는 #shrinkBy:를, nemo에게는 #growBy:를 내려주면 됩니다. 다음과 같이 말입니다. semo shrinkBy: 50. nemo growBy: 30. 운동장에 있는 모든 도형은 일정한 각도만큼 회전을 시킬 수 있습니다. 이를 위해서는 #rotateBy: 지시를 사용합니다. nemo rotateBy: 45. semo rotateBy: 90. 지금 nemo의 경우에는 다이아몬드의 모양을 하고 있지만, 45도 만큼 회전했 더니 지면과 수평인 모양이 되었습니다. 마찬가지로 세모의 경우도 각도를 조절하여 회전시키면 화면 아래쪽을 바라보는 역삼각형의 모습이 된 것입니 다. <그림 3-14>를 살펴보면 #rotateBy: 지시를 받은 도형이 어떻게 반응했 는지를 살펴볼 수 있을 것입니다. 물론 동그라미의 경우는 이리 돌려보고 저 리 돌려봐도 똑같은 모양이라는 것은 두말할 나위가 없겠지요? <그림 3-14> #rotateBy:에 반응하는 도형들 (Stp3-14.gif) 마지막으로 운동장에 있는 도형의 색깔을 바꾸어봅시다. 도형의 색깔을 바꾸 기 위해서는 #color: 지시를 사용하면 됩니다. 이 #color: 지시는 "Color" 갈래의 실체를 필요로 합니다. 색깔 역시 바로값이 아니기 때문에 "Color" 갈래에 여러 가지 지시를 내려서 색을 나타내는 객체를 만들어야 합니다. 기본적으로 "Color" 객체는 #red, #green, #black, #blue, #yellow, #cyan, #magenta, #gray 등과 같이 우리가 흔히 사용하는 색깔 이름을 지시로 알아 듣습니다. 그래서 빨간색을 나타내고 싶을 때에는 "Color red"와 같이 써 주 면 되는 것입니다. 말로 하는 것보다는 직접 실행해 보는 것이 이해하기가 쉽겠지요? 지금 운 동장에 있는 노란색 세모를 초록색으로 바꾸어 보겠습니다. 앞에서 말했듯이 어떤 도형의 색을 바꾸기 위해서는 해당하는 도형 객체에 #color: 라는 지시 를 내려주어야 합니다. semo color: Color green. 위의 경우 길수의 우선 순위에 따라서 먼저 "Color" 갈래에 외마디 지시 (unary message)인 #green이 보내지게 됩니다. 그래서 결국 #green 지시를 받은 "Color" 갈래는 초록색을 나타내는 객체를 만들어내고, 이것이 쇠마디 길수인 #color:에 인자로 넘어가게 됩니다. 결국 semo가 가리키는 세모 객체 의 색이 초록색으로 바뀌는 것입니다. 이런 원리로 네모와 동그라미의 색도 바꿀 수 있습니다. nemo color: Color magenta. dongle color: Color cyan. 이렇게 #color: 지시를 사용하면 도형의 색을 마음대로 바꿀 수 있습니다. 다음 <그림 3-15>를 살펴보면 방금 실행한 세 개의 지시가 도형의 색깔을 어 떻게 바꾸었는지를 알 수 있습니다. <그림 3-15> #color: 지시를 알아듣는 도형 (Stp3-15.gif) 그런데 "Color" 갈래에 내리는 길수로 만들어지는 색에는 한계가 있습니다. 예를 들면 "불그스레한 흰색"이나 "푸르스름한 회색"과 같이 말로 표현하기 도 조금 애매한 색을 내려면 어떻게 해야 할까요? 이럴 때에는 색을 가리키 는 이름보다는 아예 색상 표를 펼쳐놓고 내가 원하는 색을 골라서 쓰는 것이 편할 것입니다. 동그라미, 세모, 네모와 같은 모양들은 모두 #chooseColor 라는 외마디 지시 를 알아듣습니다. 이 지시가 실행되면 색상 표가 나오고, 여기서 원하는 색 을 선택하여 도형의 색을 결정할 수 있습니다. dongle chooseColor. 위의 명령이 실행되면 <그림 3-16>과 같이 색을 선택할 수 있는 화면이 나옵 니다. 선택할 수 있는 색이 적은 경우에는 "사용자 정의 색 만들기"라는 단 추를 누르면 보다 더 미세하게 색을 선택할 수 있습니다. <그림>은 "사용자 정의 색 만들기" 단추를 눌러서 선택한 화면입니다. <그림 3-16> #chooseColor로 열리는 색상 선택표 (Stp3-16.gif) 여기서 원하는 색을 선택한 후 "확인" 단추를 누르면 선택한 색이 도형의 색 으로 바뀌게 됩니다. 이 밖에도 "Color" 갈래에게 내리는 지시에 따라서 색 상(hue)과 체도(saturation)를 이용해서 색을 만들 수도 있고, 빛의 삼원색 인 빨강, 초록, 파랑을 이용해서 색을 만들 수도 있습니다. 아무튼 나중에 색에 대해서 자세히 다룰 일이 있을 때 "Color"에 대해서 좀 더 깊이 알아보 도록 하겠습니다. 이제 운동장을 가지고 놀았으니 깨끗이 정리를 해 봅시다. 운동장에 있는 도 형을 제거하려면 "Playground" 갈래의 실체에게 #remove: 지시를 내려도 되 지만 도형의 개수가 많아지면 일일이 #remove: 지시를 내리는 것이 귀찮을 때가 있습니다. 이 때 운동장에게 "청소하라"고 지시를 내려주면 모든 도형 을 한꺼번에 지울 수 있습니다. aPlayground clear. 위의 글토막을 실행하면 운동장에 있던 모든 도형이 지워집니다. 물론 각각 의 도형에 꼬리표를 붙여두었다면 #add: 지시를 이용해서 언제든지 다시 운 동장에 넣을 수 있습니다. 운동장을 다 썼으면 그냥 닫아버리면 그만입니다. 지금까지 살펴본 것처럼 어떤 객체에게 일을 지시하기 위해서는 객체가 알아 들을 수 있는 지시를 내려주면 됩니다. 또한 간단한 지시가 아니라 부수적으 로 어떤 일을 해야하는지를 자세하게 알려줄 필요가 있을 때에는 쇠마디 지 시와 인자를 사용하면 됩니다. 이것이 객체지향 패러다임의 골자입니다. 더욱이 재미있는 것은 이러한 것들을 필요하면 언제든지 즉시 실행할 수 있 다는 것입니다. 이것이 Smalltalk의 큰 특징입니다. Smalltalk에서는 모든 것이 실시간(real-time)으로 처리되며, 따라서 객체 역시 실시간으로 움직입 니다. 무엇이든지 여러분이 Smalltalk에서 명령을 내리기만 하면 그 명령에 객체는 즉시 반응합니다. 흡사 베이식(BASIC) 통역기의 환경을 보는 듯하겠 지만 명령이 중심이 되는 베이식과 객체가 중심을 이루는 Smalltalk는 하늘 과 땅만큼 차이가 있습니다. "Playground" 꾸러미의 "Circle", "Triangle", "Square" 등의 갈래는 지금 제가 알려드린 것보다 훨씬 많은 지시를 알아들을 수 있습니다. 아래에 이들 갈래들의 실체가 어떠한 지시를 알아들을 수 있는지를 정리해 놓겠습니다. 여러분이 일터에서 여러 개의 도형과 운동장을 만들어 보고, 이 객체들에게 지시를 내려보면 Smalltalk가 왜 객체지향 언어인지, 그리고 객체를 중심으 로 생각한다는 것이 얼마나 편리한지를 느낄 수 있을 것입니다. ---------------------------------------------------------- side 도형의 면 수를 알아낸다. 세모의 경우에는 3을 남기고, 네 모의 경우에는 4를 남기며, 동그라미의 경우는 무수히 많은 면을 가지고 있으므로 100을 남긴다. sides: anInteger 지시를 받은 도형의 면을 결정한다. 면의 수에 따라 모양이 달라진다. 기본적으로 동그라미, 세모, 네모의 갈래가 있지 만 이 지시를 이용해서 오각형 이상의 도형도 만들 수 있 다. radius 지시를 받은 도형의 반지름을 되돌려준다. radius: anInteger 지시를 받은 도형의 반지름을 지정한다. 반지름의 길이에 따라 도형의 모양도 달라진다. rotation 지시를 받은 도형이 현재 어떤 방향을 하고 있는지를 도 (degree) 단위로 남겨준다. rotation: anInteger 지시를 받은 도형의 방향을 anInteger 각도로 정한다. position 도형이 운동장의 어디에 있는지를 좌표(Point)로 알려준다. position: aPoint 도형의 위치를 aPoint로 정한다. (x@y)와 같은 방법으로 좌 표를 얻는데, 모든 정수는 #@ 지시를 받아서 좌표를 만들 수 있기 때문이다. color 현재 지시를 받은 도형의 색깔을 남긴다. color: aColor 지시를 받은 도형의 색깔을 aColor로 정한다. Color 갈래에 게 여러 가지 지시를 내려서 색을 만들어낼 수 있다. growBy: anInteger 지시를 받은 도형을 anInteger 화소만큼 늘린다. shrinkBy: anInteger 지시를 받은 도형을 anInteger 화소만큼 줄인다. rotateBy: anInteger 지시를 받은 도형을 anInteger 각도만큼 회전시킨다. moveBy: aPoint 지시를 받은 도형을 현재 거리에서 aPoint만큼 움직인다. moveLeft: anInteger moveRight: anInteger moveup: anInteger moveDown: anInteger 지시를 받은 도형을 상, 하, 좌, 우로 anInteger 화소만큼 움직인다. chooseColor Windows에 있는 표준 색상표를 사용하여 사용자가 색을 선 택할 수 있도록 한다. ---------------------------------------------------------- 운동장에서는 마음껏 뛰어 놀아도 나무랄 사람이 없습니다. 이제 여러분만의 운동장과 예쁜 도형들이 여러분들의 지시를 기다리고 있습니다. 이들도 Smalltalk의 객체이기 때문에 여러분이 원하는 지시를 모두 다 내려줄 수 있 습니다. 위에서 설명한 지시를 이용해서 되도록 Smalltalk 객체에게 많은 지 시를 내려보시기 바랍니다. 그리고 몸으로 많이 익혀서 적어도 이제부터는 Smalltalk 객체에게 지시를 내리는 일로 당황하는 일이 없도록 합시다. 물론 여러분이 객체에게 지시를 내릴 때 잘못하여 실수를 하는 경우도 있을 지 모릅니다. 그러나 여러분이 그런 실수를 했다고 해서 Smalltalk 환경이 파괴되지는 않습니다. Smalltalk는 매우 안전하기 때문에 여러분이 어떤 실 수를 해서 객체가 지시를 제대로 수행할 수 없었을 경우에는 언제든지 발자 취(walk back) 창이 열립니다. 여러분은 이 상태에서 당황하지 말고 "Terminate" 단추를 눌러주기만 하면 됩니다. 그러면 발자취 창이 닫히고 원 래의 상태로 되돌아옵니다. 이번 가름에서 소개한 운동장은 앞으로 Smalltalk의 여러 가지 다른 유용한 지시들을 설명할 때에도 사용될 것입니다. 그러니 지금부터 운동장을 만들고 없애는 방법과 그 안의 도형들이 어떤 지시를 알아듣는지, 또한 이러한 지시 를 알아듣고 어떤 반응을 하는지에 익숙해지시기 바랍니다. 많은 연습보다 더 좋은 것은 없으니 이제 남은 것은 여러분들이 충분히 연습해서 익숙해지 는 것입니다. ---<잠깐!>---------------------------------------------------------- Smalltalk의 그래픽 환경 Smalltalk 환경은 그 환경을 만든 회사마다 독특한 특징을 가지고 있습니다. 대부분 Smalltalk의 기본적인 부분은 같거나 비슷하지만, 특히 그래픽이나 멀티미디어 등을 처리하는데 있어서는 마땅히 정해진 표준이 없기 때문에 Smalltalk 개발 회사들은 자신만의 방법으로 이러한 것들을 구현해 내고 있 습니다. 특히 Smalltalk를 이용해서 실무에서 사용해야 하는 응용 프로그램 을 만들 경우에는 그것을 만들기 위한 뼈대(framework)가 있어야 하는데, 이 런 뼈대들이 Smalltalk 개발사들마다 약간의 차이가 있습니다. 아무튼 필자는 공개용으로 사용할 수 있고, 또한 상용 시스템과도 호환성이 있는 Dolphin Smalltalk의 뼈대를 따르기로 합니다. 어쩌면 다른 계열의 Smalltalk를 사용하는 여러분에게는 도움이 안 될지도 모르겠지만, 한 부분 의 뼈대를 공부하고 난 뒤 다른 회사의 Smalltalk에서 작업을 해야할 때에는 보다 더 쉽게 접근할 수 있다고 생각합니다. 이번 마디에서 다루어진 운동장(Playground) 역시 Dolphin Smalltalk의 MVP (Model-View-Present)의 뼈대를 사용한 작은 응용 프로그램입니다. 앞으로 여러분이 Smalltalk를 깊이 공부하게 되면 Dolphin Smalltalk의 응용 프로그 램의 뼈대인 MVP 또한 공부하게 될 것입니다. ---------------------------------------------------------- =========================================================== 이번 마디에서 우리는 Smalltalk에서 창의 역할을 하는 운동장과 이 창에 표 시될 도형들에게 직접 지시를 내려봄으로써 객체지향이란 무엇인지를 좀 더 쉽게 몸으로 느껴보고자 했습니다. 또한 앞에서 알아본 객체에게 지시를 내 리는 방법 등을 되새겨 보는 시간을 가졌습니다. 여러분께서 "Circle", "Triangle", "Square"라는 세 갈래에서 만들어진 객체들을 자유롭게 다룰 수 있다면, 여러분은 이미 Smalltalk의 문법과 의미를 통틀어 80% 이상을 공부 한 것이나 나름이 없습니다. 힘을 냅시다. 다음에는 또 어떤 객체들이 여러 분을 기다리고 있을지 모르니까요. 계속... 제 목:[잡담] Smaltlalk와 실행파일 배포 관련자료:없음 [109] 보낸이:김찬홍 (안드래아) 1999-08-31 20:09 조회:136 좀 늦은 감은 있지만 Smalltalk로 만들어진 프로그램의 배포에 대해서 이야기를 좀 할까 합니다. Smalltalk는 Java와 비슷한 방식으로 프로그램을 실행합니다. 일터에서 입력한 글토막이나 갈래(class)의 길수(method)를 지을 때 써 주는 바탕글은 우선 번역기, 그러니까 Compiler에 의해서 바이트 명령으로 번역됩니다. 이렇게 번역된 명령을 Smalltalk 가상 기계(Virtual Machine)가 통역(interpreting)하여 결과를 실행한답니다. Java가 개발되기 전 10년이 훨씬 넘은 싯점에서 벌써 가상기계와 바이트 명령 통역기가 사용되었다는 것을 보면, Smalltalk를 만든 Xerox의 ParcPlace가 선견지명이 있다고 하겠습니다. 대부분의 Smalltalk는 이렇게 돌아갑니다. 그렇기 때문에 실행파일을 만들려면 별도의 도구가 필요합니다. 실행파일에는 바이트 명령 통역기와 사용자가 만든 Smalltalk 프로그램이 함께 들어 있습니다. 물론 Smalltalk의 모든 것은 객체이고 이 객체는 나름의 갈래에 딸려있으므로, 프로그램 또한 갈래와 객체들을 모아놓은 것일 것입니다. Smalltalk는 이들을 하나의 꾸러미(package)에 넣어두고, 필요하면 이 꾸러미 자체와 꾸러미에서 사용하는 갈래나 객체들을 실행파일에 한데 묶어놓는 방법을 취합니다. 실은 Smalltalk에서 독립실행파일을 만들 수 있게 된 것은 그리 오래되지 않았습니다. 그도그럴것이 Smalltalk 환경 자체가 다른 언어의 환경에 비해 매우 작은 크기였기 문에, Smalltalk환경 자체를 배포해도 되었었습니다. 그러나 윈도 운영체계로 넘어오면서 실행파일의 크기가 무시할 수 없을 정도가 되자 Smalltalk 환경에서 필요한 갈래와 객체들만 뽑아내어서 실행파일을 만들 수 있게 한 것이지요. 아쉽지만 Dolphin Smalltalk에서 독립형 실행파일을 만들려면 "ADK" 즉, Application Deployment Kit이란 꾸러미를 구입해야 합니다. 물론 이 꾸러미의 가격이 약 70$ 정도밖에 안 되기 때문에 다른 환경에 비해서 비교적 저렴하게 상용제품을 만들 수 있습니다. 물론 독립실행파일을 만들 수 없다고 해서 현재 공개된 Dolphin Smalltalk 의 질 자체가 떨어지는 것은 아닙니다. ADK는 단지 몇 십개가 안 되는 갈래들(주로 실행파일을 만들고 정보를 관리하고 개발 환경과 실행환경을 교체해 주는 부분)로 이루어져있기 때문이지요. Dolphin이 아닌 다른 Smalltalk의 경우 역시 독립실행파일을 만들 수 있도록 해 놓았습니다. 그래도 널리 쓰이는 VisualWorks for Smalltalk나, Visual Ages for Smalltalk 역시 독립실행파일을 지원합니다. Smalltalk-MT라는 시스템은 바이트 명령을 거치지 않고 바로 기계어로 번역을 합니다. 그렇기 때문에 다른 Smalltalk들 보다는 생성된 프로그램의 실행속도가 빠릅니다. 그러나 Smalltalk-MT는 ANSI에서 정한 표준 Smalltalk의 규정에 맞지않는 것들이 많다는 단점이 있습니다. 역시 30일 간 사용할 수 있는 평가판에서는 실행파일을 만들 수 없으나, 상용판에서는 실행파일을 만들 수 있습니다. 또한 Smalltalk-MT는 다중 스레드(multi thread)로 돌아가기 때문에 DLL을 만들 수 있으며, ActiveX 컨트롤의 생성도 가능하다고 들었습니다. Smalltalk는 내가 필요하면 얼마든지 객체의 행동을 바꾸어줄 수 있는 유연한 환경이기 때문에, ADK 없이 실행파일을 만드는 방법을 생각해보고 있습니다. 글쎄요. 그러려면 Smalltalk의 안쪽을 훤히 꿰뚫어야할터인데.... C/C++를 공부할 때에는 문법 공부가 전체의 40% 가량을 차지한다고 해도 과언이 아니지만, Smalltalk의 경우 문법 공부는 전체의 10%도 안 됩니다. 나머지 90%를 갈래다발(class library)와 객체들의 관계(framework)를 공부하는데 씁니다. 음, 앞으로 열심히 하겠습니다. 지켜봐주십시오. 제 목:[사과] 연재가 늦어져서 죄송합니다. 관련자료:없음 [141] 보낸이:김찬홍 (지니반쪽) 2000-02-24 23:30 조회:53 안녕하세요? 김찬홍 안드래아입니다. 우선 Smalltalk글이 많이 늦어져서 죄송합니다. 그 동안 개인적으로 좀 사정이 생겨서 글을 올리지 못했습니다. 3월이 되기 전에 #29를 올릴 생각입니다. 너무 많이 늦어져서 죄송하고요, 제 글을 유용하게 봐 주셨던 여러분들에게 사과 드립니다. C/C++과는 전혀 다른 방식으로 접근하고, 그래서 프로그래밍 초보자와 전문가 모두를 만족시킬 수 있는 Smalltalk.... 이 좋은 언어를 보급하기 위해서 열심히 하겠습니다. 너무 많이 기다리게 해 드려서 죄송합니다. 그럼. 제 목:[강좌] Smalltalk 배우기 #29 관련자료:없음 [142] 보낸이:김찬홍 (지니반쪽) 2000-02-25 14:45 조회:80 Smalltalk 배우기 #29 2000. 2. 25. 김찬홍 mailto:andrea92@hitel.net ====================================== 3. 객체로 채워진 세상 3.1. 알아보자, 알림판! 3.2. 꼬리표 인생 3.3. 운동장 놀이 →3.4. 앗, 나의 실수!!! a→3.4.1. 김 군의 하루 3.4.2. 실수, 또 실수 ........ ======================================= 3. 객체로 채워진 세상 --------------------------- 3.4. 앗, 나의 실수!!! ~~~~~~~~~~~~~~~~~~~~~ 어떤 일을 하다가 가장 위험한 때를 꼽으라면 여러분은 뭐라고 하시겠습니 까? 저라면 "가장 익숙해졌을 때"라고 대답할 것입니다. 자신이 하고 있는 일, 알고 있는 지식에 익숙해졌다고 생각하면 처음에 가졌던 긴장감이 사라 지고, 결국 이것은 '실수'를 낳는 법입니다. Smalltalk를 공부함에 있어서도 이는 비슷하다고 하겠습니다. 이제 어느 정 도 Smalltalk에 대해서 익숙해 졌고, 객체에게 지시를 내리는 것도 나름대로 자신이 붙었다고 생각할 때 바로 '실수'라는 복병이 도사리고 있는 것 같습 니다. 필자도 처음 Smalltalk를 공부할 때에 이렇게 '방심'하고 있다가 그 복병에게 된서리를 맞은 기억이 있습니다. 이 마디에서 여러분은 Smalltalk를 사용하다가 저지를 수 있는 여러 가지 실 수들과, 그 실수들을 바로잡는 방법들에 대해서 알아보게 될 것입니다. 물론 Smalltalk가 여러분의 실수에 대해서 관대하게 대처하고 있기는 하지만, 큰 프로그램을 작성하는데 있어서 이러한 실수는 중대한 문제를 만들 수 있기 때문에 작은 실수 하나라도 용납해서는 안 될 것입니다. 그럼 먼저 전산과에 다니는 '김모군' 이야기부터 시작하도록 합시다. 3.4.1. '김 군'의 하루 ---------------------- 4학년의 마지막 여름 방학. 김 군도 다른 전산과 학생들처럼 취업 준비에 여 념이 없을 때였습니다. 그런데 안타깝게도 김 군은 뛰어난(?) 땡땡이 실력으 로 수업을 한 날짜보다 땡땡이를 친 수업 일수가 더 많을 정도였습니다. 그 러나 어찌 어찌해서 이제 졸업을 눈앞에 두고 있는데, 막상 취업을 하려 하 니 김 군이 전산과에서 알고 있는 것이라고는 군대에 가기 전에 배운 포트란 (FORTRAN)정도였습니다. 안절부절하고 있는 김 군을 옆에서 지켜보고 있던 친구는 김 군에게 취직자 리를 알아봐 주겠다고 제의를 했고, 김 군은 마다할 처지가 아니어서 친구에 게 신세를 지기로 했습니다. 김 군의 친구는 이제 막 인공위성에 대한 연구 를 마치고 시제품을 개발하고 있는 "별누리"라는 회사에 김 군을 천거했습니 다. 이력서 및 기타 다른 서류들을 준비하는 김 군을 보면서 친구는 귀띔을 해 두었습니다. "이 회사는 새로 생긴 회사이기 때문에 객체지향에 대해서 관심이 많은 모 양이더라구. 그러니깐 객체지향에 대해서 공부를 좀 해 두라고." 그 때부터 김 군의 객체지향 공부가 시작되었습니다. 그러나 처음부터 김 군 은 난관에 부딪힙니다. 객체지향 책 한 권을 사서 앞의 몇 장을 읽어봤더니 거기에는 Object, message, class, instances, receiver, polymorphism, inheritance, encapsulation 등등 정말 머리가 터져 버릴 듯한 이상한 만들 로 가득 차 있었습니다. 기가 막힐 노릇입니다. 하는 수 없이 김 군은 급한 김에 객체지향 프로그래밍 공부부터 먼저 시작하 기로 하고, 친구들이 요즘 한참 인기가 좋다고 선전하는 C++를 공부하기 시 작했습니다. 그러나 3년 전에 공부한 포트란과 C++는 너무나 달랐습니다. 하 지만 김 군은 자신의 미래를 위해서 열심히 공부했습니다. 물론 시간이 많이 걸리는 일이었지만, 일단 취업을 해서 문제에 부딪히면 잘 할 수 있겠거니 하는 생각으로 열심히 했습니다. 뛰어난 말발과 쇼맨십으로 드디어 김 군은 "별누리" 회사에 취업을 하게 되 었습니다. 김 군에게 처음으로 배당된 프로젝트는 인공 위성의 내부에 설치 하게 될 탄소 막대(carbon steel rod)의 길이를 산출하는 것이었습니다. 팀 장은 인공 위성 프로젝트가 Smalltalk를 사용해서 개발되기 때문에 반드시 Smalltalk를 사용해서 계산을 해야 한다고 으름장을 놓습니다. 그리고 다음 과 같은 조건을 부여했습니다. * 인공 위성 내부의 최고 온도는 섭씨 500도이다. * 탄소 막대는 온도에 따라서 길이가 늘어나거나 줄어든다. * 인공 위성에 막대를 탑재했을 때 길이의 변화를 고려하여 공간을 만든다. 인공 위성이 태양열을 받게 되면 내부의 온도가 섭씨 500도까지 올라가게 되 는데, 탄소 막대 역시 온도가 올라가면 길이가 늘어나게 됩니다. 그렇기 때 문에 섭씨 500도에서 탄소 막대의 길이가 얼마나 늘어나는지를 계산해서 충 분한 공간을 마련해 두지 않으면 인공 위성이 파괴될 지도 모르는 일입니다. 이러한 사태를 막기 위해서 __"섭씨 500도일 때의 탄소 막대의 길이는 얼마 나 늘어나는가"__를 해결하는 것이 김 군이 맡을 프로젝트인 것입니다. 그런데 벌써부터 눈앞이 캄캄합니다. 친구들은 객체지향 프로그래밍을 공부 하려면 C++를 공부하라고 하는데, 이 회사는 왜 Smalltalk를 사용하는 것일 까요? 안 그래도 머리가 복잡한 김 군은 C++를 놔두고 왜 Smalltalk로 프로 젝트를 수행하는지에 대해서 팀장에게 물었습니다. "C++는 객체지향 언어가 아니라 객체지향을 추구하는 언어입니다. 우리는 유사품을 원하지 않습니다. 데드라인을 지키고 싶다면 복잡한 C++ 보다는 Smalltalk를 쓰는 게 좋을 겁니다." 팀장의 말에 김 군은 어찌할 바를 모르고 일단 몸으로 부딪히기로 했습니다. 먼저 김 군은 필요한 자료를 모으기 시작했습니다. 다행이 회사에서 오랜 실 험을 통해 온도와 탄소 막대의 길이 변화에 대한 다음과 같은 공식을 도출했 습니다. s = s0(1 + Af) - s0 : 화씨 0도일 때 탄소 막대의 길이. 단위는 inch. - A : 확장 계수(coefficient expansion) 알파 = 6.7 * 10^-6. - f : 화씨 온도 - s : 화씨 f도일 때의 실제 탄소 막대의 늘어난 길이 위의 공식에서 "s0"은 화씨 0도일 때의 막대의 길이를 말합니다. "A"(알파) 는 확장 계수인데, 이는 화씨 1도가 증가할 때 금속의 길이가 얼마만큼 늘어 날지를 나타내는 상수입니다. 그리고 "f"는 구하려고 하는 화씨 온도 (fahrenheit degree)입니다. 김 군에게 떨어진 자료는 이것입니다. 이제 이 공식을 이용해서 섭씨 500도 일 때의 막대의 길이를 알아내어야 하는 것입니다. 그런데 문제가 있습니다. 위의 공식은 섭씨 온도(centigrade degree)가 기준이 아니라 화씨 온도가 기 준이 되는 것입니다. 따라서 공식을 적용하기 전에 우선 섭씨 온도를 화씨 온도로 바꾸어주는 작업이 필요합니다. 신입 사원인 김 군, 잘 몰라서 버벅거리지만 열심히 하면 회사에서 잘리지는 않겠지 라는 생각으로 늦게까지 야간 작업을 하기로 결심하고, 과학 백과 사 전을 뒤진 끝에 드디어 섭씨 온도를 화씨로 바꾸는 아래와 같은 공식을 찾아 내었습니다. 9 f = 32 + --- c 5 - c : 섭씨 온도 - f : 화씨 온도 이제 김 군은 앞이 캄캄합니다. 화씨 온도로 된 탄소 막대의 길이 구하는 공 식과 섭씨 온도를 화씨 온도로 바꾸는 공식을 얻기는 했지만, 이제 이것을 Smalltalk의 글토막으로 써내야 하는 것입니다. 시간은 벌써 새벽 다섯 시. 점점 밝아오는 여명을 보면서 김 군은 책상 위에 무거운 머리를 내려놓습니 다. 스르르 감기는 눈과 함께 김 군의 의식은 점점 흐릿해져만 가는데.... 3.4.2. 실수, 또 실수 -------------------- 누군가 김 군의 몸을 흔드는 바람에 벌떡 머리를 들어 봅니다. 시간은 벌써 여덟 시 반, 김 군은 오늘까지 Smalltalk 글토막을 제출해서 팀장에게 검사 를 받아야 합니다. 그런데 남은 시간은 30분. 자신을 깨워준 동료에게 감사 하다는 말을 전한 뒤 김 군은 이제 Smalltalk 시스템을 실행합니다. 머리가 복잡합니다. 그러나 일단 한 가지 한 가지씩 문제를 해결하면 길이 보일 듯도 합니다. 먼저 김 군은 섭씨 온도를 화씨 온도로 바꾸는 공식부터 Smalltalk를 사용해서 짜기로 했습니다. 9 f = 32 + --- c 5 일단 Smalltalk에서 분수는 "/"를 써서 나타내야 합니다. 그러므로 f = 32 + 9/5 c → (1) 로 바꿀 수 있습니다. 그러나 (1)의 경우는 문제가 있습니다. Smalltalk를 사용해서 계산을 할 때에는 연산수와 연산자가 알맞게 배치되어야 합니다. 그런데 위의 경우 "9/5"와 "c" 사이에는 아무런 연산자가 없습니다. 따라서 이 위치에 적당한 연산자를 넣어줄 필요가 있습니다. 수학에서 식을 세울 때 곱셈 연산자를 사용하지 않습니다. 그러므로 위의 계 산식은 곱셈 연산자를 사용해서 아래와 같이 고칠 수 있습니다. f = 32 + 9/5 * c → (2) 자, 그럼 이제 공식 하나가 완성된 것일까요? 물론 일반적인 경우라면 위의 공식에는 이상이 없을 것입니다. 그러나 김 군은 Smalltalk를 사용해야 합니 다. 앞에서 "길수(method)의 우선 순위"에 대해서 공부한 바와 같이, Smalltalk에서는 __겹마디 지시(binary message)는 무조건 왼쪽에서 오른쪽 으로 가늠된다__는 규칙이 존재합니다. 그러므로 위의 식은 먼저 "32 + 9"가 가늠되어버립니다. 따라서 "9/5"를 제대로 분수로 만들어 주기 위해서는 괄 호를 사용해서 식을 고칠 필요가 있습니다. f = 32 + (9/5) * c → (3) 그런데 여기서 끝난 것이 아닙니다. 공식에서는 분명히 덧셈보다 곱셈이 먼 저 게산 되어야 합니다. 즉 "(9/5)"와 "c"를 곱한 뒤에 "32"를 더해야 하므 로, 역시 (3)에 괄호를 하나 더 둘러주어서 연산의 우선 순위를 명확히 해 줍니다. f = 32 + ((9/5) * c) → (4) 그런데 (4)의 공식이 Smalltalk에서 실행된다면 어차피 "9/5"를 둘러싸고 있 는 괄호는 필요가 없습니다. 왜냐하면 길수의 우선 순위에 따라서 "/" 길표 (selector)가 "*" 길표보다 먼저 가늠될 것이기 때문입니다. 그래서 다음과 같이 계산식을 줄일 수 있습니다. f = 32 + (9/5 * c) → (5) 완성입니다. 이제 섭씨 온도를 화씨로 바꾸는 일은 모두 끝난 셈입니다. 다 음으로 탄소 막대의 길이를 구하는 공식을 Smalltalk 글토막으로 만들어 봅 시다. s = s0(1 + Af) 회사의 자료에 따르면 "s0"의 값은 30이라고 했으므로, 다음과 같은 글토막 을 만들 수 있습니다. s = 30 * (1 + (6.7e-6*f)) 위의 글토막 역시 공식에서 생략된 곱셈 연산자를 붙여주고 연산의 우선 순 위를 올바르게 바꾸어주기 위해서 각 항에 괄호를 둘러주었습니다. 이제 위 의 두 개의 글토막을 하나로 합쳐서 바탕글을 만들면 아래의 <바탕글 1>과 같이 될 것입니다. <바탕글 1> 탄소막대 길이 구하기 (1) ---------------------------------------------------------- c = 500 f = 32 + (9/5 * c) s = 30 * (1 + (6.7e-6*f)) ---------------------------------------------------------- 바탕글에서는 "c"라는 변수를 두어서 섭씨 온도 500도를 나타내도록 했습니 다. 이제 김 군은 위의 <바탕글 1>을 가늠하기 위해서 일터(workspace)를 열 고 글토막을 입력한 뒤 떨리는 손으로 글토막을 펴 봅니다. 잠시 후, 김 군 은 경악하고 맙니다! 오호, 통제라~! 도대체 김 군이 작성한 <바탕글 1>에 어떤 문제가 있는지 우리도 직접 바탕 글에 덩이(block)를 씌운 뒤 "Workspace > Display It" 명령을 실행하거나 글쇠를 눌러서 글토막을 펴 봅시다. 그러면 다음 <그림 3-17>, <3-18>과 같은 결과를 얻을 수 있을 것입니다. 이 그림을 보게 되면 어째서 왜 김 군이 경악을 금치 못했는지를 알 수 있을 것입니다. <그림 3-17> <바탕글 1>을 가늠하기 위해 덩이를 씌운 모습 (Stp3-17.gif) <그림 3-18> "undeclared" 잘못 발생 (Stp3-18.gif) <그림 3-18>을 보면 멀쩡하던 바탕글이 갑자기 붉은 색으로 바뀌어 있고, "c"라는 글자에 덩이가 씌워져 있습니다. 번역기가 바탕글을 번역할 때 "c" 때문에 문제가 있다고 알려주는 것입니다. 도대체 어떤 문제가 있는 것일까 요? 잠시 일터 아래에 있는 상태 표시줄을 살펴보면 역시 붉은색의 금지표시 와 함께 다음과 같은 글이 씌여 있음을 보게 될 것입니다. Error: undeclared 'c' 잘못(error)이 있답니다. "undeclared"란 말은 "선언되지 않았다"는 말이기 때문에, 위의 문장은 "'c'라는 것을 선언하지 않아서 잘못이 생겼습니다"라 는 뜻입니다. 자, 이제 김 군이 무슨 실수를 했는지 아시겠습니까? Smalltalk에서 어떤 객체에 이름을 붙이거나 계산 결과로 만들어진 객체를 묶어두기 위해서는 꼬리표(variable)를 붙어야 한다고 했습니다. 우리의 바 탕글에서 꼬리표믄 c, f, s 세 개가 쓰였습니다. 그런데 Smalltalk에서 꼬리 표를 쓰기 전에는 언제나 __선언을 먼저 해 주어야__ 한다고 설명한 바 있습 니다. 물론 일터 꼬리표(workspace variable)나 큰(global) 꼬리표의 경우 사용하는 것 자체가 바로 꼬리표를 선언하는 것이지만, 우리는 덩이를 씌운 글토막 안에서 꼬리표를 사용해야 하기 때문에, 작은 꼬리표(temporary variable)를 써야 합니다. 작은 꼬피표를 선언하기 위해서는 글토막 윗부분에 세로 막대 두 개를 세우 고 이 막대 사이에 바탕글에서 쓸 작은 꼬리표의 이름을 적어주면 되는 것입 니다. 우리의 경우는 c, f, s, 세 개의 꼬리표를 사용할 것이므로 아래와 같 이 써 줄 수 있습니다. | c f s | 이렇게 하면 작은 꼬리표 세 개가 생기고 이 꼬리표에 여러 가지 객체를 붙 일 수 있습니다. 뒤늦게 이런 사실을 깨달은 김 군이 수정한 <바탕글 2>를 살펴보도록 합시다. <바탕글 2> 탄소막대 길이 구하기 (2) ---------------------------------------------------------- | c f s | c = 500 f = 32 + (9/5 * c) s = 30 * (1 + (6.7e-6*f)) ---------------------------------------------------------- 이제 더 이상의 문제가 생기지 않기를 바라면서 김 군은 <바탕글 2>를 가늠 합니다. 그러나... 산 넘어 산입니다. <그림 3-19>를 보십시오. <그림 3-19> "SmallInteger does not understand #f" (Stp3-19.gif) <바탕글 2>를 가늠해 보면 <그림 3-19>와 같이 발자취 창(walkback window) 이 나타납니다. 시간은 이제 8시 40분. 큰일입니다. 마감 시간은 다가오는데 자꾸만 문제가 생기다니.... 발자취 창의 제목 표시줄을 보면 "SmallInteger 는 #f를 이해할 수 없습니다"라는 말이 씌여 있습니다. 즉 이 말은 "SmallInteger 갈래에 딸린 어떤 객체가 있는데, 이 객체는 #f라고 하는 지 시를 알아들을 수 없습니다"라는 말입니다. 그럼 도대체 SmallInteger 갈래 의 실체와 #f라는 지시의 정체는 무엇일까요? 이런 문제가 생길 때일수록 문제 자체에 집착하면 낭패를 봅니다. 잠시 다른 각도에서 생각을 해 봅시다. 우리는 <바탕글 2>에서 SmallInteger 실체에게 'f'라는 지시를 보낸 일이 __결코 없습니다__. 그런데 Smalltalk는 <바탕글 2>를 SmallInteger 실체에게 f라는 지시를 보냈다고 이해하고 있습니다. 여 기서 유심히 볼 것은 바로 "f"입니다. "f"는 우리가 작은 꼬리표로 쓰기로 한 것입니다. 그런데 바탕글을 보면 c = 500 f = 32 + (9/5 * c) 와 같은 부분이 있습니다. 잘 보면 "f" 앞에 500이라는 숫자가 있습니다. 그 러고보니 500은 SmallInteger, 즉 작은 정수 갈래의 실체입니다. 그럼 500에 게 'f'라는 지시가 내려졌다는 말인데.... 좀 더 확실히 알아보기 위해서 <바탕글 2>의 모양을 좀 바꾸어서 <바탕글 3> 으로 만들어 보았습니다. 일단 열려 있는 발자취 창을 "Terminate" 단추를 눌러서 닫은 뒤에 아래 바탕글을 유심히 살펴봅시다. <바탕글 3> 탄소막대 길이 구하기(3) ---------------------------------------------------------- | c f s | c = 500 f = 32 + (9/5 * c) s = 30 * (1 + (6.7e-6*f)) ~~~~~ ---------------------------------------------------------- Smalltalk에서 바탕글을 쓸 때에는 줄을 바꾼다거나 빈칸을 얼마큼 넣는다거 나 하는 것이 문제가 되지 않습니다. 따라서 위와 같이 여러 개의 문장을 한 줄에 늘어놓아도 실행에는 아무런 지장이 없다는 말인데.... 위에서 밑줄 친 곳을 잘 살펴보십시오. 여러 줄의 바탕글을 한 줄로 만들어 놓고 보니 이제야 문제가 보입니다. 위와 같이 해 놓으면 당연히 "500"에 'f'라는 지시를 보내는 꼴이 됩니다. 이게 말이 됩니까? 당연히 작은 정수 500은 'f'라는 지시에 대해서 반응할 길수가 없기 때문에 발자취 창을 표시 하고 만 것입니다. 자, 그럼 어떻게 해야할까요? 지금까지의 바탕글에서 잘못된 것이 무엇이겠 습니까? 네, 바로 마침표(.)입니다. Smalltalk에서 한 문장이 끝난 뒤에는 반드시 마침표가 필요합니다. 그러나 지금까지는 한 문장이 끝난 뒤에 마침 표를 찍지 않았습니다. 이제 김 군도 원인을 알았으니 <바탕글 3>에 마침표 를 붙여서 아래의 바탕글을 만들었습니다. <바탕글 4> 탄소막대 길이 구하기 (4) ---------------------------------------------------------- | c f s | c = 500. f = 32 + (9/5 * c). s = 30 * (1 + (6.7e-6*f)). s. ---------------------------------------------------------- 위에서 각 문장이 끝날 때 마침표를 찍어주었습니다. 그리고 맨 마지막에 붙 임 "s."는 위의 바탕글에서 계산한 결과를 좀 더 확실히 보여주기 위해서 넣 은 것입니다. 어떤 객체나 객체가 붙어 있는 꼬리표를 있는 그대로 펴면 그 내용이 그대로 일터에 나타남을 기억하고 계시겠지요? 자, 이제 끝이 눈에 보입니다. 위의 <바탕글 4>를 다시 원래대로 한 줄에 한 명령이 들어갈 수 있도록 <바탕글 5>로 모양을 바꾸어 봅시다. 아무래도 한 줄에 여러 가지 명령이 있는 것보다는 한 줄에는 한 개의 명령만 있는 것이 바탕글을 읽는 데에도 도움이 됩니다. <바탕글 5> 탄소막대 길이 구하기 (5) ---------------------------------------------------------- | c f s | c = 500. f = 32 + (9/5 * c). s = 30 * (1 + (6.7e-6*f)). s. ---------------------------------------------------------- 바탕글이 훨씬 알아보기 쉬워졌습니다. 이렇게 만들어진 <바탕글 5>에 덩이 를 씌워 가늠해 봅시다. 이제부터 김 군의 문제는 우리의 문제도 된 것입니 다. 이번에는, 정말 이번에는 되겠지요? 힘을 내고 <바탕글 5>를 펴 봅시다. <그림 3-20> UndefinedObject does not understand #multiplyByFraction: 잘못 발생 (Stp3-20.gif) 으악~~~~! 필자도 경악하고 맙니다... --: .... 또다시 발자취 창이 나타납니다. 그런데 이번에는 설상가상으로 쓰지도 않은 갈래의 실체와 듣도 보도 못한 길표가 불쑥 튀어나왔습니다. 도대체 UndefinedObject는 어디서 튀어나왔고, #multiflyByFraction:은 뭘 하는 길 표인지, 답답하기만 합니다. 어디서부터 시작해야할지 모르겠습니다.... --: 이제 시간은 10분밖에 남지 않았는데.... 분명히 답이 있습니다. 답은 바로 발자취 창에서 찾아야 합니다. 발자취 창 에는 문제가 발생하기까지 어떤 길수들을 사용했는지에 대한 발자취가 나타 나 있습니다. 우리는 이 발자취를 되짚어 따라감으로써 문제의 원인을 알아 낼 수 있습니다. 보통 발자취 창에 표시된 제목만 보면 어떤 잘못인지를 금 방 이해할 수 있지만, 지금과 같은 경우는 발자취 그 자체가 도움이 됩니다. 발자취 창에 표시된 발자취를 아래에 적어봅니다. 발자취를 되짚어 따라가기 위해서는 아래에서부터 위로 올라오면서 읽어야 한다는 것을 잊지 마십시오. UndefinedObject(Object)>>doesNotUnderstand: Fraction>>* UndefinedObject>>{unbound}doIt CompiledExpression>>value: SmalltalkWorkspace>>evaluateRange:ifFail: SmalltalkWorkspace>>displayIt ...(이하 생략)... 위의 발자취를 보면 Smalltalk의 일터에 있는 displayIt이란 길수가 처음 사 용되었음을 볼 수 있습니다. 우리가 글토막에 덩이를 씌운 뒤 를 사 용하여 글토막을 가늠하면 이와 비슷한 형식의 발자취가 생깁니다. 아무튼 어찌어찌해서 발자취를 따라가다 보면 다음의 두 줄을 발견할 수 있습니다. UndefinedObject(Object)>>doesNotUnderstand: Fraction>>* 열심히 바탕글이 실행됩니다. 그러다가 Fraction 갈래의 실체, 즉 분수 객체 에게 #* 지시가 내려집니다. 그런데 문제는 이 다음줄, 즉 UndefinedObject 에게 #multiplyByFraction이라는 지시가 내려졌다는 것입니다. 우리는 바탕 글에서 UndefinedObject를 쓴 적도 없고, #multiplyByFraction이라는 길수를 사용한 적도 없습니다. 정말 환장할 노릇입니다. 그러나 아무튼 분수 객체에 #* 지시가 보내지면서부터 문제가 시작되는 것으로 생각해야 좋을 것입니다. 바탕글에서 Fraction, 즉 분수 객체는 "9/5"인데, 이 분수가 사용된 부분을 아래에 보이겠습니다. f = 32 + (9/5 * c). 위의 글토막을 길수의 우선 순위를 생각하면서 따라가 봅시다. 먼저 괄호가 쳐 진 "(9/5 * c)"가 계산될텐데, "9/5"의 #/ 지시가 먼저 실행 될 것입니다. 그러면 이제 "9/5"는 엄연한 분수 객체가 됩니다. 이제 이 객 체에게 #* 지시가 내려지는데, #* 지시는 겹마디 지시이므로, #* 길표 오른 쪽에 있는 객체를 인자(parameter)로 취합니다. 여기서 #*, 즉 곱셈 연산자 의 인자는 바로 "c"가 됩니다. 그런데 바탕글에 의하면 "c" 꼬리표는 500에 붙어 있어야 합니다. 그런데 여기서 문제가 생긴다는 것은 결국 "c"라는 꼬 리표에 어떤 문제가 있다는 것으로 생각할 수 있습니다. 도대체 "c" 꼬리표 는 어떤 객체에 붙어 있을까요? <바탕글 5>에서 다음의 두 줄에만 더이를 씌운 후 펴 봅시다. | c f s | c = 500 ☞ false <그림 3-21> "false"를 결과로 넘긴 화면 (Stp3-21.gif) 어라? "거짓"(false)? 뭐가 거짓이라는 말이지? 이해가 안 갑니다. "c"라는 꼬리표에 500을 붙였으니 당연히 꼬리표에 붙인 500이라는 객체가 그대로 결 과로 나타나야 하는데, '거짓'이라니... 뭔가 잘못되어가고 있는 듯 합니다. 객체를 꼬리표에 붙였는데 왜 거짓이라는 결과가 나올까..... 객체를 꼬리표 에 붙여? __붙인다__... 붙여..? 그래! 붙임표! 네! 이제 문제를 알아 낸 것 같습니다. Smalltalk에서 꼬리표에 어떤 객체를 붙이기 위해서는 붙임표를 써야 하는데, 그 붙임표가 바로 ":="입니다. 반면 "="은 두 객체가 같은지 다른지를 비교하는 길표였습니다. 결국 위의 바탕글은 c와 정수 500을 비교하는 것인데, 꼬리표 c가 붙어 있는 객체와 500이 서로 달랐기 때문에 거짓(false)을 넘겼을 것입니다. 그럼 꼬 리표 c는 어디에 붙어 있을까요? 바탕글에서 다음 까지만 덩이를 씌워서 가 늠해 보십시오. | c f s | c ☞ nil <그림 3-22> c 꼬리표는 아무것에도 붙어 있지 않았다! (Stp3-22.gif) 그림에서 보듯이 c 꼬리표에는 아무 것도 붙어 있지 않았습니다. 'nil'이란 "헛것, 비어있는 것, 없는 것"을 나타내기 때문에, 결국 c꼬리표는 아무런 객체에도 붙어 있지 않았던 것입니다. 결과적으로 헛(nil)과 정수 500을 서 로 비교하라고 했으니 거짓(false)이 나올 수 밖에요. 자, 그럼 이제 바탕글에 있는 모든 "="을 붙임표인 ":="으로 바꾸어야 하겠 지요? 이렇게 해서 수정된 것이 <바탕글 6>입니다. <바탕글 6> 탄소막대 길이 구하기 (최종판) ---------------------------------------------------------- | c f s | c := 500. f := 32 + (9/5 * c). s := 30 * (1 + (6.7e-6*f)). s. [실행 결과] ☞ 30.187332 ---------------------------------------------------------- 고국에 계신 동포 여러분, 기뻐해 주십시오! 드디어 바탕글이 제대로 돌아갑 니다. 계산기를 사용해서 검산을 해 봐도 역시 똑같습니다. 결과가 맞게 나 타납니다. 이렇게 기쁠 수가! 드디어 해 냈습니다! 검산을 끝내자마자 시계는 아침 아홉 시를 가리킵니다. 때마침 팀장이 김 군 의 책상을 방문합니다. "다 됐으면 실행 한 번 해 보세요." 굵은 팀장의 목소리가 들립니다. 김 군은 자신 있게 바탕글을 가늠해서 결과 를 출력해 보였습니다. 팀장은 만족한 듯 했습니다. "아주 잘 했군요. 그럼 섭씨 100도일 때 막대의 길이를 구할 수 있 겠어요? 지금 바로 구해 보세요." 김 군은 처음부터 "c"라고 하는 꼬리표를 사용했기 때문에 여러 가지 온도에 따른 결과를 출력하는 것은 식은 죽 먹기였습니다. 단순하게 "c" 꼬리표에 500 대신 100이라는 객체만 바꾸어 붙여주고 바탕글을 펴면 되는 일이었습니 다. 아래 <그림 3-23>를 보면 오른쪽에 결과가 나타납니다. <그림 3-23> 여러 가지 온도에 대한 결과 출력 (Strp3-23.gif) "아주 좋군요. 프로그램을 조금만 수정해도 결과가 쉽게 출력되니까 참 편리합니다. 수고했어요. 하지만 바탕글이 읽기가 좀 어렵군요." 김 군은 드디어 첫 번째 프로젝트를 끝냈습니다. 부스스한 머리, 푸석푸석한 얼굴, 벌게진 눈, 부르튼 입술. 빤질빤질했던 김 군의 평소 모습과는 완전히 다른 모습으로 바뀌어 있었지만, 김 군은 무언가를 이루어냈다는 기쁨이 컸 습니다. 더구나 팀장의 칭찬까지 받았으니... 그러나 팀장의 마지막 한 마디 가 앙금이 되어 남습니다. "하지만 바탕글이 읽기가 좀 어렵군요." 무슨 말일까... 바탕글을 쓸 때에도 읽기 쉽게 쓰는 법이 있을까? 이 생각 저 생각을 하고 있는 사이, 바로 옆에서 오늘 김 군을 깨워 준 동료가 한 마 디 합니다. "자네, 오늘 내가 깨워줘서 살았어. 그러니까 술 한잔 사야지?" 계속... 제 목:[강좌] Smalltalk 배우기 #30 관련자료:없음 [144] 보낸이:김찬홍 (지니반쪽) 2000-03-03 17:18 조회:69 Smalltalk 배우기 #30 2000. 3. 3. 김찬홍 mailto:andrea92@hitel.net ====================================== 3. 객체로 채워진 세상 3.1. 알아보자, 알림판! 3.2. 꼬리표 인생 3.3. 운동장 놀이 3.4. 앗, 나의 실수!!! 3.4.1. 김 군의 하루 3.4.2. 실수, 또 실수 b→3.4.3. 기독성과 효율성 3.4.4. 성공의 비결은 실패 ........ ======================================= 3. 객체로 채워진 세상 --------------------------- 3.4. 앗, 나의 실수!!! ~~~~~~~~~~~~~~~~~~~~~ #29에서... 3.4.3. 기독성과 효율성 ---------------------- '바탕글을 읽기 쉽게 짜라는 말이 무슨 소리일까?' 소주 몇 잔에 거나해진 김 군은 집으로 돌아오면서 이런 생각을 곱씹어 봅니 다. 술자리에서 친구는 '프로그램을 만들기 위해서 쓰는 바탕글(source code)도 엄연히 '글'이기 때문에 사람이 읽기 쉬워야 한다'는 생각을 김 군 에게 피력했습니다. 아울러 그는 다음과 같은 말을 짖지 않았습니다. "바탕글이 읽기 쉬워야 하는 것도 중요하지만, 프로그램의 효율성도 함께 생각해야 돼. 자네가 짠 바탕글은 효율성도 그리 좋지 않았어." 물론 친구는 김 군을 생각해서 한 말이었지만 왠지 모르게 김 군의 어깨는 축 처지기만 합니다. 열심히 했는데, 그래서 결과도 좋았는데, 막상 자신이 짠 바탕글이 읽기도 어려웠고 바탕글의 효율성도 떨어진다는 말을 들으니 의 기소침 해 진 것. 이제 집으로 걸어가는 김 군을 위로해 줄 사람은 바로 이 글을 쓰고 있는 저와 제 글을 읽고 있는 여러분입니다. 자, 김 군의 바탕글 이 왜 일기도 어렵고 효율적이지도 못한지에 대해서 차근차근 살펴보고, 김 군에게 따스한 조언이라도 한 마디 해 주면 좋겠지요? 프로그램을 작성하는 사람들은 '어떻게 하면 프로그램이 효율적으로 실행될 까'라는 문제에 대해서 고민을 하곤 합니다. 물론 이제 막 Smalltalk를 공부 하고 있는 여러분들이 프로그램의 효율성에 지나치게 얽매일 필요는 없습니 다. 그러나 효율성이란 무엇이며, 이것이 왜 필요한지, 그리고 어떻게 하면 프로그램의 효율성을 높일 수 있는지에 대해서 알아두는 것은 필요한 일이라 고 생각합니다. 효율성(efficiency)이란 가장 적은 수의 명령어와 기억공간을 사용하여 일을 처리하는 것을 말합니다. 그러니까 똑같은 일을 하더라도 어떤 사람은 이것 저것 부산하게 많은 일을 하는 사람이 있는가 하면, 또 다른 사람은 꼭 필요 한 일만 하는 경우가 있는데, 이 두 가지 경우 중에 뒤의 경우가 효율성이 좋다고 볼 수 있습니다. 그럼 김 군의 바탕글을 다시 한 번 살펴보면서 왜 효율성이 떨어지는지를 살 펴보도록 합시다. <바탕글 6> 탄소막대 길이 구하기 (최종판) ---------------------------------------------------------- | c f s | c := 500. f := 32 + (9/5 * c). s := 30 * (1 + (6.7e-6*f)). s. ---------------------------------------------------------- 이 바탕글에서는 정수(SmallInteger), 분수(Fraction), 소수(Float)의 세 개 의 객체가 사용되고 있습니다. 그런데 "2.2.6. 고급 셈! 셈! 셈!"에서 분수 와 소수를 정수와 섞어 쓸 경우에는 계산이 이루어지기 전에 일단 연산수가 소수로 바뀐다고 이야기한 적이 있습니다. 그러면 위의 바탕글이 계산될 때 에는 어떤 변화가 일어나는지를 살펴봅시다. | c f s | c := 500. c := 정수 f := 32 + (9/5 * c). f := 정수 * 분수 * 정수 s := 30 * (1 + (6.7e-6*f)). s := 정수 * (정수 + (소수*분수)). s. 소수 먼저 처음 꼬리표 "c"에 정수값이 대입됩니다. 그 다음에 아래의 문장이 실 행됩니다. f := 32 + (9/5 * c). ~~~ 그런데 위의 경우 계산식에 분수 "9/5"가 있기 때문에 계산되기 전에 모든 연산수가 일단 분수로 바뀝니다. 그래서 결과적으로 꼬리표 "f"에는 분수값 이 들어갑니다. 물론 운이 좋아서 계산 결과가 정수로 약분이 되면 다행이겠 지만, 대부분의 경우 "f" 꼬리표에는 분수값이 들어갑니다. 이제 "s" 꼬리표에 값을 계산하여 넣기 위해 다음의 문장이 실행됩니다. s := 30 * (1 + (6.7e-6*f)). ~~~~~~ 이 계산식은 정수, 분수, 소수를 모두 포함하고 있습니다. 따라서 모든 연산 수가 소수로 바뀌어 계산이 이루어집니다. 결과적으로 <바탕글 6>은 계산이 수행될 때마다 여러 객체들이 정수에서 분수나 소수로 바뀌게 됩니다. 정수 에서 분수로 변환되는 것은 별로 어렵지 않지만, 어떤 객체가 소수(Float)로 바뀔 때에는 생각보다 비싼 대가를 치러야 합니다. 우리 눈에는 보이지 않지 만 "(9/5)"가 "1.8"이라는 소수로 바뀌기까지는 족히 수십 개의 명령이 수행 되어야 합니다. 따라서 프로그램에서 소수(float)를 사용하는 계산식이 있을 때에는 서로 다 른 갈래의 객체들이 소수로 변환되기 때문에 걸리는 시간을 최소화할 필요가 있습니다. 그래서 다음과 같이 바탕글을 고칠 수 있습니다. <바탕글 7> 탄소막대 길이 구하기 (소수 사용) ---------------------------------------------------------- | c f s | c := 500.0. f := 32.0 + (1.8 * c). s := 30.0 * (1.0 + (6.7e-6*f)). s. ---------------------------------------------------------- <바탕글 7>을 살펴보면 식에 사용된 모든 객체가 소수뿐임을 알 수 있습니 다. 이렇게 하면 객체들 사이의 변환 과정이 필요없기 때문에 좀 더 효율적 인 바탕글을 만들 수 있습니다. 그런데 잘 보면 <바탕글 7>은 효율성은 뛰어날지 몰라도 글을 읽기가 오히려 <바탕글 6>보다 어렵습니다. "30"과 같이 정수로 표시해도 될 것을 효율성 때문에 "30.0"과 같이 썼기 때문입니다. 이렇게 효율성을 중시하면 바탕글의 기독성이 떨어질 수 있습니다. 앞에서 '효율성'이란 수행되는 명령의 수가 적어야 하고 또한 __기억 공간을 적게 사용하는__ 것이라고 말한 바 있습니다. 이렇게 본다면 지금까지 우리 가 Smalltalk에서 사용하는 꼬리표(variables)도 기억 공간을 차지합니다. 따라서 바탕글을 쓸 때 아예 꼬리표를 쓰지 않게 되면 꼬리표 때문에 들어가 는 기억 공간을 줄일 수 있습니다. 다음 글토막을 살펴봅시다. 30 * (1 + (6.7e-6 * (32 + (9/5 * 500)))) ☞ 30.187332 위의 글토막은 꼬리표를 전혀 쓰지 않고 만들어본 글토막입니다. <바탕글 7> 과 같이 소수점으로 식을 고치게 되면 다음과 같이 되겠지요? 30.0 * (1.0 + (6.7e-6 * (32.0 + (1.8 * 500.0)))) ☞ 30.187332 위의 글토막은 꼬리표를 전혀 쓰지도 않았고, 모든 객체를 소수로 바꾸어 표 현했습니다. 따라서 Smalltalk 입장에서 보면 매우 효율성이 뛰어난 것임에 분명합니다. 그런데, 위의 두 개의 글토막을 가만히 살펴봅시다. 이 글토막 이 탄소막대를 구하는 것이라고 누가 생각할 수 있겠습니까? 도대체 뭘 하는 바탕글인지 알 수가 없습니다. 만약 여러분이 위와 같은 글토막을 써 놓고 일 주일 쯤 푹 쉬었다가 다시 위의 글토막을 문득 발견했다고 생각해 보십시 오. 과연 그 때도 여러분은 저 글토막이 '탄소 막대 구하는 글토막'이라는 사실을 깨달을 수 있겠습니까? 자, 그럼 위에서 만든 글토막을 가지고 섭씨 100도일 때의 탄소 막대의 길이 가 얼마인지 구한다고 해 봅시다. 위의 글토막에서 무엇을 고쳐야 할지 금방 보고 알 수 있을까요? 이런 경우도 생각해 봅시다. 만약 '별누리' 회사가 때돈을 벌어서 탄소 막대 대신 전도율이 훨씬 좋은 백금으로 막대를 만들었다고 해 봅시다. 그럼 이번 에는 탄소 막대가 아니라 백금 막대의 길이를 측정해야 합니다. 섭씨 500도 일 때 백금의 길이를 구하려고 한다면 위의 글토막을 어떻게 고쳐야 하겠습 니까? 여러분이 직접 해 보십시오. 열이면 열, 대부분의 사람들이 저런 숫자 들만 나열된 글토막을 붙들고 씨름하고 있을 게 뻔합니다. 자, 위의 글토막이 정말로 효율성이 있어 보입니까? 물론 컴퓨터 입장에서 보면 효율성이 좋은 글입니다. 그러나 위의 글토막은 사람이 알아보기가 너 무 어렵습니다. 따라서 효율성에서 바탕글의 기독성(readability)을 생각하 지 않을 수 없게 되는 것입니다. 그럼 여기서 우리는 고민을 해봐야 합니다. 효율성이냐, 바탕글의 기독성이 냐. 저는 이 두 가지 중에 하나를 고르라고 한다면 바탕글의 기독성을 택하 겠습니다. 왜냐하면 어떤 프로그램이라도 한 번 만들어지면 나중에 분명히 고쳐야 할 때가 있기 때문입니다. 프로그램을 고치려면 자신이 무슨 생각으로 바탕글을 썼는지를 알아볼 수 있 어야 하는데, 효율성만 중시한 나머지 바탕글을 암호와 같이 짜 놓았다면, 나중에 어떻게 고치겠습니까? 따라서 저는 아래와 같은 말을 여러분에게 해 드리고 싶습니다. "바탕글은 한 번 씌여지고 여러분 읽혀진다." 따라서 바탕글이 길어지더라도 읽기 쉽게 만들어야만 나중에 고치기가 쉽습 니다. 물론 지금까지 우리들이 만들어온 바탕글은 길어봐야 열 줄이 체 안 되는 것들이었습니다. 그러나 여러분이 나중에 큰 프로그램을 짜게 될 때 바 탕글을 읽기 쉽게 쓰지 않으면 프로그래밍 자체가 불가능해집니다. 따라서 바탕글을 쓸 때 효율성보다는 기독성에 초점을 맞추어 작성해야 한다고 필자 는 생각합니다. 일단 바탕글을 읽기 쉽게 쓰고 난 다음 좀 더 높은 효율성이 필요하면 그 때 가서 바탕글을 고치면 됩니다. 그래야만 프로그램을 만들어 놓고 필요할 때마다 고쳐서 쓸 수 있습니다. 그러면 바탕글을 읽기 쉽게 만들기 위해서는 어떻게 해야 할까요? 답은 바로 "이름을 잘 짓는 것"입니다. 프로그램을 짜다 보면 이름을 지어야 할 때가 많이 있습니다. 대표적으로 꼬 리표의 이름을 지을 때입니다. 앞에서 김 군은 세 개의 꼬리표를 "c, f, s" 라는 이름으로 지었습니다. 그런데 이렇게 꼬리표를 붙이는 것은 바탕글을 매우 읽기 어렵게 만듭니다. 물론 수학에서 변수를 쓸 때에는 a, b, x, y와 같이 이름을 붙입니다만, 프로그래밍은 수학이 아닙니다. 프로그래밍은 어디 까지나 사람의 생각을 나타내야 하기 때문에 수학 공식에서처럼 이름을 짧게 붙여서는 안됩니다. 이름을 지을 때에는 그 이름이 __내용을 충분하게 설명할 수 있도록__ 지어 야 합니다. 다시 말해서, 이름만 척 보면 그게 어떤 것인지를 알 수 있어야 한다는 말입니다. 만약 여러분이 인공위성에 대한 지식이 전혀 없는 상태에 서 김 군이 만든 <바탕글 6>을 본다면 도대체 'c, f, s'가 무엇을 의미하는 지 알 수 있겠습니까? 바탕글을 읽기 쉽게 만들기 위해서 이름은 최소한 한 개 이상의 의미 있는 단어를 사용해서 짓도록 하십시오. 아래 <바탕글 8>을 보십시오. <바탕글 8> 탄소막대 길이 구하기 (꼬리표 이름 변경) ---------------------------------------------------------- | centigrade fahrenheit length | centigrade := 500. fahrenheit := 32 + (9/5 * centigrade). length := 30 * (1 + (6.7e-6 * fahrenheit)). length. ---------------------------------------------------------- "c, f, s"로 되어 있던 꼬리표의 이름을 각각 '섭씨'(centigrade), '화 씨'(fahrenheit), '길이'(length)를 나타낼 수 있도록 이름을 고쳤더니 읽기 가 훨씬 쉬워졌습니다. 물론 'centigrade'나 'fahrenheit'과 같은 단어들이 생소한 사람에게는 자칫 바탕글이 더욱 어렵게 보일 수 있겠지만, 각 단어의 의미가 무엇인지 파악하면 위의 바탕글을 읽기는 훨씬 쉬워질 것입니다. 위의 예와 같이 바탕글에서 어떤 수식을 쓸 경우 숫자 자체에 어떤 의미가 붙어 있으면, 숫자를 그대로 쓰지 말고 일단 꼬리표를 붙여서 쓰게 되면 바 탕글을 훨씬 읽기 쉽게 만들 수 있습니다. <바탕글 8>에서 "30"은 탄소 막대의 처음의 길이이고, "6.7e-6"은 탄소 막대 의 확장 계수입니다. 따라서 여기에도 이름을 붙여서 바탕글을 쓰게 되면 글 이 훨씬 읽기 쉽게 됩니다. <바탕글 9>를 보십시오. <바탕글 9> 탄소막대 길이 구하기 (읽기 쉬운 바탕글) ---------------------------------------------------------- | centigrade fahrenheit length initialLength coefficient | centigrade := 500. "섭씨 온도" coefficient := 6.7e-6. "탄소막대의 확장 계수" initialLength := 30. "화씨 0도일 때의 처음 길이" fahrenheit := 32 + (9/5 * centigrade). length := initialLength * (1 + (coefficient * fahrenheit)). length. ---------------------------------------------------------- <바탕글 9>에는 탄소 막대의 처음 길이를 나타내는 'initialLength'와 확장 계수를 나타내는 'coefficient'라는 두 개의 꼬리표를 사용했습니다. 그리고 간단한 풀이글을 달아서 각각의 꼬리표가 어떤 역할을 하는지를 좀 더 명확 하게 나타냈습니다. 이와 같이 바탕글을 쓰게 되면 일 주일이 아니라 1년이 지난 뒤에 다시 바탕글을 보더라도 쉽게 바탕글을 이해할 수 있음은 물론, 탄소 막대가 아니라 황금 막대라 하더라도 확장 계수(coefficient)와 화씨 0 도일 때의 처음 길이(initialLength)만 알면 쉽게 결과를 얻을 수 있습니다. ---<잠깐!>---------------------------------------------------------- 1000 바이트의 예술 한 때 컴퓨터 잡지에서 "1000 바이트의 예술"이라는 제목으로 바탕글 쓰기 경진대회를 한 적이 있습니다. 이 대회에서는 어떤 문제가 주어지고, 그 주 어진 문제를 바탕글로 풀어서 써야 하는데, 이 때 절대로 1000 바이트가 넘 으면 안 된다는 규칙이 있습니다. 보통의 경우 2000~3000 바이트 정도가 되 어야만 풀 수 있는 문제들이지만, 프로그래밍 언어가 가지고 있는 기교란 기 교를 다 부려서 바탕글을 1000바이트가 안 되게 쓰는 사람이 있습니다. 이를 보고 "와, 정말 예술이다"라고 감탄한 적이 있습니다. 그러나 이것은 어디까 지나 즐기기 위한 것일 뿐, 이렇게 쓰여진 바탕글은 보통 사람들은 도저히 읽을 수 없으며, 고치기도 어렵습니다. 우리 나라에 C언어가 처음 보급되기 시작했을 때 사람들은 읽기 어려운 바탕 글을 쓰는 프로그래머가 실력이 있다는 잘못된 생각을 가지고 있었습니다. 그래서 사람들은 갖은 방법을 동원해서 바탕글을 읽기 어렵게 만들고, 이것 을 해설하면서 희열을 느꼈습니다. 물론 이러한 기교를 넣은 바탕글은 실행 효율이 좋을지는 모르겠지만 앞서 예로 든 것과 같이 전혀 읽을 수 없는 바 탕글이 되고 맙니다. 심지어는 바탕글을 쓴 자신 조차도 며칠이 지나면 그 바탕글을 알기 어렵게 되는 경우가 많습니다. 바탕글을 어렵게 쓰는 것은 자만입니다. 자신의 생각을 있는 그대로 표현하 는 것이 바로 진정한 프로그래머입니다. 요즘은 헝가리언 표기법을 많이 사 용하는데, 이것은 보기 좋은 바탕글을 만들기 위한 방법입니다. 이름을 지을 때에도 최대한 읽기 쉽게 짓고, 글을 쓸 때도 최대한 읽기 쉽게 씁니다. 바 로 이러한 경향은 바탕글은 읽기 쉬워야 한다는 것을 보여주는 좋은 보기라 할 수 있겠습니다. ---------------------------------------------------------- 3.4.4. 성공의 비결은 실패 ------------------------- 김 군은 집으로 돌아오면서 자신을 반성하고 있었습니다. '수업이나 잘 들을걸...' '프로그래밍이나 열심히 공부할 걸...' 지나 온 세월들이 후회됩니다. 그렇게 자책하며 집으로 돌아온 김 군은 컴퓨 터를 켰습니다. 문득 편지함에 들어 있는 메일 한 통. "힘 내! 실패는 누구나 다 하는 법이야. 우리가 술 마시고 있을 때 팀장은 또 밤을 세나봐. 자기가 만든 프로그램에서 오류를 찾고 있다나? 피히히!" 친구의 메일이었습니다. 따스한 격려의 말을 전해 준 친구가 김 군은 너무나 고마웠습니다. 다음부터는 좀 더 열심히 공부해야겠다고 생각하면서 김 군은 잠을 청합니다. 10년이 넘게 프로그램만 짜 온 팀장도 실수를 할 수 있다는 것을 위로로 삼으면서.... 그렇습니다. 실수는 누구나 하는 법입니다. 어떤 일을 처리하다가 한 번 실 수를 하게 되면 그 일은 머리에 오래도록 남습니다. 따라서 똑같은 실수를 할 확률은 점점 적어집니다. 또한 그렇게 실수를 함으로써 실력이 느는 것입 니다. 흔히 우리는 전문적인 프로그래머들은 실수를 전혀 하지 않는다고 생각하기 쉽습니다. 그러나 이러한 전문 프로그래머들도 똑같이 실수를 합니다. 프로 그래밍을 직업으로 하는 사람들은 밤을 세워가면서 모니터 앞에서 프로그램 에 숨어 있는 벌레(bug)를 찾아내려고 애를 씁니다. 사람은 완전하지 않기 때문에 사람이 만들어내는 프로그램 역시 벌레를 품고 있습니다. 훌륭한 프로그래머는 실수를 하지 않는 것이 아닙니다. 오히려 훌륭한 프로 그래머란 프로그램에 숨어 있는 벌레를 잘 찾아내고 해결할 수 있는 사람을 말한다고 필자는 생각합니다. 프로그램에 숨어 있는 논리적인 잘못을 '벌레'(bug)라고 부르고, 이러한 논 리적인 잘못, 즉 벌레를 없애는 작업을 "벌래 잡기"(debugging)이라고 합니 다. 아무튼 이제 막 Smalltalk를 공부하는 여러분이나 전문적으로 프로그래 밍을 작성하는 사람이나 똑같이 벌레를 만들어내고, 이러한 벌레를 잡기 위 해서 애씁니다. 그러면 벌레를 잘 잡으려면 어떻게 해야 할까요? 왕도가 없습니다. 그저 많 은 벌레를 잡아보는 수밖에는 다른 길이 없다는 말입니다. 앞으로 여러분들 이 Smalltalk로 프로그래밍을 하다 보면 분명히 많은 벌레와 맞닥뜨리게 될 것입니다. 그러나 포기하지 마십시오. 벌레를 발견했다면 여러분의 실력이 오를 수 있는 기회라고 생각하십시오. 그리고 포기하지 말고 끝까지 벌레를 찾아내어 박멸해야겠다는 생각을 가지십시오. 여러분이 벌레와의 치열한 전 투를 하다 보면 어느새 여러분도 모르게 프로그래밍 실력이 올라 있는 것을 발견하게 될 것입니다. Smalltalk에서는 언제든지 객체와 대화할 수 있고, 벌레를 잡기 위해 필요한 여러 가지 도구들―탐색기(inspector), 벌레잡이 (debugger)―이 마련되어 있으므로 여러분의 벌레 사냥을 도와 줄 것입니다. ========================================= 이번 마디에서 우리는 Smalltalk에서 프로그램을 작성할 때 어떤 실수를 범 할 수 있으며, 이런 실수들을 어떻게 고칠 수 있는지에 대해서 알아보았습니 다. 그리고 읽기 쉬운 바탕글을 작성하려면 어떻게 해야하는지에 대해서도 살펴보았습니다. 이 마디를 통해서 여러분은 바탕글을 쓰는 데 필요한 중요 한 것을 배울 수 있었으리라 생각합니다. 다음 마디부터는 다시 Smalltalk의 객체 탐험이 시작됩니다. 지금까지는 프 로그래머와 객체가 대화를 하는 방법만 설명했지만, 다음 마디부터는 프로그 램을 사용하는 사람들과 프로그램 자체가 어떻게 대화를 할 수 있는지에 대 해서 알아보도록 하겠습니다. 기대하셔도 좋습니다. ^^: 계속... 제 목:[답변] C/C++의 차이는... 관련자료:없음 [146] 보낸이:김찬홍 (지니반쪽) 2000-03-10 14:37 조회:208 >그냥 씨와 씨뿔뿔과 의 차이점이 뭔지좀 알고싶습니다.. 질문이 너무 포괄적입니다. 길거리에서 "우리말과 일본말은 어떤 차이가 있느냐"고 물어보면 사람들이 뭐라고 대답할까요? 마찬가지로 C와 C++의 차이도 똑같습니다. 한 마디로 뭐라고 이야기하기는 어렵습니다. 다만 C언어의 문법을 빌어서 객체지향 패러다임을 구현하기 위해서 만들어진 언어가 C++입니다. 언뜻 보면 C와 닮아 보이지만, C는 명령형 언어이고 C++는 객체지향적 언어이기 때문에 기본 개념이 완전히 다릅니다. 어떤 분은 C++를 잘 하려면 C를 알아야한다고 하시는데, 절대로 그렇지 않습니다. C++를 잘 하려면 객체지향 패러다임을 잘 알아야 합니다. 오히려 어줍잖은 C언어의 지식은 C++를 배우기 어렵게 만들 뿐입니다. >좀 자세히 말씀해주시면 더 감사하구요.. 아쉽지만 그렇게 자세히 설명을 해 드릴 수가 없습니다. 왜냐하면... >아님 이런 자료있는곳이라도 알려주시면... 날 잡아서 교보문고나 종로서적 등 대형 서점에 가셔서 C++의 기초를 설명해 놓은 책 한 권을 잡고, 땅바닥에 퍼질르고 앉아서 세 시간만 읽어보면 어느 정도 감을 잡을 수 있습니다. 아니면 인터넷 검색엔진에서 "C++"이라고 치면 몇백만건의 자료가 나올테니 거기서 찾아보십시오. 그리고 덧붙인다면, 사민님께서 C언어에 대해서 탄탄한 지식이 있으시다면 C와 C++을 비교하는 것이 의미가 있겠지만, 만약 지금 프로그래밍 언어를 배워야 하는데 C와 C++ 중에서 선택을 해야 한다면, 이 둘의 차이를 비교하는 것은 아무런 의미가 없습니다. 흡사 '독일어랑 불어랑 어떤 차이가 있죠?'라는 질문과 같기 때문이지요. 개인적으로는 C보다는 C++을 공부하는 게 좋겠지만, 그것보다는 아예 Java나 Delphi, 또는 Smalltalk 처럼 객체지향을 충분히 나타낼 수 있는 언어를 공부해 보시라고 권하고 싶습니다. 그럼 사민님, 힘내세요! 제 목:[강좌] Smalltalk 배우기 #31 관련자료:없음 [149] 보낸이:김찬홍 (지니반쪽) 2000-03-13 12:11 조회:66 Smalltalk 배우기 #31 2000. 3. 13. 김찬홍 mailto:andrea92@hitel.net ====================================== 3. 객체로 채워진 세상 3.1. 알아보자, 알림판! 3.2. 꼬리표 인생 3.3. 운동장 놀이 3.4. 앗, 나의 실수!!! 3.5. 대화의 창 a→3.5.1. 알림 상자 ........ ======================================= 3. 객체로 채워진 세상 --------------------------- 3.5. 대화의 창 ~~~~~~~~~~~~~~ Smalltalk는 대화형 시스템입니다. 사용자가 컴퓨터에게 어떤 명령을 내리면 컴퓨터는 지체 없이 그 명령을 실행하고 반응을 나타냅니다. 우리가 지금까 지 여러 가지 객체에게 지시(message)를 내리면 객체는 자기가 알아들을 수 있는 지시의 경우에는, 다시 말해서 객체가 지시를 어떻게 처리할 지에 대한 길수(method)를 알고 있다면 그 길수대로 행동하고, 지시를 알아들을 수 없 을 경우에는 발자취 창(walkback window)을 표시했습니다. 이와 같은 환경은 Smalltalk를 공부하는 데에도 매우 편리하고, 실제로 큰 프로그램을 만들 때 도 매우 큰 도움이 됩니다. 그런데 이러한 동작은 모두 프로그램을 만드는 프로그래머와 Smalltalk 사이 의 대화입니다. 프로그래머는 자신이 만든 프로그램을 쓰는 사용자들과 프로 그램이 어떻게 대화해야 할지를 정해줄 필요가 있습니다. Windows와 같은 대 부분의 그림 사용자 환경(GUI)에서는 대화 상자를 사용하여 필요한 정보를 프로그램에 입력하고 알림 상자(message box)를 사용하여 프로그램의 여러 가지 상태를 출력합니다. 우리가 Smalltalk에서 보는 것과 같이 어떤 경우에는 복잡한 모양을 가지는 대화 상자와 알림 상자가 필요할 수도 있지만, 대부분은 간단한 글줄 (string)을 입력할 수 있는 정도의 대화 상자와 프로그램의 간단한 상태를 사용자에게 알려줄 수 있는 알림 상자가 있으면 충분할 것입니다. 대화 상자와 알림 상자를 만들기 위해서는 보임새잡이(View Composer)를 사 용해서 창 위에 여러 가지 연모를 배치해야 합니다. 그러나 간단한 값을 입 력받거나 출력할 때마다 창을 그리고 연모를 배치하고, 이 연모를 조절하기 위해서 여러 가지 객체를 만드는 일은 번거롭기 때문에 Smalltalk에서는 간 단한 대화 상자와 알림 상자를 미리 만들어 놓고 필요할 때마다 사용할 수 있도록 하고 있습니다. 이제 이 마디에서 우리는 Smalltalk에서 미리 제공하는 알림 상자와 값을 입 력하거나 선택할 수 있는 대화 상자를 어떻게 사용하는지에 대해서 알아볼 것입니다. 이 마디의 내용을 모두 이해하고 나면 여러분은 이제 단순히 바탕 글에 있는 내용만 가지고 실행되는 프로그램이 아니라 사용자가 입력한 자료 에 근거해서 실행되는 융통성 있는 프로그램을 만들 수 있게 될 것입니다. 그럼 먼저 알림 상자부터 시작합시다. 3.5.1. 알림 상자 ---------------- 여러분이 Windows를 비롯한 갖가지 프로그램을 사용하다보면 프로그램에서 일어나는 여러 가지 상황을 여러분에게 알려주기 위해서 작은 상자에 몇 줄 의 글을 담아서 화면에 표시할 때가 있습니다. <그림 3-24> "내 컴퓨터" 창이 표시한 알림 상자 (Stp3-24.gif) <그림 3-24>를 보면 "내 컴퓨터" 창을 열고 디스켓을 넣지 않은 상태에서 A: 드라이브를 두 번 눌렀을 때 나타난 알림 상자를 관찰할 수 있습니다. 여러 분은 얼마나 이런 실수를 자주 하는지는 모르겠지만 필자는 머리가 좀 나쁜 관계로 위와 같은 실수를 상당히 자주 합니다. :) 아무튼 위와 같이 여러 가지 프로그램을 사용하면서 사용자에게 알려야 할 사항이 있다면 알림 상자(message box)에 내용을 담아서 나타내고 사용자의 확인 과정을 거치게 됩니다. Smalltalk는 미리 대화 상자를 객체로 포장해 놓고 여러분을 기다리고 있습 니다. 우리가 "3.1" 마디에서 알림판(transcript)에 글을 쓸 때(#22) 어떤 객체를 사용했습니까? 네, 바로 Transcript였습니다. 그래서 우리가 Transcript nextPutAll: '안녕하세요?' 와 같은 글토막을 가늠하면 알림판에 글줄을 써 낼 수 있었습니다. 이것은 알림판이 객체이기 때문입니다. Smalltalk에서는 모든 것이...? 그렇죠! 객 체입니다. 그렇다면 우리가 알아볼 알림 상자 역시...? 네, 그렇지요! 바로 객체입니다. 우리가 알림 상자에게 지시를 내리기 위해서는 Smalltalk에서 알림 상자를 어떻게 부르는지를 알아야 합니다. 다시 말해서 우리는 알림 상자의 이름을 알아야 한다는 것입니다. Smalltalk에서 알림 상자는 "MessageBox"라는 이름이 붙어 있다. 바로 위의 문장이 답입니다. Smalltalk에서 알림 상자에 어떤 지시를 내리고 싶을 때에는 위에서 설명한 것처럼 "MessageBox"라는 이름을 사용합니다. 이 름의 첫 글자가 대문자 인 것을 보니깐 위의 이름은 분명히 큰 꼬리표 (global variable)라는 것을 추측할 수 있었다면 여러분은 지금까지 제 글을 꼼꼼히 읽어오셨다고 말할 수 있겠습니다.(저것이 왜 큰 꼬리표인지 모르겠 다면 "3.2"(#24) 마디로 되돌아가서 다시 한 번 복습을 하는 것이 좋을 것 같습니다. ^^:) 아무튼 MessageBox가 알림상자를 나타낸다고 했으니, 이 이름을 일터에서 그 대로 펴 봅시다. 먼저 새로운 일터를 하나 열고 깨끗한 일터에서 아래의 글 토막을 펴 봅시다. 그러면 어떤 결과가 나타날까요? MessageBox ☞ MessageBox "MessageBox"를 입력하고 글쇠를 눌러서 위의 글토막을 펴 봤더니 어떻게 됐습니까? 아무런 변화가 없이 "MessageBox"라는 글자가 그대로 나타 났습니다. 그럼 "Transcript"의 경우는 어떠했습니까? 기억이 나지 않는다면 직접 실험을 해 봅시다. Transcript ☞ a TranscriptShell "Transcript"라는 이름에는 "a TranscriptShell"이라는 객체가 붙어있었습니 다. 그런데 "MessageBox" 꼬리표는 펴 봤자 그대로 "MessageBox"입니다. 따 라서 "MessageBox"는 갈래(class)의 이름이라는 것을 알 수 있습니다. 우리는 Integer 갈래에게 #superclass라는 지시를 내려서 "네 윗갈래가 뭐 냐"고 물어볼 수 있었습니다. 만약 MessageBox가 갈래의 이름이라면 역시 #superclass 지시를 알아들어야 할 것입니다. 그런지 안 그런지 일터에서 실 험을 해 봅시다. 아래 글토막을 가늠해서 펴 보십시오. MessageBox superclass ☞ Object 여러분이 보시다시피 MessageBox의 윗갈래는 "Object"라는 것을 알 수 있습 니다. 우리가 바로값이 아닌 객체를 만들어 내기 위해서는 어떻게 했는지 기억하십 니까? "3.3"에서 운동장을 가지고 놀았을 때 어떻게 했습니까? 네, 갈래에게 #new라는 지시를 내려주었습니다. #new는 "새로운 객체를 만들어 내라"는 뜻 이기 때문에 MessageBox에 #new라는 지시를 내려서 알림 상자를 만들 수 있 습니다. 그렇지만 알림 상자는 한 번 만들어지고 사용자가 내용을 확인한 다음에는 쓸모가 없는 객체이기 때문에 일일이 #new 지시를 사용해서 새로 객체를 만 들지 않고 간단한 지시를 사용해서 객체를 만들어낼 수 있도록 몇 가지의 지 시가 준비되어 있습니다. 마치 우리가 색깔을 나타낼 때 "Color" 갈래에게 #new라는 지시를 내리지 않고 바로 "Color red"와 같은 지시를 내려서 객체 를 얻어내는 것과 비슷하다고 보면 되겠습니다. 알림 상자를 어떻게 나타내는지를 알아보기 전에 먼저 알림 상자에는 어떤 종류가 있는지를 알아보도록 하겠습니다. 알림 상자는 크게 다음과 같은 네 가지의 종류로 나누어볼 수 있습니다. * 정보 상자(information box) "i"자의 아이콘(icon)을 달고 나오는 상자입니다. 단순히 프로그램에서 일 어난 상황을 사용자에게 전달하기 위해 쓰이는 평범한 상자입니다. * 경고 상자(warning box) 노란색 삼각형에 "!"가 들어가 있는 상자입니다. 상황이 제법 심각해질 지 도 모르기 때문에 주의를 기울이라는 뜻으로 나타납니다. 사용자에게 경고 하는 경우에 이 상자를 사용합니다. * 오류 상자(error box) 붉은색 동그라미에 "X"표시가 되어 있는 상자입니다. 프로그램에 오류가 발 생했거나 상황 자체가 매우 심각하여 사용자가 대처해야할 때 사용합니다. 대부분 이 오류 상자가 나타나게 되면 매우 심각한 상황이기 때문에 사용자 가 특별한 대처를 해야할 때 사용합니다. * 질문 상자(confirm box) "?" 아이콘이 그려져 있는 상자입니다. 프로그램이 어떤 일을 하려고 할 때 사용자에게 확인을 받기 위해서 사용합니다. 다른 알림 상자와는 달리 "예", "아니오"라는 두 개의 단추를 가지고 있어서, 사용자가 해당 상황을 받아들일 것인지, 거부할 것인지를 선택할 수 있습니다. 물론 알림 상자에 복잡한 지시를 내려서 경고 상자이면서 "예'와 "아니오" 단추를 가지고 있는 확인 상자의 기능을 하게 할 수도 있습니다. 그러나 우 리는 여기서 일반적으로 쓰이는 알림 상자를 만들어 볼 것입니다. 일터에서 다음의 글토막을 입력하여 가늠해 봅시다. MessageBox notify: '작업이 끝났습니다.' caption: '알림' 위의 바탕글을 가늠하면 다음 <그림 3-25>와 같이 알림 상자가 나타날 것입 니다. <그림 3-25> #notify:caption:으로 만든 정보 상자 (Stp3-25.gif) 알림 상자가 나타나면 "확인" 단추를 눌러서 닫을 수 있습니다. 신기하지 않 습니까? 이렇게 MessageBox 갈래에게 #notify:caption: 지시를 내리면 정보 상자를 만들어서 표시해 줍니다. 여기서 #notify:caption:은 두 개의 열쇠말 (keyword)을 가지고 있는 '쇠마디 지시'(keyword message)인데 "notify:" 뒤 에는 알려야 할 실제의 내용을 글줄로 적고, "caption:" 뒤에는 알림 상자의 제목을 글줄로 적으면 됩니다. 경고 상자도 만들어 볼까요? MessageBox warning: '그렇게 나오면 곤란하죠.' caption: '경고' <그림 3-26> #warning:caption:으로 만든 경고 상자 (Stp3-26.gif) <그림 3-26>을 보면 경고 상자가 나타나 있음을 알 수 있습니다. 정보 상자 와 마찬가지로 "warning:" 뒤에는 경고할 내용을 적고 "caption:" 뒤에는 알 림 상자의 제목을 적어주면 됩니다. 오류 상자도 당근! 만들 수 있습니다. MessageBox errorMsg: '잘못하셨습니다.' caption: '오류' <그림 3-27> #errorMsg:caption:으로 만든 오류 상자 (Stp3-27.gif) 아주 재미있지요? 이번에는 대화 상자의 한 종류로써 사용자에게 질문을 던 지는 질문 상자를 만들어 보도록 하겠습니다. MessageBox confirm: '계속할까요?' caption: '확인' <그림 3-28> #confirm:caption:으로 만든 질문 상자 (Stp3-28.gif) 다른 대화 상자들은 한결같이 "확인" 단추만 가지고 있었는데 #confirm: caption: 지시로 만든 질문 상자의 경우에는 "예"와 "아니오"라는 두 개의 단추를 가지고 있습니다. 정보 상자, 경고 상자, 오류 상자에는 단추가 하나만 붙어 있기 때문에 글토 막의 결과는 그리 중요하지 않습니다. 그러나 실험을 해 본 것처럼 질문 상 자의 경우는 "예"와 "아니오"라는 두 개의 단추가 있기 때문에 사용자가 어 떤 단추를 눌렀는지를 알아야 할 필요가 있습니다. #confirm:caption: 지시 를 내리게 되면 질문 상자가 나오고 사용자가 어떤 단추를 눌렀는지를 결과 값으로 넘겨줍니다. 그러면 어떤 결과가 나오는지 아래 글토막을 가늠해서 펴 봅시다. (그냥 가늠하는 것이 아니라 를 눌러서 결과를 펴 보라 는 말입니다.) MessageBox confirm: '계속할까요?' caption: '확인' ☞ true ← "예"를 눌렀을 때 ☞ false ← "아니오"를 눌렀을 때 MessageBox 객체에게―'갈래'도 엄연한 객체입니다― #confirm:caption: 지 시를 내리게 되면 이와 같이 사용자가 "예"를 선택하면 "true"(참)를 넘기 고, "아니오"를 선택하면 "false"(거짓)을 넘깁니다. 나중에 프로그램의 조 건을 판단할 수 있는 지시를 배우게 될 텐데, 그 지시를 사용하게 되면 사용 자의 선택에 따라서 프로그램의 흐름을 바꿀 수 있습니다. 아무튼 지금은 질 문 상자에서 사용자가 어떤 단추를 눌렀는지를 결과값으로 얻을 수 있다는 정도만 알아두면 되겠습니다. ---<잠깐!>---------------------------------------------------------- 갈래(class)와 객체(object)의 관계 이쯤 되면 '갈래'와 '객체'를 혼동하시는 분이 분명히 있을지도 모르겠습니 다. 지금 머리가 복잡한 사람들을 위해서 여기서 잠시 갈래와 객체에 대해서 교통정리를 좀 하고 넘어가는 것이 좋겠습니다. 갈래(class)는 비슷한 속성을 갖는 객체들을 한데 묶을 때 사용합니다. 즉 "갈래"는 객체의 종류입니다. 1, 2, 3, -1, -2 등은 객체인데 이 객체는 모 두 "정수"(Integer)라는 갈래에 속해 있습니다. '아버지', '어머니' 등은 모 두 글줄(String) 갈래에 속해 있습니다. 따라서 모든 객체는 저마다 나름대 로의 갈래에 딸려 있습니다. 어떤 갈래가 있을 때 그 갈래에 속하는 객체들 을 "실체"(instance)라고 부른다는 것은 이미 "2.2.3"(#8) 마디에서 다룬 적 이 있습니다. 따라서 갈래와 실체는 서로 반대되는 개념이라고 생각해도 무 리가 없을 듯 합니다. 그런데 Smalltalk에서는 모든 것이 객체입니다. 너무 지겹습니까? 그래도 이 것이 Smalltalk의 기본 법칙이고 아주 중요하기 때문에 필자가 자꾸 말을 하 는 것입니다. Smalltalk에서는 모든 것이 객체이기 때문에 심지어 갈래 (class)도 또한 객체(object)입니다. 그것은 다음과 같은 글토막을 가늠해 봐도 알 수 있습니다. (3 class) isKindOf: Object ☞ true 위의 글토막에서 "3"에게 #class 지시를 내리면 "SmallInteger"(작은 정수) 라는 이름의 갈래를 얻게 됩니다. 결국 "SmallInteger" 갈래에게 #isKindOf: 라는 지시가 보내지게 되는데, 이 말은 "SmallInteger가 객체인가"를 묻는 것입니다. Smalltalk가 뭐라고 대답했습니까? 분명히 '맞다'(tru)고 대답했 습니다. 따라서 Smalltalk의 모든 갈래도 결국에는 객체인 것입니다. 그런데 갈래도 객체이기 때문에 이 갈래에도 지시를 내릴 수 있습니다. 그래 서 실체가 알아들을 수 있는 지시를 '실체 지시'(instance message)라 하고 갈래가 알아들을 수 있는 지시를 '갈래 지시'(class message)라고 부르는 것 입니다. 우리의 예에서 대화 상자를 만들어 내기 위해서 썼던 #notify:caption, #warning:caption:이나 새로운 객체를 만들어 내기 위해서 썼던 #new, 윗갈 래를 알아내기 위해서 사용했던 #superclass 등은 모두 갈래가 알아들을 수 있는 갈래 지시인 것입니다. 반면 #+, #-와 같은 겹마디 지시나 #size, #at:, #between:and: 등은 모두 실체에 보내는 지시이기 때문에 실체 지시가 되는 것입니다. 바로값(literal)이 아닌 객체를 새로 만들기 위해서 우리는 보통 그 객체가 속한 갈래에게 지시를 내립니다. 보통은 #new를 사용하지만 때에 따라서는 다른 지시를 사용할 수도 있는데, 지금 보기로 들고 있는 MessageBox에는 #notify:caption: 등의 지시로 새로운 알림 상자를 만들어낼 수 있으며, Color 갈래에는 #red, #green, #blue 등의 지시를 내려서 새로운 색깔 객체 를 만들어낼 수 있습니다. 결국 이것은 갈래에게 실체 하나를 만들어 내라는 지시인 것이지요. 그렇다면 여기서 한 가지 여러분들이 궁금해 하는 점이 있을 것입니다. 모든 객체는 저마다의 갈래에 속해 있다면, "갈래는 어떤 갈래에 속해 있는가" 하는 질문입니다. 다음과 같은 글토막을 펴 봅시다. Integer class ☞ Integer class "Integer"는 정수를 나타내는 갈래입니다. 그런데 이 갈래에게 #class 지시 를 내려서 어떤 결과가 나오는지 펴 보니깐 그대로 "Integer class"라는 결 과를 넘겼습니다. 모든 갈래는 "풀이 갈래"(metaclass)에 속해있습니다. "풀이 갈래"는 "갈래 의 갈래"라고 할 수 있습니다. 즉 어떤 갈래가 있다면, 그 갈래는 "풀이 갈 래"의 실체(the instance of class of class = the instance of metaclass) 인 것입니다. 풀이 갈래는 갈래를 풀어주는 역할을 합니다. 그러니까 "Integer"라는 갈래가 어떤 행동을 하려 할 때에는 "Integer class"라는, 즉 "Integer" 갈래의 풀이 갈래가 그 지시를 받아서 처리합니다. 여러분이 풀이 갈래에 대해서 이해하려면 아직도 상당히 많은 시간이 필요할 것입니다. 특 히 C++, Java, Object Pascal처럼 순수한 객체지향 언어가 아닌 기존의 언어 를 알고 있는 사람이라면 거의 머릿속에서 폭풍이 휘몰아칠 것입니다. 아무 튼 모든 갈래는 "풀이 갈래"에 속해있다고 생각합시다. 나중에 여러분이 갈 래와 실체, 그리고 객체의 개념에 대해서 익숙해졌을 때 풀이 갈래에 대해서 좀 더 깊이 설명을 할 수 있을 것입니다. 결국에는 닭이 먼저냐, 알이 먼저 냐는 논쟁과 비슷해질 수 있는데, Smalltalk는 이러한 논리를 아주 묘하게 이용하고 있습니다. 결론은 - 갈래도 객체이므로 지시를 받을 수 있다. - 갈래와 반대되는 말은 '객체'가 아니라 __실체__이다. 위의 두 가지를 이해하고 있으면 헷갈리지 않을 것입니다. 갈래의 반대는 절 대로 객체가 아닙니다. ---------------------------------------------------------- 지금까지 알아본 것을 정리하면 다음과 같습니다. MessageBox가 알아들을 수 있는 갈래 지시 ---------------------------------------------------------- MessageBox notify: promptString caption: titleString 창의 제목을 "titleString"으로 붙이고 "promptString"의 내용을 표시하는 "정보 상자"(information box)를 만들어 화면에 표시한다. MessageBox warning: promptString caption: titleString 창의 제목을 "titleString"으로 붙이고 "promptString"의 내용을 표시하는 "경고 상자"(warning box)를 만들어 화면에 표시한다. MessageBox errorMsg: promptString caption: titleString 창의 제목을 "titleString"으로 붙이고 "promptString"의 내용을 표시하는 "오류 상자"(error box)를 만들어 화면에 표시한다. MessageBox confirm: promptString caption: titleString 창의 제목을 "titleString"으로 붙이고 "promptString"의 내용을 표시하는 "질문 상자"(confirm box)를 만들어 화면에 표시한다. "예"와 "아니오" 단 추를 함께 가지고 있고, 사용자가 누른 단추가 "예"이면 '참'(true)을, "아 니오"이면 '거짓'(false)을 넘긴다. ---------------------------------------------------------- 지금까지 알림 상자에 여러분이 원하는 내용을 출력하는 방법을 알아보았습 니다. 많이 연습해서 알림 상자를 쓰는데 익숙해지도록 합시다. 다음에는 사 용자에게서 글줄을 입력받을 수 있는 글줄 입력 상자에 대해서 알아봅시다. #32에 계속... 제 목:[강좌] Smalltalk 배우기 -차례- (수정) 관련자료:없음 [150] 보낸이:김찬홍 (지니반쪽) 2000-03-13 12:11 조회:64 Smalltalk 배우기 차례 +---------------------------------------------------------------- | <보기> >: 현재 진행되고 있는 글 | !: 별도의 자료파일이 제공되는 글 | *: 현재 쓰여지고 있는 글 | <#번호>: 글 번호 | | | 0. 'Smalltalk 배우기'를 시작하면서 <#0> | | | 1. Smalltalk의 소개 | | 1.1. 프로그램과 프로그래밍 언어 <#1> | | 1.2. Smalltalk의 설치 <#2> | | 1.3. Smalltalk 맛보기 프로그램 | | 1.4. 몇 가지 준비해야 할 것들 <#3> | 1.4.1. Dolphin Smalltalk 등록하기 | 1.4.2. 바탕본 여벌 받기 | 1.4.3. 글꼴 설정하기 | | 1.5. Smalltalk 환경 둘러보기 <#4> | 1.5.1. 알림판 | 1.5.2. 일터 | 1.5.3. 객체 탐색기 | 1.5.4. 갈래씨줄 탐색기 | 1.5.5. 길수 탐색기 | 1.5.6. 꾸러미 탐색기 | 1.5.7. 창맵씨 | 1.5.8. 자원 탐색기 | 1.5.9. 발자취 창과 벌레잡개 | | | 2. 객체들과 나누는 이야기 | | 2.1. 객체? <#5> | | 2.2. 몸으로 느껴보기 | 2.2.1. 글토막 가늠하기 <#6> | 2.2.2. 셈! 셈! 셈! | 2.2.3. 실체와 갈래 | 2.2.4. 지시에 대하여... | 2.2.5. 지시의 우선 순위 | ! 2.2.6. 고급 셈! 셈! 셈! <#11> | | 2.3. 객체의 안쪽 | ! 2.3.1. 탐색기 사용하기 <#13> | ! 2.3.2. 객체의 성분 | ! 2.3.3. 글자와 글줄 | 2.3.4. 진리를 찾아서... <#17> | ! 2.3.5. 무른값, 굳은값, 그리고 바로값 <#19> | | 2.4 정리 및 연습문제 <#21> | 2.4.1. 요약 | 2.4.2. 알아두면 좋은 것들 | 2.4.3. 연습 문제 | | | > 3. 객체로 채워진 세상 | | ! 3.1. 알아보자, 알림판! <#22> | 3.1.1. 알림판 객체 - Transcript | 3.1.2. 알림판에 객체 써내기 | 3.1.3. 잇따름 지시 | | 3.2. 꼬리표 인생 | 3.2.1. 이름이 뭐지? <#24> | 3.2.2. 바로값과 꼬리표 | 3.2.3. 작은 꼬리표 <#25> | 3.2.4. 붙임표에 대하여 | ! 3.2.5. 큰 꼬리표 <#26> | | ! 3.3. 운동장 놀이 | 3.3.1. 일터 꼬리표 <#27> | 3.3.2. 꾸러미에 대해서 | 3.3.3. 운동장 위에서 <#28> | | ! 3.4. 앗, 나의 실수!!! | 3.4.1. 김 군의 하루 <#29> | 3.4.2. 실수, 또 실수 | 3.4.3. 효율성과 기독성 <#30> | 3.4.4. 성공의 비결은 실패 | | ! 3.5. 대화의 장 | 3.5.1. 알림 상자 <#31> | 3.5.2. 글줄 입력 상자 | * 3.5.3. 목록 입력 상자 | 3.5.4. 실전: 이름을 말해봐! | 3.5.5. 실전: 나는 짬뽕! | | 3.6. 그림을 그립시다. | | 3.7. 정리 및 연습문제 | | | 4. 갈래 속 탐험기 | .... +---------------------------------------------------------------- 제 목:[알림] Smalltalk 배우기 차레 변경 관련자료:있음 [151] 보낸이:김찬홍 (지니반쪽) 2000-03-13 12:15 조회:66 안녕하세요? 김찬홍 안드레아입니다. 항상 제 글을 읽어주시는 여러분들께 감사하다는 말씀을 드리겠습니다. 이번에 알려드릴 상황은 "Smalltalk 배우기"의 차례에 대한 사항입니다. 원래 Smalltalk배우기의 차례는 5번 게시물에 올라와 있는데, 제가 한글 아이디를 바꾸는 바람에-에고, 커플아이디로 바꿨는데.. 이런 일이- 예전 글의 수정 권한이 없어서 애를 먹고 있다가, OOT 운영진께서도 어쩌실 방도가 없으신것 같아서 -결국 하이텔이 나쁘죠- 아예 차례를 '150'번 글에 배치하려고 합니다. 앞으로 차례는 언제나 '150'번 글에 올리게 될 것입니다. 착오 없으시기 바라구요, 글을 읽으시는데 있어서 불편함을 드린 점 사과드립니다. 앞으로 아이디 변경 같은건 좀 더 신중하게 해야겠네요. 에공... :) 그럼 안녕히. 제 목:[잡담] 아래, Smalltalk과 다른 언어 관련자료:없음 [154] 보낸이:김찬홍 (지니반쪽) 2000-03-21 12:02 조회:86 안녕하세요? 김찬홍 안드레아입니다. Smalltalk를 공부하는 입장에서 정남님께서 해 주신 말씀이 저에게도 무척 많은 도움이 되었습니다. 일견 저와 같은 생각을 가지신 부분도 있고 그렇지 않은 부분도 있는데요, 정남님의 글을 인용해서 제 생각을 간단히 적어보도록 할게요. ---------------------------------------------------------------- 뉴스 그룹에 가면 꽤 괜찮은 글들이 많이 나옵니다. 전에 가서 보니 스몰톡그룹에서 왜 스몰톡이 상용화 되어서 쓰는게 없나 하는 이유를 쭉 써놓은 게 있는데 일견 맞는 말이 있는 거 같기도 하더군요.. 예를 들자면 독자적인 실행파일을 못 만든다든가 , 상용 DB와 연계해서 쓸 방법이 없다든가 원래 목적이 애들용으로 만들어서 그런다든지... ---------------------------------------------------------------- Smalltalk가 주류 언어는 아닙니다. 그러나 위에 정남님께서 지적하신 사항은 절대적인 것이 아니라 다분히 개선될 여지가 있는 것이고, 현재 많은 부분에서 개선이 이루어지고 있습니다. 먼저 독자적인 실행 파일에 관해서는 저기 아래 제가 실행 파일 배포에 대해서 쓴 글에서도 나와있듯이, 이미 Smalltalk가 Windows나 기타 다른 환경에 이식될 때 독립 실행 파일을 만들 수 있도록 되어 있었습니다. 다만 초창기의 경우에는 Smalltalk 가상 기계와 객체들의 본(image)을 통째로 꾸려서 실행파일을 만들었기 때문에 필요없는 부분들이 많았지만, 현재의 경우는 뽑아내기(image stripping) 기법을 사용하여 프로그램에서 사용하지 않는 객체나 갈래(class)들과 각종 개발 환경들은 모두 본에서 뽑아내서 상당히 컴팩트한 실행 파일을 만들어 낼 수 이습니다. Dolphin Smalltalk VisualAge for Smalltalk 등은 이러한 뽑아내기를 지원합니다. 또한 Smalltalk-MT의 경우는 Multi-thread를 지원하고, 다른 Smalltalk들과는 달리 직접 기계어로 번역하여 실행하는 native-compiler를 가지고 있다는 특징이 있습니다. Squeak의 경우는 아직 공부해 보지 않아서 모르겠는데, Smalltalk 코드에 대응하는 C코드를 만들어주기 때문에 독립실행파일이 필요하면 이렇게 해서 만들어진 바탕글을 번역하여 쓰면 될 것입니다. 제가 사용하고 있는 Dolphin Smalltalk에서는 ADK(Application Development Kit)을 사용하여 독립 실행 파일을 만듭니다. 상용 데이터베이스와의 연결 문제에 대해서도 여러 가지 해결 방안이 있습니다. Dolphin Smalltalk와 Smalltalk-MT, VisualAge for Smalltalk는 모두 ODBC를 통해서 DB에 접근할 수 있기 때문에, ODBC 드라이버를 가지고 있다면 얼마든지 관계형 데이터베이스에 접속할 수 있습니다. Dolphin Smalltalk의 경우에는 ActiveX 객체와 접속할 수 있으므로, ADO를 사용할 수 있습니다. 아직까지 ADO를 포장할만한 갈래가 준비되지 않아서 바로 ADO와 접속할 수는 없지만 곧 ADO를 지원하는 꾸러미가 나올걸로 알고 있습니다. 또한 각 Smalltalk 회사들은 나름대로 OODBMS를 지원하는데, 오히려 객체지향 방법론을 제대로 실현하는데 있어서는 이러한 OODB들이 괜찮은 접근법이 될 수 있다고 생각합니다. MineStore의 경우는 Dolphin과 Squeak를 지원하는 대표적인 OODB이며, OmniBase의 경우는 Dolphin에서 지원한다고 알고있습니다. 기타의 경우도 나름대로 OODB를 지원한다고 알고 있습니다. Dolphin Smalltalk에서는 Database Connection과 OmniBase를 통하여 DB에 접근합니다. Smalltalk는 아이들을 위해서만 만들어진 언어는 아닙니다. 다만 언어의 철학이 '아이들도 쓸 수 있도록 쉽게 만들자'는 것일 뿐입니다. 따라서 이는 '교육용으로 만들어진 파스칼'이 현재의 Delphi의 모태를 이루고 있는 것을 볼 때 그리 설득력이 있어보이는 주장이 아닙니다. 여러분들이 흔히 쓰는 Visual Basic의 전신인 BASIC 역시 컴퓨터 초보자를 교육하기 위해서 만들어졌지만, 8비트 시절에는 훌륭한 운영체계 노릇을 할 수 있도록 방대한 명령어 집합을 가지고 있었습니다. ---------------------------------------------------------------- 하지만 제 생각에는 강력하게 미는 회사가 없어서 그런것 같군요.. 솔직히 스몰톡언어 자체로만 보면 깔끔함이라든지 개념은 오히려 자바보다 더 좋죠. 단지 자바와의 차이는 자바는 선이라는 강력한 벤더가 민다는 거고 스몰톡은 대형회사나 유명한 회사가 자사 어플 개발에 쓰지 않는 다는 거죠.. ---------------------------------------------------------------- 이 문제는 저도 정남님과 같은 생각입니다. 예전에 제가 하드웨어쪽으로 공부할 일이 있어서 Forth라는 언어를 공부했을 때, 그쪽 포럼에 계신 분이 "만약 필립 칸이 Turbo Forth를 만들었다면 Forth의 역사가 다시 쓰여졌을 것이다"라는 말을 하신 적이 있어요. 만약 "Turbo Smalltalk"나 "Visual Smalltalk"(마이크로소프트)가 만들어졌다면 아마 Smalltalk가 무지 발전했을 것입니다. Oracle이나 기타 다른 회사에서 Smalltalk를 가지고 응용 프로그램을 개발한다면 Smalltalk는 상당히 많이 알려지게 될 것입니다. 그런데 불행하게도 Smalltalk는 비주류 언어로써, 단지 객체지향에 대한 개념을 설명할 때 잠시 언급되는 정도로 그치고 있습니다. 이는 특히 우리나라의 경우에 더 심합니다. 유럽의 경우는 아직도 Smalltalk를 사용하는 곳이 많고, 제가 공부하고 있는 Dolphin Smalltalk 역시 영국의 Object-Arts 사에서 개발한 것입니다. 그쪽에는 컴퓨터 잡지에 Smalltalk의 공개용 버전을 배포하고 사람들에게 알리는 모양입니다. 우리나라처럼 Microsoft사의 개발 도구들만이 주류를 이루고 있는 모습과 상당히 비교된다고 할 수 있습니다. 어쨌건 현재 주류로 쓰이는 언어가 C/C++에서 이제는 Sun의 Java로 옮겨가고 있습니다. 그러나 그렇다고 해서 Smalltalk에 전혀 손을 데지 않을 수 없다고 저는 생각합니다. 오히려 Smalltalk가 가지는 그러한 장점을 이용해서 한 명이라도 많은 사람들이 Smalltalk를 공부하고, 그래서 좀 더 올바른 객체지향 개념을 적립할 수 있다면, 그리고 자신의 프로젝트에 활용할 수 있는 살아있는 지식을 배운다면 좋겠습니다. 물론 프로젝트 자체가 Smalltalk로 이루어진다면 참 좋겠지요. :) ---------------------------------------------------------------- Smalltalk는 정말 단순히 언어자체를 연구하거나 쓰는 쪽은 꽤 됩니다만. 상업성은 없다고 생각하는 것 같아요... 저도 스몰톡 공부할때 꽤 좋은건 많은 느낌이 드는데 막상 뭔가를 하려고 하면 할게 없다는 거죠... X와 연계해서 쓰기도 힘들고 , 윈도객체와 연동하기도 좀 그렇고 쓸만한 객체를 모아놓은 그런 것도 없고 CORBA지원명세 언어에는 있는데 바인딩 클래스는 없고... 간단한 그래픽 뷰어를 만들려 해도 결국 씨를 다시 써야 되니... 웹쪽으로 쓰면 좋을것 같기도 한데.. 서버와 연동해서 쓸 방법이 없고.... 결론은 언어는 괜찮은데 환경을 더 보강 해야 한다는 거죠.. 여러모로 씨와는 반대되는 언어 입니다.... 씨가 환경이 강력해서 지금도 많이 쓰는걸 보면 환경이 언어 자체보다 더 중요한건지... 씨는 대표적인 못만든 언어인데... 스몰특은 잘 만들어으면서도 별로 안쓰이는걸 보면.... 이상 잡담이었습니다..... ---------------------------------------------------------------- 네. 정곡을 찌르는 지적을 해 주셨습니다. 처음 Smalltalk를 접한 게 약 3년 전의 일이었습니다. 그 때는 그저 그러려니 하고 넘어갔습니다. 제가 그 때 쓴 Smalltalk는 "Smalltalk Express"라고 하여, 실행파일도 아예 만들 수 없었고, 기초적인 GUI 도구가 있었을 따름입니다. 물론 Smalltalk를 이루고 있는 개발 환경들과 외부 DLL을 부를 수 있는 기술들이 있었지만, 그 당시에는 별로 Smalltalk에 관심이 없었습니다. 그도 그럴 것이 32비트인 Windows 95/98 체계에서 16비트의 Smalltalk를 쓴다는 것이 영 기분이 내키지 않아서일 것입니다. 그러나 98년 말에 Dolphin Smalltalk를 알게 되면서부터 저는 조금씩 달라지기 시작해습니다. 다만 99년에 국책 프로젝트 수행 문제 때문에 6개월 동안 Smalltalk를 공부하지 못한게 무지 아쉽지만, 결국에는 결심을 굳히고 Dolphin Smalltalk의 상용 버전을 구입하게 되었습니다. 정말 기분이 좋더군요. 공개용으로 나와 있는 Smalltalk보다 상용으로 만들어진 것이 훨씬 완성도가 있었습니다. 현재 자료실에 있는 Dolphin Smalltalk 2.1은 공개용입니다. 98년에 만들어진 Smalltalk환경입니다. 따라서 Dolphin Smalltalk 2.1만을 보게 되면 충분히 실망할 수도 있다고 생각합니다. 그렇지만 어디를 가서도 공개용으로 만들어진 개발 환경이 이와 같은 여러 가지 강력한 기능을 가지고 있는 환경은 매우 드물다고 생각합니다. 그러나 Dolphin Smalltalk 3.0을 구입해서 써 보니, 정말 '와~'하는 감탄사가 나오더군요. Windows98에 있는 대부분의 컨트롤을 지원하고 있었고, 알아보기 쉬운 개발 환경과 막강한 디버깅 기능은 저를 매료되게 만들었습니다. 또한 LiveUpdate 기능으로 Smalltalk 환경 자체를 패치해 주는 기능은 정말 압권이었습니다. 저는 아예 Database Connection, ADK, Web Development Kit, Socket Connection의 꾸러미를 함께 구입했습니다. 이렇게 함께 구입하면 가격이 매우 저렴하기 때문인데, 하나하나 공부하고 있습니다. 플러그-인 프로그램을 설치하면 Dolphin Smalltalk로 에플릿을 만들 수 있습니다. 물론 ADK를 사용해서 실행파일을 만들어 배포할 수도 있겠지요. Dolphin Smalltalk의 경우는 Windows 운영체계의 기능을 수용하고, 모든 Windows의 API를 호출할 수 있을 뿐만 아니라, cdecl, stdcall, safecall과 같은 방식의 호출 관행을 지원하는 외부 DLL 함수를 사용할 수 있습니다. 2.1버전부터 조금씩 지원해 오던 COM/OLE 기능을 확장하여 3.0에서는 ActiveX 컨트롤을 불러와서 사용할 수 있게 되었습니다. 따라서 별도의 추가 비용 없이 GIF, JPG, MP3 등 운영 체계가(정확히는 Internet Explorer와 Windows Media Player가) 지원하는 파일 표시 기능들을 그대로 사용하고 있습니다. 정말 이는 저를 Smalltalk에 빠져들게 만들었습니다. 네, 분명히 지금의 Smalltalk환경은 C/C++이나 소위 '한다'하는 회사들이 밀고 있는 다른 언어들과는 비교가 안 될 정도로 빈약합니다. 이는 Forth에서도 마찬가지였었습니다. 그러나 결국 Forth는 내장 제어 시스템용 언어로밖에는 쓰이기가 힘든 실정이었고, 또한 그런 패러다임을 가지고 있었습니다. 그러나 Smalltalk는 Forth와는 좀 다른 상황을 가지고 있습니다. 시스템 자체가 GUI를 탄생하게 한 터라서, MS-DOS에서 돌아가는 Smalltalk/V 의 경우에도 자체적인 창 관리 시스템을 가지고 있었습니다. 일터(workspace)에서 객체들에게 지시(message)를 내림으로써 객체들과 대화하고 갈래 씻줄 탐색기(Class Hierarchy Browser)에서 Smalltalk에 어떤 갈래가 있는지를 검사하고 새로운 갈래를 만들며, 벌레잡이로 실시간 디버깅을 수행할 수 있습니다. 길수 탐색기(Method Browser)를 사용하여 특정 조건에 맞는 길수들을 연계 참조할 수 있으며, 각각의 Smalltalk 개발 회사들마다 제공하는 독특한 개발 도구들을 사용하면 응용 프로그램을 만들기에 부족함이 없는 환경이라고 감히 말하고 싶습니다. C/C++, Java, Delphi가 할 수 있는 일 중에 70%는 Smalltalk로 할 수 있고, Visual Basic에서 할 수 있는 일 중에는 90%를 Smalltalk가 할 수 있습니다. 물론 단순히 '할 수 있다'가 아니라 '더 잘 할 수 있다'는 말입니다. 분명히 Smalltalk의 발전 속도는 느립니다. 그러나 Squeak, Smalltalk-MT, Dolphin Smalltalk는 각자 나름대로의 영역에서 꾸준히 발전해 오고 있으며, Dolphin Smalltalk의 경우에는 Windows 운영 체계에서 제공하는 최신 기술들을 대부분 그대로 소화해 내고 있습니다. Object-Arts의 대여섯명밖에 안 되는 직원들과 Dolphin Community를 이루고 있는 Smalltalker들의 노력으로 Dolphin Smalltalk는 공히 비주얼베이식에 필적할만한 개발 환경을 가지게 되었습니다. 현재 DirectX 꾸러미의 Pre-release 버전이 출시되어 있으므로, 조만간 DirectX를 사용한 응용 프로그램들도 만들 수 있을 것입니다. 물론 저는 모든 일을 Smalltalk로 처리하려고 하지는 않습니다. 정남님께서도 말씀하셨듯이 C언어가 강한 부분이 분명히 있습니다. C가 널리 쓰일 때에도 사람들은 필요할 때 어셈블리 언어를 사용해서 코딩을 했습니다. Smalltalk를 쓸 때도 저는 이런 기분으로 프로그램을 만듭니다. 분명히 C가 강한 부분이 있다면, 이런 부분들은 DLL로 만들어서 Smalltalk와 연결을 시켜버립니다. 공부를 좀 더 해서 COM 부품을 만들어 낼 수 있다면 Smalltalk에 꽂아서 바로 객체로 사용할 수도 있을 것입니다. Dolphin Community의 "lan Bartholomew"는 "Smalltalk는 복잡한 부품들을 서로 이어주는 나사와 같은 존재"라고 했습니다. 저도 이 말에 동감합니다. 처음부터 모든 걸 C++을 써서 개발하는 것보다는 Smalltalk에서 필요한 객체들과 프로그램의 뼈대를 만들어 놓고, 필요할 때 DLL이나 외부 인터페이스를 통해서 이러한 것들을 구현해 내면 훨씬 빠른 생산성을 보장할 수 있습니다. Java 언어가 왜 JNI와 같은 규격을 만들었는지를 생각해 보면 쉽게 이해할 수 있으리라고 생각합니다. "오직 Smalltalk!"를 주장하는 시스템은 살아남을 수 없습니다. 그건 Smalltalk가 비주류 언어이기 때문이기도 하지만, 그만큼 다른 것들과의 친화력이 중요하다는 말입니다. 물론 Delphi처럼 굳이 파스칼을 쓰면서 C/C++을 쓸 필요가 없는 언어의 경우에는 상당한 장점을 가지고 있습니다만, 불행하게도 Smalltalk만으로는 모든 것을 해결해내지 못합니다. 그래서 Smalltalk는 다른 것들을 충분히 활용할 수 있도록 발전해 온 것이라고 생각합니다. 그런데 여기서 한 가지 정남님에게 여쭙고 싶은 것은, Smalltalk 환경을 비교하실 적에 과연 공정했느냐 하는 겁니다. 저는 상용 Smalltalk 시스템을 사용하기 때문에 감히 단언합니다. 현재 나와 있는 상용 Smalltalk와 Delphi나 Visual Basic, JBuilder 등의 개발 도구들은 어깨를 나란히 할 수 있을 정도의 자격이 있습니다. 물론 Enterprise Edition처럼 방대한 기능을 제공하는 Smalltalk는 매우 드붑니다만, 적어도 Windows의 응용 프로그램 개발은 충분히 비교할 수 있는 대상이라고 생각합니다. 공개용 Smalltalk들의 환경이 정비되지 않은 것은 오히려 당연한 것일지도 모릅니다. Borland에서 공급하는 C++ 컴파일러의 경우에 주변 환경이 뭐가 있었습니까? 아무것도 없었습니다. 이런 걸 보면 공개용 Smalltalk와 상용 개발 도구를 비교한다는 건 공정하지 못하다고 생각합니다. 아직까지 Smalltalk가 걸어가야 할 길은 많습니다. 그러나 Smalltalk는 그 시스템과 언어가 가지는 끈질기고 독특한 생명력과 객체지향이라는 철학을 바탕으로해서 앞으로도 꾸준히 발전을 해 나갈 것입니다. 제가 여기서 Smalltalk 강좌를 연재하는 것도, 제가 배운 것들을 정리하여 알려드리고자 하는 목적도 있지만, Smalltalk로도 충분히 응용 프로그램 개발이 가능하고, 특히 프로그래밍을 공부하는 사람들이 보다 더 논리적인 틀 속에서, 공개용으로 나와 있는 훌륭한 개발도구를 자유롭게 사용하면서 프로그래밍의 기법들을 터득할 수 있었으면 좋겠다는 것입니다. 그게 잘 될지는 모르게습니다만, 중단하지 않고 꾸준히 글을 올릴 수 있는 저의 의지가 허락한다면, 힘들고 괴로운 일만은 아닐 거라고 생각합니다. 그럼 긴 글 읽어주셔서 감사합니다. 그리고 정남님께는 특별히 감사 드립니다. 그럼 안녕히 계세요. 제 목:[질문] Linux에서 GUI지원은 어떤 언어로? 관련자료:없음 [156] 보낸이:김찬홍 (지니반쪽) 2000-03-23 13:48 조회:63 안녕하세요? 김찬홍 안드레아입니다. 정남님의 글은 언제나 저를 성찰하게 만들고 새로운 것에 궁금하게 만들고 관찰하게 만드는것 같습니다. 그런 면에서 아래 올려주신 글도 많은 생각을 해 보게 만듭니다. Smalltalk에 대한 정남님의 의견이 이해가 갑니다. 그 '당위성'. 그걸 찾기가 어렵다는 건 저도 인정합니다. 그래서 저를 더 안타깝게 만듭니다. 다행이 OOT 동에 계신 여러분들은 OOPL에 대해서도 관심들이 있으실테니 Smalltalk에 대해서도 어느 정도는 알고계시겠지만, 다른 사람들은 모르는 사람들이 태반입니다. 그건 바로 Smalltalk를 써야할 당위성이 그만큼 좁다는, 즉 Smallltalk의 활용폭이 그만큼 좁다는 의미이겠지요. 말씀하신 Python, Perl, Tcl 같은 언어는 나름대로의 목적을 가지고 있습니다. 그러데 Smalltalk 는 그러한 목적이 없다는 말씀이라고 알아들어도 되겠지요? 이걸 써도 그만, 안 써도 그만... 저도 그렇게 생각했습니다. 그러나 요즘은 Smalltalk에 대한 몇 가지의 가능성을 생각해 보고 있습니다. 예전에 프로그래밍 언어의 주류는 BASIC이었습니다. 그러다가 구조화 프로그래밍이 보급되면서 파스칼이 주류화 언어가 되었습니다. 성능을 중요시 할 때에는 C가 쓰였고, 객체지향이 도입되면서 C++이 쓰였습니다. 요즘은 또 Java도 많이 쓰지요. 그런데 안타깝게도, Java나 C++은 Smalltalk만큼 덜 객체지향적입니다. Object Arts의 Andy Bwoer가 이런 말을 한 적이 있습니다. "효율성과 타협해서 생겨난 객체지향 언어들은 __진정으로__ 객체지향적이지 않다. 따라서 이런 언어들을 사용해서 객체지향을 논의한다는 것 자체가 의미 없는 일일지도 모른다." 쉽게 말해서, 순전히 객체지향적으로 생각하지 않은 상태에서 어찌 객체지향을 논하겠느냐는 말이지요. 물론 일리가 있는 말입니다. 그래서 Pascal이 그랬듯이, 저는 Smalltalk가 OOPL을 공부하는 학생들에게 도움이 되었으면 하는 생각이 듭니다. 결국 이제 Smalltalk로 우리 나라에서 할 수 있는 일은 이 정도가 아닐까 합니다. 정남님도 느끼셨겠지만, Smalltalk를 공부하고 나서 C++이나 Java를 보는 시각이 180도 바뀌었습니다. 이를테면 C++에서 virtual 함수가 왜 필요한지에 대해서 시원하게 대답할 수 있는 사람이 적습니다만, Smalltalk처럼 객체지향을 충실하게 표현하고 있는 언어를 공부한 다음에 C++을 공부하게 되면 이것이 아주 쉽게 다가옵니다. 아무튼 Smalltalk가 쓰일 목적을 찾는 것, 그리고 많은 사람들에게 Smalltalk를 알리는 것은 저와 Smalltalk에 관심이 있는 여러분들의 목시라고 생각이 드네요. 아.. 이야기가 너무 다른 쪽으로 갔는데, Linux의 X에서 Smalltalk를 가지고 GUI를 작업할 수는 없는건가요? Squeak를 공부할까도 생각해 봤지만, 아직 Dolphin도 다 못 알고 있는 상태에서 Squeak를 공부할 엄두가... 그리구 리눅스를 깔기도 좀 그래서요. Smalltalk 에는 응용 프로그램 뼈대(framework)가 몇 개 있는데, MVC, MVP 같은 것들이 그것이라고 알고 있습니다. Squeak을 써 보셨다면 어떤 뼈대로 응용 프로그램을 짜 나가는지 궁금합니다. Tcl을 이용해서 GUI를 포장할 수 있다면, Smalltalk를 이용해서도 분명히 할 수 있으리라고 생각하는데요. 아무래도 저는 Windows계열만 쓰다보니 리눅스쪽으로는 꽝이라서요. 정남님께서 써 보신 방법들이 있으면 소개해 주십시오. 그렇다면 저도 많은 공부가 되겠습니다. 그럼... 질문 겸 잡담을 마칩니다. 제 목:[답변] 전치와 후치 연산자 관련자료:없음 [161] 보낸이:김찬홍 (지니반쪽) 2000-04-06 19:29 조회:85 안녕하세요? 김찬홍입니다. 전치 연산자와 후치 연산자는 원어로 적으면 prefix operator, postfix operator입니다. 대부분 이를 '전위 표기식 연산자', '후위 표기식 연산자'라 하고, 제가 즐겨 쓰는 한글 언어에서는 '앞가지 연산자', '뒷가지 연산자'라 부르고 있습니다. 어찌되었건 이는 연산자와 연산수의 위치 관계를 나타낼 때 사용하는 말입니다. 우리가 흔히 쓰는 연산자는 중치 연산자, 중위 표기식 연산자, 속가지 연산자, infix operator라고 부릅니다. 3 + 4 (2 + 5) / 7 등과 같이 연산수와 연산수 사이에, 즉 연산수 중간에 연산자가 배치되어 있습니다. 중위 표기식 여산자는 우리가 수학에서 가장 즐겨쓰는 표현이기 때문에 이해하기가 가장 쉽다는 장점이 있습니다. 그러나.. 3 + 4 * 5 의 경우에 "+"를 먼저 계산해야 할지, "*"를 먼저 계산해야 할지를 결정해야 합니다. 즉 어떤 연산자를 먼저 연산수와 결합할지를 결정해야 하는데, 이것이 '연산의 우선순위'(operator's precedence)입니다. 보통 중위 표기식 연산자를 컴퓨터에서 처리하려면 연산자의 우선 순위를 담고 있는 사전이 필요합니다. 그래서 이 사전에서 연산자를 찾아보고 이것이 어떤 우선권을 갖는지를 검사해서 그대로 명령을 실행하는 것입니다. 만약 연산의 우선순위를 바꾸려면 괄호를 사용하면 됩니다. 전위 표기식 연산자는 연산자가 연산수 앞에 옵니다. + 3 5 위는 3과 5를 더라하는 말입니다. 그런데 여러 개의 연산자가 올 때에는 혼동을 피하기 위해서 괄호를 반드시 붙여주어야 합니다. (+ (* 2 5) 8) 위의 식을 중위 표기식으로 바꾸면 (2 * 5) + 8 이 될 것입니다. 전위 표기식 연산자는 LISP 계통의 언어에서 사용합니다. 괄호가 많아서 이해하기가 어려울 수 있지만, 컴퓨터 입장에서는 중위표기 연산자보다 처리하기가 단순하다는 이점이 있습니다. 후위 표기식 연산자는 연산자가 연산수 뒤에 옵니다. 3 5 + 위의 식은 3과 5를 더한다는 의미입니다. 후위 표기식 연산자는 우리말을 닮았습니다. 3 4 * 2 / 10 - 5 + 위의 식을 우리말로 풀어보면 "3에 4를 곱하고 2로 나눠서 10을 고 5를 더한다" 로 읽을 수 있습니다. 또한 3 4 5 + * 의 경우는 "3에, 4와 5를 더해서, 곱한다" 로 읽으면 됩니다. 2 5 4 7 * + - 이것은 2에, 5에, 4와 칠을 곱하고, 더한 뒤, 빼라" 로 읽으 수 있습니다. 후치 연산자는 연산의 우선순위도 없고 괄호를 쓸 필요도 없어서 매우 편리하지만, 역시 중위표기식보다는 낯설기 때문에 어려워 보입니다. 후위 표기식 연산자의 경우는 주로 Forth와 같은 Stack 기반 언어에서 사용합니다. 보통 전위, 후위 연산자라고 말하면 이와 같이 말할 수 있겠는데, C/C++ 언어에 한정해서 말하는 경우가 있습니다. C++에 있는 ++/-- 연산자는 전위 표기와 후위 표기를 모두 할 수 있기 때문입니다. i++ 이나 ++i 나 똑같이 변수 i에서 1을 더합니다. 또한 i-- 나 --i 나 똑같이 변수에서 1을 뺍니다. 그러나 결과는 다릅니다. a = 3; b = a++; // a = 4, b = 3 의 경우 b에는 3이 남습니다. 왜냐하면 a를 먼저 b에 넣은 다음 ++를 하기 때문입니다. a = 3; b = ++a; // a = 4, b = 4 위의 경우는 a, b 모두 4가 됩니다. 즉 b에 a를 넣기 전에 ++을 수행했기 때문입니다. 이와 같이 ++/-- 연산자는 전치, 후치에 따라서 값이 달라지기 때문에 매우 신중하게 써야 합니다. 잘못 쓰면 바탕글을 읽기 어렵게 만들기 때문에 간단하개 사용하는 것이 좋습니다. 요약하면, 일반적인 의미에서는 연산자와 연산수의 관계를 설명하고, C/C++언어에서는 증감 연산자(++ --)의 위치에 따른 값의 변화를 나타낼 때 사용합니다. 참고로 임인건님이 쓰신 Turbo C 정복이라는 책을 권합니다. 제 목:[강좌] Smalltalk 배우기 #32 관련자료:있음 [162] 보낸이:김찬홍 (지니반쪽) 2000-04-12 19:14 조회:71 Smalltalk 배우기 #32 2000. 4. 12. 김찬홍 mailto:andrea92@hitel.net ====================================== 3. 객체로 채워진 세상 3.1. 알아보자, 알림판! 3.2. 꼬리표 인생 3.3. 운동장 놀이 3.4. 앗, 나의 실수!!! 3.5. 대화의 창 3.5.1. 알림 상자 b→3.5.2. 글줄 입력 상자 ........ ======================================= 3. 객체로 채워진 세상 --------------------------- 3.5. 대화의 창 ~~~~~~~~~~~~~~ #31에서... 3.5.2. 글줄 입력 상자 --------------------- 앞 나눔에서 우리는 컴퓨터의 상태를 나타낼 수 있는 알림 상자(message box)를 Smalltalk에서 어떻게 다루는지에 대해서 알아보았습니다. 이제 지금 부터는 프로그램을 사용하는 사람들이 자신이 원하는 값을 입력할 수 있는 입력 상자에 대해서 알아볼 것입니다. Smalltalk에서 기본적으로 제공하는 입력상자는 크게 두 가지의 종류가 있는 데, 간단한 글줄을 입력할 수 있는 "글줄 입력 상자"(string prompter)와 미 리 주어진 몇 개의 목록 중에서 한 개 이상을 선택할 수 있는 "목록 입력 상 자"(list prompter)가 그것입니다. 먼저 글줄 입력 상자부터 알아봅시다. 알림 상자에는 "MessageBox"라는 이름이 붙어있었습니다. 우리는 새로운 알 림 상자를 만들기 위해서 #notify:caption: #warning:caption: #errorMsg: caption #confirm:caption:과 같은 네 개의 지시를 사용했습니다. 따라서 글 줄 입력 상자를 다룰 때에도 먼저 이 객체에 어떤 이름이 붙어있는지를 알아 야 할 필요가 있습니다. 글줄 입력 상자의 이름은 "Prompter"입니다. 즉 글줄 입력 상자에게 지시를 내리기 위해서는 "Prompter"라는 이름을 사용 해야 한다는 것입니다. 그러면 알림 상자를 관찰했을 때와 마찬가지로 "Prompter"도 똑같은 방법으로 관찰을 해 봅시다. Prompter ☞ Prompter 일터에서 위의 글토막을 입력해서 펴 보면(display it) "Prompter"라는 이름 이 그대로 나타납니다. 이는 "Prompter"가 단순한 객체의 이름이 아니라 갈 래(class)의 이름일지도 모른다는 말입니다. Prompter가 갈래라면 #superclass 지시를 알아들을 수 있을 것입니다. Prompter superclass ☞ ValueDialog 네, 우리의 생각과 같이 Prompter는 #superclass 지시를 알아들었고, 자신이 ValueDialog(값 대화 상자)의 아랫갈래라고 대답했습니다. 값 대화 상자 (ValueDialog)는 프로그램에서 어떤 값을 입력받을 때 사용할 수 있는 대화 상자들의 갈래입니다. 지금 우리가 공부하고 있는 글줄 입력 상자도 프로그 램에서 글줄을 입력받는데 사용되기 때문에 ValueDialog의 아랫갈래입니다. 그럼 Prompter의 씻줄(hierarchy)을 계속해서 짚어 올라가 봅시다. ValueDialog superclass ☞ Dialog Dialog superclass ☞ Shell Shell superclass ☞ CompositePresenter CompositePresenter superclass ☞ Presenter Presenter superclass ☞ Object Object superclass ☞ nil 바로 앞 나눔에서의 "MessageBox"보다 훨씬 많은 갈래들이 씻줄로 얽혀 있습 니다. ValueDialog의 윗갈래는 전체 대화상자를 나타내는 "Dialog", 그 윗갈 래는 응용 프로그램의 겉모양인 "Shell"이 있습니다. 계속해서 씻줄을 따라 올라가다 보면 차례대로 "CompositePresenter"(모임 풀이꾼)와 "Presenter" (풀이꾼)을 지나 마침내는 모든 객체들의 뿌리인 "Object"에 이어집니다. 위에서 살펴본 바와 같이 Dolphin Smalltalk의 경우 "Prompter"는 응용 프로 그램의 뼈대인 "MVP"(Model-View-Presenter) 구조로 되어 있습니다. 풀이꾼 (presenter)은 응용 프로그램의 모형(model)과 보임새(view)를 조정하여 전 체 응용 프로그램을 통제하는 역할을 합니다. 아무튼 "Prompter" 역시 이러 한 "MVP"의 구성 요소인 풀이꾼(presenter)의 일부라는 것만 생각하면 될 것 입니다. 여기서 우리는 "Prompter"가 글줄 입력 상자라는 것만 알아두면 되고, 그 갈 래가 얽혀있는 갈래들이 무슨 의미가 있는지는 자세히 알 필요가 없습니다. 그냥 "Prompter"는 풀이꾼의 한 종류라고만 생각하면 될 것입니다. MessagBox 갈래에 우리는 갈래 지시(class message)를 내려서 알림 상자를 만든 것처럼 "Prompter"에도 그 갈래 자신이 알아들을 수 있는 지시를 내려 서 글줄 입력상자를 만들어야 합니다. 일터에서 아래 글토막을 입력하고 가늠해(evaluate it) 보십시오. Prompter prompt: '이름을 입력하세요' caption: '이름 입력' <그림 3-29> #prompt:caption:으로 표시한 글줄 입력 상자 (Stp3-29.gif) 위의 글토막을 입력해서 가늠해 보면 <그림 3-29>와 같이 글줄 입력 상자가 나타날 것입니다. 창이 하나 열리고 글줄 입력칸(edit box) 안에서 여러분의 입력을 기다리는 커서가 깜박거리고 있습니다. 이제 여기에 여러분의 이름을 넣고 글쇠를 눌러봅시다. 저는 "김찬홍"이라고 입력하겠습니다. 이름을 입력하고 를 눌렀더니 어떻게 되었습니까? 네, 상자가 닫혔습 니다. 그런데 일터를 보면 아무런 결과가 나타나지 않았습니다. 도대체 어떻 게 된 일일까요? Prompter 갈래에 #prompt:caption:이라는 지시를 내리면 <그림 3-29>와 같은 글줄 입력 상자를 표시합니다. 이제 여기에서 사용자가 어떤 글줄을 입력하 고 를 누르면 상자는 닫히고 #prompt:caption: 지시의 실행을 마칩니 다. 이 때 결과로써 사용자가 입력한 글줄이 넘겨집니다. Smalltalk에서 어 떤 객체에게 지시를 내리면 __반드시 결과가 되돌아온다는 것__을 기억하십 니까? 우리의 글줄 입력 상자도 사용자의 입력에 반응하여 지시의 결과를 넘 깁니다. 그런데 우리는 위의 글토막을 가늠하기만 했지 그 결과를 펴지 않았 기 때문에 아무런 값도 나타나지 않은 것입니다. 자, 이제 다음의 글토막을 펴 봅시다. 아래의 글토막을 글쇠를 이 용해서 펴 보십시오. Prompter prompt: '이름을 입력하세요' caption: '이름 입력' ☞ '김찬홍' 위에서 한 것처럼 Prompter 갈래에 다시 한 번 #prompt:caption: 지시를 내 렸습니다. 입력 상자가 나타나면 여러분 자신의 이름을 입력한 뒤에 글쇠를 누릅니다. 상자가 닫히면서 여러분이 입력한 값이 일터에 표시되어 있는 것을 확인할 수 있을 것입니다. <그림 3-30> #prompt:caption: 지시를 내린 결과를 편 모습 (Stp3-30.gif) 이렇게 Prompter 갈래에 #prompt:caption: 지시를 내려서 글줄 입력 상자를 열 수 있고 여기에 어떤 값을 입력하면 지시의 결과값으로 입력 받은 글줄을 넘기게 됩니다. 프로그래머는 이렇게 입력된 글줄을 이용해서 프로그램에 필 요한 자료로 이용하면 되는 것입니다. ---<잠깐!>---------------------------------------------------------- '가늠하기'와 '펴기' 혹시나 해서 정리해 둡니다. Smalltalk에서 글토막을 실행하는 방법은 세 가 지가 있습니다. '가늠하기', '펴기', '탐색하기'가 바로 그것입니다. 이는 이미 "첫째 마당"에서 설명을 한 바 있습니다. 그러나 혼동되시는 분들을 위 해서 다시 한 번 간단하게 정리해 둡니다. * 가늠하기(evaulate it): 글토막을 실행하기만 하는 동작. 글토막을 가늠한 뒤에 나온 결과는 버린다. * 펴기(display it): 글토막을 실행한 뒤에 실행 결과로 나오는 값을 표시하 는 동작. 글토막의 실행 결과는 덩이가 씌워진 채로 나타나므로, 결과가 필요 없으면 글쇠를 이용하여 지울 수 있다. * 탐색하기(inspect it): 글토막을 실행한 뒤에 실행 결과로 나오는 객체를 '객체 탐색기'(inspector)에서 들여다 보는 동작. 탐색기 안에 객체의 모 든 상태가 표시된다. 글토막을 실행할 때에 "Workspace" 메뉴에 있는 "Display it", "Evaluate it", "Inspect it" 메뉴를 사용하면 각각의 글토막을 가늠하거나 펴거나 탐 색할 수 있습니다. 단축키는 가늠하기가 , 펴기가 , 탐색하 기가 입니다. ---------------------------------------------------------- 그런데 만약 #prompt:caption: 지시를 받아서 열린 입력 상자에 아무런 내용 을 입력하지 않고 글쇠나 "Cancel" 단추를 누르면 어떤 일이 일어날까 요? 벌써 호기심 많은 사람들은 시험을 해 보았을 것입니다. 결론을 말한다 면 "nil", 즉 '헛 값'이 넘어옵니다. 누차 이야기했지만 "nil"은 "아무 것도 없다"는 뜻을 나타낸다고 했습니다. 그러므로 사용자가 아무런 글줄도 입력 하지 않은 상태에서 그냥 입력 상자를 닫아버렸다면 되돌아오는 값 역시 "헛"일 수 밖에는 없겠지요. 글줄 입력 상자는 #prompt:caption: 지시와 더불어 다음과 같은 갈래 지시 하나를 더 알아들을 수 있습니다. 아래 글토막을 펴 봅시다. Prompter on: '김찬홍' prompt: '이름을 고치세요.' caption: '이름 수정' 위의 글줄을 펴면 다음 그림과 같은 창이 나타날 것입니다. <그림 3-31> 이미 있는 글줄을 편집하기 (Stp3-31.gif) #prompt:caption: 지시가 완전히 새로운 글줄을 만들어 내는 것과는 달리 #on:prompt:caption: 지시는 "on:" 뒤에 있는 글줄에 기초해서 입력 상자를 만듭니다. 그림에서 보는 바와 같이, "on:" 열쇠말 뒤에 있는 '김찬홍' 이라 는 글줄이 입력칸에 표시되었습니다. 여러분은 이렇게 해서 표시된 글줄을 고쳐서 새로 입력할 수도 있겠고, 완전히 새로운 글줄을 다시 입력해도 될 것입니다. 아무튼 #on:prompt:caption:은 "on:" 뒤에 나타난 글줄을 편집하 여 결과를 넘긴다는 점이 다릅니다. 물론 이렇게 해서 열린 입력 상자에서도 "Cancel" 단추나 글쇠를 누르면 "nil"을 넘기게 됩니다. 이제 Prompter 갈래가 알아들을 수 있는 지시에 대해서 모두 다 살펴보았습 니다. 아래에 Prompter갈래가 알아들을 수 있는 갈래 지시를 다시 한 번 정 리해 보았습니다. Prompter 갈래가 알아들을 수 있는 지시 ---------------------------------------------------------- Prompter prompt: aStringPrompt caption: aStringCaption 창의 제목을 "aStringCaption"으로 하는 글줄 입력 상자를 만들어 연다. 입 력 상자 안에는 "aStringPrompt" 글줄로 지정된 내용이 표시된다. 입력 칸 에 글줄을 써 넣고 "OK" 단추를 누르거나 글쇠를 치면 입력칸의 내 용을 그대로 넘긴다. "Cancel" 단추나 글쇠를 치면 상자는 닫히고 "nil"을 넘긴다. Prompter on: aValueModel prompt: aStringPrompt caption: aStringCaption "aStringCaption" 제목을 갖는 글줄 입력 상자를 만든다. 상자 안에는 "aStringPrompt" 글줄의 내용이 표시되며, 입력칸 안에는 "aValueModel"에 넣어준 객체(보통은 글줄)의 내용이 표시된다. 글줄을 편집하거나 새로 입 력한 다음 "OK" 단추나 글쇠를 치면 해당하는 글줄이 넘겨지고, "취소" 단추나 큭뢰슬 치면 "nil"이 넘어온다. ---------------------------------------------------------- ---<잠깐!>---------------------------------------------------------- 한글 단추로 바꿀 수 없을까? 글줄 입력 상자를 열어보면 "OK"와 "Cancel"이라는 두 개의 단추가 있습니 다. 대화상자에서 보통 이 단추는 "확인"과 "취소"라고 표시됩니다. 그럼 우 리의 Dolphin Smalltalk에 있는 글줄 입력 상자의 단추는 한글로 고칠 수 없 는 것일까요? 절대 그렇지 않습니다. 당연히 고칠 수 있습니다. 여러분이 MVP 구조에 대해서 좀 더 많이 익숙해지고, 보임새잡이(view composer)에 익 숙해지게 되면 얼마든지 대화 상자를 구성하는 단추의 글을 바꿀 수 있습니 다. 그러나 그 길은 아직 멀고도 멉니다.... ^^: ---------------------------------------------------------- 입력 상자의 첫 번째 종류로써 여기서는 "글줄 입력 상자"를 어떻게 만들고, 만들어진 글줄 입력 상자에 입력된 글줄을 어떻게 가져오는지에 대해서 살펴 보았습니다. MessageBox 갈래와 같이 Prompter 갈래도 역시 갈래 자신이 알 아들을 수 있는 지시를 통해서 입력 상자를 만들어서 보여주었습니다. 따라 서 알림 상자나 입력 상자 모두 갈래 지시를 잘 활용해야 할 것입니다. 다음 나눔에서는 몇 가지의 선택할 수 있는 값을 준비하고 그 중에서 사용자가 원 하는 것을 골라서 입력할 수 있는 목록 입력 상자에 대해서 알아보겠습니다. 계속... 제 목:[잡담] 패턴: 객체지향 패러다임의 철학 관련자료:있음 [164] 보낸이:김찬홍 (지니반쪽) 2000-04-13 07:26 조회:149 정남님의 글 잘 읽었습니다. 아래 MVC에 대해서 설명을 해 주셨는데요, 결국 리눅스용으로 나온 Smalltalk도 역시 MVC나 기타 다른 짜임새(framework)를 사용해서 GUI를 구현하는군요. 아주 재미있습니다. 저는 Smalltalk를 처음 공부할 때에는 Smalltalk/V를 사용했습니다. 그쪽에서는 Model-Pane이라는 조금은 독특한 체계를 사용했었는데, 배우기도 어렵고 그 당시는 OO에 대한 개념이 아직 덜 정립되던때로 그냥 관둬버렸습니다. 그러나 Dolphin을 알게되면서 나름대로 GUI의 짜임새를 터득하게 됐습니다. 물론 저는 프로그래밍만 들입다 공부하는 입장이 아니기 때문에 Smalltalk에서 GUI의 짜임새를 어느 정도 이해하는데 6개월이라는 시간이 걸렸습니다. :) 아무튼 Dolphin의 MVP(Model-View-Presenter)에 대해서도 인제 개념이 잡히려고 합니다. 말씀하신 MVC와 상당히 흡사한 구조로 되어있다는 것도 이제야 깨달을 수 있어서 다행입니다. 아무튼 Visual Basic이나 Delphi와는 사뭇 다른 GUI 작업 방식이라서 많이 힘들었지만, 아예 예전 것을 완전히 잊어버리려 하고 새롭게 적응하려고 하니 이제 조금씩 뭔가 보이는것 같습니다. 정남님께서도 말씀하셨지만, 저는 디자인 패턴은 결국 "객 향 패러다임의 철학"이라고 생각하고 싶습니다. 1970년대에 구조적 패러다임이 프로그래밍의 주류를 이루고 있을 때, 그 때는 갖가지 알고리듬과 자료구조가 등장했었습니다. 결국 패턴이라는 것도 객체지향 패러다임의 특성을 이용해서 공통으로 쓰기 위한 방법론을 제시한 거라고 생각합니다. 예를 들면 "퀵 소트를 할 때는 어떤 알고리듬이 필요한가?" "스택을 구현할 때는 어떤 알고리듬과 자료구조를 써야 하는가"와 같이 철저히 기능중심의 사고를 해 오던 기능주의에서, 각각의 기능을 어떻게 객체로 만들것인지를 생각하는 구성주의로 패러다임이 바뀌었다고 해야겠지요. 제가 객체지향에 대해서 공부하기 시작한 건 1993년 정도입니다. 그 때 C++이 많이 뜨던 시기였죠. 저도 그래서 함 공부를 해 볼 참으로 C++ 책을 구해서 봤는데, 역시 객체지향 책에서 등장하는 상속성, 다형성, 포장성(encapulation) 등의 개념이 들어있더군요. 그런데 대부분의 C++책이 그렇듯이, 제가 본 대부분의 책들도 C++ 언어의 문법을 위주로해서 설명을 한 것이었습니다. 즉 기존 구조화 프로그래밍의 틀 속에서 C++을 바라보려고 했고, 그래서 결국 C++의 복잡한 문법에 치중한 설명이 나오게 된 것이지요. "음, 과연 이러한 객체지향적인 기법을 어떻게 써먹을까"에 대해서 생각해 봤지만, 상대적으로 구조적 프로그래밍보다는 그 개념이 방대하고 낫설었기에 많은 어려움을 가지고 있었습니다. 1995년 Delphi라는 놈을 보면서 저는 또 한번 경악했습니다. "와, 객체지향이라는 게 이렇게 편한거구나"라고 그 때 생각했습니다. 물론 그 때는 엄밀히 말하면 객체지향적이 아니라 "GUI 지향"이라고 해야 옳았습니다. 지금도 그 때 만들어 놓은 바탕글(source)을 들여다보면 제 자신이 한심해집니다. 프로그램이 UI와 완전히 밀착되어있어서 요구사항이 조금만 바뀌어도 프로그램은 거의 엉망이 됩니다. 흡사 GOTO를 남발해서 만들어진 스파게티 코드라고도 생각이 들었습니다. 그러나 그 때까지만 해도 "왜 따로 갈래(class)를 만들거나 상속을 받아서 쓰는지"에 대한 생각이 없었습니다. 그런데... 98년부터 Smalltalk 공부를 하면서 저의 이런 생각은 많은 변화를 겪었습니다. 솔직히 98년과 99년까지는 지금까지 내가 생각했던 객체지향이라는 패러다임을 다시 음미해보고, 제 나름대로 이 패러다임을 소화해 가는 시기였습니다. 이제 나름대로 객체지향에 대해서 어느 정도 기반을 다지고 있다고 생각하니, 정남님이 말씀하신 "패턴"이라는 것이 보이더군요. 우리가 의자를 만들기 위해서는 여러 가지 부품이 필요합니다. 작은 나무도막, 큰 나무도막, 나무 판, 못, 망치... 이런 연모들을 잘 조립하면 하나의 의지가 됩니다. 물론 작은 물건을 만들 때에는 아무런 생각 없이 마구 만들면 되지만, 자동차나 집을 만들거라면 좀 더 체계적인 방법을 사용해야 합니다. 이른바 '공법'이라고 하는게 그래서 생긴 것이지요. 똑같은 집을 만들어도 어떤 방법을 사용해서 만들 것인가.... 패턴은 바로 그런 공법이라고 생각되어집니다. 패턴이란 게 나올 수 있는 것은, 객체지향의 가장 기본적인 구성 요소인 객체와 지시(message), 그리고 갈래(class)가 있기 때문이라는 정남님의 말씀은 정말 천번만번 옳습니다. 실제적으로 C++이나 Delphi처럼 혼합 객체지향 프로그래밍에서는 생각해 보지 않은 것입니다. 왜냐? 그쪽 언어에서는 맘만 먹으면 쉽게 구조적 프로그래밍의 해법으로 프로그램을 짤 수 있었기 때문이죠. 그러나 Smalltalk는 날랐습니다. 아니, 달라보였습니다. 이제 약 1년 반 정도 Smalltalk를 공부하다 보니, 어느새 "짜임새"(framework)라는게 무언지, 이게 왜 필요한건지, 그리고 패턴이란게 어떤 건지 이제 감이 잡힙니다. 그 동안 Smalltalk의 문법과 바탕 본(base image)에 있는 객체들의 기능을 익히는 단계에서, 이제 제 스스로도 한 단계 더 발전했다는 생각이 들 정도죠. 여러 가지 물건을 조립해서 다른 물건을 만들듯이, Smalltalk에서도 여러 가지의 객체를 조립하거나, 이미 있던 갈래에서 새로운 아랫갈래를 지어내서 문제를 해결하는 여러 가지 방법들이 이제서야 눈에 들어오기 시작했습니다. Smalltalk 시스템 자체가 여러 가지 객체들이 서로 의사소통하면서 이루어지는 것이란 게 정말 신기하기까지 했습니다. 그래서, 며칠 전에 저는 "Design Pattern"과 "Design Pattenr Smalltalk Companion"이라는 두 개의 책을 구입했습니다. 결과적으로 패턴이란 것이 공부할 만한 충분한 가치가 있다는 것, 그리고 이러한 패턴을 잘 공부해 두면 비로소 객 향 프로그래밍의 한 단계를 더 알아나갈 수 있다는게 제 믿음입니다. 여태까지는 객체지향 설계 쪽으로 관심을 갖고 있다가, 구현 쪽에서도 이러한 방법이 있음을 깨닫게 된 제가, 너무 한심합니다. 좀만 일찍 깨달았어도... 결국 정남님의 글이 저에게 아주 큰 도움을 준 셈입니다. "Design Pattern Smalltalk Companion"에서는 "언어가 다르면 생각이 달라지고, 생각이 다르면 언어도 달라진다"는 말이 있더군요. 솔직히 Delphi나 Visual Basic 같은 여러 가지 도구들은 비슷한 개념을 형성하고 있습니다. 그래서 어느 하나의 도구나 언어에 얽메이지 말라는 선배의 충고가 마음에 와닿았습니다. 그러나 Smalltalk를 쓰면서 생각이 바뀌었습니다. 정남님의 말과 같이, 분명히 Smalltalk에서 생각하는 것과 다른 언어에서 생각하는 것은 많이 다릅니다. 물론 이러한 것들을 잘 조합해서 전체적인 것을 조망할 수 있는 능력은 꼭 필요하겠지요. 여하튼간에, 이제는 객체지향에서 컴포넌트지향으로 옮아가고 있는 이 시점에서, 객체지향 설계 기법과 구현 기법은 나름대로 공부해 볼 충분한 가치가 있다고 생각합니다. 정말, Smalltalk를 배우고 나서는 객체지향이라는 패러다임을 바라보는 시각이 훨씬 다양해짐을 느낍니다.... 아, 이게 객체지향이구나... 이제 조금씩 감이 잡힙니다. 저도 단순히 프로그래밍적이나 기능적인 것에만 치우치지 않고, 그 속에 숨어 있는 철학을 발견할 수 있도록 좀 더 깊이 있게 공부를 해야할 것 같습니다. 정남님, 다음에 또 좋은 글 올려주세요. 고맙습니다. 그럼. 제 목:[답변] Framework(짜임새) 관련자료:있음 [167] 보낸이:김찬홍 (지니반쪽) 2000-04-14 02:14 조회:152 안녕하세요? 김찬홍 안드레아입니다. 아래 성윤님께서 짜임새에 대해서 답변을 해 주셨습니다. 정말 감사하구요, 저도 이제 객체지향의 참 맛을 알아가려고 하는 찰라이기 때문에, 많이 모르는 것이 있습니다. 그러니 틀린 게 있다면 지적을 해 주세요. Smalltalk는 객체지향 언어입니다. 그래서 Smalltalk의 모든 것은 객체입니다. 그래서 우리들이 Smalltalk에서 프로그래밍을 한다는 말은, 결국 Smalltalk 안에 들어있는 객체들을 이용해서 일을 하는 것입니다. 자, 여기에 디스켓이 있습니다. 이 디스켓은 한 덩어리의 객체로 되어있지 않고 여러 가지 작은 객체를 가지고 있습니다. 잘 보십시오. - 디스켓 겉 껍질 - 보호용 미닫이 철문 - 디스켓 앞판 - 디스켓 뒷판 - 쓰기방지 칸막이 - 디스크 원판 - 회전판 디스켓이라는 하나의 객체를 이루기 위해서는 위와 같이 여러 개의 작은 객체들이 모여야 합니다. 이런 객체들은 서로 나름대로의 역할을 가지고 있습니다. 그리고 각각의 객체들이 서로 의사소통을 하면서, 즉 객체들끼리 서로 지시를 주고 받으면서 일을 합니다. 그런데 디스켓을 구성하는 작은 객체들을 아무렇게나 배치한다고해서 디스켓이 되지는 않습니다. 바로 객체들을 일정한 틀에 맞도록, 즉 일정한 짜임새에 맞도록 배치해 주어야 합니다. 짜임새(framework)란 바로 이러한 틀입니다. 여러 개의 객체들을 서로 조립해서 일을 처리해야할 때, 어떻게 이들 객체들을 조립해야 할지를 결정하는 것입니다. 자동차를 생각해 보면, 자동차에는 디스켓보다 훨씬 많은 객체들이 복잡하게 얽혀있는데, 이는 '자동차'를 구성하는 짜임새(framework)가 미리 정해져 있기 때문입니다. 집도 그렇고요... 아무튼 복잡한 일을 하기 위해서는 여러 개의 객체가 협동해서 일을 해야 한다는 것이 짜임새의 가장 중요한 이야기입니다. MVP(Model-View-Presenter) 짜임새는 Smalltalk를 사용해서 응용 프로그램을 만들 때 필요한 짜임새입니다. MVP 짜임새는 크게 '모형', '보임새', '풀이꾼'의 세 무리의 객체가 조립된 형태입니다. '모형'(model)은 응용 프로그램 자체의 모형입니다. 흔히 '문제 영역'(domain model)이라고 부르기도 합니다. 프로그램의 핵심적인 논리가 이 모형 속에 집약되어 있습니다. '보임새'(view)는 프로그램의 겉모양입니다. 어떤 프로그램이던지 사용자와 대화를 해야하는데, 그 때 드러나는 프로그램의 겉 껍데기를 말합니다. 단추, 글줄 입력 상자 등은 모두 자신들의 창을 가지고 있는데, 이런 것들이 모두 보임새에 들어갑니다. '풀이꾼'은 사용자와 대화하는 실제적인 부분으로, 마우스와 키보드에서 들어온 사용자의 입력을 받아서 모형(model)과 보임새(view)를 통제하여 전체적인 프로그램을 풀어가는 역할을 수행합니다. 비슷한 것으로는 성윤님께서 말씀하신 MFC의 Doc/View구조와 MVC가 있습니다. MVP는 Dolphin Smalltalk에서 채택한 짜임새입니다. 일단 MVP나 짜임새에 관한 것들은 객체지향에 대해. 그리고 Smalltalk에 대해 좀 더 공부한 뒤에 익히셔도 무리가 없을 것입니다. 언제가 될지는 모르겠지만, Smalltalk 배우기에서도 이러한 짜임새를 좀 다루어 볼 생각입니다. 그러기 위해서는 우선 기본에 충실해야 하기 때문에, 조금 더디더라도 Smalltalk에 대해서 충분히 깊이 있게 다루고자 합니다. 아무튼 여러분들께서 지치지 않게 좀 도와주시고요, 혹시나 제 글에서 틀린 부분이 있다면 서슴지 마시고 지적해 주십시오. 그래야 저도 공부를 해서 잘못된 것을 고칠 수 있기 때문입니다. 그럼 객체지향 공부 열심히 하세요. 화이팅! 제 목:[강좌] Smalltalk 배우기 #33 관련자료:있음 [170] 보낸이:김찬홍 (지니반쪽) 2000-05-11 17:08 조회:143 Smalltalk 배우기 #33 2000. 4. 22. 김찬홍 mailto:andrea92@hitel.net ====================================== 3. 객체로 채워진 세상 3.1. 알아보자, 알림판! 3.2. 꼬리표 인생 3.3. 운동장 놀이 3.4. 앗, 나의 실수!!! 3.5. 대화의 창 3.5.1. 알림 상자 3.5.2. 글줄 입력 상자 c→ 3.5.3. 목록 입력 상자 ........ ======================================= 3. 객체로 채워진 세상 --------------------------- 3.5. 대화의 창 ~~~~~~~~~~~~~~ #32에서... 3.5.3. 목록 입력 상자 --------------------- 앞에서 우리는 입력 상자를 열어 글줄을 입력받는 방법을 알아보았습니다. Prompter라는 갈래에 #prompt:caption:이나 #on:prompt:caption: 같은 지시 를 내려서 글줄을 입력할 수 있었습니다. 그런데 프로그램을 작성하다 보면 글줄을 입력받는 것보다는 미리 몇 가지의 항목을 정해 놓고 사용자들에게 선택권을 주는 것이 더 유용할 때가 있습니다. 특히 글쇠판에 익숙하지 못한 사람들은 화면에 표시된 항목을 마우스로 클릭하는 것이 보다 더 쉬울 것입 니다. 여기서는 미리 마련된 목록을 선택하여 값을 입력할 수 있는 목록 입 력 상자에 대해서 알아봅시다. 목록 입력 상자에도 "ListPrompter"라는 이름이 붙어있습니다. 역시 이 "ListPrompter"는 갈래(class)의 이름입니다. 아래 글토막을 차례로 가늠하 면서 ListPrompter가 어떤 갈래 씻줄에 얽혀있는지 알아봅시다. ListPrompter superclass ☞ ValueDialog ValueDialog superclass ☞ Dialog Dialog superclass ☞ Shell Shell superclass ☞ CompositePresenter CompositePresenter superclass ☞ Presenter Presenter superclass ☞ Object Object superclass ☞ nil "ListPrompter" 갈래 역시 "Prompter"와 마찬가지로 "ValueDialog"(값 대화 상자)에 씻줄이 얽혀있습니다. 따라서 글줄 입력 상자와 목록 입력 상자는 둘 다 비슷한 특성을 가지고 있다고 생각하면 됩니다. 다만 글줄 입력 상자 가 글쇠판에서 글자 입력을 받아서 처리하는 것과는 달리 목록 입력 상자의 경우는 미리 정해진 목록에서 선택하는 것이 다를 뿐입니다. "ListPrompter" 갈래가 알아들을 수 있는 갈래 지시를 내림으로써 목록 입력 상자를 열고 값을 입력받을 수 있습니다. 일터에서 다음의 글토막을 펴 보십 시오. ListPrompter list: #('빨강' '파랑' '노랑') caption: '색깔을 고르세요.' ☞ '노랑' <그림 3-32> #list:caption: 지시를 받은 ListPrompter (Stp3-32.gif) 위의 글토막에서처럼 ListPrompter에 #list:caption:이라는 지시를 내리면 목록 입력 상자를 열고 사용자의 선택을 기다립니다. 목록 입력 상자가 처음 열릴 때에는 항상 첫 번째 항목이 돋이되어 있습니다. 우리의 경우는 "빨강" 이 돋이되어 있을 것입니다. 저는 이 상태에서 "노랑"을 돋이한 다음 "확인" 단추나 글쇠를 눌렀습니다. 그랬더니 글토막의 실행 결과로 '노랑' 이라는 글줄이 그대로 넘어왔습니다. 위의 보기에서 사용자는 새로운 글줄을 입력할 필요가 없습니다. 다만 우리 가 지정해 준 세 개의 항목, '빨강', '파랑', '노랑'만 선택할 수 있도록 되 어 있습니다. 따라서 사용자가 선택한 것이 그대로 결과값으로 넘어오는 것 입니다. 이와 같은 목록 입력 상자는 프로그램에서 어떤 상황에 직면했을 때 사용자에게 선택권을 줄 수 있기 때문에 매우 편리할 것입니다. {{}}#list:caption:에서 "list:" 열쇠말(keyword)의 뒤에는 사용자가 어떤 항목 을 선택할 수 있는지를 적어주어야 합니다. 보는바와 같이 "list:" 열쇠말 뒤에는 배열(array)을 써 주었습니다. 여기서 쓴 #( )은 "2.3.5."(#19) 마디 에서 배열의 바로값(array literal)을 만들 때 사용한다고 설명한 바 있습니 다. 아무튼 위의 경우 '빨강', '파랑', '노랑' 이라는 세 개의 성분을 가진 배열을 만들어서 "list:" 열쇠말 뒤에 놓아주었습니다. 이렇게 했기 때문에 목록 상자에 세 개의 항목이 포함되어 있는 것입니다. "caption:"의 경우는 설명할 필요도 없이, 목록 입력 상자의 제목 표시줄에 써 낼 글줄을 적어주 면 됩니다. 여기에는 사용자가 무엇을 선택해야 할지를 적어주면 좋을 것입 니다. "list:" 열쇠말 뒤에는 배열을 놓아줄 수 있다고 했습니다. 그런데 배열에는 글줄뿐만 아니라 필요하면 어떤 객체이든지 모두 다 들어갈 수 있습니다. 그 래서 다음과 같이 할 수 있습니다. <바탕글 1>에 덩이(block)를 씌운 후 펴 봅시다. <바탕글 1> 여러 가지 갈래의 객체 목록 선택하기 ---------------------------------------------------------- ListPrompter list: #(123 3.14 false true #apple nil $a '가나다') caption: '골라~ 골라~'. ---------------------------------------------------------- 글토막을 한 줄에 쓰기가 너무 길어질 경우에는 위와 같이 두 줄 이상으로 나누어 쓴 다음 덩이를 씌워서 가늠해도 상관이 없다는 것은 이제 여러분들 도 잘 알고 있을 것입니다. 위와 같이 <바탕글 1>을 펴면 다음 그림과 같은 목록 입력 상자가 열리게 됩니다. <그림 3-33> 여러 가지 갈래를 담은 목록 입력 상자 (Stp3-33.gif) 그림에서 보면 정수, 소수, 거짓(false), 참(true), 이름값(#apple) 글자 ($a)와 글줄('가나다')이 나타난 것을 볼 수 있습니다. 이 목록 중에 여러분 이 고르고 싶은 데로 항목을 고른 뒤에 "확인" 단추를 눌러 보면, 바탕글을 실행하고 난 뒤에 여러분이 선택한 목록이 그대로 나타나 있는 것을 볼 수 있습니다. 신기하지 않습니까? 이렇게 목록 입력 상자를 사용하면 여러 개의 객체를 목록으로 만들어 놓고, 사용자가 원하는 것을 고르게 할 수 있습니 다. 이 목록 입력 상자에서 재미있는 것은, 헛(nil)의 경우는 항목에 'nil'이라 표시되지 않고 아예 비어있는 항목이 만들어졌다는 것입니다. 왜냐하면 "nil"은 아무 것도 없는 그야말로 '헛'을 나타내기 때문에 완전히 비어 있는 항목이 만들어지게 된 것입니다. 그런데 목록 입력 상자만을 봐서는 어떤 것이 글줄이고 어떤 것이 글자이며, 또한 어떤 것이 이름값인지를 구별하기가 어렵습니다. 그렇지만 대부분의 경 우 목록 입력 상자에서는 숫자나 글줄만 사용하기 때문에 실제로 큰 혼란은 없을 것이라고 생각합니다. 지금까지 우리는 목록 상자에서 한 개의 항목만 선택할 수 있었습니다. 그런 데 필요하면 두 개 이상의 항목을 선택할 수도 있습니다. 아래의 <바탕글 3> 을 일터에 입력한 다음 펴 보십시오. <바탕글 2> 두 개 이상의 항목을 선택할 수 있는 목록 입력 상자 ---------------------------------------------------------- ListPrompter multipleSelectionList: #('빨강' '파랑' '노랑') caption: '색깔을 두 개 이상 고르세요.' ---------------------------------------------------------- 겉으로 언뜻 보면 ListPrompter에 #list:caption: 지시를 내려서 열린 목록 입력 상자나 #multipleSelectionList:caption:으로 열린 목록 입력 상자는 별로 달라 보이지 않습니다. 그러나 항목을 선택할 때 다음과 같은 방법을 사용하면 두 개 이상의 항목을 선택할 수 있습니다. 목록 상자에서 두 개 이상의 항목 선택하기 ---------------------------------------------------------- * 한 개의 목록을 선택하려면 그냥 해당 항목을 클릭한다. * 연속된 목록을 선택할 경우에는 시작 항목을 클릭한 후 끝 항목은 키를 누른 상태에서 클릭한다. * 연속되지 않은 목록을 선택할 때에는 키와 함께 누른다. ---------------------------------------------------------- 이렇게 하면 목록 입력 상자에 있는 항목을 두 개 이상 고를 수 있습니다. 그러면 우리도 위의 방법을 사용해서 두 개 이상의 항목을 골라보도록 하겠 습니다. 다음과 같이 해 보십시오. * '빨강'을 한 번 클릭하여 선택합니다. * 키를 누른 상태에서 마우스로 '노랑'을 한 번 클릭합니다. 위와 같이 했다면 다음 그림과 같이 두 개의 항목이 선택된 것을 볼 수 있을 것입니다. <그림 3-34> 다중 선택 목록 상자에서 항목 선택하기 위와 같이 "빨강"과 "노랑"을 함께 선택한 뒤에 "확인" 단추를 누르면 결과 로 다음과 같은 값을 넘기는 것을 볼 수 있습니다. ☞ #('빨강' '노랑') 이와 같이 ListPrompter 갈래에 #multipleSelectionList:caption: 지시를 내 리면 두 개 이상의 항목을 선택하여 결과를 얻을 수 있습니다. #list: caption: 지시를 사용할 때와 달라진 것은 넘어오는 결과가 배열이라는 것입 니다. 왜냐하면 한꺼번에 두 개 이상의 객체를 담을 때에는 배열과 같이 여 러 개의 객체를 담는 통(container)이 필요하기 때문입니다. 그럼 여기서 <바탕글 2>를 한 번 더 펴 봅시다. 이번에 열린 상자에서는 "파 랑"이라는 한 가지의 항목만을 선택한 다음 "확인" 단추를 눌러봅시다. 그러 면 결과로 #('파랑')이 넘어오는 것을 볼 수 있을 것입니다. 이와 같이 한 개의 항목만 선택할 경우에도 #multipleSlectionList:caption: 지시의 결과 는 언제나 배열이라는 것을 알 수 있습니다. 배열에 들어 있는 객체는 #at: 지시를 사용하면 언제든지 내용을 볼 수 있습 니다. 다음 바탕글을 펴 보십시오. <바탕글 3> #multipleSelectionList:caption:의 결과값 활용 ---------------------------------------------------------- | result | result := ListPrompter multipleSelectionList: #('빨강' '파랑' '노랑') caption: '색깔을 두 개 이상 고르세요.'. result at: 2. ---------------------------------------------------------- 위의 바탕글을 펴면 목록 입력 상자가 열린 것입니다. 이 때 <그림 3-34>와 같이 "빨강"과 "파알"을 선택한 다음 "확인" 단추를 눌러봅시다. 그러면 바 탕글의 결과로 '파랑'이 나타날 것입니다. 위의 바탕글에서 result 꼬리표는 #multipleSelectionList:caption: 지시의 결과값으로 나온 배열 객체에 붙어 있을 것입니다. 위와 같이 '빨강'과 '파랑', 두 개의 항목을 선택헀다면 result 꼬리표의 첫 번쨰 원소는 '빨강'이, 두 번째 원소는 '파랑'이 될 것 입니다. 따라서 result := #('빨강' '파랑'). 과 같은 글토막을 실행한 것처럼 될 것입니다. 따라서 #at: 지시에서 두 번 째 원소를 꺼내라고 지시했기 때문에 결과로 '파랑'이 나온 것입니다. 만약 여러분이 위의 바탕글을 폈을 떄 한 개의 항목만 선택했다면 어떻게 될까요? 이 경우에는 발자취 창이 열리면서 "Index 2 is out of bounds"라는 예외가 발생할 것입니다. 왜냐하면 한 개의 항목만 선택할 경우에는 당연히 두 번째 의 원소는 존재하지 않기 때문입니다. 이와 같이 #multipleSelectionList:caption:의 결과값은 배열이기 때문에, 결과를 다룰 때에도 #at: 과 같이 배열 객체를 다룰 수 있는 지시를 사용해 야 하는 것입니다. 지금까지 우리는 프로그램 사용자들에게서 글줄을 입력받을 수 있는 글줄 입 력 상자와 이미 마련된 목록을 제시하고 그 중에서 선택하게 할 수 있는 목 록 입력 상자에 대해서 알아보았습니다. 이제 이 두 가지 객체의 사용법을 익혔으니 다음에는 이것을 어디에 사용하는지에 대해서 실제로 알아보도록 하겠습니다. 계속...