matheTOY 함수 엔진을 지속적으로 확장해가며,
범용적인 부분까지 처리하다보니,
결국 그 연산 내용이 LISP 처리와 유사해지고 말았다.

현재의 matheTOY 엔진의 처리 과정은 LISP 처리 과정과 동일하며,
수식, 방정식, 함수식, 집합, 행렬, 리스트 등의 지원되는 처리외에
String 등 추가적인 변수 타입, 디바이스 I/O 등을 추가한다면, 훌륭한 Lisp 엔진이 될 것 같다.

matheTOY 수식 처리 Language 엔진이 기존 Lisp 언어보다 강력한 것은, (어쩌면 기존 Lisp에도 있을지 모르지만)
1. Trans 함수
   예를들어, Tan(x) = Sin(x) / Cos(x) 와 같은 '대입 정의 함수'를 Lisp에서 처리할 수는 있다.
   그러나,
   (A ^ b) * (A ^ c) = A ^ (b + c) 같은 형태의 Trans 식은,
   LIsp 뿐만 아니라, 여타 랭귀지에서도 지원하지 않는 것으로 안다.
   (위에서 A, b, c는 단순한 수치가 아니라, 알고리즘이나 함수들을 포함한 함수식이다.)
   물론 저것을 기존 제공된 알고리즘으로 풀 수는 있다.
   그러나 그 알고리즘을 만드는 것은 Case마다 개별적이며 번거로운 과정이 필요하다.
   Trans 식은 매우 직관적이고, 수학적이다.
2. IsEqual 함수
   두 함수식 또는 두 알고리즘식이 같은 것인지 판단한다.
   복잡하게 얽힌 두 함수식, 두 알고리즘식이 같은지 여부를 판단하는 것은
   Logic이나 함수, 알고리즘 자체를 원소로 다루는 계산에서 중요한 처리이다.
   그것을 처리하도록 고안된 함수이다.
3. Mergin 함수
   함수식 내에 Inverse 함수가 중첩되거나, 중복 의미 함수가 존재하거나,
   Operator-inverse 함수가 존재할 때,
   그것은 가장 간단하게 표현되도록 Mergin하는 처리를 담당한다.
기술한 것 외에 여러가지 '함수식을 처리'하는 함수들이 있다.
또한, 그 ['함수식을 처리'하는 함수]가 포함된 함수식 역시 처리되는 대상 인자이다.

Lisp을 지원하는 프로그래밍 툴의 희소성은 충분하고,
게다가 보다 강력한 메타 랭귀지 함수를 지원하므로, 도전해볼만 한 것으로 생각된다.
하지만, 무의미한 과부하가 걸리는 것은 아닌지...

matheTOY 입실론 버전에서 현재(2010년 2월 22일)까지 처리된 함수 목록입니다.
(※ matheTOY 입실론 버전은 아직 출시되지 않은 버전이므로 착오없으시길 바랍니다)

몇몇 함수는 계산 속도를 위한 알고리즘 개선 등의 추가 작업이 필요한 상태입니다.
또, 통계 파트의 상당수 함수는 이번 버전에서 제거되어 풀시될 예정입니다.
통계 파트의 다양한 분포 함수와 PDF 처리, 신뢰도 검정 등의 부분에 대해서는 전체적인 UI를 다듬은 후에 출시할 수 있을 듯 합니다.

현재 지원되는 함수만으로도, 대부분의 수학 분야에서 mathmatica의 수학 함수 리스트에 비교하여 부족하지 않습니다.
또, 통상 소수점 이하 20자리 정도까지의 정밀도만 제공하는 여러 전문 수학 프로그램들과 달리,
각 함수에 대해 소수점 이하 1만자리까지 정밀도를 지원하므로, mathmatica에 비교하여 더 뛰어난 기능성을 보일 수 있을 것이라 생각됩니다.
또한 matheTOY는 mathmatica 처럼, 스크립트 언어를 지원하므로,
사용자가 클래스 등을 제작하여, 원하는 수학적 출력물을 프로그래밍할 수 있게 됩니다.

비함수 연산자 부분

  - 대소 비교문
  - 선택문
  - 조건문
  - 사칙연산, 거듭제곱

