Programming is Fun

: 무언가 생각을 하게 하는 글... 전부터 자주 생각하던 내용이기도 한데.. 무언가 여운을 갖기도 하고 과연 내가 사는 것이 이 방법이 맞는 것인지에 대한 여러 생각을 계속해서 하게 하는 글.

모든 건 다 너희들의 삶이다.
그리고 아직 갈길이 먼 너희들에게 정해지지 않은 앞 날이라는게 많이 무섭겠지.
먼지도 모르겠고. 

게다가 너희들은 학교에서 공부만 열심히 하라고 배우지 않았냐? 그럼 성공한다고.
근데 막상 너희가 대학에 들어가자 앞으론 다 너네가 알아서 해야한다고 하자. 
그때부터가 진짜 시작인데 말이다. 

뒤통수를 치는거야. 
얼마나 막막하냐. 

광활한 자유가. 

그래. 너흰 성년이다. 그리고 너희 인생은 너희가 선택해야한다. 
허나 어쩌면 너희들은 너희 스스로가 선택하는 법을 배운적이 없는지도 모른다. 
선택해 본 적이 없으니 누군가 '나는 성공했소. 나는 부자가 되었소' 하는 사람들의 말을 넙죽넙죽 따르는거야. 
좋은 차를 몰고.. 고기만 먹을 것 같은 사람들의 말을.

그 사람들 말이 그렇거든...
열심히 사세요.
목표를 세우고, 
아침에도 일찍 일어나고,
운동도 열심히 하고, 
영어도 하고,
뭣도 하고,
뭣도 하고.......... 다~ 하세요.

그래도 너넨 열심히 따른다. 
아주 열심히. 

때론 열심히 하지 않는 스스로를 경멸도 해가면서.
그렇게 힘든 하루를 말이다. 

왜 일까?? 

그럼 불안하지 않아도 되거든. 
그 무책임한 자유에서 벗어날 수 있거든.

그게 편한거다. 메뉴얼이 있다는게.

잠시 쉬어 청록의 나무를 바라보아라. 
또한 시간은 그리 빠르게 흘러가진 않는다. 
날이 좋지 않느냐.

연어는 자신이 '왜' 상류로 거슬러 올라가는지 알고 있다.
너희들은 너희들만의 '왜'를 알고 있는 것이냐?
반짝이는 이 순간 순간을 정작 너희들은 모르는 것 같아 안타깝구나. 

어떠냐?
터질 것 같이 너흴 뒤흔드는 무언가는 정녕 없었던게냐?

정말로 도둑놈이 정권을 잡았구나.. 하는 생각이 무척 많이 들고 있다. -_-

고등학교때 세금제도에 대해서 배울때, 직접세가 높을 나라들이 대부분 부의 재분배를 잘 하고 있는 복지 국가고, 간접세가 높을 수록 부의 재분배를 잘 못하고 있는 나라로 배웠다.

실예로.. 부가가치세는 복지 제도가 잘 만들어진 나라들의 경우에는 다른 세금의 비율에 비해서 부가가치세가 낮고, 일본의 경우에는 5%밖에 되지 않는다. 왜냐면 이 부가가치세의 경우에는 언제나 모든 물건들마다 붙는 세금이기 때문에, 조금이라도 올리게 되면 바로 모든 경제 인구의 소득이 주는 것과 비슷한 효과를 가지고 오기 때문이다.

우리나라의 부가가치세는 10%. 지금 인상이 추진되고 있는 세금은 12.5%.

부동산 취득세며, 법인세는 깎아주는 마당에 서민들의 삶에 직접적으로 영향을 주는 부가가치세의 인상은 무엇을 의미하는가. -_-

기업들 돈 깎아주면서, 당연히 나올 세수 부족은 모두 국민들에게 깔아서 내라는 이런 정책이 또 다시 나오고 있다.도대체 어떤 국민들이 이런 인간을 뽑아줘서 이런 식으로 일을 몰고가는지 모르겠다는 생각도 들면서.. 민주주의에 대한 회의는 계속되게 만든다. -_-

