Heart's Develop Inside

티맥스데이 관전(실시간 스트리밍) 소감

Heart — Tue, 07 Jul 2009 23:34:52 +0900

장장 5시간에 걸친 대장정이었다.

아쉽지만, 희망보다 결점이 눈에 띄게 두드러지는게 사실이다.

첫째, PT 에서 준비가 덜 되어 있음이 눈에 띄였다.
개발자가 PT 때 말을 잘 못할 수도 있는 것은 어찌보면 이해가 되는 일이지만, 연습을 충분히 하던지 다른 사람을 섭외를 하던지 어떠한 방법을 써서라도 PT 에서 어눌한 모습 보여서는 안되는 것이었다. 열심히 준비했는데 왜 PT 에서 망치는건지...

둘째, 오전에 스타크래프트 로딩이 2분 걸렸다는 얘기를 듣고 짐작은 했지만... 데모가 너무 부실하다.
1부에 티맥스 윈도우 강연(이라고 할 만큼 지루한 얘기) 은 1시간 넘게 하고 데모 7분...
그나마 동영상 플레이어는 끊기고, 스타크래프트 로딩 늦고 게임 하기 어려워서 리플레이 돌리고... 엉망이었다.
또 티맥스 오피스, 스카우터 강연 1시간 넘게 하고 데모 몇분...(2부 에서 데모를 얼마나 했는지는 잘 모르겠다)
물론 구현이 어떻게 되어 있고 레이어가 어쩌구저쩌구... 많은 사람들에게 중요할 수 있다.
하지만 7월 7일을 기다리고 있던 사람들이 가장 보고 싶었던 게 무엇일까를 생각해보면 어떤게 더 중요한걸까?
이렇게 데모를 짧게 하고 마무리지어버리면 우리로써는 '되는 게 없어서 그나마 되는것들로 데모를 하는구나' 라고 생각할 수 밖에 없다.

셋째, 티맥스 오피스, 스카우터는 각각 오픈오피스와 웹킷 엔진 기반으로 제작되었음을 밝혔다. 일반적인 윈도우즈 어플이라고 예상할 수 있다. 이걸 굳이 XP 에 돌려야 했던 이유는 무엇일까? 자사 어플리케이션도 개발중인 자사 OS 에서 돌리지 않고 XP 에서 시연했다는 것 자체가 이미 신뢰성을 많이 깎아먹는다.

넷째, 행사 진행은 정말 경악이었다.
정말 그 분을 직접적으로 뭐라고 한다는 게 안타깝지만 오늘 축하공연과 추첨 때 MC 보신 분... 글쎄다...
관전하신 분들은 다 아실것으로 생각한다. 특히나 위핏세트를 쪼개는 바람에 위핏만 받은 사람들은... 밀봉판 판매나...

다섯째, 이건 티맥스의 문제는 아니고... 우리들이 바뀌어야 할 부분이랄까...
1부에서 소녀시대 동영상만 틀었는데도 환호의 소리가 나왔는데, 축하공연때 정말 분위기 싸했다. 생동감크루, 바비킴, 부가킹즈때도 그렇고... (윤하때는 동영상이 갑자기 끊어져서 못봤지만 윤하가 호응 얘기를 꺼낸 걸로 알고 있다. 오죽하면...) 오늘 축하공연은 거의 뭐 이분들의 굴욕 시리즈에 넣어도 될 것 같다.

마지막으로, 티맥스는 아직 멀었다는 것을 1부의 PT 에서 느꼈다.

그들은 개발 과정의 어려움을 토로하면서 개발자가 이혼당하고, OS 작업 다시 하라면 다시 하기 싫고, 여자친구와 헤어지고, 동성 친구/이성 친구와 만날 시간도 없고, 못된 남편 그리고 못된 아빠가 되고, 일하다가 병원도 실려가며 맹장염을 30일 후에 확인한 사람도 있다고 했다. 이 모든 것이 한 회사에서 일어난 일이다.

난 개발자로 살고 싶지만 그 전에 인간으로 살고 싶다. 그리고 다른 사람들도 나와 다르지 않을 것이다.
저 고난와 역경의 과정을 열정으로만 이겨냈을 거라 절대 생각하지 않는다. 그들이 말한 5년이라는 개발 기간은 열정으로 견딜 수 있는 기간이 아니다.

애자일 인 여의도 라는 블로그에서 내가 남긴 댓글에 답변을 하셨는데, 그 말씀이 명언이라 이따금씩 생각이 난다.

고객을 행복하게 만드는 빵집! 이라는 이름을 걸고는 정작 점원은 불행하다면, 뭔가 이상하잖아요. 우리 모두 꾸준히 노력해 나갈수밖엔 없겠죠. :)

티맥스는 정말 반성을 좀 했으면 좋겠다. 오늘 얘기 나온것만 그런것도 아니고 소문이 얼마나 안좋은지 티맥스 회사 내에서도 알 것 같은데 아직도 개선이 없다. R&D 도 R&D 이지만 SI 도 마찬가지...