함수 부분
Abs  : Abs(A)
Sgn  : Sgn(A), A Is Real
Floor  : Floor(A[, FloorDigit])
Re  : Re(A)
Im  : Im(A)
------------------------------------------------
Reciprocal
Exp  : Exp(A)
Sqr
------------------------------------------------
Cos / Sin / Tan
Sec / Cosec / Cotan
Arcsin / Arccos / Arcsec / Arccosec / Arccotan
Hsin / Hcos / Htan / Hsec / Hcosec / Hcotan
Harcsin / Harccos / Harctan / Harcsec / Harccosec / Harccotan
------------------------------------------------
Atan / ArcTan / Atn
Asin / Acos / Csc / Ctan / Ctn / Acosec / Acsc / ArcCsc / Acotan / Actan / Actn / ArcCtan / ArcCtn / Asec
Hatan / Hatn / Hasin / Hacos / HCsc / Hctan / HCtn
Hacosec / Hacsc / HArcCsc / Hacotan / Hactan / Hactn / HArcCtan / HArcCtn
Hasec / Atanh / Atnh / Asinh / Acosh / Csch / Ctanh / Ctnh / Acosech / Acsch
ArcCsch / Acotanh / Actanh / Actnh / ArcCtanh / ArcCtnh / Asech / ArcTanh
ArcSinh / ArcCosh / Cosech / Cotanh / ArcCosech / ArcCotanh / ArcSech
------------------------------------------------
Sinc  : = Sin(Pi*x)/(Pi*x)
Ln  : Ln(A)
Log(X1, X2)
Gudermannian  : = 2*arcTan(e^x) - Pi/2
LogFloor  : (a, b)
Arg 
------------------------------------------------
Bernoulli  : (n) : n is none negative integer
Gamma  : (s) : s is complex
Gamma_Incomplete_Upper  : STT (통계) : (s, up) and  : up :  is Real
Gamma_Incomplete_Lower  : STT (통계) : (s, low) and  : low :  is Real
Gamma_Di  : Di(z) = PolyGamma(0, z)
Gamma_Poly  : (m, z) : m is none negative integer
Gamma_Multivariate  : (p, x) : p is natural number
Beta  : Beta(X, Y)
Beta_Incomplete  : STT (통계) : Beta_Imcomp(up, a, b) and  : up :  is Real
Zeta  : (z)
Zeta_Hurwitz  : (s, q) and Re(s)>1, Re(q)>0
// Zeta_Lerch  : -> 너무 복잡하여 사용치 않음
Error  :  = 2*Cumulative_Distribution(x * Sqr(2)) - 1
ErrorC  :  = 2*Cumulative_Distribution(-x * Sqr(2))
K  : K(n)
Barnes_G  : (z)
Dirichlet_L  : L(s, k) and k is natural number > 1
                  = Zeta_Hurwitz(s, m/k))
Dirichlet_Beta  : 4^(-n) * (Zeta_Hurwitz(s, 1/4) - Zeta_Hurwitz(s, 3/4))
Dirichlet_Character  : (k, s, n) - k: 1 보다 큰 Integer
                                     s: Positive int, n: none negative integer
------------------------------------------------
Eta_Dirichlet  : = (1 - 2^(1 - s)) * Zeta(s)
Eta_Dedekind  : (z)
Euler  : Euler(q) = q^(-1/24) * Eta_Dedekind(Tau), 단, q = e^(2*pi*i*Tau)
                                하지만, Tau를 구하는 것이 쉽지 않기 때문에 따로 처리한다.
