소프트웨어 이야기

현 시점에서 코딩 능력은 GPT Pro 코덱스 5.4가 클로드 오퍼스 4.6보다 훨 낫네요.

에드 신 — Wed, 15 Apr 2026 18:35:24 +0900

다만 클로드가 시각화를 더 잘하고

말투가 이뻐서 그렇지

GPT 프로가 확실히 더 일잘러입니다.

저도 스타트업에서 일할때나

외주를 받아서 일을 할때

일단 UI부터, 디자인 작업부터 해주면

좋아했죠.

API, 백엔드, 스키마, 알고리즘 백날 이야기해도

고개는 끄덕이지만 소용 없었죠 ㅠㅠ

스택 오버플로우를 만든 분 중 한명인

제프 앳우드(Jeff Atwood)도

IT 컨설턴트 및 개발자로 일할때

90퍼센트 내부 로직과 설계 해도

UI를 안 하면 사람들이

작업이 진행되지 않고 있다고 여겼다는 일화가 있죠.

이 현상이 현재 클로드 코드와 코덱스한테도

일어나고 있다고 봅니다.

개발 하시는 분들이나

리서치 하시는 분들은

코덱스(Codex)가 낫다는 점을 확연히 느끼실 거 같고

클로드 오퍼스는 할루시네이션도 있고

토큰 대비 좀 아쉽긴 합니다.

근데 이쁘게 나오는 건 클로드 ㄷㄷㄷ

장사는 클로드처럼..

엔비디아 창업자 젠슨황이 말하는 1000조원 가치의 기업을 만든 과정 - 비전은 중요하다

에드 신 — Sun, 2 Jul 2023 19:24:33 +0900

평소 엔비디아(NVIDIA)가 어떻게 성장했는지 궁금했던 점이 많았습니다. 그러다 젠슨황이 2009년에 한 강의를 접하게 되었네요. 아직 엔비디아가 적당히 컸던 시절이지요. 그때 엔비디아 주식이 2달러니 지금까지 가지고 있으면 200배가 올랐겠네요.

강의에선 엔비디아의 창업 과정과 미래에 대해 논합니다. 확실히 일반적인 사람과는 다르다는 생각이 들더군요. 통찰력이 있습니다. 다 듣고 나면 '관점'에 대해 생각해볼 수 있는 강의입니다. 또한 어떤 결정을 내렸기에 인공지능 산업에서 없어서는 안될 필수품이 되었는지 뒷배경도 들어볼 수 있죠.

그럼 젠슨황의 이야기를 들어보러 가실까요?

아래 내용은 2009년 스탠포드 기업가 정신 수업 중의 일부입니다. 참고로 약간의 축약과 의역이 있습니다.

------------------

티나 : 오늘의 게스트를 소개합니다. NVIDIA(엔비디아)의 공동 창업자인 젠슨 황입니다. 18년전 그는 여러분이 앉아 있는 곳에 있었어요. 전자공학 석사 과정 학생으로 있었죠. 졸업 후 2년 뒤에 회사를 세웠습니다. 그때 이후로 CEO이자 이사회 일원으로 있었습니다. 또 하나 놀라운 점은 엔지니어링 건물 빌딩을 위해 크게 기부 했다는 점입니다. 3천만 달러를 기부했습니다. 여러분도 18년 뒤에 같은 일을 할 수 있기를 바랍니다. 그럼 젠슨황입니다.

젠슨황 : 감사합니다, 티나. 전 마지막 1원까지 다 빌딩에 주었습니다. 공식적으로 빈털털이죠. 오늘은 회사 소개를 하지 않고, 여러분과 대화를 하려고 합니다. 질문이 있으면 무엇이든 상관없으니 얼마든지 질문을 해주세요.

많은 사람들이 창업에 대해 말합니다. 제가 직접 경험한 바에 따르면 회사를 세우는 건 대단히 기쁜 일입니다. 동시에 굉장히 힘듭니다. 회사를 만드는 과정은 광범위 합니다. 여러가지 다른 관점에서 말을 할 수 있죠. 그렇기에 제 경험에 특히 중요하다고 생각되는 점을 다뤄보려고 합니다.

16년 전에, 엔비디아에는 3명이 있었습니다. 모두 엔지니어였죠. 저도 그 중 하나였구요. 그리고 우린 관점(perspective)이 있었습니다. 우리가 엔비디아를 시작했을때 어떠한 통찰이 있었는데 어떤 사람들은 이를 비전이라고 부릅니다. 비전은 내게 너무 커다란 말입니다. 비전은 너무 커다란 말인데 왜냐하면, 비전은 중요하기 때문입니다. 하지만 저는 관점(perspective)이라는 말을 쓰기를 더 좋아합니다. 왜냐하면 모든 사람이 관점을 가질 수 있기 때문입니다. 비전이란 말을 하면, 몇몇 선택된 비저너리들만 가질 수 있는 듯한 느낌을 줍니다. 하지만 모든 사람은 관점을 가지고 있습니다. 사실 이게 모든 비전이 의미하는 바입니다.

다른 사람과 다른 관점으로 세상을 보는 게 바로 관점입니다. 남들이 보지 못하지만 당신이 중요하게 생각하는 기회를 보고, 그것을 추구하는게 관점입니다. 1993년 당시 우리의 관점은 이것이었습니다. 그때 PC는 윈도우즈 3.1이었고 CD롬은 막 소개되려던 참이었습니다. 인터넷이 있는 컴퓨터는 존재하지 않았죠. 무선 통신이라고 하면 FM라디오를 떠올리게 했습니다. 무선 인터넷은 없었죠. 가장 빠른 마이크프로세서는 486DX2 였고 66MZ (메가헤르츠)였습니다. 오늘날에는 테니스 신발에도 쓸 수 없는 수준이죠. 우리는 그 마이크로 프로세서로 컴퓨터를 돌렸습니다. PC는 사무실 자동화를 하기 위해 쓰이기 시작 했죠.

우리의 관점은 이 기기가 특별해질 거라는 점이었습니다. 프로그램을 돌리는 점에서요. 만약 PC에서 3D 그래픽 프로그램을 돌릴 수 있어, 새로운 세상을 탐험하고, 게임을 할 수 있게 된다면 어떨까요. 우리는 이런 계획을 가지고 사업을 시작했습니다. 우리는 가장 비싼 워크스테이션에서 돌릴 수 있는 기술을 저렴하게 만드는 게 목표였습니다. 킬러앱은 당연히 비디오 게임이었죠. 그래서 벤처투자자(Sand Hill Road )에게 이 아이디어를 이야기 했더니, 비디오 게임 시장이 없다더군요. 사람들은 게임을 하려고 회사를 시작하지 않는다면서요. 그리고 제 부모님은 회사를 시작한다는 소리를 듣고 물어보시더군요. '너희들이 하려는게 뭐니?'. 그래서 저는 대답했죠 '3D 그래픽 칩을 만들건데, 사람들이 이걸로 게임을 할거에요'

그랬더니 어머니가 말씀하셨죠. '그냥 직장을 구하지 그러니?'

물론 우리는 게임은 커다란 시장이 될거라고 믿었습니다. 우리는 다른 관점을 가졌는데 몇가지 이유에서였습니다. 일단 우리는 비디오 게임 세대였습니다. 비디오 게임을 하면서 자라났죠. 그래서 비디오 게임, 컴퓨터 게임이 주는 재미의 가치는 명백했죠. 이 시장이 얼마나 대단히 크게 될지 상상할 수 있었습니다. 대부분의 조금 더 나이든 사람에게는 이 감각이 존재하지 않았어요

비디오 게임이 가장 큰 미디어 산업이란 건 오늘날에는 명백한 사실입니다. 하지만 당시에는 우리가 가진 상식은 독특한 것이었습니다. 아무도 그 기술을 만들지 않은 상태였죠. 아무도 비디오 게임에 필요한 기술을 위해 회사를 세우지 않았습니다. 그게 바로 우리의 관점이었습니다. 우리는 비디오 게임 세계를 느꼈고, 기술의 발달을 느꼈습니다. 제가 가장 좋아했던 애플리케이션은 키홀(Keyhole)이라 불리는 회사였습니다. 5년전이었죠. 키홀은 가상현실에 대한 실리콘 밸리 회사인데 3D 가상 공간을 만드는 회사였습니다. 주소를 입력하기만 하면 어디서나 지구를 볼 수 있고, 어떤 장소든 볼 수 있습니다. 전 이 회사가 놀라운 일을 해낼 수 있다고 믿었지만 전혀 투자를 받지 못했습니다. 그래서 우리는 투자를 했습니다. 이 작은 회사는 결국 구글이 사갔고 구글 어스가 되었습니다. 구글 어스는 세상에서 가장 많이 다운로드 되었고 많이 쓰이는 어플리케이션 중 하나입니다. 2억 다운로드에 가까깝죠. 3D 그래픽은 비디오 게임 그 이상입니다.

비전 그러니까 당시 엔비디아의 관점은 독특했고, 팔기가 어려웠습니다. 우리는 벤처 투자자들에게 가서 설명하고, 이 기술이 어디까지 갈 수 있는지, 얼마나 시장은 클지 알려야 했습니다. 어떻게 당시에는 시장 크기가 명백히 0인 시장의 크기를 잴 수 있을까요? 애널리스트 리포트나 마켓 리서치를 보면 시장이 0이라고 말합니다.

벤처 투자자들과 창업자들이 함께 독려하고 방법을 찾아내야 하는 일이었습니다. 세콰이어 캐피탈(Sequoia Capital)과 셔터 힐(Sutter Hill)이 투자를 해주었습니다. 이들과 함께 우린 2백만달러(25억)으로 회사를 시작하게 됩니다.

관점에 관해서는 흥미로운 이야기가 또 있습니다.

몇년 뒤의 일입니다. 세콰이아 캐피털이 제게 와서는 묻더군요. 스탠포드에 있는 애들인데, 뭔가 있는데 인터넷 관련된거라고 하더군요. 그래서 제가 말했죠. '노란색 페이지 말이죠?' 당시에는 여러 버전의 웹페이지가 있었습니다. 세콰이어 캐피털이 물어았습니다. '이 회사에 투자해야할까요?' 그래서 제가 말했죠. '이 친구들이 돈을 벌 수 있는 어떤 방법도 없어요. 이 웹사이트들은 공짜입니다. 그렇죠?' 그랬더니 세콰이어 캐피털이 말하길 '우리는 돈 벌 방법을 찾지 못하겠지만 엄청 비용이 들지는 않으니까요. 1백만 달러나 2백만 달러만 투자해 볼 거에요.' 이 회사는 야후라고 불리는 회사가 됩니다.

제가 1가지에 대해 관점을 가지고는 있었지만 다른 것에 대해서는 관점이 없었다는 걸 알아 차렸을 겁니다. 하나에 대해 비저너리라고 해서 모든 것에 대해 비저너리라는 건 아닙니다. 당신의 관점은 당신만의 인생 경험에서 옵니다. 당신에게 상식적인 것이고, 흥미로운 것이고, 중요한 것이 있다면 당신에게도 비전이 있는 것입니다.

이 웹사이트들에 대해서 흥미로운 점이 있습니다. 야후의 이야기를 따라가보죠. 기억하겠지만, 전에는 여러 종류의 검색 엔진이 있었습니다. 알타 비스타(Alta Vista)도 있었고, 익사이트(Excite)도 있었고 라이코스(Lycos)도 있었죠. 이들은 각자 검색엔진 역할을 잘 수행했습니다. 그럼 이제 질문은 그들의 관점은 무엇이었냐는 것입니다. 이들의 관점은 각자 어떻게 달랐을까요?

한 웹사이트는 자신을 목적지로 보았습니다. 컨텐츠를 가져다 주는 곳으로 보았죠. 그러니 검색 엔진은 상품의 일부에 불과했습니다. 그래서 아웃소싱을 했습니다. 모든 검색 엔진은 검색으로 시작했지만 목적지로 변하거나, 포탈로 변했습니다. 이들은 검색을 아웃소싱 했습니다. 이 덕분에 구글이 시작할 수 있었습니다. 알아차렸겠지만 두 회사가 동일한 것을 시작합니다. 동일한 핵심 기술을 가지고 말이죠. 하지만 완전히 다른 곳에 도달하게 됩니다. 이들이 서로 다른 관점을 지녔기 때문이죠. 이들은 세상을 전혀 다르게 봅니다. 그러니 관점은 중요합니다. 비전도 중요합니다.

우리가 회사를 시작한 뒤 얼마 지나지 않아 PC용 3D 그래픽은 중요한 것이 됩니다. 뜨거운 감자였죠. 실리콘 밸리에 있는 모든 이들이 3D 그래픽 회사를 시작합니다. 엔비디아는 1993년에 유일한 3D 그래픽 회사였지만, 1995년이 끝날 즈음에는 아마도 50, 70여개의 회사가 같은 일을 하고 있었습니다. 시간이 지나고 우리는 200여개의 회사와 경쟁을 하게 되었죠.

엔비디아는 오늘날 유일하게 살아 남은 컴퓨터 그래픽 회사입니다. 우리의 질문은 무슨 일이 있었는가 입니다. 경쟁은 치열했습니다. 모두들 똑똑한 사람들이었죠. 모두들 돈이 있었습니다. 우리는 IBM과 경쟁했고, HP와도 경쟁했습니다. 실리콘 그래픽스와도 경쟁했죠. 소니, 3DFX, S3, Cirrus Logic 등 크고 작고 세계적이고 지역에 있는 온갖 회사들과 경쟁했습니다. 제가 보기에 300개의 회사들은 동일한 기술이 있었고, 동일한 수준의 사람들이 있었고, 실행했습니다. 적어도 300개 회사 중 50%의 회사는 어느 시점에 실행을 했습니다. 하지만 1개의 회사만 살아남은 까닭은 무엇일까요?

제 생각에는 관점을 가졌다는 점 때문이었습니다. 예를 하나 들어보죠. 우린 언제나 '왜 사업이 되는가'를 이해해야 한다고 믿었습니다. 사업의 본질은 무엇일까? 무엇이 사업이 되게 할까? 제 사업의 기반은 반도체 기술이었습니다. 반도체 기술은 실리콘밸리에서 흔히 '무어의 법칙'이라고 불립니다. '무어의 법칙'은 물리적인 법칙은 아니지만, 경쟁에 관한 법칙입니다. 엔지니어들이 격려하고 도전하게 하는 법칙입니다. 속도를 정하는 것에 대한 법칙이죠. '무어의 법칙'은 매년이나 2년에 한번 2배씩 성능을 늘릴 수 있게 합니다. 이는 매년이나 2년에 1번, 사업의 요소를 2배 증가시키고, 가격을 매년 1/2로 낮춥니다. 그럼 어떻게해야 살아남는 사업을 만들 수 있을까요? 우리의 관점은 3D 그래픽은 더 많이 요구한다는 것이었습니다.

더 많이 요구하기에 매년 2배로 만들 수 있었습니다. 고객들이 너무 비싸서 관심이 없다고 할때 조차요. 하루는 델(Dell)과 HP와 IBM, 게이트웨이(GateWay)에 우리의 제품을 가지고 갔더니 모두 비싸서 살 수 없다고 했습니다. 고객들이 무언가를 하지 말라고 할때, 무엇을 하는게 맞았을까요?

우리는 3D 그래픽은 더 많은 것을 필요로 하고, 무어의 법칙이 우리를 도와줄 거라는 관점이었습니다. 따라서 매년 그래픽 처리장치를 매년 2배씩 향상시켰습니다. 회사를 세우고 첫 5년 동안, 고객을 말을 무시한채요. 어떤 마케팅 수업에서 고객을 무시하라고 가르칠까요? 가끔씩은 고객을 무시할 필요가 있습니다. 고객들도 비즈니스의 본질을 아직 모르고 있고, 산업이 막 생기는 때였으니까요. 누구도 이 비즈니스의 룰을 모르는 상황이었습니다. 우리는 마지막 몇백만 달러를 써서 하나의 칩을 만들었습니다. 너무 비싼 칩이라서 만들어진 칩을 보여주기 전까지는 어떤 고객도 사려고 하지 않았습니다. 우리는 온 힘을 다해 칩을 만들었습니다. 다음 세대의 제품이 이전의 것을 잡아 먹을 때까지 계속 만들었습니다. 그리고 우리는 몇년동안 계속해서 성장했습니다.

지금은 어떨까요? 혁신은 다소 위험한 것입니다. 새로운 좋은 아이디어를 떠올리면, 다른 좋은 아이디어가 나오고 이걸 갈고 닦아 점점 더 좋아지게 됩니다. 혁신이 노트북이든, 자동차이든, 마이크로 프로세서이든, 우리의 경우는 그래픽 프로세서였는데 매년 점점 더 좋아집니다. 어느 시점이 되면 더 좋아지기 어려운 시점이 됩니다. 반도체 기술은 이미 놀라운 진보를 했고 더 좋아지기 어려워졌죠. 이는 엔비디아에게는 90년대 말이었는데 회사를 세운지 6,7년 되는 시점이었죠.

전 3D 그래픽 장치가 단순히 화면에 텍스처맵이나 폴리곤을 그리는 기기만 되어서는 지속가능하지 않다고 보았습니다. 우리 엔비디아는 3D 그래픽 프로세서를 프로그래밍 가능하게 만들기로 결정했습니다. 3D 그래픽 프로세서는 '예술적인 표현'이 가능한 '매체'( medium)가 될 가능성이 있었습니다. 이상한 말입니다. 여기 우리는 엔지니어링 회사를 가지고, '예술적인 표현'이 가능하도록 칩을 바꾸려고 하고 있습니다. 예술적인 매체, 그러니까 모든 비디오 게임과 애플리케이션이 다른 방식으로 개발될 수 있었다는 뜻입니다. 스타일적으로요.

우리 엔비디아는 우리가 컨텐츠가 더 풍부하고 흥미롭고, 스타일적으로 다르게 만들 수 없다면 우리의 매체(칩)의 발전은 한계가 있다고 보았습니다. 우리의 매체가 한계에 달하면, 선두주자로서 우리도 끝이었습니다. 우리는 GPU를 프로그래밍 가능하도록 했습니다. '매체'(칩)가 예술적인 표현을 할 수 있도록 말이죠. 또 우리는 프로그래밍 가능한 '쉐이더'라는 기술을 개발했습니다.

모든 비디오 게임 하나 하나에서 우리가 남긴 흔적을 찾아볼 수 있습니다. 엑스박스 360이건 플레이스테이션3이건 PC게임이건 말이죠. 프로그래밍 가능한 쉐이더를 통해 게임 산업에 활기를 불어넣었습니다. 쉐이더가 무엇을 가능하게 했는지 보실 수 있습니다. 하지만 한세대의 기술에서 다음 세대의 기술로 건너가는 건 회사를 망하게 할 수도 있는 일입니다. 새로운 아이디어로 이끌었던 관점은 회사를 재창조하기도 했고, 회사를 위험에 빠뜨리기도 했습니다. 이는 이야기해볼만한 흥미로운 점입니다. 따라서 관점은 중요합니다.

회사가 커짐에 따라, 창업자 또는 CEO는 새로운 것을 배우는 법을 배워야합니다. 많은 새로운 것은 처음에는 제품을 만드는 것이지만, 곧 회사를 만드는 법에 관한 것이 됩니다. 회사를 만드는 것은 설명하기 쉬우면서도 어렵습니다. 회사를 문화를 만드는 것은 무슨 의미일까요?

어떻게 한 회사의 문화가 다른 회사의 문화와 다를 수 있을까요? 왜 이 문화는 당신의 회사에는 좋은데, 다른 회사에는 좋지 않을까요? 회사의 문화를 찾는 건 중요합니다. 직접 찾아내고 만들고 발전시켜야합니다.

그럼 어떻게 회사를 조직해야할까요? 우리는 이에 대해서 이야기 했었습니다. 기능에 따라 조직 되어있나요? 사업 단위로 조직되어 있나요? 다양한 제품과 세계 곳곳에 따른 차이와 여러 고객을 어떻게 다뤄야할까요? 이게 회사를 만드는 과정입니다. 기계적이기도 하고 흥미롭기도 하죠. 많은 시도와 실패가 있습니다. 자연스럽게 나타나기도 합니다. 사람들이 중요하고, 성격도 중요합니다. 가장 중요한 1가지만 고르자면 이것입니다. 회사와 제품을 만들때는 스킬도 중요하고, 지적능력도 중요하고, 훈련도 중요 합니다만, 이것만으로는 안 됩니다. 회사를 만드는 게 도전적인 일이고, 고통스러울 뿐더러, 종종 대단히 무서운 일이기도 하다는 걸 깨닫는 것입니다.

이렇기에 열정이 있지 않는한, 회사를 만들고 제품을 만들어 가는 과정을 사랑하지 않는한, 이는 굉장히 굉장히 힘든 일이 됩니다. 회사를 세우기로 결정했다면 스스로에게 묻기를 바랍니다. 회사를 세우는 목적이 무엇인가요? 회사를 세우고, 그 회사를 팔아서 큰돈을 벌기 위해서인가요? 회사를 주식시장에 공개(IPO)하기 위함인가요? 연속 창업가라면, 회사를 만들고 다른 사람이 운영하고, 팔기를 원하는가요? 이유가 무엇이든간에 자기 자신에게 솔직해지기를 바랍니다. 저의 경우에는 무언가를 만드는 과정을 사랑했고, 무언가의 일부가 되는 것을 사랑했을 뿐입니다.

엔비디아( NVIDA)의 일부가 되고, 같이 일하는 사람들의 일부가 되고, 저를 활기차게 하는 이유들의 일부가 되는 것이 바로 제가 매우 긴 시간동안 기꺼이 할 일 들입니다. 16년간 이 상태에 있었고, CEO가 되고 회사 창업자가 되며 많은 것을 배웠습니다. 이제 질문을 받을 시간이 되었네요. 어떤 질문이든 해주세요.

질문자 : 투자자들이 회사를 재창조 하는 과정에 대해 무슨 말을 했나요? 프로그래밍 가능한 쉐이더를 더하고, 프로덕트 카테고리를 바꾸는 위험을 감수했을때 투자자들이 무슨 말을 했나요?

젠슨황 : 우선, 이런 종류의 대화는 투자자들과 잘 하지 않습니다. 먼저 경영팀과 대화를 가지고, 같이 일하는 사람들고 이야기를 하는데 2번째 이고, 이사회는 3번째입니다. 제가 주로 택하는 방식입니다. 하이 테크 산업에 있으면 알게 됩니다. 테크놀로지(기술)의 변화 속도가 빠르기에, 스스로 재창조하지 않으면 천천히 죽어가게 되죠. 불행하게도 '무어의 법칙'은 우리가 아는 변화의 속도 중에서 가장 빠릅니다. '무어의 법칙'이 주는 복리 효과는 믿을 수 없을 정도죠.

성공적인 제품을 가지고 있어 돈을 왕창 번다고 해보죠. 이는 무서운 일이란 걸 저는 압니다. 성공적인 제품이 있다면 어떻게 스스로 잡아먹을 수 있을까 질문을 던져야합니다. 스스로 잡아먹지 않는다면 누군가가 할 겁니다. 이건 너무나도 명백합니다. 시장의 선두 주자가 되고자 한다면, 가장 먼저 자신의 제품을 잡아먹어야 하고, 이전의 아이디어를 잡아먹을 새로운 아이디어를 가지고 있어야합니다.

우리는 고정된 함수만 쓸 수 있는 그래픽 프로세서에서 시작해, 퀘이크3나 둠 같은 게임에 들어가는 텍스처 맵핑을 위한 엔진, 프로그래밍 가능한 쉐어더 아키텍처까지 만들었습니다. 우리의 첫번째 칩은 회사를 거의 망하게 할뻔 했습니다. 지포스Fx(GeForceFx) 라는 제품이었죠.

이 그래픽 카드를 가지고 있는 분이 여기에 있는지 모르겠습니다만, 지포스Fx는 프로세서인데, 엄마만 사랑할 수 있는 아기처럼, 엉망인 제품이었죠. 지포스Fx를 만드는 과정에서 우리는 거의 망할 뻔 했습니다. 하지만 이 칩을 만들지 않았다면 엔비디아는 오늘날 이미 망했을 겁니다. 저는 이를 아주 크게 확신합니다. 엔비디아 역사에서 가장 큰 도박이었죠. 우리는 API를 만드는 대신에, 언어가 있는 프로세서를 만들었습니다. 우리는 이를 CG(C for Graphics)와 컴파일러라고 불렀죠. 이는 프로세서의 일종입니다. 우리는 처음에는 사람들이 이해하지 못한 프로그래밍 패러다임을 소개했습니다. 많은 홍보와 마케팅, 교육이 필요했죠. 하지만 CG를 만든 것은 전혀 예상치 못한 곳으로 우리를 이끌었습니다.

오늘날 GPU와 관련된 가장 중요한 일은 범용 컴퓨팅 (General purpose computing - 특정 목적이 아니라 일반적인 목적을 위한 컴퓨팅) 입니다. 우리가 보는 놀라운 일들은 CG에서 비롯되었습니다. CG를 시작하지 않았다면 일어나지 않았을 일들입니다. 그러니 도약을 해야합니다. 다음 질문?

(주 - CG가 있어 GPU를 인공지능 개발에 쓸 수 있게 되었다)

(주 - 지포스Fx는 엔비디아의 흑역사로 불린다)

(주 - API는 정해진 것만 쓸 수 있는데, 프로그래밍 언어가 있으면 자유롭게 편집할 수 있다)

질문자 : 게임이 PC에서 콘솔로 이동해가는게 보인다고 합니다. 소니나 닌텐도와 협상하기는 어렵지 않나요? 개개인에게 그래픽 카드를 파는 것보다요.

젠슨황 : 우리가 가격을 정하지 않습니다. 경쟁이 가격을 정합니다. 시장이 가격을 정하지 않습니다. 경쟁이 가격을 정합니다. 그러니 경쟁자가 플레이 스테이션3를 만들고자 한다면 그렇게 하게 두세요. 경제적 요인으로 인해 험난할 것입니다. 그리곤 결정하게 하세요. 이건 당신에게 경제적 이유입니까? 예를 들면, 우리가 특정 콘솔을 더 선호하고, 특정 콘솔은 그렇지 않다는 루머가 있습니다. 이건 우리에게 달려있습니다. 우리의 자원은 한정되어 있습니다. 매니저로서 당신에게 부족한 자원은 무엇인가요? 매니저는 최대의 결과를 얻기 위해 자원을 할당하는 일을 합니다. 우리의 자원의 경우는 제한된 수의 탁월한 엔지니어만 있다는 것입니다. 이들이 하루에 쓸 수 있는 시간은 정해져 있습니다. 어떤 기회를 추구하는 간에요.

우리의 엔지니어로 할 수 있는 일보다 시장의 수요가 많다면 저는 분명히 열정적으로 되겠지요. 반대의 경우, 경제적으로 끔찍한데 게임 콘솔을 만들거나 어떤 프로젝트를 하는 건 할 만한 가치가 있는 일이 아닙니다.

저는 이를 경쟁이랑 무관하게 봅니다. 경쟁은 가격을 정합니다. 하지만 이 프로젝트에 참여하고 싶을지 아닐지는 직접 정해야합니다. 당신은 CEO 역할을 하고 있지요? 그렇다면 경제적인지 판단해야하고, 일단 판단했다면 그렇다고 보아야합니다. 그러니 무엇이 가장 중요한 자원인지 신중하게 생각해야합니다. 시장의 수요보다 더 많은 자원을 가지고 있나요? 적게 가지고 있나요? 당신이 가진 자원보다 더 많은 기회가 있나요 더 적은 기회가 있나요? 무엇이 적절한 투자 대비 이득인지 생각해야합니다. 단지 비용만이 아니라, 기회 비용도요. 우리는 매번 그 관점에서 바라봅니다.

질문 : 엔비디아에서 만드려고 한 문화에 대해서 말해주실 수 있나요?

젠슨황 : 좋은 질문입니다. 질문은 우리가 엔비디아에서 만드려고 한 문화였죠? 엔비디아의 성공의 핵심은 혁신입니다. 많은 회사는 혁신이 중요하다고 말하고, 발명이 중요하다고 말합니다. 하지만 저는 위험을 감수하는 문화가 있지 않은 한, 혁신을 장려하는 문화를 가지고 있다고 생각하지 않습니다.

엔지니어를 이끌고 격려하고, 마케팅 팀이나 우리의 모든 직원들이 계산된 위험을 감수할 수 있게 해야합니다. 계산된 위험을 감수할 수 있게 하려면, 무엇보다도 어떻게 하는지 가르쳐야합니다. 계산된 위험을 감수하는 건 스킬입니다. 스킬의 문제죠. 2번째 부분은 용기의 문제입니다. 대부분 사람들은 실패하는 걸 죽도록 싫어합니다. 여러분도 동의하시죠?

성공하고 싶다면 실패에 대한 내성을 키워야합니다. 실패에 대한 내성이란, 낮 12시까지 자고, 숙제를 하나도 안 하고, 모든 수업을 빼먹는 걸 말하진 않습니다. 제가 말한 건 정확히 계산하는게 불가능한 일이더라도, 직감을 따라보라는 의미입니다. 그게 성공으로 이끌 수도 있으니까요. 창업자나 많은 직원들의 직감을 따르지 않았다면, 엔비디아가 여기에 있지도 않았고 세상에 존재하지 않았던 것을 만들지도 않았습니다. 그러니 위험에 대한 내성이 있는 문화를 만들어야합니다. 허나 너무 자주 실패하게 된다면, 당신은 실패 자체가 될 수도 있습니다. 이건 성공하는 것과는 다릅니다. 문제는 빠르게 실패하지만, 막다른 골목에 도달했을때를 알자마자 방향을 바꾸는 법을 어떻게 가르치냐 입니다. 이렇게 하는 방법을 우리는 지적 정직함( intellectual honesty)라고 부릅니다. 우린 무엇이 합당한지 합당하지 않은지 지속적으로 확인합니다. 만약 잘못된 결정이라면 생각을 바꿉니다. 많은 사람들이 말하길 CEO는 항상 옳고, 생각을 바꾸지 않는다고 합니다. 이건 적어도 저에게는 해당하지 않는 일입니다, 특히 우리 회사가 나아가려는 방향에서 벗어날때는 말이죠.

혁신적인 회사는 놀라운 것을 만들어내고, 세상이 있는 줄도 몰랐던 문제를 해결합니다. 혁신적인 일을 하고 싶다면, 위험을 감수하는 문화를 만들고, 적은 비용으로 빠르게 실패하는 법을 가르쳐야합니다. 직설적으로 이게 잘못된 방향인지, 무엇이 더 나은 방향인지 말할 수 있어야하고, 방향을 빠르게 바꿀 수 있을만큼 유연해야 합니다.

이런 문화는 오늘날 인터넷 기반 회사에서는 필수적입니다. 오늘날 회사는 전세계의 회사들과 경쟁하고 24시간 7일간 경쟁합니다. 위험을 감수하고, 시장에 따라 생각을 바꿀 수 있지 않을만큼 유연해야만 살아남을 수 있습니다. 방금 저는 오래된 회사와 새로 생긴 회사의 속성을 이야기 했습니다. 현대의 회사는, 구글을 예로 들면, 언제나 '베타버전'입니다. 구글은 온갖것을 실험합니다. 만약 구글이 완성된 제품이라고 말하면, 사람들은 화를 낼 것입니다. 그래서 구글은 이를 '베타'라고 부릅니다. '베타'라고 부르기에 온갖 것을 하고, 실패하면 빼버립니다. 좋지 않아도 빼버리죠. 효과가 있으면 더 합니다. 이렇듯 혁신은 약간의 실험이 필요합니다. 실험은 탐험을 필요로 하죠. 탐험은 실패로 끝나기도 하는데, 실패에 대한 내성이 없다면 절대로 실험을 하지 못합니다. 실험을 하지 못하면 절대 혁신을 할 수 없습니다. 혁신이 없다면 성공할 수 없고, 지루한 사람이 되겠지요. 이게 혁신입니다. 다른 질문 있나요?

질문자 : 어떻게 창업자나 초기 팀을 정했나요?

젠슨황: 완전히 믿는 사람이 아닌 이상 같이 사업을 하지 마세요. 저의 공동 창업자 둘은 가장 가까운 동료들이었고, 저는 그들을 완전히 신뢰했습니다. 오늘날에도 가장 좋은 친구들이기도 합니다.

CEO로서 99%의 일은 사람을 선택하는 일입니다. 어떤 애플리케이션이 범용 컴퓨팅의 수요를 이끌까요? 이건 산업의 다음 단계에 관한 것입니다. GPU 컴퓨팅에서 우리는 무엇을 보고 있을까요? GPU 컴퓨팅은 GPU를 단지 그래픽에만 쓰는 게 아닙니다. 그래픽을 처리하는 방법 중에는 컴퓨터 그래픽 연산이라는 방법이 있습니다. 이미지를 만들기 위해 프로그램을 사용하죠. 알고리즘은 더이상 실리콘 칩에 있지 않습니다. 알고리즘은 실제로는 소프트웨어입니다.

알고리즘은 엠비언트 오클루젼(ambient occlusion), 레이 트레이싱 (ray tracing), 사람들이 훗날 탐험할 모든 종류의 흥미로운 것일 수도 있습니다. 우리가 지포스FX를 만들었을때, 지포스는 그래픽처리에 있어 성공적인 GPU는 아니었습니다. 하지만 전세계의 연구자들은 GPU에 CG(C for graphics)라고 불리는 프로그래밍 언어가 있다는 걸 알아차렸죠. CG를 이용하면 GPU에 그래픽 처리말고 다른 것을 하게 할 수 있었습니다. 또 32비트 부동소숫점을 가지고 있었죠. 몇몇 똑똑한 연구자들, 많은 이들이 여기 스탠포드에 있는데, 그래픽 카드를 사서 프로그램을 작성하기 시작했습니다. 그리고 이 연구자들은 정말 열심히 일했고, 온갖 알고리즘 기술을 썼고, 20배나 빠르게 프로그램을 돌릴 수 있게 되었습니다. 어떻게 프로그램을 20배나 빠르게 할 수 있을까요?

(주 - 엠비언트 오클루젼은 한 장면의 각 점이 앰비언트 라이팅(광원)에 얼마나 노출되어 있는지를 계산하기 위해 사용되는 셰이딩 및 렌더링 기법이다.)

(주 - 레이 트레이싱은 광선을 추적하는 알고리즘이다. 빛이 물체나 표면에 닿을 때 해당 물체나 표면, 또는 다른 광선의 표면과 상호 작용하는 방식이 알고리즘으로 계산된다.)

우리는 흥미로운 관찰을 했는데, 우리는 3D 애플리케션을 빠르게 했는데 기본적으로 소프트웨어를 통한 것이었고, CPU를 쓰는 것보다 수천배는 빠른 것이었습니다. 만약 우리가 GPU에 있는 모든 병렬 프로세서를 프로그래밍 가능하게 하면 어떤 일이 일어날까요? C언어를 통해서요. 일단 C이고 훗날에는 C++이 될 수도 있죠. 이렇게 빠른 속도로 얼마나 많은 종류의 문제를 풀 수 있는지 상상해보세요. 날씨를 예측하거나, 지반을 분석하거나, CT 스캔을 해서 사람의 모습을 재구성할 수도 있습니다. 모든 종류의 계산 중심의 애플리케이션을 50배나 100배 빠르게 할 수 있습니다. 이제 우리의 관점을 놓고 보자면, 100배는 무어의 법칙에서는 10년입니다. 10년 어치의 컴퓨팅 자원을 과학자, 연구자, 엔지니어의 손에 쥐어 준다면 어떻게 될까요. 믿을 수 없는만큼 대단한 가치를 가져올 것입니다.

GPU를 좀 더 범용 컴퓨팅을 할 수 있게 만드는 건, 대단히 위험합니다. 매번 어떤 것을 특수한 분야가 아니라, 일반 목적으로 만들때마다 핵심 비즈니스에서 벗어나기 때문입니다. 스위스 만능칼과 같죠. 아주 좁은 시장(니치, niche) 에 집중하는게 보통은 낫습니다. 여러분이 마케팅 수업에서 마켓 세분화에 대해서 배우듯이 말이죠. 일반적인 것을 만들수록, 모든 사람을 위한 제품이 됩니다. 모든 것을 적당히 할 줄 알지만, 잘하는 건 하나도 없는 것과 같습니다. 범용 컴퓨팅을 만드는 건 대단히 대단히 위험한 행동입니다. 하지만 좀 더 GPU를 일반적으로 쓸 수 있게 만드는 건, 너무나도 중요해서 하지 않을 수 없었습니다. 우리는 하기로 결정했습니다. 이건 놀라운 결과를 가져왔습니다. 우리가 보는 것들은 그 결정들의 일부입니다.

(주 - GPU가 프로그래밍하게 되면서 인공지능에 쓰일 수 있게 됨. 이는 엔비디아의 새로운 성장을 이끔)

아까 공동 창업자에 대한 질문에 답하자면, 우리 셋은 처음부터 친구였습니다. 지금도 친구죠. 어떻게 누가 적절한 자리에 있고, 어떻게 이윤을 나눌까요? 저는 농담은 하지 않겠습니다, 그래야 잘못 이해되지 않으니까요. 우리 창업자 셋의 월급은 동일했습니다. 엔비디아의 지분도 동일하게 가지고 시작했죠. 간단히 말해 공평함이었죠. 이제 문제는 지배구조였습니다. 지분은 공평함을 말하는 다른 말입니다. 우리는 동일한 급여를 받았습니다. 우리 셋은 모두 100,000달러를 매년 받았습니다. 우리는 회사의 동일한 부분을 가지고 있었죠. 그렇지만 이렇게 해서는 회사를 운영하고, 위대한 회사를 만들 수가 없었죠. 세 사람이 같은 비율로, 같은 책임으로 투표할 경우에는 불가능합니다. 이건 리더십의 문제가 되고, 경영의 문제가 되고, 위대한 회사를 만드는 것의 문제가 됩니다. 제는 정확한 대화를 기억하지는 않습니다. 아마도 이렇게 대화가 흘러갔습니다. '좋아, 젠슨 너가 CEO지?' 그렇게 결정되었죠. 이게 기본적인 과정이었습니다.

저는 특별히 성격적으로 외향적이지는 않습니다. 외향적인게 좋은 CEO의 필수조건은 아닙니다. 성격적으로, 저는 어떤 문제가 일어나기 전에 예상을 하는 편이었습니다. 그래야만 한다면요. 저는 흐릿하고 모호한 부분들을 볼 수 있었습니다. CEO들과 리더들은 모호함과 함께 하는데 편해야합니다. 모호함은 다른 말로, 미래는 앞으로 어떨까 보는 것입니다. 이는 말하기 어렵고 어떤 사람들은 하기 싫어합니다. 몇몇 사람은 말합니다. '젠슨, 그때까지 그 일을 하려면 얼마나 많은 자원이 있어야합니까?' 몇몇은 또 말하죠. '저기 기회가 있어요. 무엇인지는 얼마나 클지 확실하지 않지만요. 같이 가서 알아내고 비즈니스를 만들어가봐요.' 어떤 사람은 이런것에 매우 편안해 합니다.

모호함을 편안해 하는 건 중요합니다. 아주 성공한 CEO들은 모두 모호함을 편하게 다룬다고 생각합니다. 저 역시도 모호함을 편하게 여깁니다.

질문자 : 얼마나 초기 투자를 직접 했습니까? 나머지 투자금은 어떻게 얻었나요? 몇번이나 투자를 받기 위해 제안을 했나요?

젠슨황 : 저는 30살이었고, 단 1개의 비즈니스 관련 수업을 듣지 않았습니다. 마케팅 수업도 하나도 듣지 않았죠. 파워포인트도 써보지 않았죠. 그때는 '맥북'을 썼는데 맥에서 파워포인트는 '퍼슈에이젼' (Persuasion, 설득) 이라고 불렸습니다. 저는 '퍼슈에이젼'을 쓰기 위해 맥을 샀죠. 저는 회사 소개 프레젠이션을 만들어서, 벤처 투자자들에게 보여주려고 했습니다. 저의 공식적인 첫 업무일은 2월 17일, 제 30번째 생일이었죠. 우리는 자금을 받았습니다.

일단 시작하고 나면, 질문은 '무엇을 할것이냐'가 되죠. 어떻게 모든 것을 할까? 어떻게 회사를 시작할까? 우리 셋은 매일 만났습니다. 프레몬트(Fremont, 캘리포니아의 도시)에 있는 창업자 중 1명의 집에서였죠. 우리는 매일 모였고, 달리 할 일이 없었죠. 무엇을 했을까요? 3명이 모여서 그냥 이야기를 했습니다. 어젯밤에는 무얼했니? 어제 저녁에는 무얼 먹었어? 이걸 6개월 동안 했습니다. 매일 가장 중요한 일은 '어디로 점심 먹으러갈까' 였죠. 필라델피아 치즈스테이크는 오늘이고, 중국 음식은 내일이나 다른날로 하자. 이건 큰 일이었죠. 한동안은 이랬죠. '아침에 냉장고에 도넛 좀 넣어둘 수 있을까?' 이건 몇달동안 계속되었습니다.

이게 부적절한건 알지만 실제로 그랬습니다. 왜냐하면 당시 저는 회사를 어떻게 시작하는가에 관한 책을 읽고 있었거든요. 저는 어떻게 하면 투자금을 모으고, 벤처 투자자는 무엇이고, 회사 설립은 어떻게 하는가와 같은 것이었죠. 곧 저는 변호사를 만났고, 쿨리 갓워드(Cooley Godward)라는 로펌에 갔습니다. 이들은 회사를 설립하는 걸 도왔습니다. 변호사가 말하길, 돈이 좀 있어야 회사의 가치를 정하고 회사를 설립할 수 있다더군요.

변호사가 묻더군요. '주머니에 얼마나 돈이 있나요?'

저는 대답했죠. '200달러 있는데요.'

변호사가 답했습니다. '좋아요. 200달러를 제게 주세요.'

그래서 저는 200달러를 그에게 주었습니다.

200달러로 저는 15%를 샀죠, 생각해보니 엔비디아의 20%였네요.

아주 좋은 거래였죠. 20%요.

저는 집으로 돌아가 다른 2명에게 말했더니, 둘 다 200달러를 줬고, 둘 다 20%의 지분을 가졌습니다. 이게 우리가 했던 방식입니다. 문자 그대로요. 더 특별할 것도 없었죠. 저는 사업 계획을 끝내지 않았습니다. 우리 셋은 사업 계획을 다 마무리 짓지 못했죠. 솔직히 말해 어떻게 사업 계획을 마무리 짓는지 알아내지 못했습니다.

저는 보더스(서점이름)에 가서 고든 벨의 책을 샀습니다. '어떻게 고급 기술 회사를 시작하는가' (How to Start a High Tech Company)란 책이었죠. 한 손으로 못 잡을만큼 두꺼운 책이었습니다. 이 책을 다 읽어야했다면 저는 지금쯤 죽어있을 겁니다. 우리는 돈이 다 떨어졌고, 시간도 다 떨어졌겠죠.

저는 단지 앞의 3,4 챕터를 읽고 일하러 갔습니다. 이렇게 회사를 설립했죠. 그들은 2명의 벤처 투자자들에게 우리를 소개해 주었습니다. 저는 투자자들의 사무실에 가서 제가 무얼 하려고 하는지 말했습니다. 회사에 투자를 받으려는 사람들은 몇가지를 기억하세요. 벤처 투자자들은 사업 계획에 투자하지 않습니다. 사업 계획서는 쓰기 쉽거든요. 저는 사업 계획서를 쓰지도 못했지만, 다른 사람들은 쓸 수 있었죠. 벤처 투자자들은 이것에 투자합니다. 뛰어난 사람들에게 투자하죠. 문제는 투자자들이 당신을 어떻게 믿느냐 입니다.

평판은 중요합니다. 당신이 살아온 역사도 중요하죠. 저는 앤디 벡톨샤임 (투자자)와 많은 일을 했었고, 시놉시스(실리콘 칩 디자인 도구를 만드는 회사)와 LSI 로직(반도체 제조 회사)의 창업자들과도 일했었습니다. 이들과의 일은 성공적이었죠. 당신의 평판은 당신을 앞질러 갑니다. 사업 계획서를 쓰는 스킬이 별로라고 해도 말이죠.

2번째는 투자할만큼 충분히 큰 비전이 있어야 한다는 것입니다. 통계에 따르면 스타트업의 성공 가능성은 낮습니다. 1000만 달러를 투자하는데, 시장의 크기가 겨우 2000만이라면, 투자자들은 충분한 양의 돈을 돌려받지 못합니다. 하지만 2000억 달러 크기의 시장이면 조금 다릅니다. 시장의 크기가 중요합니다. 그러니 투자자들은 알고 싶어합니다. 아직 시장을 발견하진 못했지만 충분히 시장이 큰 아이디어가 있는가.

마지막 부분은 이것입니다. 마지막으로 말한 이유는 엄청나게 중요하기 때문입니다. 시간이 흐름에 따라 계속 자기자신을 다시금 혁신해야 합니다. 자신을 다시 혁신하고 싶다면, 뛰어난 사람들이 필요합니다. 이게 뛰어난 사람들이 중요한 이유입니다.

질문자 : 누가 회사를 시작할때 당신의 멘토였나요? 멘토들로부터 어떤 조언을 받았나요?

젠슨황 : 질문은 누가 멘토이고, 받은 조언 중 어떤 게 최고였나죠? 저는 성공하려면 누구로부터든 배울 수 있어야한다고 진정으로 믿습니다. 저는 그랬습니다. 저는 누구로부터도 배웠습니다. 이건 매우 작은 걸 수도 있지만, 큰 것일수도 있습니다. 제 아이들이 아니었다면 저는 모든 인터넷 시대를 놓쳤을 겁니다. 유튜브를 놓치고, 페이스북도 놓치고 트워터도 놓쳤겠죠.

세계가 변하고 있으니, 누구로부터든 배울 수 있어야합니다. 저는 대단히 재능 있는 임원들과 온갖 직업을 지닌 사람들로 둘러쌓여 있습니다. 누구로부터든 기꺼이 배우려 한다는 걸 확실히 해야합니다. 제가 여러해동안 받은 조언 중 대단히 가치 있는 것은 '집중'(focus) 입니다. 레이저 빔 같은 집중입니다. 너무 많은 걸 하려고 하지 마세요. 몇개를 잘하고, 그걸 매우 탁월한 수준으로 하세요. 집중은 중요합니다.

제가 평소에 시간을 어떻게 쓰는지 본다면, 저는 매일 아침 일어나서 가장 먼저 하는 건 '엔비디아'이고, 마지막에 하는 것도 '엔비디아'입니다. 하루 24시간 일주일 7일 동안이요. 제가 앞으로 이걸 50년 동안 더 하는 방법을 알아 낸다면, 엔비디아는 계속해서 좋은 회사가 될 겁니다.

질문자 : 성공한 기업가로서 시간을 어떻게 쓰나요? 미래의 당신과 가족에게 있어, 무엇이 가장 동기를 주고, 무엇이 가장 동기를 뺏나요?

젠슨황 : 그녀의 질문은 제가 성공한 기업가이고, 무엇이 가장 큰 도전인가이죠? 저는 모호함을 좋아한다는 점을 고려하면, 회사의 미래와 저 자신에게 최상의 예상은 무엇일까요? 회사를 만들때 가장 큰 도전은 회사를 다시금 혁신해 내는 것입니다. 회사의 재창조이죠. 모든 성공적인 사업은 어떤 시점에서 무너지게 되어 있고, 새로 지어져야합니다. 불행한 일이지만, 이게 진실이죠.

발명을 하는 과정은 종종 혼란스럽습니다. 실은 파괴적이기까지 하죠. 과거에 당신이 만들었던 걸 부수기도 합니다. 이렇기에 재창조 과정은 매우 힘듭니다. 속이 울렁거리는 일이죠. 저는 재밌는 도전이라고 생각합니다. 저는 재창조의 과정을 사랑합니다. 회사에 대한 제 최선의 예측은 무엇일까요? 저는 엔비디아가 세상에서 가장 중요한 기술 회사가 될 기회가 있다고 봅니다. 그렇게 되기를 희망하죠. 제 최선의 예상은 80세가 되어서, 여기 학생들 앞에서 떠들고, 그때까지도 CEO이기를 바랍니다.

질문자 : (소리가 들리지 않음)

젠슨황 : 매우 날카로운 질문입니다. 우선 살아남아야합니다. 지출을 처리할 현금이 있어야죠. 현금이 왕이에요. 생존은 항상 중요하고 현금은 왕입니다. CEO로서 돈을 벌거나, 돈을 절약하거나, 투자금을 모아와야합니다. 돈을 벌지 않거나, 돈을 절약하지 않거나, 투자금을 모아오지 않는다면 당장 이 3개를 해야합니다. 이 3개에 항상 집중하고 있어야합니다.

회사 초반, 저는 항상 투자금을 모으고 다녔습니다. 한번 투자를 받고 나면, 다음 투자를 받아야했죠. 항상 투자금을 모으고 있었습니다. 가끔 1주일 정도 쉬는때는 있었습니다만, 저는 항상 투자금을 모으고 있었죠. 스타트업은 언제나 사업이 중단될 수 있는 상황입니다. 이게 스타트업의 정의지요. 거의 항상 적자 상태인 기업이 바로 스타트업의 정의입니다.

질문자 : 어떻게 리더 자리 승계를 준비하고 있나요?

젠슨황 : 질문은 제가 어떻게 CEO 자리 승계를 다루느냐였죠? 저는 80살까지 이 일을 하고 싶다고 말했지만, 그건 농담이었습니다. CEO의 핵심적인 역할 중 하나는 새로운 리더를 키워내는 것입니다. 그래서 이들이 새로운 아이디어를 찾아내고, 새로운 사업을 키워낼 수 이으니까요. 이들은 다른 세계의 다른 지역에 있을 수도 있고, 다른 프로덕트 라인을 운영할 수도 있습니다. 저는 요즘은 많은 시간을 관리자들과 앉아서 전략적으로 생각하고, 도전들에 대해 고민할 수 있게 돕고 있습니다. 관리자들이 프로덕트 로드맵을 깊이 생각할 수 있게 하고, 변화에 대해 깊이 생각할 수 있게 하고, 오래도록 지속될 팀과 조직을 만드는 것을 돕고 있습니다.

우리 창업자 3중에 1명을 다음 리더로 뽑는 것보다 다음 세대의 리더를 키우는 게 훨씬 더 나은 과정이라고 생각합니다. 제게 무슨 일이 일어나거나, 제가 더는 CEO로서 적절하지 않을때에요. 이사회는 많은 선택을 할 수 있습니다. 회사 밖에서 찾을 수도 있죠. 회사를 만들어 가는 과정에는 회사 승계를 생각하는 것도 포함되어 있다고 봅니다.

질문자 : 적절한 질문인지 모르겠는데요. 제 친구들은 엔지니어인데, 아주 훌륭한 아이디어를 많이 가지고 있습니다. 그런데 친구들은 그다지 이미 가진 돈에 만족을 해요. 그러니 더 일을 추진하려고 하지 않아요.

젠슨황 : 제가 질문을 다시 정리하도록 하죠. 친구들에게 많은 아이디어들이 있지만, 돈도 너무 많기에 굳이 그 아이디어로 무언가를 하려고 하지 않는다는 거네요. 우선 돈에 대해 말해보도록 하죠. 제가 당신의 질문에 답이 되었으면 하네요. 돈은 회사를 시작하지 말아야할 유일한 이유입니다. 왜냐하면 회사를 시작하는 건, 성공 확률이 매우 매우 매우 낮은 일이거든요. 당신이 큰 돈을 벌기 위해 회사를 세우고, 그게 이유라면 분명히 후회하게 될 테니까요.

당신은 아이디어를 믿기 때문에, 회사를 세우고 회사를 만들어가야 합니다. 아이디어에 큰 열정을 가지고 있고, 무언가 훌륭한 것을 만들고 싶기에 회사를 시작해야합니다. 돈이 따라오는 것이면 괜찮긴 하죠. 저는 돈이 아주 많습니다. 근데 그게 저에게 동기를 주지는 않죠, 동기를 빼앗지도 않구요. 그건 제가 돈 때문에 회사를 시작하지 않았기 때문입니다.

저는 스스로에게 묻기를 강하게 권합니다. 당신의 친구들에게도요. 회사를 시작하고 싶은 목적이 무엇인가요? 아이디어는 널리고 널렸습니다. 세상엔 아주 많은 아이디어가 있습니다. 이 강의실에서도 무수한 아이디어를 얻을 수 있어요. 아이디어는 정말로 중요한게 아닙니다. 당신만의 독특한 관점이 있어야합니다. 당신 스스로 그 관점에 대해 강하게 느끼고 있어야하죠. 그리고 어떤 도전이든 기꺼이 감당하고, 아이디어가 현실이 되게할 수 있어야합니다. 이게 회사를 시작하는 유일한 이유여야만 해요.

좋습니다. 모두들 감사합니다. 저는 이 시간을 즐겼습니다.

출처 - 스탠포드 기업가 정신 수업, Jensen Huang, Vision Matters ( https://ecorner.stanford.edu/podcasts/vision-matters/ )

오픈AI CEO인 샘알트만이 말하는 13가지 성공비법

에드 신 — Mon, 12 Jun 2023 17:35:14 +0900

샘알트만이 말하는 성공하는 13가지 방법입니다.

읽다보니 좋은 글이라서 개인적으로 읽을겸 정리해보았습니다.

IT분야에 적용되는 방법론이지만, 커리어에 관한 조언도 있습니다.

IT분야에서 일하고 있거나, 아직 커리어 초반인분들이 읽으면 많은 도움이 되겠더군요.

샘알트만이 어떻게 챗GPT를 성공시켰는지 궁금한 분은 글을 읽어보세요.

--------------------------------------------------------

어떻게해야 성공하는가 (How to be successful)

난 수천명의 창업자들을 보았고, 어떤게 커다란 성공을 만드는지 생각해왔다. 여기서 성공은 엄청난 돈이나 대단히 중요한 것을 만드는 걸 말한다. 보통 사람들은 앞의 것을 원하며 시작하지만 뒤의 것을 원하게 된다.

여기에 어떻게 하면 그런 예외적일만치 놀라운 성공을 만드는지에 관한 생각을 13가지로 정리해보았다. 모든 건 일정 기준의 성공을 (특권을 통해서든 노력을 통해서든) 달성하면 점점 더 쉬워진다. 그리곤 그 일정 수준의 성공을 예외적일만한 성공으로 바꾸고 싶어진다. 남다른 케이스로 보이지만 누구에게나 적용할 수 있다고 본다.

1.복리 효과를 믿어라 (Compound yourself)

복리는 마법과도 같다. 복리는 어디서나 볼 수 있다. 지수적인 증가는 부의 창출의 열쇠이다. 매년 50% 크는 중간 크기의 사업은 순식간에 커다랗게 된다. 매우 적은 수의 사업만이 진정한 네트워크 효과가 있으며 극도로 확장성이 있다. 하지만 기술과 함께라면 더 많은 사업이 이렇게 될 것이다. 강한 복리 효과가 있는 사업을 찾고 만들어 가는건 매우 큰 노력을 들일만한 일이다.

당신은 스스로를 지수적으로 발전시킬 수도 있다. 당신은 따를만한 가치가 있는 올바른 목적을 찾아야한다. 복리 효과가 있는 커리어를 택하는 게 중요하다. 대부분의 커리어는 선형적이다.

당신은 2년 동안 일하면 20년 동안 일한것과 비슷해지는 분야에서 일하고 싶지는 않을 것이다. 배우는 속도는 언제나 빨라야한다. 커리어가 발전하면서 당신이 일하는 1단위는 점차 더 많은 결과를 만들게 된다. 이런 종류의 레버리지를 활용하는데는 여러 방법이 있다. 레버리지에는 자본, 기술, 브랜드, 네트워크 효과 그리고 사람들을 다루는 것이 있다.

언제나 또다른 0을 너의 성공지표에 더하는 건 유용하다. 그 성공지표가 돈이든 지위든 세상에 영향을 주는 것이든 무엇이든 상관없다. 난 그 다음의 것(my next thing)을 찾는데 얼마든지 시간을 쓸 각오가 있다. 하지만 그 다음 것, 다음 프로젝트가 성공적이라면 나의 예전 커리어가 참고사항정도가 될정도인 프로젝트가 되기를 바란다.

대부분의 사람들은 선형적인 기회에 붙잡혀있다. 작은 기회들을 기꺼이 보내버리고, 더 커다란 기회들에 집중해야한다.

난 사업이든 개인의 커리어든 간에 가장 큰 경쟁력은 장기적으로 생각하는 것이라고 본다. 세상에 존재하는 다른 시스템이 어떻게 함께 동작하는지 넓은 관점에서 바라보라. 복리 효과의 눈에 띌정도로 놀라운 점은 앞으로의 몇년이 가장 중요하다는 점이다.

거의 대부분의 사람들이 진정으로 장기적으로 생각하지 않은 세상에서, 시장은 장기적으로 보는 사람에게 보상을 한다.

지수적인 증가를 믿고, 인내심을 가지고, 기꺼이 놀라워 하기 바란다.

2. 과할 정도로 자신을 믿어라 ( Have almost too much self-belief )

자신을 믿는 건 놀라울 정도로 강력하다. 내가 아는 가장 성공적인 사람들은 맛이간 수준일 정도로 자신을 믿었다.

자신을 믿는 걸 일찍부터 발전 시켜라. 당신의 판단이 좋다는 증거가 쌓이고, 계속해서 좋은 결과를 만들어낼 수 있다면, 당신 자신을 더 믿어라. 스스로를 믿지 못한다면 미래에 대해 일반적인 믿음과 반대되는 아이디어를 가지기 매우 어렵다. 허나 대부분의 가치가 만들어지는 곳은 대중과 다른 미래에 대한 생각이다.

난 몇년전 엘론 머스크가 스페이스 X의 공장을 견학시켜주었을 때를 기억한다. 엘론 머스크는 로켓을 만드는 아주 세부적인 과정을 말했는데, 1가지가 내 기억에 오랫동안 남아있었다. 엘론이 화성으로 커다란 로켓을 보내는 것에 대해 말할때 보여준, 확신에 가득찬 엘론의 표정이었다. 이 일은 나를 숙고하게 했다. "아, 이게 바로 신념이란게 무엇인지 보여주는 것이구나"

스스로의 사기를 관리하고, 팀의 사기또한 관리하라. 이는 수많은 노력 중에서 가장 어려운 것이기도 하다. 강한 자기 믿음 없이는 거의 불가능한 일이다. 불행하게도 당신이 더 야심적일수록, 세상은 당신을 더 부수러고 할 것이다.

가장 성공적인 사람들은 적어도 1번은 미래에 관해서 맞았다. 사람들이 그들이 틀렸다고 생각할때 말이다. 만약 그렇지 않았다면 이들은 엄청난 경쟁에 부딪혔을 것이다.

자기 확신은 객관적인 자기 인식과 균형을 잡아야 한다. 난 비판을 싫어했었고, 이를 일부러 피하기도 했다. 지금은 비판이 사실이라는 가정하에 들으려고 한다. 그리곤 비판을 다 들은 다음에 행동할지 안 할지 결정하려고 한다. 진실을 추구하는 건 어렵고 고통스러운 일이다. 하지만 비판을 받아들이는 게 자기 확신과 자기 망상을 구분짓는 점이다.

이 균형은 특권의식이 있는 사람으로 보여지거나, 무지하게 느껴지는 것으로부터 벗어나게 도와줄 것이다.

3. 스스로 생각하는 법을 배워라 (Learn to think independently)

기업가 정신은 가르치기 매우 어려운데, 독창적인 생각은 가르치기 아주 어렵기 때문이다. 학교는 기업가 정신을 가르치기 위해 세워지지 않았다. 사실은 기업가 정신과 반대되는 것에 보상한다. 이렇기에 기업가 정신을 스스로 키워야한다.

제 1원리로부터 생각하고, 아이디어를 생각해내라, 그리곤 사람들은 찾아서 생각을 주고 받고 발전 시켜라. 다음 단계는 이 아이디어를 현실 세계에서 시험해보는 빠른 방법을 찾는 것이다.

"무수히 실패하더라도 1번만 맞으면 된다" 이게 바로 기업가의 방식이다. 자기 자신에게 행운을 잡을 기회를 여러번 주어라.

내가 배운 가장 강력한 교훈은 아무런 답이 없는 것처럼 보이는 상황이여도 답을 찾을 수 있다는 것이다. 이 경험을 여러번 할 수록 자신을 더 믿게 될 것이다. '그릿'은 당신이 완전히 쓰러진 다음에도 다시 일어설 수 있다는 걸 배우는데서 온다.

(제1원리 - first principle, 모든 것의 밑바닥이 되는 원리를 말한다. 다른 것에 영향을 받지 않은 가장 밑바닥에 있는 원리를 말한다. 엘론 머스크가 말하며 유명해졌다. 엘론 머스크는 스페이스X를 시작할때 왜 우주선이 비싼가 의문이 들었다고 한다. 그래서 우주선을 만드는 아주 밑바닥까지 파고 들었고 처음부터 만들기 시작하면 비쌀 이유가 없다는 걸 꺠달았다고 한다.)

4. 세일즈에 능숙해져라 ( Get good at “sales”)

자기 확신만으로는 부족하다, 당신이 믿는 것을 다른 사람도 믿을 수 있도록 해야한다.

모든 탁월한 커리어는, 어느 정도는, 판매하는 일이 되었다. 당신의 계획을 고객들, 잠재적 고용인, 언론, 투자자 등에게 널리 알려야한다. 이렇게 하려면 영감을 주는 비전, 강력한 의사소통 기술, 어느 정도의 카리스마, 그리고 실행 능력에 대한 증거가 필요하다.

커뮤니케이션을 잘하게 되는것, 특히 글쓰기, 는 시간을 투자할만한 일이다. 커뮤니케이션에 대한 내 최선의 조언은 깔끔하고, 쉽고, 간결한 언어를 쓰라는 것이다.

판매에 능하게 되는 가장 좋은 방법은 파는 것을 진정으로 믿는 것이다. 진정으로 믿는 것을 파는 것은 끝내주는 느낌이고, 뱀기름을 팔려고 하는것 최악이다.

판매을 잘하게 되는 건 다른 기술을 향상시키는 것과 같다. 누구나 의도적인 연습을 하면 점점 더 잘하게 될 수 있다. 하지만 몇몇 이유때문에, 아마도 역겹게 느껴지기에, 많은 사람들은 판매일을 배우지 않는다.

내 다른 세일즈 팁은 어떤 일이 중요할때마다 직접 만나는 것이다. 내가 처음 시작할때는, 언제든 비행기를 타려고 했다. 직접적으로 만나는 게 대부분은 불 필요하기는 했지만, 내 커리어를 완전히 바꿀 3번의 순간으로 이끌었다. 직접 만나지 않았다면 얻지 못했을 변화의 순간이었다.

5.위험을 감수하기 쉽게 만들어라 ( Make it easy to take risks)

대부분의 사람들은 위험을 너무 크게 평가하고, 보상은 너무 낮게 평가한다. 위험을 감수하는 건 중요한데, 항상 정답일수는 없기 때문이다. 많은 것을 시도하고, 재빨리 적응하면서 더 많이 배울 수 있다.

보통은 커리어 초반에 위험을 감수하기 더 쉽다. 잃을 게 별로 없기 때문이고 얻을 건 많기 때문이다. 일단 기본적인 의무를 만족할 수준이 되면 위험을 감수하기 쉽게 만들어야한다. 작은 베팅을 찾아라. 잃었을때는 1x (1배)를 잃고, 얻었을때는 100x(100배)를 얻을 수 있는 베팅 말이다. 그리곤 그 방향으로 더 큰 베팅을 해라.

너무 오랫동안 돈을 모으기 위해 준비하지는 마라. YC(Y 콤비네이터)에서는 오랜시간 구글이나 페이스북에서 오래 일한 창업자들이 겪는 문제를 발견했다. 사람들이 안정적인 삶에 익숙해지고, 예측가능한 일, 어떤 일을 하든 성공한다는 평판을 얻게 되면, 이 모든 걸 뒤로 하고 떠나기가 매우 힘들어진다. 사람들은 자신의 라이프스타일을 내년 수입에 맞추는 놀라운 능력이 있다. 이들이 회사를 떠나더라도, 되돌아가려는 유혹은 엄청나게 크다. 단기적 이득과 편리함을 먼 훗날의 만족감과 성취보다 우선하는 건 인간의 본성이다.

만약 아직 트레드밀 위에 있지 않다면, 직감을 따르고 정말로 흥미로운 것에 시간을 쓸 수 있다. 가능한 적게 쓰고 유연성을 가지는건 이런 일을 할 수 있게 해주는 강력한 방법이다. 하지만 이는 트레이드 오프가 있는 일이다.

(트레드밀 - 러닝머신을 말하며, 회사에서 반복적으로 일하며 살아가는 것을 말함. )

6. 초점 (Focus)

초점은 일을 몇 배로 증폭시킨다.

내가 만난 대부분의 뛰어난 인물들은 더 오랜 시간 일하는 것보다 어디에 초점을 맞출까를 생각하는데 시간을 쓴다. 올바른 방향으로 일하는 게 많은 시간을 일하는 것보다 훨씬 더 중요하다. 대부분의 사람들은 별로 중요하지 않은데 시간을 쓴다.

일단 어떤 것을 해야할지 알아낸 뒤에는 해결해야할 우선 순위가 높은 것들을 빠르게 끝내라. 나는 문제 해결에 뛰어난 데 느리게 움직이는 사람을 아직 만나본 적이 없다.

7. 열심히 일하라 (Work Hard)

열심히 일하거나, 똑똑하게 일하면 상위 10퍼센트 안에 들 수 있다. 이는 대단한 성취이기는 하다. 하지만 상위 1퍼센트에 들어가려면 열심히와 똑똑함 둘 다가 필요하다. 당신은 타고난 재능이 있는 이들과 경쟁하게 될 것이다. 탁월한 아이디어가 있으면서 많이 일하려는 이들 말이다.

극단적인 사람들은 극단적인 결과를 얻는다. 많이 일하는 건 인생에 있어 커다란 트레이드 오프가 있고, 많이 일하지 않기로 결정하는 건 대단히 합리적인 일이다. 하지만 많이 일하는 건 큰 이점이 있다. 대부분의 경우에, 모멘텀은 점차 불어나고, 성공은 성공을 부른다.

그리고 많이 일하는 건 종종 즐거운 일이다. 인생에서 가장 즐거운 일 중 하나는 삶의 목적을 찾는 것이고, 그것을 잘하게 되고, 하는 일이 임팩트를 준다는 걸 발견하는 것이다. 한 YC 창업자는 대기업을 관두고, 얼마나 행복하고, 보람찬지 알고 놀라워했다. 그는 그가 줄 수 있는 최대치의 임팩트를 주기 위해 일하는 중이었다. 이런 식으로 많이 일하는 건 축하받을 일이다.

내겐 왜 많이 일하는 게, 미국의 어떤 곳에서는 나쁜 일로 취급받는지 이해가 되지 않을때가 있다.

당신은 번아웃을 피하며 열심히 일하는 법을 알아내야한다. 사람들은 자신만의 전략을 찾아내곤 한다. 대부분의 경우는 오랜시간 같이 일해도 즐거운 사람들과 일을 하는 게 이 방법 중 하나이다. 난 열심히 일하지 않고 성공한 척 하는 이들이 매우 해롭다고 생각한다. 사실 일을 하는 체력이 장기간의 성공을 보여주는 가장 강력한 예측 지표라고 본다.

열심히 일하는 것에 대한 1가지 생각을 더 말하자면, 커리어 초기에 하라는 것이다. 열심히 일하는 것은 복리 효과가 있어서 더 빨리 시작할 수록, 더 오랜시간 이득을 본다. 또한 책임이 적을때 열심히 일하는 게 더 쉽다.

8.대담해 져라 ( Be bold)

난 어려운 스타트업을 하는게, 쉬운 스타트업을 하는 것보다 쉽다고 믿는다. 사람들은 놀라운 것의 일부가 되고 싶어하고, 자신의 일이 의미가 있다고 느끼기를 바란다. 만약 중요한 문제에 있어 진전을 만들고 있다면, 언제나 당신을 도와주려는 지원군을 만나게 될 것이다. 좀 더 야심을 가지고, 정말로 전념하고 싶은 일에 몰두해라.

만약에 모든 사람이 '밈 회사'를 시작하고, 당신은 유전자 수정 회사를 만들고 싶다면, 유전자 회사를 시작하고 두번다시는 고민하지 마라. 호기심을 따라라. 당신을 설레게 하는 일은 종종 다른 사람도 설레게 한다.

(밈 회사 - 유행하는 트렌드를 따라 세우는 회사)

9. 의지를 밀고 나가라 ( Be willful)

큰 비밀은 당신이 세상을 변화시킬 수 있다는 점이고, 얼마나 자주 바꿀수 있는지 비율을 알게 되면 놀랄 것이다. 대부분의 사람들은 시도도 하지 않고 있는 그대로를 받아들인다. 사람들은 무언가를 만들어낼 대단한 잠재력이 있다. 자기 의심과 빠른 포기, 강하게 푸시하지 않기가 합쳐지면 대부분은 잠재력 근처에 가지도 못한다.

원하는 걸 요청해보라. 물론 대부분은 얻지 못할 것이고, 거절은 고통스럽다. 하지만 얻게 된다면, 놀랄정도로 잘 풀리게 된다.

"이 일을 끝낼때까지 계속할거야. 어떤 고난이 있더라도 난 방법을 알아낼거야" 라고 말하고 실제로 행하는 이들은 해낸다. 이들은 행운이 이들 곁을 지나갈때까지 오랫동안 있을만큼 인내심이 있다.

에어비앤비는 이에 대한 예시다. 에어비앤비는 자신들의 온갖 이야기를 말할 것이다. 1달러짜리 시리얼은 매끼니마다 먹었다거나 하는 이야기 말이다. 이들은 행운을 잡을때까지 결국 살아남았다. 의지를 강하게 가지려면, 낙관적이어야한다. 다행히도 이는 훈련을 통해 좋아질 수 있는 성격적 특징이다. 나는 비관적인데 아주 성공적인 사람을 만나본 적이 없다.

10. 경쟁하기 어렵도록 해라 ( Be hard to compete with)

대부분의 사람들은 다른 회사가 따라하기 어려운 회사가 더 가치 있다는 걸 안다. 이건 분명한 사실이다. 하지만 이건 회사에만 적용되는 게 아니다. 개개인에게도 적용된다. 당신이 할 수 있는 일이 다른 사람이 쉽게할 수 있는 것이라면 결국에는 적은 돈만 지불받게 된다.

다른 사람이 따라올 수 없게 하는 최고의 방법은 레버리지를 하는 것이다. 예컨데 아주 강력한 퍼스널 브랜딩을 하거나, 여러 분야에 능통하게 되거나 하는 것이다. 여기에는 여러 전략이 있지만, 스스로 방법을 찾아내야한다.

대부분의 사람들은 같이 어울리는 사람이 하는 일을 한다. 이런 모방하는 행동은 보통은 실수이다. 다른 사람들이랑 똑같은 일을 한다면, 따라잡기 쉬워진다.

11.네트워크를 만들어라 (Build a network)

탁월한 일은 팀을 필요로 한다. 재능 있는 사람들의 네트워크를 만들고, 긴밀하게나 느슨하게 일하는 건, 커리어에 있어 핵심이다. 진정으로 재능있는 사람들과 얼마나 네트워크를 가지고 있느냐는 종종 얼마나 달성할 수 있는가를 한정짓기도 한다.

네트워크를 만드는 가장 쉬운 방법은 다른 사람들을 최대한 도와주는 것이다. 매우 오랜기간 동안 이렇게 하면은 기회가 온다. 내 커리상 최고의 기회 3번은 내가 한 4번의 투자에서 온 것이다. 난 계속해서 놀라곤 한다. 얼마나 다른 사람을 도와준 일이 보답을 받는지. 나에게 일어난 좋은 일 중 몇은 내가 10년전에 한 창업자를 도와줬기에 일어났다.

또 다른 네트워크를 만드는 방법은 같이 일하는 사람을 정말 신경 쓴다는 평판을 쌓는 것이다. 얻는 이득을 배푸는 데 있어서 과할 정도로 관대해져라. 이는 10배로 돌아올 것이다. 또한 다른 사람이 뛰어난 것이 무엇인지 아는 법도 배우고, 이들은 그 일에 배치해라. (이는 내가 경영에 대해 배운 가장 중요한 것이고, 그다지 읽어보지 못한 것이기도 하다.) 당신은 다른 사람의 한계를 끌어내지만 번아웃 시키지는 않는다는 평판을 얻는 것도 원할 것이다.

모든 사람은 적어도 무언가에 있어 다른 사람들보다 낫다. 강점이 무엇인지 파악하고, 단점은 신경 쓰지 마라. 약점을 인정하고 어떻게 대응할지를 알아내라. 하지만 약점이 당신을 막아서도록 하지는 마라. "난 X를 잘하지 않으니 Y도 못해" 라는 말을 많은 사업가들로부터 놀랄정도로 자주 들어왔다. 이는 거의 항상 창의성의 부족을 보여준다. 약점을 메꾸는 최고의 방법은 보완할 수 있는 사람들 팀멤버로 데려오는 것이다. 당신이 이미 잘하는 것을 잘하는 사람을 채용하는 것이 아니다.

특히 네트워크를 만드는 데 있어서 가치 있는 부분은 몰랐던 재능을 발견하는 일이다. 빠르게 다른 사람의 지적능력, 동기, 창의성을 발견하는 일은 숙련될 수록 점점 쉬워진다. 가장 빠르게 이를 익히는 방법은 그냥 많은 사람을 만나는 것이고, 누가 깊은 인상을 주는지, 누가 그렇지 않은지 쭉 기록하는 것이다. 성장하는 속도를 봐야한다는 걸 기억하고, 현재의 수준이나 과거의 성취를 너무 높게 평가하지 마라.

난 누군가를 만날때마다 내 스스로에게 묻고는 한다. "이 사람이 '자연현상'인가". 이는 훌륭한 것을 만들어낼 수 있는 사람을 찾아내는 데 있어 대단히 유용한 직관이다.

(자연현상 - 원문에는 force of nature로 되어 있는데 자연적으로 발생하는 강한 힘, 현상을 말한다. 대단히 강하거나 독특한 성격의 사람을 말한다.)

네트워크를 만드는 특이 케이스 중 하나는 당신에게 베팅할정도로 눈에 띄는 사람을 만나는 것이다. 커리어 초반에 만나는 게 이상적이다. 이렇게 하는 최선의 방법은, 놀랍지 않게도, 다른 사람에게 도움을 주는 것이다. 먼저 베풀어야지 나중에 돌아온다는 걸 기억하기 바란다.

마지막으로, 긍정적이고 당신의 꿈을 도와줄 사람과 시간을 보내도록 하라.

12.무언가를 소유해야 부를 얻는다 ( You get rich by owning things)

난 어린 시절 많은 월급을 받아야 부자가 되는 줄 알았는데, 이는 나의 가장 커다란 경제에 관한 착각이었다. 연예인 같은 몇몇 예외는 있지만, 포브스 명단에 있는 그 누구도 월급을 받아서 부를 얻지는 않았다. 당신은 가치가 빠르게 증가하는 무언가를 소유해야지 부를 얻을 수 있다.

이건 사업의 일부일수도 있고, 부동산일수도 있고, 천연자원일수도 있고, 특허일수도 있고, 다른 비슷한 무언가일수도 있다. 어쩄든 시간을 파는 대신에 무언가의 일부를 소유할 필요가 있다. 시간은 선형적으로 증가한다.

(선형적으로 - 갑자기 안 커지고 1,2,3,4,5처럼 순서대로 늘어남. )

가치가 대단히 빠르게 커지는 무언가를 만드는 최고의 방법은 매우 많은 사람들이 원하는 걸 만드는 것이다.

13. 내적으로 동기부여가 되라 ( Be internally driven)

대부분의 사람들은 외적으로 동기부여 되어 있다. 사람들은 다른 사람을 감명시키기 위해 무언가를 한다. 이는 많은 이유에서 나쁜데, 그 중 2가지가 제일 큰 이유다.

(외적 동기 - 평판, 돈, 지위 등 외부로부터 오는 동기)

(내적 동기 - 흥미, 목적 등 내부로부터 오는 동기)

첫째, 모든 사람들이 동의하고 모든 사람이 추구하는 커리어를 따라가게 된다. 또한 다른 사람의 시선을 매우 신경쓰게 된다. 이는 정말로 흥미진진한 일을 하는 것을 막는다. 비록 당신이 다른 사람을 따라 어떤 일을 해내더라도, 어쨌든 다른 이들이 결국은 했을 일이기에 큰 의미가 없다.

둘째, 위험 계산을 잘못하게 된다. 다른 사람을 따라가고, 경쟁에 뒤쳐지지 않는데 촛점을 맞추게 되기 때문이다. 심지어 단기간에도 그렇게 할 것이다.

영리한 사람들은 외적 동기를 따르는 위험에 쉽게 빠진다. 이에 주의하는 건 약간은 도움이 되지만, 다른 사람을 모방하는 함정에 빠지지 않으려면 매우 매우 노력해야한다.

내가 아는 가장 성공적인 사람들은 주로 내적 동기에 따른다. 그들은 자기 자신을 위해 일하고, 세상에 무언가를 만들어내고자 하는 충동이 있다. 원하는 걸 무엇이든 살 수 있을만큼 돈을 벌고, 원하는 사회적 지위를 얻은 뒤에도 , 내적 동기는 더 높은 수준의 성과를 만들어내는 유일한 힘이.

이게 바로 동기가 대단히 중요한 이유다. 난 사람들에게 동기가 무엇인지 맨먼저 물어본다. 그 사람을 알고자 할때면. 올바른 동기는 일정한 룰로 정의하기가 어렵지만, 그걸 보면 알게 될 것이다.

제시카 리빙스턴과 폴 그레이엄은 내가 본보기로 삼는 이들이다. YC는 처음 몇년동안 비웃음을 당하였고, 아무도 성공을 거둘거라고 생각하지 않았다. 하지만 제시카와 폴은 YC가 잘 돌아가기만 한다면 세상을 위해 좋을거라고 생각했다. 이들은 사람들을 돋는 걸 좋아했고, 이들의 새로운 모델 (YC가 스타트업을 키우는 방식)이 기존의 모델보다고 낫다고 믿었다.

(제시카 리빙스턴과 폴 그레이엄은 Y콤비네이터의 설립자이다)

결국 당신은 자신이 중요하게 생각하는 분야에서 일을 하게 될 것이며, 이를 통해 무엇이 당신에게 성공인지 정의하게 될 것이다. 더 빠르게 당신에게 중요한 방향으로 갈수록, 더 멀리갈 수 있다. 당신이 집착하지 않는 것에서 성공하기란 너무나 어렵기 때문이다.

-------

출처 (샘알트만 블로그 ) - https://blog.samaltman.com/how-to-be-successful

놀라운책, 프로그래머의 뇌를 읽고

에드 신 — Fri, 24 Jun 2022 14:22:01 +0900

모든 개발자가 읽어야할 책이 있을까?

개발 분야는 다채롭고, 개발자의 경력과 실력에 따라 필요한 책이 다르기에

'예'라고 말하기는 어렵다. 하지만 모든 개발자에게 권할 만한 책이 나왔다.

바로 '프로그래머의 뇌'이다.

뇌와 프로그래밍의 관계, 우리가 코딩을 하고 디버깅을 할때 두뇌에서 무슨 일이 일어나는지 적은 거의 유일한 책이다. 왜 어떤 코딩은 더 어렵고 어떤 코딩은 더 쉬운가와 같은 개발자가 항상 마주치는 의문을 이 책은 해소해준다.

책 내용 중 버릴 게 없어 전부 다 인용하고 싶을 정도지만 공간이 협소하니

책에 적힌 각종 과학적 사실, 코딩 테크닉 중 경험한 부분을 바탕으로 책을 읽은 후기를 적어보려고 한다.책에 설명된 뇌 관련 내용 중 중요한 것만 짧게 적어보겠다. 뒷내용을 이해하기 위해 필요하다.

0. 간단한 뇌 구조 설명

우리 뇌에는 크게 3가지 기억이 있다.

a.장기 기억(Long term memory, LTM )

b.단기 기억 (Short term memory, STM )

c.작업 기억 (Working memory )

'장기 기억'은 우리 두뇌 깊숙이 저장되어 있는 기억이다. 초등학교때 배웠던 것이나, 계속해서 반복적으로 배운 것들이 주로 장기기억에 저장이 된다.

'단기 기억'은 잠깐 기억할 필요가 있는 것을 말한다. 처음 듣는 전화번호나 처음 만나는 사람의 이름 같이 짧게 기억하는 정보가 단기 기억이다.

'작업 기억'은 어떠한 일을 하기 위해서 임시로 기억을 하는 것을 말한다. 뇌의 메모장이라고 보면 된다. 함수를 만들때 함수 이름을 기억하는 것 같은게 작업 기억이 하는 일이다.

'작업 기억'과 '단기 기억'은 헷갈릴 수 있다. 똑같이 숫자를 기억하는 상황을 떠올려보자. '단기기억'은 '010-123-4567' 처럼 단순히 전화번호를 기억하는 것이고, '작업기억'은 '456 + 23 - 85 + 1200'같은 숫자계산을 하기 위해 기억하는 걸 말한다.

전화번호를 기억할때는 숫자만 차례대로 기억하면 되지만, 숫자 계산을 할때는 앞의 숫자와 뒤의 숫자가 어떻게 변하는지를 다 기억하고 있어야한다.

한마디로 작업기억이 할일이 더 많은 셈이다. '단기기억'과 '작업기억'은 둘 다 잠시 기억한다는 공통점이 있는데 이에 반해 '장기 기억'은 자고 나서, 며칠이나 몇달 뒤에도 기억하는 걸 말한다.

우리가 어떤 문제를 해결할때는 3가지를 다 쓰게 되는데 보통 '장기 기억'을 먼저 확인하고 그 다음에 '단기 기억'을 본 뒤 필요할때 '작업 기억'을 활용하게 된다. '작업기억'을 쓰는 건 상당한 에너지가 필요하기 때문이다.

가장 중요한 기억이 어떻게 분류 되는지 알았으니 책에 나온 방법을 일부 적어보겠다. 책내용 요약과 경험담이 섞여있다.여기 적힌건 내용의 1/10도 안되니 꼭 책을 구해서 읽어보기를 바란다. 그럴만한 가치가 있다.

1.간단한 문법부터 외우며 수련하라

책에서는 상당수 개발자가 검색을 하면서 시간을 보낸다고 말한다. 이는 얼핏 보기에는 아무것도 아닌 것 같지만 상당히 비효율적이다.

검색하는 데 작게 나마 시간이 들뿐더러, 뇌의 작업기억에 부하를 주기 때문이다.

뇌가 쓸 수 있는 에너지는 한정적인데 장기 기억을 쓰는데는 별로 에너지가 안 들고

단기 기억은 적게 들고 작업 기억은 많이 든다.

작업 기억이 많이 필요한 일일수록, 두뇌가 다른 일을 하지 못한다. 문법이나 기초적인 기능을 머리에 담고 있느라 막상 중요한 문제를 해결하지 못하는 셈이다. 이렇기에 기본적인 문법이나 사용중인 프레임워크에서 자주 쓰는 기능은 외워버리는 게 좋다. 두뇌의 남는 에너지를 문제 풀이나 기능 개발에 쓸 수 있게 되기 때문이다.

원래 나는 개발 문법 정도는 다 외웠지만 특별히 프레임워크의 기능 같은 걸 외우지는 않았다. 그러나 코딩 과외를 하게 되면서 라이브 코딩을 2-3시간은 해야되었고, 어떤 질문이 나올지 몰라 문법과 프레임워크의 기능을 외워서 갔다. 그런데 이상하게도 수업을 하면 할수록, 원래 본업으로 돌아와 개발을 하는 시간이 단축되었고 디버깅이 잘 되었다. 추측건데 단기기억에 머물렀던 문법들이 장기기억으로 넘어가면서 두뇌가 더 편하게 코딩을 할 수 있게 되었던 걸로 보인다. 남을 가르치다보면은 실력이 는다고 하는데 이런 원리이기 때문인걸로 보인다.

2.두뇌는 개발툴의 온갖것을 다 참고해서 코드를 기억한다

두뇌는 코드를 기억할때 코드만 기억하지 않는다. 개발툴의 화면 구조나 색깔 등도 참고한다는 뜻이다.비주얼 스튜디오, 이클립스, XCode 같은 개발 툴을 쓰다보면 함수나 클래스, 폴더 등의 색이 다르다. 뇌는 이런 색, 구조도 같이 기억해두었다가 코드를 찾을때 활용한다. 장기기억이 작업의 환경까지도 기억하는 셈이다.

fun add() {

var age = 35;

}

위와 같은 함수가 있다면 'fun'과 'add'를 읽고 무슨 함수일거라고 추측하는 게 아니라 'fun'과 'add'의 색깔을 보고 추측한다는 소리다. 노란색이면 변수고, 파란색이면 함수구나라고 두뇌에서 미루어 짐작하는 것이다. 평소 쓰던 개발툴이 아니라 다른 개발툴로 넘어가면 생산성이 급감하는데는 단순히 단축키가 달라서만은 아닌 것이다. 또한 상당수 개발자가 '종이, 화이트 보드에 코딩'을 하면 실력이 확 줄어드는 이유를 알 수 있다. 평상시 코딩 참고했던 것들이 화이트보드에는 없기 때문이다. 아마도 장기기억에 색깔 같은 것도 들어있는게 아닐까.

실제로 개발툴을 바꾸면은 생산성이 떨어지는 경우가 많고, 개발툴의 테마를 바꾸면 이상하게 느려진듯한 느낌을 받곤 했는데 이때문인 걸로 보인다.

3. 새로운 개발자는 왜 느리게 개발할까? 개발자 끼리도 서로 알고 있는 것에 대한 착각과 오해가 많다.

새로 개발자가 팀에 합류하게 되면 기존의 코드에 대한 정보가 0인 상태이다. 반면 기존 개발자는 기존 코드를 대부분 파악하고 있다. 새로운 개발자가 아는 게 0이라면, 기존 개발자는 10,000정도 안다고 보면 된다. 새로운 개발자는 함수간의 연관 관계나 클래스는 어떤 식으로 구성되어 있는지, 어떤 식으로 개발을 해나갔는지를 모른다. 기능 추가 하는데도 상당히 오래걸린다. 새회사에서 1-2주는 코드 파악하느라 바쁘다. 기존 개발자는 어떤 함수가 어떻게 돌아가는지, 환경 세팅은 어떻게 하는지 알고 있기에 기능 추가하는데 오래 걸리지 않는다. 기존 개발자는 새로운 개발자가 버벅이는 모습을 보고 능력이 부족하다고 생각한다.

"나는 기능 추가하는데 3일이면 되는데, 새로운 친구는 2주나 걸리네, 실력이 없구만."

이는 일반적인 개발회사에서 벌어지는 일이다. 실제 개발 능력은 비슷할 수 있지만 새로 들어온 개발자는 작업해야될 코드에 대한 지식이 없다. 반면 기존 개발자는 변수 이름, 폴더 구조, 코드들이 어떻게 연결되어 있는지 등에 대한 지식이 장기 기억에 들어 있다. 지식 차이를 인식하지 못하기에 오해가 생기는 셈이다.

이런 오해를 줄이는 방법이 있다. 일반적으로 많이 쓰는 아키텍처를 사용해서 새로운 개발자가 학습하는데 걸리는 시간을 줄이면 된다. 디자인 패턴이나 일반적인 아키텍처를 쓰는 경우 코드 수정을 하는데 시간이 적게 들었다고 한다. 또 새로운 코드에 빨리 적응할 수 있게 코드 구조를 다룬 문서나 작업 기록을 공유할 필요가 있다. 일정 시간 기다리는 건 필수이다. 참고로 IT 선진국인 미국도 1/3 가량 회사가 '신규 개발자 적응 과정'이 없다고 한다. 우리나라에서는 더 적은수만이 적응과정이 있지 않을까. 이런 걸 보면 구글이 오픈소스를 많이 하는게 미리 구글 스타일 코드를 잘 아는 사람을 늘리기 위해서는 아닐까 하는 생각이 문득 든다.

4.함수, 클래스 이름 등을 보며 어떤 기능인지 추측을 한다.

못 보던 변수, 함수나 클래스를 보면 그 이름을 읽으며 얘가 어떤 기능이겠구나 예상을 한다.경험이 쌓이면 코드를 다 읽기 전에 일종의 '예측'을 하는 셈이다.

'예측'과 실제 기능이 일치한다면 빠르게 코드를 읽고 넘어갈 수 있지만 함수가 예측과 다른 일을 많이 하면은 할수록 문제가 생긴다. 예를 하나 들어 보자.

밑의 함수는 이메일이 제대로 되었는지 확인하는 함수이다.

fun isValidEmail() {

// 블라블라

}

'isValidEmail' 은 함수 내부를 보기 전에도 이메일을 검증하는 함수일거라고 대강 추측할 수 있다.그런데 추측과는 다르게 이메일을 수정하는 내용이 있다고 해보자. 이 경우에 이 함수에 문제가 있을거라고 생각하기도 어렵고 디버깅하는데 걸리는 시간도 오래 걸리게 된다. 이름을 잘 정하는 게 길게 보았을때 매우 중요한 일인 셈이다.

5.초기 프로젝트 세팅이 끝까지 간다.

윈도우즈를 개발할때 택했던 명명법은 '헝가리안 표기법'이었는데 이 방식은 한 논문에서 나온 것이었으나 막상 논문에 적힌 내용과는 조금 달랐다. 윈도우즈의 초기 개발진들이 논문의 일부를 잘못 이해했고, 찰즈 페졸즈가 쓴 '윈도우즈 프로그래밍'이 널리 팔리면서, 이 방식이널리 퍼지게 되었다.

이건 윈도우즈만의 문제가 아니라 어떤 프로젝트든 초반의 구조가 끝까지 영향을 미치는 경우가 대단히 많다고 한다. 일단 구조가 한번 잡히면 이를 바꾸기는 상당히 어렵고 새로 합류하는 개발자들은 큰 고민없이 기존의 구조나 명명법을 따르기 마련이다.

나중에 고치기 어렵다는 걸 감안하면 초반에 많은 공을 들이는게 낫다.

6.개발자 간에도 이름 짓는 방식이 아주아주 다양하다.

동일한 기능을 하는 함수를 설명하고 개발자들에게 이름 짓기를 했는데 30여건에서 단하나도 동일한 이름이 나오지 않았다.

초반에 프로젝트를 설계할때 '이름짓는법'(네이밍)을 개발자끼리 정해 놓는 게 꼭 필요하다.

개발자들에게 "매달 최대로 받을 수 있는 혜택"을 변수로 만들도록 했는데 10가지가 넘는 변수명이 나왔다.

max_benefit
max_benefit_per_month
max_benefit_num
max_monthly_benefit
benefits
benefits_per_month
max_num_of_benefit
benefit_max_num
max_number_of_benefit
max_benefit_amount
max_acc_benefit
max_allowed_benefit
montly_benefit_limit

이에 대한 해결책은 이름짓기에 대한 규칙을 정하는 것이다. 변수 이름이 비슷하면 동일한 이름틀을 사용한다는 의미다.

예를 들어 최대 이자 금액을 계산하는 변수에 "max_interest_amount"라는 이름을 주었다면, 최대와 관련된 변수는 "max_benefit_amount" , "max_cost_amount" 같은 식으로 짓는게 좋다. "interest_maximum"같은 식으로 이름을 지으면 두뇌의 장기기억에서 기존의 지식을 활용하기 어려워진다.

7. 코드 정렬도 중요하다.

코드 블록을 어떻게 만드는가에 따라서 코드를 파악하는 정도도 달라진다고 한다. 코드 블록은 탭은 얼마나 쓸지, 각종 열고 닫기는 어떤 시점에서 할지를 말한다.

익숙한 코드 블록으로 된 코드를 보면 더 빠르게 코드를 파악하지만, 익숙하지 않다면 파악하는데 오래 걸린다. 여럿이서 하는 프로젝트라면 코드 블록도 정해놓고 하는게 좋다.

C와 Java는 코드 블록이 미묘하게 다른데, 한쪽 언어를 주로 쓰다가 다른 언어를 쓰게 되면 주로 쓰던 언어의 스타일을 따라 가려는 경향이 있다. 한번 학습된 것을 잊기가 쉽지 않은 것이다.

마무리

한분야의 전문지식을 다룬 분야와 연결하기는 매우 어렵다. 그런데 저자는 이 놀라운 일을 해냈다. 뇌과학과 프로그래밍이라는 하나도 알기 어려운 것을 연결시킨 것이다. 덕분에 우리 두뇌가 근본적으로 어떻게 코딩을 하는가, 어떻게 두뇌를 잘 활용해서 코딩할 수 있을까를 근본적으로 알수 있게 되었다. 경력 있는 개발자라면 꼭 한번 읽어보기를 권한다. 뇌과학적 용어 (fMRI 같은것)이 나오기는 하는데 검색 하면서 읽을 가치가 있다.

인상깊은 구절

"생소한 코드를 처음 접하면 누구나 어느정도 혼란을 느끼기 마련이다. 이러한 혼란은 3가지로 나눌 수 있다. 첫째는 지식의 부족이다. 프로그래밍 언어나 알고리즘 혹은 업무 영역에 대한 지식이 없는 경우 혼란이 생길 수 있다. 둘째는 정보의 부족이다. 코드를 이해하기 위해 필요한 정보를 충분히 가지고 있지 못하는 경우다. 요즘은 코드가 다양한 라이브러리를 사용하기 때문에 코드를 잘 이해하기 위해서는 이들에 대한 정보를 많이 찾아봐야하고, 찾아보는 일을 하기 전에 무엇을 하고 있었는지도 기억해야한다. 셋째, 처리 능력의 부족이다. 코드를 따라가다보면 어떤 동작들이 수행되는지 알기 어려울 때가 있다. 코드가 너무 복잡해서 혼란이 생기는 경우이다."

"전문가는 초보자보다 코드를 더 잘 기억한다. 전문가는 청크(덩어리) 단위로 기억을 한다."

"심지어 다른 프로그래밍 언어를 잘 아는 뛰어난 프로그래머조차, 아직 장기기억(LTM, long term memory)에 저장되지 않은 익숙하지 않은 키워드, 구조, 도메인 개념을 기억하는데 어려움을 겪는다"

"프랑스어를 배울 수 있다면 파이썬도 배울 수 있다. "

"fMRI 스캔을 통해 작업 기억 공간과 언어 처리에 관련 있는 두뇌의 영역이 프로그래밍과 연관된다는 것을 살펴봤다. 이 사실은 작업 기억 공간 용량이 크고 언어 능력이 좋은 사람이 더 뛰어난 프로그래머가 된다는 것을 암시하는 것일까?"

"프랫의 연구팀이 발견한 사실이 어떤 프로그래머들에게는 놀라운 것일 수 있다. 계산 능력, 즉 수학적 능력을 적용해야 하는 지식과 기술은 프로그래밍 능력에 대한 예측력이 작았다. 실험 참여자들 사이에서 겨우 2의 분산(편차)이 나타났다. 언어 능력이 더 나은 예측요인으로 17% 분산이 나왔다. 이것은 흥미로운 결과다. 개발자들은 보통 수학 능력을 중요시하고, 필자가 아는 많은 프로그래머는 자신들이 언어에 소질이 없다고 말했기 때문이다. 세 가지 테스트 중에서 가장 뛰어난 예측력을 보인 요인은 작업 기억 공간 용량과 추론 능력이었다. 실험 참여자들 사이 분산이 34%였다." - p87

"학습률에 대한 측도는 언어 능력이 가장 큰 요인이었다. 학습률과 프로그래밍 능력은 서로 비례하는 상관관계를 보였다. 물론 이 연구에서 읽기 능력이 뛰어난 학생이 일반적으로 학습 성과가 좋고 반면에 읽기 능력이 부족한 학생은 빠르고 쉽게 학습하지 못한다는 사실이 근원적인 요인일 수 있다" - p87

힐트 Hilt 안드로이드에서 의존성 관리하기

에드 신 — Thu, 7 Apr 2022 21:56:25 +0900

힐트 Hilt - Android 모듈 정리

Hilt는 의존성을 추가하는 (dependency injection, di)는 라이브러리이다. ''의존''이란 한 클래스가 다른 클래스를 참고한다는 뜻인데, 개발을 하다보면 여러 클래스끼리 연결되는 경우가 흔하게 있다. 한 클래스가 준비되어야 다른 클래스도 쓸 수 있는 것이다.

2개 정도의 클래스면 손으로 클래스끼리 연결을 해 줄 수도 있지만, 클래스의 수가 3개, 4개가 넘어가고 여러곳에서 연결이 생기면 일일이 객체를 만드는 것도 번거로운 일이 된다.

이런 어려움을 해결하기 위해 라이브러리를 써서 의존성을 관리한다. 라이브러리를 쓰면 알아서 객체를 만들어준다고, 연결해야될 클래스끼리 연결해준다는 뜻이다. 힐트(Hilt)는 안드로이드에서 쉽게 의존성을 관리할 수 있게 해주는 라이브러리이다. 기존에 많이 쓰이던 대거(Dagger)를 기반으로 만들어졌는데 쓰기가 훨씬 편하다.

사실 대거는 학습 난이도도 꽤 있고, 쓰다보면 일을 줄이려다 더 복잡하게 일을 만들어버리는 경향이 있었는데 힐트는 대거에 비해 상당히 단순하다.

구글에서도 적극 힐트를 밀고 있으니 빨리 힐트를 학습해보도록 하자.

설정하기

힐트 라이브러리를 추가해줘야 힐트를 쓸 수 있다. 2군데에 추가하면 된다

build.gradle - 프로젝트의 그래들

buildscript {
    ext.hilt_version = '2.38.1'
    dependencies {
        classpath "com.google.dagger:hilt-android-gradle-plugin:$hilt_version"
    }
}

app/build.gradle - 앱의 그래들

apply plugin: 'kotlin-kapt'
apply plugin: 'dagger.hilt.android.plugin'


dependencies {
    implementation "com.google.dagger:hilt-android:$hilt_version"
    kapt "com.google.dagger:hilt-android-compiler:$hilt_version"
}

설정이 되었으면 힐트를 써보자.힐트를 사용하려면 힐트를 쓴다는 걸 알려줘야한다. 다들 알다시피 안드로이드의 시작점은 Application이다.

Application에 @HiltAndroidApp 이라고 적으면 힐트를 쓸 준비가 된다.

MainApplication.kt 파일

@HiltAndroidApp
class MainApplication: Application() {

}

MainApplication도 잊지말고 AndroidManifest에 추가해주자

AndroidManifest.xml 파일

<application

 android:name=".MainApplication"
 …. 
/>

이제 실행해보자. 잘 돌아가면 본격적으로 힐트를 적용해보겠다

일단 기본적인 액티비티를 만들어보고 설명을 해보겠다.

2개 파일을 만들건데 데이터를 담을 Store 클래스와 MainActivity 클래스이다.

힐트 적용전

Store.kt

const val TAG = "STORE"

class Store {

    fun open() {
        Log.i(TAG, "OPEN")
    }

    fun close() {
        Log.i(TAG, "CLOSE")
    }   
}

MainActivity.kt

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {

   lateinit var store: Store

   override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        store = Store() // 스토어 객체를 만듬
        store.opne()
   }
}

액티비티를 보면 못 보던 것이 있다. 바로 @AndroidEntryPoint 이다. @AndroidEntryPoint 는 액티비티나 프래그먼트 등에 붙여서 힐트가 쓰인다는 걸 알려준다.

현재까지는 액티비티(Activity), 프레그먼트(Fragment) , 뷰(View), 서비스(Service), 브로드캐스트(Broadcast)에 붙일 수 있다.

메인 액티비티에서 Store 클래스를 쓰려면 어떻게 해야할까? 보통때라면 미리 객체를 만들거나, onCreate 등 라이프 사이클에서 객체를 만들어 쓸 것이다.

지금은 Store 객체를 하나만 만들지만, Book 객체, Street 객체, Shop 객체 등 온갖 객체를 만들어야 된다고 상상해보자. 매우 번거로울 것이다.

힐트 적용하기

Store.kt

class Store @Inject constructor() {
    fun open() {
        Log.i(TAG, "OPEN")
    }

    fun close() {
        Log.i(TAG, "CLOSE")
    }
}

클래스 이름 뒤에 @Inject 를 적어주고 constructor() 를 적어주면은 된다. 여기서 @Inject 를 적으면 힐트가 이 클래스는 어딘가에서 쓰이겠구나를 알게 된다. 보통 코틀린에서 변수없는 생성자 (constructor)는 생략할 수 있는데 힐트를 쓸때는 꼭 constructor()를 써줘야한다

이제 액티비티에도 힐트를 적용해보자

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {

   @Inject lateinit var store: Store

   override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        store.opne()
   }
}

사용할 객체 앞에 @Inject 를 적어주면 힐트가 알아서 객체를 만들어준다.

여기서는 lateinit var store 앞에 @Inject 를 적어주자

이제 준비가 되었으니 앱을 실행해보자.

별 이상없이 로그가 찍히면 성공이다.

일반 클래스일 경우에는 이처럼 간단히 힐트를 적용할 수 있으나 인터페이스인 경우에는 조금 더 할 작업이 있다

인터페이스에 힐트 적용하기

가게 (Store)를 한종류만 열줄 알았는데, 옷가게 (Clothing Store)와 책방 (Book Store)도 열게 되었다. 옷가게와 책방은 비슷한점도 있기에 기존의 것을 재활용하고 싶다. 그래서 Store 클래스를 수정하고 ClothingStore와 BookStore 클래스를 만든다.

Store.kt

interface Store  {
    fun open()
    fun close()
}

인터페이스로 수정하였다.

ClothingStore.kt

class ClothingStore @Inject constructor() : Store {
    override fun open() {
        Log.i(TAG, "open clothing store")
    }

    override fun close() {
        Log.i(TAG, "close clothing store")
    }

}

Store 인터페이스를 구현하고 @Inject 를 적어준다

BookStore.kt

class BookStore @Inject constructor() : Store {
    override fun open() {
        Log.i(TAG, "open book store")
    }

    override fun close() {
        Log.i(TAG, "close book store")
    }

}

ClothingStore와 동일한 작업을 해준다

이제 액티비티로 가서 객체가 잘 만들어지는지 확인해보자

MainAcitivity.kt

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {

    @Inject lateinit var store: BookStore // 잘 만들어진다 

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        store.open() // 에러 없음 
    }
}

구현된 BookStore의 경우 객체가 잘 만들어진다. 힐트가 제대로 일을 한다.

반면 Store 인터페이스를 쓰려고 하면 빌드 단계에서부터 막힌다.

MainAcitivity.kt

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {

    @Inject lateinit var store: Store // 에러 발

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        store.open()
    }
}

힐트가 보았을때 Store가 BookStore인지, ClothingStore인지 구분할 수 없기에 에러가 생기는 것이다.

힐트가 이를 구분할 수 있게 하려면 '모듈'(Module)을 추가해주어야한다.

StoreModule.kt

@Module
@InstallIn(ActivityComponent::class) // 모듈이 사용되는 범위를 정한다 
abstract class StoreModule {

    @Binds // 연결한다. 인터페이스의 구현을 제공한다고 보아도 된 
    abstract fun BookStoreImpl(bookStore: BookStore): Store
}

여기서 @Module은 모듈로 사용한다는 의미이고, @InstallIn은 모듈이 어떤 범위에서 쓰이는가를 나타낸다. 범위에는 액티비티, 애플리케이션, 싱글턴 등 다양한 종류가 있으니 입맛에 맞게 골라쓰면 된다.

모듈을 추가했으면 다시 빌드를 해보자. 깔끔하게 빌드가 된다. 실행을 해도 잘된다. 힐트 정복이라고 말하고 끝내고 싶지만 문제가 남아 있다. 아직 Store가 BookStore인 ClothingStore인지 구분을 못하는 것이다. 난감하다. 기껏 인터페이스를 만든 의미가 없다.

다행히 퀄리파이어 (@Qualifier, 구분자) 추가하면 구분을 할 수 있게 된다.

StoreModule을 수정해주자.

StoreModule.kt

@Module
@InstallIn(ActivityComponent::class)
abstract class StoreModule {

    @BookStoreQualifier
    @Binds // @Binds 는 연결한다는 뜻 
    abstract fun BookStoreImpl(bookStore: BookStore): Store

    @ClothingStoreQualifier
    @Binds
    abstract fun ClothingStoreImpl(clothingStore: ClothingStore): Store
}



@Qualifier
annotation class BookStoreQualifier

@Qualifier
annotation class ClothingStoreQualifier

BookStoreQualifier와 ClothingStoreQualifier 라는 퀄리파이어를 만들었다.이 퀄리파이어를 각각의 다른 함수 BookStoreImpl와 ClothingStoreImpl에 붙여주면 이 표시(어노테이션)을 보고 어떤 인터페이스가 어떻게 구현되는지 힐트가 구분할 수 있게 된다.

이제 액티비티로 가보자.

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {


    @BookStoreQualifier // 퀄리파이어 사용 
    @Inject lateinit var bookStore: Store

    @ClothingStoreQualifier  // 퀄리파이어 사용 
    @Inject lateinit var clothingStore: Store

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        bookStore.open()
        clothingStore.open()
   }
}

위의 액티비티와는 코드가 좀 달라졌다. BookStore를 사용하고 싶을때는 BookStore를 구현한 퀄리파이어 @BookStoreQualifier 를 붙였고, ClothingStore를 사용하고 싶을때는 @ClothingStoreQualifier를 붙였다.

실행을 해보면 BookStore와 ClothingStore가 잘 구분이 되는 걸 알 수 있다. 각기 다른 로그가 나오면 성공이다.

직접 만든 클래스와 인터페이스를 연결하는 법을 알아보았다.

외부 라이브러리를 쓸때는 어떻게 해야할까? Retrofit이나 OkHttp 등등을 사용할때는 어떻게 해야할까

외부 라이브러리 모듈로 만들기

외부 라이브러리에 힐트를 적용하는건 약간 더 까다롭지만 어렵지는 않다.

많이 쓰이는 네트워크 라이브러리인 OkHttp 에 힐트를 적용해보겠다.

app의 build.gradle에 다음과 같이 추가해주자

implementation 'com.squareup.retrofit2:retrofit:2.9.0'
implementation 'com.squareup.okhttp3:logging-interceptor:4.9.0'

그리고 네트워크 관련된 코드를 담을 NetworkModule.kt 파일을 만들어보자.

NetworkModule 파일에는 OkHttpClient 객체를 만드는 코드가 들어있다.

일단 코드를 보고 설명을 읽어보도록 하자

NetworkModule.kt

@Module
@InstallIn(SingletonComponent::class)
class NetworkModule {

    @Provides // 다른 곳에서 사용될 객체를 만들어준다는 뜻이다  
    @Singleton
    fun provideHttpLoggingInterceptor() : HttpLoggingInterceptor =
        HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BODY)

    @Provides
    @Singleton
    fun provideOkHttpClient(
        @ApplicationContext context: Context,
        httpLoggingInterceptor: HttpLoggingInterceptor
    ): OkHttpClient =
        OkHttpClient.Builder().apply {
            interceptors().add(httpLoggingInterceptor)
        }.build()

}

위의 StoreModule이 abstract class 였던 것과는 다르게 NetworkModule은 일반 클래스이다. 또 객체를 만들어주는 부분을 @Provides 로 표시하였다. @Provides 를 적어줘야 다른 곳에서 객체가 잘 만들어진다.

provideOkHttpClient() 함수가 OkHttpClient 객체를 만들어주는데, 잘보면 인자를 2개 받는다. 하나는 context인데 @ApplicationContext*가 붙어있다. *@ApplicationContext 를 적어주면 힐트가 알아서 컨텍스트를 찾아주니 매우 편리하다 다른 인자 하나는 httpLoggingInterceptor 인데 바로 위의 provideHttpLoggingInterceptor() 에서 HttpLoggingInterceptor 객체를 만들어준다. 같은 모듈 안에 있는 것도 바로 바로 연결이 되는 것이다.

이제 액티비티로 가서 OkHttpClient 객체가 잘 만들어지는지 확인해보자

@AndroidEntryPoint
class MainActivity : AppCompatActivity() {
    @Inject lateinit var httpClient: OkHttpClient

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // request 를 하기 위
        val request = Request.Builder()
            .url("https://www.google.com")
            .header("User-Agent", "OkHttp Example")
            .build()    

       httpClient.newCall(request).enqueue(object : Callback {
            override fun onFailure(call: Call, e: IOException) {
                Log.i(TAG, "Network call error - ${call}, err msg - ${e.message}")
            }

            override fun onResponse(call: Call, response: Response) {
                Log.i(TAG, "Network call - ${response.body}")
            }

        })

    }

}

요청을 하고 기다려보자.

로그에 request body 나오면 성공이다.

이번 글에서는 힐트의 사용법에 대해서 간단하게 알아보았다. 힐트를 쓰려는데

헷갈렸다면 이번 글을 통해 도움을 얻었으면 한다.

안드로이드 젯팩 (jetpack - viewmodel, workmanager)과의 연결이나 범위(scope) 등 좀 더 자세한 내용을 알고 싶다면 공식 문서를 참고하도록 하자

참고

안드로이드 힐트 문서 - https://developer.android.com/training/dependency-injection/hilt-android

대거 힐트 문서 - https://dagger.dev/hilt/view-model

개발자로 일하기에 좋은 성격이 있을까?

에드 신 — Thu, 4 Nov 2021 19:08:54 +0900

빅파이브나 mbti 같은 각종 성격 분류법을 보다보니,

개발자로 일하면 유리한 성격이 있을거라는 생각이 들었다.

빅파이브 기반으로 이를 한번 분석해보고자 한다.

빅파이브는 사람의 성격이 크게 5가지로 구성되어 있다고 하는 이론이다.

심리학계에서 많이 쓴다.

다만 유념해야할 점은 어떤 성격이 있다고 해서 무조건 잘한다는 건 아니다.

잠재력이 있다 정도로 보는게 좋다.

땅에 과일을 심는 걸 생각해보자.

땅이 기름지고, 기후가 좋으면 같은 사과나무를 심더라도, 수확량이 많은 가능성이 높다.

허나 땅이 아무리 좋더라도, 심은 나무를 관리 안하면 병충해에 열매가 다 사라질수도 있다.

만약 나무를 한그루만 심는다면? 100그루를 심고 충실히 관리한 곳보다 훨씬 못할 것이다.

유리한 조건이 있을 수도 있지만, 활용을 못하는 경우도 매우 흔하다.

그리고 재능, 환경, 자존감 등도 차이가 난다.

성격 유형에 대한 글을 읽을 때는 이 점을 생각하면서 읽었으면 좋겠다.

빅 파이브에서는 사람의 성격을 5가지로 나누어 본다.

‘성실성(C)’, ‘개방성(O)’, ‘신경성(N)’, ‘외향성(E)’, ‘우호성(A)’이다. 영어 약자는 C, O, N, E, A인데 앞으로 약자를 같이 쓰겠다.

빅 파이브 간략한 테스트는 '여기'에서 할 수 있다.

5대 성격

각 성격 특징을 간략히 설명해 보겠다.

‘성실성’은 얼마나 계획을 잘 세우고, 꾸준히 일하느냐를 말한다. 매일 10년동안 회사에 지각을 한번도 안 하고 꾸준히 다녔다면

‘성실성’이 높다고 볼 수 있다. 매일매일 계획이 흐트러지며 약속을 잘 안 지킨다면 ‘성실성’이 낮다고 볼 수 있다. ‘성실성’이 높으면 계획을 잘 세우고 따라가며, ‘성실성’이 낮으면 기존의 계획도 잘 바꾼다. ‘성실성’이 낮은 사람이 유머 감각이 있다고 한다.

‘개방성’은 새로운 걸 얼마나 잘 받아들이느냐를 나타낸다. 보통 추상적인 철학, 미술, 책 등을 좋아하는 사람은

개방성이 높다. ‘개방성’이 높으면 새로운 분야를 배우는데 유리하지만, 너무 높으면 어떤 일이든 금방 질려 한다. ‘개방성’이 낮으면 반복적인 일을 잘 수행한다. ‘개방성’이 낮은 사람이 좀 더 실용적으로 보일 수 있다. 일반적으로 ‘개방성’ 차이가 적을수록 친구나 연인이 되기 쉽다.

‘신경성’은 예민한 정도이다. 남이 한 말을 곱씹어 보고, 어떤 일이 해결 안 되었을때 자꾸 스트레스 받는다면 ‘신경성’이 높은 것이다.

다른 사람의 말이나 행동을 신경 안 쓴다면, ‘신경성’이 낮다고 보면 된다. ‘신경성’이 낮은 사람들은 웬만한 일에는 스트레스를 안 받는다.

‘신경성’이 높으면 삶을 부정적으로 보고, 우울증에 걸릴 가능성이 높다. ‘신경성’이 높은 사람 중에 위대한 철학자, 예술가가 상당히 많다.

‘신경성’이 높고, ‘개방성’도 높으면 창의적이 될 확률이 급격히 올라간다. 남다른 결과물을 만들어낼 가능성이 높지만, 삶이 불행한 경향이 있다. 베토벤, 고흐도 ‘신경성’이 매우 높았을 걸로 추정된다. ‘신경성’이 높으면 유산소 운동, 명상, 친밀한 대인 관계를 통해 스트레스를 다루는 법을 알 필요가 있다.

‘외향성’은 얼마나 외부 활동을 추구하느냐를 말한다. ‘외향성’이 높으면 밖으로 엄청 돌아다닌다. 사람을 만나고, 여행을 가고, 외부 활동에 많은 시간과 에너지를 쓴다. 집에만 있는 날이 드물다. ‘외향성’이 낮으면 집에 주로 있거나, 밖으로 나가도 혼자서 있는다. 일이나 취미 활동도 혼자 하는 걸 선호한다.

‘우호성’은 다른 사람에게 동의하는 정도이다. ‘우호성’이 높으면 타인과 쉽게 친해지며, 의견 차이가 있더라도 관계를 생각해 넘어간다. 처음 봤는데도 친근해 보이는 사람이 있다면, 우호성이 높다고 보면 된다.

‘우호성’이 낮으면 타인과 친해지는데 시간이 걸리고, 의견이 다를 경우 할말 다 하는 경향이 있다.

‘우호성’이 너무 높으면 주관이 없어 보이고, ‘우호성’이 너무 낮으면 반골 기질이 있어보인다.

5개 성격적 특징에 대해 간략히 알아보았다.

이 특징들을 영어 알파벳으로 나타낼 건데

각각의 수치는 5개 ( ++, +, 무표시, -, — )로 나타낸다.

C이면 중간의 성실성이고, C++면 계획에 집착할 정도로 성실한 경우다.

성격적 특징에 따른 차이

1.성실성

성실성 (C+) : 일반적으로 성실도가 높으면 개발에 투자하는 시간이 많을 것이다.

개발 적성은 사람마다 차이가 있는데, 적성이 뛰어나도 투자하는 시간이 적으면 잘 못 배울 가능성이 높다.

개발적성이 10이지만 하루에 5시간 공부하는 사람과 개발 적성이 6이지만 하루에 9시간 공부하는 사람이 있다고 치자.

10 * 5 = 50
6* 9 = 54

매일 4씩의 차이가 생기게 된다. 이 차이가 1년, 2년 쌓이면 어마어마진다.

시간이 지날수록 성실성이 높은 사람이 유리해지는 것이다.

또한 성실성이 높을수록 개발 일정이나 다른 직군과의 약속을 책임감 있게 준수할 가능성이 높다. 성실도가 낮으면 중간에 계획에서 벗어날 가능성이 높다.

다만 지나치게 성실한 것은 좋지 않을수가 있는데, 잘못된 방법을 택한 뒤 그것을 고수할 가능성이 높기 때문이다. 한마디로 융통성이 없는 것이다.

실제 프로그램을 만들때 버그가 생기면 재빨리 다른 수를 3~4개 생각해내고, 그것을 확인해보는 게 중요하다. 하지만 성실성이 과하게 높으면 엉뚱한 방법에 시간을 과하게 낭비할 가능성이 높다.

성실도가 C인 사람이 C+나 C++보다 디버깅은 잘할 가능성이 있다고 본다. 막혔을때 우회로를 찾아내는 능력이 있을 것이기 때문이다.

스티브 맥코넬은 책 ‘코드 컴플리트’에서 개발자가 가지지 말아야할 덕목으로 ‘인내심’을 적었는데 개인적으로 동의한다.

성실도가 C++인 사람이 필요할때 C 정도로 바뀔 수 있으면 좋겠지만, 그런 경우는 잘 없다.

여러면을 종합했을때 C+ 인 사람이 가장 뛰어난 개발자가 될 가능성이 높아 보인다.

2.개방성

개방성 (O++) : 개방성은 높을수록 좋다. 개방성은 새로운 걸 받아들이는 것을 말한다.

개발쪽은 배웠던 지식이 바뀌는 경우가 흔하다. 따라서 개방성은 무조건 높은 사람이 좋다.

개방성이 높은 사람은 항상 새로운 걸 시도하거나, 새로운 정보를 받아들이려고 한다.

평소 호기심이 많고, 여러 분야를 탐험하는 성격이라면 개방성이 높을 걸로 추정할 수 있다.

개방성은 낮은데(O - ), 성실성은 높다면 (C +) 옛 기술을 고집하려는 성향이 나타날 수 있다.

개방성이 낮으면 의도적으로 신기술을 공부할 필요가 있다. 보통 언어 1개가 최고라고 주장하는 사람은 개방성이 낮다.

개방성이 매우 낮은 사람과 개방성이 매우 높은 사람은 서로를 이해 못한다.

개방성은 엄청 높은데 (O++), 성실성은 낮다면 (C-) 매번 새로운 언어를 배우거나,

새 프로젝트를 시작하느라 완결된게 하나도 없을 수 있다.

개방성이 높고 (O+), 성실성은 낮고 (C-), 외향성이 높다면 (E+, E++)

말로만 개발하는 입개발자가 될 수 있다.

참고로 개방성은 mbti에서 N과 S와 관계가 있다.

3.신경성

신경성 (N- ) : 신경성은 낮을수록 좋다. 개발을 하다보면 과거에 되던게 안되거나,

문제가 없다고 생각했는데 큰 문제가 터지는 경우가 많다.

웬만한 일에는 정신이 나가지 않는 성향이 개발을 할때 매우 유리하다.

신경성이 매우 높다면 (N++), 함수 하나가 잘 안 짜이는것에 큰 스트레스를 받을 수 있다.

디버깅을 하다가 자괴감에 빠져서, 슬퍼하고 있을 수도 있다.

신경성이 낮고 ( N - ), 성실성이 높다면 ( C+ ) 실제 문제가 생겼을때 덤덤하게 수정을 할 것이다.

서버가 터졌을때 덤덤하게, 서버에 문제가 있구나 하고 표정 변화없이 수정하러 가는 사람을 생각하면 된다.

신경성이 낮고 (N — ), 성실성이 낮고 ( C - - ), 외향성이 매우 높다면 (E++)

서버가 멈춰도, "서버가 문제가 있네. 다음에 고치자" 하고 놀러갈 수도 있다.

신경성이 높으면 정신 관리 차원에서 불리한데, 장점이 하나 있다.

신경성은 책임감이나 성실성 지표를 높여주는 역할을 한다.

실제 신경성이 높은 사람이 사회적 성공을 약간 더 한다는 연구 결과도 있다.

신경성이 높고 (N++), 성실성이 중간인 (C ) 사람은 코드가 신경 쓰여서 집에서 잠을 못잘 수도 있다.

본인은 스트레스 받지만 문제 해결력이 좋은 것이다.

신경성이 중간(N) 이고, 성실성이 중간( C ) 이상이거나

신경성이 낮고 (N - ) , 성실성이 높은 사람(C ++ )이 일을 아주 잘 완수할 가능성이 높다.

신경성이 매우 높고 (N ++), 성실성도 매우 높다면 (C ++ ) 강박증이 있을 수 있다.

4. 외향성

외향성 (E-) : 외향성은 낮을수록 좋다. 외향성이 높을수록 사회적 관계를 추구하고

앉아서 작업하는 시간이 적어지기 때문이다.

개발은 문제를 푸는 것과 비슷한 측면이 많은데, 외향성이 낮을수록 ( E - ), 시간 투자를 할 가능성이 높다.

영업인들에게 높은 외향성(E+)이 필요한 것과 정반대인 것이다.

성실성이 높고 (C+), 외향성이 낮다면 (E-) 탁월한 개발자가 될 가능성이 있다.

성실성이 높은데 (C++), 외향성이 높다면 (E+) 밖으로 나가려는 성향을 잘 제어할 것이다.

성실성이 중간이고 (C), 외향성이 낮다면 (E-) 준수한 실력이 있을 가능성이 있다.

외향성이 낮으면 직급이 올라갈수록 문제가 생길 수 있긴 하다. 의사소통에 들어가는 시간이 많아지기 때문이다.

CTO 는 외향성이 중간(E)은 되어야 문제 없이 일을 수행할 수 있다.

5.우호성

우호성 (A-): 우호성이랑은 큰 관계가 없어보인다. 우호성이 높으면 남을 잘 받아들인다.

의심도 적게 한다. 우호성이 낮으면 의심을 많이 한다.

우호성이 높으면 (A+) 선생님이나 직장 상사의 말을 더 잘 받아들일 가능성이 높다.

우호성이 낮으면 (A-) 권위 있는 사람의 말도 의심을 한다.

타인에게 도움을 청하는 건 우호성이 높은 사람이 더 잘한다.

우호성이 높다면 (A+) 개발을 시작할때는 배울만한 사람이 많은 학원을 찾는 게 좋을 것이고,

회사에 들어갈때는 선배 개발자가 많은 곳을 찾는 게 유리하다.

우호성이 낮다면 (A-) 도움을 청하는 법을 배우거나, 경쟁적인 환경으로 가는 게 좋다.

우호성이 낮다면 토론을 수용하는 곳에서 일하거나, 작은 조직을 택하는 게 나을 수 있다.

글을 끝내며

종합적으로 성실성이 높고 (C+), 개방성이 높고 ( O+ , O++), 내향적인 ( E - ) 사람이 탁월한 개발자가 될 가능성이 높다고 본다.

신경성과 우호성은 조합에 따라 달라지기에 뺐다.

이는 전반적인 프로파일이고, 직군이나 기업 규모에 따라

조금씩 다를 수 있다고 본다.

타직군과 협업을 많이 해야한다면, 좀 더 외향적이고 우호성이 있는게 좋고

시스템 프로그래밍처럼 아주 깊은 기술을 다룬다면, 극단적으로 내향적이고 개방성이 낮아도 상관없거나 유리할 수 있다고 본다.

사용자와 가까운 직군일수록 (프론트쪽), 개방성이 높은게 낫고,

사용자와 멀수록, 개방성이 낮아도 문제가 없다고 보면 된다.

참고책

성격의탄생, 다니엘리틀 ( http://www.yes24.com/Product/Goods/80854209?OzSrank=1 )
마음을 읽는지도 빅파이브, 피어스 하워드 ( http://www.yes24.com/Product/Goods/13655346?OzSrank=2 )

개발 더 잘하기 - 초급자에서 중급자로 가기 위한 8가지 방법

에드 신 — Wed, 1 Sep 2021 17:40:13 +0900

초보자에서 초중급자, 중급자로 넘어가는 방법을 정리해보았다.

1. 내가 쓰는 도구를 이해하자.

쓰는 툴에 대한 이해도가 높아질수록, 작업 속도가 빨라 진다.
개발 툴의 단축키나 개발 툴의 보조도구 (플러그인, 익스텐션) 등을 알고 있을수록 생산성이 올라간다.
의식적으로 내가 자주하는 작업을 생각하고, 이걸 쓰는 단축키가 있는지 알아보도록 하자.
우선 자주 쓰는 단축키 ( 영어로는 short cut cheetsheet ) 를 검색해서, 남들이 쓰는 단축키를 알아보고, 10개정도만 적용해보자. 생산성이 달라진다.

2. 빌드 시스템을 이해하자.

프로젝트가 커질수록 빌드에서 문제가 생기는 경우가 많다.
빌드 시스템에 대해서 따로 시간을 투자해서 공부하는 게 좋다. 빌드가 어떤 과정으로 되는지 알면, 빌드가 느려지는 원인이나 막혔을때 해결법을 알 수 있다.
웹 개발자면 webpack (웹팩), 모바일이면 gradle (그래들), pod 를 이해하자.
버전업 등으로 문제가 생기더라도 스스로 해결 할 수 있게 될 것이다. 적은 구글링 혹은 구글링 없이도 문제를 고칠 수 있게 된다.
빌드 시스템 이해가 먼저고 CI/ CD 가 다음이다.

3. 라이브러리를 작성해 보자.

직접 라이브러리를 만들어보면 어떤 코드를 재활용하고, 코드를 어떻게 나눠야 효과적인지 감이 잡히기 마련이다.
라이브러리를 만들다보면 남이 만든 라이브러리도 자연스럽게 많이 읽게 되는데, 가져다 쓰기만 할때와는 다른 깊은 이해를 얻게 된다.
이미 비슷한 라이브러리가 있다고 해도, 내가 라이브러리를 만들어보면은 많은 걸 배우게 된다.
공개도 할 수 있으면 하자. 공개하는 코드랑 개인적으로 쓰는 코드는 아무래도 질적인 면에서 차이가 나기 마련이다.

4. 다른 언어로 포팅을 해보자.

한 언어로 구현된 코드를 다른 언어로 바꾸려면 많은 난관을 겪게 된다. 이전 언어의 라이브러리를 못 쓰는 경우도 많고, 문법 자체가 다른 경우도 많다.
포팅을 하려면 결국 2언어를 다 이해해야 하는데, 한 언어로만 코딩하는 것에 비해 3~4배는 힘든 일이다.
대신 성공만 하면 이전 언어에 대한 이해가 폭발적으로 좋아지고, 새 언어도 잘 쓰게 된다.
파이썬으로 백엔드를 작성했다면, 노드나 스프링으로 작성해보도록 하자.

5. 개발 일지를 적어보자.

내가 오늘 개발한것, 문제는 무엇이 있었는지를 적어보는 것이다. 해결책도 같이 적는게 좋다. 공개된 장소에 적어도 좋고, 개인 일기장에 적어도 좋다.
개발 일지를 적으면, 같은 문제를 만났을때 해결하는 속도가 매우 빨라져서 좋다. 또 내가 반복적으로 잘못하고 있는 것을 알게 되어서 내가 범하는 명백한 실수를 없앨 수 있어서 좋다.
개발일지를 오래 적을수록, 자신만의 지식창고 만들어지기에 생산성이 높아진다.
우리 두뇌는 자신이 기록하고 정리한 것을 더 오래 기억하고, 쉽게 찾는다. 단기적으로는 시간을 좀 더 쓰는 것 같아도 장기적으로는 이득이다.

6. 컴파일을 덜 하자.

1줄, 1줄 단위로 코드를 작성하고, 실행을 하면 결과를 바로 볼 수 있어서 편하지만 실행 전에 결과를 알지 못한다.
반면 코딩을 여러 줄 혹은 블록 단위로 컴파일을 하게 되면 실행 전 결과를 예측이 가능해진다. 머릿속으로 코딩 결과를 예측하는 습관이 들고 예측하는 범위가 커질수록 개발속도가 올라가게 된다.

7. 다른 시도를 해보자.

테스팅을 소홀히 해왔다면 테스팅을 해보자. 안 하던 스타일로 리팩토링을 시도해봐도 좋다.
서버 개발자면 클라 개발을 해보거나, 다른 분야 개발을 해보자.
정적 언어만 했으면 스크립트 언어를 만져보거나, 스크립트 언어만 했다면 정적 언어를 해보자.
다른 시도를 하면 실력이 일시적으로 줄어들게 되지만, 새 시도에 익숙해지고 나면 원래 쓰던 방법들을 더 잘 쓸 방법이나 응용할 방법을 알게 된다. 다른 분야의 지식이 새 분야로 옮겨가면서, 이전에 알던 부분을 더 나아지게 할 방법을 알게 된다.

8. 가르쳐보자.

가르치다보면 내가 실제로 알고 있다고 생각한게, 실제로 아는 게 아닌 걸 알 수 있다.
다른 사람을 이해시키려면 풀어서 설명을 하게 되고, 설명을 하는 과정에서 깊이 알게 된다.
가르치다보면 라이브 코딩을 많이 하게 되는데, 내가 예상치 못한 에러를 많이 만나게 된다. 이 에러를 해결해주는 과정에서 디버깅 실력이 올라간다.
가르치다보면 질문에 대비하기 위해 준비를 더 많이 하게 된다. 일할때는 1만 알고 적당히 넘어 갔던 것을, 가르칠때는 4~5배 찾아보게 되는 경우가 흔하다. 이 과정에서 깊이가 생긴다.
우리 두뇌는 무언가를 가르쳐야 한다고 생각하면 정보를 더 깊게 받아들인다. 우리 두뇌는 에너지 낭비를 싫어해서 안 중요하다고 여기면 무시한다. 가르쳐야 된다고 여기는 순간, 중요한 정보로 여겨 더 잘 기억한다.

개발을 공부할때 종종 쓰는 방법을 정리해보았다. 이 글이 개발 실력을 높이는데 도움이 되었으면 한다.

파이썬 정규표현식 배워보기

에드 신 — Sat, 9 Jan 2021 15:48:44 +0900

04-reg

정규 표현식은 특정 데이터를 추출하는데 아주 유용하다. 대량의 문서에서 원하는 데이터를 찾을때 정규 표현식 만한 게 있을까?

하지만 정규 표현식은 처음 배우기 까다롭고, 배웠어도 안 쓰다보면 쉽게 까먹는다.

이번 글을 통해 정규표현식에 대해 공부하고, 자주 쓰는 표현을 정리해보고자 한다.

정규표현식을 시작하거나, 관련 예제 (튜토리얼)를 찾고 있다면 도움이 될 글이다.

이번 글에서는 다음과 같은 내용을 다룬다.

정규표현식 기본 원리
정규표현식 기본 표현들 ( {n,m} , [a-zA-Z], [ㄱ-ㅎㅏ-ㅣ] , ()(), ^abc )
자주 쓰는 표현들 (이메일 추출, 전화번호 매칭, 한글 제거, 특수문자 제거 등)

그럼 시작해보자

1. 정규 표현식이란?

정규표현식은 특정한 규칙을 찾는데 쓰인다. 예컨데 한글로된 문서에서 영어 알파벳을 없애고 싶다거나, 이메일만 찾고 싶다거나 할때 쓰인다.

예컨데 '안녕하세요 abc 좋은날이네요' 라는 문자열에서 abc만 찾고 싶다고 해보자.

파이썬 함수를 사용할 경우에는 abc문자열의 위치를 알아내야하고, 찾아낸 문자열에 다른 문자는 섞이지 않았는지, 대문자는 아닌지 등 확인해야될 게 많다. 하지만 정규표현식을 사용하면 이 모든걸 한번에 해결할 수 있다.

정규표현식은 원하는 문자열을 쉽게 찾기 위해, 기존의 문자열을 다른 방식으로 쓰곤 한다.

. 의 경우 일반 문자에서는 마침표로 쓰이지만 정규표현식에서 .는 모든문자(줄바꿈은 제외)를 의미한다.

다른 뜻으로 쓰이는 문자를 메타 문자라고 하는데 사용하다보면 익숙해진다.

메타문자


. ^ $ * + ? \ | ( ) { } [ ]

메타문자는 12개가 있는데 일부만 설명하고 나머지는 파이썬과 함께 설명하도록 하겠다

마침표 ( . ) 메타문자 - 일치하는 모든 문자열 (1개)

첫번째 문자열은 a고, 마지막 문자열은 c인 문자열을 찾고 싶으면 어떻게 해야할까.

'abc', 'aec', 'afc' 같은 문자열을 모두 찾고 싶다면?

이때 사용하는게 마침표( . ) 메타문자이다. 마침표 (.) 가 있으면 어떤 문자가 있어도 일치하는 걸로 여긴다. 이때 새로줄 표시(\n)는 제외이기는 하다.

a.b처럼 적혀있으면 정규표현식에서는 a1b 나 aOb나 같은 패턴으로 여겨진다. 동일한 패턴을 찾기에 효과적인 방식이라 할 수 있다.

곱하기 (*) 메타문자 - 같은 문자열 반복

abbc, abbbc 처럼 같은 문자열이 반복되는 경우를 찾고 싶으면 어떻게 할까.

이때는 곱하기 (*) 메타문자를 쓰면 된다.

ab*c 처럼 적혀 있으면 b가 0개든, 1개든, 100개든 같은 패턴으로 여겨진다.

abc 랑 abbbbbbbbbbbbc 가 컴퓨터가 볼때는 같은 패턴인 것이다. 사람이 볼때는 다르지만.

이처럼 메타문자를 쓰면 일반적으로는 표현하지 못했던 패턴들을 적고, 찾아낼 수 있다.

그럼 파이썬에서 이런 정규표현식들이 어떻게 쓰이는지 알아보도록 하자.

더하기 (+) 메타문자 - 1개 이상 같은 문자열 반복

더하기 (+) 메타문자는 곱하기(*)와 유사하나 1가지 차이점이 있다.

1개 이상 문자열이 일치해야한다는 것이다.

a+c의 경우 abc 는 일치하는 패턴이지만 ac는 아니다

2. 파이썬에서의 정규표현식

2.1. re 모듈과 메서드

파이썬에서 정규표현식은 re 모듈를 써서 활용한다.

re 모듈에는 여러 함수가 있는데 주로 search, match, findall, compile을 사용한다.

각각의 사용법을 알아보자

match - 첫문자열부터 일치하는 패턴을 찾고 싶을때

문장에서 abc라는 문자열을 찾고 싶다면 어떻게 해야할까?

특히 첫단어부터 일치하는 경우만 찾고 싶다면, match 함수를 사용하면 된다.


xxxxxxxxxx
s = 'abc123'  // 검색하려는 문자열.
m = re.match('abc', s) // 문자열에 맞는 패턴이 있는지 확인, 여기서는 abc가 패턴
print(m.group()) // 일치하는 패턴이 있는 경우 m에 값이 담겨 있고, group을 쓰면 일치하는 문자열이 출력됨


xxxxxxxxxx
abc // 출력결과

match 함수의 사용법은 다음과 같다.

내가 검색하려는 문자열을 정해 2번째인자로 넣고, 패턴을 match함수의 첫번째 인자로 넣어주면 된다.

패턴( 예제에서는 abc )와 일치하는 문자가 있으면, m에 결과가 담기게 된다.

다른 예제를 보도록 하자


xxxxxxxxxx
s = 'abcd1004'
m = re.match('a.c', s) // a.c와 일치하는 문자열을 찾는다. 
print(m.group())


xxxxxxxxxx
abc // 출력결과

이번에는 a.c 를 패턴으로 썼다. 마침표 ( . )이 있으니 이 부분에는 아무 문자가 들어가도 된다.

문자열이 abcd1004이고 이 중에 abc이 일치하니 이 값을 출력하게 된다.

이제 정규표현식을 좀 더 배우면 파이썬으로 원하는 문자를 찾는 건 쉬울것 같다.

과연 그럴까?

다른 예제를 확인해보자


xxxxxxxxxx
s = '123abc456'
m = re.match('a.c', s)
print(m) // 출력결과 : None

위의 예제를 실행하면 아무값도 나오지 않는다.

match 함수는 패턴이 첫문자열부터 일치해야지, 패턴을 찾은것으로 여기기 때문이다.

이처럼 match 함수는 일반적으로 쓰이기에는 무리가 있기에 search 함수를 자주 쓴다.

search - 아무곳에서나 일치하는 문자열을 찾고 싶을때

위의 예제를 search 함수를 써서 실행해보자


xxxxxxxxxx
s = '123abc456'
m = re.search('abc', s)
print(m.group()) // 출력결과 : abc

아무 문제 없이, 문자열 abc를 찾는다.

예제를 하나 더 보도록 하자


xxxxxxxxxx
s = '123def789' // 검색 대상인 문자열
m = re.search('[a-f]e', s) // [a-f] 는 a~f까지, abcdef 중 일치하는 게 하나라도 있는지 확인한다는 뜻
print(m.group())

[a-f]e 을 찾고 싶은 패턴으로 썼는데, [] 는 여러 문자들 중 1개라도 일치하는지 확인하고 싶을때 쓰인다.

[abㅊ] 라고 되어 있으면 a와 b와 ㅊ 중 한개라도 일치하면 되는 것이다.

위의 예제에서는[a-f] 라고 적었는데 a-f는abcdef 의 줄임말이다. ( 요런 특수 표시는 나중에 더 정리하겠다. )

즉 [a-f]e 는 ae, be, ce, de, ee, fe 중 아무거나랑 하나라도 일치하는 것을 찾겠다는 뜻이다.

문자열 '123def789' 에는 de 가 들어 있으므로, 패턴을 찾는데 성공한다.

허나 search에도 문제가 있었으니, 일치하는 패턴을 1개만 찾을 수 있단 것이다.

find all - 패턴과 일치하는 여러 문자열을 찾고 싶을때

문자열에서 영어만 찾은 경우를 보자.

이때는 [a-zA-Z]+ 패턴을 쓰면 된다.


x
s = 'hello-world-123-good-984'
m = re.search('[a-zA-Z]+',s) // [a-zA-z]는 모든 알파벳을 뜻함. +는 1개 이상 일치하는 문자열이 있는 경우.
print(m.group()) // 실행결과 : hello

위의 예제를 실행하면 영어 hello가 출력된다.

영어를 잘 찾기는 했지만 모든 영어 문자를 찾지는 못한다.

모든 일치하는 문자열을 찾고 싶을때는 어떻게 해야할까. 이때 쓰이는 게 findall이다.


xxxxxxxxxx
s = 'hello-world-123-good-984'
m = re.findall('[a-zA-Z]+',s)
print(m) // 출력결과 ['hello', 'world', 'good']

findall을 쓰면, 일치하는 모든 문자열을 찾아준다.

10만자 짜리 문서에서 이메일만 여러개 찾아보고 싶다면, 써야될게 바로 findall 이다.

2.2. 메타문자와 파이썬

이제 파이썬과 정규표현식에 익숙해졌으니, 나머지 메타문자를 알아보고 조금 더 복잡한 정규표현식을 작성해보도록 하자.

앞에서 알아본 메타문자에는 . * + []가 있었다.

? - 없거나 하나가 있을때

? 앞에 문자가 하나 있거나 없을때 매치가 된다.

go?d 의 경우

gd와 god는 일치로 처리되지만

good는 일치가 아니다.

물음표 ( ? ) 메타문자 대신에 실제 물음표를 쓰려면 \? 식으로 적어주면 된다.

밑에서 자세히 알아보겠다.

{n, m} - 일정 갯수인 패턴 찾기

. * 메타문자를 쓰면 반복되는 문자를 찾을 수 있지만 갯수 제한이 없는게 단점이다.

만약 a가 4개, b가 2개인 문자열을 찾고 싶다면 어떻게 해야할까?

이때 사용하는게 { n, m } 메타문자이다.

여기서 n과 m은 숫자를 가리킨다.

{n,m} 앞의 문자열이 n번 이상, m번 이하 나타났다면 맞는 패턴으로 여겨진다.

x{2,5} 처럼 정규표현식이 적혀있다면, xx, xxx, xxxx , xxxxx 가 일치하는 패턴이 된다.

코드를 보며 좀 더 설명해보겠다


xxxxxxxxxx
s = '0aaa5'
m = re.search('a{3,4}', s) // a{3,4}는 범위를 나타내는 정규식. a가 3번이상이고 4번 이하면 맞는 패턴으로 본다
print(m.group()) // 출력결과 : aaa

위의 코드를 보면 a{3,4} 가 정규식인데, 맞는 패턴을 찾을 수 있었기에 aaa 가 출력된다.

범위를 나타내는 정규표현식은 전화번호 찾기 등에 쓰일 수 있다.

휴대폰 번호는 일반적으로 11자리지만, 집전화의 경우 10자리인 경우도 있다.

이 경우 첫번째 전화 번호자리에 범위를 나타내는 정규식을 쓰면 쉽게 원하는 값만 추출할 수 있다.


xxxxxxxxxx
s1 = '휴대전화에요.010-1234-9001'
m1 = re.search('[0-9]{2,3}-[0-9]{4}-[0-9]{4}', s1) 
print(m1.group()) // 출력결과 : 010-1234-9001
s2 = '중국집이에요.02-2940-7001'
m2 = re.search('[0-9]{2,3}-[0-9]{4}-[0-9]{4}', s2)
print(m2.group()) // 출력결과 : 02-2940-7001

예제의 첫번째 패턴을 보면 [0-9]{2,3}-[0-9]{4}-[0-9]{4} 로 적혀있다.

여기서 [0-9]{2,3} 는 숫자(0부터 9까지)가 2개 이상 3개 이하 있는 걸 말한다.

마찬가지로 [0-9]{4}는 숫자가 4개 있는 걸 말한다.

보통 전화번호 앞자리가 2자리거나 3자리이고, 뒷번호는 4자리씩이기에 이 정규식을 쓰면 전화번호를 적절히 찾을 수 있다.

하지만 완벽한건 아니고 - 가 없는 경우나 다른 기호() 가 들어가 있는 경우, 국제 번호인 경우는 처리하지 못한다.

^ - 시작 문자가 일치하는 경우 찾기

특정 문자로 시작하는지 확인하고 싶을때는 어떻게 해야할까

예컨데 어떤 문장이 '안녕'이란 말로 시작하는지 알고 싶다면?

이때 쓰이는게 ^ 메타문자이다.


xxxxxxxxxx
s = '안녕하세요. 좋은 아침이에요'
m = re.search('^안녕', s)
print(m.group()) // 출력결과 : 안녕

^안녕 을 정규식으로 적었더니 '안녕하세요. 좋은 아침이에요' 란 문장에서

'안녕' 으로 매칭되는 걸 알 수 있다. '안녕하세요'가 문장의 맨 앞에 있기때문이다.

반면에 '안녕하세요'가 문장 안쪽에 있을때는 매칭이 안되는 걸 알 수 있다


xxxxxxxxxx
s = '좋은 아침이에요.안녕하세요'
m = re.search('^안녕', s)
print(m) // 출력결과 : None

^ 메타문자가 [] 안에서 쓰이면 다른 의미가 된다. 이 패턴은 제외한다는 뜻이 된다.

[0-9]가 숫자인 패턴을 찾는 거라면 , [^0-9] 는 숫자는 패턴을 제외한는 뜻이다.

$ - 마지막 문자가 일치하는 문자열 찾기

그럼 첫 문자가 아니라, 마지막 문자가 일치하는 경우를 찾고 싶다면 어떻게 해야할까.

예컨데 '요'로 끝나는 문장을 찾는 과제를 받았다고 상상해보자.

이때 $ 메타문자를 쓰면 된다

예시를 보자


xxxxxxxxxx
s = '지금은 즐겁게 있어요'
m = re.search('[ㄱ-힣]+요$', s) // [ㄱ-힣] 은 한글일때만 일치하는 걸로 본다는 뜻
print(m.group()) // 출력 결과 : 있어요

'[ㄱ-힣]+요$' 정규식은 '요'로 끝나는 한글을 찾겠다는 의미이다.

[ㄱ-힣] 는 한글일때만 일치하는 걸로 본다는 뜻이고

요$ 는 '요'로 끝나는 경우만, 일치하는 걸로 여긴다.

'요'가 아니라 '요.' 이었으면 일치하지 않았을 것이다.

| - 여러개 조건 만족하는 패턴 찾기 (or, 또는)

정규식을 쓰다보면 여러 패턴과 일치하는지 확인하고 싶을때가 많다.

이때 쓰이는 게 | 메타문자이다.

| 앞 뒤에 적힌 정규식은 서로 다른 정규식으로 여겨진다.

| 를 쓰면 원하는 만큼 정규식을 적을 수 있다.

정규식1| 정규식2 | 정규식3 | ...

예를 보도록 하자


xxxxxxxxxx
s = 'There is a crow and bird'
m = re.findall('cro*w|bir+d', s) // | 앞뒤로 정규식이 2개 있다
print(m) // 출력결과 : ['crow', 'bird']

예에서 쓰인 정규식은 cro*w|bir+d으로 2개의 정규식이 연결되어 있다.

cro*w 랑 bir+d 중 하나만 일치해도, 맞는 패턴으로 본다.

There is a crow and bird 에는 crow가 일치하고 bird도 일치하는 문자열이기에

['crow', 'bird'] 가 결과로 출력된다.

() - 그룹으로 묶기

찾은 결과물에서 특정 부분만 빼내고 싶을때는 어떻게 해야할까.

예컨데 날짜를 찾았는데 연도랑 월만 빼내고 싶다면?

이 때 () 메타문자를 써서 그룹으로 묶으면 편리하다.


xxxxxxxxxx
s = '안녕하세요. 새해 복 많이 받으세요. 글은 2021-01-06에 썼어요'
m = re.search('[0-9]{4}-[0-9]{2}-[0-9]{2}', s) // 날짜를 찾기 위함. 
print(m.group()) // 출력결과 : 2021-01-06

위의 예를 실행하면 2021-01-06 이 출력된다. 날짜를 찾아낸 것이다.

하지만 우리는 연도랑 월만 원한다.

이때 다른 함수로 문자열을 나눌 수도 있지만, () 로 묶어주면 구분하기 편리하다.

()로 묶어주고 나면


xxxxxxxxxx
s = '안녕하세요. 새해 복 많이 받으세요. 글은 2021-01-06에 썼어요'
m = re.search('([0-9]{4})-([0-9]{2})-([0-9]{2})', s) // ()로 세번 묶어줌. 
print(m.group(0)) // 출력결과 : 2021-01-06
print(m.group(1)) // 출력결과 : 2021
print(m.group(2)) // 출력결과 : 01

group(0) 을 쓰면 정규식과 일치하는 모든 문자를 다 가져온다.

group(1) 은 정규식과 일치하는 첫번째 문자를 찾아서 가져온다.

group(2)는 두번째, group(3)은 세번째인 식이다.

여기서는 2021이 첫번째 패턴인 ([0-9]{4}) 과 일치하기에

group(1) 은 2021를 출력한다.

그룹으로 만드는 방식은 우편번호 앞자리만 찾거나, 이메일의 도메인만 찾는다든지 할때 유용하다.

사실 그룹 기호가 섞인 정규식은 처음에 보면 꽤 헷갈리는데

() 없는 정규식을 만들어보고, 내가 () 기호를 써서 정규식을 만들어보는 식으로 연습하면은

점차 눈에 익게 된다.

메타문자 ( . ? $ )들을 원래 문자로 사용하기

물음표 (?)나 마침표(.)는 원래 문장에서도 쓰이는데 메타 문자로 쓰이고 있다.

이 메타문자들을 문자열로 쓰고 싶다면 앞에 \를 붙여주면 된다.


xxxxxxxxxx
s = '오늘은 안녕하세요.안녕하세요?'
m1 = re.search('안녕하세요\?', s)
print(m1.span()) // span은 일치하는 범위를 말함. span - (10, 16)
print(m1.group()) // 출력결과 : 안녕하세요?
m2 = re.search('안녕하세요?', s)
print(m2.span()) // span - (4, 9), 위와는 span이 다르다.

위의 예제를 보면 \? 를 쓰는가, ? 를 쓰는가에 따라

패턴이 매칭되는 곳이 달라진다.

m1에서는 \?가 패턴이기에 실제 ?가 있는 곳에서 매칭이 되지만

m2는 ?는 메타문자이기에 앞쪽, 물음표 기호가 없는 곳에서 매칭이 된다.

\문자 - 자주 쓰는 패턴을 나타낼때 사용한다

\d : 숫자인 경우, [0-9]와 같다
\D: 숫자가 아닌 경우, [^0-9] 와 같다.
\s: 공백 문자인 경우. 띄어쓰기나, 탭 (\t ), 새로운 줄(\n, \r)인 경우
\S : 공백 문자가 아닌 경우
\w: 숫자 및 알파벳 문자인 경우. [a-zA-Z0-9_] 와 같다
\W: 숫자 및 알파벳 문자가 아닌 경우. [^a-zA-Z0-9_] 와 같다

3.자주 쓰는 정규표현식 표현

이메일 찾기

문서에서 이메일만 찾고 싶을때가 있다.

이메일은 '@' 기호가 꼭 들어가고 영어 알파벳으로만 되어있다.

이를 고려하면 정규식은[\w]+@[\w]+ 처럼 될 것이다.

[\w]+ 은 알파벳이 1개 이상 있을때, 일치하는 걸로 본다는 뜻이다.

그런데 [\w]+@[\w]+만으로는 이메일을 모두 찾을 수 없다.

이메일에 . - 가 들어가 있는 경우가 있기 때문이다.

. -가 있어도 이메일을 찾을 수 있게 정규식을 바꾸면

[\w\.-]+@[\w\.-]+ 가 된다.


x
s = 'Ryan has sent an invoice email to john.d@yahoo.com by using his email id ryan.arjun@gmail.com and he also shared a copy to his boss rosy.gray@amazon.co.uk on the cc part.'
m = re.findall(r'[\w\.-]+@[\w\.-]+', s)
print(m) // 출력 결과 : ['john.d@yahoo.com', 'ryan.arjun@gmail.com', 'rosy.gray@amazon.co.uk']

맞는 이메일인지 확인하기

회원 가입 페이지를 만들다 보면

맞는 이메일을 입력했는지 확인할 필요가 있다.

이때도 정규표현식을 쓰면은 편리하다.

일반적인 이메일은 알파벳및숫자@도메인이름 으로 되어 있다.

도메인 이름은 abc.com 처럼 com이나 co.kr 로 끝나는 주소를 말한다.

알파벳및숫자@도메인이름 중에서 알파뱃및 숫자를 정규식으로 표현하면 [a-z0-9]+ 이고

도메인 이름을 정규식 표현하면 \w+[.]\w+[.]?\w$이 된다.

\w+[.]\w+[.]?\w{2,4}$ 에서 \w[.] 까지는 도메인의 앞부분 ( naver.com에서 naver. 까지의 부분 )을 찾기 위함이다.

그 뒤의 \w+[.]? 은 도메인에 . 이 2개인 경우 ( naver.com은 .이 한개이지만, kbs.co.kr은 .이 두개이다 )를 찾기 위함이다.

[.]? 은 . 이 있을 수도 있고 없을 수도 있다는 의미이다.

마지막으로 com, org, uk, kr 등의 최상위 도메인의 길이를 확인하면 되는데

\w{2,3}$ 정규표현식으로 확인하면 된다.

이를 다 합치면 정규식 ^[a-z0-9]+[\._]?[a-z0-9]+[@]\w+[.]\w+[.]?\w{2,3}$ 이 된다


x
def valid_email(email):
    regex = r'^[a-z0-9]+[\._]?[a-z0-9]+[@]\w+[.]\w+[.]?\w{2,3}$'
    valid = re.search(regex, email)
    if valid:
        print('valid email')
    else:
        print('invalid email')
    return valid
email = "mysite.com"
valid_email(email) # 제대로 된 이메일이 아님
email = "mike@korea.co.kr"
valid_email(email) # 제대로 된 이메일
email = "mike@daum.net"
valid_email(email) # 제대로 된 이메일
email = "mike@good"
valid_email(email) # 제대로 된 이메일이 아님

한글 찾기, 한글 제거

한글 찾기는 []를 사용한다.

알파벳을 찾을때 [a-z] 를 써서 찾은 것처럼 [ㄱ-힣] 를 쓰면 한글을 찾을 수 있다.


xxxxxxxxxx
s = '한글이에요. good morning. 안녕하세요'
m = re.findall('[ㄱ-힣]+', s)
print(m) // ['한글이에요', '안녕하세요']

마무리

정규표현식은 처음 배울때 난이도가 있지만

익혀두면 프로그래밍 언어에 상관없이 쓸 수 있어서 활용도가 높다.

간단한 식부터 써보면서 차근차근 익혀보도록 하자.

참고글 - 이메일 정규표현식으로 맞는지 확인하기

유용한 사이트 1 - 정규표현식 요약표 (Reg Cheet sheet)

유용한 사이트 2 - 온라인 정규표현식 연습 사이트

처음 개발 시작하는 이들을 위한 6단계 로드맵

에드 신 — Tue, 15 Sep 2020 15:24:00 +0900

프로그래밍을 배우게 되면 분야에 따라서 조금은 다르지만 크게 6가지 과정을 거치게 된다.

일단 기본기를 쌓고, 실무에 쓰이는 프레임워크 등을 배우며 개발을 맛보게 된다.

이 과정은 순서대로 이뤄지기는 하지만, 한번에 끝나는 건 아니다.

한번 진행되었다가, 이전 단계로 돌아가서 첨부터 시작하는 경우도 종종 있다.

그럼 큰 그림에서 이 단계를 이해해 보자.

1.기본 문법 배우기

프로그래밍 기본 문법을 배우는 기간이다. 변수, 클래스, 함수 등을 이해하는 시간이다 .

이 과정에서 프로그래밍 언어를 처음 설치해보고, 각종 개발 툴도 처음 써보게 된다.

어떤 언어를 쓰느냐에 따라 이 과정이 빨리 끝나기도 하고, 길게 걸리기도 한다.

파이썬의 경우 1주일이 안 걸리는 경우가 대부분이고, 자바의 경우 1달 넘게 걸리는 경우도 흔하다.

내가 빠르게 배울 수 있는 동적 타이핑 언어 (파이썬, 자바스크립트) 등 택했다면

좀 더 기본을 탄탄하게 하는 게 좋고,

배우는 데 시간이 걸리는 정적 타이핑 언어(자바, C, C#, C++, 코틀린, 다트 등)를 골랐다면

클래스 정도까지 배운 뒤 프레임워크를 익혔다가 다시 문법 공부하는 게 나을 수 있다.

보통 정적 언어 문법 배우다 지치는 경우가 많기 때문이다.

2. 프레임 워크 사용 방법 배우기

컴퓨터 공학과를 간다면, 프레임워크 대신에 알고리즘이나 자료구조를 배우겠지만

독학하거나 학원을 가는 경우 여기로 오게 된다.

자바의 스프링이니, 스위프트의 iOS, 모바일의 안드로이드니, 자바스크립트의 리액트니 하는 것들은 모두 다 프레임워크다.

프레임워크는 프로그래밍 언어 문법을 쓰기는 하지만 나름의 규칙이 있다.

이 규칙들은 개발 환경( 모바일이냐 웹이냐, 급히 만들어야 했냐 따위 )이나 프레임 워크 개발사의 입맛에 따라 만들어진 경우가 대부분이다.

환경에 대한 지식은 물론, 프레임워크 자체에 대해서도 배워야되는 순간이다.

대게는 프레임워크 개발사 홈페이지에 들어가서 공식 문서를 보는 게 제일 확실하다.

하지만 처음에 공식 문서를 보는 건 정말 난감하다. 공식 문서가 있다는 것 정도만 기억하고 '강의'를 보는 걸 추천한다.

책도 좋지만, 책은 처음에는 너무 오래걸린다.

특히 UI를 쓰는 프레임워크 ( 리액트, 안드로이드, ios, 플러터 등 )은 화면을 보면서 따라하는 게 효과적이다.

보통 프레임워크를 훑어보는데 1~2달 정도 걸리는 편이다.

여기서는 훑어본다는 말을 했는데, 처음에는 따라하느라 급급해 배우긴 배웠지만

실제로 이해는 못하고 있는 상황이기 때문이다. 꼭 내가 시간을 들여서 따로 프로젝트를 해보아야한다.

프레임워크를 배우는 과정에서 중간 중간에 문제 풀이를 많이 해보는 것도 중요하다.

따로 문제가 있는 수업이면 더 좋고, 없다면 오늘 들은 수업을 내 마믐대로 바꿔보는 걸 추천한다.

예컨데 오늘 화면을 그리는 수업을 했다면, 화면을 내 생각대로 조금씩 바꿔보는 것이다. 함수 이름을 바꿔도 되고, UI의 위치를 수정해 보아도 좋다. 그 과정에서 검색도 조금씩 해보게 되는데 이게 실제 개발에 가까워지는 과정이다.

3. 프레임 워크 사용해서 간단한 포트폴리오 만들기

보통 프레임워크를 강의 등을 통해 배웠더라도 실제로 못 써먹는 경우가 상당히 많다.

이건 지식을 완전히 내것으로 하지 못했기 때문이다.

보통 들어서 아는 지식과 내 것인 지식은 큰 차이가 있는데,

들어서 아는 지식은 내가 떠올리려고 하면 잘 생각이 안나지만, 누가 말하면 이야기할 수 있다.

내 것인 지식은 누가 말안해도 쉽게 꺼내서 쓸 수 있는 걸 말한다.

한마디로 책이나 강의를 보지 않고 웹사이트, 앱, 서버를 만들 수 있는 단계를 말한다.

처음부터 이 단계에 도달하는 것은 어렵다. 따라서 아주 작은 프로젝트 (포트폴리오)부터 만드는 게 필요하다.

내가 웹을 배운다면 3페이지짜리 간단한 웹을 만들어보겠다. 로그인도 없고, 회원가입도 없다.

이 첫 웹페이지를 만들면 일단 아무데라도 호스팅을 해서 올려보겠다.

첫 웹사이트가 어떻게든 돌아가는 상태가 되면, 프로젝트 규모를 키워보자.

지도 기능을 넣어볼 수도 있고, 회원 가입 기능을 넣어볼 수도 있다.

이전에 3페이지를 만들었다면 이번에는 5~6페이지정도 만들어보자.

두번째 사이트가 만들어지면 세번째 사이트를 만들어보자.

이번에는 좀 더 과감하게 글쓰기나 검색 기능을 넣어볼 수 있다.

아니면 게시판 같은 걸 만들어보아도 좋다.

여기서 포인트는 작게 만들되 완성을 하고, 좀 더 크게 만드는 것이다.

이 과정을 통해 자연스럽게 지식이 내것이 되고, 개발 숙련도가 올라간다.

이 때 괜히 스케일을 엄청 크게 해서 좌절하지 말자.

여러분이 보는 서비스는 대게 많은 개발자들이 몇년씩 만든 것이다.

너무 기획에 힘주지 말고, 기존에 있는 디자인이나 서비스를 따라하는 걸 권한다.

보통 이 과정이 1~3개월 정도 걸린다. 컴퓨터 학원들은 여기까지 하고 끝나는 경우가 대부분이다.

혹은 2번째 단계에서 끝나기도 한다. 일반적으로 3번째 단계까지 하면 취업은 그럭저럭 하는 편이다.

빠른 취업이 목표라면 3단계까지 빠르게 마무리하는 걸 권한다.

4.컴퓨터 공학 기초 지식 채우기

보통 프레임워크를 배우다보면 전반적인 컴퓨터 공학 지식을 얕게 배우게 된다.

프레임워크는 모두 다 컴퓨터 공학에 기초를 두고 있기 떄문이다.

프레임워크로 개발을 시작한 사람들은 2부류로 나뉘는데 하나는 적당히 돌아가는 코드에 만족하고, 막히면 스택 오버플로우를 뒤지는 스타일이다. 다른 하나는 원리까지 알고 해결하려는 스타일이다.

대게는 후자가 시간이 갈수록 개발을 잘하는 편이다.

전체 컴퓨터 공학을 다 배우는 건 시간이 없는 상태에서는 어려운 일이다.

컴퓨터 공학을 전반적으로 빠르게 훑어볼 수 있는 '컴퓨터 과학 입문' 개통을 읽어보기를 권한다. 보통 대학교 1학년 필수 과목으로 지정되어 있다.

시간이 있다면 컴퓨터 공학 전공 과목을 10개 정도 다 보는 것도 좋다.

알고리즘, 자료구조, 데이터베이스, 운영체제, 이산수학, 네트워크, 컴퓨터 구조 등의 전공서적을 다 보는 것이다.

보통 이 과정에 1개월 ~ 1년 정도 걸리는데, 프로젝트 하기와 병행하기를 권한다. 이것에만 집중하기에는 시간이 너무 오래걸리기 때문이다.

대게의 컴퓨터 공학과 출신들은 4단계까지 하고 취업을 한다.

일부 기업에서 불평을 하는 컴퓨터 공학과 학생들은 1단계와 4단계만 하고 일자리를 구한다.

5. 다른 사람의 소스 많이 보면서, 패턴 배우기

남의 소스를 많이 보다보면, 많이 배운다.

내가 무작정 코드를 작성하는 것도 좋지만, 이게 맞는 게 틀린건이 확신하기 어렵다.

다행히도 온라인 상에 제대로 짜인 코드가 엄청나게 많다.

구글 같은 거대 IT 기업이 친절하게도 최상급의 코드를 공개해놓고 있다.

여기에 오픈소스는 말할 것도 없다.

이 소스들을 내가 이해할 수 있는 선에서 읽어보며 분석해보자.

따라해보는 것도 나쁘진 않지만 너무 많은 시간이 드니 읽어보면서

이 사람들은 패키지를 이렇게 나누었고, 클래스는 여떤 식으로 나누었는지 읽어보기를 권한다.

내가 본 코드들이 바로 내 코드에 적용은 안되겠지만 어느정도 큰 그림은 잡을 수 있을 것이다.

틈틈히 디자인 패턴 등을 보아도 좋다. 하지만 너무 깊게 들어가지는 말자.

보통 패턴이란 건, 어떤 문제를 계속 경험하다보면 눈에 들어오게 되는 것이다. 그 문제들의 해결책을 모은 게 패턴이다.

그렇기에 패턴은 경험 있는 사람들이 보면 훌륭한 해결책이지만 초보들이 보기에는 이해가 잘 안될 수가 있다.

왜 써야되는지 크게 와 닿지 않을수가 있다. 나중에 봐야겠다는 생각정도만 가져도 충분하다.

6. 프로젝트 많이 하기 (출시 등)

실무를 하는게, 공부만 하는 것보다 낫다는 말을 한다.

대게는 맞는 말이다. 실무를 하다보면 공부할 때는 적당히 넘어가는 일들도

다 해결하고 넘어가야 되기에 문제 해결 능력이 좋아질 수 밖에 없다.

또한 깊은 실용적 지식일수록 책이나 강의에는 안 적혀 있을 가능성이 높다.

직접 일 하면서 배우는 게 중요하다. 직접 일을 하는 게 힘든 상황이라면 최대한 실제 상황과 유사하게 만들어가야한다.

실제 제품에 근접하게 코드를 만들수록, 의외의 문제를 만나고 그 문제를 해결하는 과정에서 실력이 좋아지기 때문이다.

마냥 프로젝트만 많이 한다고 실력이 늘지는 않는데, 기본이 없는 상태로 프로젝트의 양만 늘리거나

동일한 난이도의 프로젝트만 반복하는 경우가 많기 때문이다.

이 때는 의도적으로라도 자신의 프로젝트의 난이도를 조절하면은 좋다.

안 쓰던 라이브러리를 써본다든지, 안 써본 언어를 써본다든지, 한 언어로 짜인 코드를 다른 언어로 바꿔본다든지, 프론트 엔드 개발자인데 백엔드쪽을 해본다는지 하는 식으로 말이다.

난이도를 높였다가 낮추는 과정에서 내 원래 분야의 이해도도 올라가게 된다.

세부적으로는 다른 면이 있더라도, 각각의 분야들은 하나의 뿌리에서 나왔기 때문이다.

이 과정은 끝이 없기에 따로 기간은 적지 않겠다.

기타. 더 깊게 배우기

이 단계가 되면 특별히 정형화된 공부방법은 없다.

개발 방법론을 찾아볼 수도 있고, 각종 개발도구를 추가적으로 배워볼 수도 있다.

혹은 일반 개발원리 ( 클린코드나 아키텍처) 같은 걸 보면서

더 나은 개발은 무엇인지 연구해볼 수도 있다.

예전에는 잘 모르고 넘어갔던 프레임워크를 더 깊이 공부하기도 하고

적당히 쓰기만 했던 프레임워크 내부나 리눅스 커널을 뜯어보기도 하고

테스팅을 배워볼 수도 있겠다.

이 글을 쓰게 된 건 수업을 하다가 어디까지 공부해야

개발자로 취업할 수 있나요란 질문을 받아서이다.

예전부터 많이 듣던 질문이라 글로 한번 정리해보았다.

큰 그림을 잡는 데 도움이 되었으면 하며, 글을 마친다.

내가 개발을 배워온 과정 - 3부 어둠 속의 희망

에드 신 — Sun, 26 Jul 2020 22:37:44 +0900

사실 29살때 있었던 일은

여지껏 누구에게도 잘 말하지 않았다.

생각을 하는 것만으로도

우울한 맛이 있었기 때문이다.

이 글은 개발자로 취업하려는

비공대생들에게 많은 도움이 될 것이다.

사람들이 쉬쉬하는 진실을 다루고 있기 때문이다.

화려한 광고에서는 말하지 않는 이야기다.

그럼 5년 전으로 돌아가보자.

나는 학원을 마치고

바로 취업를 시도하지는 않았다.

아직 공부할 게 더 많이 남았다고 생각했기 때문이다.

학원은 12월 초에 끝났다. 포트폴리오도 만들었지만 좀 더 공부하기로 결정했다.

컴공 과목을 공부하면 좋다 생각해

네트워크, 운영체제, 데이터 베이스 전공서적을 구해서 읽었다.

그 외 이산수학이나 컴퓨터 구조, 디자인 패턴 책도 짬짬이 읽었다.

이때 대략 10개 정도 컴공 과목을 공부했는데

커리어적으로는 별로 좋은 선택은 아니었지만

개발 실력을 탄탄하게 하는 데 있어서는 좋은 선택이었다.

학원에서 네트워크 프로그래밍을 하기는 했지만

주로 구현이 치중했고, 이론은 깊이 다루지 않았다.

내가 네트워크를 따로 공부해두지 않았다면

나중에 블루투스 (BLE)를 개발할때 디버깅을 아예 못했을 것이다.

운영체제를 공부하자

학원에서 따라서 쳤던 스레드가 왜 필요하고 어떻게 쓰이는지 알았다.

만약 내가 바로 일을 시작했다면, 메모리나 스레드 관리의 필요성을 몰랐을 수도 있다.

사실 커리어적으로는 학원이 끝나자마자 바로

아무데나 취업하는 게 좋았다.

일단 경력이 1이라도 있는 것과

아예 없는 것을 사람들은 달리보기 마련이니깐.

( tip - 오랫동안 개발을 하려면 컴공 과목을 배워보자 )

3월이 되자

일반적인 기업을 위주로 지원을 했다.

이 선택은 상당히 잘못된 것으로 드러나게 된다.

지금이었으면은 절대 택하지 않을 방식이다.

세상 사람들은 많은 편견이 있다.

그 편견에 의해 때론 이득을 보기도 하고, 때론 손해를 보기도 한다.

공식적인 경로로 취업을 하는 건

내가 택할 수 있는 방법 중에서도

가장 안 좋은 수였다.

만약 지금이라면

우회적인 방법을 택할 것이다.

이미 자리를 잡은 개발자들을 만날 수 있는 모임이나 스터디를 나갈 것이고

컨퍼런스 등에서 유명한 개발자들에게 다가가 질문을 할 것이다.

그러며 조언을 구할 것이다.

직접 만날 기회가 생기면 넌지시 일자리를 구하는 법이 있는지 물어볼 것이다.

일자리 추천을 받을수도 있고, 적어도 유용한 조언을 들을 수 있다.

당장 일자리는 생기지 않더라도 나중에 제안을 받을 수도 있다.

사람들은 한번이라도 만나본 사람을 완전한 타인보다 선호하기 마련이다.

혹은 블로그나 책을 쓴 사람에게

연락해서 질문을 해볼 수 도 있다.

대게 그런 사람들에게는 제안이 많이 들어오기 마련이다.

그 사람에게는 안 맞더라도 나에게는 꽤 괜찮은 제안일 수도 있다.

아니면 잡코리아나 스타트업 채용 공고들을 뒤져서

내 기술 스펙이랑 비슷한 회사의 리스트를 뽑아보겠다.

그래서 내 장점을 어필하는 메일을 가능한 많이 보내볼 것이다.

하지만 나는 그러지 않았다.

당시에 나는 채용공고가 유일한 길인 줄 알았기에

다른 방법을 찾지 않았다.

3월이 되자 지원을 시작했다.

이름난 기업부터 시작해 덜 유명한 기업도 모두 지원했다.

이래저래 지원을 많이 했는데 연락이 오지 않았다.

당당했던 자신감은 사라진지 오래였다.

개발 공부는 계속하고 있었지만

연이은 서류 탈락에 조금씩 회의감이 들었다.

당시에는 주로 아침 9시 정도에 학교에 나가서

밤 11시 정도에 학교를 떠났다.

워낙 오래 학교에 있다보니

회계사 시험 준비하던 친구와 자주 마주쳤다.

서로 열심히 한다고 칭찬하고 위로를 해주었던 기억이 난다.

서류 준비와 개발 공부를 하고
남는 시간엔 컴퓨터 공학과 수업을 도강하기도 했다.

'인공지능'이랑 '데이터 마이닝' 수업이었는데

절반은 호기심에 절반은 컴퓨터 공학과에서 대체 무슨 수업을 하나 궁금해서 들었다.

처음엔 약간 어려웠는데

수업에서 쓰는 교과서를 구해서

미리 예습을 하니 들을만 했다.

도강을 했지만 끝까지 걸리진 않았다.

공대생 비슷한 나의 얼굴이 한 몫 한 것 같다.

거의 4개월 동안 아무 성과없이 6월말이 되었다.

나의 실력은 좋아지고 있었지만

자존감이 정말 많이 떨어졌다.

지금 같으면 작은 기업 위주로 찾아보거나,

제 3의 길을 찾아서 취업을 했겠지만

그때는 내 노력이나 실력이 부족했다고 생각했다.

그래서 지금도 나는 무작정 노력 하라는 말을 별로 좋아하지 않는다.

나에게 필요한 건, 올바른 방법과 조언이었다.

7월 즈음되자 회의감이 많이 들었다.

나는 왜 이런 사서 고생을 했는가.

혼자 도서관에 앉아 있는데 괜히 서러움에 눈물이 나오곤 했다.

개발을 더 해야될지 말지 고민이 되었다.

때론 2014년이었고, 코딩을 하는 것 자체가 어리석은 것으로 비춰지던 떄였다.

나는 단호한 마음으로 시작했지만

주변의 모든 신호들이 아니라고 했다.

사실 나도 2달 정도 개발을 놓고 지냈다.

뭘할지 모르는 상황이라 아무거나 흥미 가는 걸 공부했다.

그때 내가 공부한 건 '기초 물리학'이었다.

당시 공대쪽은 적성검사에서 '과학' 지식을 물어보는 경우가 흔했고

나는 시험 통과를 위해 과학 공부를 약간했다.

고1 이후로는 과학책을 본 적이 없었으니 12년만에 한 것이었다.

바로 공대생들이 보는 책을 보기는 어려워

'수학 없는 물리' 라는 책을 보았는데 비유와 그림이 많아

재밌게 읽었다.

물리에 대해 좋은 기억이 있어

2달 동안은 기초 물리를 공부하면서 지냈다.

대학물리책도 보고, 전자 기학 책도 살짝 보았다.

지금 생각해도 뜬금없는 결정인데

시간을 마냥 보내기보다는 아무거라도 하는 게 낫다고 생각했다.

공부할때는 몰랐는데 기초 물리를 배워둔 게

나중에 가상현실 게임을 만들어볼때 큰 도움이 되었다.

요즘은 게임 개발을 다 엔진으로 하지만

게임을 제대로 만드려면 기본 로직은 이해해야한다.

로직들은 다 물리를 기반으로 만들어졌다.

약간은 물리를 알아야

3D 물체의 이동, 각도 계산, 쿼터니언, 그래픽스 이론 등을

이해할 수 있다.

잠시나마 게임 개발에 도전해볼 수 있었던 건

이때 물리를 배워둔 덕분이었다.

하지만 그때 당시 나는 게임을 만들 생각이 1도 없었다.

난 물리책을 현실 도피용으로 읽었다.

누군가 이 일이 먼 훗날 도움이 될거라는 이야기를 해도

막상 어려움에 처해있는 당사자는 전혀 공감이 안 된다.

현재의 고통이 너무나도 크기 때문이다.

하지만 정말로 쓸데없을 것만 같았던 경험도

당시에 최선을 다했다면 도움이 되는 순간이 분명히 온다.

나는 그 사실을 분명히 말할 수 있다.

때로는 불운이 행운이고, 행운이 불운이다.

8월말이 되어 새로운 취업 시즌이 되었다.

난 계속 개발을 할지 말지 고민을 했다.

그러다 우연히 "싱가폴에서 개발자 모집. 알고리즘 시험 통과하면 연봉 6천만원"이란 공고를 보게 된다.

나는 이 공고를 보고 눈이 멀었다.

고백하겠다.

내가 개발자를 다시 하겠다고 마음 먹은 것은

6천만원이 탐이 나서였다.....

이 회사의 알고리즘 시험을 준비하면서

오랜만에 코딩을 했다.

문제를 풀어가는 과정도 흥미로웠고

코딩에 몰입하는 순간이 좋았다.

외부적인 요인때문에 개발을 잠시 놓았지만

아직도 개발에 대한 관심과 애정이 남이 있었다.

아쉽게도 알고리즘 시험은 떨어졌다.

내가 2달간 코딩을 손에서 놓지 않았다면

충분히 통과했을 거란 확신이 있었다.

이 일을 계기로 전략을 바꿨다.

전공 지식을 테스트하는 곳만 지원하기로..

개발자의 세상은 실력 위주라 들었고

난 공고를 보고 채용과정에

'필기테스트'와 '기술면접'이 포함되어 있으면 지원을 했다.

나의 예상은 반은 맞았고, 반은 틀렸다.

난 대부분 기술면접까지는 통과를 했다.

문제는 최종면접이었다.

내게 들어온 질문들은 비슷했다.

"경영학과인데 잘 할 수 있나요?"

"경영학과인데 사업을 하러 갈 것 아닌가요?"

"알고리즘이 무엇인지 아나요?"

나는 더 공부를 많이했다는 이야기를 했고

자신이 있다는 어필을 했지만 소용없었다.

마치 나는 '친환경 세제'와 같았다.

똑같은 세제라고 해도 친환경이라고 하면

거품도 덜나고, 잘 안 씻길듯한 이미지가 있다.

돌이켜보면 나는 2가지 중 하나를 택해야했다.

실력을 압도적으로 키우거나

실력에 대한 의문을 부드럽게 해소하거나.

근데 나는 둘 다 못했다.

신입 개발자에게 필요한 실력이 1이라면

난 1.2 ~ 1.5 정도의 실력은 있었다.

문과생에 대한 선입견을 생각할 떄

3~4정도는 실력이 있어야했다.

난 그 사실을 몰랐다.

아니면 좀 더 부드럽게 면접관을 설득할 방법을 고민했어야했다.

지금은 웬만하면 개발 이야기를 많이 하거나

개발 지식을 어필한 뒤에

전공 이야기를 한다.

일단 개발 잘할듯한 이미지가 생기고 나면

전공을 말해도 상관없다. 오히려 플러스가 된다.

하지만 반대로 말하면

의심 가득한 표정을 보게 된다.

같은 내용이어도 순서에 따라

다른 결과가 나온다.

( tip - 사람들은 비논리적이고 개발자들도 예외는 아니다 )

어쨌든 다시 취업 과정으로 돌아가보자.

월화수목 최종면접을 보고

다 떨어지는 상황이 계속되니

멘탈이 완전히 너덜너덜 되었다.

원래 정신이 약한 사람은 아닌데

이때는 정신이 꽤나 약해졌었다.

12월말이 되었다.

마지막으로 기대했던 곳에서

탈락 통보를 받았을 때의 기분이란..

세상에 대한 원망이 없었다면

거짓말일 것이다.

내가 악플러가 아니라 개발자가 된 건

어느 순간 생긴 자각 덕분이었다.

어떠한 일을 계속해서 하게 되면

작은 변화가 생겨난다.

나는 이것을 '정체성'이라고 부른다.

내 스스로는 인식하지 못했지만

나 자신을 '개발자'로 보고 있었다.

근 1년여간 개발을 공부하는 과정에서

개발 자체가 하나의 일상이 되었고

포기할 수 없는 한 부분이 되었다.

자신을 농부로 인식한 사람은

비가 와도 농사를 짓고, 가뭄이 와도 농사를 짓는다.

자신을 화가로 생각하는 사람은

붓이 망가져도, 새로 붓을 사든, 붓을 만들어서든 그림을 그린다.

어떤 어려움이 왔을 때

관두지 않는 건 '정체성'때문이다.

나중에 내가 코딩을 가르치면서 알게 된 건데

현재 실력이랑 상관없이 계속 하는 사람도 있고

금방 포기하는 사람도 있다.

난 처음에는 끈기의 차이라고 생각했다.

아니었다.

포기 하지 않는 사람들은 '진지하게 개발이 필요하다'고 생각하는 사람이었고

쉽게 포기하는 사람들은 '개발 공부가 유행하니 배워보자'는 사람이 대부분이었다.

한쪽은 절반정도 '개발자'의 정체성을 가지고 시작하는 반면

다른 한쪽은 아니었다.

작은 마인드 차이지만 결과는 많이 달랐다.

내가 이걸 깨달은 건 한참후이다.

12월말 결과가 나온 뒤 생각을 바꿨다.

일단 나는 아무곳이라도 가서

일을 해보자고 마음 먹었다.

1년전에 했으면 좋았을 결정이었다.

당시 학교에서는 스타트업이나 중소기업과 인턴 연계 프로그램을 진행하고 있엇다.

그 중 SNS 앱을 만드는 회사에 지원을 했다.

다운로드 10만정도가 있는 곳이었다.

학교에서 일부 금액을 지원해주고, 회사에서는 20만원을 주는 조건이었다.

12월 말에 면접을 보고, 12월 30일 경에 출근을 했다.

직책은 안드로이드 개발 인턴이었다.

회사 인원은 10여명 정도였고

개발자는 나까지 3명이었다.

안드로이드와 서버를 담당하는 CTO겸 공동창업자가 있었고

아이폰 ( ios) 를 담당하는 사람이 한명 있었다.

실제로 출시된 앱의 코드를 보는 건 처음이었다.

첫 임무는 간단한 편이었다.

앱의 UI를 일부 고치는 것이었다.

두번째 임무는 지금생각해도 살짝 난감한 것이었다.

SNS에 영상 업로드 기능을 추가하려고 하는데,

영상 길이에 제한을 두고 싶다고 했다.

10초 까지만 영상을 올릴 수 있게

영상 편집 기능을 넣어달라고 했다.

아이폰은 금방 했다고 했다.

이전에 산업협력으로 인턴들이 다 만들어 두었으니

그 소스를 고치기만 한다고 하였다.

하지만 실제 소스를 열어보니 동작하지 않았고

깃허브에서 적당히 가져다 붙인 것이었다.

처음에는 안드로이드에서 mp4를 자를 수 있는 라이브러리를 써서 했었다.

약간의 어려움은 있었지만 잘 돌아가는 걸 확인했다.

하지만 mp4 만 지원해서는 안 된다는 이야기를 들었고

다른 확장자도 자를 수 있어야 한다고 했다.

하지만 자바 라이브러리 중에 영상을 자를 수 있는 라이브러리가 없었다.

C 라이브러리를 써야만 했다.

결국 NDK를 써야했다.

NDK는 안드로이드에서 C나 C++를 쓸 수 있게 해준다.

내 작업환경은 윈도우였기에 NDK를 바로 쓸 수 없었다. 시그윈을 써서 작업을 했다.

시그윈은 윈도우에서 리눅스 터미널을 쓸 수 있게 해주는데 실제 리눅스와는 미묘하게 다르다.

맥이나 리눅스에서 했으면 좀 더 쉬웠을 수도 있다.

내가 겪은 에러의 상당수는 시그윈 때문이었다.

CTO겸 공동창업자도 NDK나 FFMpeg은 다뤄본 적이 없었기에

혼자서 끙끙대면서 작업을 했다.

CTO에게 질문을 해도 피상적인 답변만 들었다.

나는 인턴을 뽑게 되면

최대한 세부적으로 알려줘야겠다는 생각을 했다.

이 다짐을 1번은 지켰고, 1번은 지키지 못했다.

인턴일은 작업량이 상당했다.

안드로이드도 해야하고, C도 만지고, NDK도 만져야되서 상당히 스트레스를 받았다.

썼던 C 라이브러리는 FFmpeg 이었는데 역시나 처음 보는 것이었다.

9시에 나와서 10시나 10시 반까지 작업을 했다.

할일이 너무 많아 주말에도 거의 일을 했다.

포기를 하려고 몇번이나 생각했는데

이상하게 관두려할때 즈음 조금씩 진전이 있었다.

한달 좀 넘게 지나서 기능 구현을 했다.

안될 것 같았는데 어떻게든 한 것이다.

기능 구현을 다 끝내고 고민을 많이 했다.

물어봐도 답이 없는 상황에 지쳐 있었다.

약속된 2달을 채워야하는 게 아닌가

고민을 했다.

그래서 CTO와 면담을 했다.

주 내용은 회사에서 주는 돈은 20만원인데

업무 내용이 너무 과한것 아니냐

야근도 지나치게 많다는 이야기였다.

내가 들은 답변은 이랬다.

"IT 회사는 원래 이래요"

나는 조용히 짐을 쌌다.

약 5주간의 인턴 생활을 마치고 고민을 했다.

당당히 나오긴 했지만 미래에 대한 확신이 하나도 없었다.

그때가 2월 초였다.

나는 바람을 쐴 겸 강남쪽을 갔다.

여기저기 정처없이 돌아다니다가

삼성전자 스토어에 들어가게 된다.

스토어에선 '갤럭시 VR'을 전면에 놓고 홍보하고 있었다.

나는 가상현실에 대해서 들어보기는 했지만

실제 접한 건 처음이었다.

VR을 처음 써보고 놀라움을 금치 못했다.

이런 신세계가 있었다니.

집에 돌아와서도 VR 생각이 머리를 떠나지 않았다.

내가 직접 만들어보면 어떨까?

'유니티'를 쓰면 VR 개발을 할 수 있단 걸 알게 되었고

유니티 책을 찾아서 읽었다.

전에 잠깐 도서관에서 유니티 책을 빌려본 적이 있었는데

이해가 안 되어, 읽다가 반납을 했다.

하지만 이번에는 결심도 달랐고 다른 책을 골랐다.

전의 책은 유니티의 기능을 설명만 했는데

다른 책은 처음부터 따라하면 3D 총싸움 게임(FPS)이 만들어지는 구성이었다.

앞의 100쪽은 미니 2D 게임 하나, 중간의 100쪽은 3D 게임 하나, 나머지 300쪽에선 3D 총싸움 게임을 만든다.

프로젝트 형식으로 된 책을 따라하니

만드는 재미가 있었다.

기능만 설명하는 책을 보면

이걸 어떻게 합쳐야할지 감이 안온다.

프로젝트 형태였기에

아주 아주 작게나마 게임을 만드는 경험을 할 수 있었다.

( tip - 초보라면 기능보다는 프로젝트 위주의 책을 고르자 )

책을 보고나서 간단히 게임을 만들기 시작했다.

책만으로 배운 것이기에 진도가 잘 나가지는 않았다.

그러다 우연히 오큘러스 잼이란 공모전을 알게 된다.

페이스북이 오큘러스를 인수한 후 VR 게임을 늘리기 위해

대회를 연 것이다.

팀원을 모집해야되나 고민하고 있을 무렵

네이버 까페에 올라온 글을 보게 된다.

3D 모델링 디자이너인데

같이 할 팀원을 구한다는 내용이었다.

게임의 컨셉은 비행기 VR 슈팅 게임이었다.

작은 비행기가 바다를 돌아다니면서

적 비행기를 잡고, 마지막에는 보스(배)를 처리하는 게임이었다.

공모전에는 스테이지 1개까지만 만들고 제출하고

상황에 따라 더 만들 계획이라고 했다.

디자이너 분을 만나서 대화를 나눈 뒤 같이 하기로 했다.

VR개발은 어려운 점도 있었지만

즐거운 점이 훨씬 더 많았다.

약간의 기술적 어려움은 있었지만 결국 다 돌파해냈다.

VR 개발의 가장 큰 문제점은

신기술이란 것이다.

신기술이었기에

딱히 검색해도 답이 안 나왔다.

페이스북이 적어놓은 공식 문서를 참고해서 개발을 했다.

사실 나는 이전까지는 책을 많이 활용했다.

이때 처음으로 책에 의지하지 않고 개발을 하는 법을 알게 되었다.

내가 구현한 기능들은 사실 기본적인 것들이었다.

비행기의 이동, 미사일 쏘고 맞았을때 처리하기,

아주 간단한 적 비행기 인공지능,

VR 멀미 줄이기, VR로 포팅하기 등등을 만들었다.

중간에 머리에 쓴 VR 기기가 미세하게

잘못 동작하는 문제가 있었다.

이틀 동안 끙끙거렸는데 답이 안 나왔다.

그러다 아주 작은 계산 실수가 있다는 걸 알고

고쳤더니 자연스럽게 돌아갔다.

그때의 희열이란..

무엇과도 바꿀 수 없었다.

가상현실 게임 개발을 하며

계속해서 개발을 하겠다는 강한 결심을 했다.

개발을 계속해야 되나 말아야 되나

고민을 하던 나에게 '빛'이 된 순간이었다.

루쉰이 쓴 소설 '고향'에는 이런 이야기가 나온다.

"원래 숲에는 길이 없었다.

사람들이 다니다 보니 길이 된 것이다.

희망도 같은 게 아닐까?"

나도 조금씩 길을 만들어 가고 있었다.

내가 개발을 배워온 과정 - 2부 두 갈래의 길

에드 신 — Tue, 21 Jul 2020 09:40:25 +0900

안드로이드는 책으로 시작했다.

1300쪽짜리 두꺼운 책을 사서 읽었는데

이해가 잘 되지 않았다.

원래 개발은 잘 이해가 되지 않은 것이란

생각이 있었기에 그냥 참고 읽었다.

돌이켜보면 나의 학습 방법이 문제였다.

안드로이드는 그래픽 위주 프로그래밍이다.

책을 차근차근 따라가는 것보다는 '영상'을 따라하는 게 훨씬 유리하다.

각종 UI를 책을 보면서 열심히 타이핑하고

책이랑 틀린지 확인하고, 나중에 실행을 해야한다.

또한 개발 툴에서 어디를 눌러야할지도 모르기에 열심히 찾아야한다.

이 과정에서 오타도 나기 마련이며, 엉뚱한 부분을 누르기도 한다.

이에 반해 영상은 어디에 UI를 배치할지,

어떤식으로 개발 툴을 다루면 될지 알려준다.

생각없이 따라하기만 하면 되는 것이다.

그래픽 관련 프로그래밍은

영상으로 배우는 게 책으로 배우는 거에 비해 5~10배는 쉽다.

다만 영상은 휘발성이 강해

꼭 복습을 해야한다.

이걸 아무도 알려준 적이 없었기에

나는 이해가 안 되는 책을 끙끙거리면서 읽었다.

게다가 고른 책도 문제였다. 안드로이드 기능(API) 위주로 설명이 되어 있었기에

책을 다 보더라도 앱을 하나 만들 수 없었다. 지금이라면 프로젝트 위주의 책을 골랐을 것이다.

어쨌든 대학 수업에 별 흥미가 없었기에

뒷자리에 앉아서 안드로이드 책을 열심히 따라했다.

만약 원래 전공에서 성적이 좋은 편이었다면

수업을 열심히 들었을 거 같다.

하지만 나는 학점이 안 높아

중간만 가자는 심정으로 딴짓을 했다.

낮은 학점이 포기하지 않은 원동력이 된 것이다.

그럭저럭 안드로이드 책을 다 따라하고 나니

6월말이 되었다.

안드로이드 책을 1번 다 따라하기는 했지만

이해도는 매우 낮은 상태였다.

내가 원하는 앱을 만들기는 커녕

책에 있는 내용도 기억이 잘 나지 않았다.

당시에 고민을 많이 했다.

내 주변 친구들은 취업준비를 하거나

인턴을 하고 있었다.

어디에 자기 소개서를 썼고, 면접을 보았는지 이야기를 많이 했다.

나는 사실 인턴도 거의 쓰지 않았는데

아직 뭘 할지 확신이 서지 않았기 때문이다.

지금 생각해도 믿을 수 없는 배짱이다.

좀 더 개발 공부를 해볼까, 원래 전공을 살려볼까 고민을 많이 했다.

친구들에게도 물어보았는데 대답은 한결같았다.

"컴퓨터 공학 전공을 한 사람도 있는데, 굳이 너를 쓸 이유가 있을까? 정신 차리고 전공을 택해"

이런 이야기를 많이 들었지만 천성적으로 반항을 잘하고

원래 전공을 안 좋아했기에 고민했다.

경영학 전공을 살리면, 마케팅이나 경영관리를 해야되는데 다 싫었다.

결국 나는 개발 공부를 좀 더 하기로 결정했다.

스터디만으로는 한계가 있는 듯해서 학원도 알아보았다.

7월 초부터 학원에 등록해서 다니기 시작했다.

역시나 친구들은 말렸지만, 초기 학원 생활은 나에게 큰 도움이 되었다.

지금 와서 보면 친구들도 무얼 모르는 상태에서 조언을 한 셈이었다.

실제 컴퓨터 공학과를 나온 사람중에서도 개발자가 되는 비중은 30% 정도 밖에 안된다.

친구들은 자신의 세계관을 바탕으로 대답을 했고

나는 우연히 맞아 떨어지는 선택을 한 것뿐이었다.

만약 공학 학위가 중요한 기계, 화학 분야의 일을 하려고 했다면 기회조차 얻지 못했을 것이다.

학원은 5개월간 다녔다.

지금이라면 유료 학원을 택했을 것 같지만

당시에는 거의 대부분이 국비 지원 학원이었다.

유료 학원 자체가 없었다.

그래서 개강일이 가까운 곳으로 골랐다.

아무 생각없이 골랐는데 상당히 운이 좋았다.

탁월한 선생님을 만난 것이다.

50대 중반이었던 걸로 기억하는데

30년동안 개발을 하고, 창업을 중간에 3번했다 실패한 분이었다.

신기술이 나오면 먼저 찾아보는 스타일이었고

책도 없던 2010년에 안드로이드를 배워서 가르치고,

스프링도 독학해서 은행권에 강의를 나가는 분이셨다.

지금 생각해도 믿을 수 없을만큼 열정을 지닌 분이었다.

학원에서 제일 늦게 가는 사람은 선생님이었다.

9시에 시작하는 학원인데, 9시 넘게 공부하고 계셨다.

사실 이런 선생님 앞에서

대부분의 것들은 핑계로 보였다.

사람은 자기 주변 사람을 닮아간다.

열정적인 선생님을 만날 수 있었던 건 행운이었다.

늦게라도 감사의 말을 드리고 싶다.

학원은 진도가 빠른 편이었다.

학원은 2주 만에 자바를 떼고, 2주 뒤에 데이터베이스를 익히고

2개월차에는 웹을 만들고 4~5개원에는 모바일을 하는 초스피드 압축 과정이었다.

첫주에 스레드를 배우고,

2주차에는 2D 슈팅 게임을 만드는

정신 나간 일정이었다.

아마 개발을 처음 배운 사람은 상당히 힘들어 했을 것이다.

다행히도 나는 미리 6개월 넘게 예습을 한 상태였고,

직접 개발하는 것을 옆에서 보니 이해가 더욱 빠르게 되었다.

선생님이 개발하는 것을 하나하나 따라하면서 몰랐던 개념을 익혀갔다.

객체지향이나 클래스 개념도 좀 모호한 상태였는데

선생님 설명을 듣고, 추천해주신 책을 읽으면서

정리를 확실히 할 수 있었다.

남들이 4년동안 하는 걸 1년내에 끝내야겠다는 생각을 했다.

학원은 9시에서 6시까지였지만, 끝나고도 계속 공부를 했다.

내가 공부한 건 주로 컴퓨터 공학과에서 배우는 과목들이었다.

개발을 잘하려면 대학에서 배우는 걸 배워두면 좋겠다는 생각을 막연히 했다.

이때 공부해 둔 게 구글링 할 수 없는 문제를 만났을때, 해결하는데 도움이 많이 되었다.

하지만 그건 3년 뒤의 일이었다.

컴퓨터 과목 중에서 알고리즘이 중요하다는 이야기도 들어서

알고리즘을 공부하려고 했다..

그런데 어려움이 있었다.

알고리즘과 자료구조 책이 죄다 C 였던 것이다.

자바로 된 책이 있었으면 좋았겠지만

도서관을 아무리 뒤져도 없었다.

어쩔 수 없이 C언어를 한달정도 공부한뒤에 알고리즘을 공부했다.

알고리즘을 처음 접한 건 7월 경이었다.

고른 책은 '뇌를 자극하는 알고리즘'이었다.

분명 뇌를 자극한다고 했는데, 머리가 터질 것 같았다.

아니, 다른 의미로 자극을 하는 것이었나.

터지는 것도 뇌에 자극이 되기는 하는 것이니..

아침에 밥 먹으면서 알고리즘 책을 읽고

지하철 타고 가서면서도 읽고

집에 와는 책을 타이핑도 하고, 알고리즘 문제도 찾아서 조금씩 풀었다.

여전히 이해가 안되었다.

책만으로는 안될 것 같아서 코세라의 '알고리즘' 강의도 같이 들었다.

영어라 이해가 안될 것 같았는데 3번 정도 들으면 들을만 했다.

알고리즘 책을 읽다가 이해가 안되면 처음으로 되돌아가서 읽었다.

그러면 예전보다 좀 더 이해가 되었다.

책을 처음으로 다 읽은 건 '추석연휴'였다.

마지막 챕터의 코드를 다 타이핑하고

정상적으로 돌아가는 걸 확인하니

강한 희열이 몰려왔다.

뭔가 내가 해냈구나 하는 뿌듯함이 있었다.

그 뒤로 책을 한번 더 보았는데 예전보다 훨씬 쉽게 느껴졌고 기억에도 남았다.

나의 개인적인 공부와는 별개로 학원 수업은 계속 진행되었다.

1시간 정도 수업을 하고 나면은 꼭 문제풀이 시간을 가졌는데

도움이 많이 되었다.

수업을 들으며 따라하다보면

내가 이해를 다 한것처럼 느껴진다.

하지만 나 혼자 해보려 하면은

잘 안된다. 지식의 공백이 있는 것이다.

문제를 푸는 건 공백을 메우는 아주 좋은 방법이다.

내가 아는 부분과 모르는 부분을 정확히 알 수 있다.

우리의 기억은 뭔가를 더 배울때보다

뭔가를 끄집어 낼때 더 강화된다.

무언가를 꺼내려고 노력하면

뇌는 중요한 정보라고 생각해서

더 깊게 기억하기 때문이다.

이를 '인출효과'라고도 하는데, 단순히 여러번 수업을 듣는 것보다

시험을 여러번 치는 게 훨씬 낫다는 이야기다.

인출효과는 과학적으로도 효과가 있는 게 증명되었다.

( 학습법에 대해서 알아보고 싶다면 책 '어떻게 공부할 것인가'를 읽어보기를 권한다. )

내가 혼자 공부하거나, 스터디를 할 때는

문제 풀이를 많이 하지 않았다.

반면 학원을 다닐때는 하나의 개념을 배우더라도

문제를 꼭 풀었다. 당시에는 왜 늘었는지 이해를 못했지만

나중에 인지 심리학 책을 보면서 알았다.

개발 실력을 올리려면 무조건 문제를 많이 풀어보기를 권한다

당장 풀어야할 문제가 생각이 안난다면

남들이 공개한 문제를 풀어보거나

이미 있는 소프트웨어를 모방해 보기를 권한다.

모방하는 과정이 하나의 문제 덩어리이기 때문이다.

어쩄든 학원 생활은 전반적으로 좋았다.

초반에는 벅찼던 문제풀이도 시간이 갈수록 쉬워졌고

1,2등으로 푸는 경우도 종종 생겼다.

이건 실력이 좋아서라기 보다는

무료 학원의 특성이 컸다.

무료 학원은 들어오는 사람들은 큰 투자를 안 하는 편이다.

사람들은 투자를 적게 할수록, 가치를 적게 느낀다.

그래서 조금 하다가 어려우면은 포기하는 경우도 많다.

학원에는 나오지만 다른 진로를 찾는 사람도 꽤 있다.

컴퓨터 공학과 학생들의 경우 다 아는 것이라고 '롤'을 하고 있는 경우도 있었다.

20명 정도가 있다면 10명 정도가 실제로 수업을 들었다.

상황이 이렇다 보니 열정적인 선생님도

열정이 조금씩 식어갔다.

3개월이 넘어가자 8시간 진행하던 수업도

5시간 진행하고 자습을 하고는 했다.

자습 시간에는 다양한 개발 공부를 했다.

C++의 창시자가 쓴 책도 읽어보고

네트워크 책도 읽어보고, 미적분도 공부해봤다.

실제 프로젝트 보다는 이론쪽을 많이 판 셈이다.

학원에서 배우게 되면 장단점이 있는데

장점은 바로 써먹을만한 기술을 속성으로 배울 수 있단 점이다.

단점은 학원에서 알려준 지름길 외에

다른 상황에 처하면

대처를 잘 못한다는 것이다.

나는 그 사실을 몰랐다.

개발 레벨이 99까지 있다면

나는 레벨이 2~3이었는데 나중에야 알았다.

학원이 끝날 때 즈음에

난 자신감이 상당했다.

학원에서 누가 질문을 하더라도

잘 대답을 할 수 있었다.

문제 풀이도 매우 빨리 하는 편이었기 때문이다.

게다가 주말까지 공부하는 사람은 많지 않았다.

당시에는 나도 모르게 거만 했던 것 같다.

하지만 나의 자신감이 산산조각 나는 데는 그리 오랜 시간이 걸리지 않았다.

산골짜기에서 우수했던 학생이

도시의 명문 학교로 전학온 느낌이랄까.

찬란한 미래가 올 것이라 생각했지만

그렇지 않았다.

개발의 배우는 것과는 다른 차원의 어려움이 있었다.

나의 29살은 상당히 어두웠다.

아마도 '그것'이 없었다면 암울했던 1년을 버티지 못했을 것이다.

다른 분야에서 넘어와 개발자가 된 사람은 결국 '그것'을 가졌던 사람들이었다.

나 또한 '그것'이 있었다

내가 개발을 배워온 과정 - 1부 우연한 선택

에드 신 — Sun, 19 Jul 2020 16:41:26 +0900

내가 IT에 관심을 갖게 된 건 2012년이었다.

직접 써 본 IT 회사들의 서비스들은 몇년은 앞서 있었다.

지금은 너무나도 당연해진 '아마존', '인스타그램', '에어비앤비'를 처음 접하고 큰 충격을 받았다.

마치 미래를 보는 느낌이었다.

난 IT 쪽에서 일하면 무언가 기회가 생기지 않을까 하는 막연한 생각이 들었다.

10여개월의 미국 생활을 마무리하고 한국으로 돌아왔다.

당시 난 1학기만 남은 상황이었고 뭐든 진로를 명확히 해야했다.

개발을 배워보는 게 어떨까 하는 생각을 했다.

고민을 좀 해보았다.

지금해도 괜찮을까 하는 의문이 많이 들었다.

난 27살의 겨울을 맞이하고 있었다. 남들은 이미 진로를 확정한 경우가 많았다.

나이는 너무 많지 않을까, 경쟁력은 있지 않을까.

고민이 되었다.

난 미래학 관련 책도 뒤져보고, 컴퓨터 공학의 인기도 찾아보았다.

다행히 카이스트 전산과 입학 성적은 5년째 하락중이었다.

경쟁이 덜 하고, 미래에 잘 될 산업이라면 해볼만하단 생각을 했다.

천재들은 이 산업에 없겠다는 생각을 했다.

사실 꼭 개발자가 되겠다는 생각은 아니었고, 프로그래밍 언어를 배워두면 무언가 유용할 거란 생각을 했다.

적어도 IT 쪽에서 일할때 다른 사람들이랑 이야기 하기 편할 거라는 생각이 있었다.

어떤 언어를 고를까 고민하다가

MIT에선 파이썬으로 대학교 수업을 한다는 얘기가 있어

파이썬을 공부하기 시작했다. 파이썬이 쉽고 배우기에 좋다는 이야기가 많았다.

코세라에 파이썬 기초 강의가 있어서 듣고 따라해보았는데 이해가 안 되었다.

약간 좌절하다가 코드카데미 (codecademy )를 알게 되었다.

코드카데미는 간단히 문법을 설명하고, 그걸 따라하는 방식이었다.

따라한 뒤에는 꼭 퀴즈를 풀어야했다. 퀴즈를 풀다보니 제대로 이해가 되었는지 확인이 되었고, 작게나마 성취감을 느꼈다.

돌이켜 보면 파이썬으로 시작한 건 상당한 행운이었다. 자바와 C로 개발 공부를 시작한 상당수의 사람들이 금새 포기를 하기 때문이다.

나는 프로그래밍의 어려움보다 흥미를 느끼며 시작을 했다.

코드카데미를 끝내는데 대략 한달정도 걸렸다. 파이썬 기초문법( 변수, 조건문, 클래스)등을 익히는 데 꽤 오랜시간이 걸린 것이다.

파이썬을 마치고, 그 다음에 뭘할지를 몰랐다.

지금이야 파이썬이 대중적이고 개발 공부법도 많이 나와있지만 당시엔 그런 게 없었다.

파이썬을 깊게 파거나, 실용적인 프로젝트를 했다면 좋았겠지만

조금은 아쉬운 선택을 하게 된다.

바로 ‘자바’를 공부하기 시작한 것이다. 지금이었다면 파이썬으로 웹사이트를 만들어보거나 데이터 분석 프로젝트를 진행했을 것이다.

인터넷에 질문도 올려보고, 책을 뒤져보니 파이썬은 대중적인 언어가 아니라 배워봐야 쓸데 없다는 이야기를 들었다.

( 교훈1 - 조언을 해주는 사람이 누구인지도 판단할 수 있어야 한다 )

조언에 따라 ‘자바’를 공부하기로 맘먹고 서점에서 자바 책을 읽어봤다.

어려웠다.

읽어도 하나도 이해가 되지 않았다.

읽다가 막히면 다시 앞으로 돌아가서 첨부터 읽었다.

10쪽 읽다가 처음으로 돌아가고, 50쪽 읽다가 처음으로 돌아가고의 반복이었다.

프로그래밍 책은 일본인이 번역한 영어 단어를 가져다 쓴 경우가 많다.

이 때문에 차라리 영어로 배우는 게 쉬울 수도 있는데 그걸 몰랐었다.

책에는 코딩은 쳐봐야 실력이 좋아진다고 적혀 있었다.

책에 있는 자바 코드를 따라 쳐보았다.

책에서 시키는 대로 실행을 해보았는데 안 되었다.

책에선 메모장으로 코드를 적었다.

난 책을 따라 메모장으로 코딩을 했다.

저자가 "메모장으로 개발해야 실력이는다는 믿음"을 가진 사람이었기에 일어난 일이었다.

세미콜론이 빠진 경우가 많았기에, 여지없이 에러가 났다.

지금 생각해보면 초반에 큰 고통을 겪은 건 잘못된 책 때문이었다.

근데 그 고통 덕에 좀 더 흥미를 가진 것도 사실이다.

난 2개월 동안 공부해서 겨우겨우 자바 책을 완독했다.

타이핑도 열심히 했지만 이해가 잘 안되었다.

혼자 공부하는 건 한계가 있다 생각했고

강의와 스터디를 알아보기 시작했다.

개발 커뮤니티는 몰랐기에 학교 커뮤니티를 뒤적거렸다.

마침 개강 직전이라 안드로이드 스터디를 모집하는 사람이 있었다.

반가운 마음에 메일을 보냈고, 스터디원들을 만나게 되었다.

스터디 장은 앱만들기 동아리를 운영하는 기계과 학생이었다.

동아리원 중 하나는 앱을 출시한 경험도 있었다.

난 스터디에 참여한 첫날 엄청나게 충격을 받게 된다.

이클립스라는 프로그램이 있으며, 개발자들은 이 프로그램을 써서 개발을 한다고 했다.

첫 모임이 끝나고 집에서 이클립스를 써보았다.

놀라웠다.

세상에 세미콜론을 뺴먹으면 알려주는 프로그램이 있다니…

영어 몇글자만 적으면 함수를 자동으로 만들어주는 프로그램이 있다니…

남극에서 평생 썰매를 끌던 에스키모가 처음 비행기를 타봤을때 이런 느낌이었까?

자바 책에 있던 코드를 이클립스에 쳐보니 매우 쉽게 되었다.

난 감탄을 하며 흥미를 느꼈다. 책 저자가 살짝 원망스러워질 정도였다.

어렵기만 했던 책이 조금씩 이해가 되는 기분이었다.

스터디에 참여하고 나서, 나와 다른 스터디원의 차이를 알게 되었다.

나는 미리 예습을 했고, 메모장에서 삽질을 많이 한 덕에 조금만 알아도 성취감을 느꼈다.

약간의 파이썬 경험과 메모장이 도움이 된 셈이다.

반면 다른 스터디원은 자바부터 배우기 시작했고, 이클립스로 시작하다보니

많이 어려워했다. 안드로이드는 꿈도 못 꾸는 상황이었다.

2달정도 지나자 스터디를 제대로 나오는 사람은 나와 스터디장 밖에 없었다.

나머지는 다른 우선 순위가 있으면 그걸 우선시 했다.

사실 내가 자바를 재밌어한건 원래 메모장으로 프로그래밍하다가

이클립스를 쓰니 개발이 갑자기 쉬워져서였다. 나는 근데 그걸 재능이 있다고 착각을 했다.

내 주변의 많은 이들이 같은 이유로 직업 선택을 했다.

1학년때 우연히 들은 '회계원리' 성적이 좋아서 회계 시험을 준비하고 회계사가 된다.

그 반 학생들이 게을렀을수도 있고, 교수님이 학점을 뿌리는 스타일이었을수도 있다.

초등학교때 우연히 본 과학 만화에 흥미를 느껴

과학책을 많이 보다보니, 과학책이 쉽게 느껴진다.

그래서 이과를 가게 되고 물리학도, 생물학자가 된다.

이런 우연함이 쌓여 재능 혹은 능력이 된다.

이는 7년 정도 지나고, 나보다 탁월한 사람을 많이 만나서 깨달은 것이다.

생각보다 실력이 있는데 평범하다고 착각하거나, 평범한데 탁월하다고 착각하는 사람이 많다.

어쨌든 중간 고사가 끝나자 스터디는 흐지부지가 되었다.

난 조금은 자신이 생긴 상태라 안드로이드를 혼자서 공부하기 시작했다.

그러며 예상치 못한 문제점들을 만나게 되는데...

Flutter - 5분안에 AndroidX 마이그레이션 하기

에드 신 — Mon, 26 Aug 2019 11:18:36 +0900

5분 안에 Flutter AndroidX Migration 하기

플러터를 개발하다보면 안드로이드 X 문제를 종종 만나게 됩니다.

사실 제일 쉬운 방법은 AndroidX 적용하기 전 라이브러리를 사용하는 거죠.

플러터 공식 문서에도 Avoiding AndroidX 라는 섹션에 이전 버전들이 나와 있습니다.
(https://flutter.dev/docs/development/packages-and-plugins/androidx-compatibility)

하지만 이건 임시 방편에 불과하죠.

나중에 더 큰 문제를 일으킵니다.

오래된 라이브러리를 쓰다보니 새로운 기능이나, 지원이 끝나는 문제도 생기구요.

이번 글에서는 안드로이드 스튜디오로 손쉽게 마이그레이션(Migration) 하는 방법을 다룹니다.

일단 새 플러터 프로젝트를 만들어주세요.

1. 프로젝트의 android 부분으로 가서 새롭게 Android Studio를 연다

Flutter 프로젝트에서 android 쪽으로 가서 Open for editing Android Studio 를 눌러주세요.

Migration 기능을 제대로 쓰려면 플러터 프로젝트 중 android 부분만 따로 열 필요가 있습니다.

2. 안드로이드 스튜디오 써서 Migrate 하기

상단의 Refactor 탭에 있는 Migrate to Android 를 누르고 기다리면 됩니다.

Migrate to Android가 활성화가 안 된 경우가 있는데요.
1분 ~ 5분 정도 지나면 활성화 됩니다(흰색으로 바뀜.).

마이그레이션 작업은 보통 1분 ~ 5분 정도가 걸립니다.

파일을 백업할거냐고 물어보기도 하는데요.

백업해도 되고 안해도 됩니다.

프로젝트 규모가 클수록 혹시 모르니 백업하는 게 좋습니다.

방금 만든 프로젝트면 백업 안해도 상관 없습니다.

3. AndroidX 로 그래들이 바뀌었는지 확인

작업이 끝났으면 build.gradle 을 확인해 보세요.

라이브러리들이 androidx 로 바뀌어 있으면 성공입니다.

참고글 - https://flutter.dev/docs/development/packages-and-plugins/androidx-compatibility

Flutter - Provider 패턴에 대해서 알아보자

에드 신 — Tue, 6 Aug 2019 16:28:52 +0900

flutter_provider

Flutter Provider 패턴이란?

Provider란? 데이터 생산과 소비
Provider 써보기
ChangeNotifierProvider로 변하는 데이터 다뤄보기
MultiProvider로 여러 프로바이더 관리하기

Provider가 주목받게된 배경

Provider 는 올해 Google IO (2019 Google IO) 에서 추천되면서 큰 주목을 받았습니다.

원래 커뮤니티에서 만든 플러그인인데 구글에서 공식으로 추천을 한 거죠.

작년 구글 IO 떄 구글은 Bloc 패턴을 사용하길 권했습니다.

Bloc 패턴은 UI와 데이터 처리 로직(비즈니스 로직)을 분리하는 방식입니다.

플러터는 UI도 코드다 보니, 잘 관리 안 해주면

코드가 한 클래스에 너무 많이 몰리는 문제가 있었습니다.

이를 해결하기 위해 나온 게 Bloc 패턴입니다.

그런데 BLoc 패턴은 사용하기 너무 어렵다는 사람이 많았습니다.

단순한 로직을 짜려고 해도 4개 정도는 클래스를 만들어야 했죠.

반면 Provider 패턴을 쓰면 데이터 공유나 로직의 분리를 좀 더 간단히 할 수 있습니다.

프로바이더 패턴을 쓰는 이유는?

a. 관심사의 분리 (separation of concerns)

관심사의 분리는 디자인 원칙의 하나입니다.

보통 관심사는 어떤 코드가 하는 일을 말합니다.

UI를 담당하는 코드, 네트워크를 담당하는 코드, 데이터를 담당하는 코드 등

코드를 역할에 따라 나눌 수 있죠.

보통은 한 클래스가 여러 역할을 할 수록, 클래스가 커지고 관리가 어렵게 됩니다.

따라서 클래스가 하나의 역할(관심)만 갖도록, 클래스를 나누죠.

이게 바로 관심사의 분리입니다.

Provider나 Bloc 패턴을 쓰는 이유는 관심사의 분리를 위해서에요.

b. 데이터의 공유

하나의 데이터를 여러 페이지에서 공유하고 싶을 때가 있습니다. 유저 인증 정보의 경우 장바구니, 회원 등급 등 여러 페이지에서 쓰이죠. 근데 페이지마다 인증 정보를 새로 불러온다면 앱이 복잡해지고, 비용도 많이 들겠죠?

이럴 때 데이터 공유가 필요합니다.

Provider 패턴을 쓰면 데이터 공유를 쉽게 할 수 있습니다.

c. 좀 더 간결한 코드

Bloc 패턴의 경우 클래스들을 역할 별로 나누는 데는 좋지만

코드 자체가 복잡해지는 경향이 있습니다.

Provider 패턴을 쓰면 좀 더 적은 코드로

클래스들을 구분해서 쓸 수 있죠.

구글에서도 중규모 프로젝트는 Provider 패턴을, 대규모 프로젝트는 Bloc 패턴을 추천하고 있습니다.

1. 프로바이더의 구조 - 데이터 생산과 소비

Provider는 데이터를 생산하고, 소비하는 2부분으로 되어 있습니다.

어떤 데이터를 생산하느냐에 따라 Provider의 종류가 달라지죠.

그냥 Provider가 되기도 하고 StreamProvider가 되기도 하고 합니다.

Provider가 어떻게 데이터를 생산하고 소비하는 지 알아보고, 실제 앱에서 활용해 보도록 하겠습니다.

일단 라이브러리부터 추가해주세요.

pubspec.yaml


provider: ^3.0.0+1

1.1 Provider 데이터 생산하기


xxxxxxxxxx
Provider<int>.value( // int 타입 사용
      value: 5,
      child: Container(),
)

데이터를 생산할 때는 꼭 데이터 타입을 적어줍니다.

여기선 int 형태로 데이터를 만들었죠.

1.2 Provider 데이터 소비하기


xxxxxxxxxx
var data = Provider.of<int>(context) // int 타입 사용. Provider를 만들 때 int 타입을 썼기에..

Provider에서 만든(제공하는) 데이터를 쓰려면

Provider.of(context) 나 Consumer() 위젯을 사용합니다.

저는 Provider.of(context) 가 더 쓰기 편해 이쪽을 더 선호합니다.

그럼 간단히 앱을 만들어볼께요.

요런 디자인입니다 :)

예제 1.1 - 기본 Provider 사용해보기 : 데이터 생산


x
void main() {
  runApp(SimpleApp());
}
class SimpleApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Provider<int>.value( // Provider로 위젯을 감싸면, 자식 위젯에서 그 값을 사용 가능.
      value: 5, // Provider에서 제공하는 값은 5
      child: MaterialApp(
        home: SimplePage(),
      ),
    );
  }
}

Provider를 쓰려면 부모 위젯을 Provider로 감싸줘야합니다.

전체 앱에서 사용하고 싶으면 MateriapApp을 감싸면 됩니다.

Provider에서 어떤 값을 쓸지를 정해야 하는데요.

전 5를 주었습니다. 지금은 value가 5로 고정되어 있지만, 변하는 값을 넣는 것도 얼마든지 가능합니다.

이제 Provider가 제공한 데이터를 사용해보겠습니다.

예제 1.2 - 간단히 Provider 사용해보기 : 데이터 소비


xxxxxxxxxx
class SimplePage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    var data = Provider.of<int>(context); // 가까운 Provider로부터 값을 가져옵니다. 
    return Scaffold(
      appBar: AppBar(
        title: Text('Simple app'),
      ),
      body: Center(
        child: Text('${data}'), // 값이 표시됩니다 (여기서는 5)
      ),
    );
  }
}

Provider.of(context) 함수를 통해

데이터를 가져옵니다.

이 값은 5 입니다. 부모 위젯에서 정한 값이죠.

데이터를 만드는 곳과 쓰는 곳이 분리되어 있습니다.

이게 Provider 패턴의 가장 큰 특징이죠.

사실상 옵저버 패턴과 큰 차이가 없어요.

그럼 Provider를 써서

값이 변할 때 어떻게 하는지를 알아보겠습니다.

2. ChangeNotifierProvider 사용하기 - 변하는 값 처리하기

UI에 있는 값이 변했을 때, UI를 변경해 줘야합니다.

이를 setState() 로 할 수도 있겠지만

ChangeNotifier 를 쓰면 같은 일을 할 수 있습니다.

ChangeNotifier를 믹스인 (mixin) 한 클래스는

notifyListeners() 함수를 부를 수 있습니다.

이 함수를 쓰면 UI가 업데이트 됩니다.

예제 2.1은 counter 값이 변할때, UI를 업데이트 하도록 만든 클래스입니다.

예제 2.1 - Counter 클래스


xxxxxxxxxx
import 'package:flutter/material.dart';
class Counter with ChangeNotifier {
  int _counter;
  Counter(this._counter);
  getCounter() => _counter;
  setCounter(int counter) => _counter = counter;
  void increment() {
    _counter++;
    notifyListeners(); // 값이 변할 때마다 플러터 프레임워크에 알려줍니다.
  }
  void decrement() {
    _counter--;
    notifyListeners(); // 값이 변할 때마다 플러터 프레임워크에 알려줍니다.
  }
}

Counter 클래스를 Provider에 넣어볼텐데요.

Counter 클래스가 ChangeNotifier를 믹스인 했기에

ChangeNotifierProvider 를 사용해줘야합니다.

예제 2.2 - CounterApp.

ChangeNotifierProvider 로 위젯을 감싸줍니다 - 데이터 사용할 준비하기


xxxxxxxxxx
class CounterApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return ChangeNotifierProvider<Counter>( // Counter 타입 사용. Counter 클래스의 데이터가 변하는지 보고 있다가 변하면 알려줍니다.
      builder: (_) => Counter(0), // 초기값 정하기
      child: MaterialApp(
        title: 'Flutter Value',
        theme: ThemeData(
          primarySwatch: Colors.blue,
        ),
        home: HomePage(),
      ),
    );
  }
}

머터리얼 앱을 ChangeNotifierProvider로 감싸고 있습니다.

builder 속성에서 초기값을 정하고 이를

자식 위젯들에서 사용합니다.

예제 2.3 ChangeNotifierProvider의 값 사용하기

예제 2.2에서 제공하는 데이터를 위젯에서 보여줍니다.

+,- 버튼을 누를 때마다 값이 바뀌죠.


xxxxxxxxxx
class HomePage extends StatefulWidget {
  HomePage({Key key}) : super(key: key);
  @override
  _HomePageState createState() => _HomePageState();
}
class _HomePageState extends State<HomePage> {
  @override
  Widget build(BuildContext context) {
    final counter = Provider.of<Counter>(context); // Counter 타입의 데이터를 가져옴. 
    return Scaffold(
      appBar: AppBar(
        title: Text("Provider demo"),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            Text(
              '${counter.getCounter()}',
              style: Theme.of(context).textTheme.display1,
            ),
            RaisedButton(
              onPressed: openFirstPage,
              child: Text('first page'),
            ),
            RaisedButton(
              onPressed: openSecondPage,
              child: Text('second page'),
            ),
          ],
        ),
      ),
      floatingActionButton: Column(
        mainAxisAlignment: MainAxisAlignment.end,
        children: <Widget>[
          FloatingActionButton(
            onPressed: counter.increment, // 버튼을 누를 때마다, 값이 증가합니다. notifyListeners()가 호출되기에 UI가 갱신됩니다.
            tooltip: 'Increment',
            child: Icon(Icons.add),
            heroTag: null,
          ),
          SizedBox(
            height: 10,
          ),
          FloatingActionButton(
            onPressed: counter.decrement,
            tooltip: 'Decrement',
            child: Icon(Icons.remove),
            heroTag: null,
          )
        ],
      ),
    );
  }
  // 다른 페이지로 이동을 합니다. 이동한 페이지에서도 Counter의 값은 동일합니다.
  Future openFirstPage() {
    return Navigator.push(
      context,
      MaterialPageRoute(builder: (context) => FirstPage()),
    );
  }
  Future openSecondPage() {
    return Navigator.push(
      context,
      MaterialPageRoute(builder: (context) => SecondPage()),
    );
  }
}

아래 그림 같은 UI 인데요.

+, - 버튼을 누르면 중앙에 있는 값이 바뀝니다.

그럼 다른 페이지에서도 Counter 값이 잘 공유되는지 알아볼께요.

예제 2.4 - FirstPage 다른 페이지에서도 값이 동일한지 확인


xxxxxxxxxx
class FirstPage extends StatefulWidget {
  @override
  _FirstPageState createState() => _FirstPageState();
}
class _FirstPageState extends State<FirstPage> {
  @override
  Widget build(BuildContext context) {
    final counter = Provider.of<Counter>(context);
    return Scaffold(
      appBar: AppBar(
        title: Text('first page'),
      ),
      body: Center(
        child: Container(
          child: Text('first page counter ${counter.getCounter()}'),
        ),
      ),
    );
  }
}

다른 페이지에서도 값이 동일합니다.

똑같이 5가 나오는 걸 알 수 있죠.

생각보다 프로바이더 쓰는 건 간단합니다!!

다만 문제가 하나 있는데요.

Provider가 여러개 일수록 관리가 어려워진다는 거죠.

게다가 Provider 가 중첩될 경우엔 앱이 난잡해지기 쉽습니다.

이때 쓰는 게 MultiProvider 에요.

3. MultiProvider - 여러 프로바이더 같이 사용하기

멀티 프로바이더를 쓰면 프로바이더 관리가 상당히 편해집니다.

다른 위젯들이랑 섞일 일이 없어서 쓰기 편해지죠.

사용법은 간단합니다.

MultiProvider의 providers 속성에 원하는 프로바이더를 적어주면 됩니다.

여러개 적을 수 있죠.

MultiProvider 사용 예


xxxxxxxxxx
Widget build(BuildContext context) {
    return MultiProvider(
      providers: [
        Provider<int>.value(value: 50),
        Provider<String>.value(value: "Hello World"),
      ],
    );
 }

프로바이더는 자료형으로 어떤 값을 가져올지 구분합니다.

근데 멀티 프로바이더에 같은 자료형이 여러번 정의 된다면 어떻게 될까요?

MultiProvider - 같은 자료형이 여러개면 가장 밑에 있는 것에 접근.


xxxxxxxxxx
MultiProvider(
      providers: [
        Provider<int>.value(value: 50),
        Provider<int>.value(value: 100),
        Provider<int>.value(value: 300), // Provider.of<int> 로 접근하면 이 값만 가져옴. 
      ]
)

같은 자료형인 프로바이더가 여러개일 경우, 가장 밑에 값으로 처리합니다.

그럼 좀 더 실용적인 예제를 만들어보겠습니다.

파이어 스토어의 데이터를 받아서 보여주는 예제에요.

화면 2개로 구성되어 있는데 1개는 로그인 화면, 1개는 유저 데이터를 보여주는 화면입니다.

예제3. 로그인 화면 - 로그인 안 되었을 때 나옴

예제3. 유저 데이터 화면 - 로그인 되면 나옴

우선 라이브러리부터 추가하겠습니다.

예제 3.1 pubspec.yaml


xxxxxxxxxx
 cloud_firestore: ^0.12.9
 firebase_auth: ^0.14.0

이제 파이어 스토어에서 필요한 데이터를 만들어주세요.

데이터는 아래 그림과 같은 형식입니다.

User 콜렉션과 다큐먼트를 만들어 주세요~!

예제 3.2 파이어스토어에 데이터 추가하기

파이어 스토어의 데이터를 앱에서 읽으려면

그에 걸맞은 클래스가 필요하겠죠?

user.dart 에서 이 일을 합니다.

예제 3.3 user.dart - 데이터를 담을 클래스


x
import 'package:cloud_firestore/cloud_firestore.dart';
class User {
  final String name;
  final int age;
  User({this.name, this.age});
  factory User.fromMap(Map map) {
    return User(
      name: map['name'] ?? '', // 디폴트 값은 '' 으로 했습니다.
      age: map['age'] ?? 0,
    );
  }
  factory User.fromFireStore(DocumentSnapshot doc) {
    Map map = doc.data;
    return User(
      name: map['name'] ?? '',
      age: map['age'] ?? 0,
    ) ;
  }
}

데이터 관리는 따로 클래스를 만들어서 하겠습니다.

Database Provider 라는 클래스인데요.

파이어 스토어로부터 데이터를 읽어 들입니다.

예제 3.4 database_provider.dart - 파이어 스토어를 관리할 클래스


x
import 'package:cloud_firestore/cloud_firestore.dart';
import 'package:flutter_state_provider/model/user.dart';
class DatabaseProvider {
  final Firestore _db = Firestore.instance;
  // User 1명의 데이터 읽기
  Future<User> getUser(String id) async {
    var snap = await _db.collection('user').document(id).get();
    return User.fromMap(snap.data);
  }
  // User 여러명의 데이터 읽기
  Stream<List<User>> getUsers() {
    // DocumentSnapshot 으로 되어 있기에 이를 리스트 형식으로 바꿔줌.
    return _db.collection('user').snapshots().map((list) =>
        list.documents.map((doc) => User.fromFireStore(doc)).toList());
  }
}

이제 프로바이더를 써서 데이터를 읽어들이도록 할께요.

DatabaseProvider 클래스에서 만든 함수 2개를 사용합니다.

예제 3.5 login_app.dart - 로그인 화면을 처리하고, 유저 데이터를 보여줄 클래스


x
import 'package:firebase_auth/firebase_auth.dart';
import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'database/database_provider.dart';
import 'model/user.dart';
class LoginApp extends StatelessWidget {
  DatabaseProvider db = DatabaseProvider();
  @override
  Widget build(BuildContext context) {
    return MultiProvider(
      providers: [
        // 스트림 프로바이더로 인증 정보를 읽어들임. 인증 상태가 변하면, 변한 값이 출력됨.
        StreamProvider<FirebaseUser>.value(
          value: FirebaseAuth.instance.onAuthStateChanged,
        ),
        // 스트림 프로바이더로 파이어스토어 데이터를 읽어들임.
        StreamProvider<List<User>>.value(
          value: db.getUsers(),
        ),
      ],
      child: MaterialApp(
        title: '인증 프로바이더',
        theme: ThemeData(
          primarySwatch: Colors.blue,
        ),
        home: LoginPage(),
      ),
    );
  }
}
class LoginPage extends StatefulWidget {
  @override
  _LoginPageState createState() => _LoginPageState();
}
class _LoginPageState extends State<LoginPage> {
  TextEditingController emailCtrl = TextEditingController();
  TextEditingController passwordCtrl = TextEditingController();
  Map data = Map();
  FirebaseAuth auth = FirebaseAuth.instance;
  @override
  Widget build(BuildContext context) {
    var user = Provider.of<FirebaseUser>(context);
    var loggedIn = user != null;
    return Scaffold(
      appBar: AppBar(
        title: Text(
          "로긴 페이지",
          style: TextStyle(color: Colors.white),
        ),
      ),
      body: Column(
        children: <Widget>[
          // 로그인(가입)된 유저일 경우만 UI에서 보여줌.
          if (loggedIn) ...[
            RaisedButton(child: Text("Sign out"), onPressed: auth.signOut),
            UserList(), // User 데이터를 보여주는 위젯
          ],
          // 로그인이 안 된 유저일 경우 보여주는 UI - 가입 화면
          if (!loggedIn) ...[
            TextFormField(
              controller: emailCtrl,
              decoration: InputDecoration(
                  icon: Icon(Icons.email), hintText: '이메일을 적어주세요.'),
            ),
            TextFormField(
              controller: passwordCtrl,
              decoration: InputDecoration(
                  icon: Icon(Icons.keyboard), hintText: '비밀번호를 적어주세요.'),
              obscureText: true,
            ),
            RaisedButton(
              child: Text("Sign up"),
              onPressed: signUp,
            )
          ]
        ],
      ),
    );
  }
  void signUp() {
    String email = emailCtrl.text;
    String password = passwordCtrl.text;
    auth.createUserWithEmailAndPassword(email: email, password: password);
    emailCtrl.clear();
    passwordCtrl.clear();
  }
}

로그인이 되었으면 유저 데이터를 보여주고,

로그인이 안 되었으면 email, password 입력 화면이 나옵니다~!

Provider(프로바이더)를 쓰면 이런 상태 관리를 정말 쉽게 할 수 있죠.

전 편의상 유저 데이터를 보여주는 위젯은 따로 클래스로 뺐습니다.

이 부분까지만 하면 이 예제는 끝이에요.

예제 3.6 user_list.dart - 유저 데이터를 보여줄 위젯


class UserList extends StatefulWidget {
  @override
  _UserListState createState() => _UserListState();
}
class _UserListState extends State<UserList> {
  @override
  Widget build(BuildContext context) {
    var users = Provider.of<List<User>>(context);
    return Container(
      height: 400,
      child: ListView.builder(
        itemCount: users.length,
        itemBuilder: (BuildContext context, int index) {
          User user = users[index];
          return ListTile(
            title: Text("이름 -  ${user.name}"),
            leading: Text("나이 - ${user.age}"),
          );
        },
      ),
    );
  }
}

이제까지 Provider 에 대해서 알아보았습니다.

Bloc 패턴에 비하면 정말 간결합니다.

Provider 패턴을 쓰면 좀 더 부담없이 깔끔한 코드를 작성할 수 있단 생각이 드네요!

이 글에 쓰인 소스는 여기 에서 찾아보실 수 있습니다.

예제 1,2,3은 주석 처리를 지우면서 실행해 보세요!


xxxxxxxxxx
void main() {
  runApp(SimpleApp()); 
  //runApp(CounterApp());
  //runApp(LoginApp());
}

이번 글에선 프로바이더에 대해서 알아보았는데요.

다음 글에선 애니메이션이나 파이어베이스에 대해서 알아볼 예정입니다.

여기까지 읽어주셔서 감사합니다.

참고한 자료들

멀티 프로바이더 부분 참고 - 유튜브 Fireship 채널 영상 ( https://www.youtube.com/watch?v=vFxk_KJCqgk )

프로바이더 아키텍처 - https://medium.com/flutter-community/flutter-architecture-provider-implementation-guide-d33133a9a4e8

코딩 잘하기 - 여러 언어 배우기 vs 1개 언어에 집중하기

에드 신 — Mon, 8 Jul 2019 23:35:51 +0900

어느정도 프로그래밍 언어 하나에 익숙해지면

겪게 되는 고민이 있습니다. 언어를 더 배워야 하는 건가?

왜 이리 프로그래밍 언어는 이토록 많지?

개발자라면 당연히 C는 알아야 한다는데,

요즘 다트가 유행이라는데,

인공지능 개발하려면 파이썬은 기본이라는데,

서버는 Go언어로 짜야 성능이 좋다는데

이 모든 걸 다 배워야 될 것 같은 생각이 듭니다.

심지어 폴 그레이엄은 그의 책, '해커와 화가'에서 자바만 아는 개발자는 심각한 문제라는 이야기도 하였죠.

조엘 스폴스키는 '얼랭' 같은 특이한 언어를 배운 개발자를 뽑으라고 권하기도 했구요.

여러 언어를 배우는 게 정답일까요?

그렇지 않습니다.

언어는 2개 정도만 깊이 파고

언어 자체보다는 소프트웨어 자체를 만들기를 권합니다.

프로그래밍은 외국어와 비슷한 측면이 있습니다.

외국어를 7개 국어 한다는 사람도 있지만

모국어 수준으로 하는 건, 2~3개 정도이고

나머지는 간단한 회화나 독해가 전부입니다.

안 쓰면 잊혀지기 때문이죠.

프로그래밍 언어를 7~8개 한다는 사람을 실제로 봐도

문법을 아는 정도지, 자유 자재로 상용 소프트웨어를 만드는 경우는 많지 않았습니다.

(근데 다 하는 사람이 가끔 있긴 합니다 가끔요..)

한 언어를 택해서, 그 언어의 숙련도를 높이는 게 좋습니다.

프론트 엔드 개발자가 목표라면, 바닥부터 웹사이트를 만들어보고 브라우저 원리도 공부해보고,

네트워크로 데이터 주고 받기, 재사용성 높게 클래스 만들기, 내가 필요한 거 라이브러리로 만들어보기,

실제 서비스 만들어 유저 받기 같은 걸 하는 게 낫습니다.

괜히 파이썬으로 rest api 짜다가, Vue가 뜬다고 하니 뷰하다가, 리액트가 낫다니 리액트 해보고

이런 건 정말 안 좋습니다.

데이터 분석을 배운다면 데이터를 분석한 뒤

어떤 결론을 도출해 내거나, 보고서를 작성해 실제 서비스에 반영되도록 시도하는 게 낫습니다.

내가 분석한 내용이 실제 환경 (마케팅이든, 앱의 ui 든)에 적용된다면 그보다 나을 게 없죠.

파이썬이 크롤링 하기 좋다니 파이썬 배우다가, R이 통계 기능이 낫다니 R 배우고,

딥러닝 최적화 하려면 C++이 필수라고 하니 C++ 배우고 이럼 진전이 없습니다. R이든 파이썬이든 하나 정해서 끝장을 보는 게 나아요.

끝장을 본 다는 건 하나의 분야에서 a to z를 말합니다.

여러 언어를 배우는 건 중국어로 자기 소개 배운다음에, 스페인어로 자기소개 배우는 거랑 똑같아요.

한 언어를 잘하고 난 다음에 다른 언어로 넘어가는 게 낫습니다.

저도 여러 언어를 배워봤는데 숙련도 차이가 큽니다. 어떤 언어는 컴파일을 안 해도 동작이 예상되지만, 어떤 언어는 한줄 한줄 쳐봐야 되죠.

당연히 개발 속도나 질에서도 차이가 납니다.

이 글에서 언어 하나의 숙련도를 높이라고 했지만

그래도 2~3개 정도는 아는 게 필수라고 생각합니다.

다른 언어를 배우면 주 언어를 더 깊이 이해할 수 있고

어떤 언어에선 못하는 걸, 다른 언어에선 쉽게 할 수 있는 경우가 종종 있거든요.

이럴 때를 대비해서 배워두면 필요에 따라 활용할 수 있습니다.

책 파이썬 '실전 스케일링 파이썬 프로그래밍’를 보면

async io 라이브러리 개발자의 인터뷰가 나옵니다.

그분도 “고성능 병렬 프로그램을 짤때는 GO”를 씁니다라고 하더군요.

파이썬으로 멀티 프로세싱을 할 때는 어려움이 있다면서요.

이렇듯 더 나은 문제 해결을 위해, 다른 언어를 알면 좋습니다.

동적 언어로 시작했으면 정적 언어를 배워보고

정적 언어로 시작했으면 동적 언어를 배워보는 게 제일 효과적이라고 생각합니다.

결론

처음 개발을 배우거나 아직 서비스를 만들어본 경험이 없다면

언어 하나에 집중하자. 그치만 틈틈이 1~2개 정도는 추가로 배워두자.

Flutter - 다국어 지원하기 (Localization and Internalization)

에드 신 — Tue, 2 Jul 2019 13:42:55 +0900

flutter_intl

플러터 다국어 지원 - Flutter Internalization

intl 패키지와 툴 써서 번역하기

arb란?
intl 이란?
intl - message, format, number
intl 툴로 arb 추출하기
app에 다국어 적용하기

플러터 다국어 지원은 좀 까다롭습니다. Intl.message를 .arb 파일로 바꾼 뒤 읽어들여야 하죠.

.arb 파일이란?

arb(Application Resource Bundle)는 구글에서 만든, 파일 형식입니다.

언어 데이터를 저장했다가 번역하기 위해 쓰이죠. 단순한 형태의 json 파일이라고 보면 됩니다.

플러터에선 arb 말곤 다국어지원을 안해서, 어쨌든 arb 파일 다루는 법을 알아야합니다.

Google Translators Toolkit도 .arb 파일형식을 지원하고 있습니다.

intl 란?

intl은 다트에서 다국어 (internalization and localization)을 지원하는 패키지입니다. 언어 번역이나 단수/복수, 성별, 날짜/숫자를 그 지역이나 국가에 맞게 바꿀 때 씁니다.

1. Intl.message

일단 패키지들을 설치하고 설명을 따라해보세요.

1.1 pubspec.yaml 설정

intl 패캐지와 intl_translation 패키지를 추가해주세요.


x
dependencies:
  flutter:
    sdk: flutter
  flutter_localizations: 
    sdk: flutter
  intl: ^0.15.8
dev_dependencies:
  flutter_test:
    sdk: flutter
  intl_translation: ^0.17.1

1.2 Intl.message() 사용해보기

Messages는 번역할 문자들을 말합니다. 이 문자들을 필요할 때, 한번에 추출해 번역합니다.

Intl.message()은 문자를 담은 함수로 볼 수 있습니다.

이 함수를 한번 사용해볼께요.


xxxxxxxxxx
import 'package:intl/intl.dart';
String helloWorld() => Intl.message("Hello World",
    name: "helloWorld", // 함수랑 동일
    args: [],
    desc: "Hello world message");
String openButton() => Intl.message("open button",
  name: 'openButton',
  args: [],
  desc: "This is an open button"
);
void main() {
  print(helloWorld());
  print(openButton());
}

일반 문자랑 큰 차이없이 쓰이죠? 다만 Intl.message의 name은 꼭 함수이름이랑 일치해야지 나중에 .arb 파일로 추출할 수 있습니다.

1.3 Flutter에서 Intl.message 사용해보기

위젯 코드는 보통때처럼 main.dart에 작성하고

Intl.message는 i18n/messages 클래스에 작성하겠습니다.

main.dart 파일


xxxxxxxxxx
import 'package:flutter/material.dart';
import 'i18n/messages.dart';
void main() => runApp(MyApp());
final msg = Messages();
class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: MyHomePage(title: 'Flutter Demo Home Page'),
    );
  }
}
class MyHomePage extends StatefulWidget {
  MyHomePage({Key key, this.title}) : super(key: key);
  final String title;
  @override
  _MyHomePageState createState() => _MyHomePageState();
}
class _MyHomePageState extends State<MyHomePage> {
  @override
  void initState() {
    print(msg.widgetMessage);
    super.initState();
  }
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(msg.appName),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            Text(
              '${msg.widgetMessage}',
            ),
          ],
        ),
      ),
    );
  }
}

Message에다가 Intl.message를 모아놓습니다. 이래야 관리하기 편하더군요.

i18n/messages.dart 파일


xxxxxxxxxx
import 'package:intl/intl.dart';
class Messages {
  String get widgetMessage => Intl.message("widget message",
    name: "widgetMessage"
  );
  String get appName => Intl.message("widget message",
      name: "appName"
  );
}

2. 다국어 적용

이제 문자열 번역을 해보겠습니다.

문자열 번역은 크게 4단계에요.

-1. intl message를 .arb로 추출하기 -2. arb로 파일들 번역하기 -3. arb를 message_xx.dart로 바꿔주기 -4. app에 적용하기

2.1 intl의 messages를 추출해 arb 파일 만들기

intl_translation 패키지는 arb를 만드는 명령어를 지원합니다.

flutter pub run intl_translation:extract_to_arb --output-dir=[저장될 경로] [arb를 추출할 dart 파일]

같은 형식인데요. 경로와 파일을 정해줘야합니다.

아래 명령을 실행해볼께요.

파일에 있는 Intl.messages()만 골라서 arb로 바꿔주는 명령이에요.


xxxxxxxxxx
flutter pub run intl_translation:extract_to_arb --output-dir=lib/i18n lib/i18n/messages.dart

실행하면 intl_messages.arb 이 생깁니다.

intl_messages.arb를 열어볼께요.


xxxxxxxxxx
{
  "@@last_modified": "2019-07-02T08:43:15.261695",
  "widgetMessage": "widget message",
  "@widgetMessage": {
    "type": "text",
    "placeholders": {}
  },
  "appName": "widget message",
  "@appName": {
    "type": "text",
    "placeholders": {}
  }
}

messages.dart 에서 정의했던 Intl.message()들이 json 형태로 바뀌어 있습니다.

2.2 arb로 파일들 번역하기

이제 intl_messages.arb 을 복사해 언어별 파일을 만듭니다.

intl_en.arb
intl_ko.arb

만든 arb을 언어에 맞게 수정해주면 되겠죠.

arb를 수정하는 건 직접 해도 되고, Google Translate Toolkit을 써도 됩니다.

intl_ko.arb


xxxxxxxxxx
{
  "@@last_modified": "2019-07-02T08:23:30.820815",
  "widgetMessage": "위젯이에요",
  "@widgetMessage": {
    "description": "Explains that we will not proceed further until the user presses a key",
    "type": "text",
    "placeholders": {}
  },
  "appName": "앱 이름입니다.",
  "@appName": {
    "type": "text",
    "placeholders": {}
  }
}

intl_en.arb


xxxxxxxxxx
{
  "@@last_modified": "2019-07-02T08:23:30.820815",
  "widgetMessage": "This is a new widget",
  "@widgetMessage": {
    "description": "Explains that we will not proceed further until the user presses a key",
    "type": "text",
    "placeholders": {}
  },
  "appName": "My flutter app",
  "@appName": {
    "type": "text",
    "placeholders": {}
  }
}

arb 파일을 직접 사용하진 못하고, 플러터에서 쓸 수 있게 dart 파일로 바꿔줘야해요.

arb로부터 변환된 dart 파일은 message_en.dart, message_ko.dart 형식이 됩니다.

2.3 arb 파일을 dart로 바꾸기

arb파일을 변환하려면 역시 intl_translation에서 지원하는 명령어를 써야합니다.

flutter pub run intl_translation:generate_from_arb --output-dir=[저장될 경로] --no-use-deferred-loading [문자열 있어 있는 다트파일] [번역된 arb 파일들]

실행해볼께요.

(맥,리눅스의 경우)


xxxxxxxxxx
flutter pub run intl_translation:generate_from_arb --output-dir=lib/i18n --no-use-deferred-loading lib/i18n/messages.dart lib/i18n/intl_*.arb

(윈도우의 경우)


xxxxxxxxxx
flutter pub run intl_translation:generate_from_arb --output-dir=lib/i18n --no-use-deferred-loading lib/i18n/messages.dart lib /i18n/intl_ko.arb lib/i18n/intl_en.arb

위 명령을 실행하면 messages_all.dart, messages_ko.dart, message_en.dart 가 만들어집니다.

2.4 app에 적용하기

다국어 적용은 LocationDelegate 클래스를 써서 합니다.

번역된 message들을 읽어들이고, 어떤 언어를 지원하는지 알아내서 적용하죠.

i18n/app_localizations.dart


xxxxxxxxxx
import 'dart:async';
import 'package:flutter/material.dart';
import 'package:intl/intl.dart';
import 'messages_all.dart';
class AppLocalizations {
  static Future<AppLocalizations> load(Locale locale) {
    final String name = locale.countryCode == null ? locale.languageCode : locale.toString();
    final String localeName = Intl.canonicalizedLocale(name);
    return initializeMessages(localeName).then((bool _ ) {
      Intl.defaultLocale = localeName;
      return new AppLocalizations();
    });
  }
  static AppLocalizations of(BuildContext context) {
    return Localizations.of<AppLocalizations>(context, AppLocalizations);
  }
}
class AppLocalizationDelegate extends LocalizationsDelegate<AppLocalizations> {
  @override
  bool isSupported(Locale locale) {
    return ['en', 'ko'].contains(locale.languageCode);
  }
  
  @override
  Future<AppLocalizations> load(Locale locale) {
    return AppLocalizations.load(locale);
  }
  @override
  bool shouldReload(LocalizationsDelegate<AppLocalizations> old) {
    return false;
  }
}

AppLocalizationDelegate()를 위젯에 적용해보도록 할께요.

MaterialApp()의 localizationsDelegates 속성과, supportedLocales 속성을 바꿔줘야합니다.

main.dart


xxxxxxxxxx
import 'package:flutter/material.dart';
import 'package:flutter_localizations/flutter_localizations.dart';
import 'package:flutter_internalization/i18n/app_localizations.dart';
import 'i18n/messages.dart';
void main() => runApp(MyApp());
final msg = Messages();
class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      localizationsDelegates: [
        AppLocalizationDelegate(),
        GlobalMaterialLocalizations.delegate,
        GlobalWidgetsLocalizations.delegate,
      ],
      supportedLocales: [Locale("en"), Locale("ko")],
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: MyHomePage(title: 'Flutter Demo Home Page'),
    );
  }
}

전체 프로젝트 구조입니다.

3. iOS의 경우

ios의 경우 Info.plist 도 업데이트 해줘야합니다.

번역 하려는 locale을 추가해야합니다.

Info.plist


<key>CFBundleLocalizations</key>
<array>
  <string>en</string>
  <string>ko</string>
</array>

이번 글에서는 플러터 다국어 지원을 알아보았는데요.

xml 간단히 수정하던 안드로이드에 비하면 번거롭긴 합니다.

해외 출시를 계획중이라면 미리미리 다국어 지원을 해놓기를 권합니다.

한꺼번에 하려면 무척 할 일이 많더군요. (제가 그랬습니다.)

이번 글에 쓰인 코드는 깃허브 에서 확인할 수 있습니다~!

그럼 다음 플러터 글에서 뵐께요 :)

Flutter - CustomPainter로 차트(그래프) 그려보기

에드 신 — Fri, 17 May 2019 18:33:30 +0900

flutter-paint

Flutter CustomPainter 및 차트 그려보기

custom painter란?
canvas, paint
drawLine 등 메소드 사용해보기
그래프 그려보기

이 글에 쓰인 소스 코드는 Github 에서찾아보실 수 있습니다.

플러터를 쓰다보니 입맛에 딱 맞는 그래프 라이브러리가 없더군요.

그래서 커스텀 페인터를 공부해서 직접 차트를 만들어보고 있습니다.

그 과정에서 정리한 걸 공유하려고 합니다!

글을 마칠 때는 아래 같은 차트를 그릴 수 있게 될 거에요.

그럼 시작해 볼께요.

1.CustomPainter 란?

커스텀 페인터는 화면에 직접 UI를 그릴 때 사용합니다. 기존의 UI로 만들기 어려운 화면을 만들고 싶을 때 유용해요.

개인적으론 그래프를 그릴 때 사용했습니다.

직접 UI를 그릴려면 CustomPaint와 CustomPainter 클래스가 있어야 합니다.

용어가 비슷해서 헷갈리는데 정리해볼께요.

1.1CustomPainter와 CustomPaint

CustomPaint는 Container나, Center 같은 위젯이에요.

CustomPaint는 CustomPainter를 담는 그릇이라고 보면 됩니다.

CustomPaint
- Container나, Center 같은 위젯입니다.
- painter를 갖고 있습니다. painter에게 화면을 그리도록 합니다.
- painter -> child -> foregroundPainter 순으로 화면을 그립니다.
CustomPainter
- canvas, paint, size등을 통해 실제 화면을 그릴 때 쓰인다.
- 선 그리기 (drawLine), 원 그리기 (drawCircle) 등 다양한 그리기 함수를 지원합니다.

정의만 보니 어떤 뜻인지 잘 모르겠죠?

실제 코드로 확인해 볼께요.

화면에 직선을 그리는 코드입니다.

완성되면 아래 그림처럼 나올 거에요.

1.2.1 CustomPainter - 스크린에 선 긋기


x
class MyPainter extends CustomPainter {
  @override
  void paint(Canvas canvas, Size size) {
    Paint paint = Paint() // Paint 클래스는 어떤 식으로 화면을 그릴지 정할 때 쓰임.
      ..color = Colors.deepPurpleAccent // 색은 보라색
      ..strokeCap = StrokeCap.round // 선의 끝은 둥글게 함.
      ..strokeWidth = 4.0; // 선의 굵기는 4.0
    Offset p1 = Offset(0.0, 0.0); // 선을 그리기 위한 좌표값을 만듬. 
    Offset p2 = Offset(size.width, size.height); 
    canvas.drawLine(p1, p2, paint); // 선을 그림. 
  }
  @override
  bool shouldRepaint(CustomPainter oldDelegate) {
    return false;
  }
}

일단 CustomPainter 클래스를 정의해볼께요.

CustomPainter는 paint(Canvas canvas, Size size) 와 shouldRepaint(CustomPainter oldDelegate)를 구현해야합니다.

paint()는 화면을 그릴 때 사용합니다. 화면을 새로 그릴때마다 호출되죠.
shouldRepaint()는 화면을 새로 그릴지 말지 정합니다. 예전에 위젯의 좌표값과 비교해, 좌표값이 변했을 때 그린다든지 원하는 대로 조건을 줄 수 있죠.

paint(Canvas canvas, Size size) 은 canvas 객체를 써서 화면을 그립니다.

canvas는 다양한 그리기용 함수를 지원합니다. 선그리기, 사각형 그리기 등 다양하죠.


xxxxxxxxxx
canvas.drawLine(p1, p2, paint);
canvas.drawRect(rect, paint);

canvas는 항상 Paint클래스를 객체로 받는데요. Paint 클래스는 화면이 어떤식으로 그려질지 정합니다.


xxxxxxxxxx
Paint paint = Paint() // Paint 클래스는 어떤 식으로 화면을 그릴지 정할 때 쓰임.
      ..color = Colors.red // 색은 빨강색
      ..strokeWidth = 8.0 // 굵기는 8.0
      ..strokeCap = StrokeCap.round; // 선의 끝은 둥글게

그럼 방금 만든 MyPainter() 클래스를 사용해 보겠습니다.

1.2.2 CustomPaint 위젯


xxxxxxxxxx
class PainterPage extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text("Chart Page"),
      ),
      body: CustomPaint(
        size: Size(200, 200), // 위젯의 크기를 정함. 
        painter: MyPainter(), // painter에 그리기를 담당할 클래스를 넣음.
      ),
    );
  }
}

CustomPaint() 위젯에 좀 전에 만든 MyPainter() 클래스를 넣어주면 됩니다.

그림처럼 나오면 성공입니다.

1.2.3 CustomPaint 위젯 - painter와 foregroundPainter의 차이

CustomPaint()는 위젯의 크기를 정하고, 어떤 painter를 쓸지 결정합니다.

painter는 2 종류가 있습니다.

foregroundPainter, painter인데요.

위젯이 그려지는 순서와 관련이 있습니다.

painter : painter -> child 순으로 그려진다. 나중에 그려지는 위젯이 맨앞에 보인다.


xxxxxxxxxx
CustomPaint(
   size: Size(200, 200),
   painter: MyPainter(), // painter -> child 순으로 그려진다. MyPainter()에서 선을 그림
   child: Container( // 더 늦게 그려지니 화면에 보인다. 
      width: 200,
      height: 200,
      color: Colors.red,
   ),
)

선이 보이지 않네요. child 위젯이 가려서 그렇습니다.

foregroundPainter: child -> foregroundPainter 순으로 그려짐.


xxxxxxxxxx
CustomPaint(
  size: Size(200, 200),
  foregroundPainter: MyPainter(), // child -> foregroundPainter 순으로 그려진다. MyPainter()에서 선을 그림
  child: Container( // child가 먼저 그려지니, 선이 화면에 보이게 된다.
     width: 200,
     height: 200,
     color: Colors.red,
  ),
)

선이 잘 보이죠? CustomPainter(커스텀 페인터)가 child에 가려지는 걸 원치 않으면 foregroundPainter를 써주세요.

1.2.4 CustomPaint 위젯 - 위젯 크기 정하기

커스텀 페인트을 쓰다보면 헷갈리는 부분이 있습니다.

바로 위젯의 크기입니다.

크기가 부모나 자식 위젯때문에 쉽게 변하기에 혼란스럽죠.

위젯의 크기는 기본적으로 부모 > 자식(child) > size (CustomPaint의 속성) 값을 따릅니다.

부모가 크기가 제일 중요하고, 그 다음이 자식이고, 아무것도 없으면 size 값에 따라 위젯의 크기를 정합니다. size도 없으면 위젯이 그려지지 않습니다.

부모, 자식, Size()가 다 있는 경우


xxxxxxxxxx
Container(
        width: 300,
        height: 300,
        child: CustomPaint(
          size: Size(200, 200),
          foregroundPainter: MyPainter(),
          child: Container(
            width: 150,
            height: 150,
          ),
        ),
      )

부모가 있을 때는 부모의 크기 (넓이 300, 높이 300)로 위젯이 그려집니다.

자식과 Size()만 있는 경우


xxxxxxxxxx
CustomPaint(
        size: Size(200, 200),
        foregroundPainter: MyPainter(),
        child: Container(
          width: 150,
          height: 150,
        ),
      )

자식이 있을 때는 자식의 크기 (넓이 150, 높이 150)로 위젯이 그려집니다.

Size()만 있는 경우


xxxxxxxxxx
CustomPaint(
        size: Size(200, 200),
        foregroundPainter: MyPainter(),
      )

Size만 있을 때는 Size의 크기에 따라 (넓이 150, 높이 150)로 위젯이 그려집니다.

Size가 우선순위가 제일 낮습니다.

2.그래프(차트 ) 그려보기

2.1 - 파이 차트 그려보기

CustomPainter를 써서 직접 차트를 그려볼께요.

가장 먼저 그릴 차트는 파이 (원) 차트 입니다.

완성되면 아래 그림처럼 나올거에요.

그림 2-1. pie chart

프로젝트 구조는 아래와 같습니다.

ui와 chart만 있는 간단한 구조입니다.

일단 main을 정의해주세요.

2.1 main.dart


xxxxxxxxxx
import 'package:flutter/material.dart';
import 'package:flutter_sketcher_app/ui/chart_page.dart';
void main() => runApp(MyApp());
class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Chart Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: ChartPage(),
      debugShowCheckedModeBanner: false,
    );
  }
}

대부분의 코드는 chart_page.dart에 작성할 거에요.

2.1 chart_page.dart


x
class ChartPage extends StatelessWidget {
  List<double> points = [50, 0, 73, 100,150, 120, 200, 80];
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text("Chart Page"),
      ),
      body: Container(
        padding: const EdgeInsets.symmetric(vertical: 8.0),
        child: Center(
          child: Column(
            children: <Widget>[
              Container(
                child: CustomPaint( // CustomPaint를 그리고 이 안에 차트를 그려줍니다.. 
                  size: Size(150, 150), // CustomPaint의 크기는 가로 세로 150, 150으로 합니다. 
                  painter: PieChart(percentage: 50, // 파이 차트가 얼마나 칠해져 있는지 정하는 변수입니다.
                      textScaleFactor: 1.0, // 파이 차트에 들어갈 텍스트 크기를 정합니다. 
                      textColor: Colors.blueGrey),
                ),
              ),
            ],
          ),
        ),
      ),
    );
  }
}

파이 차트는 원을 2개 그리고, 그 안에 텍스트를 그려서 만듭니다.

원을 그릴 때는 drawCircle() 와 drawArc() 함수를 사용합니다.

drawCircle()는 정해진 위치에 원을 그릴 때 쓰고,

drawArc()는 타원이나, 열린 원(끝이 닫히지 않은 원)을 그릴 때 씁니다.

2.1 pie_chart.dart


xxxxxxxxxx
class PieChart extends CustomPainter {
  int percentage = 0; 
  double textScaleFactor = 1.0;
  @override
  void paint(Canvas canvas, Size size) {
    Paint paint = Paint() // 화면에 그릴 때 쓸 Paint를 정의합니다. 
        ..color = Colors.orangeAccent
        ..strokeWidth = 10.0 // 선의 길이를 정합니다. 
        ..style = PaintingStyle.stroke // 선의 스타일을 정합니다. stroke면 외곽선만 그리고, fill이면 다 채웁니다. 
        ..strokeCap = StrokeCap.round; // stroke의 스타일을 정합니다. round를 고르면 stroke의 끝이 둥글게 됩니다. 
    double radius = min(size.width / 2 - paint.strokeWidth / 2 , size.height / 2 - paint.strokeWidth/2); // 원의 반지름을 구함. 선의 굵기에 영향을 받지 않게 보정함. 
    Offset center = Offset(size.width / 2, size.height/ 2); // 원이 위젯의 가운데에 그려지게 좌표를 정함.
    canvas.drawCircle(center, radius, paint); // 원을 그림. 
    double arcAngle = 2 * pi * (percentage / 100); // 호(arc)의 각도를 정함. 정해진 각도만큼만 그리도록 함. 
    paint..color = Colors.deepPurpleAccent; // 호를 그릴 때는 색을 바꿔줌. 
    canvas.drawArc(Rect.fromCircle(center: center, radius: radius), -pi / 2, arcAngle, false, paint); // 호(arc)를 그림.
    drawText(canvas, size, "$percentage / 100"); // 텍스트를 화면에 표시함.
  }
  // 원의 중앙에 텍스트를 적음.
  void drawText(Canvas canvas, Size size, String text) {
    double fontSize = getFontSize(size, text);
    TextSpan sp = TextSpan(style: TextStyle(fontSize: fontSize, fontWeight: FontWeight.bold, color: Colors.black), text: text); // TextSpan은 Text위젯과 거의 동일하다. 
    TextPainter tp = TextPainter(text: sp, textDirection: TextDirection.ltr); 
    tp.layout(); // 필수! 텍스트 페인터에 그려질 텍스트의 크기와 방향를 정함.
    double dx = size.width / 2 - tp.width / 2;
    double dy = size.height / 2 - tp.height / 2;
    Offset offset = Offset(dx, dy); 
    tp.paint(canvas, offset);
  }
  // 화면 크기에 비례하도록 텍스트 폰트 크기를 정함.
  double getFontSize(Size size, String text) {
    return size.width / text.length * textScaleFactor;
  }
  @override
  bool shouldRepaint(PieChart old) {
    return old.percentage != percentage;
  }
}

텍스트를 그리는 부분만 볼께요.

CustomPainter에 텍스트를 적으려면 꼭 TextPainter를 써야 합니다.

TextPainter()는 텍스트의 좌표를 정하는데 쓰입니다.

TextPainter를 쓸 땐 꼭 layout() 함수를 호출해줘야 합니다. 그래야 텍스트의 크기와 방향을 에서 알 수 있습니다.

TextSpan()은 기존의 Text() 위젯과 거의 동일합니다.

원과 글자가 제대로 나오나요?

그럼 다음에 그릴 차트는 라인 차트(선) 차트입니다.

2.2 라인 차트 그려보기

라인 차트는 아래의 그림처럼 생겼습니다.

각각의 값이 점(포인트)로 표현되고, 점들을 연결하고 있습니다.

또한 최저값이랑 최고값을 표시합니다.

라인 차트는 파이 차트랑 비슷한데요.

drawArc() 대신에 drawPath()와 drawPoints() 함수를 사용합니다.

drawPath(Path path, Paint paint) 선을 그릴 때 씁니다. path에 있는 좌표를 따라서 선을 그립니다.


x
    Paint paint = Paint()
        ..strokeWidth = 5.0
        ..style = PaintingStyle.stroke
        ..color = Colors.red;
    Path path = Path();
    path.moveTo(0.0, 0.0); // (0.0, 0.0) 좌표로 이동 
    path.lineTo(120.0, 120.0); // 시작점에서 (120.0, 120.0) 까지 선을 그음
    canvas.drawPath(path, paint);

drawPoints(PointMode pointMode, List points, Paint paint) 은 점을 그릴 때 씁니다.


x
    Paint paint = Paint()
        ..strokeCap = StrokeCap.round // 선이 연결되는 지점이 둥글게 되도록 합니다. 점을 원으로 찍기 위해서 씁니다.  
        ..color = Colors.yellow
        ..strokeWidth = 30;
    List<Offset> offsetPoints = []; 
    offsetPoints.add(Offset(10, 10)); // 점의 위치를 더합니다.  
    offsetPoints.add(Offset(60, 60));
    offsetPoints.add(Offset(160, 160));
    canvas.drawPoints(PointMode.points, offsetPoints, paint); // 점을 화면에 그립니다.

라인 차트에서 쓰는 주요 함수를 알아봤으니 직접 차트를 그려볼께요.

일단 chart_page.dart 에 라인 차트를 포함해주세요.

2.2 chart_page.dart


xxxxxxxxxx
class ChartPage extends StatelessWidget {
  List<double> points = [50, 0, 73, 100, 150, 120, 200, 80];
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text("Chart Page"),
      ),
      body: Container(
        padding: const EdgeInsets.symmetric(vertical: 8.0),
        child: Center(
          child: Column(
            children: <Widget>[
              Container(
                child: CustomPaint(
                    size: Size(200, 200),
                    foregroundPainter: LineChart(
                        points: points, 
                        pointSize: 15.0, // 점의 크기를 정합니다. 
                        lineWidth: 5.0, // 선의 굵기를 정합니다.
                        lineColor: Colors.purpleAccent, // 선의 색을 정합니다.
                        pointColor: Colors.purpleAccent)), // 점의 색을 정합니다.
              )
            ],
          ),
        ),
      ),
    );
  }
}

line_chart는 크게 4개의 함수로 되어 있습니다.

getCoordinates() : 좌표 구하기
drawText() : 텍스트 그리기
drawLines(): 선 그리기
drawPoints(): 점 그리기

2.2 line_chart.dart


xxxxxxxxxx
class LineChart extends CustomPainter {
  List<double> points;
  double lineWidth;
  double pointSize;
  Color lineColor;
  Color pointColor;
  int maxValueIndex;
  int minValueIndex;
  double fontSize = 18.0;
  LineChart({this.points, this.pointSize, this.lineWidth, this.lineColor, this.pointColor});
  @override
  void paint(Canvas canvas, Size size) {
    List<Offset> offsets = getCoordinates(points, size); // 점들이 그려질 좌표를 구합니다.
    drawText(canvas, offsets); // 텍스트를 그립니다. 최저값과 최고값 위아래에 적은 텍스트입니다. 
    drawLines(canvas, size,  offsets); // 구한 좌표를 바탕으로 선을 그립니다.
    drawPoints(canvas, size, offsets); // 좌표에 따라 점을 그립니다. 
  }
  void drawLines(Canvas canvas, Size size, List<Offset> offsets) {
    Paint paint = Paint()
      ..color = lineColor
      ..strokeWidth = lineWidth
      ..style = PaintingStyle.stroke
      ..strokeCap = StrokeCap.round;
    Path path = Path(); 
    double dx = offsets[0].dx;
    double dy = offsets[0].dy;
    path.moveTo(dx, dy);
    offsets.map((offset) => path.lineTo(offset.dx , offset.dy)).toList();
    canvas.drawPath(path, paint);
  }
  void drawPoints(Canvas canvas, Size size, List<Offset> offsets) {
    Paint paint = Paint()
        ..color = pointColor
        ..strokeCap = StrokeCap.round
        ..strokeWidth = pointSize;
    canvas.drawPoints(PointMode.points, offsets, paint);
  }
  List<Offset> getCoordinates(List<double> points, Size size) {
    List<Offset> coordinates = [];
    double spacing = size.width / (points.length - 1); // 좌표를 일정 간격으로 벌리지 위한 값을 구합니다.
    double maxY = points.reduce(max); // 데이터 중 최소값을 구합니다. 
    double minY = points.reduce(min); // 데이터 중 최대값을 구합니다. 
    double bottomPadding = fontSize * 2; // 텍스트가 들어갈 패딩(아랫쪽)을 구합니다.
    double topPadding = bottomPadding * 2; // 텍스트가 들어갈 패딩(위쪽)을 구합니다.
    double h = size.height - topPadding; // 패딩을 제외한 화면의 높이를 구합니다. 
    for (int index = 0; index < points.length; index++) {
      double x = spacing * index; // x축 좌표를 구합니다. 
      double normalizedY = points[index] / maxY; // 정규화한다. 정규화란 [0 ~ 1] 사이가 나오게 값을 변경하는 것.
      double y = getYPos(h, bottomPadding, normalizedY); // Y축 좌표를 구합니다. 높이에 비례한 값입니다. 
      Offset coord = Offset(x, y);
      coordinates.add(coord);
      findMaxIndex(points, index, maxY, minY); // 텍스트(최대값)를 적기 위해, 최대값의 인덱스를 구해놓습니다. 
      findMinIndex(points, index, maxY, minY); // 텍스트(최소값)를 적기 위해, 최대값의 인덱스를 구해놓습니다. 
    }
    return coordinates;
  }
  double getYPos(double h, double bottomPadding, double normalizedY) => (h + bottomPadding) - (normalizedY * h); 
  void findMaxIndex(List<double> points, int index, double maxY, double minY) {
    if (maxY == points[index]) {
      maxValueIndex = index;
    }
  }
  void findMinIndex(List<double> points, int index, double maxY,double minY) {
    if (minY == points[index]) {
      minValueIndex = index;
    }
  }
  void drawText(Canvas canvas, List<Offset> offsets) {
    String maxValue = points.reduce(max).toString();
    String minValue = points.reduce(min).toString();
    drawTextValue(canvas, minValue, offsets[minValueIndex], false); 
    drawTextValue(canvas, maxValue, offsets[maxValueIndex], true);
  }
  void drawTextValue(Canvas canvas, String text, Offset pos, bool textUpward) {
    TextSpan maxSpan = TextSpan(style: TextStyle(fontSize: fontSize, color: Colors.black, fontWeight: FontWeight.bold), text: text); 
    TextPainter tp = TextPainter(text: maxSpan, textDirection: TextDirection.ltr);
    tp.layout();
    double y = textUpward ? -tp.height * 1.5  : tp.height * 0.5; // 텍스트의 방향을 고려해 y축 값을 보정해줍니다.
    double dx = pos.dx - tp.width / 2; // 텍스트의 위치를 고려해 x축 값을 보정해줍니다.
    double dy = pos.dy + y; 
    Offset offset = Offset(dx, dy);
    tp.paint(canvas, offset);
  }
  @override
  bool shouldRepaint(LineChart oldDelegate) {
    return oldDelegate.points != points;
  }
}

차트가 잘 그려지나요?

이번엔 바 차트(막대 그래프)를 만들어보겠습니다

2.3. 바 차트 그려보기

바 차트는 가로와 세로에 텍스트를 적을 수 있게 만들었습니다.

연도별 제품 판매량이나 생산량 같은 걸 나타내기에 좋습니다.

2.3 chart_page.dart


xxxxxxxxxx
class ChartPage extends StatelessWidget {
  List<double> points = [50, 90, 1003, 500, 150, 120, 200, 80];
  List<String> labels = [ // 가로축에 적을 텍스트(레이블)
    "2012",
    "2013",
    "2014",
    "2015",
    "2016",
    "2017",
    "2018",
    "2019",
  ];
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text("Chart Page"),
      ),
      body: Container(
        padding: const EdgeInsets.symmetric(vertical: 8.0),
        child: Center(
          child: Column(
            children: <Widget>[
              Container(
                child: CustomPaint(
                    size: Size(300, 300),
                    foregroundPainter: BarChart(
                        data: points,
                        labels: labels,
                        color: Colors.pinkAccent)), // color - 막대 그래프의 색깔
              )
            ],
          ),
        ),
      ),
    );
  }
}

바 차트는 3부분으로 되어 있습니다.

좌표를 구하는 부분 - 어디다 그래프를 그릴지 정합니다.

그래프를 그리는 부분 - 실제 막대 그래프를 그립니다. 그래프를 그릴 때는 drawRect() 함수를 사용합니다.
텍스트를 그리는 부분 - x축과 y축에 텍스트를 그립니다. 이번엔 정해진 폰트 크기가 아니라, 화면 크기에 비례해 폰트 크기가 정해지도록 계산합니다.

바 차트는 길어서 설명 보다는 주석으로 대체하였습니다.

코드를 따라하면서 익히시기를 권합니다.

2.3 bar_chart.dart


x
class BarChart extends CustomPainter {
  Color color;
  double textScaleFactorXAxis = 1.0; // x축 텍스트의 비율을 정함. 
  double textScaleFactorYAxis = 1.2; // y축 텍스트의 비율을 정함. 
  List<double> data = [];
  List<String> labels = [];
  double bottomPadding = 0.0;
  double leftPadding = 0.0;
  BarChart({this.data, this.labels, this.color = Colors.blue});
  @override
  void paint(Canvas canvas, Size size) {
    setTextPadding(size); // 텍스트를 공간을 미리 정함.
    List<Offset> coordinates = getCoordinates(size);
    drawBar(canvas, size, coordinates);
    drawXLabels(canvas, size, coordinates);
    drawYLabels(canvas, size, coordinates);
    drawLines(canvas, size, coordinates);
  }
  void setTextPadding(Size size) {
    bottomPadding = size.height / 10; // 세로 크기의 1/10만큼만 텍스트 패딩을 줌
    leftPadding = size.width / 10; // 가로 길이의 1/10만큼 텍스트 패딩을 줌
  }
  void drawBar(Canvas canvas, Size size, List<Offset> coordinates) {
    Paint paint = Paint()
      ..color = color
      ..style = PaintingStyle.fill
      ..strokeCap = StrokeCap.round;
    double barWidthMargin = (size.width * 0.09); // 막대 그래프가 겹치지 않게 간격을 줌. 
    for (var index = 0; index < coordinates.length; index++) {
      Offset offset = coordinates[index];
      double left = offset.dx;
      double right = offset.dx + barWidthMargin; // 간격만큼 가로로 이동
      double top = offset.dy;
      double bottom = size.height - bottomPadding; // 텍스트 크기만큼 패딩을 빼줘서, 텍스트와 겹치지 않게 함.  
      Rect rect = Rect.fromLTRB(right, top, left, bottom);
      canvas.drawRect(rect, paint);
    }
  }
  // X축 텍스트(레이블)을 그림. 
  void drawXLabels(Canvas canvas, Size size, List<Offset> coordinates) {
    double fontSize = calculateFontSize(labels[0], size, xAxis: true); // 화면 크기에 유동적으로 폰트 크기를 계산함. 
    for (int index = 0; index < labels.length; index++) {
      TextSpan span = TextSpan(
          style: TextStyle(
              color: Colors.black,
              fontSize: fontSize,
              fontFamily: 'Roboto',
              fontWeight: FontWeight.w400),
          text: labels[index]);
      TextPainter tp = TextPainter(text: span, textDirection: TextDirection.ltr);
      tp.layout();
      Offset offset = coordinates[index];
      double dx = offset.dx;
      double dy = size.height - tp.height;
      tp.paint(canvas, Offset(dx, dy));
    }
  }
  // Y축 텍스트(레이블)을 그림. 최저값과 최고값을 Y축에 표시함.
  void drawYLabels(Canvas canvas, Size size, List<Offset> coordinates) {
    double bottomY = coordinates[0].dy;
    double topY = coordinates[0].dy;
    int indexOfMax = 0; 
    int indexOfMin = 0; 
    for (int index = 0; index < coordinates.length; index++) {
      double dy = coordinates[index].dy;
      if (bottomY < dy) {
        bottomY = dy;
        indexOfMin = index;
      }
      if (topY > dy) {
        topY = dy;
        indexOfMax = index;
      }
    }
    String maxValue = "${data[indexOfMax].toInt()}";
    String minValue = "${data[indexOfMin].toInt()}";
    double fontSize = calculateFontSize(maxValue, size, xAxis: false);
    drawYText(canvas, maxValue, fontSize, topY);
    drawYText(canvas, minValue, fontSize, bottomY);
  }
  // 화면 크기에 비례해 폰트 크기를 계산. 
  double calculateFontSize(String value, Size size, {bool xAxis}) {
    int numberOfCharacters = value.length; // 글자수에 따라 폰트 크기를 계산하기 위함. 
    double fontSize = (size.width / numberOfCharacters) / data.length; // width가 600일 때 100글자를 적어야 한다면, fontSize는 글자 하나당 6이어야겠죠. 
    if (xAxis) {
      fontSize *= textScaleFactorXAxis; 
    } else {
      fontSize *= textScaleFactorYAxis;
    }
    return fontSize;
  }
  // x축과 y축을 구분하는 선을 긋습니다. 
  void drawLines(Canvas canvas, Size size, List<Offset> coordinates) {
    Paint paint = Paint()
      ..color = Colors.blueGrey[100]
      ..strokeCap = StrokeCap.round
      ..style = PaintingStyle.stroke
      ..strokeWidth = 1.8;
    double bottom = size.height - bottomPadding;
    double left = coordinates[0].dx;
    Path path = Path();
    path.moveTo(left, 0);
    path.lineTo(left, bottom);
    path.lineTo(size.width, bottom);
    canvas.drawPath(path, paint);
  }
  void drawYText(Canvas canvas, String text, double fontSize, double y) {
    TextSpan span = TextSpan(
      style: TextStyle(
          fontSize: fontSize,
          color: Colors.black,
          fontFamily: 'Roboto',
          fontWeight: FontWeight.w600),
      text: text,
    );
    TextPainter tp = TextPainter(text: span, textDirection: TextDirection.ltr);
    tp.layout();
    Offset offset = Offset(0.0, y);
    tp.paint(canvas, offset);
  }
  List<Offset> getCoordinates(Size size) {
    List<Offset> coordinates = [];
    double maxData = data.reduce(max);
    double width = size.width - leftPadding;
    double minBarWidth = width / data.length;
    for (var index = 0; index < data.length; index++) {
      double left = minBarWidth * (index) + leftPadding; // 그래프의 가로 위치를 정합니다. 
      double normalized = data[index] / maxData; // 그래프의 높이가 [0~1] 사이가 되도록 정규화 합니다.
      double height = size.height - bottomPadding; // x축에 표시되는 글자들과 겹치지 않게 높이에서 패딩을 제외합니다.
      double top = height - normalized * height; // 정규화된 값을 통해 높이를 구해줍니다. 
      Offset offset = Offset(left, top);
      coordinates.add(offset);
    }
    return coordinates;
  }
  @override
  bool shouldRepaint(BarChart old) {
    return old.data != data;
  }
}

이제 커스텀 페인터를 쓰는 데 익숙해 졌나요?

이번 글에선 직접 차트를 만들어 보았습니다.

다음 번엔 애니메이션에 대해 알아보도록 하겠습니다.

이 글에 쓰인 소스 코드는 Github 에서찾아보실 수 있습니다.

파이썬 - 데이터 분석 라이브러리 (numpy, pandas, matplotlib) 익히기

에드 신 — Wed, 24 Apr 2019 16:48:44 +0900

data

0. dimension (차원)

리스트를 쓰다보면 중첩된 구조를 쓰는 경우가 종종 있습니다.

중첩되었다는 건, 리스트 안에 리스트가 있는 건데요.

데이터 쪽에서는 중첩된 정도를 구분하기 위해 차원이란 말을 씁니다.

1번 중첩되면 1차원, 2번 중첩되면 2차원이죠.


xxxxxxxxxx
[1,2,3,4] # 1차원
[[10,11,12], [30, 40, 50]] # 2차원
[
 [[100,110,120], [130, 140, 150]], 
 [[200,210,220], [230, 240, 250]]
] # 3차원

일반적인 리스트로는 중첩된 자료를 처리하는 게 느리고, 복잡해서 numpy(넘파이)라는 라이브러리를 많이 씁니다.

1. numpy (넘파이)

numpy는 과학 연산을 위한 라이브러리입니다. 리스트, 배열, 매트릭스 연산을 빠르게 하는 걸 도와줍니다.

리스트와 넘파이의 속도 차이는 30~40배까지도 난다고 하네요.

데이터가 커질수록 넘파이는 필수겠죠.

numpy의 배열(array)를 쓰는 법을 알아볼께요.


xxxxxxxxxx
import numpy as np
a = np.array([1,2,3])
# 1행
print(a.shape)
print(a[0])
print(a[1])
b = np.array(
    [[1,2,3], 
    [4,5,6]]
)
# 2행 3열
print(b.shape)
print(b[0])
print(b[1])
print(b[0, 1])
print(b[1, 1])
c = [[1,2,3], [4,5,6]]
print(c[0][1])

넘파이도 리스트처럼, 인덱스로 원하는 값을 접근할 수 있습니다. 다만 2차원 넘파이부터는 데이터 접근 방식이 좀 다릅니다.


xxxxxxxxxx
import numpy as np
a = np.array([ 
    [1,2],
    [3,4],
    [5,6]
])
# 조건을 적용할 수 있다. 
bool_idx = (a > 2 )
print(bool_idx)
# 2보다 큰 값만 출력한다.
print(a[ a > 2 ])


xxxxxxxxxx
import numpy as np
a = np.array([
    [1,2],
    [3,4]
])
b = np.array([
    [10, 11],
    [12, 13]
])
print(a + b)
print(np.add(a, b))
print(a - b)
print(np.subtract(a, b))
print(a * b)
print(np.multiply(a, b))
print(a / b)
print(np.multiply(a, b))


xxxxxxxxxx
import numpy as np
x = np.array([ [1,2,3], [4,5,6] ])
print(np.sum(x, axis=0)) # 열(column)끼리 값을 더합니다. 
print(np.sum(x, axis=1)) # 행(row)끼리 값을 더합니다.

2. pandas (판다스)

2.1 pandas - 열과 행 다뤄보기

데이터 프레임은 행과 열로 이루어진 표입니다. 데이터 프레임을 이용하면 각 열(칼럼)에 있는 값을 편하게 쓸 수 있습니다. 평균 나이를 구하거나, 성적이 상위 20%인 사람을 구하는 것도 쉽죠.

데이터 프레임은 행과 열로 데이터를 구분합니다.

행을 index(인덱스)리고 부르고, 열은 칼럼이라고 부르죠.


xxxxxxxxxx
import pandas as pd
# 딕셔너리의 키를 열이름(칼럼명)으로 쓴다. 
df = pd.DataFrame({
    'name': ['Bob', 'Alice', 'Jane'],
    'age': [71, 33, 58]
})
print(df)
# (3,2) 출력. 3행 2열의 데이터 프레임이란 뜻이다.
print(df.shape) 
# 열 별로 데이터를 이용할 수 있다.
print(df['age']) 
print(df['name'])
print(df[:1])
print(df.index) # 인덱스 알아보기. 
print(df.columns) # 칼럼 알아보기.

2.2 pandas - 필터링 및 정렬 하기

데이터 프레임의 기본 기능을 사용하면 원하는 데이터만 쉽게 필터링 하고, 정렬할 수 있죠!

보통 엑셀을 많이 쓰는 이유가 정렬이나 필터링, vlookup 같은 기능 때문인데요.

파이썬을 쓰면 엑셀의 모든 기능을 쉽게 대체할 수 있습니다.

물론 속도는 파이썬이 비교할 수 없을 정도로 빠르구요.


xxxxxxxxxx
import pandas as pd
df = pd.DataFrame({
    'weight': [91, 85, 100, 75, 43, 38],
    'height': [180, 173, 190, 170, 163, 152],
    'gender': ['male','female', 'male', 'female', 'female', 'male']
})
print(df['weight'] > 80) # weight가 80 이상이면 True 아니면 False인 데이터 프레임을 만듬.
df_filtered = df[df['weight'] > 80]
print(df_filtered) # weight가 80 이상인 값만 남았습니다.
df_sorted = df_filtered.sort_values('weight', ascending=True) # weight 기준으로 오름차순으로 정렬. 몸무게가 적은 순으로 정렬
print(df_sorted)
df_sorted = df_filtered.sort_values('height', ascending=False) # height 기준으로 내림차순으로 정렬. 키가 큰 순으로 정렬.
df_grouped = df.groupby('gender') # 데이터를 그룹으로 묶어줍니다. 성별에 따라 키와 몸무게를 그룹으로 만들겠죠.
df_grouped_mean = df_grouped.mean() # 성별에 따른 키와 몸무게의 평균
for key, group in df_grouped:
    print(key) # 그룹을 묶을 때 쓴 키입니다. 
    print(group) # 키로 묶인 그룹입니다.

2.3 pandas - 통계 관련 함수

판다스는 다양한 내장 함수를 제공합니다.

기초적인 통계를 구할 때 유용하죠.

총합(sum), 평균(mean), 상관관계(correlation), 누적합(cursum), 요약(describe) 등 지원하는 함수가 많습니다.


xxxxxxxxxx
import pandas as pd
df = pd.DataFrame({
    '몸무게': [70, 80, 90, 82, 91],
    '키': [170, 181, 185, 168, 180]})
total_age = df['몸무게'].sum() # 몸무게 총합을 구한다.
print(total_age)
mean_age = df['키'].mean() #  키의 평균을 구한다.
print(mean_age)
print(df.describe()) # 요약된 통계 결과를 보여줍니다.
corr = df.corr() # 항목들간의 상관관계를 보여줍니다.
print(corr) # 상관 계수가 1에 가까울 수록 양의 상관관계가 있고, -1에 가까울수록 음의 상관관계가 있고, 0에 가까울수록 서로 상관이 없습니다.(독립적)

2.4 pandas - csv 읽기와 저장하기

csv 읽고 쓰는 건 정말 간단합니다.


xxxxxxxxxx
import pandas as pd
df = pd.read_csv('my_csv.csv') # 읽기
print(df)

한줄이면 쓰기가 됩니다.


xxxxxxxxxx
import pandas as pd
df = pd.DataFrame({
    'name': ['Bob', 'Jane', 'Mike'],
    'age': [20, 33, 45]
})
df.to_csv('my_data.csv') # 쓰기

3. matplotlib - 시각화 라이브러리

매트플롯은 데이터를 시각화 할 때 쓰는 라이브러리입니다.

곡선이나 원, 막대 그래프 등을 그릴 수 있죠.

간단한 그래프 그려보기


xxxxxxxxxx
import matplotlib.pyplot as plt
x = [1, 2, 3]
y = [0, 1, 2]
plt.plot(x, y) # 그래프 그리기
plt.show() # 그래프 보여주기

사인 곡선 그려보기


xxxxxxxxxx
import numpy as np
import matplotlib.pyplot as plt
x = np.arange(0, 10, 0.1) # np.arange()는 리스트를 만들 때 씁니다.  np.arange(시작점,끝점,증가량)이죠.
print(x) 
y = np.sin(x)
plt.plot(x, y)
plt.show()

여러 그래프 같이 그려보기


xxxxxxxxxx
import numpy as np
import matplotlib.pyplot as plt
t = np.arange(0., 10., 0.2)
# 여러 점 동시에 그리기. 
plt.plot(t, t, 'r--', # x축 값은 t, y축 값은 y 
         t, 2 * t, 'bs',  # x축 값은 t, y축 값은 2 *t
         t, t**2, 'g^') # x 축 값은 t, y 축 값은 t^2
plt.title('several graphs') # 그래프에 제목 붙이기          
plt.show()

매트 플롯으로 이렇게 일일이 그래프를 그릴 수도 있지만

판다스 라이브러리는 매트 플롯을 통해 그래프 그리는 기능을 지원합니다.

막대 그래프 그려보기


xxxxxxxxxx
import numpy as np
import pandas as pd
import random
import matplotlib.pyplot as plt
age = [random.randint(20, 100) for x in range(0, 50)] # 랜덤인 정수(정수 범위 0~100)가 50개 있는 리스트를 만듭니다. 
weight = [random.randint(40, 150) for i in range(0, 50)]   
df = pd.DataFrame({
    'age': age,
    'weight': weight
})
df.plot(kind='bar', subplots=True) # pandas 라이브러리 써서 그래프 그림.
plt.title('Bar Chart') # 차트에 제목 붙이기
plt.savefig('bar_chart_random.png') # 차트 이미지로 저장하기
plt.show()

4. 분석 예제 - 유제품 생산량 및 소비량 분석

이 데이터는 매년 생산되는 유제품(치즈, 버터, 연유, 탈지분유 등)의

생산량과 소비량을 나타내고 있습니다.

데이터의 항목은 년도(year), 유제품 종류(dairy), 생산량(production), 소비량(consumption) 으로 이뤄져 있습니다.

어떤 유제품이 더 많이 소비되는지를 보면 산업의 대략적인 흐름을 알 수 있겠죠?

4.1.1 유제품 전체 생산량, 소비량


xxxxxxxxxx
import pandas as pd
data = pd.read_csv('csv/milk.csv')
# 위의 5개 데이터만 출력
print(data.head(5)) 
# 열 이름 출력 - 'year', 'dairy', 'production', 'consumption'
print(data.columns)
data = data.set_index('year') # index를 year로 정합니다. index는 데이터를 구분할 때 쓰는 기준입니다.
 
print(data.describe())
print(data.min())
print(data.max())

데이터를 묶어서 보니 의미를 알기가 어렵죠.

평균이랑 최대값을 구했는데도 어디에 써야할지 모르겠네요.

데이터를 좀 더 세분화해서 볼께요.

4.2.1 유제품 종류로 본 생산량, 소비량

유제품 별로 나눠서 데이터를 보도록 하겠습니다.

다운로드

groupby() 함수를 쓸께요.

데이터 타입은 숫자형(numerical data), 범주형(categorical data)가 있는데요.

숫자형은 1,2,3 같은 숫자로 되어 있는 데이터 타입을 말합니다. 판매량, 가격 같은 게 숫자형이지요.

범주형은 몇개의 종류로 나눠진 데이터 형태를 말합니다.

셩별(남자/여자), 혈액형(A/B/O/AB), 영화장르(코미디/액션/로맨틱/호러), 성적(1등/2등/3등/4등/5등)

groupby()는 범주형 데이터에 적용해 주는 게 좋습니다.


xxxxxxxxxx
import pandas as pd
data = pd.read_csv('csv/milk.csv')
grouped_dairy = data.groupby('dairy')
# 유제품들의 연평균 생산량과 소비량을 출력
print(grouped_dairy.mean())
# 유제품이 가장 적게 소비되고, 생산된 연도의 데이터를 출력
print(grouped_dairy.min())
# 유제품이 가장 많이 소비되고, 생산된 연도의 데이터를 출력
print(grouped_dairy.max())
# 특정 dairy의 값만 출력
grouped_dairy.get_group('치즈')
grouped_dairy.get_group('연유')
grouped_dairy.get_group('연유').sort_values('year', ascending=True) # sort_values() - 정렬함. 오른차순으로.
# group by로 정렬 후, 특정 year의 값만 출력
grouped_year = data.groupby('year')
grouped_year.get_group(2015) 
grouped_year.get_group(2011)

4.2.2 시각화 하기

유제품별 생산량과 소비량을 그래프로 그려보겠습니다.

그래프로 그리면 어떤 제품이 생산량 대비 소비가 많은지 알 수 있겠죠.

소비량이 생산량보다 많으면 수입을 하겠죠?


xxxxxxxxxx
def milk_graph():
    import pandas as pd
    import matplotlib.pyplot as plt
    data = pd.read_csv('csv/milk.csv')
    data = data.set_index('year')
    grouped_dairy = data.groupby('dairy')
    for key, group in grouped_dairy:
        group_sorted = group.sort_values('year', ascending=True)
        group_sorted.plot(kind='bar', subplots=False)
        plt.legend(['production', 'consumption'])
        plt.xlabel(key)
        plt.savefig('milk_graph_{}.png'.format(key))
    plt.show()
    plt.close()
milk_graph()

5. 분석 예제 - 온라인 쇼핑몰 데이터 보기

온라인 쇼핑몰 데이터를 분석해볼께요.

다운로드

공공 데이터 포털에서 구했구요. 아마도 네이버 스마트 스토어를 크롤링한 것 같아요.

제품의 id(good_id), 가격(sales_price), 제품 종류(pun_name) 등의 항목으로 구성되어 있습니다.

아래 코드를 보면서 어떤 데이터인지 알아볼께요.


xxxxxxxxxx
import pandas as pd
import numpy as np
df = pd.read_csv('csv/commerce_20190301.csv')
print(df[df['sales_price'] < 10000]) # 판매 가격이 10,000원 아래인 물품만 출력합니다. 
df_filtered = df[df['sales_price'] < 10000] 
df_sorted = df_filtered.sort_values('sales_price', ascending=False) # 판매가격이 10,000원 이하인 제품중에 싼 순으로 정렬합니다. 
print(df_sorted.head(5)) # head()는 위에서부터 데이터 프레임을 잘라서 쓸 때 씁니다. head(5)는 5개만 데이터를 쓴다는 뜻이죠.
category = df.groupby('pum_name') # 항목별로 데이터를 묶습니다. 
# agg()는 데이터 프레임에 여러 함수를 적용할 때 씁니다. 최소값(min), 최대값(max), 평균(mean)을 한번에 구하고 있습니다.  
category_agg = category.agg([np.min, np.max, np.mean]) 
  
print( category_agg) 
print( category_agg.columns)
print( category_agg[['sales_price', 'discount_price']] ) # sales_price와 discount_price 열만 확인합니다.

데이터의 형태를 알아보았으니

제품의 항목별로 나눠서 보도록 할께요.


xxxxxxxxxx
df = pd.read_csv('csv/commerce_20190301.csv')
grouped_by_category = df.groupby('pum_name')
running_suit = grouped_by_category.get_group('운동복') # 제품 종류 중에서 운동복만 가져다 쓰려고 합니다.
print(running_suit)
print(running_suit.min())
print(running_suit.max())

운동복의 최저가는 4350인데, 최고가는 389,920 이네요.

여러 날의 데이터를 수집한다면 제품 가격의 변화를 알아내거나, 물가 변동을 알 수 있겠죠.

하루치 데이터라 분석이 좀 단순하긴 한데요.

크롤링과 합치면 분석을 응용할 곳이 많습니다.

해외에서 수입해서 중간 거래만 하는 사람이라면, 경쟁 상대가 상품을 얼마에 올리는가,

해외에선 동일한 제품이 얼마인가를 자동화 툴로 주시하다가

이익이 날만한 제품만 올릴 수도 있죠.

특히 1일치 데이터 뿐만 아니라 장기간 데이터를 수집하면 가치가 더 올라갑니다.

경쟁상대는 몇명이 있는가, 가격이 올라가는 추세인가, 떨어지는 추세인가 알아볼 수 있죠.

다만 온라인 쇼핑 데이터 수집할 때는 단위(3kg, 50개)를 보고, 그 단위에 맞게 가격등을 조절해야합니다.

이 글에서는 하지 않았지만 직접 해보시기를 권합니다.

이번 글과 지난 글에서 정말 기본적인 크롤링과 분석 라이브러리 사용법을 알아보았습니다.

다음에는 크론잡으로 주기적으로 크롤링 하는 법을 알아보겠습니다.

참고 사이트 - numpy 라이브러리 설명, 스탠포드 수업 ( http://cs231n.github.io/python-numpy-tutorial/ )

참고 사이트 - 공공 데이터 포펄 ( https://www.data.go.kr/search/index.do )

추천 영상 - 인생은 짧아요. 엑셀 대신 파이썬 (https://www.youtube.com/watch?v=w7Q_eKN5r-I&list=PLp5Djnc0GE9FVYIi2WXNatf9AmZ0TWVOO&index=2&t=0s)

용어 정리 - 공분산과 상관계수 ( https://datascienceschool.net/view-notebook/4cab41c0d9cd4eafaff8a45f590592c5/ )

이미지 출처 - The components of a DataFrame (https://medium.com/epfl-extension-school/selecting-data-from-a-pandas-dataframe-53917dc39953 )

Flutter - 유닛 테스트 해보기

에드 신 — Mon, 22 Apr 2019 01:21:29 +0900

flutter_testing

플러터 유닛 테스팅

유닛 테스팅 (Unit Testing)

첨엔 핫리로딩의 효율성이 정말 좋다보니 테스팅을 할 필요성을 못 느꼈었는데요.

점차 코드를 추가하다보니 테스트를 해야겠단 생각이 들었습니다.

이번에 테스팅을 공부하면서 다트가 정말 잘 만들어졌구나 하는 걸 느꼈습니다.

사실 다트의 테스팅도 다른 테스트와 비슷합니다. 용어가 조금 다를 뿐이죠.

이번 글을 통해 제가 개발하며 배운 테스팅을 정리해보려 합니다.

플러터에서 쓰이는 테스트 방식은 크게 3가지인데요.

유닛 테스트, 위젯 테스트, 통합 테스트입니다.

뒤로 갈수록 테스팅의 규모가 커지는 대신, 시간이 더 오래걸리죠.

이번 글에선 유닛 테스팅을 알아보도록 할께요.

1. Unit Testing

유닛 테스팅은 메소트나 클래스처럼 작은 단위를 테스트할 때 쓰입니다. 외부에 의존하지 않는 테스트를 말하죠. 보통 IO 처리를 하거나, 데이터베이스에 접근 하는 걸 외부에 의존한다고 하는데요.

외부에 의존하는 경우는 Mockito 같은 테스트 프레임워크를 써서 테스트를 합니다.

일단 다트의 기본 테스트 프레임워크를 알아보도록 할께요. Mockito는 다른 글에서 알아보도록 하겠습니다.

1.1 Unit Testing - 다트 기본 테스트 프레임워크

1.1.1 설정 및 첫 테스트 실행하기

우선 test 라이브러리를 추가해주세요.

pubspec.yaml


dev_dependencies:
  test: any

test 폴더에다가 테스트 파일(simple_test.dart)을 만들어주세요.

파일 이름은 항상 test로 끝나야합니다.

test/simple_test.dart


x
import 'package:test/test.dart';
void main() {
  test('should be lowercase', () { // 어떤 테스트를 할지 설명하고,안에 있는 테스트를 실행합니다. 
    String hello = "Hello World"; 
    expect(hello.toLowerCase(), "hello world"); // 테스트를 실행했을 때의 기대값과 실제값을 비교합니다.
  });
}

테스트 코드는 main()에 적어주셔야합니다.

테스트 코드는 크게 test() 함수와 expect() 함수로 되어 있습니다.

test()는 테스트를 실행할 때 쓰이는 함수고, expect()는 테스트 실행값과 기대값을 비교하는 함수입니다.

그럼 테스트를 실행해보겠습니다.

이 테스트는 소문자로 잘 바뀌는지 확인해보는 테스트입니다.


xxxxxxxxxx
flutter test test/simple_test.dart

문제 없이 통과 되었네요.


xxxxxxxxxx
00:01 +1: All tests passed!

그럼 테스트할 때 쓰이는 기본적인 함수들을 알아보겠습니다.

1.1.2 다트의 테스트 함수

test
- 테스트에 대한 설명과 실제 테스트 코드를 적습니다.
- 시간 제한(timeout) 이나 테스트 환경 (브라우저, OS) 등도 적어줄 수 있습니다.
expect
- expect(실제값, 기대값)
- 테스트의 기대값과 실제값을 비교합니다.
- 다른 언어의 assert 와 동일하다고 보시면 됩니다.
setup
- 테스트를 시작하기 전에 설정을 해줍니다.
- 테스트 단위 하나마다 실행됩니다. ( test() 함수 하나가 테스트 단위 하나에요. 한 파일에 여러 test() 가 있으면 여러번 실행됩니다. )
setupAll
- 테스트 시작하기 전에 설정을 해줍니다.
- 파일 하나에 한번만 실행됩니다. (데이터 베이스 설정할 때 쓰기 좋겠죠)
teardown
- 테스트를 마치고 할 작업을 정해줍니다.
- 테스트 단위 하나마다 실행됩니다 ( setup() 함수랑 동일합니다 )
teardownAll()
- 테스트를 마치고 할 작업을 정해줍니다.
- 파일 하나에 한번만 실행됩니다. ( setupAll() 함수랑 동일합니다 )

이 뿐만 아니라 테스트 시간 제한, 비동기 테스트 등 할 수 있는게 정말 많습니다.

자세한 건 다트 펍을 참고해주세요 (https://pub.dartlang.org/packages/test)

1.1.3 테스트 예제 - 테스트 실패 해보기

이번엔 테스트를 일부러 실패해 보겠습니다.

test/simple_test.dart


xxxxxxxxxx
void main() {
  test('should be lowercase', () {
    String hello = "Hello World";
    expect(hello.toLowerCase(), "hello world");
  });
  test('should contain name', () {
    String hello = "Hello World, Mike";
    expect(hello.contains('mike'), true); // 테스트 실패! 소문자 mike는 찾을 수 없다.
  });
}

테스트 실패시 기대값과 실제값이 어떻게 다른지 보여줍니다.


xxxxxxxxxx
Expected: <true>
  Actual: <false>
package:test_api            expect
test/simple_test.dart 13:5  main.<fn>

어떤 점이 다른지 보여주니, 함수를 잘못 작성했다면 쉽게 고칠 수 있겠죠?

1.1.4 테스트 예제 - 덧셈, 뺄쎔 함수 테스트 해보기

덧셈 뺄쎔을 하는 함수를 만들어보고 테스트를 해보겠습니다.

group() 함수로 여러 테스트를 묶어서 테스트 해보겠습니다.

calculator.dart


xxxxxxxxxx
class Calculator {
  int add(int x, int y) => x + y;
  int minus(int x, int y) => x - y;
  int square(int x) => x * x;
}

test/calculator_test.dart


xxxxxxxxxx
import 'package:test/test.dart';
void main() {
  
  group('calculator', () {
    Calculator cal = Calculator();
    test('add should be equal to a + b', () {
      expect(cal.add(20, 30), 50);
    });
    test('minus should be equal to a - b', () {
      expect(cal.minus(30, 20), 10);
    });
    test('square should be equal to a * a', () {
      expect(cal.square(10), 10 * 10);
    });
  });
  
}

3 케이스 다 통과 했습니다.

1.1.5 비동기 테스트 해보기

플러터 개발을 하다보면 비동기 데이터를 확인할 일이 많습니다.

퓨처를 어떻게 테스트 하는지 알아보겠습니다.

asynchronous_test.dart


xxxxxxxxxx
void main() {
  test('new Future.value() returns the value', () {
    var value = Future.value(10);
    expect(value, 10);
  });
}

이대로 테스트를 실행하면 어떻게 될까요?


xxxxxxxxxx
Expected: <10>
  Actual: <Instance of 'Future<int>'>

실패하네요.

expect()의 기대값을 바꿔주면 테스트를 통과할까요?


xxxxxxxxxx
void main() {
  test('new Future.value() returns the value', () {
    var value = Future.value(10);
    expect(value, Future.value(10));
  });
}

또 실패합니다.


xxxxxxxxxx
Expected: <Instance of 'Future<int>'>
  Actual: <Instance of 'Future<int>'>

둘 다 퓨처의 인스턴스지만 같은 인스턴스는 아니라서 실패했습니다.

퓨처를 테스트할때는 expect(실제값, 기대값) 중 기대값을 completion으로 해줘야합니다.

completion은 퓨처가 완료될 때까지 테스트를 종료하지 않도록 하죠.

테스트를 실행해볼께요.


xxxxxxxxxx
void main() {
  test('new Future.value() returns the value with completion', () {
    var value = Future.value(10);
    expect(value, completion(10));
  });
}

테스트를 무사히 통과합니다.

여태까지 간단한 테스트를 해보았는데요.

이젠 좀 더 실용적인 예제를 테스트 해볼께요.

맞는 주민 번호와 이메일인지 확인하는 함수를 작성하고

테스트를 해보겠습니다.

2.이메일과 주민번호 테스트하기

2.1 테스트 예제 - 주민번호 확인하기 ( social security number validator )

주민 번호는 앞에는 생년월일, 뒤에는 성별 및 주소로 되어 있죠.

이를 확인하는 정규표현식을 작성해 보겠습니다.

field_validator.dart


xxxxxxxxxx
class FieldValidator {
  
  static bool validateSocialSecurityNumber(String input) {
    if (input.isEmpty) return false;
    Pattern pattern = r'^[0-9]{2}(0[1-9]|1[0-2])(0[1-9]|[12][0-9]|[3][01])-([1-4][0-9]{6})'; 
    RegExp exp = RegExp(pattern);
    if (exp.hasMatch(input)) return true; // 유효한 주민번호면 true 리턴
    return false;
  }
  
}

정규표현식과 매칭되면 true를 반환하고 아니면 false를 반환합니다..

이제 함수를 테스트 해볼게요.

3가지 케이스를 테스트합니다.

911222-2110332 , 761031-1518312, 983015-1910312 를 넣어볼건데요.

911222-2110332 , 761031-1518312 은 true를 반환하고

983015-1910312 은 983015니 (30월이니) false를 반환해야겠죠.

정말 그런지 테스트 해볼께요.

test/field_validator_test.dart


xxxxxxxxxx
void main() {
  group('field validator test', () {
    test('validate Social Security Number', () {
      final String socialNumber = "911222-2110332";
      expect(FieldValidator.validateSocialSecurityNumber(socialNumber), true);
      final String socialNumber2 = "761031-1518312";
      expect(FieldValidator.validateSocialSecurityNumber(socialNumber2), true);
      final String socialNumber3 = "983015-1910312";
      expect(FieldValidator.validateSocialSecurityNumber(socialNumber3), false); 
    });
  });
}

예상대로 테스트를 통과하네요.

이해를 위해 테스트를 좀 더 해볼께요.

이메일을 확인하는 함수를 작성하고 테스트 해보겠습니다. .

2.2 테스트 예제 - 이메일 확인하기 ( email validator )

아래 코드를 봐주세요.

validateEmail()는 이메일 형식에 맞으면 true를 반환하고, 아니면 false를 반환하는 함수입니다.

field_validator.dart


xxxxxxxxxx
class FieldValidator {
  static bool validateEmail(String email) {
    if (email.isEmpty) return false;
    Pattern pattern = r'^\w+@[a-zA-Z_]+?\.[a-zA-Z]{2,3}$'; 
    RegExp exp = RegExp(pattern);
    if (exp.hasMatch(email)) return true; // 유효한 이메일이면 true 리턴
    return false;
  }
  
}

테스트 케이스는 2개를 작성했습니다.

goodday@gmail.com, badday#@gmail.com 란 입력인데요.

badday#@gmail.com 은 #이 들어있어서 유효한 이메일이 아닙니다.

2 케이스 다 통과할거라고 테스트 함수를 짜면, 하나는 실패하겠죠?

정말 그런지 볼께요.

test/field_validator_test.dart

import 'package:test/test.dart';
import '../src/field_validator.dart';


void main() {
  group('field validator test', () {

    test("validateEmail", (){
      const String email1 = "goodday@gmail.com";

      expect(FieldValidator.validateEmail(email1), true); // 통과할거로 예상하고 통과

      const  String email2 = "badday#@gmail.com";

      expect(FieldValidator.validateEmail(email2), true , reason: '# is a not valid character'); // 통과할 거로 예상했으나 통과하지 못하기에 test fail
    });
  });
}

테스트 실행결과

Expected: <true>
  Actual: <false>
# is a not valid character

예상대로 이메일 badday#@gmail.com는 테스트를 통과하지 못하네요.

이번엔 expect() 에다 reason 을 적어줬습니다. reason을 적으면 테스트가 실패한 원인을 알려줍니다.

마무리

테스트 방식에는 크게 3가지가 있는데

이번 글에선 단위 테스트만 알아보았습니다.

플러터의 위젯 테스트, 통합 테스트는 다음 번에 알아보도록 할께요!

참고글 - http://dartdoc.takyam.com/articles/dart-unit-tests/

파이썬 크롤링 시작하기 - html 구조와 간단한 크롤링

에드 신 — Wed, 17 Apr 2019 15:33:21 +0900

crawling

html 간단한 구조

tag
head
title
body
p
a href
img
h1, h2, h3, h4
input
button

css란?

tag별 스타일링
id, class

크롤링

requests
beautiful soup

네이버 블로그 크롤링 해보기

크롤링은 웹상에서 데이터를 원하는 대로 받아올 수 있어, 활용도가 높은 기술이죠. 프로그래밍을 통한 자동화의 핵심도 크롤링인데요. 이번 글에서는 html 기본 구조를 알아보고, beautifoul soup를 통해 간단한 크롤링을 해워보도록 하겠습니다.

마지막으론 실습 겸 네이브 블로그를 크롤링 해볼께요.

1. html이란?

HTML(Hypertext markup language) 은 웹페이지를 보여줄 때 사용하는 언어에요.

모든 웹사이트는 html을 기본적으로 써서 만들어졌습니다.

웹의 기본적인 구조를 알아야 크롤링을 할 수 있어요.

직접 html을 만들어 볼께요.

파일명은 index.html로 해주세요.

index.html


x
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<p>Hello 안녕하세요.</p>
<h1>간단한 문자 쓰기</h1>
</body>
</html>

위의 html을 브라우저에 띄우면

"Hello 안녕하세요."란 문자가 표시됩니다.

html은 항상 열고 닫는 <태그><태그/>로 구성되어 있습니다.

열었다가 닫는 <body></body> 같은 걸 태그라고 하는데요.

html은 태그로 만들어진 문서입니다.

1.1 기본 태그 - html, head, body

html 문서는 html 문서인 걸 표시하는 <html></html>이 있고

필요한 데이터를 불러오거나, 문서 정보를 표시할 때 쓰는 <head></head>,

웹 페에지를 표시할 때 쓰이는 <body></body>로 구성되어 있습니다.

<html><head><body> <- 이 3개의 태그는 항상 있어야 되니 잊지 마세요.

1.2 기본 태그 (문자) - p, h1

<p></p> 는 문자를 적을 때 쓰는 태그고

<h1></h1>도 문자를 적을 때 쓰는 태그인데 h1은 문자의 크기가 기본적으로 정해져 있는 태그에요.

h1,h2,h3,h4,h5,h6 같이 점점 작은 크기의 문자를 표시합니다.

1.3 기본 태그 활용해보기 - img, a href, input

모든 태그를 알아 볼 수는 없으니 자주 쓰는 태그만 몇 개 알아볼께요.

<a></a> a 태그는 다른 사이트에 링크를 걸 때 씁니다.

<a href="https://www.naver.com"> 네이버 이동</a>

input 태그는 입력을 받을 때 쓰여요. 버튼 같은 걸 만들 떄 씁니다. <input></input>

img 태그는 이미지를 표시할 때 쓰여요. <img src=""/>

아래의 html을 실행시키고 확인해보세요.

index.html


xxxxxxxxxx
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<p>Hello 안녕하세요.</p>
<h1>h1 글씨</h1>
<h6>h6 글씨 </h6>
<img src="https://images.unsplash.com/photo-1554659966-023466cbc607?ixlib=rb-1.2.1&auto=format&fit=crop&w=1225&q=80">
<a href="https://www.naver.com"> 네이버 이동</a>
<input type="button" name="login" value="login">
</body>
</html>

문제 1.1 html을 새로 만들고,
태그를 3개 넣어보세요.

문제 1.2. html을 새로 만들고 를 써서 구글로 이동하는 링크를 만들어보세요.

모를 때는 w3school (https://www.w3schools.com/) 을 참고하세요.

2. css - html 스타일링

기본 html 태그를 써서 웹페이지를 만들면 밋밋합니다.

이럴 때 css를 써서 웹페이지를 스타일링합니다.

css를 쓰면 html 태그별로 스타일링을 할 수 있어요.

style.css란 파일을 만들어볼께요.

style.css


xxxxxxxxxx
p {
    font-size: 25px;
    font-family: Verdana;
}
img {
    width: 200px;
    height: 200px;
}
a {
    color: cornflowerblue;
}

css를 만들었으면 html에서 불러와야 됩니다.

안에다가 를 적어주세요.


xxxxxxxxxx
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <link rel="stylesheet" type="text/css" href="style.css">
</head>

index.html


xxxxxxxxxx
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <link rel="stylesheet" type="text/css" href="style.css">
</head>
<body>
<p >Hello 안녕하세요.</p>
<p id="greeting">안녕하세요.</p>
<p>제 이름은 </p>
<h1>h1 글씨</h1>
<h6>h6 글씨 </h6>
<h6>날씨 예보</h6>
<h6 class="textStyle">오늘 날씨는</h6>
<h6 class="textStyle">맑고</h6>
<h6 class="textStyle">화창합니다.</h6>
<img id="road-img" src="https://images.unsplash.com/photo-1554659966-023466cbc607?ixlib=rb-1.2.1&auto=format&fit=crop&w=1225&q=80">
<img src="https://images.unsplash.com/photo-1554659966-023466cbc607?ixlib=rb-1.2.1&auto=format&fit=crop&w=1225&q=80">
<a href="https://www.naver.com"> 네이버 이동</a>
<input type="button" name="login" value="login">
</body>
</html>

문제 2.1 - html을 새로 만들고, css가 적용된
태그를 만들어보세요.

모르겠으면 구글에 "css p tag" 라고 검색해보세요.

2.1 html, css - id와 class의 차이점

지금은 html 태그가 많지 않으니 괜찮지만

100개, 1000개가 될 때는 구분할 방법이 필요하겠죠?

이럴 때 쓰는 게 id와 class 입니다.

id와 class를 통해 html 속성에 접근하거나, 꾸미거나 변경을합니다.

id와 html의 차이는 간단합니다. html 태그당 1개씩 있는가, 여러 태그를 한꺼번에 다루는가입니다.

id는 html 속성을 구분할 때 사용합니다. id는 한 html 페이지에 하나만 있을 수 있어요.

class도 html 속성을 구분할 때 사용합니다. class는 한 html 페이지에 여러개가 있을 수 있어요.

id는 <p id="my-id"> </p> 같은 식으로 적고 class는 <p class="textStyle"></p> 같은 방식으로 적어줍니다.

그럼 html에 id와 class를 적고, 적은 id와 class를 css에서 활용해보도록 할께요.

index.html


xxxxxxxxxx
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <link rel="stylesheet" type="text/css" href="style.css">
</head>
<body>
<p >Hello 안녕하세요.</p>
<p id="greeting">안녕하세요.</p>
<p>제 이름은 </p>
<h1>h1 글씨</h1>
<h6>h6 글씨 </h6>
<h6>날씨 예보</h6>
<h6 class="textStyle">오늘 날씨는</h6>
<h6 class="textStyle">맑고</h6>
<h6 class="textStyle">화창합니다.</h6>
<img id="road-img" src="https://images.unsplash.com/photo-1554659966-023466cbc607?ixlib=rb-1.2.1&auto=format&fit=crop&w=1225&q=80">
<img src="https://images.unsplash.com/photo-1554659966-023466cbc607?ixlib=rb-1.2.1&auto=format&fit=crop&w=1225&q=80">
<a href="https://www.naver.com"> 네이버 이동</a>
<input type="button" name="login" value="login">
</body>
</html>

style.css

css에서는 원하는 id와 class만 스타일링 해줄 수 있습니다.

id를 표시할 때는 #id 같은 식으로 쓰이구요.

클래스는 .class 같은 식으로 적습니다.


xxxxxxxxxx
p {
    font-size: 25px;
    font-family: Verdana;
}
.textStyle {
    font-size: 15px;
    font-family: Serif;
}
img {
    width: 200px;
    height: 200px;
    border-radius: 8px;
    border: 1px solid #cccccc;
}
img#road-img {
    width: 300px;
    height: 300px;
}
img#road-img:hover {
    box-shadow: 0 0 3px 3px rgba(200, 255, 255, 0.5)
}
a {
    color: #b4654d;
}

2.3 CSS - 자식 태그에 접근하기


xxxxxxxxxx
p em

p em은 em이 p보다 안쪽에 있는 경우면 다 해당됩니다.

이렇게 적든


xxxxxxxxxx
<p>Text <em>foo</em> bar</p>

요렇게 적든 상관없죠.


xxxxxxxxxx
<p><strong><em>foo</em></strong></p>

반면 > 기호가 있으면 바로 안쪽에 있는 경우만 해당됩니다.


xxxxxxxxxx
p > em

이것만 되고


xxxxxxxxxx
<p>Text <em>foo</em> bar</p>

이건 안되요. p와 em 사이에 strong이 있으니까요.


xxxxxxxxxx
<p><strong><em>foo</em></strong></p>


xxxxxxxxxx
p > em {
}


xxxxxxxxxx
<p>Text <em>foo</em> bar</p>

지금까지 html에 id와 class를 통해 css를 적용하는 방법을 알아보았습니다.

기본적인 html 구조는 알게 되었으니 이제 크롤링 하는 법을 알아보도록 할께요.

3. 크롤링하기


xxxxxxxxxx
- http request 보내기, response 받기
- beautiful soup
- save data

3.1.1 파이썬 라이브러리 설치

이미 만들어진 함수들의 모음을 라이브러리라고 하는데,

파이썬으로 크롤링을 하려면 라이브러리를 설치해야 합니다.

커맨드 라인에서 pip를 써서 설치를 하거나 파이참에서 설치를 해주세요.


xxxxxxxxxx
pip install beautifulsoup4 requests

파이참에서 라이브러리 설치하기 - https://www.youtube.com/watch?v=HJ9bTO5yYw0

설치한 라이브러리는 requests와 Beautiful Soup입니다.

requests는 인터넷 상으로 데이터를 보내고, 받는 걸 쉽게 해줍니다.

웹사이트에서 html 문서를 받을 때 쓰죠.

Beautiful Soup(뷰티플 소프)은 받은 html 문서를 파싱할 때 씁니다. 파싱은 분해해서 다루기 편하게 만드는 걸 말합니다. Beautiful Soup를 쓰면 원하는 html 태그를 쉽게 찾을 수 있습니다.

3.1.2 requests 라이브러리

인터넷은 http란 프로토콜로 만들어졌는데요. 프로토콜은 어떤일을 어떻게 하겠다는 약속입니다.

http는 통신을 하는 방식에 대한 약속이죠.

http는 크게 요청(request)과 응답(response)으로 이뤄져 있습니다.

간단히 말해 요청은 데이터를 달라는 말과 같습니다.

"내가 이 사이트에 접속할 테니 필요한 html을 줘!" 라고 웹사이트에 요청하는 거죠.

응답(response)는 내가 한 요청을 사이트가 처리해서 돌려주는 겁니다.

보통 응답에 html이나 에러(잘못된 페이지에요. 서버가 죽었어요) 등을 담아서 돌려주죠.

이런 요청과 응답을 쉽게 해주는 게 requests 라이브러리에요.

아래의 코드를 실행해 볼까요?


xxxxxxxxxx
import requests
response = requests.get('https://www.naver.com') # 웹사이트에 리퀘스트를 보냄. 리퀘스트의 결과가 response에 저장
print(response)
print(response.status_code) # 응답 코드 보여주기 200이면 성공!
print(response.text) # 응답 결과를 텍스트로 보여줌.

**http 응답이 이해하기 어려우면

웹사이트 주소를 치면 데이터를 보내주고,

그 데이터를 분해해서 쓴다 정도로만 생각해도 됩니다.**

html 데이터를 받았으니 이제 파싱(쓰기 쉽게 분해)를 해볼께요.

그래야 나중에 분석이 가능하겠죠?

3.2 Beautiful Soup 써보기

BeautifulSoup는 파싱을 할 떄 사용합니다.

간단히 파싱을 해보도록 할께요.


xxxxxxxxxx
html_doc="""
<html>
    <head>
    </head>
        <body>
            <p> hello </p>
            <p> good day </p>
        </body>
</html>
"""
from bs4 import BeautifulSoup
soup = BeautifulSoup(html_doc, 'html.parser') # <- html_doc은 파싱할 문서고, 'html.parser'는 파싱 방식이에요.
for p in soup.find('p'):
    print(p)

html 문서에서 p 태그만 출력합니다.

근데 find() 함수를 쓰니 p 태그가 여러개 있어도 1개만 출력하네요.

이때는 find_all() 함수를 쓰면 됩니다.


xxxxxxxxxx
from bs4 import BeautifulSoup
soup = BeautifulSoup(html_doc, 'html.parser') # <- html_doc은 파싱할 문서고, 'html.parser'는 파싱 방식이에요.
for p in soup.find_all('p'):
    print(p)

모든 p 태그가 출력됩니다.

3.2.1 Beautiful Soup - find, select 차이점. requests 사용

Beautiful Soup (뷰티풀 소프)는 2가지 방식으로 html 문서를 파싱합니다.

find와 select인데요. find는 html tag를 통해서 원하는 부분을 찾습니다.

반면 select는 css를 통해 원하는 부분을 찾습니다.

find와 select는 기능적으로는 동일해요. 선택의 문제죠.

많은 메소드가 있지만 자주 함수는 4개에요.

find : 1개의 태그만 찾음.
find_all : 모든 태그를 찾음.
select_one : 1개의 태그만 찾음.
select : 모든 태그를 찾음.


xxxxxxxxxx
import requests
from bs4 import BeautifulSoup
response = requests.get('https://www.naver.com')
soup = BeautifulSoup(response.text, 'html.parser')
for p in soup.select('p'):
    print(p)
    
for link in soup.select('a'):
    print(link.get('href')) # a태그의 href를 전부 찾기

문제 3.1 - Beautiful Soup를 써서 태그만 골라서 출력해보세요.

3.3 Chrome 써서 원하는 태그 쉽게 찾기

크롬을 쓰면 웹에서 내가 찾고자 하는 부분을 쉽게 찾을 수 있어요.

일단 '개발자 도구'를 열도록 할께요.

마우스 오른쪽 키를 누르면 '검사'가 뜨는 데 검사를 누르면 됩니다.

새로 창이 생겼죠? 거기서 element 탭을 누르면 html 요소들을 확인할 수 있습니다.

내가 원하는 태그를 찾을 때도 비슷한 방법을 써요.

일단 마우스를 웹 페이지에 올리고 '검사' 버튼을 누르면 됩니다.

아래 이미지를 참고해주세요.

크롬 툴을 쓰면 편하게 html에 있는 요소들을 찾고, 편집할 수 있습니다.

내가 원하는 html 요소 찾는 법을 알았으니 이걸 크롤링하면 되겠죠?

아래 영상을 보거나

이 영상을 참고하세요 (https://www.youtube.com/watch?v=mLPIcnFKD04)

4. 네이버 블로그 크롤링 하기

네이버에서 검색했을 때 나오는 블로그의 글을 크롤링해보도록 하겠습니다.

글의 제목과 내용정도만 간단히 크롤링해보려 합니다.

네이버 검색에서 '홍대 맛집'으로 검색하고 블로그 탭을 누르도록 합시다.

블로그 검색 결과만 주르륵 나옵니다 .

이 검색 결과를 크롤링 하도록 할께요.

위의 사진처럼 검색 결과를 나타내는 주소 (https://search.naver.com/search.naver?where=post&sm=tab_jum&query=%ED%99%8D%EB%8C%80+%EB%A7%9B%EC%A7%91)를

복사해주세요.

4.1 크롤링 함수 만들기

블로그 검색 결과를 요청하는 함수를 만들어볼께요.

4.1 step 1

리퀘스트를 보내고 응답이 제대로 오는지 확인합시다.


xxxxxxxxxx
import requests
from bs4 import BeautifulSoup
def blog_crawling():
    url = 'https://search.naver.com/search.naver?where=post&sm=tab_jum&query=%ED%99%8D%EB%8C%80+%EB%A7%9B%EC%A7%91'
    
    response = requests.get(url)
    
    print(response.text)
blog_crawling()

4.1 step 2

응답을 Beautiful Soup로 파싱해 봅시다.


xxxxxxxxxx
import requests
from bs4 import BeautifulSoup
def blog_crawling():
    url = 'https://search.naver.com/search.naver?where=post&sm=tab_jum&query=%ED%99%8D%EB%8C%80+%EB%A7%9B%EC%A7%91'
    
    response = requests.get(url)
    
    soup = BeautifulSoup(response.text, 'html.parser')
    
    print(soup.text)
    
blog_crawling()

4.1 step 3

검색 결과 중에서 블로그 제목만 파싱해 보도록 할께요.

'3.3 Chrome 써서 원하는 태그 쉽게 찾기'에 적은 대로 블로그 제목의 항목만 찾아주세요.

크롤링을 잘하려면 html 구조를 보고, 원하는 항목만 쉽게 볼 수 있어야 해요.

이건 연습이 필요합니다.


xxxxxxxxxx
import requests
from bs4 import BeautifulSoup
def blog_crawling():
    url = 'https://search.naver.com/search.naver?where=post&sm=tab_jum&query=%ED%99%8D%EB%8C%80+%EB%A7%9B%EC%A7%91'
    
    response = requests.get(url)
    
    soup = BeautifulSoup(response.text, 'html.parser')
    
    for links in soup.select('li.sh_blog_top > dl'): 
        title = links.select('dt > a')
        title = title[0].get('title') # select로 찾은 결과는 리스트로 표시되기에 [0]을 썼습니다. 
        
        print(title)
    
blog_crawling()

4.1 step 4

블로그 제목뿐만 아니라, 작성자, 내용까지 파싱해보도록 할께요.

블로그 데이터는 사전으로 만들고, 하나씩 리스트에 담겠습니다.


xxxxxxxxxx
import requests
from bs4 import BeautifulSoup
def blog_crawling():
    url = "https://search.naver.com/search.naver?where=post&sm=tab_jum&query=%ED%99%8D%EB%8C%80+%EB%A7%9B%EC%A7%91"
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'html.parser')
    blog_post_list = []
    for links in soup.select('li.sh_blog_top > dl'):
        title = links.select('dt > a')
        content = links.select('dd.sh_blog_passage')
        author = links.select('dd.txt_block a')
        title = title[0].get('title')
        content = content[0].text
        author = author[0].text
        blog_post = {'author': author, 'title': title, 'content': content} # 블로그 데이터를 사전으로 만들어주었습니다.
        blog_post_list.append(blog_post) 
    return blog_post_list
    
    
blog_post_list = blog_crawling()

4.1 step 5

추출한 데이터를 엑셀에 저장하도록 할께요.


xxxxxxxxxx
import csv
def save_data(blog_post):
    keys = blog_post[0].keys()
    with open('blog_crawling.csv', 'w') as file:
        writer = csv.DictWriter(file, keys) 
        writer.writeheader()
        writer.writerows(blog_post) 
blog_post_list = blog_crawling() 
save_data(blog_post_list)

4.1 step 6

위의 코드는 검색 결과 중 1페이지만 저장했습니다.

여러 페이지를 저장할 수 있게 코드를 수정해볼께요.


xxxxxxxxxx
def blog_crawling(page=1):
    url = "https://search.naver.com/search.naver?date_from=&date_option=0&date_to=&dup_remove=1&nso=&post_blogurl=&post_blogurl_without=&query=%ED%99%8D%EB%8C%80%20%EB%A7%9B%EC%A7%91&sm=tab_pge&srchby=all&st=sim&where=post&start={}".format(page)
    
blog_post_list = []
for i in range(1, 100, 10):
    blog_post_list.extend( blog_crawling(page=i) )
    time.sleep(2)
save_data(blog_post_list)

100개 블로그의 데이터가 저장됩니다!

네이버 블로그 크롤링 전체 코드


xxxxxxxxxx
import csv
import requests
import time
from bs4 import BeautifulSoup
def blog_crawling(page=1):
    url = "https://search.naver.com/search.naver?date_from=&date_option=0&date_to=&dup_remove=1&nso=&post_blogurl=&post_blogurl_without=&query=%ED%99%8D%EB%8C%80%20%EB%A7%9B%EC%A7%91&sm=tab_pge&srchby=all&st=sim&where=post&start={}".format(page)
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'html.parser')
    blog_post_list = []
    for links in soup.select('li.sh_blog_top > dl'):
        title = links.select('dt > a')
        content = links.select('dd.sh_blog_passage')
        author = links.select('dd.txt_block a')
        title = title[0].get('title')
        content = content[0].text
        author = author[0].text
        blog_post = {'author': author, 'title': title, 'content': content}
        blog_post_list.append(blog_post)
    return blog_post_list
def save_data(blog_post):
    keys = blog_post[0].keys()
    with open('blog_crawling.csv', 'w') as file:
        writer = csv.DictWriter(file, keys)
        writer.writeheader()
        writer.writerows(blog_post)
blog_post_list = []
for i in range(1, 100, 10):
    blog_post_list.extend( blog_crawling(page=i) )
    time.sleep(2)
save_data(blog_post_list)

참고사이트 : https://www.w3schools.com/html/ 참고글 : 파이썬 requests 라이브러리 예제 - http://docs.python-requests.org/en/master/user/quickstart/

Flutter - Zone이란? 프로그램 종료되지 않게 예외처리 하기.

에드 신 — Mon, 15 Apr 2019 18:17:47 +0900

flutter-zone

Flutter Zone이란? 종료되지 않게 예외처리 하기.

Zone이란?
try ~ catch와의 차이점
Zone 예제

플러터 플러그인을 쓰다보면

runZone()를 쓰는 경우가 종종 있습니다.

주로 아래처럼 쓰입니다.

flutter_crashlytics 플러그인


x
void main() async {
  await FlutterCrashlytics().initialize();
  runZoned<Future<Null>>(() async { 
    runApp(MyApp());
  }, onError: (error, stackTrace) async {
    await FlutterCrashlytics().reportCrash(error, stackTrace, forceCrash: false);
  });
}

저도 처음에는 별 생각없이 적용했는데 점점 zone이 무엇인가 궁금해지더군요.

그래서 찾아봤습니다.

1. Zone이란?

zone은 프로그램이 예상치 못한 에러로부터 종료하는 걸 막을 때 쓰입니다. 일반적인 상황이면 프로그램이 종료되는 경우더라도 zone(존)을 쓰면 잘 돌아가게 되는 거죠.

1.1 try ~ catch를 사용한 경우


xxxxxxxxxx
void main() {
  try {
    Timer.run(() {
      throw 'throw error'; // 명시적으로 throw를 사용. 일반적이면 무조건 에러 발생.
    });
  } catch(e) {
    print(e);
  }
}

에러가 생기고 프로그램이 중단됩니다.

하지만 Zone을 쓰면 계속 프로그램이 실행됩니다.

1.2 Zone을 사용한 경우


xxxxxxxxxx
void main() {
  runZoned(() {
    Timer.run(() {
      throw 'do not kill the program'; // Zone을 썼기에 프로그램이 죽지 않습니다.
    });
  }, onError: (e) {
    print('Uncaught error ${e}');
  });
}

명시적으로 Throw을 날렸지만 프로그램이 멀쩡히 돌아갑니다!

Zone은 실행되는 공간을 나눠서, 그 공간 안에 있는 한 안전하게 프로그램이 돌아가도록 합니다.

크래시리틱스에서 runZone()을 쓴 건 정말 당연했네요. 크래시가 발생하더라도 이를 남기려면 프로그램이 종료되면 안되니까요.

Zone을 쓰는 예제를 몇개 더 적어보겠습니다.

2.1 Stream이랑 Zone 같이 써보기 - 1


xxxxxxxxxx
void main() {
  var stream = File('data.text').openRead()
        .map((x) => throw 'Callback throws');
  stream.listen(print);
  runZoned(() {
     stream.listen(print);
  }, onError: (e) {
     print('Caught error: $e');
  });
}

2.2 Stream이랑 Zone 같이 써보기 - 2


xxxxxxxxxx
void main() async {
  runZoned(() {
    countNumber();
  }, onError: print );
}
Future countNumber() async {
  await for ( var num in numbers()) {
    print('Num : $num');
    if (num > 10) throw ('error : $num'); // 에러 일부러 발생시킴
  }
}
Stream<int> numbers() async* {
  var duration = Duration(milliseconds: 30);
  for (var x = 0; x < 100; x++) {
    await Future.delayed(duration);
    yield x;
  }
}

숫자 11때 에러가 생기지만 프로그램이 강제적으로 종료되지 않습니다.

마무리

이번 글에선 Zone에 대해 알아보았습니다.

Zone을 쓰면 종료 되지 않아야 되는 상황을 다루기가 쉬워집니다.

무작정 runZone()에 넣는 건 안 좋은 습관이지만, Zone을 쓰면 예측하기 어려운 상황을 다룰 때 도움이 되겠네요.

참고글 : Zone에 관하여 (https://www.dartlang.org/articles/libraries/zones)

참고영상 : Tensor Programming채널의 Zone, Microtask ( https://www.youtube.com/watch?time_continue=1083&v=pHpvfaanrbw )

파이썬 기초 문법 정리

에드 신 — Thu, 11 Apr 2019 00:12:22 +0900

파이썬 기초 문법 정리

파이썬 문법 익히기

파이썬은 가장 대중적이면서도 쉽게 다가갈 수 있는 언어 중 하나에요.

보통 프로그래밍 언어를 새로 깔면 'Hello World'를 출력해봅니다.

프로그래밍 언어가 제대로 설치 되었는지 확인하기 위해서요.


xxxxxxxxxx
print('Hello World')

위의 코드를 실행해 보세요.

잘 출력되나요? 파이썬 설치가 성공적으로 되었어요.

그럼 이제부터 기본적인 파이썬 문법을 알아보도록 할께요.

변수, 조건문, 리스트 등이 가장 기초적인 파이썬 문법입니다.

변수

프로그래밍은 기본적으로 어떤 데이터를 저장하고, 이를 자유롭게 처리하는 것이에요.

데이터를 쓰려면, 쓰기 전에 어딘가에 저장을 해두어야해요.

어떤 데이터가 들어간 공간을 변수라고 합니다.


xxxxxxxxxx
a = 10 
print(a)

a라는 변수에 10을 넣고 출력을 해보았습니다.


xxxxxxxxxx
a = 20
print(a)
b = 30
print(b)
sum = a + b
print(sum)
c = 50
d = 40
result = 50 - 40
print(result)

변수는 여러개를 만들 수 있고 더하고 뺄 수도 있어요.


xxxxxxxxxx
a = 50
b = 40
result = a / b
print(result)
result = a // b # 나눴을 때 몫입니다. #는 주석인데, #이 달려있으면 그 뒤에 있는 건 컴퓨터가 무시해요!
print(result)
result = a % b # 나누었을 때 나머지에요.
print(result)

곱하거나 나누어 줄 수도 있죠.

변수에는 정수뿐만 아니라 실수나 문자도 넣을 수 있습니다.


xxxxxxxxxx
name = 'mike'
print(name)
city = 'seoul'
print(city)
a = 10.5
print(a)

참 거짓을 나타내는 변수도 있죠.


xxxxxxxxxx
live_in_seoul = True
print(live_in_seoul)
live_in_tokyo = False
print(live_in_tokyo)

문제 1.1

변수 a에 숫자 10을 넣고 출력해보세요.

문제 1.2

변수 city에 문자 seoul을 넣고 출력해보세요.

문제 1.3

변수 a에 20, 변수 b에 30을 넣고 둘을 더해보세요.

변수는 데이터를 저장하는 가장 간단한 방법이에요.

근데 변수는 한번에 하나의 데이터만 담을 수 있습니다.

여러 데이터를 담고 싶으면 어떻게 해야할까요?

리스트

많은 데이터를 한꺼번에 다루려면 리스트를 사용합니다.


xxxxxxxxxx
names = ['mike', 'jane', 'tom']
print(names)
print(names[0]) # 리스트의 첫번째 값을 가져옵니다. 컴퓨터는 항상 0부터 시작해요.
print(names[1])
print(names[2])
# print(names[3]) # 에러가 생깁니다. 리스트의 길이보다 큰 인덱스에 접근하려고해서 그래요.

리스트에 있는 값에 접근하려면 인덱스를 써야됩니다.

인덱스는 names[0]에서 [0] 같은 걸 말하는데요.

항상 0부터 시작하고, 리스트의 길이보다 작아야합니다.

names 리스트는 길이가 3이니 2까지만 쓸 수 있죠.


xxxxxxxxxx
odd_number = [1, 3, 5, 7, 9]
print(odd_number)
user_data = [ 20, 'mike', 'seoul' , True]
print(user_data)

리스트에는 같은 종류의 변수뿐만 아니라 다른 종류의 변수도 섞어 쓸 수 있어요.

숫자, 문자 섞어서 쓸 수 있어요.

리스트는 여러 데이터를 쓸 수 있어 편리하지만, 어느 위치에 있는지(인덱스)를 알아야해요.

인덱스를 모르고도 쓸 수 있는 저장 방식이 있을까요?

사전 (딕셔너리)

사전은 '키'를 써서 데이터를 접근하고 사용합니다.


xxxxxxxxxx
user = {}
user['age'] = 25
user['address'] = 'seoul'
print(user)
print(user['age'])
print(user.get('age')) 
user['age'] = 90
print(user.get('age'))

사전을 쓰려면 user = {} 처럼 적어줘야 합니다. 위 코드에선 'age' 와 'address'가 키로 쓰였습니다.

사전에서 값을 가져오는 방식은 2가지인데요.

user['age'] 처럼 가져올 수도 있고, user.get('age')처럼 가져올 수도 있어요.

보통은 user.get('age')처럼 쓰는 걸 권장해요. 키가 없어도 에러가 생기지를 않거든요.

다음은 조건문에 대해서 알아볼께요.

문제 2.1

홀수만 5개 있는 리스트를 만들어서 출력해보세요.

문제 2.1

도시 이름을 3개 넣은 리스트를 만들어서 출력해보세요.

문제 2.3

과일(fruit) 사전을 만들어보세요. 키는 color, size로 해주세요.

조건문 IF 문

조건문은 어떤 조건을 만족할 때 실행되는 명령을 말합니다.

우리 일상으로 비유를 해보자면

"스타벅스에 가면, 아메리카노를 시킨다" "아침 8시가 되면, 일어나서 아침을 먹는다"

같은 게 조건문이 될 수 있겠죠.

그럼 파이썬의 조건문을 알아볼께요.


xxxxxxxxxx
live_in_seoul = True
if live_in_seoul:
    print('서울에 살아요')
    
live_in_seoul = False
if live_in_seoul:
    print('서울에 살아요')

조건문은 if문 안에 있는 조건을 만족하면 실행됩니다.

위의 코드에서 첫번째 if문은 실행되고 두번째는 실행되지 않겠죠


xxxxxxxxxx
name = 'jane'
if name == 'jane':
    print('이름이 제인이에요')
else:
    print('이름이 제인이 아니에요.')

else 문은 if문과 함께 쓰이는데요.

if 문을 만족하지 못하는 경우에 실행됩니다.

age = 35

if age > 30:
    print('30살보다 많습니다.')
else:
    print('30살보다 적어요.')

if 문은 다양하게 응용이 가능하답니다.

기초 중의 기초라고 할 수 있죠.

조건문 For 문

다른 많이 쓰이는 조건문은 For 문입니다.

위에서 리스트를 사용할 때 인덱스 하나하나 접근을 했죠.

리스트가 작아서, 3,4개 데이터만 있으면 괜찮지만

100개, 1000개면 어떻게 처리할까요?

이럴 때 for 문이 필요합니다.

for 문은 반복적인 작업을 쉽게 처리할 수 있게 해줘요.

odd_number = [1, 3, 5, 7, 9, 11, 13]

for num in odd_number: # num 은 odd_number에 있는 변수에요.
    print(odd_number)

odd_number란 리스트에 있는 숫자를 하나하나 확인하면서 출력을 합니다. 처음의 num은 1 다음의 num은 3 마지막 num은 13

이런 식으로 되겠죠.

for문은 if문과 함께 쓰이는 경우가 많습니다.

짝수만 출력하는 함수를 만들어볼께요.


xxxxxxxxxx
number = [1,2,3,4,5,6,7]
for num in number:
    if num % 2 == 0:
        print(num)

num을 2로 나눴을 때 0인것만 출력하고 있어요.

For문은 실행중에 멈출 수도 있는데요. break를 쓰면 되요.


xxxxxxxxxx
ages = [10, 21, 25, 33, 44, 55, 66]
for i in ages:
    if i > 30:
        print('여기서 멈출께요')
        break

위의 코드는 리스트에 있는 값이 30을 넘는 순간 멈추도록 했습니다.

for 문은 원할 때 언제든지 끝낼 수 있어요.

문제 3.1

For문을 써서 1부터 10까지의 합을 구한 뒤 출력하세요.

문제 3.2

For문과 If 문을 써서 홀수만 출력해보세요.(20까지만 출력하세요)

함수

함수는 같은 일을 반복하지 않기 위해서 사용합니다. 예컨데 변수 3개를 더하는 경우를 생각해 볼께요.


xxxxxxxxxx
a = 10
b = 20
c = 30
result = a + b + c
print(result)
d = 11
e = 21
f = 31
print(result)

변수에 값을 넣고 더하는 작업으 반복하고 있죠. 엄청 번거로운 일입니다.

함수를 만들면 이런 번거로움을 덜 수 있어요.


xxxxxxxxxx
def add(x, y, z): # add 함수. x,y,z는 입력값
    return x + y + z # 함수 내에서 계산을 하고 함수 밖으로 내보냅니다. 
    
    
result = add(10, 30 , 50) # 함수로 계산한 결과는 result에 들어가게 됩니다. 
print(result)
result = add(5, 7, 11)
print(result)
result = add(1, 3, 4)
print(result)

함수를 항상 def를 앞에 적어줘야해요.

그리고 입력과 결과값(함수 내에서 계산한 값)이 있어야 합니다.

일단 여러 함수를 써보다 보면 개념이 이해가 될 거에요.


xxxxxxxxxx
def subtract(x, y):
    return x - y
    
    
result = subtract(20 , 10)
print(result)
result = subtract(35, 22)
print(result)

곱하는 함수도 만들어볼께요.

def multiply(w, x, y, z):
    return w * x * y * z


result = multiply(2, 3, 4, 5)
print(result)

result = multiply(10, 20, 30, 40)
print(result)

함수를 항상 만들어 쓸 필요는 없고 내장 함수(파이썬 언어를 만든 사람들이 미리 만든 함수)를 쓰면 편합니다.

a = "Good morning, man"
a.upper() # - 대문자로 바꿔줍니다.



a.lower() #  소문자로 바꿔줍니다.
a.count('m') # m이 몇개나 있는지 세줍니다.


a = "Life is too short"
a.replace("Life", "Your height")


a = "I regret what I did to you"
a.split()  # split은 문자열을 나누는 함수다.  값을 넣지 않으면 공백으로 잘라줍니다
['I', 'regret', 'what', 'I', 'did', 'to', 'you']

d = "home,mother,sweet"
d.split(",")
['home', 'mother', 'sweet']


a.swapcase() # 대문자와 소문자를 바꾸어준다.


str(3) # str은 문자열로 만들어주는 함수이다. str(3)을 실행하면 문자열이 된다.

len("hi") # 길이를 알려주는 함수이다.

문제 4.1

삼각형의 넓이를 구하는 함수를 만들어보세요.

(삼각형 공식 : 밑변의 길이 x 높이 / 2)

문제 4.2

원의 넓이를 구하는 함수를 만들어보세요.

(원의 넓이 공식 : 3.14 x 반지름 x 반지름)

문제 해답

문제 1.1

변수 a에 숫자 10을 넣고 출력해보세요.

a = 10
print(a)

문제 1.2

변수 city에 문자 seoul을 넣고 출력해보세요.

city = 'seoul'
print(city)

문제 1.3

변수 a에 20, 변수 b에 30을 넣고 둘을 더해보세요.

a = 20
b = 30
print(a + b)

문제 2.1

홀수만 5개 있는 리스트를 만들어서 출력해보세요.

odd_number = [1, 3, 5, 7, 9]
print(odd_number)

문제 2.1

도시 이름을 3개 넣은 리스트를 만들어서 출력해보세요.

cities = ['seoul', 'daegu', 'busan']
print(cities)
print(cities[2])

문제 2.3

과일(fruit) 사전을 만들어보세요. 키는 color, size로 해주세요.

fruit = {'color': 'White' }
fruit['size'] = 20

print(fruit)

문제 3.1

For문을 써서 1부터 10까지의 합을 구한 뒤 출력하세요.

sum = 0
for i in range(1, 10):
    sum += i

print(sum)

문제 3.2

For문과 If 문을 써서 홀수만 출력해보세요.(20까지만 출력하세요)


xxxxxxxxxx
for i in range(1, 21):
    if i % 2 == 1:
        print(i)

문제 4.1

삼각형의 넓이를 구하는 함수를 만들어보세요.

(삼각형 공식 : 밑변의 길이 x 높이 / 2)


xxxxxxxxxx
def triangle_area(width, height):
    return width * height / 2
area = triangle_area(30, 10)
print(area)

문제 4.2

원의 넓이를 구하는 함수를 만들어보세요.

(원의 넓이 공식 : 3.14 x 반지름 x 반지름)


xxxxxxxxxx
def circle_area(radius):
    return 3.14 * radius * radius
area = circle_area(5)
print(area)

서버리스 앱 개발하기 3 - 서버리스 프레임워크 써서 플러터 앱과 연결하기

에드 신 — Wed, 13 Mar 2019 16:43:35 +0900

aws-series-03-serverless-lambda-dynamodb

1.Serverless framwork

1.1. Serverless framwork 시작하기

람다와 다이나모DB를 연결하기 전에 서버리스 프레임워크를 먼저 알아보도록 할께요.

웹 콘솔에서 aws 람다, api 게이트웨이 설정을 하는 건 불편하죠.

이를 코드로 편하게 배포할 수 있게 하는게 Serverless framwork (링크) 입니다.

1.1.1 Serverless 설치


npm install serverless -g

설치가 잘 되었는지 확인하려면 serverless -v 를 쳐보세요. 버전 확인이 되면 성공입니다.

서버리스 프레임워크로 aws를 관리하려면 접근 권한을 줘야해요.

1.1.2 AWS IAM에서 자격증명(Credential) 만들기

1. 우선 AWS에 접속해서 IAM 페이지에 들어가 주세요.

유저를 하나 추가합니다.

1. 유저를 추가할 때 꼭 Programmatic access를 체크해줘야 됩니다. (아래 그림 참고)

1. 유저 추가를 쭉 하다보면 접근 키(Access key, Secret key)를 받을 수 있는 페이지가 나옵니다.
  키를 다운받은 다음에 잘 보관해주세요. 이 키들을 서버리스 프레임워크에서 쓸 겁니다.

키를 받고 나면 iam 페이지에서 나오도록 합시다.

1.1.3. Serverless 접근 권한 주기

아까 받은 키들을 서버리스에서 설정해주세요.


xxxxxxxxxx
serverlsss login
serverless config --provider aws --key 액세스키 --secret 시크릿액세스키

1.1.4. serverless 기본 템플릿 만들어보기

서버리스 프레임워크는 템플릿을 써서 기본적인 애플리케이션을 만들 수 있습니다.


xxxxxxxxxx
serverless create -t aws-nodejs -p serverless-start
cd serverless-start

템플릿을 만들면 파일 2개가 생깁니다. handler.js와 serverless.yml 입니다.

handler.js - 람다 실행 코드


x
'use strict';
module.exports.hello = async (event, context) => {
  return {
    statusCode: 200,
    body: JSON.stringify({
      message: 'Go Serverless v1.0! Your function executed successfully!',
      input: event,
    }),
  };
  // Use this code if you don't use the http event with the LAMBDA-PROXY integration
  // return { message: 'Go Serverless v1.0! Your function executed successfully!', event };
};

serverless.yml - 서버리스 프레임워크 설정파일


xxxxxxxxxx
service: sls-start
provider:
  name: aws
  runtime: nodejs8.10
functions:
  hello:
    handler: handler.hello // handler.js에 있는 hello 함수를 실행

serverless.yml을 조금 수정하고 배포를 해보겠습니다.

1.1.5. serverless.yml 수정 및 배포

serverless.yml - 서버리스 프레임워크 설정파일


xxxxxxxxxx
service: sls-start
provider:
  name: aws
  runtime: nodejs8.10
  region: ap-northeast-2
functions:
  hello:
    handler: handler.hello
    events: // rest api를 만들거니 events는 http로 하겠습니다.
      - http:
          path: hello
          method: get

이제 serverless deploy 를 터미널에 입력해봅시다.

성공적으로 배포되면 아래처럼 뜰 거에요.


xxxxxxxxxx
endpoints:
  GET - https://kzf2871d.execute-api.ap-northeast-2.amazonaws.com/dev/hello
functions:
  hello: sls-start-dev-hello

GET 옆의 url을 브라우저에 붙여넣기해 봅시다.

응답이 나오면 성공이에요!

이제 다이나모 DB와 람다를 연결해보겠습니다.

이제부터 쓸 데이터는 저번글 에서 다이나모 DB에 넣었던 Food 테이블의 데이터입니다.

Food 테이블에 데이터가 들어가 있다고 생각하고 설명할께요.

2 DynamoDB 와 람다 연결

2.1. 설정하기

다이나모DB를 쓰려면 사용 권한(iam role 지정)이 있어야해요.

serverless.yml 을 수정해주도록 합시다.


xxxxxxxxxx
service: sls-start
provider:
  name: aws
  runtime: nodejs8.10
  stage: dev
  region: ap-northeast-2
  iamRoleStatements:
    - Effect: "Allow"
      Action:
        - dynamodb:*
      Resource: "*"

배포를 해볼께요.


xxxxxxxxxx
sls deploy

배포가 성공적으로 되었나요?

이제 다이나모 디비에 접근할 수 있습니다!

이를 위한 람다함수를 만들어보도록 할께요.

다 완성되면 아래 그림 같은 구조가 됩니다.

2.2 람다함수 추가하기

프레임워크 설정에다 어떤 람다 파일을 쓸지 추가해줄께요.

`serverless.yml`


xxxxxxxxxx
provider:
  name: aws
  runtime: nodejs8.10
  stage: dev
  region: ap-northeast-2
  iamRoleStatements:
    - Effect: "Allow"
      Action:
        - dynamodb:*
      Resource: "*"
functions:
  hello:
    handler: handler.hello
    events:
      - http:
          path: hello
          method: get
  get:
    handler: api/recipes.get
    events:
      - http:
          path: recipes
          method: get
  list:
    handler: api/recipes.list
    events:
      - http:
          path: recipes/{type}
          method: get

functions 부분에 get, list 함수를 추가했습니다.

get함수는 쿼리 스트링(queryString)에 따라 값을 불러오는 함수이구요.

list함수는 음식의 종류(type)에 따라 데이터를 불러옵니다.

api 폴더에 recipes.js를 추가하고 배포해 볼께요.

`api/recipes.js`


xxxxxxxxxx
'use strict';
const AWS = require('aws-sdk');
AWS.config.update({
    region: 'ap-northeast-2',
    endPoint: 'http://dynamodb.ap-northeast-2.amazonaws.com'
});
const docClient = new AWS.DynamoDB.DocumentClient();
const TableName =  'Food';
module.exports.get = async (event, callback) => {
    let queryParam = event.queryStringParameters;
    let  type  = queryParam['type'];
    const name = queryParam['name'];
    const params = {
        TableName : TableName,
        Key : {
            "type": type,
            "name": name,
        }
    }
    const result = await docClient.get(params).promise();
    const response = {
        statusCode: 200,
        body: JSON.stringify(result)
    }
    return response;
}
module.exports.query = async (event, callback) => {
    const { type } = event.pathParameters;
    const params = {
        TableName: TableName,
        KeyConditionExpression: "#type = :type",
        ExpressionAttributeNames: {
            "#type": "type"
        },
        ExpressionAttributeValues: {
            ":type": type
        }
    }
    const result = await docClient.query(params).promise();
    const response = {
        statusCode: 200,
        body: JSON.stringify(result['Items'])
    }
    console.log(result);
    return response;
}

배포를 해볼께요.


xxxxxxxxxx
sls deploy

배포가 끝났나요?

이제 함수가 제대로 동작하는지 테스트 해볼께요.

2.3.1 동작 테스트 - GET 함수

우선 GET 함수는 아래의 주소를 브라우저에 붙여 넣어주세요.


xxxxxxxxxx
https://kzf2871d.execute-api.ap-northeast-2.amazonaws.com/dev/recipes?type=Western&name=Carbonara

DB에 데이터가 있다면 아래처럼 나올 거에요.


xxxxxxxxxx
{
    "Item": {
        "ingredients": {
            "garlic": "1",
            "bacon": "50g",
            "spaghetti": "90g",
            "egg": "1"
        },
        "price": 13000,
        "name": "Carbonara",
        "type": "Western",
        "orderCount": 50
    }
}

2.3.2 동작 테스트 - list 함수

list 함수를 테스트 해볼께요.


xxxxxxxxxx
https://kzf2871d.execute-api.ap-northeast-2.amazonaws.com/dev/recipes/Western

type이 Western인 아이템을 모두 조회하는 걸 알 수 있습니다.


xxxxxxxxxx
[
    {
        "ingredients": {
            "garlic": "1",
            "bacon": "50g",
            "spaghetti": "90g",
            "egg": "1"
        },
        "price": 13000,
        "name": "Carbonara",
        "type": "Western",
        "orderCount": 50
    },
    {
        "ingredients": {
            "honey maid graham cracker crumbs": "1 3/4 cups",
            "eggs": "3",
            "butter, melted": "1/3 cup",
            "sugar, divided": "1 1/4 cups",
            "philadelphia cream cheese": "3 packages(8 ounce)",
            "vanilla": "2 teaspoons vanilla"
        },
        "price": 13000,
        "name": "Cheese cake",
        "type": "Western",
        "orderCount": 77
    }
]

3.플러터 앱에서 보여주기

이번엔 API Gateway와 플러터 앱을 연결해 보도록 하겠습니다.

앱은 최대한 간단히 만들어보도록 할께요.

앱은 3개의 클래스로 구성되어 있습니다.

UI를 그리는 위젯 클래스(main.dart)
데이터 저장 하는 모델 클래스( recipe.dart)
http로 데이터 요청하는 api 클래스 (api.dart)

플러터 구조

일단 http package를 설정 파일에 추가해주세요.

dart 2.0 부터는 http 패키지를 항상 추가해줘야합니다.

`pubspec.yaml`


xxxxxxxxxx
version: 1.0.0+1
environment:
  sdk: ">=2.0.0-dev.68.0 <3.0.0"
dependencies:
  flutter:
    sdk: flutter
  cupertino_icons: ^0.1.2
  http: ^0.12.0
dev_dependencies:
  flutter_test:
    sdk: flutter

AWS로부터 받은 데이터를 저장하는 클래스를 만들어볼께요.

`recipe.dart`


xxxxxxxxxx
class Recipe {
  String name;
  String type;
  int orderCount;
  int price;
  Map<String, dynamic> ingredients;
  Recipe({this.price, this.name, this.type, this.orderCount, this.ingredients});
  Recipe.fromJson(Map<String, dynamic> json) : // json데이터를 클래스 형식으로 변환
    name = json['name'],
    type = json['type'],
    price = json['price'],
    orderCount = json['orderCount'],
    ingredients = json['ingredients'];
}

`api.dart`


xxxxxxxxxx
import 'dart:async';
import 'dart:convert';
import 'package:http/http.dart' as http;
import 'model/recipe.dart';
class API {
  String baseUrl = "https://kzf2871d.execute-api.ap-northeast-2.amazonaws.com/dev";
  final client = http.Client();
  Future<Recipe> fetchRecipe(String type, String name) async {
    var path = "/recipes?type=${type}&name=${name}";
    var url = baseUrl + path;
    final response = await client.get(url); // http get 메소드로 리퀘스트를 보냅니다.
    var data = json.decode(utf8.decode(response.bodyBytes)); // utf8로 디코딩해야 한글이 깨지지 않습니다.
    return Recipe.fromJson(data['Item']);
  }
}

response data를 utf8로 디코딩해야 한글이 깨지지 않습니다.

`main.dart`


xxxxxxxxxx
import 'package:flutter/material.dart';
import 'package:flutter_api_gateway/model/recipe.dart';
import 'api.dart';
void main() => runApp(MyApp());
class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: MyHomePage(title: 'Flutter Demo Home Page'),
    );
  }
}
class MyHomePage extends StatefulWidget {
  MyHomePage({Key key, this.title}) : super(key: key);
  final String title;
  API api = API();
  @override
  _MyHomePageState createState() => _MyHomePageState();
}
class _MyHomePageState extends State<MyHomePage> {
  bool loadRecipe = false;
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(widget.title),
      ),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.start,
          children: <Widget>[
            loadRecipe
                ? FutureBuilder<Recipe>(
                    future: widget.api.fetchRecipe("Western", "Carbonara"),
                    builder: (context, snapshot) {
                      if (snapshot.hasData) {
                        Recipe recipe = snapshot.data;
                        print(recipe.price);
                        return recipeView(recipe);
                      } else {
                        return Text("no data!");
                      }
                    },
                  )
                : Text("data is not loaded!"),
          ],
        ),
      ),
      floatingActionButton: FloatingActionButton( // 버튼을 누르면 데이터를 불러옵니다.
        onPressed: () {
          setState(() {
            loadRecipe = true;
          });
        },
        tooltip: 'Data Load',
        child: Icon(Icons.add),
      ), // This trailing comma makes auto-formatting nicer for build methods.
    );
  }
  Widget recipeView(Recipe recipe) {
    return Container(
      padding: const EdgeInsets.symmetric(vertical: 18.0, horizontal: 9.0),
      child: Column(
        mainAxisAlignment: MainAxisAlignment.spaceEvenly,
        crossAxisAlignment: CrossAxisAlignment.start,
        children: <Widget>[
          Text("음식종류 : ${recipe.type}"),
          Text("음식이름 : ${recipe.name}"),
          Text("가격 : ${recipe.price}")
        ],
      ),
      decoration: BoxDecoration(
        color: Colors.grey.withOpacity(0.2),
        borderRadius: BorderRadius.all(
          Radius.circular(10.0),
        ),
      ),
    );
  }
}

버튼을 누르면 데이터가 화면에 표시됩니다.

생각보다 마지막편 업데이트가 늦었네요!

AWS 서버리스 시리즈는 3편으로 마무리하고

추후 새로운 내용이 있으면 연재하도록 하겠습니다.

다음에는 플러터 글로 찾아뵙도록 하겠습니다!

1편 - AWS Lambda와 AWS Gateway 연결

2편 - 아마존 DynamoDB 시작하기. CRUD부터 Scan까지

서버리스 앱 개발하기 2 - 아마존 DynamoDB 시작하기. CRUD부터 Scan까지

에드 신 — Tue, 11 Dec 2018 01:31:38 +0900

AWS DynamoDB 시작하기 - 아마존 다이나모 디비 예제.aws-series-02-dynamodb

DynamoDB란?

DynamoDB(다이나모디비)는 키-밸류 데이터베이스입니다.

NoSQL방식이라서 확장이 간편하고 사용한만큼만 요금을 내는 구조입니다.

DynamoDB는 스키마를 복잡하게 잡지 않아도 되는 게 장점입니다.

스키마와 상관없이 데이터를 추가가하는 게 가능하기 때문이에요.

DynamoDB는 또한 빠르고 안정성 있게 확장이 가능합니다.

다만 정렬용으로는 좀 맞지 않습니다.

정렬을 다채롭게 하는 것도 가능하긴 한데, SQL 데이터베이스에 비하면 좀 까다롭습니다.

1. DynamoDB - 테이블 만들기

1.1 - Table

테이블은 데이터를 담는 그릇입니다.

DynamoDB는 관계형 데이터베이스가 아니기에 조인이 없습니다.

대신 파티션 키 (Partition Key)와 정렬 키 (Sort Key)만 있으면 됩니다.

파티션 키 (Parition Key) : 무조건 있어야함. 테이블에 있는 아이템을 어디다가 나눌지 정할 때 쓰임. Hash Key라고도 불림. 파티션 키는 1개만 있어야 됨.
정렬 키 (Sort Key) : 정렬할 때 쓰임. 꼭 있어야되는 건 아님. Range Key라고도 불림.

파티션 키와 정렬 키는 한번 정해지면은 바꿀 수 없습니다.

영화 데이터를 담은 테이블을 만들어볼께요

1.1 - Table. 파티션 키만 사용

movie name (Partition Key)	duration (minute)	date
집으로 가는 날	90	2018.09.10
놀러 가기 좋은 날	120	2017.02.05
여행 가고 싶은 날	150	2016.01.03

영화 이름을 파티션 키로 잡아 보았습니다.

파티션 키만 쓸 경우 간단히 테이블을 만들 수 있는 게 장점이지만, 중복된 키가 있을 때 문제가 됩니다.

( 아마존은 e-mail_id, employee_no, customer_id + product_id 처럼 중복되는 값이 없는 걸 권장합니다. )

영화 이름이 같을 경우 문제가 되겠죠?

데이터를 추가하거나, 업데이트할 때 어떤 걸 할지 모르게 되니까요.

1.1 - Table. 파티션 키와 정렬 키 사용

위의 테이블에 정렬 키를 더해 볼게요. 영화에 따라 고유하게 부여된 ID 입니다.

이젠 영화 이름이 같아도 데이터를 추가하는 데 없어집니다.

movie name (Partition Key)	movie id (Range Key)	duration (minute)	date
집으로 가는 날	a8273uerie	90	2018.09.10
놀러 가기 좋은 날	e9a928grjf	120	2017.03.05
여행 가고 싶은 날	d23a8beqo	150	2016.01.03
여행 가고 싶은 날	abc2913eu	125	2014.06.15

이제부터 실습을 해보도록 할께요.

**1.1.2 - 실제 사용할 테이블

이 테이블은 음식 정보를 담은 테이블입니다.

음식을 구분하는 id, 종류, 이름, 가격 등이 나와 있죠.

type	name	price	size
양식 (Western Food)	까르보나라	13000	소
한식 (Korean Food)	족발	33000	중
중식 (Chinese Food)	짜장면	55000	대

테이블을 만들 때는 파티션 키 (Paritition Key, 필수)를 정해줘야합니다. 정렬 키(Sort Key)도 있으면 좋으니 만들도록 할께요.

파티션키 (Partition Key) - type
- 파티션키는 필수입니다!
정렬 키 (Sort key) - name
- 필수는 아닙니다.
- 정렬할 때 써요.
- 다른 키로 정렬하고 싶으면 두번째 정렬 키 (Local Secondary Index나, Global Secondary Index )를 정해주면 됩니다.

1.2 item(항목)

아이템은 테이블에 있는 각각의 행을 말합니다.

위의 음식 테이블에서는 (1,양식,까르보나라,13000,소)가 아이템이 되겠지요.

아이템에 있는 항목은 키(partition key, sort key)만 뺴고 수정할 수 있습니다.

partition key와 sort key를 수정하려면 지우고 새로 만드는 수 밖에 없습니다.

1.3 데이터 타입

DynamoDB의 데이터는 크게 3가지 타입이 있습니다.

Scalar Type: Number(숫자, N으로 표시), String(문자, S로 표시), Binary(B로 표시), Boolean and Null
Document Types: 리스트와 맵
Set Types: 숫자 집합(Number Set), 문자 집합(String Set), Binary Set(이진자료형 집합)

2. DynamoDB 테이블 만들기

2.1. module 설치

이번 예제는 nodejs를 써서 진행하도록 하겠습니다.

일단 aws-sdk를 설치해주세요.


npm install -g aws-sdk

2.2. aws 설정하기

aws-sdk가 설치되었으면 새로 자바크스립트 파일(dynamodb_start.js)을 하나 만들어줍니다.

한국 리전을 설정해주고, 엔드포인트도 변경해줍니다.


x
// dynamodb_start.js
var AWS = require('aws-sdk')
AWS.config.update({
    region: 'ap-northeast-2',
    endpoint: "http://dynamodb.ap-northeast-2.amazonaws.com"
})

2.3. 테이블 만들기

이제 데이터베이스 테이블을 만들어볼께요.

일단 테이블을 어떻게 만들지 정합니다.

파티션 키나, 데이터 읽기 쓰기량을 정하는거죠.

지금 만들 테이블은 요리법이 담겨 있는 테이블입니다.

요리종류(type), 이름(name), 재료(ingredients) 등등이 들어있죠.


const dynamodb = new AWS.DynamoDB()
const params = {
    TableName: tableName,
    KeySchema: [
        {AttributeName: "type", KeyType: "HASH"},
        {AttributeName: "name", KeyType: "RANGE"}
    ],
    AttributeDefinitions: [
        {AttributeName: "type", AttributeType: "S"},
        {AttributeName: "name", AttributeType: "S"}
    ],
    ProvisionedThroughput: {
        ReadCapacityUnits: 1,
        WriteCapacityUnits: 1
    }
}

정해진 설정을 바탕으로 테이블을 만듭니다.


xxxxxxxxxx
dynamodb.createTable(params).promise()
    .then(req => {
        console.log(req)
    })
    .catch(err => {
        console.log(err)
    })

제대로 만들어졌나요?

성공하면 아래와 같은 메시지가 나옵니다.


xxxxxxxxxx
{ TableDescription:
   { AttributeDefinitions:
      [   { AttributeName: 'type', AttributeType: 'S' },
          { AttributeName: 'name', AttributeType: 'S' } ],
     TableName: 'Food',
     KeySchema:
      [ { AttributeName: 'type', KeyType: 'HASH' },
        { AttributeName: 'name', KeyType: 'RANGE' } ],
     TableStatus: 'CREATING',
     CreationDateTime: 2018-12-05T07:25:06.054Z,
     ProvisionedThroughput:
      { NumberOfDecreasesToday: 0,
        ReadCapacityUnits: 1,
        WriteCapacityUnits: 1 },
     TableSizeBytes: 0,
     ItemCount: 0,
     TableArn: 'arn:aws:dynamodb:ap-northeast-2:xxxxxxxxxxxx:table/Food',
     TableId: 'xxxxxxx-xxxx-xxxx-xxxx-xxxxxx' } }

이제 테이블에서 데이터(아이템)을 읽고, 쓰고, 업데이트 하는 걸 해보도록 할께요.

3. DynamoDB - 데이터 활용하기 (CRUD, QUERY)

3.1 CRUD 작업하기

3.1.1 ADD ITEM

일단 아이템을 테이블에 넣어보도록 할께요.

아이템을 넣는 건 테이블을 만드는 거에 비하면 간단합니다.

아이템의 형태는 자유롭게 정할 수 있습니다만, partition key랑 sort key는 빼먹으면 안됩니다!


xxxxxxxxxx
const docClient = new AWS.DynamoDB.DocumentClient()
const tableName = "Food"
const params = {
        TableName: tableName,
        Item: {
            "type": "Western",
            "name": "Carbonara",
            "price": 13000,
            "ingredients": {
                "egg": "1",
                "spaghetti": "90g",
                "garlic": "1",
                "bacon": "50g"
            }
        }
}
docClient.put(params).promise()
        .then(req => {
            console.log(req)
        })
        .catch(err => {
            console.log(err)
        })

잘 되었나요?

3개 정도 아이템을 더 더해보도록 하겠습니다.

이번에는 파일에서 읽을께요.

recipes.json - ingredients이 조금씩 달라요.


xxxxxxxxxx
{
  "items": [
    {
      "type": "Western",
      "name": "Carbonara",
      "price": 13000,
      "orderCount": 50,
      "ingredients": {
        "egg": "1",
        "spaghetti": "90g",
        "garlic": "1",
        "bacon": "50g"
      }
    },
    {
      "type": "Korean",
      "name": "Spicy chicken stew",
      "price": 25000,
      "orderCount": 12,
      "ingredients": {
        "chicken": "1",
        "potato": "2",
        "onion": "1",
        "carrot": "1/3",
        "green onion": "2",
        "water": "600ml",
        "sesame seeds": "little",
        "red pepper": "2spoons"
      }
    },
    {
      "type": "Korean",
      "name": "Soybean pastestew",
      "price": 6000,
      "orderCount": 25,
      "ingredients": {
        "fermented soybean paste": "1T",
        "anchovy broth": "500ml",
        "pumpkin": "1",
        "marbled": "2 pieces",
        "red peper": "1T",
        "bean paste": "0.3 spoon",
        "onion": "1 tablespoon"
      }
    },
    {
      "type": "Western",
      "name": "Cheese cake",
      "price": 13000,
      "orderCount": 77,
      "ingredients": {
        "honey maid graham cracker crumbs": "1 3/4 cups",
        "butter, melted": "1/3 cup",
        "sugar, divided": "1 1/4 cups",
        "philadelphia cream cheese": "3 packages(8 ounce)",
        "vanilla": "2 teaspoons vanilla",
        "eggs": "3"
      }
    }
  ]
}


xxxxxxxxxx
const data = fs.readFileSync("recipes.json")
const recipes = JSON.parse(data)
for(let index in recipes.items) {
    let item = recipes.items[index]
    const params = {
        TableName: tableName,
        Item: item
    }
    docClient.put(params).promise()
        .then(req => {
            console.log(req)
        })
        .catch(err => {
            console.log(err)
        })
}

Item의 ingredients가 다르더라도 큰 문제없이 추가가 됩니다.

이런 유연함이 다이나모 디비의 장점이죠.

3.1.2 get item

추가한 아이템을 불러와 볼께요.

여러 아이템을 한꺼번에 불러오려면 다른 방법(query, scan)을 써야되지만

아이템 1개만 가져올땐 get을 쓰면 됩니다.


x
const docClient = new AWS.DynamoDB.DocumentClient()
const params = {
    TableName: "Food",
    Key: {
        "type": "Western",
        "name": "Carbonara"
    }
}
docClient.get(params).promise()
    .then(req => {
        console.log(req)
    })
    .catch(err => {
        console.log(err)
    })

get을 쓸땐 꼭 Key를 적어줘야합니다.

잘 되면은 아래처럼 나올거에요.


xxxxxxxxxx
{ Item:
   { ingredients: { garlic: '1', bacon: '50g', spaghetti: '90g', egg: '1' },
     price: 13000,
     name: 'Carbonara',
     type: 'Western' } }

3.1.3 update item

이번엔 아이템의 값을 수정할께요.


xxxxxxxxxx
var docClient = new AWS.DynamoDB.DocumentClient()
var params = {
    TableName: "Food",
    Key: {
        "type": "Western",
        "name": "Carbonara",
    },
    UpdateExpression: "set price = :price", // 어떤 걸 수정할지 정해줘야합니다.
    ExpressionAttributeValues: {  // 수정할 것의 값을 정해줘야합니다.
        ":price": 15000
    }
}
docClient.update(params).promise()
    .then(res => {
        console.log(res)
    })
    .catch(err => {
        console.log(err)
    })

방금 수정한 아이템을 불러와 보겠습니다.


const docClient = new AWS.DynamoDB.DocumentClient()
const params = {
    TableName: "Food",
    Key: {
        "type": "Western",
        "name": "Carbonara"
    }
}
docClient.get(params).promise()
    .then(req => {
        console.log(req)
    })
    .catch(err => {
        console.log(err)
    })

price 가 바뀌었죠?

이처럼 일반 값은 얼마든지 수정할 수 있습니다.

하지만 키(key), 테이블명(table name)은 수정이 안됩니다.

키는 한번 정하면 끝이니 주의하세요.

3.1.4 delete item

아이템을 지워보겠습니다.

단순히 지우는 게 아니라 조건을 넣어보겠습니다.

모든 아이템을 다 지우면 곤란하니까요.

sql에서 where를 쓰는 거랑 비슷합니다.

조건은 ConditionExpression 을 써서 정합니다.


xxxxxxxxxx
var docClient = new AWS.DynamoDB.DocumentClient()
const params = {
    TableName: tableName,
    Key: {
        "type": "Korean",
        "name": "Soybean pastestew",
    },
    ConditionExpression: "price <= :price",
    ExpressionAttributeValues: {
        ":price": 8000
    }
}
docClient.delete(params).promise()
    .then(res => {
        console.log(res)
    })
    .catch(err => {
        console.log(err)
    })

잘 지워졌나요?

지워진 아이템을 가져오려고 하면(get) 아무것도 안 나옵니다.


xxxxxxxxxx
const params = {
    TableName: "Food",
    Key: {
        "type": "Korean",
        "name": "Soybean pastestew"
    }
}
docClient.get(params).promise()
    .then(req => {
        console.log(req)
    })
    .catch(err => {
        console.log(err)
    })

지금까지 기본적인 CRUD (Create, Read, Update, Delete)를 알아보았습니다.

이제 데이터를 조회하는 법에서 알아보도록 할께요.

3.2 데이터 조회하기

데이터를 조회하는 방법은 2가지 입니다. 쿼리랑 스캔인데요. 쿼리는 파티션 키를 바탕으로 데이터를 찾습니다. 스캔은 전체 테이블에서 데이터를 찾을 때 쓰구요. 일단 쿼리부터 설명해보겠습니다.

3.2.1 query

쿼리를 잘 쓰려면 파티션 키를 잘 정해야합니다. 파티션 키를 통해 데이터를 분산하고, 조회할 때 쓰기 때문이죠.

위에서 파티션 키를 음식 종류(type)로 정했죠. 음식 종류에 따라 음식을 찾기 위해서 입니다. 한식이 500종류, 일식이 200종류, 양식이 1000종류 있는 경우를 생각해 봅시다. 유저가 50대 한국인이여서 한식만 찾는다면 어떤 쿼리를 써야할까요?

한식을 키로 두고 쿼리를 쓰면 되겠죠?


xxxxxxxxxx
const params = {
    TableName: "Food",
    KeyConditionExpression: "#type = :type", // 어떤 키로 조회할지 정합니다.
    ExpressionAttributeNames: { // 조회할 때 쓸 키의 이름, 별명을 정합니다.
        "#type": "type"
    },
    ExpressionAttributeValues: { // 조회할 키의 값을 정합니다.
        ":type": "Korean"
    }
}
docClient.query(params).promise()
        .then(res => {
            res.Items.forEach(item => {
                console.log("name :", item.name, ", type :", item.type)
            })
        })
        .catch(err => {
            console.log(err)
        })

쿼리 결과는 아래와 같이 나옵니다. 어렵진 않죠.

다만 다이나모디비의 쿼리는 SQL의 SELECT처럼 자유롭게는 못 쓰고, 파티션 키의 영향을 크게 받는다는 걸 명심하세요.


xxxxxxxxxx
name : Soybean pastestew , type : Korean
name : Spicy chicken stew , type : Korean

3.2.2 query - 다른 키로 정렬하기, 보조 인덱스

다이나모 디비는 정렬키로 데이터로 정렬합니다. 하지만 정렬키 만으로는 부족할 때가 있죠.

그때는 새 인덱스를 추가해 정렬 할 때 씁니다.

새 인덱스를 더하는 방법은 2가지입니다.

하나는 로컬 보조 인덱스 (Local Secondary Index, 두번째 지역 인덱스)이고

다른 하나는 글로벌 보조 인덱스 (Global Secondary Index, 글로벌 두번째 키) 입니다.

로컬 보조 인덱스
- 테이블을 만들 때 정해야됨
- 테이블을 만들고 추가 못함
- 인덱스를 써서 정렬해도, 읽기 쓰기 사용량이 늘어나지 않음
- 강력한 일관성과 최종 일관성(Eventual consistency)을 보장함.
- 인덱스 크기 제한이 있음 (10 GB 이하)

글로벌 보조 인텍스
- 테이블 만들고도 추가할 수 있음
- 테이블을 복제해서 새 인덱스를 추가함.
- 추가할 때마다, 읽기 쓰기 사용량이 늘어남
- 최종 일관성만 보장함.
- 인덱스 크기 제한이 없음 (No partition key size limits)

일단 로컬 보조 인덱스부터 알아볼께요.

3.2.3. query - Local Secondray Index

로컬 보조 인덱스는 테이블을 만들때만 정할 수 있습니다.

전에 만든 테이블을 지우고, 새로 테이블을 만들어 볼께요.

`테이블 삭제`


xxxxxxxxxx
dynamodb.deleteTable({TableName: 'Food'}).promise()
        .then(req => {
            console.log(req)
        })
        .catch(err => {
            console.log(err)
        })

음식의 가격별로 쿼리할 수 있게, price를 새로운 인덱스로 정하겠습니다.

`인덱스 있는 새 테이블 만들기`


x
const params = {
        TableName: 'Food',
        KeySchema: [
            { AttributeName: "type", KeyType: "HASH" },
            { AttributeName: "name", KeyType: "RANGE" },
        ],
        AttributeDefinitions: [
            { AttributeName: "type", AttributeType: "S" },
            { AttributeName: "name", AttributeType: "S" },
            { AttributeName: "price", AttributeType: "N" } // 로컬 인덱스에 쓸 Attribute입니다.
        ],
        LocalSecondaryIndexes: [
            {
                IndexName: "IndexPrice", // Index 이름을 정해줘야합니다.
                KeySchema: [
                    { AttributeName: "type", KeyType: "HASH" },
                    { AttributeName: "price", KeyType: "RANGE"} // price를 키로 정했습니다. 
                ],
                Projection: {
                    ProjectionType: "ALL"
                }
            }
        ],
        ProvisionedThroughput: {
            ReadCapacityUnits: 1,
            WriteCapacityUnits: 1
        },
}
dynamodb.createTable(params).promise()
        .then(res => {
            console.log(res);
        })
        .catch(err => {
            console.log(err);
        })

테이블이 만들어졌나요?

이제 인덱스를 써서 쿼리를 할 수 있습니다.

테이블을 새로 만들었으니, 데이터를 넣어주세요 (위의 데이터 넣는 코드를 참고해주세요)

그럼 조회를 해보겠습니다. 가격 순으로 조회를 할거에요.

`인덱스로 조회`


xxxxxxxxxx
const params = {
        TableName: 'Food',
        IndexName: "IndexPrice", // 어떤 인덱스를 쓸지 정해줘야합니다.
        KeyConditionExpression: "#type = :type",
        ExpressionAttributeNames: {
            "#type": "type"
        },
        ExpressionAttributeValues : {
            ":type": "Korean"
        },
        ScanIndexForward: false // false면 내림차순, true면 오름차순입니다.
    }
docClient.query(params).promise()
        .then(res => {
            res.Items.forEach(item => {
                console.log('item : ', item);
            })
        })
        .catch(err => {
            console.log(err);
        })

제대로 되었으면 음식이 가격순으로 나올 거에요.

3.2.3 query - Global Secondary Index

글로벌 보조 인덱스는 전에 만든 테이블을 써서 만듭니다.

인덱스로 쓰일 속성은 orderCount입니다.

주문량이 많은 음식순으로 정렬을 하려고 합니다~!


xxxxxxxxxx
const params = {
        TableName: tableName,
        AttributeDefinitions: [
            { AttributeName: "type", AttributeType: "S"},
            { AttributeName: "orderCount", AttributeType: "N"}
        ],
        GlobalSecondaryIndexUpdates: [ // 글로벌 인덱스를 정의합니다.
            {
                "Create": {
                    IndexName: "IndexOrderCount", // 인덱스 이름을 정합니다.
                    KeySchema: [
                        { AttributeName: "type", KeyType: "HASH"  },
                        { AttributeName: "orderCount", KeyType: "RANGE" } 
                    ],
                    Projection: {
                        "ProjectionType": "ALL"
                    },
                    ProvisionedThroughput: {
                        ReadCapacityUnits: 1,
                        WriteCapacityUnits: 1
                    }
                }
            }
        ]
    }
dynamodb.updateTable(params).promise() // 테이블을 업데이트합니다. 새로 만들지 않습니다.
        .then(res => {
            console.log(res);
        })
        .catch(err => {
            console.log(err);
        })

글로벌 보조 인덱스를 만들었으니, 이 인덱스로 조회해 볼께요.


xxxxxxxxxx
const params = {
        TableName: tableName,
        IndexName: "IndexOrderCount",
        KeyConditionExpression: "#type =:type and #oc >= :orderCount", 
        ExpressionAttributeNames: {
            "#type": "type",
            "#oc": "orderCount"
        },
        ExpressionAttributeValues: {
            ":type": "Korean",
            ":orderCount": 10
        }
}
docClient.query(params).promise()
        .then(res => {
            res.Items.forEach(function (item) {
                console.log(item.type, item.name, item.price, item.orderCount);
            })
        })
        .catch(err => {
            console.log(err)
        })

조회 결과


xxxxxxxxxx
Korean Spicy chicken stew 25000 12
Korean Soybean pastestew 6000 25

orderCount(주문량) 순으로 조회가 되네요!

이렇게 다이나모 디비도 정렬을 원하는 대로 할 수 있지만,

테이블 만들 때 인덱스를 정하거나, 나중에 추가해줘야하는 번거로움이 있습니다.

3.3 scan

스캔은 전체 테이블에서 데이터를 찾을 때 사용합니다.

스캔은 데이터 양이 많을수록 처리량이 많아서 비효율적이 되죠.

그렇지만 필터를 쓰면 SQL을 쓰는 것처럼 편하게 데이터 조회가 가능한 게 장점입니다.

키를 지정하지 않아도 되는게 쿼리(query)와의 차이점이죠.


xxxxxxxxxx
// scan시 쓰일 함수를 정의합니다.
function onScan(err, data) {
    if (err) {
        console.error("Unable to scan the table. Error JSON: ", JSON.stringify(err, null, 2))
    } else {
        console.log('Scan Succeeded')
        data.Items.forEach(function(food){
            console.log(food)
        })
    }
}
var params = {
   TableName: "Food", // 스캔은 키가 없어도 됩니다.
}
docClient.scan(params, onScan)

실행을 하면 전체 데이터를 조회해서 출력합니다.

지금은 데이터가 몇개 안되지만 테이블이 클수록 양이 엄청나겠죠?

전체 데이터를 스캔하지 말고 필터해서 필요한 데이터만 쓰도록 할께요.


xxxxxxxxxx
const params = {
    TableName: "Food",
    ProjectionExpression: "#name,#type,price", // 어떤 속성을 스캔할지 정함.
    FilterExpression: "price between :start_price and :end_price", // 데이터 필터링할 조건을 정함.
    ExpressionAttributeNames: {
        "#name": "name",
        "#type": "type"
    },
    ExpressionAttributeValues: {
        ":start_price": 5000,
        ":end_price": 20000
    }
}
function onScan(err, data) {
    if (err) {
        console.error("Unable to scan the table. Error JSON: ", JSON.stringify(err, null, 2))
    } else {
        console.log('Scan Succeeded')
        data.Items.forEach(function (food) {
            console.log(food)
        })
    }
}
docClient.scan(params, onScan)

실행하면 아래처럼 나옵니다.


xxxxxxxxxx
{ price: 15000, name: '까르보나라', type: 'Western' }
{ price: 6000, name: '차돌박이된장찌개', type: 'Korean' }

필터링을 하면 필요한 값만 쓸 수 있습니다.

다만 필터링을 해도 테이블을 다 확인하는 건 동일하다고 하네요.

데이터베이스 입장에서는 필터를 하나, 안 하나 큰 차이가 없는 거지요.

스캔을 적게 써야하는 건 이때문입니다.

기타 주의할점 - 테이블명 짓기

테이블이나 인덱스명을 정할 때는 규칙이 있습니다. 3~255자 사이의 글자여야하고, 다음의 문자만 포함할 수 있어요.

a-z
A-Z
0-9
_ (underscore)
- (dash)
. (dot)

자세한 건 아마존 공식 문서 를 참고해주세요.

기타 주의할점 - 다이나모 DB를 쓸 때 고려할점

이 글을 읽고 정리해 보았습니다. 공감이 가더군요.

SQL처럼 쿨하게 조회가 안된다. Key-Value 데이터베이스에 익숙하면 괜찮지만 RDMS에서 바로 왔으면 난감할 수도
개발 및 유지 보수가 간단하지 않다. 학습 곡선이 좀 있더군요.
해시키 잘 정해야한다. 중간에 못 바꾼다.

장점은 꾸준히 빠르다. 확장이 편리하다 입니다.

기타 주의할점 - 스캔 효율적으로 쓰기

아마존의 베스트 프랙티스를 요약해보았습니다.

Best Practice for Querying and Scanning

Reduce page size - 스캔을 할 때는 페이지 크기를 줄이기를 권하고 있습니다. 기본값은 1mb인데 Limit 변수를 쓰면 한번에 읽는 페이지수를 조절할 수 있죠.
Isolate scan operations - 복제 테이블(shadow table)을 만들기를 권합니다. 특정 용도를 위해 테이블을 만들면 스캔때문에 생기는 병목 현상을 막을 수 있습니다. read capacity를 과도하게 쓰는 것도 피할 수 있죠.

마무리

오늘은 다이나모 DB에 대해서 알아보았는데요.

다음에는 서버리스 프레임워크 (Serverless Framework)의 사용법과 람다, 다이나모 DB의 연결을 해보도록 하겠습니다.

더 효율적인 구글 검색을 위한 5가지 팁

에드 신 — Tue, 27 Nov 2018 14:04:29 +0900

더 효율적인 구글 검색을 위한 5가지 팁

1. 영어 단어 뜻 검색하기

영어 뜻을 찾아볼때 구글을 쓰면 정말 편리합니다.

바로 뜻이랑 발음이 다 나오죠.

define: 을 쓰면 됩니다.

영어 공부할때 이만한 게 없습니다.

define : collate

define : plummet

2. 사이트 내부 검색

자주 가는 커뮤니티나 사이트에서 원하는 글을 찾고 싶지만

통합 검색이 없어서 아쉬운 경우가 종종 있죠.

이때 사이트 내부 검색을 쓰면 좋습니다.

사이트 내부 검색은 site:를 쓰면 됩니다.

페북에서 독서모임을 찾고 싶다면?

site:facebook.com 독서모임

페북에서 블록체인 관련 글을 찾아보고 싶다면?

site:facebook.com 블록체인

코딩에 대해 알아보고 싶다면?

site:tistory.com 코딩

퇴사 이야기를 듣고 싶다면?

site:brunch.co.kr 퇴사

아마존 클라우드를 공부하고 싶다면?

site:medium.com aws lambda

3. 특정 종류의 파일만 검색하기

pdf나 이미지, 영상만 검색해보고 싶을 때가 있죠.

이럴 때는 filetype: 를 쓰면 좋습니다.

이력서 양식이 궁금하다면?

filetype:doc 이력서양식

스위프트 프로그래밍 관련 pdf를 찾아보고 싶다면?

filetype:pdf swift

코틀린 프로그래밍 관련 pdf를 찾아보고 싶다면?

filetype:pdf kotlin

4. 내가 원하는 정확한 단어로 검색하기

구글이 뛰어난 검색 엔진이지만 여러 단어를 검색하면 딱 원하는 결과가 안 나오는 경우가 종종 있습니다.

이때 ""를 써서 단어들을 감싸주면 내가 찾는 정보가 정확히 검색되게 됩니다.

"inbound marketing"

"performance marketing"

"퍼포먼스 마케팅"

5. 특정 단어 뺴고 검색하기

검색을 하다보면 내가 원하지 않는 내용이 나올 때가 있죠.

이때 - (마이너스 기호)를 쓰면 그 내용은 빠지고 검색되게 됩니다.

코딩 -파이썬

마케팅 -애플

마무리

지금까지 더 나은 구글 검색 방법을 알아보았습니다.

이번에 알게 된 구글 검색 팁을 활용해서 더 빠르게 공부, 일을 끝내기를 바랍니다.

30분 적게 일하는 삶을 누릴 수 있기를!

서버리스 앱 개발하기 1 - AWS Lambda와 AWS Gateway 연결

에드 신 — Tue, 27 Nov 2018 01:02:09 +0900

서버리스 앱 개발하기 1 - AWS Lambda와 AWS Gateway 연결

앞으로 서버리스로 앱 개발이란 주제로 3회간 연재를 해보려 합니다.

AWS Lambda와 AWS Gateway 연결해보기

AWS Lambda와 DynamoDB 연결하기, Serverless 프레임워크 사용

AWS Lambda와 Flutter 연결하기

사용할 서비스는 AWS Lambda, AWS API Gateway, Flutter 입니다.

서버리스나 크로스 플랫폼 개발에 관심 있는 분들이 봐주시면 좋겠네요.

기존에 저는 파이어베이스를 1년 넘게 사용했었는데 복잡한 쿼리가 안 되는 치명적인 단점이 있더군요.

파이어베이스가 처음 개발할 때는 정말 좋은데 클라이언트 단에 코드가 몰리는 경향이

강하고 데이터베이스에 있는 데이터 관리가 쉽지 않아 다른 서비스를 고려하기 시작했습니다.

그러다가 AWS Lambda를 알게 되었죠.

서버가 있는지 없는지 신경 쓰지 않고 함수만 호출하면 되는게 람다입니다.

람다를 쓰게 되면 서버가 죽었을 때 살리는 걱정을 하지 않아도 되는 장점이 있었습니다.

게다가 커스터마이징도 가능하구요.

반면 좀 상대적으로 느리다고 합니다.

바로 콜드 스타트와 핫스타트때문인데요.

오랫동안 람다 함수를 쓰지 않으면 람다가 대기 상태에 있기에

반응속도가 느려진다고 합니다.

어떤 언어를 쓰느냐에 따라 다르지만 0.2 ~ 0.5초 가량 걸린다고 합니다.

그럼 언제 람다를 쓰는 게 좋을까요? 장단점을 비교해 보겠습니다.

AWS Lambda를 써도 좋은 곳 (람다의 장점)

비용 예측이 어려운 곳
조금은 느려도 좋은 앱
확장을 적은 노력으로 빠르고 하고 싶을 때

AWS Lambda 쓰지 말아야할곳 (람다의 단점)

cpu 처리를 많이 하는 곳
실시간 멀티 플레이를 하는 게임 (모바일 턴제 게임은 가능함)
속도가 중요한 앱

제 경우엔 크롤링 후 서버에서 데이터를 처리 후, 보여주는 앱을 만들고 있습니다.

속도가 크게 문제가 되지 않기에 람다를 택했습니다.

AWS Lambda 시작하기

aws lambda는 콘솔에서 만들 수도 있고 cli 툴로 만들수도 있는데요.

일단은 콘솔에서 만들어보도록 하겠습니다.

aws에 로그인하고 함수를 만드는 화면으로 이동합시다.

create function을 누르면 람다 함수를 만드는 화면으로 넘어갑니다.

함수 이름(Name)은 ‘myHello'로 하고 프로그래밍 언어는 node.js를 쓰도록 하겠습니다.

nodejs의 버전은 8.1로 하겠습니다. 8.1로 해도 예전 코드가 돌아가더군요.

웹 상의 예제 코드가 낮은 버전이라고 해도 신경 쓰지 마시고 최신 버전 노드를 쓰면 됩니다.

새로 role을 만들거구요.

roleName은 ‘myLambdaRole’로 하겠습니다.

람다 함수를 만들면 설정(lambda cofiguration) 화면으로 넘어오게 됩니다.

여기서 람다 함수를 변경해 줄 수도 있고, 람다와 연결할 트리거들을 정해줄 수 있습니다.

이 설정화면을 가장 많이 사용하게 될 건데요.

현재는 따로 연결된 함수는 없습니다.

오른쪽 상단을 보면 Test와 Save 버튼이 보이는데요.

람다 함수를 실행할 때 쓰입니다.

이제 화면을 내려서

실제 람다 코드를 보도록 합니다.


x
exports.handler = async (event) => {
    // TODO implement
    const response = {
        statusCode: 200,
        body: JSON.stringify('Hello Lambda'),
    };
    return response;
};

어떻게 동작하는지 알고 싶다면 Test 버튼을 눌러보세요.

이벤트를 설정하는 화면이 나올거에요.

이벤트를 만들었으면 Save를 하고 다시 테스트를 해보세요.

응답이 아래처럼 오면 성공이에요.


x
Response:
{
  "statusCode": 200,
  "body": "\"Hello Lambda"\"
}

아래는 전체 실제 람다 에디터에서 실행해본 화면이에요.

소스 코드 밑에 response가 표시되어서 바로바로 결과를 확인할 수 있습니다.

index.js를 수정해보면서 람다가 어떻게 동작하는지 확인해보도록 합시다.

지금까지 가장 기초적인 람다를 만들었습니다.

람다를 바로 쓸 수는 없고, 외부에서 접근하려면 AWS API Gateway와 연결을 해주어야합니다.

AWS API Gateway

aws api gateway는 api를 만들때 쓰입니다. aws 내부의 서비스와 외부의 연결 통로를 만들 때 쓰이죠. aws lambda도 외부에서 쓰려면 api gateway와 연결해야합니다.

1. 새 api 만들기

api gateway를 쓰려면 새 api를 정해줘야합니다.

이름은 편한대로 정해주세요.

2. 리소스 만들기

리소스는 url을 말합니다.

리소스를 통해 api에 접근하게 되는거죠

여기서는 create Resource를 택해줄께요.

3. 리소스 만들기 - 리소스 이름 정하기

리소스 이름(resource name)은 user로 하겠습니다. 이제 url에 user가 추가되었네요.

4. post 메소드 만들기

리소스를 만들었으면(url을 정했으면)

이제 메소드를 만들 겁니다. 메소드는 get, post, put, delete 등이 있는데 모두 rest 방식에서 쓰이는 것들입니다.

user를 클릭하고 create method를 눌러주세요.

action을 고를 수 있는데 그 중에서 POST를 선택해줍니다.

그리곤 어떤 람다함수와 연결할지를 정해주면 됩니다.

람다와 API 게이트웨이의 연결이 되었습니다.

연결을 했다고 끝이 아니에요. Deploy를 해야 외부에서 람다를 사용할 수 있습니다.

저도 디플로이 과정을 깜빡해서 엄청 삽질을 했었죠.

6. API Deploy하기

Actions탭에서 Deploy API를 골라주세요.

Deploy 설정에서는 이름만 정해주도록 할께요.

디플로이가 끝나면 Stage로 가봅시다.

Invoke URL이 생겼죠?

이 URL에다가 HTTP 메소드(Post)를 써주면 이제 완성입니다!

7. API 테스트 하기

저는 포스트맨을 이용해서 테스트를 해보겠습니다.

Method를 포스트로 바꿔주고 Invoke URL을 통해 요청을 보내 볼께요.

생각했던대로 응답이 오네요.

실행 시간은 350ms 좀 걸리긴 하네요.

마무리

AWS Lambda가 개념 자체는 간단한데

아무래도 콘솔 창에 익숙해지는 좀 걸리더군요.

앞으로는 콘솔 대신에 Serverless라는 프레임워크를 통해서 람다를 다뤄보도록 하겠습니다.

대부분의 개발자분들은 서버리스 프레임워크가 더 편할 거에요.

Flutter - 플러터에서 리액티브 프로그래밍, Stream과 Bloc 패턴 적용하기

에드 신 — Fri, 16 Nov 2018 22:53:28 +0900

Flutter - 플러터에서 리액티브 프로그래밍, Stream과 Bloc 패턴 적용하기

플러터에서 리액티브 프로그래밍 - Stream, Bloc 패턴

리액티브 프로그래밍 정의
스트림 써보기
스트림 플러터에서 써보기
블록 패턴 적용해보기

플러터에서의 리액티브 프로그래밍

요즘 프로그래밍의 대세는 반응형 프로그래밍(Reactive Programming)입니다.

반응형 프로그래밍은 비동기 데이터 처리를 효율적으로 하기 위해 만들어졌습니다.

비동기 처리는 데이터가 언제 도착할지 모르는 http 호출이나, UI 클릭, 데이터 저장, 에러 처리 등을 할 때 쓰입니다.

플러터에서도 반응형 프로그래밍을 할 수 있습니다. 보통 Stream이나 RxDart를 써서 합니다.

Stream, StreamController

스트림은 데이터가 들어오고 나가는 통로에요.

데이터가 변하는 걸 보고 있다가 그에 맞춰 적절한 처리를 하죠. 필터링(where)이나 수정(map), 버퍼링(take) 같은 일을 합니다.

스트림 컨트롤러는 여러 스트림을 관리하는 데 쓰여요.

데이터가 추가되거나 이벤트가 종료되거나 할때 스트림 컨트롤러를 써서 처리해줄 수 있습니다.

스트림 컨트롤러를 쓰는 예제를 보도록 할께요.

스트림 컨트롤러에 데이터가 추가될때마다 출력하도록 했습니다.


void main() {
  StreamController ctrl = StreamController();
  ctrl.stream.listen((data) {
    print(data);
  });
  ctrl.add(10);
  ctrl.add("Good morning");
  ctrl.add({"age": 50, "name": "Youngmi"});
  ctrl.close();
}

실행결과


xxxxxxxxxx
10
Good morning
{age: 50, name: Youngmi}

간단히 데이터를 출력만 해주고 있습니다.

그럼 스트림을 플러터에서 어떻게 쓸까요?

스트림 빌더(StreamBuilder)를 써서 스트림 처리를 해요.

스트림 빌더를 쓰면 setState() 를 쓰지 않고도 UI를 업데이트 할 수 있습니다.

또 항상 스트림의 최신값을 가져오니, 최신값을 확인할 필요가 없습니다.

이제 실제 플러터에서 스트림 빌더를 어떻게 쓰는지 볼까요.

예제 1 - 스트림 빌더로 간단한 UI 만들어보기

스트림 빌더를 써서 UI 2개를 만들어볼께요.

- 1. 버튼을 누를때 텍스트가 바뀌는 UI

- 2. 타이머로 1초마다 알아서 텍스트가 바뀌는 UI

예제1 - 완성 후 모습

예제1 - 코드


xxxxxxxxxx
import 'dart:async';
import 'package:flutter/material.dart';
void main() => runApp(new MyApp());
class MyApp extends StatelessWidget {
  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    return new MaterialApp(
      title: 'Flutter Demo',
      theme: new ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: CounterPage()
    );
  }
}
class CounterPage extends StatefulWidget {
  @override
  _CounterPageState createState() => _CounterPageState();
}
class _CounterPageState extends State<CounterPage> {
  int _counter = 0;
  final StreamController<int> _streamController = StreamController();
  final StreamController<int> _ctrl = StreamController();
  final Stream<int> stream = Stream.periodic(Duration(seconds: 1), (int x) => x); // 1초에 한번씩 업데이트
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('Stream version of the Counter App')),
      body: Center(
        child: Column(
          children: <Widget>[
            Text("Hello"),
            // 1. 버튼 누를 때마다 텍스트 변경  
            StreamBuilder<int>(
                stream: _streamController.stream, // 어떤 스트림을 쓸지 정함
                initialData: _counter, // 초기값 정하기, 스트림에 값이 없을지도 모르니 초기값을 정함.
                builder: (BuildContext context, AsyncSnapshot<int> snapshot) { // UI 만드는 부분.
                  return Text('You hit me ${snapshot.data} times'); 
                },
            ),
            // 2. 1초마다 텍스트 변경
            StreamBuilder<int> (
              stream: stream, //
              builder: (BuildContext context, AsyncSnapshot<int> snapshot) {
                return Text('${snapshot.data} seconds passed'); // 1초에 한번씩 업데이트 된다. 
              },
            )
          ],
        ),
      ),
      floatingActionButton: FloatingActionButton(
        child: const Icon(Icons.add),
        onPressed: () {
          _streamController.sink.add(++_counter);
        },
      ),
    );
  }
}

위 예제에선 스트림을 2개 써보았어요.

하나는 버튼을 누를 때마다 텍스트가 변경될 때 쓰였고,

다른 하나는 1초마다 자동으로 텍스트가 업데이트 되도록 하였습니다.

굳이 setState()로 값이 변경되었다는 걸 알려주지 않아도 알아서 텍스트가 바뀝니다.

UI를 다룰 때나, 네트워크 처리를 할 때 정말 유용하겠죠?

이번엔 서버에서 데이터를 가져와 스트림 빌더로 파싱하는 예제를 만들어볼께요.

https://jsonplaceholder.typicode.com/todos 에 있는 데이터를 쓰도록 하겠습니다.

예제 2 - 스트림 빌더로 TodoList만들기

이번엔 TodoList를 만들어보겠습니다.

서버에서 데이터를 가져와서 TodoList를 만드는 예제에요.

완성 후 모습

일단 Todo 데이터를 담을 클래스를 만들어 볼께요.

https://jsonplaceholder.typicode.com/todos/1 를

http request 하면 아래처럼 응답이 옵니다.


xxxxxxxxxx
{
    userId: 1,
    id: 1,
    title: "delectus aut autem",
    completed: false
},

4개의 값이 응답 왔네요.

이에 맞게 Todo클래스를 만들어주겠습니다.

json처리를 위한 생성자를 추가적으로 만들었습니다!


xxxxxxxxxx
class Todo {
  int userId;
  int id;
  String title;
  bool completed;
  Todo(this.userId, this.id, this.title, this.completed);
  Todo.fromJson(Map json) // named constructor
    : userId = json['userId'],
      id = json['id'],
      title = json['title'],
      completed = json['completed'];
}

이젠 UI 부분을 작업해볼께요. 버튼을 누르면 json 데이터를 서버에서 가져와 스트림 빌더에서 그려주는 구조입니다.

스트림 빌더는 stream과 builder 부분으로 구성되어 있습니다.

stream은 스트림 빌더에 쓰일 스트림을 정하는 일을 하고

builder에서 스트림 데이터를 받아 UI 를 그리는 일을 합니다.


x
StreamBuilder(
     stream: streamController.stream, // 스트림 빌더에서 쓰일 스트림을 지정
     builder: (BuildContext context, AsyncSnapshot snapshot) {
            if (snapshot.hasData) { // 스냅샷에 데이터가 있는지 확인
                 return Text("data");
            } 
     }     
),

예제2 - TodoList 전체 코드


xxxxxxxxxx
import 'dart:async';
import 'dart:convert';
import 'package:http/http.dart' as http;
import 'package:flutter/material.dart';
class TodoListPage extends StatefulWidget {
  @override
  _TodoListPageState createState() => _TodoListPageState();
}
class _TodoListPageState extends State<TodoListPage> {
  StreamController<List<Todo>> streamController = StreamController(); // 데이터를 받아들이는 스트림.
  Future<List<Todo>> getTodo() async {
    String url = "https://jsonplaceholder.typicode.com/todos"; // http request를 보낼 url
    http.Client _client = http.Client(); // http 클라이언트 사용
    List<Todo> list = [];
    await _client.get(url) // http 리퀘스트를 보낸다.
    .then((res) => res.body) // http 응답을 받으면, 그 중에서 body만 가져옴
    .then(json.decode) // json을 형태로 파싱하고
    .then((todos) =>
        todos.forEach((todo) => list.add(Todo.fromJson(todo))) // json을 클래스 형태로 바꿔서 리스트에 더해준다.
    );
    return list;
  }
  Widget _buildListTile (AsyncSnapshot snapshot, int index) { // 리스트 뷰에 들어갈 타일(작은 리스트뷰)를 만든다.
    var id = snapshot.data[index].id; 
    var title = snapshot.data[index].title;
    bool completed = snapshot.data[index].completed;
    return ListTile(
      leading: Text("$id"),
      title: Text("$title"),
      subtitle: Text("completed ",
        style: TextStyle(color: completed ? Colors.lightBlue : Colors.red),
      ),
    );
  }
  @override
  Widget build(BuildContext context) {
    return Scaffold(
        appBar: AppBar(title: Text("Todo List")),
        body: Column(
          children: <Widget>[
            Center(
              child: RaisedButton(
                child: Text("Load"),
                color: Colors.lightBlueAccent,
                textColor: Colors.white,
                onPressed: () { // 버튼을 누르면 서버에서 데이터를 가져옴
                    
                  getTodo().then((todos) {
                    streamController.add(todos); // 스트림 컨트롤러에 데이터가 추가된다. 
                  });
                    
                },
              ),
            ),
            Flexible(
              child: StreamBuilder(
                stream: streamController.stream,
                builder: (BuildContext context, AsyncSnapshot snapshot) {
                  if (!snapshot.hasData) { // 스냅샷에 데이터가 없으면 그냥 텍스트를 그린다.
                    return Text("no data");
                  } else { // 스냅샷에 데이터가 있으면, 즉 스트림에 데이터가 추가되면 리스트뷰를 그린다. 
                    return ListView.builder(
                        itemCount: snapshot.data.length, // 스냅샷의 데이터 크기만큼 뷰 크기를 정한다. 
                        itemBuilder: (context, index) => _buildListTile(snapshot, index),
                    );
                  }
                },
              ),
            ),
          ],
        ));
  }
}

이제 실행해볼까요?


x
import 'package:flutter/material.dart';
import 'todolist_page.dart';
void main() => runApp(new MyApp());
class MyApp extends StatelessWidget {
  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    return new MaterialApp(
      title: 'Flutter Demo',
      theme: new ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: TodoListPage(),
    );
  }
}

화면 상단의 Load 버튼을 누르면 json파일을 서버에서 불러와서 보여줍니다.

매끄럽게 처리가 되죠?

스트림을 쓰면 비동기 데이터를 다루는 일이 한결 편해지는 걸 알 수 있습니다.

다만 아쉬운 점은 스트림과 스트림 빌더가 앱에 추가되다 보니, UI 코드와 섞인단 거죠.

앱의 크기가 커질수록 UI와 데이터 부분이 더 많이 섞이겠죠.

이 문제를 해결하기 위해선 UI와 데이터 처리 부분을 분리해줘야합니다.

Bloc 패턴

Bloc은 비즈니스 로직 컴포턴트(Business Logic Component)의 약자입니다.

Bloc 패턴이 쓰이는 이유?
- UI와 비즈니스 로직을 분리해 개발을 원활히 하고자 함입니다.
- 비즈니스 로직은 데이터베이스 조회나 서버와의 통신 등 데이터를 처리하는 부분을 말합니다.
- UI와 비즈니스 로직을 분리하면, UI를 수정하는 일이 비즈니스 로직에 영향을 미치지 않고 비즈니스 로직의 변경이 UI에 영향을 미치지 않게 됩니다. 테스트가 용이해지고, UI의 변경이 손쉬워집니다. 또한 위젯 build 횟수가 줄어들게 됩니다. 성능면에서도 이점이 있죠.
- 기존의 MVC와 유사합니다.

Bloc 패턴 그림

Bloc 패턴을 앱에다 어떻게 적용할까?

앱에 블락 패턴을 쓰려면 3가지를 해야합니다.

Bloc을 만들고 필요한 로직을 구현한다.

BlocProvider을 만든다. BlocProvider는 로직(Bloc)을 UI에 건내주기만 합니다. Provider(제공자)란 이름에 맞는 역할이지요.

BlocProvider를 통해 건내받은 Bloc을 StreamBuilder와 연결합니다.

실제 Bloc 패턴이 어떻게 쓰이는지 위에서 만든 TodoList 앱을 통해서 설명해볼께요.

예제3. TodoList 만들기 - Bloc패턴 적용

예제3의 소스는 여기 - github 서 확인하실 수 있습니다.

폴더 구조는 다음과 같습니다.

UI, Bloc, Data를 다 분리해주었습니다.

일단 Todo 데이터를 담을 클래스를 만들어줍니다.

여기까지는 이전 예제와 큰 차이는 없습니다.

todo.dart


class Todo {
  int userId;
  int id;
  String title;
  bool completed;
  Todo(this.userId, this.id, this.title, this.completed);
  Todo.fromJson(Map json)
      : userId = json['userId'],
        id = json['id'],
        title = json['title'],
        completed = json['completed'];
}

json 데이터를 가져오는 api를 만들어볼께요.

api.dart


xxxxxxxxxx
import 'dart:async';
import 'dart:convert';
import 'package:http/http.dart' as http;
import '../model/todo.dart';
class API {
  final http.Client _client = http.Client();
  static const String _url = "https://jsonplaceholder.typicode.com/todos";
  Future<List<Todo>> getTodo() async {
    List<Todo> list = [];
    await _client
        .get(Uri.parse(_url))
        .then((res) => res.body)
        .then(json.decode)
        .then((todos) =>
            todos.forEach((todo) => list.add(Todo.fromJson(todo))
            ));
    return list;
  }
}

Bloc 부분이에요.

데이터를 가져오면 그걸 스트림에 더해줍니다.

이전 예제에서는 UI 부분이랑 섞여 있는 걸 분리했습니다.

todo_bloc.dart


xxxxxxxxxx
import 'dart:async';
import '../model/todo.dart';
import '../repository/api.dart';
class TodoBloc {
  final API api;
  StreamController<List<Todo>> ctrl = StreamController();
  Stream<List<Todo>> get results => ctrl.stream; // 바로 스트림에 접근하지 않기 위해 만들었습니다.
  TodoBloc(this.api);
  
  void dispose() { 
    ctrl.close(); // 스트림은 안 쓸 때 닫아줘야합니다. 
  }
  void getTodo() {
    api.getTodo().then((todos) {
      ctrl.add(todos);
    });
  }
}

이제 Provider를 만들어볼께요.

Bloc은 항상 Provider를 통해서 사용합니다.

Provider는 InheritedWidget을 상속받습니다.

InheritedWidget을 쓰면 자식 위젯에서도 접근할 수 있기에, Bloc을 어디서나 접근할 수 있게 하려고 InheritedWidget을 썼습니다.

TodoProvider.dart


xxxxxxxxxx
import 'package:flutter/material.dart';
import 'todo_bloc.dart';
import '../repository/api.dart';
class TodoProvider extends InheritedWidget { // 자식 위젯에서 접근하기 위함
  final TodoBloc todoBloc;
  @override
  bool updateShouldNotify(InheritedWidget oldWidget) => true;
  static TodoBloc of(BuildContext context) =>
      (context.inheritFromWidgetOfExactType(TodoProvider) as TodoProvider).todoBloc; // static으로 해서 1번만 초기화하도록 함. 
  TodoProvider({Key key , TodoBloc todoBloc, Widget child })
    : this.todoBloc = todoBloc ?? TodoBloc(API()),
      super(child: child, key: key);
}

이제 UI 부분을 만들어볼께요.

TodoList를 그리는 화면이고, StreamBuilder를 사용했습니다.

todo_page.dart


import 'package:flutter/material.dart';
import '../bloc/todo_provider.dart';
class TodoPage extends StatefulWidget {
  @override
  _TodoPageState createState() => _TodoPageState();
}
class _TodoPageState extends State<TodoPage> {
  Widget _buildListTile (AsyncSnapshot snapshot, int index) {
    var id = snapshot.data[index].id;
    var title = snapshot.data[index].title;
    bool completed = snapshot.data[index].completed;
    return ListTile(
      leading: Text("$id"),
      title: Text("$title"),
      subtitle: Text("completed ",
        style: TextStyle(color: completed ? Colors.lightBlue : Colors.red),
      ),
    );
  }
  @override
  Widget build(BuildContext context) {
    final todoBloc = TodoProvider.of(context);
    return Scaffold(
      appBar: AppBar(title: Text("Title")),
      body: Center(
        child: Column(
          children: <Widget>[
            Text("Stream Builder with Bloc"),
            RaisedButton(
                color: Colors.lightBlueAccent[200],
                child: Text(
                  "Load Data",
                  style: TextStyle(color: Colors.white),
                ),
                onPressed: () {
                  todoBloc.getTodo();
                }),
            Flexible(
              child: StreamBuilder(
                stream: todoBloc.results,
                builder: (context, snapshot) {
                  if (!snapshot.hasData) {
                    return Text("No data");
                  } else {
                    return ListView.builder(
                      itemCount: snapshot.data.length,
                      itemBuilder: (context, index) => _buildListTile(snapshot, index),
                    );
                  }
                },
              ),
            )
          ],
        ),
      ),
    );
  }
}

마지막 메인 부분입니다.

MaterialApp 을 TodoProvider가 감싸고 있는데,

Bloc을 어디서나 쓸 수 있도록 하기 위함입니다.


import 'package:flutter/material.dart';
import 'ui/todo_page.dart';
import 'bloc/todo_provider.dart';
import 'bloc/todo_bloc.dart';
import 'repository/api.dart';
void main() => runApp(new MyApp());
class MyApp extends StatelessWidget {
  // This widget is the root of your application.
  @override
  Widget build(BuildContext context) {
    return TodoProvider(
      todoBloc: TodoBloc(API()),
      child: MaterialApp(
        debugShowCheckedModeBanner: false,
        title: 'Flutter Demo',
        theme: ThemeData(primarySwatch: Colors.blue),
        home: TodoPage(),
      ),
    );
  }
}

실행을 해볼까요?

실행 결과는 예제2와 동일합니다.

하지만 UI코드를 분리하다보니 코드가 간결해진 걸 알 수 있습니다.

이처럼 Bloc 패턴을 활용하면 보기 좋고, 깔끔한 코드를 만들 수 있습니다.

마무리

리액티브 프로그래밍은 플러터에서도 예외는 아니었습니다.

저도 처음엔 왜 쓰나 했는데 적응 될 수록 코드가 간결해지는 맛이 있더군요.

하지만 처음 플러터를 배울 때부터 Bloc 패턴을 적용하는 건 무리가 있단 생각이 드네요.

처음에는 한 클래스에 넣다가, UI와 로직을 분리하고픈 생각이 들면 그때 Bloc패턴을 적용해봅시다!

참고

무료 국비 학원갈까 말까?

에드 신 — Sun, 11 Nov 2018 13:35:01 +0900

무료 국비 학원갈까 말까?

처음 프로그래밍을 첨 배울 때 흔히 하는 고민이 학원 갈까 말까입니다.

학원은 잘만 활용하면 상당한 도움이 됩니다.

특히 비전공자의 경우 개발 이야기를 할 사람도 적고, 어디서부터 시작할지 모르기 때문에 난감하죠.

학원을 잘 활용하면 도움이 많이 됩니다.

학원에 대해 고민하다 보면 국비 지원 학원을 고려하게 되죠. 아무래도 공짜니깐요.

저는 2013년에 5개월간 국비 지원 학원을 다녔는데 그 때의 경험을 바탕으로

학원 가는 것의 장단점과 국비 지원 학원의 장단점을 적어보겠습니다.

학원 가는 것의 장점

1. 커리큘럼을 따라간다.

학원의 커리큘럼을 따라가다보면 자연스럽게 필요한 스킬들( 프로그래밍 언어, 데이터 베이스, 웹이나 앱 제작 기술) 등을 배울 수 있습니다.

뭘 알아야할지도 모르는 상황에서 누군가 갈 길을 알려주는 건 큰 도움이 되죠. 파이썬을 배워야한다, 자바를 배워야한다는 말을 듣더라도,

그 다음에 뭘 해야할지 모르는 경우가 많거든요. 커리큘럼을 차근차근 따라가다보면 전반적으로 어떤 걸 배워야할지 감이 잡힙니다.

이래서 프레임워크가 필요하구나, 웹 사이트를 이렇게 만드는 구나 하는 걸 알 수 있죠.

2. 물어볼 사람이 있다.

막히는 부분은 선생님에게 물어볼 수도 있죠. 처음 개발을 배우면 사소한 데에서 에러가 생기기 마련입니다.

세미콜론을 빼먹거나 함수를 잘못 쓴다거나 하는 것에서부터 sdk 버전이나 api 키를 잘못 가져온다든지 하는 식의 설정문제까지 단순한 곳에서 실수를 저지릅니다.

이때 잘하는 사람이 옆에서 봐주면 문제를 금방 해결할 수 있죠.

또 좋은 선생님을 만나면 롤모델이 되기도 합니다. 저는 다행히도 선생님은 정말 훌륭하신 분이었습니다.

나이가 55세가 넘으셨는데, 항상 먼저 배우고 알려주는 자세를 가지셨죠. 그 나이에도 배움을 멈추지 않았습니다.

코볼, 포트란 시절에 개발을 시작했는데 안드로이드, 스프링 등을 남들보다 빨리 배우고 가르치셨죠.

모르는 부분은 직접 실험해보고 가르치는 스타일이셨습니다.

학원 학생들에게 나중에 리눅스, 알고리즘 등을 추가로 공부하고 디자인 패턴 등도 알아야한다는 말을 계속 하셨습니다.

본보기가 되는 참 선생님이었습니다.

보통 학원에는 30대 학생들도 많은데 50살 넘게 열심히 가르치고 배우는 분이 선생님이니 학생들이 핑계를 댈 수 없었죠.

반면 안 좋은 선생님도 정말 많습니다. 적당히 시간만 때우는 경우도 많죠.

3. 같이 공부할 수 있다.

혼자 개발을 배우면 개발 이야기 통하는 사람도 없고 갑갑할 때가 많죠.

특히 비전공자의 경우 혼자만의 싸움이 되기 쉬운데 학원을 가게 되면 같이 개발 이야기도 나누고, 스터디할 사람이 생겨서 좋습니다.

아무래도 불안한 심정을 나누기에 좋고, 성실한 사람끼리 만나면 서로 발전할 수 있습니다.

4.강제로 앉아서 공부를 한다.

평소 오래 앉아서 공부하는 습관이 든 사람이면 상관없습니다.

보통은 그렇지 못하죠.

학원에서 공부를 하면 짧게는 하루에 4시간에서 길게는 10시간, 12시간 공부를 하게 됩니다.

처음 개발 배울 때는 오래 앉아서 공부하는 게 정말 정말 중요합니다.

빨리 배우는 사람도 있지만 보통은 임계점이 있어서, 일정 시간 이상 배워야 코딩을 알게 됩니다.

임계점을 빨리 넘기려면 매일매일 공부하는 것만큼 좋은 게 없죠.

학원 다니면 코딩하는 습관을 키울 수 있습니다.

학원 가는 것의 단점

1.학원별 차이가 크다.

학원에 따라서 수업 환경이 천차만별입니다.

직접 들어보기 전에는 알기가 어렵죠.

비싼 학원이 좋은 학원은 아닙니다.

경력이 좋거나 실력이 뛰어나다고 해서 잘 가르친다는 보장이 없구요.

요즘은 마케팅에 공을 들이는 학원이 많아서 실제 누가 잘 가르치는지 알기 어렵습니다.

과도하게 비용을 요구하는 곳도 많죠.

아이러니 하지만 좋은 학원을 파악하려면 어느정도는 개발을 알아야지 누가 과장광고를 하는지 알 수 있죠.

2.학원에서 안 배운 건 모른다.

학원은 빠르게 웹,앱을 만드는 법을 배우도록 커리큘럼을 짭니다.

필요하지 않다고 생각되는 언어의 세부사항이나 프레임워크의 깊은 이해 등은 무시하기 쉽죠.

또 학원의 교육 과정은 실제 개발 상황과는 다르기 때문에 문제가 생깁니다.

모든 게 잘 갖춰진 동물원과 아프리카 야생을 생각해보세요.

동물원에서는 급작스런 날씨의 변화나 천적의 습격, 먹이가 떨어져서 굶어죽는 상황 등이 나오지 않습니다.

완벽히 통제된 상황이죠.

반면 야생에서는 언제 잡아 먹힐지 모르고, 갑자기 가뭄이 들어서 마실 물이 없어져도 이상하지 않습니다.

회사의 업무는 야생인데 학원은 동물원이죠. 언제 에러가 터지거나 다른 부서의 요청이 들어올지 몰라요.

학원만 다니면 실제 쓰이는 서비스에 필요한 기능을 많이 못 배울 수 있습니다.

선생님이 잘 가공된 정보만 받아 먹다보면

혼자 문제 해결하는 능력이 많이 떨어질 수 있어요.

커리 큘럼에 없었던 에러를 접하면 해결을 못할 수 있죠.

저도 다른 학원 출신 개발자랑 일해봤는데 배운 것만 잘 쓰시더라구요 ㅠ

학원에서 배우는 것 뿐만 아니라 공모전을 하거나, 개인 프로젝트를 하거나, 앱 출시 등을 하면은

이 문제를 좀 줄일 수 있지만 그러기가 쉽지는 않죠.

국비 학원의 장점

장점은 무료라는 거죠. 무료다보니 효율이 좋지 않습니다.

다만 유료학원 가보기 전에 체험삼아 가보기에는 정말 좋습니다.

사실 비싼 학원이라고 다 잘 가르치는 건 아니거든요.

패스트 캠퍼스, 러닝 스푼즈, 비트 컴퓨터 학원, 스터디 파이 등 코딩 배울 곳은 정말 많습니다.

문제는 어디가 잘 가르치고 못 가르치는지 초보자 입장에선 알 수가 없죠.

국비 학원을 한 두 달 다녀보면 어디가 진짜 잘 가르치는지 볼 수 있는 안목이 생깁니다.

청담동 레스토랑도 가보고, 맘스 터치도 가봐야 어디가 음식을 잘하는지 알 수 있듯이

학원도 겪어봐야 어디가 좋은지 알 수 있습니다.

국비 학원의 단점

자신이 지불한 만큼, 투자를 하는 게 사람심리입니다. 시간이든 금전이든 감정적 투자든 많이 투자할 수록 값어치를 높게 봅니다.

짝사랑을 오래 할 수록 쉽게 떨치지 못하고, 값이 떨어진 주식을 오래 갖고 있을수록 팔지를 못하죠.

국비 학원의 대부분의 문제점은 무료라는 데서 발생합니다.

무언가를 얻기 위해 투자를 안 했으니, 교육 수준이나 환경이 좋지 못합니다.

1.무료라 수강생 수준이 떨어진다.

아무래도 자기 돈을 내고 온 곳이 아니다 보니 열심히 하는 사람이 적습니다. 조금 하다가 어려우면은 포기하는 사람도 많구요.

제대로 도전해 보지도 않고, 1~2시간정도 하다가 어렵다고 불만을 토로하는 사람이 많습니다. 이런 사람이 많으면 반 수업 분위기가 처질수 밖에 없죠.

어떤 수강생들은 모 대학 교수의 소개로 5명 정도 함께 들어왔는데, 뒤에서 롤만 엄청나게 하더군요. 자바는 수업에서 들어서 이미 잘 안다는 이유였습니다.

또 수업은 안 듣고 웹서핑만 열심히 하는 분도 있었습니다. 보통 국비 학원 가면 20~30명정도 있는데, 3~5명정도만 열심히 합니다.

나머지는 적당히 시간만 보내다가 가는 경우가 많아요.

결국 선생님도 처음 3개월은 열정적이셨는데 뒤의 2개월은 하루 4시간정도만 강의하시고 4시간은 숙제 + 자습 시켰습니다.

코딩 과제 시키면 하는 사람이 적었거든요 ㅠ

모두 열심히 안 하는 환경에서는 혼자 주말에도 공부하고, 수업에도 안 배우는 부분을 찾아보는 사람은 이상해 보일 수 있습니다.

2.선생님에 따라 차이가 크다.

저는 운이 좋게도 좋은 선생님을 만났는데, 그 분은 원래 강남에서 강의를 하다가 그때만 종로로 강의를 하러 오신 거였습니다.

보통은 안 그렇더군요. 2018년에도 자바 6까지만 가르친다는 이야기를 스터디 나갔다가 듣게 되었죠. 충격이었습니다.

학생들을 무시하는 경우도 종종 있구요.

아무래도 국비 학원은 무료다 보니, 좋은 선생님 찾기가 힘들어요. 물론 있긴 합니다만 운이 좋아야해요.

3.낡은 커리큘럼

좋은 선생님들이 적다보니 커리큘럼도 오래된 경우가 많습니다.

옛 기술을 그대로 가르치는 경우가 많구요.

웹도 엄청나게 많이 바뀌었는데 제가 5년전에 배웠던 jsp를 아직도 학원에서 가르치더군요 ㅠㅠ

IT쪽은 필요한 지식이 빠르게 바뀌는 만큼, 교육 과정도 업데이트를 자주 해야하는데 국비 학원은 그렇지 못합니다.

마무리

저도 국비학원을 다녀 보긴 했지만 초반 3개월을 지나니 크게 배우는 게 없더군요.

프로그래밍을 꼭 배우고 싶은데 돈이 부족하거나, 습관이 안 잡혀 있다면 권합니다.

1, 2달정도 체험해 보다 좋은 교육 과정 들으러 가는 것도 좋습니다.

하지만 가능하면 유료 동영상 강의나, 유료 학원을 듣기를 권합니다.

5만원 아끼려다 개발 자체를 싫어하게 될 수도 있거든요.

단기적으로는 돈을 아끼는 게 좋지만 인생 전체로 보면 큰 손해입니다.

이 글을 참고해 꼭 현명한 선택을 하시기를 바랍니다.

플러터를 빠르게 배우기 좋은 4개의 사이트

에드 신 — Wed, 7 Nov 2018 13:55:42 +0900

플러터를 빠르게 배우기 좋은 4개의 사이트

플러터를 빠르게 배우려면

어떻게 UI를 코드로 만드는지 알아야합니다.

다트를 공부하고 플러터를 배우는 것도 좋지만

플러터를 갖고 위젯을 조금씩 수정하고, 핫리로딩해보다가

모르는 게 나올 면 그때 다트를 찾아보는 게 효율적입니다.

제가 추천하는 학습 순서는 다음과 같습니다.

일단 위젯과 레이아웃의 사용법에 익숙해지고,

그 다음에 구글이 제공한 풍부한 예제를 분석해보고

실제 앱을 만들어보는 겁니다.


추천 사이트 및 학습 순서
1.코드랩 
2.플러터 레이아웃 튜토리얼 문서 
3.구글 플러터 예제 (갤러리) 분석 
4.플러터 행성 만들기 튜토리얼 
5.실제 앱 제작

1. 코드랩- 첫 플러터 앱 만들기 1, 2

링크1

링크2

구글 코드랩은 정말 설명이 깔끔한 편이고, 플러터 튜토리얼도 잘 되어 있습니다.
배울 수 있는 것 : 첫 플러터앱 만들기, 위젯 개념 잡기, 리스트뷰 만들어보기, 버튼 클릭(Interactivity), 다른 페이지로 넘어가기 (Routing)

2. 플러터 레이아웃 튜토리얼 문서

링크

플러터도 위젯과 레이아웃의 종류가 다양한데요. 그 차이를 알아야 플러터를 자연스럽게 쓸 수 있죠. 이 문서를 보면 Row, Column, Expanded의 차이부터 시작해, 각종 레이아웃들(GridView, ListView, Stack )이 다 나와 있습니다. 무엇보다 예제 코드가 짧아서 바로 실행해 보기 좋죠.
배울 수 있는 것 : 레이아웃에 대한 깊은 이해

3. 구글 예제 분석

링크

이런 게 있었나 싶은 위젯이나 기능들이 정말 많습니다. 꼭 폰에 넣어서 확인하면서 소스 분석해보세요.
배울 수 있는 것 : 쿠퍼티노 디자인, 구글 표준 코드

4. 행성 정보 앱 만들기 (미디엄 글)

링크

5개의 포스트에 걸쳐 플러터의 기본 기능을 알려줍니다.
디자인이 깔끔한데다가 2페이지로 구성된 앱이라 어떻게 페이지를 이동하는지 알 수 있습니다.
배울 수 있는 것 : 이쁘게 레이아웃 잡기, Routing(페이지 이동), 애니메이션, 전반적인 복습

마무리

사실 여기까지 했으면 기본적으로 UI만드는 건 무리가 없습니다.

이제 제대로 앱을 만드려면 아래의 것들을 천천히 찾아보시면 되요.

안드로이드, ios 네이티브 코드 쓰기
웹에서 데이터 받아서 파싱하기
각종 플러그인(로컬 데이터 베이스, 파이어베이스, 지도) 써보기
위젯 깊이 알기 (렌더링 과정, inheritedWidget)

저도 이 글에서 소개한 글을 통해 플러터를 배웠고, 같은 순서로 튜토리얼을 만들어보려고 합니다~!

아, 그리고 전 유데미 플러터 과정은 좀 안 맞더군요. 별로 안 배웠는데 문제를 풀어야되서요.

영상으로 배우실 거면 유튜브 TensorProgramming도 좋습니다.

설명이 깔끔합니다.

세부적인 것도 다 풀어서 이야기해줍니다.

여기는 왜 async를 쓰고, isolate는 왜 쓰고, 왜 모델을 쓰는지 등 차근차근 말해주죠.

이해가 잘 됩니다. 단점은 영어란 거죠.

그래도 무료 영상 중에 이정도 퀄리티인 곳은 없습니다.

그럼 플러터 개발을 즐기실 수 있기를 바라며 글을 마치도록 하겠습니다.