도대체 누굴 위한 정부이고, 누굴 위한 제도인가...

정말 요즘은 뉴스 보기가 무서운 세상이다. -_- 노원구쪽 집값 올랐다는 이야기들으면서도 가슴 한편이 매우 아프고 말이야.. -_-

'제품으로서의 소프트웨어'에서 '서비스로서의 소프트웨어(SaaS : Software as a Service)'로의 변화는 시대적 대세다. 이로써 고객은 더욱 양질의 서비스를 누릴 수 있고, 공급 업체는 안정적이고 새로운 비즈니스 모델을 확립할 수 있다.

이와 관련, IDC는 전 세계 소프트웨어 유지보수 서비스 매출액이 2008년이면 전체 소프트웨어 매출액 중 56.3%에 이를 것이라는 예측을 내놓은 바 있다. 국내 시장에서도 소프트웨어 지원 서비스(Support) 시장은 하드웨어 지원 서비스 시장의 연평균 성장률 5.4%보다 높은 9.1%의 성장률을 보이며 성장할 것이라고 전망했다.

하지만, 우리나라의 패키지 소프트웨어 업체의 전체 소프트웨어 사업 금액 중 유지보수(Maintenance & Support) 사업 금액의 비중은 21%. 이는 51%인 미국의 절반도 안 되는 수준이다. 심지어 공공 부문의 유지보수 사업은 소프트웨어 사업 수주 금액 대비 17%에 불과해 더 낮은 수준인 것으로 나타났다.

이 같은 조사는 한국소프트웨어진흥원이 2004년에 발표한 <패키지 SW 유지보수 서비스 실태 조사>자료에 따른 것으로, 2006년인 현재에도 이러한 상황이 크게 달라지지 않았다는 것이 업계의 공통된 시각이다.

유지보수율이 제자리를 찾지 못하는 한, 질높은 서비스도 요원할 것이다. 인식의 전환과 더불어 합리적인 기준을 적용한 유지보수 서비스를 하루빨리 시행해야 할 까닭이다.

1. 팀원을 존중하고, 피드백을 주고 코칭을 하는 사람

2. 팀원에게 적절한 권한위임을 하는 사람

3. 바라는 결과를 명확히 알려주는 사람

4. 방법보다는 결과에 초점을 맞추는 사람

5. 실수했다는 것을 인정하는 사람

6. 팀원의 경력개발을 지원하는 사람

7. 팀원의 변화와 공헌을 알아차리고 감사하는 사람

8. 감정의 폭발에 반응하기 보다는 사건에 대응하는 사람

9. 조직의 상층부에 영향력을 행사할 수 있는 사람

10. 자기 자신을 관리하는 사람

http://610.or.kr/museum/bbs/sub03e_000.html

예전부터 정치에도 관심이 많았고, 하는 지금 일 모두가 결국은 민주주의의 완성 아닌가.. 라는 생각이 드는 방법론들이 많이 나오는 이때에.. http://color.egloos.com/ 이곳 방문 했다가 업어온 글.

2MB의 당선. 그리고 지금 백골단의 부활. 우리나라의 역사의 수레바퀴는 어디로 굴러가고 있는 것일까.

1960년대 한창 학생운동이 미국 대학가를 휩쓸고 있을 때였다.

하버드 법대의 한 학생이 졸업식에서 다음과 같은 연설을 했다.

"지금 우리나라는 혼란의 도가니에 빠져있다.

 대학가는 반란과 난동을 부리는 학생들로 가득 차 있으며 공산주의자들은 이 나라를 파괴하기 위해 열을 올리고 있다.

 위험이 도처에 도사리고 있지 않은가. 내부의 적과 외부의 적이 들끓고 있는 것이다.

 그렇다. 우리나라에게는 법과 질서가 필요하다. 법과 질서가 없다면 이 나라는 생존할 수 없다."

 우뢰와 같은 박수가 터져 나왔고 그것은 한참이나 그칠 줄 몰랐다.

 시국이 어수선한 중에도 하버드 법대 졸업생의 소신에 찬 뜨거운 졸업사라는 반응이었다.

 박수가 가라앉을 무렵 이 학생은 조용한 어조로 말을 이어나갔다.

 "방금 한 말은 1932년 아돌프 히틀러의 연설 내용이었다."