Chi_Legendre  : chi_v(z) = 1/2 * [Li_v(z) - Li_v(-z)] : Li : PolyLogarithm
Delta_Kronecker  : (i, j) : i, j is integer
------------------------------------------------
Theta_Riemann_Siegel  : theta(t) = arg (Gammat((2it+1)/4))) - t * Ln(pi)/2
Theta_Jacobi  : (z, r) : z, r is complex
Theta_Ramanujan  : (a, b) a, b is real and |ab| < 1
Theta_Riemann  : (t) : t is real
Theta_Q  : (z, q) : q is real and |q| < 1
------------------------------------------------
Bessel_First  : J_a(x) 로 표기 - (a, x) and a, x is complex
Bessel_Second  : Y_a(x) = (J_a(x) * cos(a * pi) - J_-a(x)) / sin(a * pi)
Bessel_Modified_I  : I_a(x) = i ^ (-a) * J_a(i * x)
Bessel_Modified_K  : K_a(x) = (Pi / 2) * i ^ (a + 1) * H1_a(i * x)
Bessel_Spherical_J  : j_n(x) = sqr(pi / (2 * x)) * J_{n+1/2}(x)
Bessel_Spherical_Y  : y_n(x) = (-1)^{n+1} * sqr{pi / (2 * x)} * J_{-n-1/2}(x)
Bessel_Riccati_S  : S_n(x) = x * j_n(x)
Bessel_Riccati_C  : C_n(x) = -x * y_n(x)
Bessel_Riccati_Zeta  : Zeta_n(x) = x * h2_n(x)
Bessel_Clifford_One  : (n, z) : n, z is complex
Bessel_Clifford_Two  : (n, z) : n, z is complex
Hankel_One  : H1_a(x) = (J_-a(x) - e^(a * pi * i) * J_a(x)) / (i * sin(a * pi))
Hankel_Two  : H2_a(x) = (J_-a(x) - e^(a * pi * i) * J_a(x)) / (-i * sin(a * pi))
Hankel_One_Spherical  : h1_n(x) = j_n(x) + i * y_n(x)
Hankel_Two_Spherical  : h2_n(x) = j_n(x) - i * y_n(x)
Kelvin_Ber  : (n, x) : n is integer
Kelvin_Bei
Kelvin_Ker
Kelvin_Kei
Airy_Ai  : (x) : x is real
Airy_Bi 
Synchrotron_First  : (x) : x is real >=0
Synchrotron_Second  : G(x) = x * K_{2/3}(x)
------------------------------------------------
Weierstrass  : (x, a, b) : 0 < a < 1, b : positive odd integer, and ab > 1 + {3 * pi}/2
Weierstrass_Elliptic  : (z[, w1], w2)
Invariant_J  : j(x) =      [θ(0;x)^8+θ_{01}(0;x)^8+θ_{10}(0;x)^8]^3
                             32 ---------------------------------------
                                [θ(0;x) θ_{01}(0;x) θ_{10}(0;x)]^8}
                                θ : Jacobi Theta FC