솔직히 마지막 얘기 때문에 이 글을 쓴 것이지만 제목이 일단 소감이니 정리를 하자면...
티맥스 윈도우즈가 앞으로 헤쳐나가야 할 것은 너무도 많다. 설령 모든 것들을 헤쳐나가도 MS 의 소송에 얼마나 대응할 수 있을지 미지수이다. 하지만 오픈소스이던 뭐던 노력한 것에 대한 보상을 얻어나간다면 성공이리라 생각한다.
물론 오늘 티맥스데이는 그야말로 '막장' 이라고 말할 수 있었다. 내용도 행사도 모두 다...
11월에는 철저한 준비로 깔끔한 진행과 많은 것을 보여 줄 수 있는 알찬 PT 가 겸비된 컨퍼런스이길 바란다.

ps. 마지막 얘기... 찔리는 회사들은 다 같이 반성하길...
ps2. 티맥스 OS 와 ReactOS 의 상관관계는 오늘 풀리지 않았다... 이게 중점 화두인데...
ps3. [B급 프로그래머] 티맥스 윈도우 개발 총괄 담당자에게 묻고 싶은 질문 네 가지 의 한 리플을 보면 MS 가 윈도우/오피스 만들 때에도 이혼 별거 심리치료 레파토리가 나왔다는데... MS 가 이랬다는 건 나로써는 정말 충격적이다.
대작이 나오기 위해서는 꼭 사람들의 눈물이 들어가야 하는건가? 그럼 난 대작을 만들지 않을꺼다...

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

한국 SI 에 애자일 방법론을 적용하는 사례가 생겨나고 있네...

Heart — Tue, 16 Jun 2009 21:56:09 +0900

며칠 전에 '201X 년 나의 일상(미래의 하루 묘사)' 라는 글을 올린 적이 있다.
사실 미래를 묘사할 때 나를 중심으로 묘사해야 되는데 뭔가 좀 잘못된 느낌이 들지만... 개발 환경만큼은 그렇게 바뀌었으면 하는 바램이 있었는데, 현실에서 나의 바램과 많이 닮은 프로젝트가 진행되고 있다.

@ 애자일 인 여의도

무려 대한민국 SI 에 애자일 방법론을 적용한 프로젝트이다.
(사... 사실 그 전에도 이런 시도가 있었을지도 모르지만 이렇게 과정이 오픈된 프로젝트는 없었으니...;;)

Continuous Integration 또한 프로젝트에서 시행되고 있다.
CI 점수 라는게 어떤건지는 블로그의 글을 처음부터 차근차근 읽어 봐야겠지만, 흥미와 경쟁심 유발로 CI 사용(즉, 개발 참여)을 가속화시키는 방안도 사용하고 있는 것 같다.
Commit Log 도 강제화하고... 아무튼 읽어보면 좋은 프랙티스가 될 것 같다.

사실 나는 애자일 방법론 자체에 대해 공부를 한 적은 없다.
내가 실제로 관심이 가는 부분은 Continuous Integration 인데(일전에 형상관리 업체에서 일했었기에...) 페어 프로그래밍 같은 경우는 워낙 유명하니까 들어 알고 있다.

내가 놀란 것은, 한국의 개발 문화 또한 변화를 시도하고 있다는 사실이다.

미래의 하루 를 묘사할 때, 무언가 미래 기술이 적용된 거창한 것이 아니라 현재에도 충분히 가능하지만 기술력이 아니라 문화나 분위기 상 어려운 것들이 미래에는 문화가 바뀌지 않을까 생각하고 작성했다.
저 바다 건너 있는 나라들에서는 내가 묘사한 미래의 하루가 지금도 일어나고 있을 수 있다. 충분히 가능한 일이다.
다만, 한국에도 이런 시도가 속속들이 일어나고 있다는 사실 자체가 기분이 좋다.
분명 오픈되지는 않았지만 성공사례들도 쌓여가고 있을 것이다. 그 성공사례들이 널리 퍼져서 한국의 개발 문화의 변화를 몰고 왔으면 좋겠다.

이 분의 개발 블로그 또한 애자일과 버전관리, 이슈 관리 등의 주제로 포스팅을 한다. 좋은 글들이 많다.

ps. 애자일과 내가 추구하는 철학은 추구하는 핀트가 똑같은지는 잘 모르겠다.
미래 묘사에서 내가 말하고자 한 핀트는 '개발자도 야근이 없는 세상' 이다.

ps2. 뭐 그렇다고 1년 내내 야근 안하겠다는 건 아니다... 정 필요한 상황이면 해야지... (면책용)

ps3. 음냐... 기술등급 초급이 개발하는 것보다 이런데에 관심을 가지면 막장인가요(...)

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

다시 한 번 헌 책 정리합니다

Heart — Sun, 14 Jun 2009 00:12:01 +0900

책이 쌓여서 정리를 하려고 하는데, 그냥 폐지로 재활용하기엔 조금 아까워서 먼저 정리해보려 합니다.
가격은 강컴과 알라딘 두 서점 중에 가격이 저렴한 사이트를 기준으로 하였습니다.

일단 인증에 대해서는 걱정하시지 않으셔도 됩니다.
도메인을 3년 넘게 써 왔고, 이전에도 이 방식대로 책 판매를 한 적이 있구요 :)

인증 수단이 확실하기 때문에 선입금을 기준으로 합니다.

배송은 편의점택배를 생각하고 있습니다. 저번에 의류는 2500원인가 나왔던 것 같은데 책이라서 확실하지가 않네요.
5000원 잡고 있습니다. (더 적을 것으로 생각되시면 착불 요청하셔도 됩니다.)

