IT 지식 데이터베이스

구글 웹폰트 얼리 엑세스에서 제주폰트 사용가능합니다.

(꽤 오랬동안 구글은 얼리 엑세스를 관리하는 듯 합니다. 그렇다고 사용못하는 것은 아닙니다. 듣기로는 구글이 계속 테스트하고 있고 얼리 엑세스에서는 코드가 변경될 수도 있다고 하네요)

아래 링크를 참고해봅시다.

https://www.google.com/fonts/earlyaccess

http://technet.microsoft.com/ko-kr/library/cc755985(WS.10).aspx

이 진단 도구는 대상에 대해 다양한 TTL(Time-To-Live) 값으로 ICMP(Internet Control Message Protocol) 에코 요청 메시지를 보내 대상으로 가는 경로를 결정합니다. 적어도 하나의 IP 패킷을 전달하기 전에 패킷의 TTL을 감소시키기 위해 경로를 따라 각 라우터가 필요합니다. 실제로 TTL이 최대의 연결 카운터입니다. 패킷의 TTL이 0에 도달하면 라우터에서 ICMP 시간 초과 메시지를 원본 컴퓨터로 돌려 보냅니다. tracert는 대상이 응답하거나 최대 홉의 수에 도달할 때까지 1의 TTL을 가진 첫째 에코 요청 메시지를 보내고 이어지는 각 전송에서 TTL을 1씩 증가하여 경로를 결정합니다. 기본적으로 최대 홉의 수는 30이고 -h 매개 변수를 사용하여 지정할 수 있습니다. 경로는 중간 라우터가 돌려 보낸 ICMP Time Exceeded 메시지와 대상에서 돌려 보낸 에코 응답 메시지를 검사하고 확인합니다. 그러나 일부 라우터는 만료된 TTL 값과 함께 패킷에 대한 Time Exceeded 메시지를 돌려 보내지 않아 tracert 명령이 보이지 않습니다. 이 경우 별표(*) 열이 홉에 대해 표시됩니다. 

Tracert 에 대한 설명, 

요약하면 ICMP패킷을 이용한다는 것과 TTL을 하나씩 증가해서 애코 응답을 받기 때문에 ICMP패킷이 차단되 있고 TTL에 따른 애코를 응답하지 않는 라우터의 경우 확인할 수 없음.

def start(x):
    def increment(y):
        return x + y
    return increment

스코프에 규제받지 않는 코드 블록의 집합

64bit 에서 32bit 모듈 사용을 위해서 아래와 같이 해주면 된다.

# dpkg --add-architecture i386
# apt-get update
# apt-get install ia32-libs
# apt-get install libncurses5:i386
# ln -s /usr/lib/mesa-diverted/i386-linux-gnu/libGL.so.1 /usr/lib/i386-linux-gnu/

티스토리 초대장 드립니다!!

댓글로 이메일 주소 남겨주세요.

선착순 아닌 제 임의로 드립니다. ^^

프록시 패턴은 어떤 객체에 대한 접근을 제어하기 위한 용도로 대리인이나 대변인에 해당하는 객체를 제공하는 패턱

import java.util.*;
 
interface Image {
    public void displayImage();
}
 
//on System A 
class RealImage implements Image {
    private String filename;
    public RealImage(String filename) { 
        this.filename = filename;
        loadImageFromDisk();
    }
 
    private void loadImageFromDisk() {
        System.out.println("Loading   " + filename);
    }
 
    public void displayImage() { 
        System.out.println("Displaying " + filename); 
    }
}
 
//on System B 
class ProxyImage implements Image {
    private String filename;
    private Image image;
 
    public ProxyImage(String filename) { 
        this.filename = filename; 
    }
    public void displayImage() {
        if (image == null)
        {
           image = new RealImage(filename);
        } 
        image.displayImage();
    }
}
 
class ProxyExample {
    public static void main(String[] args) {
        Image image1 = new ProxyImage("HiRes_10MB_Photo1");
        Image image2 = new ProxyImage("HiRes_10MB_Photo2");     
 
        image1.displayImage(); // loading necessary
        image2.displayImage(); // loading necessary
    }
}

http://en.wikipedia.org/wiki/State_pattern