Struve  : (a, x) : a, x is complex
Anger  : (v, z)
Weber  : (v, z)
Riesz  : (x)
Dawson  : = - {i * sqr{pi} / 2} * e^{-x^2} * erf(i * x)  :  erf() : Error Function
Lambert_W  : (x)
Dirac_Delta  : (x)
Mittag_Leffler  : (a, b, z) : a, b, z is complex, Re(a) > 0
------------------------------------------------
Polylog  : Li(s, z) : s, z Is complex and |z| < 1
Polylog_Incomplete  : Li(s, low, z) : s, z Is complex and |z| < 1, low is real
Polylog_Spence  :  = Li_2(z)
------------------------------------------------
Integral Type Function
integral_Scorer_Gi  : (x)
integral_Scorer_Hi  : (x)
integral_Clausen  : (s, x) : Re(s) > 1
integral_Kummer  : (n, z) : n, z is complex
integral_Heaviside_Step  : (x) : x is real
integral_Logarithmic  : li(x) : x is real > 0 and x<>1
integral_Logarithmic_Offset  : Li(x) = li(x) - li(2)
integral_Exponential  : Ei(x) : x is real x <> 0
integral_Trigono_Upper  : Si(x) : x is real > 0
integral_Trigono_Lower  : si(x) : x is real > 0
integral_Fresnel_Sin  : (x) : x is real > 0
integral_Fresnel_Cos  : (x) : x is real > 0
// integral_Elliptic_Incomplete_First  : -> 이해되지 않는 수학적 내용이 있어서 처리를 미룸
integral_Elliptic_Incomplete_Second
integral_Elliptic_Incomplete_Third
integral_Elliptic_Complete_First
integral_Elliptic_Complete_Second
integral_Elliptic_Complete_Third
------------------------------------------------
Seri_Integral  : 부정 적분이다. Integral(By X, F(X)) 꼴로 나타낸다.
Seri_IntegralReal  : 정적분이다. IntegralReal(By X, Area(), F(X)) 꼴로 나타낸다.
Seri_Differ  : 미분 Differ(By X, F(X)) 꼴
Seri_Series  : Series(By X, Area(A, B), F(X)[, Where(IsFactor(X,C))]) 양식
Seri_SumAll  : SumAll(By X, Area(A, B), F(X)[, Where(IsFactor(X,C))]) 양식
Seri_ProductAll  : ProductAll(By X, Area(A, B), F(X)[, Where(IsFactor(X,C))]) 양식
Seri_ContinuedFrac  : ContinuedFrac(By X, Area(A, B), F(X)[, Where(IsFactor(X,C))]) 양식
Seri_Interval  : Series, Integral 등에서 사용, (Start, End[, Step])
------------------------------------------------
ModExpand_CycleMod  : (R, modR)
------------------------------------------------
n번째 항을 순차적으로 출력하는 함수들만 모음
nThElem_Bernoulli  : (n) : n is none negative integer
nThElem_Prime  : (n) : n is none negative integer
nThElem_Divisor  : (d, n) : d is natural, n is none negative integer
nThElem_Divisor_Count  : (d)
nThElem_Factor_Prime  : (d, n) : d, n is natural
nThElem_Factor_Prime_Count  : (d)
nThElem_Factor_PrimePower  : (d, n) : d, n is natural
nThElem_Factor_PrimePower_Count  : (d)
nThElem_Modulus_Coprimes  : (d, n) : d, n is natural
nThElem_Modulus_PrimitiveRoots  : (d, n) : d, n is natural
nThElem_Modulus_PrimitiveRootFirst  : (d)
nThElem_Add_PowersRepresent  : (d, n) : d, n is natural
nThElem_Add_CountOfPowersRepresent  : (d)
nThElem_Add_SumByTwoSquares  : (d, n) : d, n is natural
nThElem_Add_CountOfSumByTwoSquares  : (d)
------------------------------------------------
Expand_ContinuedFrac  : (v, Count) : v는 수 또는 함수, Count = 자연수
Expand_Talor  : (F) : F is function
Expand_Integral  : (F) : F is function
Expand_SumAll  : (F) : F is function
------------------------------------------------
Poly_Expand  : (F) : F is function
Poly_Collapse  : (F) : F is function
Poly_Collapse_Differention  : (F) : F is function
------------------------------------------------
PolyExpand_Hermite  : (n, x) : n is none negative integer
PolyExpand_Laguerre  : (n, x) : n is none negative integer
PolyExpand_Bessel  : (n, x) : n is none negative integer
PolyExpand_BesselReserved  : (n, x) : n is none negative integer
PolyExpand_Tchebycheff_First  : (n, x) : n is none negative integer
PolyExpand_Tchebycheff_Second  : (n, x) : n is none negative integer
PolyExpand_Legendre  : (n, x) : n is none negative integer
PolyExpand_Legendre_Associated  : (m, n, x) : m, n is none negative integer
PolyExpand_Primitive  : (n, x) : n is natural > 1, 원시 방정식
PolyExpand_Symetric  : (n, x1, x2, ..., xk) : n is natural
PolyExpand_PowerSymetric  : (n, x1, x2, ..., xk) : n is natural
------------------------------------------------
NumThAdd_Partition  : (n) : n is natural
NumThAdd_Bell_Number  : (n) : n is none negative integer
// NumThAdd_Stirling_Number_First  : 수학적 의미가 부정확하여 처리를 미룸
NumThAdd_Stirling_Number_Second
------------------------------------------------
NumThBin_Binomial  : (a, b) : a, b is complex
NumThBin_Multinomial  : (a, k1, k2, k3, ...) : all arguments is complex
NumThBin_Catalan_Number  : (n) : n is none negative integer
------------------------------------------------
NumTh_Lcm  : (x1, x2, ...) : x is gauss integer
NumTh_Gcd  : (x1, x2, ...) : x is gauss integer
NumTh_Quotient  : (a, b) : a, b is gauss integer
NumTh_SumOfPower  : (a To b, n) : a, b, n is natural
------------------------------------------------
NumThMul_Legendre_Symbol  : (a, b) : a is integer, b is odd prime > 0
NumThMul_Jacobi_Symbol  : (a, b) : a is integer, b is odd integer > 0
NumThMul_Kronecker_Symbol  : (a, b) : a, b is integer
NumThMul_MoebiusMu  : (n) : n is integer > 0
NumThMul_Liouville  : = (-1)^PrimOmega(n)  : (n) : n is integer > 0
NumThMul_Dedekind_Psi  : (n) : n is integer > 0
NumThMul_Euler_Totient_Phi  : (n) : n is integer > 0
NumThMul_Carmichael_Lambda  : (n) : n is integer > 0
NumThMul_Mangoldt_Lambda  : (n) : n is integer > 0
NumThMul_DivisorSigma  : (n[, x]) : n is integer > 0, x is complex
NumThMul_DivisorSigmaAliquot  : (n[, x]) : n is integer > 0, x is complex
NumThMul_Dedekind_Sum  : (a, b, c) : a, b, c is integer > 0
NumThMul_PrimeOmega  : (n) : n is integer > 0
NumThMul_PrimeOmegaDistinct  : (n) : n is integer > 0
------------------------------------------------
NumThPrime_NearPrime  : (n) : n is real > 0
NumThPrime_PrimePi  : (n) : n is real > 0
NumThPrime_NextPrime  : (n) : n is real > 0
------------------------------------------------
STT_Fermi_Dirac_Complete  : (j, x) : j, x is complex
STT_Fermi_Dirac_Incomplete  : (j, x, low) : j, x is complex, low is real
STT_Cumulative_Distribution
------------------------------------------------
Method_Select  : Select(T/F, TruePart, FalsePart)
------------------------------------------------
Where  : Where(T/F)  :  Series 등에 사용되는 조건문
------------------------------------------------
Bool Type Function - Where문에서 사용
Is_Even  : (n) : n is integer
Is_Odd  : (n) : n is integer
Is_Natural  : (C) : C is complex
Is_Integer  : (C) : C is complex
Is_Rational  : (C) : C is complex
Is_Irrational  : (C) : C is complex
Is_UnReal  : (C) : C is complex
Is_Not  : Not(T/F)  :  Ex) IsNot(IsEven(a)) 등
------------------------------------------------ 여기까지 Base Is-Function
Is_Prime  : (n) : n is integer
Is_PrimePower  : (n) : n is integer
Is_SqaureFree  : (n) : n is integer
Is_Factor  : (n, m) : n, m is integer
Is_Divisible  : (n, m) : n, m is integer
Is_CoPrime  : (a1, a2, a3, ... ) : all arguments are integer
------------------------------------------------
※ 상기의 함수 목록은 제작 과정 중에 변경 또는 추가될 수 있습니다.