책 상태 사진 요청하셔도 되구요, 대신 되도록이면 반품 없이 깔끔하게 거래되었으면 좋겠습니다.
많은 관심 부탁드리고 질문, 가격에 대한 태클 혹은 판매 요청은 덧글로 남겨주세요. 꾸벅(__)

* 따로 표기되지 않은 모든 책에 저의 책도장이 날인되어 있습니다.(크진 않습니다) 이 점 양해부탁드립니다.

배송료만으로 보내드릴 서적들부터 나열합니다

1. 자바 언어로 배우는 디자인 패턴 입문(개정 이전판) - 판매완료
한번 쭉 표시를 하면서 읽어서 사용흔적이 많습니다.
내용이 쉽게 되어 있어 어려운 디자인패턴 서적을 보시기 전에 한번 쭉 훓어보시고자 하는 분들께 추천합니다.

2. Oracle - JDBC & JSP Programming
학원에서 진도로 나간 부분에 대해서는 사용흔적이 좀 있습니다. (JSP 부분)

3. C로 배우는 알고리즘 - 판매완료
줄긋기 등의 사용흔적이 좀 있습니다.
책 외향도 깔끔하지는 않습니다만, 내부는 멀쩡해서 책을 보시는 데에 대한 불편함은 크지 않을 것으로 생각합니다.

4.프로그래머를 위한 EJB - 예약중
학원 수업교재로 사용, 전체에 줄긋기 및 필기하였습니다.

5. 자바 개발자를 위한 XML 프로그래밍 - 예약중
일부 부분에 줄긋기와 필기 등의 사용 흔적이 남았습니다.

아래 서적부터는 배송료 포함 서적 값이 각각 명시되어 있습니다.

1. The C Programming Language 2nd Edition
앞부분에 약간 연필 필기 후 지운 흔적이 남았습니다.

배송비 포함 8000원

2. 열혈강의 Python - 개정 ver.2 - 판매완료
강의 쿠폰은 이미 써 버려서 없네요.
책에 흔적은 전혀 없습니다.

배송비 포함 12000원

3. Windows 시스템 실행파일의 구조와 원리 - 판매완료
책에 흔적은 전혀 없습니다.
이 책은 책도장도 날인되어 있지 않습니다.

배송비 포함 10000원

4. Windows API 정복(구판)
4권으로 분권해서 스프링제본 했는데, 1권(1~11장) 까지는 줄긋기와 형광펜으로 사용흔적이 좀 많습니다.
2, 3, 4권에는 사용흔적이 없습니다.1, 2권은 책이 좀 휘어졌습니다.

배송비 포함 10000원

5. 전병선의 Component Development with Visual C++ & ATL(2004년 판) - 예약중
사용흔적 없고, 책도장 날인되어 있지 않습니다.

배송비 포함 10000원

6. Head First EJB - 판매완료
줄긋기 및 풀기 Chap2까지 되어 있습니다.(전체가 Chap 12, Chap 2까지가 입문내용)
책도장 날인되어 있지 않습니다.

배송비 포함 10,000원

7. Mastering Windows Server 2003 - 삼각형프레스
상태 깔끔함(한두번 보았음), 줄긋기 없음
책도장 날인되어 있지 않습니다.

배송비 포함 8,000원

ps. 1차 수정합니다(가격하락 & 자바 개발자를 위한 XML 프로그래밍 무료로 이동)

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

201X 년 나의 일상(미래의 하루 묘사)

Heart — Tue, 09 Jun 2009 01:43:38 +0900

강연의 과제인데... 미래를 상상하다 보니 너무도 바라던 미래가 묘사가 되어서 블로그에도 한 번 남겨 본다.
뭐... 이 미래가 나에게 다가올 것인가는 내가 하기 나름일 것이고(현시창이기 때문에 정말 많이 노력해야 되지 않을까 싶다...ㅠㅠ) 차후 한국 IT 에 변화가, 아니면 해외에서라도 변화가 나타나야 할 것이다.

아직은 해외 쪽이 이 미래에 더 근접하다. 그 이유는 미래 묘사의 대부분의 내용이 '뉴욕의 프로그래머' 와 '실용주의 프로그래머', '조엘 온 소프트웨어' 등에서 접한 사실에 기초하기 때문이다. 그런 면에서 참 아쉽다. 한국 IT 도 미래에는 이런 모습을 꼭 갖추기를 소망해 본다.

오늘은 201X년 어느 봄날이다.
나는 한 S/W 회사에서 프로그래머로 일하고 있다.

이번 주는 프로그램 릴리즈를 하는 주간이다.
상당히 중요한 주간이다. 사실 다른 회사 같으면 릴리즈날 앞뒤로 며칠이 될 지 모르는 철야작업에 돌입할 것이다.

