SIRINI`s Blog

진화, 혁신... 그리고 Xpress Engine

시리니 — Thu, 20 Nov 2008 23:27:06 +0900

저는 지금 흥분하고 있습니다.
무척이나 떨리는 이 심장의 고동소리에, 스스로도 놀랄만큼
놀라고 또 놀라는 중입니다.

이 것을 뭐라고 표현해야 할까요?
진화? 변화? 혁신?
가늠할 수 없는 깊이의 잘 정제된 일련의 코드들이
마치 하나의 화음을 이루는 듯한 착각에 빠질 만큼
너무나도 몰라보게 변해버려서, 저는 그만 정신줄을 놓아버렸습니다. ㅠ.ㅠ;;;

(바뀌어진 로고가 보이시죠?)

더 이상 제로보드는 없습니다.
이제는 Xpress Engine 입니다. (어감이 괜찮군요. 엔진... 묵직합니다. ^^)

일전에 제로보드XE 에 관하여 관리자 화면의 불만족에 대해
토로했던 적이 있습니다. 뭐... 미움 받아도 별로 할 말 없지만
솔직히 단순함에 병적인 집착을 보이는 저 같은 사람에겐
영 아니올시다~ 였거든요.

그러나, 바뀌어진 지금의 모습은 매우 마음에 듭니다.

(새로워진 관리자 화면, 개인적인 생각으로는 와이드 스크린을 고려한 배치가 아닌가 싶습니다.)

관리화면의 직관적인 모습은 더 이상 헤맬 필요가 없음을 보여주고 있습니다.
심미안적인 요소도 중요하고 아기자기한 아이콘이나 이쁜 글씨 등도
물론 중요합니다.

허나 관리자 화면은 기능성이 우선되어야 합니다. 특히, 사용자가
편하게 특정 기능들을 제어할 수 있도록 쉬운 절차를 제공해주는 게 더 중요합니다.
기존에 변경되기 전의 관리화면이 가졌던, 내용은 많은데 볼 건 없는 그런 모습에서
완전히 탈바꿈된, 그야말로 깔끔하고 정돈된 화면을 만나 보실 수 있습니다.

이번 XE 1.1.0 에서 추가된 기능중에 제일 눈에 띄는 기능으로는
단연 "플래닛" 기능을 들 수 있습니다.
미투데이나 플레이톡과 유사한, 마이크로블로깅을 위한 기능인데요.
우선 생김새를 한 번 보시죠~.

(시리니넷 서버에 생성한 공개 플래닛입니다. 테스트주소: http://sirini.net/xe/planet)

기능이나 룩앤필을 보았을 때 미투데이의 그 것과 유사한 것을 알 수 있습니다.
제가 가동중인 일명 '묻지마 정보망' 에서 이와 유사한 기능이 준비중이라는 걸 듣고
어떤 모양새로 나올까 내심 기대중이었는데, 정말 기대이상입니다.
GR블로그에 내장한 모노로그 기능을 대폭적으로 손봐서 플래닛처럼 좀 더 유용하게
쓸 수 있도록 해봐야 겠습니다. ^^

(플래닛용 스킨도 때를 봐서 한 번 만들어봐야 겠습니다. 정말 마음에 드는 기능이고,
스킨 만들어 볼 맛도 나겠군요. ^^;; 지금은 침 질질~ 흘리면서 코드 훔쳐보는 중입니다. 하악하악)

이번 XE 1.1.0 업그레이드는 아주 중요한 터닝 포인트로 보입니다.
제로보드라는 이름을 버림으로서, 기존의 패러다임을 종결시키고
Xpress Engine 이라는 이름을 부여함으로서, 새로운 패러다임과 비젼을 제시하고 있습니다.
더 이상 게시판에 머물지 않는 큰 목표점을 엿 본듯한 느낌이 듭니다.

물론 큰 비젼과 목표에 다가가기 위해서는 지금보다 더 많은 분들의 참여가
밑바탕이 되어야 합니다. 세계적으로 이름있는 워드프레스나 무버블타입, 드러팔등의 도구들을 보면
알 수 있듯이 수많은 개발자/사용자들의 자발적인 참여 속에 훌륭한 결과물들이 탄생되고 있습니다.

점점 개발 규모가 커지게 되면 아무리 천재 제로님이라도 24시간이 부족하게 될테고
더구나 그렇게까지 광범위한 코드를 단지 몇 명이서 고품질 수준의 코드로 관리하기란,
한마디로 불가능에 가깝습니다.

점차 뚜렷히 드러나는 XE 의 발전방향과 더불어 아직 속 시원하게 해결되지 않는
문제점 중 하나가 참여자 부족이겠지요. 뭐... 시간이 해결해 주리라 생각됩니다만. (낙천주의 ^^;)

대승적으로 보았을 때 우리나라의 텍스트큐브나 Xpress Engine 이 세계에도 널리 알려지는,
우리나라의 오픈소스 역량을 자랑할만한 수준으로 성장했으면 합니다.
미약하지만 저도 제가 기여할 수 있는 분야를 찾아 기여하려고 준비중이고... 아마 저 말고도
다른 훌륭한 분들께서 이미 직/간접적인 참여와 지원을 준비중이실줄로 압니다.
(우리도 뭉치면 뭔가 해 낼수 있다는 걸 저 콧대높은 친구들에게 보여주자구요~!)

(XE의 개발방향에 대한 이야기는 NHN DeView 2008 에서 제로님과 직접 논의해 보실 수 있습니다.)

XE 프로젝트는 진화하고 있습니다.
그리고 지속적으로 혁신중입니다.
기존의 이름을 버린다는 것은, 처음부터 다시 시작하겠다는 것을 뜻합니다.
인지도 있는 브랜드를 버리고 다시 새로운 이름을 부여한다는 것은
그에 걸맞는 목표가 새롭게 주어졌음을 의미하는 것입니다.

저와 GR시리즈 사용자분들의 혁신과,
Xpress Engine 의 혁신은 방법은 다르지만 목표점은 같습니다.
우리는 서로 경쟁하지만 서로 협력합니다.
웹의 본질, 협력과 상생, 그리고 진화... 그 끝에
지금보다 더 나은 웹이 기다리고 있을 것임을 우리는 이미 알고 있습니다.

진화, 혁신, 그리고 Xpress Engine.
다시 시작되는 뜨거운 도전으로의 길 앞에
역시 뜨거운 박수, 보냅니다!
...

[뻘줌한 알고리즘] 소수점 1000자리 π 구하기

시리니 — Wed, 19 Nov 2008 23:29:50 +0900

일전에 예고해 드렸던 대로, 긴 자리수 나눗셈과
긴 자리수 덧셈, 뺄셈 기능을 활용하는 예제로서
소수점 이하 1000자리까지 정확하게 원주율 π 를 구해보도록 하겠습니다.

(John Machin, 1686 ~ 1751 http://en.wikipedia.org/wiki/John_Machin)

먼저, π 를 구하기 전에 이번에 사용할 수학적 알고리즘이 무엇인지부터
확인해 보도록 할까요? 위에 초상화에 나오는 옆집 중년 아저씨처럼 생기신 분이
일명 마친의 정리로 알려진, 고속 π 계산 공식을 유도하신 분이십니다.

위키피디아에도 잘 정리되 있지만, 그가 발견해낸 공식은
아래 관계식에 모두 나타나 있습니다.

얼마전이였죠.
라이프니츠 수열을 직접 코드로 구현해보는 걸 해보았는데요,
그 것을 연상하신다면 조금 이해가 빨리 되실 듯 합니다.
(자세한 것은 위키피디아를 참조해 보아요~. 수학을 좋아하시는 분 계시면 설명좀... 굽신굽신)

실제로 파이를 구하는 공식은 아래처럼 쓸 수 있습니다.

π = (16/5 - 16/3*5^3 + 16/5*5^5 - 16/7*5^7 + ...) - (4/239 - 4/3*239^3 + 4/5*239^5 - 4/7*239^7 + ...)

물론 양 변을 병합하여서 반복적으로 계산을 해도 되지만,
우리가 목표로 하는 게 소수점 이하 1000자리까지이기 때문에
계산 횟수를 적절하게 제한해 주는 게 필요합니다.

그 제한 범위는, 역시 수학자 여러분들의 노고 덕분에 아래 공식으로
정리가 되었습니다. 1000자리까지 계산하고자 할 경우 계산해야 할 항의 개수는

n = |1000/1.39794| + 1 (여기서 | ? | 은 가우스 기호입니다.)

즉, 716 개의 항만 계산하면 소수점 이하 1000자리까지 정확하게 값을
구해낼 수 있게 됩니다. 

더 자세한 사항을 알고 싶으신 분들은 주변에 수학과 대학생이나
혹은 수학 선생님 혹은 수학을 잘하는 엄친아에게 물어봅시다~.
(아 머리 아퍼... 알지도 못하면서 자료 찾느라 힘들군요. -_ㅠ)

자, 우선 언제나처럼 계산결과를 한 번 확인해 봅시다.

여담입니다만, 초등학교 시절인가...? 아무튼 기억나지는 않는데
제가 처음 원주율이라는 숫자를 외울 적에는 그냥 3 이었습니다.
에... 믿기지 않으시겠지만 정말입니다. 저는 원주율이 3인줄 알고 있었습니다.

그러다 중학교를 오게 되면서 원주율이 무리수라는 사실을 알게 되었지요.
그래도 한 동안 저에게 원주율은 3.14 였습니다. ^^;
물론 수학을 언제나 거의 낙제 수준으로 점수를 받아온 터라
대학생이 된 지금은 거의 뭐... 쩝. 체념하는 수준입니다만,
그래도 막상 원주율을 이렇게 길게 구해보니 감회가 남다르긴 하네요. ^^;;;;;

자 그럼 실제로 코딩해보실 분들을 위한 주석 달린 코드 나갑니다.

#include &lt;stdio.h&gt;

/* 존 마친이 고안한 고속 파이(Pi) 구하기로 소수점 이하 1000자리까지
정확하게 구한다. 알고리즘 원리는 http://en.wikipedia.org/wiki/John_Machin 이 문서에서
확인할 수 있다. */

void iAdd(short*, short*, short*); /* 덧셈 */
void iSub(short*, short*, short*); /* 뺄셈 */
void iDiv(short*, short, short*); /* 나눗셈 */
void iResult(short*); /* 결과출력 */

#define L 1000 /* 구할 범위 */
#define L1 ((L/4)+1) /* 배열 크기, 4로 나누는 건 short 형 사용 때문 */
#define L2 (L1+1) /* 배열 크기 +1 */
#define NUM (short)((L/1.39794)+1) /* 계산하려는 항의 수 (마친 공식에서 채용) */

int main(int args)
{
&nbsp;&nbsp;&nbsp; static short s[L2+2], w[L2+2], v[L2+2], q[L2+2];
&nbsp;&nbsp;&nbsp; short k;
&nbsp;&nbsp;&nbsp; 
&nbsp;&nbsp;&nbsp; // 초기화
&nbsp;&nbsp;&nbsp; for (k=0; k&lt;L2; k++)
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; s[k] = w[k] = v[k] = q[k] = 0;
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; 
&nbsp;&nbsp;&nbsp; // 마친의 공식 적용 (v 가 더 빨리 수렴하는 점을 이용한다.)
&nbsp;&nbsp;&nbsp; w[0] = 16*5; 
&nbsp;&nbsp;&nbsp; v[0] = 4*239;

&nbsp;&nbsp;&nbsp; for (k=1; k&lt;=NUM; k++) {
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; iDiv(w, 25, w);
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; iDiv(v, 239, v);
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; iDiv(v, 239, v);
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; iSub(w, v, q);
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; iDiv(q, 2*k-1, q);
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; 
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; // k 가 홀수면 (즉 2로 나눠떨어지지 않으면) 계산항은 + 다.
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; if ((k % 2) != 0)
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; iAdd(s, q, s);
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; else
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; iSub(s, q, s);
&nbsp;&nbsp;&nbsp; }
&nbsp;&nbsp;&nbsp; iResult(s);
&nbsp;&nbsp;&nbsp; 
&nbsp;&nbsp;&nbsp; return 0;
}

// 출력하기
void iResult(short c[])
{
&nbsp;&nbsp;&nbsp; short i;
&nbsp;&nbsp;&nbsp; printf("%3d.&nbsp; ", c[0]); // 최상위 자리 (즉 소수점 이상) 출력 : 3
&nbsp;&nbsp;&nbsp; 
&nbsp;&nbsp;&nbsp; // 소수점 이하 자리수 출력
&nbsp;&nbsp;&nbsp; for (i=1; i&lt;L1; i++)
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; printf("%04d ", c[i]);
&nbsp;&nbsp;&nbsp; printf("￦n");
}

// 긴자리수 나누기
void iDiv(short a[], short b, short c[])
{
&nbsp;&nbsp;&nbsp; short i;
&nbsp;&nbsp;&nbsp; long d, rem=0;
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; 
&nbsp;&nbsp;&nbsp; // 4자리씩 끊어서 나눗셈을 처리한다.
&nbsp;&nbsp;&nbsp; // 이 때, 긴자리 덧셈/뺄셈과 달리 처음 블록 a[0] 부터 a[N] 까지 루프를 돈다.
&nbsp;&nbsp;&nbsp; // 돌면서 현재 블록의 나눗셈을 한 몫은 c[i] 에 저장하고, 나머지를 다시 rem 변수에 할당한다.
&nbsp;&nbsp;&nbsp; // 루프를 한바퀴 돌면, 직전에 저장해둔 rem 변수에 현재 블록을 더해서 다시 반복한다.
&nbsp;&nbsp;&nbsp; // 나머지에 10000 을 곱하는 이유는 덧셈을 위해서이다.
&nbsp;&nbsp;&nbsp; for (i=0; i&lt;=L2; i++) {
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; d=a[i];
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; c[i]=(d+rem)/b; // 직전 루프에서 계산한 rem 값을 더하여 나눗셈을 한다.
&nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; rem=((d+rem) % b) * 10000; // 다음번 루프에서 반영된다.
&nbsp;&nbsp;&nbsp; }
}

// 긴 자리 덧셈하기
void iAdd(short a[], short b[], short c[])
{
&nbsp;&nbsp;&nbsp; short i, cy=0;
&nbsp;&nbsp;&nbsp; 
&nbsp;&nbsp;&nbsp; // 배열의 뒷자리부터 (그러니까 작은 단위수부터) 한 인덱스씩 계산한다.
&nbsp;&nbsp;&nbsp; // 한 블럭의 덧셈결과가 10000 을 넘게 되면 자리올림수 처리를 해준다. (cy)
&nbsp;&nbsp;&nbsp; for (i=L2; i&gt;=0; i--) {
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; c[i] = a[i] + b[i] + cy;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // 4자리수끼리 덧셈을 했는데도 10000 을 못넘겼으면 자리올림수는 없다!
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; if(c[i] &lt; 10000)
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; cy = 0;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; else {
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; c[i] = c[i] - 10000;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; cy = 1; // 덧셈해서 10000 을 넘겼다면 자리올림수를 만든다.
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // 위에서 만들어진 자리올림수는 그대로 다음 루프문에서 반영된다.
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; }
&nbsp;&nbsp;&nbsp; }
}

// 긴 자리수 뺄셈하기
void iSub(short a[], short b[], short c[])
{
&nbsp;&nbsp;&nbsp; short i, br=0;
&nbsp;&nbsp;&nbsp; 
&nbsp;&nbsp;&nbsp; // 역시 배열의 뒷자리 블럭부터 4자리씩 끊어서 계산한다.
&nbsp;&nbsp;&nbsp; for (i=L2; i&gt;=0; i--) {
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; c[i] = a[i] - b[i] - br;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; // 4자리수 뺄셈해서 결과가 0 이거나 혹은 0보다 크면 자리내림수는 없다!
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; if (c[i] &gt;= 0)
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; br = 0;
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; else {
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; c[i] = c[i] + 10000; // 0보다 작게 되었다면 10000 을 빌리고
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; br = 1; // 대신 그 윗자리수에서 1을 뺀다. 등가교환법칙
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; }
&nbsp;&nbsp;&nbsp; }
}

대부분은 주석의 설명만 봐도 이해가 되실 겁니다.
다만 마친의 정리가 어떤 원리로 동작하는지 알지 못하면
이해가 불가능한 부분도 있습니다. 제 허접한 설명으로는 감히 어찌할 수 없는 문제라
부득불 다른 경로로 추가적인 정보를 확인해 보시길 부탁드립니다. -_ㅠ;

이번 원주율 구하기와 비슷한 문제로, 테일러 전개를 이용한 exp 값 구하기가 있습니다.

exp = 1 + (1/1!) + (1/2!) + (1/3!) + (1/4!) + ... + (1/n!) + ...

위에서 느낌표! 는 팩토리얼임을 뜻합니다.
물론 실제 수학적으로는 무한한 계산량이지만, 컴퓨터로 계산하기 위해서는
메모리나 시간 등을 고려해서 적절하게 제한 범위를 줘야 합니다.
n < 300 정도로 범위를 설정해두면 일반 PC 에서 별 무리없이 계산이 가능할 것 같네요. ^^;

심심풀이로 해 보실 분들은 위에 공개된 소스코드를 참조하셔서 긴자리수 사칙연산을
이용하여 exp 도 한 번 구해봅시다~.
(정확하게 구하셨다면, 2. 7182 8182 8459 0452 3536 0287 ... 이런 숫자로 시작합니다.)

이상하게 별 인기도 없는 이 뻘쭘한 알고리즘편을
계속 이어오고 있네요. ^^;;
앞으로도 틈 나는 대로 간간히 두뇌 회전 할 수 있는 생각거리를
함께 나눌 수 있도록 하겠습니다.

그럼, 다음 뻘글에서 다시 뵙겠습니다. :)
...

뒤늦은 우분투(ubuntu linux) 8.10 사용 소감

시리니 — Wed, 19 Nov 2008 12:19:21 +0900

사실 설치는 그저께 최종적으로 마무리를 하였습니다.
나름대로 운영체제 만큼은 안정 지향이라서, 우분투 8.10 공개 후에도
바로 갈아타지 않고 나름대로 뜸(?)을 좀 들였더랬죠.

이번에 업데이트 하는 과정은 wubi 인스톨러의 도움을 받았습니다.
학업에 사용해야하는 S/W 가 전부 Windows ONLY 라서,
부득불 가상 OS 위에 올려두고 우분투를 사용했었는데요. ㅠ.ㅠ;;
이제부터는 듀얼 부팅 체제로 전환해서 학업용 S/W 를 쓸 때나
기타 Windows 에서밖에 못하는 것들을 제외하고는 우분투에서
나름대로 편하게 지금처럼 블로깅도 하고 코딩도 하고 있습니다. ^^;

우선 Wubi 인스톨러로 설치하는 과정은... 솔직히 말씀드려서
왠만한 게임 설치하는 것보다 더 쉬웠습니다.
가끔씩 친구들에게 우분투를 써 볼 것을 권하고 있는데 언제나 설치 부분에서
그래도 설명이 막히더라구요. 리눅스 파티션이 뭔지, 듀얼 부팅이 뭔지 등을
설명하려면 살짝 귀찮기도 하고... 그렇다고 RTFM 이라고 얘기해봤자
뭔 소린지도 모를테고... -_;;;

그런데 이제는 그런 고민 할 필요가 없어졌습니다.
http://wubi-installer.org/ 여기 접속해서 인스톨러 다운로드 받고
마치 Windows 애플리케이션 설치하듯 쉽게 설치해서 재부팅, 그 후
듀얼 모드로 부팅 시 OS 선택하기까지 일사천리로 진행됩니다.
거기다 삭제도 프로그램 추가/제거 기능으로 제어판에서 쉽게
처리할 수 있으니 말 다했죠 뭐.

(초창기 Wubi 에서 나타났던 여러 심각한 버그들도 많이 사라진 모습입니다.
이제는 안심하고 적극적으로 홍보를 해봐야 겠습니다. ^^)

설치 후에 언제나 그랬던 것처럼 한/영 키와 한자키 세팅을 하려고
.Xmodmap 을 설정하려고 했는...데, 어라? 자동으로 SCIM 에서 잡아주는군요.
(전에는 안잡혀서 아예 nabi 로 갈아타고 하는 게 일상이었는데)
거기다 NVIDIA 최신 그래픽 드라이버까지 안내해주고...
이거 원, 편해져도 너무 편해졌다는 생각이 들 정도로 좋아졌습니다.

제가 우분투에서 하는 일이라는 게, 대부분 지금처럼
블로깅을 한다던지 아니면 코딩해야 할 게 있다던지 할 때인데
개발환경으로서의 우분투는 이미 괜찮은 완성도를 보여주고 있습니다.

물론 linux/UNIX 문화에 익숙하지 않다면 여전한 진입장벽으로 인해
좌절감을 느끼실 수도 있는데...;;; 조금만 익숙해지면
오히려 Windows 환경에서 작업할 때보다 더 편하다는 걸 알 수 있으실 겁니다.
(그러나 Windows 용 S/W 개발하시는 분들은 낭패...)

여담입니다만, Microsoft 에서 저와 같은 대학생들에게 값비싼 개발도구들을
무상으로 제공해 준다는 소식을 접했습니다. 저희 학부 건물 곳곳에도
꿈불꽃 이라는 포스터가 여기 저기 붙어있었죠.

그러나, Linux 환경은 시초부터 꿈불꽃 환경이었습니다. -_;;; (말장난?)
값으로 따질 수 없는 높은 완성도의 컴파일러, gcc 도 무료이고
MySQL DBMS 도 무료, 그리고 Apache 도 무료고 더불어 OS 도 무료입니다.
저는 정말 '개방'된 개발환경을 원하신다면 우분투와 같은 linux 환경을
적극적으로 추천해 드리고 싶습니다.

(얼마 전에 써먹었던 스크린샷 재활용... ~_~;;)

우분투 8.10 은 큰 변화는 눈에 띄지 않지만
전체적으로 굉장히 안정적으로 변했다는 것을 느낄 수 있었습니다.
개발 방향이 안정화에 맞추어 개발된 것이었는지는 알 수 없지만
솔직히, 기대 이상입니다. :)

만약 우분투를 써 보고 싶으신데,
여태까지 CD 를 굽고 포맷하고 설정하는 과정이 귀찮아서(혹은 두려워서)
망설이셨던 분들은 위에서 소개해드린 Wubi 인스톨러로
한 번 도전해 보셔도 괜찮을 것 같습니다.

하아...
그나저나, 나름대로 삽질하는 과정을 즐겼었는데
이젠 그럴 필요가 없다니, 왠지 좀 섭섭하네요... 음... ㅠ.ㅠ;;
...

[뻘쭘한 알고리즘] 긴 자리수 덧셈 뺄셈 해보기

시리니 — Tue, 18 Nov 2008 00:33:59 +0900

이번에는 아주 기본적인 것을 한 번 고찰해 보겠습니다.
이름하야, 긴 자리수 (혹은 무한 자리수!) 덧셈 뺄셈!! ...입니다. ^^;
굳이 설명이 필요할 것 같지는 않지만, 그래도 한 번 같이 생각해보자는 취지로
배경지식을 이야기 해 보도록 하겠습니다.

C 언어에서 기본적으로 제공하는 데이터 타입 중에
95782023975478592927348 이라는 숫자를 한 번에 담을 수 있는
타입이 무엇일까요? 네, 짱돌 날라오는 군요. ==3=3 (튀엇!!)

없죠.
어이 없어 하시는 것도 충분히 이해가 됩니다.
사실 저는 그 동안 이른 바, 강타입(strong type) 언어를 자주 쓰지 않아서
이런 부분에 특히 무신경 했습니다. 놀랍게도 Python 과 같은 언어에서는
아예 언어 특성상 이런 무한자리수 연산이 가능하도록 설계가 되어 있으니
더더욱 무신경했는지도 모릅니다. (반성중... ㅠ.ㅠ)

어쨌든, 현실세계는 냉정합니다.
95782... 로 시작하는 저런 긴 숫자는 최소한 C언어에서는 감당할 수가 없습니다.
반드시 배열이나 기타 다른 데이터 구조에 담아서 별도의 가공을 거쳐야 하지요.
슬픈 현실 앞에 비통한 마음 금할 길 없지만, 뭐 그래도 어쩌겠습니까.
언어에서 지원하지 않는다면 우회하는 길이라도 만들어 봐야지요. ^^;;

그래서 준비된 것이 이번에 소개해 드릴 긴 자리수 연산 알고리즘입니다.
원리는 단순합니다. 긴 자리수를 4자리 정수를 담을 수 있는 short 배열에다가
담습니다. 그리고 그 4자리씩 덧셈과 뺄셈을 해서 각각 자리올림수와 자리내림수를
처리해 줍니다. 그러니까 다시 말해 긴 자리의 숫자를 한 번에 처리하지 않고
4자리씩 끊어서 결국 4자리 short int 형 정수의 덧셈과 뺄셈을 하는 것입니다.

우선 아래 성공했을 시 나타날 화면을 보시겠습니다. (찬조출현: GNOME 콘솔)

(출력부분을 보시면 일부로 4자리씩 끊어서 나타난 것을 알 수 있습니다.)

이 전략을 좀 더 고급(?)스럽게 이야기하면 '분할 정복 전략' 이 되겠습니다.
즉, 한 번에 해결할 수 없는 단위의 큰 문제는 한 번에 해결할 수 있는 작은 몇 개의 문제로
나눠서 개별적으로 각개 격파 하는 것입니다. 위에서도 긴 자리수의 숫자를
short int 형으로 담아서 결국에는 4자리수 덧셈 / 뺄셈을 하도록 했습니다.

물론 여기서 만족할 수는 없겠지요.
아래 제가 작성한 코드의 문제점은 외부에서 입력을 받을 때 어떻게 할 것인가 하는 대비가
없다는 점입니다. 또한 수치를 반드시 short int 형 배열에 쪼개서 넣는 게 좋은지,
아니면 다른 타입으로 변환해서 넣는게 더 좋은지에 대해서도 고려를 해보아야 합니다.
더 깊게 생각해 본다면 CPU I/O 카운팅을 통해서 그야말로 마니악한 집요성으로
코드 최적화를 해 볼 수도 있겠습니다.

#include &lt;stdio.h&gt;

/* 이 소스코드는 기존 C 언어에서 지원하지 않는
무한자리수 산수 연산을 예시한다. 기본 데이터타입의 범위를 초과한
데이터의 덧셈과 뺄셈을 처리한다. */

#define LIMIT 32 /* 일단 여기서는 편의상 32자리 수로 제한한다. */
#define NUM ( ((LIMIT-1) / 4) + 1 ) /* 배열 크기다. short 타입의 배열을 쓴다. */

void iAdd(short*, short*, short*); /* 덧셈 */
void iSub(short*, short*, short*); /* 뺄셈 */
void iResult(short*); /* 결과 출력용 */

int main(int args)
{
&nbsp;&nbsp; &nbsp;// 임의로 큰 수를 4자리로 short 배열에 담아두었다.
&nbsp;&nbsp; &nbsp;// 실제 활용시에는 이 부분도 자동으로 되겠금 처리하는 게 좋다.
&nbsp;&nbsp; &nbsp;static short a[NUM+2] = {1522,7849,2969,5432,1562,5092,8504,9562},
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;b[NUM+2] = { 592,1949,6040,2947,6029,1156,5892,6782},
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;c[NUM+2];
&nbsp;&nbsp; &nbsp;
&nbsp;&nbsp; &nbsp;printf("연산대상 A: 1522,7849,2969,5432,1562,5092,8504,9562￦n");
&nbsp;&nbsp; &nbsp;printf("연산대상 B:&nbsp; 592,1949,6040,2947,6029,1156,5892,6782￦n");
&nbsp;&nbsp; &nbsp;printf("---------------------------------------------------￦n");
&nbsp;&nbsp; &nbsp;
&nbsp;&nbsp; &nbsp;iAdd(a, b, c);
&nbsp;&nbsp; &nbsp;printf("덧셈결과 +: ");
&nbsp;&nbsp; &nbsp;iResult(c);
&nbsp;&nbsp; &nbsp;
&nbsp;&nbsp; &nbsp;iSub(a, b, c);
&nbsp;&nbsp; &nbsp;printf("뺄셈결과 -: ");
&nbsp;&nbsp; &nbsp;iResult(c);
&nbsp;&nbsp; &nbsp;
&nbsp;&nbsp; &nbsp;return 0;
}

// 긴 자리 덧셈하기
void iAdd(short a[], short b[], short c[])
{
&nbsp;&nbsp; &nbsp;short i, cy=0;
&nbsp;&nbsp; &nbsp;
&nbsp;&nbsp; &nbsp;// 배열의 뒷자리부터 (그러니까 작은 단위수부터) 한 인덱스씩 계산한다.
&nbsp;&nbsp; &nbsp;// 한 블럭의 덧셈결과가 10000 을 넘게 되면 자리올림수 처리를 해준다. (cy)
&nbsp;&nbsp; &nbsp;for (i=NUM-1; i&gt;=0; i--) {
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;c[i] = a[i] + b[i] + cy;
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;// 4자리수끼리 덧셈을 했는데도 10000 을 못넘겼으면 자리올림수는 없다!
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;if(c[i] &lt; 10000)
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;cy = 0;
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;else {
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;c[i] = c[i] - 10000;
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;cy = 1; // 덧셈해서 10000 을 넘겼다면 자리올림수를 만든다.
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;// 위에서 만들어진 자리올림수는 그대로 다음 루프문에서 반영된다.
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;}
&nbsp;&nbsp; &nbsp;}
}

// 긴 자리수 뺄셈하기
void iSub(short a[], short b[], short c[])
{
&nbsp;&nbsp; &nbsp;short i, br=0;
&nbsp;&nbsp; &nbsp;
&nbsp;&nbsp; &nbsp;// 역시 배열의 뒷자리 블럭부터 4자리씩 끊어서 계산한다.
&nbsp;&nbsp; &nbsp;for (i=NUM-1; i&gt;=0; i--) {
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;c[i] = a[i] - b[i] - br;
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;// 4자리수 뺄셈해서 결과가 0 이거나 혹은 0보다 크면 자리내림수는 없다!
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;if (c[i] &gt;= 0)
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;br = 0;
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;else {
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;c[i] = c[i] + 10000; // 0보다 작게 되었다면 10000 을 빌리고
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;br = 1; // 대신 그 윗자리수에서 1을 뺀다. 등가교환법칙
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;}
&nbsp;&nbsp; &nbsp;}
}

// 출력용
void iResult(short c[])
{
&nbsp;&nbsp; &nbsp;short i;
&nbsp;&nbsp; &nbsp;
&nbsp;&nbsp; &nbsp;// 저장된 배열을 역시 4자리씩 끊어서 보여준다.
&nbsp;&nbsp; &nbsp;for (i=0; i&lt;NUM; i++)
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;printf("%04d ", c[i]);
&nbsp;&nbsp; &nbsp;printf("￦n");
}

알록달록한 코드 첫머리를 보고자 하실 분들을 위해... (찬조출연: GEdit)

개인적으로 파이썬에서는 어떻게 이런 긴자리수 연산을 지원하는지
무척 궁금합니다. 귀도 아저씨가 어떤 기가 막힌 알고리즘을 썼을지... ^^;;

에, 오늘은 좀 싱거웠나요?
사실 저는 이 부분 보면서 '아...! 이렇게 하면 되네...!' ...라는 둥,
뻘 소리를 남발했거든요. -_;;; (저는 처음에 한자리씩 차근차근 움직이면서
덧셈하고 자리올림수 만들고 다시 덧셈하고... 이런 걸 구상했었거든요. ㅠ.ㅠ)

참고로 긴 자리수 곱셈과 나눗셈 역시 여러분들께서 예측하신대로,
4자리수 씩 나눠서 쉽게 할 수 있습니다.
다만 곱셈의 경우는 4자리수씩 곱셈을 하고, 5번째 이상 숫자는 그 앞 블럭의
곱셈결과에 더해주는 과정을 처리해야 합니다. 그러니까 자리올림수가 한 개가
아니고 두 개가 있는 거지요. (직접 한 번 해 보아요~)

나눗셈의 경우는 좀 더 손을 가해야 합니다.
4자리수씩 하는 건 맞는데 4자리 나눗셈을 하고 나서 몫은 그대로 결과에 반영하고,
나머지는 10000배 해서 그 다음 블럭에 더한 후 다시 나누기를 해야 합니다.
그리고 계산 방향도 기존과는 반대방향이구요. (역시 직접 한 번 해 보아요~)

이 긴 자리수 사칙연산은 실제로도 굉장히 유용합니다.
어째서 유용한지, 내일 보여드릴 원주율(pi) 값 구하기편에서 같이 알아보도록 합시다.
(긴 자리수 나누기 함수도 사용합니다. 그리고 pi 값은 소수점 이하 1000 자리까지
슈퍼컴퓨터 뺨치고 달랠 수 있을 정도로 정확하게 구할 수 있습니다. ^^)
...

그들만의 밥상을 뒤엎어라!

시리니 — Sun, 16 Nov 2008 20:15:25 +0900

다시 또 느닷없는 뻘글입니다. (주말 저녁이니까요... 하하;;)

저는 '밥상 뒤엎기' 라는 말을 좋아하는데요,
그러니까 어머니께서 만들어주신 그 밥상을 반찬투정 때문에
뒤엎는 게 아니라 기존의 틀이나 게임의 법칙 자체를 뒤엎는 걸
비유적으로 말하는 겁니다. (혹시나 퍠륜아로 오해받을까봐... 어머니, 밥 맛있어요.)

뭐 세상에는 좋은 말들도 많지만
왠지 모르게, 저는 밥상을 뒤엎는다는 표현이 마음에 쏙 듭니다.
이미 공전히 히트를 기록한 블루오션 전략이라거나
기타 여러 어려운 말들(?) 보다 더 와닿더군요.

(출처: Weekly 경향, 잘 차려진 밥상)

밥상이라는 것은 이미 차려진 것을 말하는 겁니다.
그리고, 그 차려진 밥상은 불행히도 나의 것이 아닙니다.
언제나 그들만을 위한 밥상일 뿐, '나' 는 찌꺼기조차
얻어먹을 수 없습니다.

실제 경제에서도 똑같습니다.
잘 나가는 1등, 2등, 3등이 다 먹고 난 찌꺼지를
나머지 기업들이 나눠 먹는 게 바로 시장원리입니다.
새로운 기업이거나 중소 기업이 '그들'만의 견고한 성벽을
넘어서 자리를 잡기란 쉽지 않습니다.

그 걸 우리는 스스로를 납득시키기 위해
'현실의 벽' 이라고 '위장' 합니다.
저건 내 힘으로 할 수 없는 거다.
이미 게임의 승자는 정해져 있다. 포기하자...

그래서 지레 포기하고 좌절 속에 사는 경우를
우리는 자주 목격하게 됩니다.
학업이나 사업등에서 그 '현실의 벽' 앞에 고개를 떨구어야 했던
우리네 이웃, 혹은 자기 자신의 모습을 말이죠.

(좌절금지, 아직은 포기할 때가 아닙니다.)

그럴 때, 우리는 어떻게 해야 할까요?
정말 계속 좌절하고 고개를 숙이고 있어야 할까요?
움츠린 어깨를 떨며 속절없이 눈물만 흘려야 할까요?

아니죠.
더 이상 잃을 게 없는 사람들이 본래 무서운 겁니다.
다 끝났다고 생각될 때, 더 이상 잃을 게 없다고 생각될 때,

그들의
밥상을
뒤엎어
버립시다!

시밤 쾅─!!

이미 만들어진 게임의 법칙 속에서
죽을 때까지 이길 수 없을 것 같다면,
그 게임의 법칙을 바꾸면 됩니다.

이미 승자가 정해진 싸움에서
영영 단 한번도 이겨 볼 수 없을 것 같다면,
그 싸움의 법칙을 바꾸면 됩니다.

자기 자신에게 유리하게,
더 이상 그들만의 밥상이 아닌
'나' 를 위한 밥상을 가질 수 있도록...!

물론 말은 쉽습니다.
자, 게임의 법칙을 나에게 유리하게 바꾸면 된다고?
그럼 이제 어떻게 하면 되지?

전략을 재정비 해야겠지요.
본래 전쟁에서도 지형지물부터 제갈량의 동남풍까지
할 수 있는 모든 노력을 다해서 자기 자신에게 유리하게 만들어놓고
그 후에 '반드시 이긴다!' 는 자세로 싸움에 임해야 합니다.

기존에 만들어진 전선에서의 싸움이 불리하다면,
다른 전선을 구축하면 됩니다.
거기서 자신이 유리하도록 미리 전선을 구축하고
그 후에 싸움에 임해도 늦지 않습니다.

ASUS 는 이미 만들어진 기존의 노트북 시장에서
기존의 방식대로 싸워서는 이길 수 없다는 걸 잘 알고 있었습니다.
그래서 그들은, 그들이 잘 할 수 있는 싸움터를 스스로 만들어냈습니다.
바로 넷북(NetBook) 시장이죠. eee PC 의 탄생입니다.

Apple 은 Windows 생태계에서는 죽었다 깨어나도 Microsoft 를 넘지 못한다는 걸
오래전부터 알고 있었습니다. 그래서 그들은 UNIX 커널을 사용한 자체 OS 를
만들게 됩니다. 또한 그들은 기존 휴대전화 시장에서 이미 만들어진 게임의 법칙을
따라가다간 제 힘을 발휘할 수 없을 거라는 걸 간파했습니다. 그래서 만들었죠.
그들만의 철학을 담은 iPhone 을요.

혁신은 '창조적 파괴', 즉 '밥상 뒤엎기' 에서부터 시작합니다.
기존의 법칙들은 당신의 재능을 인정하지 않습니다.
설령 당신이 공부는 못하지만 매우 뛰어난 음감을 가지고 있더라도,
적어도 기존의 사회 속에서 당신은 그저 노래 좀 잘 부르고
음정에 민감한 '열등생' 일 뿐입니다.

그렇게 계속 열등생으로 남길 원합니까?
그렇다면 그대로 웅크린 채 죽을 때까지 빛을 저주하며 어둠 속에서 찌질하게 살면 됩니다.

아니면 기회를 원합니까? 자신의 재능을 꽃 피우길 원합니까?
그렇다면 부셔버리십시오. 기존 사회의 관습, 관념, 인식... 그 모든 것들을
부셔버리는 겁니다.

각양각색의 사람들을 획일적인 국영수 성적으로만 평가하는 이 세상이 잘못된 것인지,
아니면 자신이 잘 하는 일조차 주저하며 포기하는 게 잘못된 것인지는
스스로에게 물어봅시다. 분명 답이 나올 겁니다.

기존에 만들어진 게임의 법칙 속에서 1등은 언제나 단 한명 뿐입니다.
그리고 당신은 1등이 아닙니다. 언제나 남과 비교했을 때 당신은 열등합니다.
더구나 이 법칙은 어느 누구도 피할 수 없는, 빌어먹을 엿 같은 법칙입니다.

자, 그렇담 답은 이제 다른 곳에서 찾아야 합니다.
기존의 틀 속에서 당신은 절대로 1등이 될 수 없습니다.
그렇다면 내가 진정으로 이길 수 있는, 나 만의 게임을 만들어야 합니다.
그리고 그 게임에서, 남들의 고리타분한 관념이나 법칙들은 무시해 버리면 그만입니다.

보다 나은 내일을 원하십니까?
이 빌어먹을, 엿 같은 게임의 법칙 속에서
언제까지나 패배자로 남는 건 질색이십니까?

그렇다면, 부셔버리십시요!
뒤엎어 버리십시오!
그들만의 밥상을 발로 차 버리십시오!

ASUS 처럼!
Apple 처럼!

당신도 할 수 있습니다!
우리도 할 수 있습니다!
'나' 도 할 수 있습니다!

언제까지 '현실의 벽' 운운하며 고개 숙이고 있을 겁니까?
패배를 받아들일 '용기' 가 있다면,
그 용기로 기존의 밥상을 뒤엎어 버립시다.

우리는 할 수 있습니다.
세상이 나를 알아주지 않는다면,
알아주기 싫어도 알아보고야 말도록 만들면 됩니다.

'밥상 뒤엎기!'

이제 우리 차례입니다.
...

블로그 디자인을 상콤하게 변경!

시리니 — Sat, 15 Nov 2008 21:52:14 +0900

(블로그 테마 바꾼지 얼마 되었다고... 또 삽질을... -_;; )

오늘은 GR보드 업데이트 작업과 GR블로그 신규 테마 작업으로
나름 알차게 보낸 것 같습니다. (물론 어머니께 된통 어택을 당했습니다만... ㅠ.ㅠ)

이 디자인은 본래 워드프레스용으로 공개된 디자인인데
그 걸 GR블로그용으로 변환한 것입니다.
본문 폭이 좀 좁아서 보시기에 어떨지 모르겠네요. 우선 큰 이미지들을
자동으로 리사이즈해서 보여주도록 변경했고 글꼴도 맑은 고딕을
한 번 사용해 보았습니다. (설치된 곳이 많아야 할 터인데... 후덜덜;;;)

블로그 디자인이 전체적으로 화사해진 느낌입니다.
직전에 만들었던 테마 디자인이 전체적으로 잿빛 콘크리트 빛깔이었다면
지금의 디자인은 총천연색 자연의 빛깔!! ...정도 될까요? 하하하;;;

오늘 공개된 GR보드 업데이트판과 GR블로그 업데이트판은
그간 누적된 버그 패치가 반영된, 소규모 업데이트를 반영하고 있습니다.
버그 패치와 함께 지금 제가 쓰는 이 테마는 GR블로그 기본 배포판에 추가되어서
공개중입니다.

    ※ GR보드 업데이트 페이지: GR Board 하프물범 Plus Pack #2.1
    ※ GR블로그 업데이트 페이지: GR Blog v1.1.4 "황조롱이" (pl3)

오늘 하루 빡세게 작업했으니
내일부터는 다시 또 딩가리~ 딩가리~ 하면서 (응?) 보내야겠군요. (흠흠)

새로 바뀐 디자인 어떠신가요?
부디 마음에 드셨길 빕니다... ^^;;;

덧.

곧 400만힛이 오는 군요..;; 뻘글이 난무하는 이 곳을 찾아와 주시는
여러분들께 진심으로 감사드립니다. 항상 감사하다는 말을 하지만
그래도 감사합니다. 언젠가 1000만힛이 달성되면, 그 땐 정말 어떻게
시루떡이라도 돌리던가 해야 겠습니다. 아하하하하;;;
...

[뻘쭘한 알고리즘] 범위 내 소수만 걸러내기 (에라토스테네스의 체)

시리니 — Fri, 14 Nov 2008 23:31:36 +0900

아래편에 (1) 이라고 적었는데 후속글 제목으로는 (2) 라고 안했군요.
거기다 이번에는 코드 작성과 컴파일을 Ubuntu Linux 에서 했네요.
이거 뭐 원... 전혀 일관성이 없는, 역시 제 블로그 다운(?) 뻘쭘함의 향연입니다. (ㅠ.ㅠ)

우선 앞 글에서 소수와 관련된 이야기, 그리고 소수의 조건과
소수 판별 절차 마지막으로 root n 부터 나눗셈을 시작한 것과
n-1 부터 나누기를 시작한 결과가 같다는 점까지 확인해 보았습니다.
(수학자들은 정말 대단합니다. 같은 인간으로 생각되지가 않군요... 흑)

이번에는 2 부터 N 까지의 숫자 사이에 끼여 있는 소수만 톡톡! 걸러내어서
정렬해 보도록 하겠습니다. 수학 관련 도서 뒷편에 보면 참고 자료로
소수표 같은 게 붙어있을...지도 모르겠는데;;; (워낙 교과서와 담 쌓고 지내서... -_ㅠ)
그 걸 이제부터 같이 해 볼 겁니다.

우선 결과가 어떻게 나올 건지부터 먼저 보실까요?

(Linux 콘솔에서 출력한 결과입니다.)

2부터 N까지의 소수를 구하는 것은 이전편에서 소개해 드렸던
소수 판별법을 N까지 계속 반복하면서 소수를 발견할 때만
특정 배열에 저장해주면 됩니다. 이 때 숫자를 저장해줄 배열의 최대 크기는
N/2 + 1 의 크기를 넘지 않습니다. (당연합니다. 언뜻 생각해도 소수는 그렇게
자주 발견되지 않습니다. 위에서도 10000 까지 소수는 약 1/8 정도의 비율입니다.)

문제는 이렇게 단순하게 처리를 해버리면 처리 속도가 느려지게 된다는 점입니다.
그래서 어떻게 해야 할까... 고민하려다 이미 지금으로부터 약 2300년 전에 태어난
에라토스테네스라는 사람이 고민 후 답을 냈다는 걸 알아내고는 그의 풀이를
베껴서 해보기로 합니다. (생각이 없는 시리니 ㅠ.ㅠ)

에라토스테네스가 고안해낸 주요 처리절차는 아래와 같습니다.

2부터 N까지를 크기로 하는 체(여기서는 배열)를 만든다.
우선 모든 배열 요소를 1로 채운다.
2를 제외한 2의 배수를 체(배열)에서 모두 제거(즉, 해당 배열 요소들을 모두 0으로 설정)한다.
3을 제외한 3의 배수를 ... (위 3과 동일)
위의 절차를 N까지 반복해서 그래도 1로 끝까지 버텨낸(?) 배열의 각 인덱스 숫자가 바로 소수다.

위의 처리절차를 실제로 C코드로 구현해보면 아래와 같습니다.

#include &lt;stdio.h&gt;
#include &lt;math.h&gt;

/* 이 소스코드는 2 부터 N 까지의 수 사이의 소수만 선택해서
보여준다. 사용된 알고리즘은 에라토스테네스의 체 이다.
(개선된 소수 발견방법) */

#define Num 10000

int main(int args)
{
&nbsp;&nbsp; &nbsp;// 범위+1 크기의 배열 생성
&nbsp;&nbsp; &nbsp;static int prime[Num+1];
&nbsp;&nbsp; &nbsp;int i, j, limit;
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;
&nbsp;&nbsp; &nbsp;// 생성한 배열을 1로 초기화
&nbsp;&nbsp; &nbsp;for (i=2; i&lt;=Num; i++)
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;prime[i] = 1;
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;
&nbsp;&nbsp; &nbsp;// 입력 범위의 root 씌운 값의 정수값을 limit 으로 할당
&nbsp;&nbsp; &nbsp;limit = (int)sqrt(Num);
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;
&nbsp;&nbsp; &nbsp;// 루프를 돌면서 앞서 해봤던 소수판별방식으로 소수만 계속 1로 남긴다.
&nbsp;&nbsp; &nbsp;// 2의 배수, 3의 배수 등은 모두 0 으로 변경한다.
&nbsp;&nbsp; &nbsp;// 마치 체에 소수만 탈탈~ 걸러내는 것처럼 해본다.
&nbsp;&nbsp; &nbsp;for (i=2; i&lt;=limit; i++) {

&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;// 1 이라는 건 즉 상태가 아직 변경 안된 것으로 추정할 수 있다. 검사해보자.
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;if (prime[i] == 1) {

&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;// i 에 2 배한 값 j 를 i 로 나눠 0 이 되는지 (즉 소수가 아닌지) 보고
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;// 또 그 j 에 1을 더한 3 을 i 에 곱해서 다시 i 로 나눠 0 이 되는지 보고... (반복)
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;for (j=2*i; j&lt;=Num; j++) {

&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;// 나눠 떨어지는 수가 있다면 그 놈은 이미 소수가 아니다!
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;if (j % i == 0)
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;prime[j] = 0;
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;}
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;}
&nbsp;&nbsp; &nbsp;}
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;
&nbsp;&nbsp; &nbsp;// 여기까지 오면 배열에서 소수 숫자로 된 인덱스만 1 이고 나머지는 다 0 으로 바뀐 상태다.
&nbsp;&nbsp; &nbsp;int result_num = 0;
&nbsp;&nbsp; &nbsp;printf("2 ~ %d 사이의 소수￦n￦n", Num);

&nbsp;&nbsp; &nbsp;for (i=2; i&lt;Num; i++) {
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;if (prime[i] == 1) {
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;printf("%5d", i);
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;result_num++;
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;}
&nbsp;&nbsp; &nbsp;}
&nbsp;&nbsp; &nbsp;
&nbsp;&nbsp; &nbsp;printf("￦n￦n휴우~! 무사히 %d 까지의 소수 %d 개를 출력했습니다.￦n￦n", Num, result_num); 
&nbsp;&nbsp; &nbsp;
&nbsp;&nbsp; &nbsp;return 0;
}

역시 주석을 좀 꼼꼼히 달아보았습니다.
아마 그냥 읽어보시기만 해도 '아~ 요로코롬 돌아가는구나~' 하실 겁니다. ^^;
단지 반복문을 돌 때 우리가 흔히 하는 것처럼 i=0; 부터가 아니라 i=2; 부터라는 점은
조금 주의할 필요가 있을 것 같네요. (왜 2 부터 시작할까요? 소수는 2 부터 정의되기
때문입니다. 초기화 때부터 prime[0], prime[1] 은 열외가 된 것을 알 수 있습니다.)

배열의 인덱스 번호가 바로 숫자 번호로 사용되기 때문에
한 번에 너무 큰 크기의 배열만 선언하지 않는다면 계산량을 줄이면서도
더 빠르게 소수들을 찾아낼 수 있습니다.

(환상적인 에디터인 GEdit 의 늠름한 모습)

물론 문제점도 있습니다.
반복문 안에 다시 또 반복문이 들어가는, 그런 아름답지 못한 구조로
설계가 되어 있어서 순간적인 CPU 과부하를 일으키는데 활약할 수 있습니다.
또한 소수를 발견해낼 적정 범위가 분명히 제한됩니다. 왜냐면, 적어도
C 언어 상에서는 최고 큰 기본 데이터형이 double 형으로 제한되기 때문입니다.
(Python 의 경우는 좀 다르겠지요. 긴 자리수 연산이 기본으로 지원되니까요.)

이 문제까지 해결하기 위해서는 엄청나게 긴 자리수의 사칙연산을
해결할 수 있어야 합니다. 흥미롭게도 이와 관련해서 이미 선배 개발자분들이
여러 해결책을 제시해 주셨는데요, 다음에 이 '긴 자리수 사칙연산' 과 관련해서
또 함께 뻘쭘한 시간 가져보도록 합시다. (제발~)
...

[뻘쭘한 알고리즘] 나는 네가 소수인지 아닌지 알 수 있다 (1)

시리니 — Fri, 14 Nov 2008 19:37:34 +0900

요즘 어딘가의 나사가 풀려 버린 것만 같아
나름대로 어떻게 정신통일을 해볼까, 하다가
기본적인 알고리즘 공부를 해보자! ... 라는 결심을 하게 되었습니다. -_;;

마침 한빛미디어에서 출판된 책도 학교 도서관에서 빌렸고,
여차 저차해서 최근 열독중입니다. (일본인 저자가 지은 『C언어로 배우는 알고리즘 입문』)
인동형님께서 사주신 C++ 책도 간간히 보고 있는데 어쨌든 중요한 점은
제가 알고리즘이나 수리적 추론 능력이 완전 저질급이었다는 점입니다. ㅠ.ㅠ;;

그래서...
앞으로 간간히 [뻘쭘한 알고리즘] 이라는 걸로다가
책을 보면서 나름 재밌는 알고리즘에 대해 소개를 드릴까 합니다.
오늘은 그 첫 시간으로, 소수 판별을 하는 코드와 특정 범위 내에서의
소수 판별, 그리고 계산량을 줄여서 최적화를 할 수 있는
에라토스테네스의 체 라는, 다소 수학 매니아틱한 뻘글을 소개하겠습니다.

아, 같이 해보실 분들은 자신의 PC 에 C 컴파일러만 설치하시면
쉽게 하실 수 있으실 겁니다. 소스코드는 모두 그대로 쓰실 수 있도록
글 중간 중간에 넣어두겠습니다. 저는 Windows 환경에서 Dev-C++ 이라는
IDE 로 작성을 했는데요, Linux 의 경우 gcc 와 vi 만으로도 훌륭한 개발환경이
됩니다. ^^;;

(이클립스에서 작업을 할까 했지만, MinGW 와의 연동을 하려다 귀찮아져서... -_;;; )

자, 먼저 오늘 고찰해 볼 소수가 무엇인지 한 번 알아봅시다.
사실은 이미 다들 알고 계시지만, 수학에 아픈 추억을 가지고 있는
저와 같은 분들은 잊어버렸거나 기억에서 지웠을 수도 있습니다.

소수란 자기 자신 외에는 약수를 가지지 않는 수를 말합니다.
2 이상의 양수에 해당하며 2, 3, 5, 7, 11 ... 등의 수를 소수라고 합니다.
(약수란 말은 어떤 수를 나누었을 때 나머지가 0 인 수를 말합니다.)

수학 문제중에보면 500 이하의 숫자 중에서 소수는 몇 개가 있는가?
...같은, 보는 것만으로도 짜증이 치솟는 문제들이 있습니다. (나름 수학 울렁증)
손으로 일일이 계산한다는 것은 굉장히 어려운 일이고, 또 귀찮은 일입니다.
사람은 누구나 귀찮은 일을 싫어합니다. 그래서 수학자들은 그 것을 수학적
추론과 논증을 통해 간략화 하려 하고, 저 같이 게으른 공돌이는 컴퓨터에게
시켜놓고 낮잠을 즐기죠. -_ㅠ;

우리는 오늘, 컴퓨터가 소수를 구해 놓을 수 있도록 일련의 코드를 작성해
컴퓨터에게 전달할 것입니다. 우선 소수인지 아닌지 검사해주는 코드가
실제 실행될 때의 모습을 한 번 보시죠.

(굉장히 친절한 우리의 소수판별군)

소수를 좀 더 쉽고 빠르게 판별하기 위해서는 몇가지 알아둬야 하는 게 있습니다.

입력한 수 n 이 n 이외의 정수로 나눠서 떨어지면 그 수는 소수가 아닙니다.
수학자들의 증명에 의해, n 대신에 root n 부터 위 1의 과정을 거쳐도 결과는 동일합니다.
루프를 돌면서 어떤 수에 나눠떨어지면 루프를 탈출해 소수가 아님을 알 수 있습니다.

제가 실제로 컴파일 시 사용한 코드는 아래와 같습니다.

#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;
#include &lt;math.h&gt;

/* 이 소스코드는 입력받은 숫자가 소수인지 아닌지를 판별하는
역할을 한다. Dev-C++ 에서 작성되었음. */ 

int main(int argc, char *argv[])
{
&nbsp;&nbsp; &nbsp;int i, n, limit, stop;
&nbsp; 
&nbsp;&nbsp; &nbsp;// 루프를 돌면서 숫자를 받자
&nbsp;&nbsp; &nbsp;while(1) {
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;// 입력받기
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;printf("소수 여부를 판별할 숫자(2 이상의 양수) 입력: "); 
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;scanf("%d", &amp;n);

&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;// 유효범위 테스트
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;if(n &lt; 2 || n &gt; 100000) {
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;printf("너무 큰 숫자이거나 혹은 숫자가 아닙니다!￦n");
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;continue;
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;}

&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;// 입력받은 수에 루트를 씌운 값으로 나눠서 소수 여부를 판별해도 된다.
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;// 이건 수학자들이 밝혀낸 것임. 일단 루트 씌운 값부터 알아내서 정수형으로 저장하자.
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;limit = (int)sqrt(n);

&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;// 루트씌운 값부터 마이너스를 계속 하면서 루프를 돈다.
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;// 만약 소수라면, 그 루트씌운 값 (limit) 이 1이 될 때까지 한번도 나눠서 0 이 되는 일은
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;// 없을 것이다. 아니라면, 도중에 탈출하게 된다.
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;for(i=limit; i&gt;1; i--) {
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;if(n % i == 0)
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;break;
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;}

&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;// 위의 루프를 끝까지 돌면서 도중하차 하지 않은 경우가 소수인 경우다.
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;if(i == 1)
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;printf("%d 는 소수였습니다!￦n", n);
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;else
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;printf("%d 는 소수가 아닙니다! %d 로 나눠지던걸요?￦n", n, i);

&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;// 그만할 건지 물어본다.
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;printf("￦n￦n그만하실래요? (0 : 그만할래요. / 1 : 계속할거야) ");
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;scanf("%d", &amp;stop);

&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;// 그만한다면 나간다.
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;if(stop == 0)
&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;&nbsp;&nbsp; &nbsp;break;

&nbsp;&nbsp; &nbsp;}
&nbsp; 
&nbsp;&nbsp; &nbsp;// 종료 처리 
&nbsp;&nbsp; &nbsp;//system("PAUSE");&nbsp;&nbsp; &nbsp;
&nbsp;&nbsp; &nbsp;return 0;
}

주석을 좀 더 보강해 보았는데요, 아마 읽어보시면 쉽게 아실 수 있을 겁니다. ^^;;

위에 제가 작성한 코드에서 좀 더 보강할 점은 입력값에 대한 유효성 검사와
반복 구문입니다. 물론 컴퓨터는 반복문을 눈부신 속도로 처리합니다만,
그 것도 범위가 작을 때 말이지 커지면 커질수록 현격히 느려지게 됩니다.
따라서 반복문을 안 쓰는 방법은 없는지도 고찰해 볼 필요가 있습니다.

위의 코드는 비교적 단순합니다.
숫자를 입력 받고, 그 숫자의 root 씌운 값 (sqrt 함수를 통과한 값) 에 정수부분만
떼어서 그 숫자를 기준으로 나누기를 합니다. 만약 9 가 입력되었다면 root 값은 3이므로
9 을 3 으로 나눠서 떨어지는지 보고 (물론 떨어지므로 소수가 아니죠!) 2 로 나눠서
떨어지는지 보고... 이런식으로 동작하게 됩니다.

이런;;
다시 또 은근슬쩍 스크롤 압박이 재게되는 것 같아 할 수 없이 제목에 (1) 을 붙여놓고
다음 포스트에서 이어 가도록 하겠습니다. (이래 놓고 안 쓸 꺼면서... -_;; )
...

수능대박기원! 수험생 여러분 화이팅이에요~

시리니 — Wed, 12 Nov 2008 09:27:41 +0900

매년 11월이 되면 꼭 하루는 엄청나게 추워지는,
그런 마법의 날이 있습니다. 거의 대부분의 사람들이
한 번쯤은 거쳐가는 시련, 수능날이죠.
(이 글이 공개될 때쯤이면 내일 수능날이겠군요.)

불필요하게 긴장을 너무 해서 복통이 생긴다거나
스트레스로 인해 제 실력이 발휘되지 못하는 경우도 있습니다.
아니면 지레 미리 겁먹고 포기하거나 미리 좌절감을
사서 가지는 학생들도 있을 겁니다.

수능은 우리들의 긴 인생에 있어서 단지 처음 맞이하는
큰 시련중 하나에 불과할 뿐입니다.
획일적인 암기능력 측정식의 현 교육 환경에서는
여러분들의 숨겨진 창의력과 재능이 올바르게 반영되지
않을 수도 있습니다.

그러나, 그렇다고 해서 좌절하지 맙시다!

위기를 기회로 받아들이고,
어떠한 결과가 주어지더라도 항상 겸허하게 받아들일 수 있다면
여러분들은 어디에 가서든 성공할 수 있습니다.

"이제 끝났다..." 라고 말할 때가 바로, 시작할 때입니다!

학교가 자신의 성공을 보증해주는 시대는 이미 지나갔습니다.
이제는 자기 자신의 능력으로 스스로를 계발해 나가야 합니다.
그리고 그 과정의 시작으로, 수능이라는 시련을 거치게 됩니다.

그 시련 앞에서 당당히 서 있으십시오!
여러분들은 재능있는, 창의적인 존재들입니다.
그 어떤 문제, 그 어떤 시련이 오더라도
꿋꿋히 견뎌낼 수 있습니다.

자, 내일 아침 일찍 일어나서
힘차게 "화이팅!!!" 한 번 외쳐주고
당당한 걸음걸이로 수험장소로 가십시오.

그리고 가져오십시오!

수능대박은, 바로 당신의 것입니다!
...

올블로그는 대체 무엇을 하고 있나?

시리니 — Mon, 10 Nov 2008 20:01:04 +0900

(사이트 에러가 났을 때 도저히 안되겠다 싶어서 캡쳐한 모습입니다. 복구가 덜 된 상태였죠.)

지난 번에 올블로그 접속 장애가 나서 한 동안 접속이
되지 않던 문제가 생겼었습니다. 중국발 해킹으로 의심된다는 정보를
보긴 했는데 뭐 사이트 운영하다보면 그럴 수도 있지 않겠나
생각했습니다. 재발 방지를 위해 노력하겠다는 메시지도 봤고...
솔직히 제가 방비를 하더라도 제대로 해 낼 수 있었겠나 하는 생각에
괜히 열심히 하시는 분들 기 꺾고 싶진 않았습니다.

그리고 얼마 전에, 그러니까 최근 주말이죠.
또, 또, 또! 올블로그는 장애를 일으켰습니다.
지난 번 봤던 것 같은 동일한 메시지를 보여주면서 말이죠.
솔직히 그 때는 화가 많이 났습니다.

저는 올블로그의 장애가 잦은 이유 때문에 화가 난 것이 아닙니다.
장애는 있을 수 있습니다. 기계는 언젠가 고장나기 마련이고,
그게 하필이면 화장실에서 열심히 일을 보고 있을 때이거나
24시간 철야 끝에 잠깐 찾아온 휴식시간에 올 수도 있습니다.

제가 화가 나는 것은,
어째서 같은 실수를 올블로그는 반복하고 있는가 하는 점입니다.
그 때 재발방지를 하겠다고 했는데 왜 같은 장애를 보아야 하고
왜 저는 좋아하는 올블로그를 두고 믹시나 블로거뉴스로 가야만 하는 겁니까?

물론 개발팀이나 엔지니어분들이 대비를 하셨겠지만
지금의 이런 모습들을 보았을 때는 전혀 충분하지 못한 것 같습니다.
한 두번 실수는 용서가 되지만 그게 계속 반복된다면
그 건 도저히 옹호하고 싶어도 양심상 그럴 수가 없습니다.

대체 올블로그는 무엇을 하고 있습니까?
어떤 내부적인 문제점이 있기에 이렇게 해결하는데 시간이 걸리는 겁니까?
왜 서비스 사용자들은 장애가 났다는 사실을 이렇게 무기력하게
받아드려야만 하는 겁니까?

왜? 도대체 무엇 때문에 올블이가 이렇게 힘들어하는 겁니까?

(저는 즐거워하고 웃는 올블이를 보고 싶습니다.)

해킹을 좀 더 유리하게 막을 수 있고 장애시 빠른 복구가 가능하도록
지금보다 더 나은 개선은 할 수 있을 겁니다.
지금 블로그칵테일에서 위드블로그라는 새 서비스를 준비중인 것으로 아는데
제 생각으로는 신규 서비스를 내기 이전에 기존 서비스의 안정화부터
준비해 두는 게 순서에 맞지 않나 싶습니다.

저는 나름대로 자부심이 있습니다.
올블로그를 초창기 때부터 지켜봐 왔다는 것 말입니다.
그리고 비교적 오랫동안 지켜봐 오면서 짧은 시간내에 이룩한 많은 성과들을
진심으로 축하했고 또 부러워 했습니다.

그러나, 지금 저는 걱정스럽습니다.
또 언제 해킹 공격을 당해 몇 시간 동안이나 멍~ 해야 할지 모른다고 생각하니
불안합니다. 무섭습니다.

이게 계속 반복되면 내성이 생깁니다.
그러면 무감각해집니다. '어? 또 장애났네... 다른 데 가자.' 그리고 그 길로
두 번 다시 올블로그로 돌아오지 않을지도 모릅니다.

올블로그 초기부터 지금까지, 군대에 가서도 꿋꿋히 애용했던
한 명의 자칭 열혈 사용자가 진심으로 올블로그 팀원 분들께
말씀드리고픈 말이 있습니다.

여러분들은 프로(pro) 입니다.
일을 하면서 돈을 버는, 저 같은 햇병아리 아마추어와는 다른 사람들입니다.
자신의 분야가 있을 테고, 그 분야는 스스로 책임져야 하는 분들입니다.
올블로그의 표어가 무엇인지, 설마 벌써 잊어버리신 건 아니겠지요?
만약 그렇다면 진심으로 실망입니다.

여러분들은 혹시 착각하고 있지 않습니까?
'우린 아직 초기니까 괜찮아.'
'우린 아마추어 정신으로 가는 거야~'
'우린 이미 1등이야. 괜찮아.'

정말, 진심으로 제 기우이길 바랍니다.
블로거들이 그렇게 욕하고 싫어하는 네이버, 서비스 장애로
하루 넘게 보낸 적이 없을 겁니다. 왜일까요?
단순히 돈이 많아서? 아니면 똑똑한 사람들이 많으니까?

아니죠.
뭐가 다른 지는 여러분들이 더 잘 아실 겁니다.
서비스를 만들고 운영하면서 '더 나은 서비스와 안정성' 을 보여주는 것은
고객들과의 암묵적인 약속입니다. 그리고 그 약속은
'어? 장애가 생겼었네요. 미안해요. ㅠ.ㅠ' 같은 말로 대충 얼버무릴만한 것이
아닙니다.

제 말이 기분 나쁘실 겁니다.
그렇지만 그래도 해야 겠습니다.
저는 지금의 올블로그가 마음에 안듭니다.

눈에 보이는 개선을 바랍니다.
중국발 해킹을 설령 또 다시 당하더라도, 최소한 밥 먹고
오는 정도의 시간이면 다시 웃는 올블이를 보길 원합니다.
더 이상 다른 곳에 가보라─, 따위의 글은 용서 할 수 없습니다.
저에게 있어 메타블로그는 올블로그 하나 밖에 없는데,
대체 어디를 다시 또 가라고 하시는 겁니까?

(다시 정상화된 올블로그)

대책을 강구해 주십시오.
중국발 해킹이던, 미국발 크래킹이던 아니면 갑작스런 장비 고장이든
무슨 이유이든 올블로그가 안정적으로 운영될 거란 믿음을 보여주십시오.

저는 다시 한 번 더 강조하지만 자칭 열혈 올블로그 사용자입니다.
올블로그에서 선물도 나름 받아 본 사용자고,
비록 올블 TOP 100 리스트 근처에도 가보지 못했지만
나름대로 101번째는 나야! ...라면서 박박 우기는 사용자입니다.

두 번 다시 실망하고 싶지 않습니다.
다시 예전처럼 올블로그를 마구마구 사랑하고 알려주고 싶습니다.

기대해도 될까요?
저는 올블로그의 저력을 믿습니다.
중국 해커들이 아무리 설치고 노려도, 결코 함락당하지 않는
그런 튼튼하고 힘 쎈 올블이를 기대하겠습니다.
...