처리 엔진의 개략
위의 함수들은 심볼릭 연산 엔진을 기반으로 처리하게 됩니다.
즉, 모든 함수는 심볼릭 연산을 우선적으로 처리합니다.
따라서,
다항식이나 초월함수 등의 여러가지 수학적 형태를 있는 그대로 다루어 계산하게 됩니다.
출력값은,
기본적으로 복합 함수식이거나 미적분 꼴이 되고,
사용자가 추가적인 명령을 내리면, 복소수 또는 그래프로 출력할 수 있게 됩니다.

matheTOY Delta 버전의 수론 계산기 및 다항식 계산기에서 발전하여 더욱 강력해진 심볼릭 연산을 통해,
사용자들이 여러가지 수학적 연산을 깊이있게 실행해볼 수 있으리라 기대합니다.

이번에 리뉴얼하는 matheToy의 기능 개선 사항의 첫번째 항목으로,
사칙 연산, 기본 함수 처리 부분의 변경에 대해 적어 본다.

변경 사항 1.
정수 및 실수 영역과 정밀도 확장
10^30,000 크기의 거대한 정수를 다루는 처리에서,
10^420,000 크기의 거대 정수로 변환하고,
실수 영역 역시, 10^-14 ~ 10^14 영역에서,
10^-420,000 ~ 10^420,000 크기의 거대 실수, 거대 정밀도로 변환하였다.
단, Gamma, Zeta Function, Exp 등 초월 함수류는 소수점 이하 1만자리까지가 유효하다.

변경 사항 2.
엔진 통합
기존의 실수와 정수 파트에서 따로 제작된 계산 엔진을,
하나로 통합하도록 처리하였다.

변경 사항 3.
연산 속도 개선
거대 정수의 연산 속도를 5 ~ 100배 정도 더 빠르게 개선하였다.

변경 사항 4.
복소수 및 원시근 도입
모든 수학 함수, 모든 사칙 연산에 복소수 처리를 기본적으로 도입.
복소수 및 그 확장으로서 원분체의 원시근을 연산에 임의로 적용할 수 있도록 처리하였다.

변경 사항 5.
무한을 해로 도입
-∞, ∞ 이라는 무한값도 사칙연산 및 함수의 입, 출력값으로 다루어,
복잡한 연산 중에도 오류보다는 적정한 값이 나타나도록 처리하였다.
무한이라는 값은, 결과값이 특정하지 않은 '발산'과 구분하였다.

여기까지가,
사칙 연산 및 기본 함수 파트의 엔진 변경 내용이다.
스크립트 코딩 기능 등, 다른 개선 사항들은 다음 포스트에서 기록한다.