스테이트 패턴을 이용하면 객체의 내부 상태가 바뀜에 따라서 객체의 행동을 바꿀 수 있다. 마치 객체 클래스가 바뀌는 것과 같은 결과를 얻을 수 있다.

Strategy pattern과의 차이점

state pattern은 상태 객체의 일련의 행동이 캡슐화 됨

strategy pattern은 일반적으로 클라이언트에서 컨택스트 객체한테 어떤 전략 객체를 사용할지를 지정해 중

interface Statelike {
 
    void writeName(StateContext context, String name);
 
}
 
class StateLowerCase implements Statelike {
 
    @Override
    public void writeName(final StateContext context, final String name) {
        System.out.println(name.toLowerCase());
        context.setState(new StateMultipleUpperCase());
    }
 
}
 
class StateMultipleUpperCase implements Statelike {
    /** Counter local to this state */
    private int count = 0;
 
    @Override
    public void writeName(final StateContext context, final String name) {
        System.out.println(name.toUpperCase());
        /* Change state after StateMultipleUpperCase's writeName() gets invoked twice */
        if(++count > 1) {
            context.setState(new StateLowerCase());
        }
    }
 
}

http://en.wikipedia.org/wiki/Composite_pattern

컴포지트패턴을 이용하면 객체들을 트리구조로 구성하여 부분과 전체를 나타내는 계층구조로 만들 수 있다. 이 패턴을 이용하면 클라이언트에서 계별 객체와 다른 객체들로 구성된 복합객체를 똑같은 방법으로 다룰 수 있다.

import java.util.List;
import java.util.ArrayList;
 
/** "Component" */
interface Graphic {
 
    //Prints the graphic.
    public void print();
 
}
 
/** "Composite" */
class CompositeGraphic implements Graphic {
 
    //Collection of child graphics.
    private List mChildGraphics = new ArrayList();
 
    //Prints the graphic.
    public void print() {
        for (Graphic graphic : mChildGraphics) {
            graphic.print();
        }
    }
 
    //Adds the graphic to the composition.
    public void add(Graphic graphic) {
        mChildGraphics.add(graphic);
    }
 
    //Removes the graphic from the composition.
    public void remove(Graphic graphic) {
        mChildGraphics.remove(graphic);
    }
 
}
 
 
/** "Leaf" */
class Ellipse implements Graphic {
 
    //Prints the graphic.
    public void print() {
        System.out.println("Ellipse");
    }
 
}
 
 
/** Client */
public class Program {
 
    public static void main(String[] args) {
        //Initialize four ellipses
        Ellipse ellipse1 = new Ellipse();
        Ellipse ellipse2 = new Ellipse();
        Ellipse ellipse3 = new Ellipse();
        Ellipse ellipse4 = new Ellipse();
 
        //Initialize three composite graphics
        CompositeGraphic graphic = new CompositeGraphic();
        CompositeGraphic graphic1 = new CompositeGraphic();
        CompositeGraphic graphic2 = new CompositeGraphic();
 
        //Composes the graphics
        graphic1.add(ellipse1);
        graphic1.add(ellipse2);
        graphic1.add(ellipse3);
 
        graphic2.add(ellipse4);
 
        graphic.add(graphic1);
        graphic.add(graphic2);
 
        //Prints the complete graphic (four times the string "Ellipse").
        graphic.print();
    }
}

http://jmnote.com/wiki/Iterator_%ED%8C%A8%ED%84%B4

이터레이터 패턴은 컬랙션 구현 방법을 노출시키지 않으면서도 그 집합체 안에 들어가있는 모든 항목에 접근할 수 있게 해주는 방법을 제공해줍니다.

클래스를 바꾸는 이유는 한가지 뿐이어야 한다.

http://en.wikipedia.org/wiki/Template_metho

템플릿 메소드 패턴에서는 매소드에서 알고리즘의 골격을 정의한다. 알고리즘의 여러단계 중 일부는 서브클래서에서 구현할 수 있다. 템플릿 메소드를 이용하면 알고리즘의 구조는 그대로 유지하면서 서브클래서에서 특정 단계를 지정할수도 있다.

헐리우드 원칙

/**
 * An abstract class that is common to several games in
 * which players play against the others, but only one is
 * playing at a given time.
 */
 