하지만 내가 속한 팀은 일정이 아주 상세하게, 그리고 넉넉하게 잡혀 있고 기능 개선 요청 등이 발생해도 릴리즈에 포함할 것인지를 릴리즈 날짜와 견주어서 냉철하게 평가하기 때문에 필요한 기능은 기한 전에 모두 구현된다.
기한이 넉넉하다면 “‘일찌감찌 대충 끝내고 농땡이를 피겠다’ 라고 생각하는 팀원이 생길 수도 있지 않느냐” 라고 말할 수 있지만, 우리는 우리가 만들어낸 솔루션에 대해 자부심을 갖고 있기 때문에 - 또한, 팀 내에서 변경 사항에 대한 코드 리뷰를 주기적으로 하기 때문에 - 자발적으로 기능 개선에 엄청난 신경을 쓴다. 다만 인생과 일의 균형을 갖춰야 오래 갈 수 있다는 신념 하에 무리하게 야근까지 해 가면서 기능 개선에 신경을 쓰지는 않는다.
물론 일이 편하던 안편하던 어찌됐던 직장인이다 보니 퇴근 후에도 일 생각을 가끔 하긴 한다...
승진은 해야되니까 말이다... ;)

게다가 코드의 변경사항이 모두 체크되고 검토되기 때문에 버그 발생율이 워낙 낮다. 그러므로 릴리즈 주간이라고 해서 갑자기 바빠지지는 않는다.
그래도 릴리즈 주간이 평상시보다 긴장이 조금이나마 더 되긴 하다.

모든 프로그램은 작던 크던 버그와 함께 S/W 의 인생을 살아간다. 그러므로 이를 얼마나 효율적으로 관리하느냐는 개발팀에게는 엄청나게 중요한 이슈이다.

우리가 개발하는 S/W 에서 발생한 버그는 Q/A 팀을 통해 버그 관리 시스템에 전부 등록되고, 우리는 버그가 발생할 때마다 일정을 재정돈한다. 릴리즈 이전에 해결되지 않는 버그들은 다음 릴리즈로 미루는데, 치명적인 버그의 경우에는 릴리즈 날짜를 미루는 경우도 있다. 작년에는 생각하기도 싫은 버그로 릴리즈 날짜가 미루어지고 우리는 1년에서 손가락에 꼽을 야근을 하기도 했지만 - 그만큼 야근 할 일이 없다 - Q/A 팀과의 커뮤니케이션 방향을 개선하고 테스터의 수를 보충하면서 올해는 치명적인 버그들은 릴리즈 주간 이전에 전부 발견하고 수정했다. 올해는 정말 야근이 없는 해가 될 지도 모르겠다.
사실 프로그래머라는 직업을 가진 사람의 삶이라고는 생각하기 어려운 일이지만 - 그리고 나도 그런줄만 알았지만 - 우리 팀에게는 현실의 삶이 되었다.

출근을 하고 먼저 빌드 서버의 메시지를 확인한다. 릴리즈 주간이니 기능 개선 급의 코드 변경이 일어나지는 않았겠지만 - 간혹 중요한 주간에 무모한 짓을 하는 팀원이 있다... :) - 혹시나 하는 마음이기도 하고, 매일 출퇴근시에 확인하는 일상적인 일이기도 하다.

일단, 별 일 없는 것 같다. 버그 관리 시스템에 남겨진 이슈를 확인해 보았지만 특별한 이슈는 없다. 그리고, 앞에서 얘기했듯이 릴리즈 주간에는 치명적인 버그가 아니라면 코드를 건들지 않는 것이 좋다. 오늘은 일단 개발에 관한 건은 없다.

메일을 훑고, RSS 리더로 구독하는 블로그들의 새 글들을 확인한다.
‘근무시간에 블로그 글이나 보고 있다니 근무태만이 아니냐’ 라고 생각할 수 있겠지만, 내가 구독하는 곳들은 대부분이 개발자 블로그, 혹은 커뮤니티이고, 이들을 통해 최신 기술이나 동향을 빠르게 습득할 수 있기 때문에 근무와 엄청난 연관이 있다. 물론, 일상적인 블로그나 유머, 좋은 글들을 올려 주는 블로그들도 껴있음을 부정하지는 않는다. :)

새 글들을 대충 훑고 Delicious와 Twitter 등을 통해 정리한 다음 개발자 커뮤니티를 놀러 갔다.
여기 또한 최신 기술이나 동향을 빠르게 습득할 수 있다.

나도 이제 개발자로써 유명세가 약간은 붙어서 지인들이 상당히 많고 나를 좋아해주는 개발자들도 많다. 고마운 일이다. 뭐... 그 덕분인지 커뮤니티에 가면 최신 기술 습득보다는 친목, 일상 적인 얘기를 많이 하게 되기도 한다. 조절이 좀 필요하긴 한 것 같다. :)

아참, 이럴 때가 아니다. 나는 우리 팀의 S/W 개발을 주도하고 있지만 동시에 사내 벤처 아이템 개발 또한 참여하고 있다. 사내 벤처 아이템 또한 우리 팀의 S/W 처럼 철저하게 소스와 버그가 관리된다. 다만 벤처이기 때문에 아이디어를 더 중시하고, 우리는 위키와 포럼 게시판, 마인드맵을 통해 서로의 아이디어를 공유하고 주기적인 회의를 통해 이를 구현에 옮기는 일정을 잡는다.

이번 주가 릴리즈 주간이긴 하지만 별 일이 없으니 지금 아이템 개발의 진도를 빼는 데 적기이다. IDE 를 열고 코딩을 어느 정도 마치니 시간이 꽤 되었다.