드디어 matheToy 리뉴얼이 시작되었다.
2006년에 마지막 버전이었고,
그 후로 조금씩 마이너 버전의 개선이 이루어졌지만,
그래프의 Avi 영상, 수론 함수의 추가 정도 외에는 큰 개선이 없었다.
사용자들에게 어떻게 사용해야 하는지 매뉴얼(도움말)도 최근에야 겨우 체계적으로 지원하기 시작하였다.
예를들어, Byedodo matheToy와 Equation은 복소 다항식을 계산할 수 있지만,
전문 수학자가 아닌 이상, 대부분의 유저는 원분체를 응용한 복소 다항식 계산법을 알지 못하는 것 같다.
그러한 추가적인 사용법 또한 매뉴얼로 작성하였다.

이번에 메이저 버전 업데이트가 진행되는데,
순차적으로 3 ~ 5회 정도의 반복 마이너 업데이트를 먼저 진행하게 된다.
그 중간 중간에 ArtCanvas 베타 버전과 Byedodo 웹에디터 알파 버전 출시도 함께 진행하게 된다.

전체적인 matheToy 뉴 버전의 기능은 시간 관계상,
다음 포스트에서 전개한다.

Byedodo 입실론 버전에 들어간지 벌써 1년이 지나간다.
입실론 버전의 규모나 완성도에 대한 기대 수준에 의해 작업 시간 또한 상대적으로 길어졌다.
디자인을 중심으로 소규모 수정에만 집중한 [델타 버전]에서
그 개발 기간이 3개월 남짓이었던데 비하여 아주 큰 시간적 차이가 있다.

특히, 레일노트 타입의 UI 그룹을 모든 Byedodo System에 적용하기 위해,
DB부터 시작하여 완전히 새롭게 개발하는데 2달 이상이.
HTML Wysiwyg 에디터 개발에 2달 이상이.
또, 자체적인 Grid(표) 에디터 개발에 2달 이상이.
ArtCanvas로 분류되는 그림 에디터 관련 기본 모듈 개발에 또한 2달 이상이 소요되었다.
또한, railNote에 HTML에디터, 표에디터, Text 에디터가 함께 적용됨으로 인한 '느린 로딩 속도'를 개선하기 위해 Byedodo Components와 Libraries 전체에 대한 대대적인 수정 작업에도 1달 이상 소요되었다.
덕분에 Byedodo 제품군 전체가 좀 더 가볍고 빨라지게 되었다.

표면적으로는 레일노트 하나에 1년이 걸린 셈인데,
표 에디터, HTML 에디터, ArtCanvas 모두 각각의 독립적인 어플리케이션으로 기능하게 될 것이고,
(현재 ArtCanvas는 이미 독립적인 어플리케이션으로 출시한 상태이다)
myDrawer나 matheTOY 등 다른 Byedodo software에도 결합되어 사용되는 기능이므로,
전체적으로 1년간 Byedodo 입실론 버전군의 기초 모듈을 제작한 것이라 할 수 있다.

현재는 추가적인 기능들.
예를들어 Sms (휴대폰 문자 서비스) 부분, 온라인 결제 시스템, 온라인 Database UI 부분 등에 대한 기술적 검토가 계속되고 있고,
이것들은 ideaPannel이나 myDrawer 등에 적용되는 부분이다.
ideaPannel은 To-do Software의 확장 형태로 마무리한 후 정식으로 배포할 예정이다.
Vista 이상에서 지원되는 태블릿 입력에 대한 처리 역시 조만간(1~2주일 이내) 완료되어 모든 Byedodo 제품군에 젹용될 예정이다.

가까운 시일내로 마무리할 사안으로,
홈페이지 리뉴얼과 프로그램 그룹의 세분화가 진행되고 있다.
프로그램 그룹의 세분화는,
예를들어 세부적 완성도의 문제로 늘 출시가 미루어지던 각종 소프트웨어 - Explorer, Music Editor 등 - 에 대해 내부 개발 Test version으로 출시하는 것이고,
기본 소프트웨어 또한 분화하여,
정식 버전, 알파 테스트 버전, 내부 개발 테스트 버전. 세가지로 분류한 후 선보일 계획이다.

2010년 개발될 Byedodo Software의 핵심은,
HTML 에디터나 Code 에디터, JSP, PHP 에디터, CHM 에디터 등의 전문가용 에디터 부분.
그리고 matheTOY 리뉴얼.
뮤직 에디터, Wave Editor 등 멀티미디어 파트의 에디터 그룹의 신규 출시.
그리고 myDrawer 등 개인용 어플리케이션의 기능을 강화하는 것이다.
2010년 하반기부터 영문 버전의 출시를 통해 해외에 본격적으로 배포하는 것 또한, 중요한 일정이다.