abstract class Game {
 
    protected int playersCount;
    abstract void initializeGame();
    abstract void makePlay(int player);
    abstract boolean endOfGame();
    abstract void printWinner();
 
    /* A template method : */
    public final void playOneGame(int playersCount) {
        this.playersCount = playersCount;
        initializeGame();
        int j = 0;
        while (!endOfGame()) {
            makePlay(j);
            j = (j + 1) % playersCount;
        }
        printWinner();
    }
}
 
//Now we can extend this class in order 
//to implement actual games:
 
class Monopoly extends Game {
 
    /* Implementation of necessary concrete methods */
    void initializeGame() {
        // Initialize players
        // Initialize money
    }
    void makePlay(int player) {
        // Process one turn of player
    }
    boolean endOfGame() {
        // Return true if game is over 
        // according to Monopoly rules
    }
    void printWinner() {
        // Display who won
    }
    /* Specific declarations for the Monopoly game. */
 
    // ...
}
 
class Chess extends Game {
 
    /* Implementation of necessary concrete methods */
    void initializeGame() {
        // Initialize players
        // Put the pieces on the board
    }
    void makePlay(int player) {
        // Process a turn for the player
    }
    boolean endOfGame() {
        // Return true if in Checkmate or 
        // Stalemate has been reached
    }
    void printWinner() {
        // Display the winning player
    }
    /* Specific declarations for the chess game. */
 
    // ...
}

high cohesion, low coupling

cohesion: 한 모듈이 얼마나 관련된 일로만 구성되어 있는가?

coupling: 두개이상의 object가 얼마나 관계되어 있는가?

설계할 때 아주 중요하다.

http://en.wikipedia.org/wiki/Facade_pattern

어떤 서브시스템의 일련의 인터페이스에 대한 통합된 인터페이스를 제공한다. 퍼사드에서 고수준 인터페이스를 정의하기 때문에 서브시스템을 더 쉽게 사용할 수 있다.

최소 지식원칙, 정말로 친한 친구끼리만 얘기해라.

/* Complex parts */
 
class CPU {
	public void freeze() { ... }
	public void jump(long position) { ... }
	public void execute() { ... }
}
 
class Memory {
	public void load(long position, byte[] data) {
		...
	}
}
 
class HardDrive {
	public byte[] read(long lba, int size) {
		...
	}
}
 
/* Façade */
 
class Computer {
	public void startComputer() {
		cpu.freeze();
		memory.load(BOOT_ADDRESS, hardDrive.read(BOOT_SECTOR, SECTOR_SIZE));
		cpu.jump(BOOT_ADDRESS);
		cpu.execute();
	}
}
 
/* Client */
 
class You {
	public static void main(String[] args) throws ParseException {
		Computer facade = /* grab a facade instance */;
		facade.startComputer();
	}
}

http://en.wikipedia.org/wiki/Adapter_pattern

Object Adapter

http://en.wikipedia.org/wiki/Adapter_pattern

Class Adapter

한 클래스의 인터페이스를 클라이언트에서 사용하고자 하는 다른인터페이스로 변환한다. 어댑터를 이용하면 인터페이스 호환성 문제 때문에 같이 쓸 수 없는 클래스들을 연결해서 쓸 수 있다.

# Python code sample
class Target(object):
    def specific_request(self):
        return 'Hello Adapter Pattern!'
 
class Adapter(object):
    def __init__(self, adaptee):
        self.adaptee = adaptee
 
    def request(self):
        return self.adaptee.specific_request()
 
client = Adapter(Target())
print client.request()

http://ko.wikipedia.org/wiki/%EC%BB%A4%EB%A7%A8%EB%93%9C_%ED%8C%A8%ED%84%B4

커맨드 패턴을 이용하면 요구사항을 객체로 캡슐화 할 수 있다. 매개변수를 써서 여러가지 요구사항을 만들 수도 있다. 또한 요청내역을 큐에 저장하여 로그를 기록하는 것도 가능하고 작업 취소 구현도 가능하다.

/*the Invoker class*/
public class Switch {
    private Command flipUpCommand;
    private Command flipDownCommand;
 