ps : 사실인지 아닌지는 모름.;;  

require 'test/unit'
class JollyJumper

  attr_reader :values

  

  def initialize

    @values = []

  end

  

  def insert_value(value)

    @values << value

  end

  

  def print_values

    @values.each{ |value| print value.to_s + ' ' }

  end

  

  def calculate

    result = true

    @values.each_index do |index| 

      first_value = (@values[index -1] - @values[index]).abs if @values[index-1] != nil

      second_value = (@values[index +1] - @values[index]).abs if @values[index+1] != nil    

      result &= values.member?(first_value) if first_value != nil

      result &= values.member?(second_value) if second_value != nil

    end

    result

  end  

end
class JollyJumperTest < Test::Unit::TestCase

  def test_case1

    jumper = JollyJumper.new

    assert_not_equal(nil, jumper)

    jumper.insert_value(4)

    jumper.insert_value(1)

    jumper.insert_value(4)

    jumper.insert_value(2)

    jumper.insert_value(3)    

    jumper.print_values()

    assert_equal(true, jumper.calculate)

  end

  

  def test_case2

    jumper = JollyJumper.new

    assert_not_equal(nil, jumper)

    jumper.insert_value(5)

    jumper.insert_value(1)

    jumper.insert_value(4)

    jumper.insert_value(2)

    jumper.insert_value(-1)    

    jumper.insert_value(6)    

    jumper.print_values()

    assert_equal(false, jumper.calculate)

  end

  

end

import unittest

import os

import math
segment_enables = [

[True, True, True, False, True, True, True],

[False, False, True, False, False, True, False],

[True, False, True, True, True, False, True],

[True, False, True, True, False, True, True],

[False, True, True, True, False, True, False],

[True, True, False, True, False, True, True],

[False, True, False, True, True, True, True],

[True, True, True, False, False, True, True],

[True, True, True, True, True, True, True],

[True, True, True, True, False, True, True]

]


class SevenSegmentNumber:

    def __init__(self, number, size):

        self.size = size

        self.number = number

        self.max_line = size * 2 + 3

     

    def printHorizontalLine(self, print_enable):

        lines = ' '

        for i in range(self.size):

            if print_enable:

                lines = lines + '-'

            else:

                lines = lines + ' '

        lines = lines + ' '

        return lines

    

    def printVerticalLine(self, print_first, print_last):

        lines = ''

        vert_size = self.size  + 2 

        if print_first:

            lines = lines + '|'

        else:

            lines = lines + ' '

        

        for i in range(vert_size - 2):

            lines = lines + ' '
        if print_last:

             lines = lines + '|'

        else:

             lines = lines + ' '        

        return lines   

    

    

    def getLine(self, line):

        total_line = self.size * 2 + 3

        line_segment = (total_line - 3) / 2 + 1

        line_end = total_line - 1        

        out_line = ''       

        if line == 0:

            out_line = self.printHorizontalLine(segment_enables[self.number][0])

        elif 0 < line and line < line_segment:

            out_line = self.printVerticalLine(segment_enables[self.number][1], segment_enables[self.number][2])

        elif line == line_segment:

            out_line = self.printHorizontalLine(segment_enables[self.number][3])

        elif line_segment < line and line < line_end:

            out_line = self.printVerticalLine(segment_enables[self.number][4], segment_enables[self.number][5])

        elif line == line_end:

            out_line = self.printHorizontalLine(segment_enables[self.number][6])

        return out_line