메일을 다시 확인하니 내가 커미터로 속한 오픈 소스 프로젝트에서 회의 관련 메일이 날아왔다.

세계 각국의 커미터들(물론 레벨이 있어 일정 이상 레벨의 커미터들만 회의에 참석한다)이 회의에 참석해야 하므로 회의는 보통 화상회의가 된다. 다행히도 회의 시간은 퇴근 이후이다. 게다가 나의 사랑스러운 아내와 아들과 놀아주기로 한 약속은 지킬 수 있는 시간대이니 가족들에게도 미안해하지 않아도 될 것 같다.

요즘 아들이 걷기 시작했는데 얼마나 귀여운지 모른다.
네살배기 이상의 남자애는 짐덩이라는데 아직 그 나이가 되지 않아서 그런가 귀엽기만 하다.
나도 네 살때 사고 많이 치고 다녔던가... 모르겠다 기억나지 않는다... :)

어느새 퇴근할 시간이다.
집에 도착하여 가족들과 맛있는 저녁을 먹고 오픈 소스 프로젝트 회의를 진행하였다.
다행히도 큰 이슈는 없다. 릴리즈 주간에 다른 프로젝트가 바쁘면 골치가 아프기 때문에 사실 걱정이 되었는데, 무난하게 넘어갔다.

우리 아들이 빨빨거리면서 걷는 것을 캠으로... 또 디카로 찍으면서 오늘의 행복한 기억을 컴퓨터에 정리한다. 얼마나 귀여운지 플리커와 내 블로그에서도 인기가 많다. - 물론 내 블로그는 개발자 블로그로도 어느 정도 유명하다. 기술 관련 노하우 라던지 고충상담 글 들을 자주 올리기 때문이다.

적어도 지금의 나에겐 회사의 상하관계에 따른 스트레스, 프로젝트 관리 시스템의 부재로 인한 일정 지연 및 야근, 인생과 일의 괴리란 남의 이야기일 뿐이다.

회사 다니는 것이 재밌을 정도이다. 이런 일은 (솔직히 말하자면) 전에는 겪지 못했던 것들이다.

난 지금의 삶이 너무도 행복하다. 난 ‘행복한 프로그래머’ 이다.

아무리 미래가 좋아져도 위의 미래는 이루어지지 않을 수도 있지만... 뭐 어떤가? 이상인데...
이상에 조금이라도 더 가까워지는 미래가 되었으면 하는 바램이다.

ps. 부득이하게 비공개 과제를 밝힌 꼴이 되어버렸네요...
보보님 불편하시다면 댓글 남겨주세요. 원하시는 방향으로 수정할께요~

ps2. 사실 더 장황하고 세세하게 묘사할까 했는데 어차피 세세한 부분은 마음속에 있으니 상관없는 것 같다.

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

버블 정렬 개선 - 이미 정렬되어 있는 경우 최소한의 비교로 정렬을 종료하기

Heart — Mon, 11 May 2009 20:19:38 +0900

마찬가지로 현재 보고 있는 책의 연습문제이다.

이미 정렬되어 있는 경우, 필요 없는 비교를 수행하지 않고 함수를 종료할 수 있도록 BubbleSort 를 수정하세요

버블 소트의 동작을 생각해 보면, 인근의 값을 비교하여 교환을 수행한다.

이미 정렬되어 있는 경우를 생각해보자.
a, b, c, d, e, f 가 정렬되어 있다면, a < b < c < d < e < f 이다.
다시 말하면... 첫 스텝 때 교환이 수행되지 않는다면, 배열은 이미 정렬되어 있다는 것이다.

몇 번째 스텝이라 해도 마찬가지이다.
스텝을 하나 적용했을 때, 나머지 부분이 이미 정렬되어 있다면 다음 스텝에서는 교환이 수행되지 않을 것이다.
그렇다면 차후 스텝은 의미가 없다.

이를 적용한 소스는 다음과 같다.

def print_array(array)
puts array.map {|x| x.to_s + " "}.to_s
end

def bubble_sort(array)
array_len = array.length

(0..array_len - 1).each do |i|
    flag = nil

    (0..array_len - (i+2)).each do |j|
      puts "."

      if array[j] > array[j+1]
        array[j], array[j+1] = array[j+1], array[j]
        flag = true
      end
    end

    return if !flag
end
end

array_sorted = [1,2,3,4,5,6]

bubble_sort(array_sorted)
print_array(array_sorted)

위와 같이 완전히 정렬된 6개의 원소를 가진 배열을 정렬하면 '.' 은 총 5번만 출력된다.
array 를 [1,2,6,3,4,5] 로 변경하면 '.' 은 총 9번(5번 + 4번) 출력되고 정렬이 완료된다.

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

퀵 정렬 개선 - median 을 이용한 pivot 결정하기

Heart — Mon, 11 May 2009 19:48:23 +0900

@ 퀵 정렬 - in Ruby

현재 보고 있는 책에 연습문제로 나와서 한 번 풀어 보았다.

퀵 정렬에서 partition() 이 pivot 을 결정할 때 최악의 경우를 피하도록 개선하시오

참고로 퀵 정렬에서 최악의 경우는 partition() 을 호출할 때 피벗을 중심으로 계속 1:n-1 개의 집합으로 나뉘는 것이다.