    public Switch(Command flipUpCmd,Command flipDownCmd){
            this.flipUpCommand=flipUpCmd;
            this.flipDownCommand=flipDownCmd;
           }
 
    public void flipUp(){
         flipUpCommand.execute();
    }
 
    public void flipDown(){
         flipDownCommand.execute();
    }
}
 
/*Receiver class*/
 
public class Light{
     public Light(){  }
 
     public void turnOn(){
        System.out.println("The light is on");
     }
 
     public void turnOff(){
        System.out.println("The light is off");
     }
}
 
 
/*the Command interface*/
 
public interface Command{
    void execute();
}
 
 
/*the Command for turning on the light*/
 
public class TurnOnLightCommand implements Command{
   private Light theLight;
 
   public TurnOnLightCommand(Light light){
        this.theLight=light;
       }
 
   public void execute(){
      theLight.turnOn();
   }
}
 
/*the Command for turning off the light*/
 
public class TurnOffLightCommand implements Command{
   private Light theLight;
 
   public TurnOffLightCommand(Light light){
        this.theLight=light;
       }
 
   public void execute(){
      theLight.turnOff();
   }
}
 
/*The test class*/
public class TestCommand{
   public static void main(String[] args){
       Light light=new Light();
       Command switchUp=new TurnOnLightCommand(light);
       Command switchDown=new TurnOffLightCommand(light);
 
       Switch s=new Switch(switchUp,switchDown);
 
       s.flipUp();
       s.flipDown();
   }
}

http://en.wikipedia.org/wiki/Singleton_pattern

객체를 하나만 만들때 사용

참고, 자바에서 volatile 키워드를 사용하면 멀티스레딩을 쓰더라도 uniqueInstance 변수와 singleton인스턴스로 초기화 되는 과정이 올바르게 진행되도록 할 수 있다.

http://en.wikipedia.org/wiki/Abstract_factory

http://en.wikipedia.org/wiki/Factory_method

추상화된 것이 의존하게 만든다.

구상클래스에 의존하게 만들지 않도록 한다.

http://en.wikipedia.org/wiki/Observer_pattern

서로 상호작용을 하는 객체 사이에는 가능하면 느슨하게 결합하는 디자인을 사용해야 한다.

class Observable(object):
  def __init__(self):
    self.__observers = []
  def addObserver(self, obs):
    self.__observers.append(obs)
  def notify(self, *args, **kwargs):
    for o in self.__observers:
      o.update(self, *args, **kwargs)
 
class Observer(object):
  def __init__(self, observable):
    observable.addObserver(self)
  def update(self, observable, *args, **kwargs):
    print 'Got', args, kwargs, 'From', observable
 
source = Observable()
target = Observer(source)
source.notify('test')

http://en.wikipedia.org/wiki/Strategy_pattern

애플리케이션에서 달라지는 부분을 찾아내고, 달라지지 않는 부분으로 부터 분리시킨다.

구현이 아닌 인터페이스에 맞춰서 프로그래밍한다.

상속보다 구성을 활용한다.

/** The classes that implement a concrete strategy should implement this.
* The Context class uses this to call the concrete strategy. */
interface Strategy {
    int execute(int a, int b); 
};
 
/** Implements the algorithm using the strategy interface */
class Add implements Strategy {
    public int execute(int a, int b) {
        System.out.println("Called Add's execute()");
        return a + b;  // Do an addition with a and b
    }
};
 
class Subtract implements Strategy {
    public int execute(int a, int b) {
        System.out.println("Called Subtract's execute()");
        return a - b;  // Do a subtraction with a and b
    }
};
 
class Multiply implements Strategy {
    public int execute(int a, int b) {
        System.out.println("Called Multiply's execute()");
        return a * b;   // Do a multiplication with a and b
    }    
};
 
// Configured with a ConcreteStrategy object and maintains
// a reference to a Strategy object 
class Context {
    private Strategy strategy;
 
    public Context(Strategy strategy) {
        this.strategy = strategy;
    }
    public int executeStrategy(int a, int b) {
        return this.strategy.execute(a, b);
    }
};
 