class Numbers:    

    def __init__(self):

        self.numbers = []

        self.seven_segments = []
    def displayNumber(self, number, size):

        decimal = int(math.log(number) / math.log(10)) + 1

        self.numbers = []

        self.seven_segments = []

        

        for i in range(decimal):

            self.numbers.append(int(str(number)[i]))

            segment = SevenSegmentNumber(self.numbers[i], size)

            self.seven_segments.append(segment)

        

        max_line = self.seven_segments[0].max_line

        for i in range(max_line):

            line = ''

            for s in range(decimal):

                line = line + self.seven_segments[s].getLine(i) + ' '

            print line

        
class SevenSegmentNumberTest(unittest.TestCase):

    """

    def testDisplay(self):

        print 'Start'

        zero = SevenSegmentNumber(8, 3)

        

        for i in range(zero.max_line):

            print zero.getLine(i),

            print ""

    """

    def testNumber1(self):

        number = SevenSegmentNumber(8, 2)

        #print number.getLine(0)

        #self.assertEqual(number.max_line, 3 + 2 * 2)

        #self.assertEqual('    ', number.getLine(0))

        #self.assertEqual('   |', number.getLine(1))

        

        #for i in range(0, number.max_line):

        #    print number.getLine(i)

    

    def testOutputNumber(self):

        for i in range(10):

            number = SevenSegmentNumber(i, 2)

            for j in range(number.max_line):

                print number.getLine(j)

       

if __name__ == '__main__':

    #unittest.main()

    n = Numbers()

    n.displayNumber(1238, 3)

require 'test/unit'
class SevenSegment

    attr_reader :number, :size, :height, :width

    attr_writer :number, :size 

    

    @@segment_enables = [ 

            [true, true, true, false, true, true, true],

            [false, false, true, false, false, true, false],

            [true, false, true, true, true, false, true],

            [true, false, true, true, false, true, true],

            [false, true, true, true, false, true, false],

            [true, true, false, true, false, true, true],

            [false, true, false, true, true, true, true],

            [true, true, true, false, false, true, false],

            [true, true, true, true, true, true, true],

            [true, true, true, true, false, true, true] ]

    

    def initialize(number, size)

        @number = number

        @size = size

        @height = size * 2 + 3

        @width = size + 2

    end

    

    def get_vertical_line(mark_first, mark_second)

        line = ''

        length = @size + 2

         

        line = line + '|' if mark_first

        line = line + ' ' if !mark_first
        @size.times { line = line + ' ' }

        

        line = line + '|' if mark_second

        line = line + ' ' if !mark_second

        line        

    end

    

    def get_horizontal_line(enable)        

        mark = ''

        mark = '-' if enable

        mark = ' ' if !enable

        length = self.size + 2
        line = ' '

        @size.times { line = line + mark }

        line = line + ' '

        line

    end

     

    def get_line(line_count)

        if line_count == 0 then self.get_horizontal_line(@@segment_enables[@number][0])

        elsif line_count > 0 and line_count < (@size+1) then self.get_vertical_line(@@segment_enables[@number][1], @@segment_enables[@number][2])

        elsif line_count == (@size+1) then self.get_horizontal_line(@@segment_enables[@number][3])

        elsif line_count > (@size+1) and line_count < (@size * 2 + 2) then self.get_vertical_line(@@segment_enables[@number][4], @@segment_enables[@number][5])            

        elsif line_count == (@size * 2 + 2) then self.get_horizontal_line(@@segment_enables[@number][6])                    

        end

    end    

end
class SevenSegments

    attr_reader :numbers, :size

    attr_writer :numbers, :size

    

    def initialize(size, number)

        @size = size

        self.set_number(number)

    end
    def set_number(number)

        @numbers = []

        string_numbers = number.to_s()

        string_numbers.length.times { |index| @numbers << string_numbers[index] - 48 }

    end
    def display_number

        puts ' ' 

        seven_segments = []

        @numbers.each { |n| seven_segments << SevenSegment.new(n, @size) }

        line = @size * 2 + 3
        line.times do |line_count| 

            line = ''

            seven_segments.each do |seven_segment|

                line = line + seven_segment.get_line(line_count) + ' '

            end

            puts line 

        end

        

    end