전체의 median 을 구해서 pivot 을 구하면 되겠네... 라고 생각했는데 정렬이 선행되기 때문에 불가능하고...
최악의 경우만 피하면 되므로 맨 앞의 값 중 3개만 뽑아서 median 을 pivot 으로 잡는다.
그러면 최악의 경우까지는 피할 수 있다.(그래도 간신히 최악을 피할 수도 있음...;;)

def get_sample_median_index(array, begin_idx, end_idx)
# 3개가 되지 않으면(2개, 1개) 맨 처음 인덱스를 리턴
return begin_idx if end_idx - begin_idx < 2

idx_arr = []
(0..2).each { |i| idx_arr[i] = begin_idx + i }

value_arr = []
(0..2).each { |i| value_arr[i] = array[begin_idx + i] }

# 셀렉션 소트로 값을 기준으로 정렬하되 인덱스 정보도 같이 정렬해야 한다
(0..1).each do |i|
    min_idx = i

    (i+1..2).each do |j|
      min_idx = j if value_arr[min_idx] > value_arr[j]
    end

    if min_idx != i
      value_arr[i], value_arr[min_idx] = value_arr[min_idx], value_arr[i]
      idx_arr[i], idx_arr[min_idx] = idx_arr[min_idx], idx_arr[i]
    end

end

return idx_arr[1]
end

위의 메소드를 pivot 결정할 때 사용한다.

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

분리 집합

Heart — Mon, 11 May 2009 15:00:40 +0900

분리 집합이란, 교집합을 갖지 않는 집합들이다. 당연하게도 분리 집합은 2 개 이상의 집합을 일컫는다.

분리 집합은 집합들 간의 교집합을 허락하지 않기 때문에 서로 구분되어야 하는 데이터 집합을 다룰 때 유용하다.

분리 집합은 트리 형태를 따르지만, 각 노드가 자식들을 링크하지 않고 부모를 링크한다는 점이 특이한 점이다.
또한 루트 노드가 집합 그 자체이며 집합에 이름을 부여하고자 한다면 추가 데이터를 운용해야 한다.

분리 집합의 연산은 '합집합' 과 '집합 탐색' 이 있다.

합집합 연산은 간단하게 구현된다.
A 와 B 집합의 합집합을 만들 때는 B의 루트 노드의 부모 노드를 A 의 루트 노드로 지정하면 된다.
합집합을 만들면 합쳐진 집합만 남는다.(기존의 집합이 따로 보존되지는 않음)

집합 탐색을 주의해야 하는데, 집합 탐색은 집합에서 원소를 찾는 것이 아니라 원소가 속해 있는 집합을 찾는 것이다.
(구조상 순회가 불가능하므로 분리 집합 만으로는 집합에서 원소를 찾을 수 없다.)

원소가 속해 있는 집합을 찾는 것은 간단하다. 루트 노드가 집합 그 자체이므로, 루트 노드를 찾으면 된다.

구현된 소스는 다음과 같다. 코드 하이라이트 된 것은 링크 를 참조한다.

=begin
분리 집합(DisjointSet) 을 구현한다

=end

class DisjointSet
attr_reader :data
attr_accessor :parent

def initialize(data)
    @parent = nil

    @data = data
end

def union_set(set)
    root = find_set

    set.parent = root
end

def find_set
    root = self

    root = root.parent while root.parent

    root
end

end

a = 1;b = 2;c = 3;d = 4
set1 = DisjointSet.new(1)
set2 = DisjointSet.new(2)
set3 = DisjointSet.new(3)
set4 = DisjointSet.new(4)

puts "Set1 == Set2 : #{set1.find_set == set2.find_set}"

set1.union_set(set3)
puts "Set1 == Set3 : #{set1.find_set == set3.find_set}"

set3.union_set(set4)
puts "Set3 == Set4 : #{set3.find_set == set4.find_set}"

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

수식 트리 in Ruby

Heart — Mon, 11 May 2009 13:48:08 +0900

후위 수식을 받아서 수식 트리를 구축하고 계산하는 코드이다.

토큰 파싱을 간단하게 하기 위해 피연산자는 한 자리 수로 제한하였다.

소스 코드는 길어서 접어 두었고, 코드 하이라이트가 적용된 코드는 링크 를 참조한다.

=begin
수식 트리 만들고 계산하기
후위 수식을 받아서 트리를 만들고 계산한다
중위 수식을 후위 수식으로 변경하는 것은 생략

=end

class ExpTreeNode
attr_accessor :data, :left, :right

def initialize(data)
    @data = data
    @left = nil
    @right = nil
end

end

class ExpTree

OPERATOR_LIST = ['+', '-', '*', '/']

def initialize
    @root = nil
end

def load_postfix_expression(exp)
    expression = exp.clone

    @root = build_expression_tree(expression)
end

def calculate
    calculate_recursive(@root)
end

private