/** Tests the pattern */
class StrategyExample {
    public static void main(String[] args) {
        Context context;
        // Three contexts following different strategies
        context = new Context(new Add());
        int resultA = context.executeStrategy(3,4);
 
        context = new Context(new Subtract());
        int resultB = context.executeStrategy(3,4);
 
        context = new Context(new Multiply());
        int resultC = context.executeStrategy(3,4);
 
        System.out.println("Result A : " + resultA );
        System.out.println("Result B : " + resultB );
        System.out.println("Result C : " + resultC );
    }
};

    class Program

    {

        private const int MAX = 10;

        private static int[] memo;

        static void Main(string[] args)

        {

            memo = new int[MAX];

            for (int i = 0; i < MAX; ++i)

            {

                memo[i] = MAX - i;

            }

            memo = new int[] { 200, 3, 10, 9, 8, 7, 4, 12, 5, 2 };

            quicksort(0, memo.Count() - 1);

            for (int i = 0; i < MAX; ++i)

            {

                Console.Write(memo[i] + " ");

            }

        }

        static void quicksort(int left, int right)

        {

            if (left < right)

            {

                int pivot = memo[left];

                int i = left + 1;

                int j = right;

                while (i <= j)

                {

                    while (i <= j && memo[i] < pivot)

                    {

                        ++i;

                    }

                    while (i <= j && memo[j] > pivot)

                    {

                        --j;

                    }

                    if (i < j)

                    {

                        int tmp = memo[j];

                        memo[j] = memo[i];

                        memo[i] = tmp;

                    }

                }

                int tmp2 = memo[j];

                memo[j] = pivot;

                memo[left] = tmp2;

                quicksort(left, i - 1);

                quicksort(i + 1, right);

            }

        }

    }

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace Fibo

{

    class Program

    {

        private const int MAX = 512;

        private static decimal[] memo;

        static void Main(string[] args)

        {

            memo = new decimal[MAX];

            for (int i = 0; i < MAX; ++i)

            {

                memo[i] = 0;

            }

            int input = Convert.ToInt32(Console.ReadLine());

            Console.WriteLine(fibo(input));

        }

        static decimal fibo(int idx)

        {

            if (idx == 0)

            {

                return 0;

            }

            else if (idx == 1)

            {

                return 1;

            }

            if (memo[idx] > 0)

            {

                return memo[idx];

            }

            else

            {

                memo[idx] = fibo(idx - 2) + fibo(idx - 1);

                return memo[idx];

            }

        }

    }

}

회귀분석(回歸分析, regression analysis)은 통계학에서 관찰된 연속형 변수들에 대해 독립변수와 종속변수 사이의 상관관계에 따른 수학적 모델인 선형적 관계식을 구하여 어떤 독립변수가 주어졌을 때 이에 따른 종속변수를 예측한다. 또한 이 수학적 모델이 얼마나 잘 설명하고 있는지를 판별하기 위한 적합도를 측정하는 분석 방법이다.

1개의 종속변수와 1개의 독립변수 사이의 관계를 분석할 경우를 단순회귀분석(Simple Regression Analysis), 1개의 종속변수와 여러 개의 독립변수 사이의 관계를 규명하고자 할 경우를 다중회귀분석(Multiple Regression Analysis)이라고 한다.

http://ko.wikipedia.org/wiki/%ED%9A%8C%EA%B7%80%EB%B6%84%EC%84%9D

최근 ubuntu에서 debian으로 갈아탔다. ubuntu 가 처음에 6개월 업데이트라서 최신기능을 빨리 써볼수 있고 유니티 데스크톱이 보기 좋아서 그냥 좋았는데 몇년 쓰다보니 업데이트 될 때마다 문제가 생기곤한다. 그리고 메이저 하드웨어를 사용하지 않는 나로써는 매번 힘들다. 그래서 보수적? 이라고 할 수 있는 debian으로 저번 주말에 설치! 그리고 오늘 node.js 도 설치해보려고 한다.

안정 패키지에 안들어있어서 소스컴파일 하기로했다. 아래 링크 참고,

http://sekati.com/etc/install-nodejs-on-debian-squeeze

간단히 필요한 패키지 설치하고

sudo apt-get update && apt-get install git-core curl build-essential openssl libssl-dev

git에서 최신버전 받은 후

git clone https://github.com/joyent/node.git