end
class SevenSegmentsTest < Test::Unit::TestCase

    def test_numbers

        s = SevenSegments.new(3, 987654321)

        print s.numbers[0]        

        s.display_number

        assert_equal(9, s.numbers[0])

    end

end
class SevenSegmentTest < Test::Unit::TestCase

    def test_number0

        s = SevenSegment.new(0,2)

        assert_equal(" -- ", s.get_line(0))

        assert_equal("|  |", s.get_line(1))

        assert_equal("|  |", s.get_line(2))

        assert_equal("    ", s.get_line(3))

        assert_equal("|  |", s.get_line(4))

        assert_equal("|  |", s.get_line(5))

        assert_equal(" -- ", s.get_line(6))

    end
    def test_number1

        s = SevenSegment.new(1,2)

        assert_equal("    ", s.get_line(0))

        assert_equal("   |", s.get_line(1))

        assert_equal("   |", s.get_line(2))

        assert_equal("    ", s.get_line(3))

        assert_equal("   |", s.get_line(4))

        assert_equal("   |", s.get_line(5))

        assert_equal("    ", s.get_line(6))

    end

     

    def test_number8

        s = SevenSegment.new(8,2)

        assert_equal(" -- ", s.get_line(0))

        assert_equal("|  |", s.get_line(1))

        assert_equal("|  |", s.get_line(2))

        assert_equal(" -- ", s.get_line(3))

        assert_equal("|  |", s.get_line(4))

        assert_equal("|  |", s.get_line(5))

        assert_equal(" -- ", s.get_line(6))

        

    end

end

import unittest

class TheTrip:
    def __init__(self, count):
        self.count = count
        self.costs = []
        pass
    def inputCost(self, cost):
        self.costs.append( float(cost * 100) )
    def calculateAverageCost(self):
        return float( sum(self.costs) / len(self.costs) ) / 100.00
    def calculateMinCharge(self):
        average = self.calculateAverageCost() * 100.00
        diff_values = []
        for value in self.costs:
            differ = average - value
            diff_values.append(abs(differ))
        return sum(diff_values) / 2.00 / 100.00

class TheTripTest(unittest.TestCase):
    def setUp(self):
        pass
    def testInsertValue(self):
        t = TheTrip(3)
        t.inputCost(10.00)
        t.inputCost(20.00)
        t.inputCost(30.00)
        self.assertEqual(20.00, t.calculateAverageCost())
        self.assertEqual(10.00, t.calculateMinCharge())
    def testInsertValue2(self):
        t = TheTrip(4)
        t.inputCost(15.00)
        t.inputCost(15.01)
        t.inputCost(3.00)
        t.inputCost(3.01)
        self.assertEqual(11.99, t.calculateMinCharge())
if __name__ == '__main__':
    unittest.main()

require 'test/unit'

class TheTrip
attr_reader :member, :costs, :average
attr_writer :member, :costs

    def initialize(number)
        self.member = number
        self.costs = []
    end

    def input_cost(cost)
        self.costs << cost
        @average = 0
        self.costs.each {|value| @average += value }
        @average /= self.costs.length
    end

    def get_min_charge()
        charges = 0.00
        self.costs.each { |value| charges += (value - self.average).abs }
        return charges / 2.00
    end
    
end

class TheTripTest < Test::Unit::TestCase
    def test_case1
        t = TheTrip.new(3)
        t.input_cost(10.00)
        t.input_cost(20.00)
        t.input_cost(30.00)
        assert_equal(20.00, t.average)
        assert_equal(10.00, t.get_min_charge())
    end

    def test_case2
        t = TheTrip.new(4)
        t.input_cost(15.00)
        t.input_cost(15.01)
        t.input_cost(3.00)
        t.input_cost(3.01)
        assert_equal(11.99, t.get_min_charge())
    end
end