def build_expression_tree(exp, parent_node = nil, is_left = nil)
    # 표현식이 끝남
    return nil if 0 >= exp.length

    # 표현식 끝을 토큰으로 가져오고 표현식에서 잘라버림
    data = exp.split(//)[exp.length - 1]
    exp.chop!

    new_node = ExpTreeNode.new(data)

    # 부모 노드가 지정된 경우 새 노드를 부모 노드에 붙임
    if parent_node
        is_left ? parent_node.left = new_node : parent_node.right = new_node
    end

    # 연산자인 경우 피연산자 두 개를 얻음
    if OPERATOR_LIST.include?(data)
      new_node.right = build_expression_tree(exp, new_node, nil)
      new_node.left = build_expression_tree(exp, new_node, true)
    end

    # 새 노드 리턴
    new_node
end

def calculate_recursive( node )

    # 연산자인 경우 피연산자 두 개를 얻어서 계산하고 리턴
    if OPERATOR_LIST.include?(node.data)
      operand1 = calculate_recursive(node.left)
      operand2 = calculate_recursive(node.right)

      case node.data
      when '+'
        result = operand1.to_i + operand2.to_i
      when '-'
        result = operand1.to_i - operand2.to_i
      when '*'
        result = operand1.to_i * operand2.to_i
      when '/'
        result = operand1.to_i / operand2.to_i
      end
    else
      # 피연산자인 경우 자기 자신을 리턴
      result = node.data
    end

    result

end

end

exp_tree = ExpTree.new

exp_tree.load_postfix_expression("12*78-+")
puts exp_tree.calculate

exp_tree.load_postfix_expression("78*58*+2/32--")
puts exp_tree.calculate

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

Backtracking : N-Queen Problem

Heart — Thu, 07 May 2009 11:11:32 +0900

@ N-Queen 문제의 정의

문제야 워낙 유명하니까 위키피디아 링크로 넘기고...

N * N 의 체스판에 Queen 을 N 개 배치한다고 하면 N^2 Combination N 가지의 조합이 나온다.
N이 2,3 일 경우 N-Queen의 해는 없으므로 가장 작은 N은 4인데, N이 4일 때 무려 1820 개의 조합이 나온다.

이 때, 백트래킹을 이용하여 해가 될 수 없는 부분해들을 소거하면서 진행하면 조합 수를 엄청나게 줄일 수 있다.

푸는 방법도 백트래킹을 이용하면 어렵지 않으므로 소스를 참조할 것
(링크를 따라가면 코드 하이라이트 된 소스를 볼 수 있음)

=begin
N-Queen Problem

=end

def place_queen(queen_count)
place(0, queen_count, [])
end

def place(row, queen_count, columns)
if row == queen_count
    print_queen_place(queen_count, columns)
    return
end

movable_cols = get_movable_places(row, queen_count, columns)

movable_cols.each do |col|
    columns[row] = col

    place(row + 1, queen_count, columns)
end

end

def get_movable_places(row, queen_count, columns)
places = []

(0...queen_count).each { |i| places[i] = 1 }

(0...row).each do |rowidx|
    prev_place = columns[rowidx]

    places[prev_place] = 0

    oppo_angle_left = prev_place - (row - rowidx).abs
    oppo_angle_right = prev_place + (row - rowidx).abs

    places[oppo_angle_left] = 0 if oppo_angle_left >= 0
    places[oppo_angle_right] = 0 if oppo_angle_right < queen_count
end

movable_cols = []
places.each_index { |i| movable_cols.push i if 1 == places[i] }

movable_cols
end

def print_queen_place(queen_count, columns)
puts "Queen -------------------------------------"

(0...queen_count).each do |i|
    (0...queen_count).each do |j|
      if j == columns[i]
        print 'Q'
      else
        print '.'
      end

    end

    puts
end

end

place_queen(4)

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.

Backtracking : 미로 찾기

Heart — Thu, 07 May 2009 01:24:42 +0900

미로 찾기 알고리즘

1. Move
* 현재 위치가 유효한지 체크
   > 유효하지 않다면, 이전 위치로 돌아간다
* 현재 위치가 도착점인지 체크
   > 도착점이라면, 현재까지의 경로가 미로찾기의 해
* 현재 위치를 경로로 표시함
* 동서남북으로 이동해 봄(순서는 관계없음 - 다만 맵에 따라 순서가 해 찾는 속도에 영향을 끼칠 수 있음)
   * 동쪽으로 가 봄(Move 재귀)
   * 동쪽으로 가는 데 실패했다면, 서쪽으로 가 봄(Move 재귀)
   * 서쪽으로 가는 것도 실패했다면, 남쪽으로 가 봄(Move 재귀)
   * 남쪽으로 가는 것도 실패했다면, 북쪽으로 가 봄(Move 재귀)
   * 네 방향 모두 실패했다면, 현재 위치를 경로에서 제거하고(길로 변경하고) 이전 위치로 돌아간다

2. 현재 위치 유효성 체크
* 현재 위치가 미로 내인지, 벽이 아닌지, 갔던 길이 아닌지 체크
> Yes 라면 유효함 / No 라면 유효하지 않음

미로의 시작점 부터 Move 를 시작하면, 미로찾기의 해를 얻을 수 있다.
시작점에서 출발 후 시작점으로 다시 돌아왔고 네 방향 모두 가는 것이 실패했다면 미로찾기의 해가 없는 것이다.

갈 수 있는 길이 있으면 무작정 계속 이동해보기 때문에 그래프의 깊이 탐색과 유사한 부분이 있다.

소스는 아래와 같다. 길기 때문에 접어 두었으며, 링크를 통해 코드 하이라이트된 소스를 참고할 수 있다.

소스 보기

=begin
Backtracking 을 이용하여 미로 탈출

현실감은 고려하지 않았음
(현실이라면 현재 위치가 아니라 진행 전에 진행 위치에 대해 갈 수 있는지 체크해야 함)

=end

class Location
attr_accessor :row, :col

end

class Maze
attr_accessor :map_matrix, :height, :width

attr_accessor :start

WALL = '#'
ROAD = ' '
WALK = '+'
START = 'S'
GOAL = 'G'

DIRECTION = [:NORTH, :WEST, :EAST, :SOUTH]

def initialize()
    @map_matrix = []

end

def init_map(height, width)
    @height = height
    @width = width

    (0..@height).each do |i|
      @map_matrix[i] = []

      (0..@width).each { |j| @map_matrix[i][j] = ROAD }
    end
end

def print_maze
    puts "------------- Start Printing Maze ------------------"

    (0...@height).each do |i|
      (0...@width).each do |j|
        print @map_matrix[i][j]
      end

      puts
    end

    puts "------------- End of Printing Maze -----------------"
end

def Maze.init_example_maze()
=begin
* 예제 미로 모양
#G#######
#       #
### # ###
### #   #
#   ### #
# ###   #
# #S### #
# #     #
#########
=end

    maze = Maze.new
    maze.init_map(9, 9)

    maze.map_matrix[0] = [WALL, GOAL, WALL, WALL, WALL, WALL, WALL, WALL, WALL]
    maze.map_matrix[1] = [WALL, ROAD, ROAD, ROAD, ROAD, ROAD, ROAD, ROAD, WALL]
    maze.map_matrix[2] = [WALL, WALL, WALL, ROAD, WALL, ROAD, WALL, WALL, WALL]
    maze.map_matrix[3] = [WALL, WALL, WALL, ROAD, WALL, ROAD, ROAD, ROAD, WALL]
    maze.map_matrix[4] = [WALL, ROAD, ROAD, ROAD, WALL, WALL, WALL, ROAD, WALL]
    maze.map_matrix[5] = [WALL, ROAD, WALL, WALL, WALL, ROAD, ROAD, ROAD, WALL]
    maze.map_matrix[6] = [WALL, ROAD, WALL, START, WALL, WALL, WALL, ROAD, WALL]
    maze.map_matrix[7] = [WALL, ROAD, WALL, ROAD, ROAD, ROAD, ROAD, ROAD, WALL]
    maze.map_matrix[8] = [WALL, WALL, WALL, WALL, WALL, WALL, WALL, WALL, WALL]

    maze.start = Location.new
    maze.start.row = 6
    maze.start.col = 3

    maze
end

def Maze.load_maze(file_path)
    maze = Maze.new

    start_loc = Location.new

    maze_width = -1
    maze_height = 0

    File.open(file_path, "r") do |file|
      while line = file.gets

        line.chomp!

        line_len = line.length

        if -1 == maze_width
          maze_width = line_len
        else
          if line_len != maze_width
            puts "Maze data is not square!!!"
            return nil
          end
        end

        maze_height += 1
      end

      file.rewind

      maze.init_map(maze_height, maze_width)

      (0...maze_height).each do |i|
        line = file.gets

        line.chomp!

        line_arr = line.split(//)

        (0...maze_width).each do |j|
          maze.map_matrix[i][j] = line_arr[j]

          start_loc.row, start_loc.col = i, j if Maze::START == maze.map_matrix[i][j]
        end
      end

    end

    maze.start = start_loc
    maze
end

end

class MazeExplorer

def initialize(maze)
    @maze = maze

end

def solve_maze
    if move(@maze.start)
      @maze.map_matrix[@maze.start.row][@maze.start.col] = Maze::START
      @maze.print_maze
    else
      puts("No Way to Exit!!")
    end

end

def move(curr)
    return nil if !check_valid(curr)

    return true if Maze::GOAL == @maze.map_matrix[curr.row][curr.col]

    @maze.map_matrix[curr.row][curr.col] = Maze::WALK

    Maze::DIRECTION.each do |dir|
      new_loc = Location.new

      new_loc.row, new_loc.col = curr.row, curr.col

      case dir
      when :NORTH
        new_loc.row = curr.row - 1
      when :WEST
        new_loc.col = curr.col - 1
      when :EAST
        new_loc.col = curr.col + 1
      when :SOUTH
        new_loc.row = curr.row + 1
      end

      return true if move(new_loc)
    end

    # move to new Direction : ALL nil // do backtracking
    @maze.map_matrix[curr.row][curr.col] = Maze::ROAD

    return nil
end

def check_valid(curr)
    return nil if curr.row < 0 || curr.row >= @maze.height

    return nil if curr.col < 0 || curr.col >= @maze.width

    if Maze::WALL == @maze.map_matrix[curr.row][curr.col] ||
        Maze::WALK == @maze.map_matrix[curr.row][curr.col]
        return nil
    end

    return true
end

end

maze = Maze.init_example_maze
#maze = Maze.load_maze("MazeSample.dat")

person = MazeExplorer.new(maze)
person.solve_maze

크리에이티브 커먼즈 라이선스

이 저작물은 크리에이티브 커먼즈 코리아 저작자표시-비영리-변경금지 2.0 대한민국 라이선스에 따라 이용하실 수 있습니다.