Lectures/IA/2017

From MCLab
Jump to: navigation, search

Contents

인터넷응용(캡스톤디자인) Class Overview

평가

  • Quiz/Coding Test (20%)
  • 과제물 (75%)
    Lab Reports - 매회 10점 만점
    Programming Assignments - 매회 20점 만점 (난이도에 따라 조정될 수 있음)
    Team Project - 300점 만점 (팀 80% + 개인공헌도 20%)
    개인및 조별과제(Pair Programming Project), 실습과제, Team Project, Quiz/Coding Test는 실기로 각 1회 실시
  • 출석 (5%)

조교

박경수, phone : 010-2592-0887, ks08_18@naver.com, 공대 425호

공지사항

과제물 제출요령
별도의 명기 없으면 PDF 파일로 e-class에 제출하세요. (보통 강의 전날 자정에 마감됨)
A+, A0, ...D0, F 로 평가되며, 10점 만점 점수로 환산하면 10, 9, ..., 3, 0 (미제출인 경우 F)
주의사항-지각제출을 허용하지 않습니다.

Coding Exam

추후공지

2인 1조 Pair Project

Programming Assignment 중에는 난이도에 따라 2인 1조로 과제 조를 구성하여 수행할 수 있습니다.

프로젝트 팀 구성

5인 1팀으로 프로젝트 팀을 구성하라. 자세한 사항은 e-class 팀프로젝트 참조하여 등록한다.

강의자료

Introduction to Python Programming

Python, IDE Install
  1. OS별 설치(2.7x version을 설치
  2. Python IDE(Pycharm Free Community version)설치
    Python에 앞서서
Handouts
  1. Python Programming - Part I
  2. Python Programming - Part II
  3. Python Programming - Part III
참고자료
  1. Computer Networks Chapter 2 Application Layer
  2. Appendix B. Reference Tables in Core Python Application Programming
  3. Python 2 vs Python 3
On-line Books
  1. Allen Downey, Think Python, O'Reilly. On-line free book, 한글 번역판 (편집 중)
  2. 점프 투 파이썬
  3. 왕초보를 위한 Python 2.7
On-line Tutorials
  1. Python Tutorial, tutorialspoint http://www.tutorialspoint.com/python/index.htm
    PDF version
  2. Official Tutorial https://docs.python.org/2/tutorial/index.html
Manual

Advanced Python Programming

Handouts
  1. Tkinter GUI
  2. Useful Modules, 한글처리
  3. Regular Expressions
Unit Testing with Python

HTML5, CSS, Javascript

모던웹 표준 HTML5와 반응형 웹의 구조 및 사용에 대한 지식을 습득하고 활용방안에 대해서 Pair Project를 진행합니다. 참고 site: http://www.w3schools.com/html/default.asp

Web Application: Server-side Programming

Handout
  1. Web Application Programming in WSGI
    Download Web App Examples
Web
Web Applications

Django Framework

준비사항 - 미리 install하세요.
Download and install django
Django REST framework QuickStart http://www.django-rest-framework.org
동영상 강의 참조
강의자료
DjangoFramework

Python Network Programming

Handout
  1. Network Programming - Introduction
    download Lab. NP - Introduction (ZIP)
  2. Client-side Programming
    download Lab. Clients
  3. Threads
    download Lab. Threading
  4. Server-side Programming - updated in 5/25/2016
  5. SQL Database Interfaces
참고 자료

소스형상관리

Bitbucket-SourceTree
Android 개발이슈

Socket API and UNIX Network Programming in C

Handouts
UNIX Network Programming (PDF)
참고자료
POSIX Thread Programming, https://computing.llnl.gov/tutorials/pthreads/
Multithreaded Programming, http://randu.org/tutorials/threads/

Python Books and Sites

실습/숙제/팀프로젝트 환경

Lab Step. One

stringtest.py
a = 'test string'
b = 180
c = 3.141592

print a, b, c

#We can make print format
print "output is below : \n a={0} \n b={1} \n c={2}".format(a,b,c)
print "\n\n"

#We can check variable type
print "variable type is :\n a={0} \n b={1} \n c={2}".format(type(a), type(b), type(c))

stringtest.py 계속
# -*- coding: utf-8 -*-
text = "mclab_test_string"

#length
print "text_length : {0}".format(len(text))

#slicing
#last character
print "last cahracter is {0}".format(text[len(text) - 1])

#print every single character in text variable
def print_using_while_textvariable():
    index = 0
    while index < len(text):
        single = text[index]
        print single
        index = index + 1

print_using_while_textvariable()

def print_using_for_textvariable():
    for l in text:
        print l

print_using_for_textvariable()

#slicing for forward
#it's very different to what we're used to index in array
print "indexing vs slicing  : {0} vs {1}, ???{2}".format(text[2], text[1:2], text[2:2])

functiontest.py
# -*- coding: utf-8 -*-
a = '32' #String Variable
b = int(a)

print "a = {0}, type : {1} --> b = {2}, type : {3}\n\n".format(a, type(a), b, type(b))

b = float(a)
print "a = {0}, type : {1} --> b = {2}, type : {3}\n\n".format(a, type(a), b, type(b))

c = str(b)
print "b = {0}, type : {1} --> c = {2}, type : {3}\n\n".format(b, type(b), c, type(c))


import math

signal_power = 30.0
noise_power = 11.2
ratio = signal_power/noise_power
decibels = 10 * math.log10(ratio)
print "decibels : {0}\n\n".format(decibels)


def print_string():
    print "Did you have launch?"
    a = 10
    b = 20
    print "In print_string function : {0}\n\n".format(a+b)

print_string()

#Are u understanding local variable?
def print_sum(lvalue, rvalue):
    output = lvalue + rvalue
    return output

print "Printing print_sum() : {0}\n\n".format(print_sum(10,20))

#conditional
def print_conditional_exec(x):
    if x > 0:
        print 'x is positive number'
    else:
        print 'x is negative number'

print_conditional_exec(10)

#recursive function
def countdown(n):
    if n <= 0:
        print 'fire!!'
    else:
        print n
        countdown(n-1)

countdown(10)

containertest.py
# -*- coding: utf-8 -*-
#list
a = [1, 2, 3]
b = [4, 5, 6]
c = a+b  #what's happen?

print "list is : {0}\n\n".format(c)
print "list is : {0}\n\n".format(c*2) #repeat

#list slicing
test_list = ['a', 'b', 'c', 'd', 'e'] 
print "print until c : {0}".format(test_list[:3])
print "print behind c : {0}".format(test_list[-2:])

test_list.reverse() 
print "print reverse list {0}".format(test_list)


#list : append list value

def list_append(source_list):
    rlist = []
    for l in source_list:
        rlist.append(l)
    return rlist

source_list = ['mclab', 'list', 'test']
print "print list : {0}".format(list_append(source_list))

#delete value in list
print "print list : {0}".format(source_list.pop(1)) #return removed element
print "print list : {0}".format(source_list)

del source_list[1]
print "print list : {0}".format(source_list)

source_list.remove('mclab')
print "print list : {0}".format(source_list)


#make list from String split
test_str = "mclab test string"
test_list = test_str.split()
print "print list : {0}".format(test_list)

#make list using delimiter in string
test_str = "mclab:test:string"
test_list = test_str.split(':')
print "print list : {0}".format(test_list)


#python is use heap memory
alist = [1, 2, 3]
b = alist
print b is alist
b[2] = 10
print "alist = {0}, blist = {1}".format(alist, b)


#dictionary
dic = dict()
print dic #{} is dictionary

dic['one'] = 'mclab'
print dic

dic = {'one':'mclab', 'two':'test', 'three':'dic'}
print dic  #key ordering is ??????
print dic['one']
jsontest.py
# -*- coding: utf-8 -*-
import json
jsonDic = {
    'id': 200632090,
    'name': 'mkhan',
    'history': [
        {'date': '2015-03-11', 'item': 'iPhone'},
        {'date': '2016-02-23', 'item': 'Monitor'},
    ]
}
jsonString = '{"name": "mkhan", ' \
              '"id": 200632090, ' \
              '"history": [{"date": "2016-03-11", "item": "iPhone"}, {"date": "2017-02-23", "item": "Monitor"}]}'

#json Encncoding
x = json.dumps(jsonDic)
print x
print type(x)

n = json.dumps(jsonDic, indent=4)
print n

#jSON Decoding
dict = json.loads(jsonString) 
print dict['name']
for h in dict['history']:
    print h['date'], h['item']


classtest.py
# -*- coding: utf-8 -*-

Target :
1. class 이해하기
2. class는 무엇으로 구성되어 있는가?
3. 객체란 무엇인가


#Step 1: non-property(getter, setter)

class Duck1():
    def __init__(self,input_name):
        self.hidden_name = input_name

    def get_name(self):
        print('inside the getter')
        return self.hidden_name

    def set_name(self, input_name):
        print('inside the setter')
        self.hidden_name = input_name

if __name__ == '__main__':
    obj = Duck1('test1')
    obj.get_name()
    print obj.hidden_name



#Step 2: property & new type class

class Duck2(object):
    def __init__(self,input_name):
        self.hidden_name = input_name

    @property
    def name(self):
        print('inside the getter')
        return self.hidden_name

    @name.setter
    def name(self, input_name):
        print('inside the setter')
        self.hidden_name = input_name


if __name__ == '__main__':
    obj = Duck2('test2')
    temp = obj.name
    print "1. {0}".format(temp)

    obj.name = 'test3'
    temp = obj.name
    print "2. {0}".format(temp)
    print obj.hidden_name #we can direct accessing


#Step 3: private naming convention & mangling

class Duck3(object):
    def __init__(self,input_name):
        self.__hidden_name = input_name

    @property
    def name(self):
        print('inside the getter')
        return self.__hidden_name

    @name.setter
    def name(self, input_name):
        print('inside the setter')
        self.__hidden_name = input_name


if __name__ == '__main__':
    obj = Duck3('test2')
    temp = obj.name
    print "1. {0}".format(temp)

    obj.name = 'test3'
    temp = obj.name
    print "2. {0}".format(temp)
    print obj.__hidden_name #we can direct accessing



#method type in class (instance method, class method)
class Duck4(object):
    __wing = False #private bool type
    __legs = 4 #public
    count = 0

    def __init__(self,input_name):
        self.__hidden_name = input_name
        #self.count += 1
        Duck4.count += 1

    @property
    def name(self):
        print('inside the getter')
        return self.__hidden_name

    @name.setter
    def name(self, input_name):
        print('inside the setter')
        self.__hidden_name = input_name

    @property
    def wing(self):
        if self.__wing == True:
            print "{0} is flying".format(self.__hidden_name)
        else:
            print "{0} isn't flying".format(self.__hidden_name)

        return self.__wing

    @wing.setter
    def wing(self, wing):
        self.__wing = wing

    @property
    def legs(self):
        return self.__legs
 
    @legs.setter
    def legs(self, legs):
        self.__legs = legs


    @classmethod
    def info(cls):
        print "It was created {0}\n".format(cls.count)


if __name__ == '__main__':
    obj1 = Duck4('test2')
    obj1.wing = True
    obj1.legs = 4
    Duck4.info()

    obj2 = Duck4('test3')
    obj2.wing = False
    obj2.legs = 1
    Duck4.info()

    obj1.info()
    obj2.info()


Lab Test for Step. One

Lab #1, Test String Slicing
 source_text = "did you have launch", find_char = "l"
 1. 상기 두 파라미터를 입력받은 후 find_char를 찾는 function을 구성하세요
 2. 상기 두 파리미터를 입력받은 후 find_char가 source_text에서 몇번 나오는지 출력하세요.
Lab #2, Test String Slicing
text = 'mclab_test_string'
상기 text의 문자열을 다음과 같이 출력해보세요
        s
       est
      test_
     _test_s
    b_test_st
   ab_test_str
  lab_test_stri
 clab_test_strin
mclab_test_string
Lab #3, 홀수와 짝수를 판별하도록 바꿔보세요
Lab #4, 두 정수 값을 입력 받고 그 크기를 비교하여, 작다, 크다, 같다 를 프린팅 하는 함수를 만들어 실행해보세요
sample is below, 
def print_conditional_exec(x):
    if x > 0:
        print 'x is positive number'
    else:
        print 'x is negative number'
print_conditional_exec(10)


Lab #5 상기 countdown()의 내부로직을 for loop 과 while loop 으로 수정하세요
Lab #6 상기 lab에서 100을 입력받으로 받고 50까지 countdown이 되었을 경우 loop을 탈출시켜보세요(break)
sample is below,
def countdown(n):
    if n <= 0:
        print 'fire!!'
    else:
        print n
        countdown(n-1)
countdown(10)
Lab #7
source_string = "mclabtestdictionary" 에서 각각의 케릭터가 몇번 나오는지 dictionary를 이용해 출력하시오
output format { 'm':1, 'c':2, ...}

Lab Step. Two(Advanced)

step_up.py
# -*- coding: utf-8 -*-
#Slicing

[:] 처음부터 끝까지 전체 시퀀스 추출
[start:] start 오프셋부터 끝까지 시퀀스를 추출한다
[:end] 처음부터 (end-1) 오프셋까지 시퀀스를 추출한다
[start:end] start 오프셋부터 (end - 1) 오프셋까지 시퀀스를 추출한다
[start:end:step] step만큼 인덱스를 건너뛰면서, start 오프셋부터 (end -1)오프셋까지 시퀀스를 추출한다
:: ---> step keyword

testString = "abcdedfghigjklmnopqrstuvwxyz"

test1 = testString[::7]
print 'print test1:',test1

#abcd
test2 = testString[:4]
print 'print test2:', test2

test3 = testString[4:20:3]
print 'print test3:',test3

test4 = testString[2::4]
print 'print test4:',test4

test5 = testString[:21:5]
print 'print test5:',test5

#back step
test6 = testString[::-1]
print 'print test6:',test6
 


#find string
testString2 = ios programming,
the Big 'Nerd' Ranch Guide

print testString2
word = 'Nerd'
print testString2[testString2.find(word)+len(word) : testString2.rfind(' Guide')]
print 'word count',testString2.count('m') #python은 object.count()로 ()안의 item 개수가 몇개인지 알 수 있습니다


#replace string
testString3 = 'your name is james'
print 'replace string : ', testString3.replace('james', 'simpson')



#List
alist = [1, 'a', 2, 'b']
blist = [3, 'c', 'd', 'e']

ablist = alist + blist
print 'ablist : ',ablist

clist = [alist, blist]
print 'clist : ', clist
print 'print row 1 in clist', clist[0]
print 'print row 2 in clist', clist[1]
print 'print 2 row, 3 col value :', clist[1][2]


#reference vs copy
a = [1, 2, 3]
b = a
print a, b
a[0] = 'suprise'
print a, b

d = [1, 2, 3]
e = list(d)
f = d[:]
d[0] = 'suprise'
print d, e, f

#tuple is  constant value list
aTuple = '1', '2', '3',
print aTuple
bTuple = ('1', '2', '3',)
print bTuple

def tupleTest(a, b, c):
    a += 'test_a'
    b += 'test_b'
    c += 3

    return a, b, c

print tupleTest('a', 'b', 10)
x, y, z = tupleTest('a', 'b', 10)
print x, y, z

#Using set
#집합을 생각해보세요 정의를 A는 {1, 2, 3, 4 ..}를 포함한다 등의 생각이나죠
#즉 그럼 A와 B의 교집합 여집합 등에 대한 것도 표현할 수 있겠군요...
#set은 홀로 쓰이기가 힘드니... 예를 보면서 익혀보죠 ...
#dict와 혼동하지 마세요...
drinks = {
    'martini':{'vodka', 'vermouth'},
    'black russian':{'vodka', 'kahlua'},
    'white russian':{'cream', 'kahlua', 'bitters'},
    'screwdriver':{'orange juice', 'vodka'}
}

print "\n\n\n\n\n\n\n\n\n"
print "I want a drink with vodka"
for name, contents in drinks.items(): #여기서 우리가 알 수 있는것은?
    if 'vodka' in contents:
        print name

print "\n\n\n\n\n"
print "without vermouth, cream"
for name, contents in drinks.items():
    if 'vodka' in contents and not ('vermouth' in contents or 'cream' in contents):
        print name


print "\n\n\n\n\n"
print "without vermouth, cream"
for name, contents in drinks.items():
    if 'vodka' in contents and not contents & {'vermouth', 'cream'}:
        print name

bruss = drinks['black russian']
wruss = drinks['white russian']

print 'intersection is below:'
print bruss.intersection(wruss)
print bruss & wruss

print 'union is below:'
print bruss.union(wruss)
print bruss | wruss

print 'differnece(차집합)'
print bruss.difference(wruss)
print bruss - wruss
 
print 'symmetric_defference(대칭차집합) 상대에 비해 나만 가지고 있는 요소'
print bruss.symmetric_difference(wruss)
print bruss ^ wruss
 
#List & tuple & parallel looping(using zip)
days = ['Monday', 'Tuesday', 'Wednesday']
fruits = ['banna', 'orange', 'peach']
drinks = ['coffee', 'tea', 'beer']
desserts = ['tiramisu', 'ice cream', 'pie', 'pudding']

for day, fruit, drink, dessert in zip(days, fruits, drinks, desserts):
    print day, "-", drink, "-", fruit, "-", dessert
 
 
#comprehension-----------------------------------------------
#List Comprehension
#format : [표현식 for 항목 in 순회 가능한 객체]
#         [표현식 for 항목 in 순회 가능한 객체 if 조건]

number_list = [number for number in range(1,6)]
print number_list

#print odd list
number_odd_list = [ item for item in range(1, 6) if item % 2 == 1]
print number_odd_list


#dictionary Comprehension
#{키표현식 : 값표현식 for 표현식 in 순회 가능한 객체}
word = 'letters'
letter_counts = {letter:word.count(letter) for letter in word}
print letter_counts

#tuple은 comprehension이 없습니다


#special def(function) argument

In C Programming
int main(int argc, char **argv);
argc refers to the number of command line arguments passed in, which includes the actual name of the program,
as invoked by the user.  argv contains the actual arguments, starting with index 1. Index 0 is the program name.

So, if you ran your program like this:
./program hello world

Then:
argc would be 3.
argv[0] would be "./program".
argv[1] would be "hello".
argv[2] would be "world".


 
def print_args(*args):
    print args
    print args[0], args[1], args[2]

a = [1,2,3]
b = [1,2]
c = [1]
print_args(a, b, c)


#Internal Function & Closure & Lambda
#first-class citizen
print "********* First-Class Citizen is below *********"
def square(x):
    return x*x

print square(5)
f = square

print square
print f

print "Is 'f' function?"
print f(5) #We can know about python is support first-class citizen


print "**** first-citizen test #1"
def square1(x):
   return x*x

def reuse_square(func, arg_list):

    result = []
    for i in arg_list:
        result.append(func(i)) 

    return result
num_list = [1, 2, 3, 4, 5]
squares = reuse_square(square1, num_list)
print "reuse_square results : ",squares



print "same function is above"
snum_list = [1,2,3,4,5]

def simple_square(arg_list):
    result = []
    for i in arg_list:
        result.append(i*i)
    return result

simple_squares = simple_square(snum_list)
print "simple squares : ", simple_squares


print "**** first-citizen test #2"
def xsquare(x):
    return x*x

def xcube(x):
    return x*x*x
def xquad(x):
    return x*x*x*x

def xwrapped_function(func, arg_list):
    result = []
    for i in arg_list:
        result.append(func(i))
    return result

xnum_list = [1, 2, 3, 4, 5]

xsquares = xwrapped_function(xsquare, xnum_list)
xcubes = xwrapped_function(xcube, xnum_list)
xquads = xwrapped_function(xquad, xnum_list)

print xsquares
print xcubes
print xquads


print
print
print
print "********* inner function & Closure *********"

Closure -----------------

In programming languages, closures (also lexical closures or function closures) are techniques
for implementing lexically scoped name binding in languages with first-class functions. 
Operationally, a closure is a record storing a function[a] together with an environment:
a mapping associating each free variable of the function (variables that are used locally, but defined in an enclosing scope)
with the value or reference to which the name was bound when the closure was created.

A closure—unlike a plain function—allows the function to access those captured variables through the closure's copies of their values
or references, even when the function is invoked outside their scope.



def outer_func():
    message = 'Hi'

    def inner_func():
        print "caller 'outer_func()' : ", message

    return inner_func()

outer_func()

print
print
print


def outer_func1():
    message = 'Hi'

    def inner_func1():
        print "caller 'outer_func1()' : ", message

    return inner_func1  # <-- ()가 빠진것에 주의하세요.

print "execute outer_func1() : "
outer_func1()
#왜 아무결과도 안보일까요? 결과를 보려면?


print
print
print

print "type of outer_func1(): ", type(outer_func1())
xfunc = outer_func1()
print xfunc
xfunc()
print "analysis closure---------------------"
print xfunc
print
print dir(xfunc) #dir은 객체가 자체적으로 가지고 있는 변수나 함수를 보여줍니다
print
print type(xfunc.__closure__)
print
print xfunc.__closure__[0]
print
print dir(xfunc.__closure__[0])
print
print xfunc.__closure__[0].cell_contents

#HTML Contents making
def outer_func_make_tag(tag):
    text = 'write something'
    tag = tag

    def inner_func():
        print '<{0}>{1}<\{0}>'.format(tag, text)

    return inner_func

h1_func = outer_func_make_tag('h1')
p_func = outer_func_make_tag('p')

h1_func()
p_func()


def outer_func_make_tag2(tag):
    text = 'write something'
    tag = tag

    def inner_func2(text):
        print '<{0}>{1}<\{0}>'.format(tag, text)

    return inner_func2

h1_func = outer_func_make_tag2('h1')
p_func = outer_func_make_tag2('p')

h1_func('h1 tag안에 있는 정보입니다.')
p_func('p tag안에 있는 정보입니다')

About File Handling
About Lambda Function

Lab. To display Linux GUI on Windows

  1. Download and install Xming X Server for Windows, https://sourceforge.net/projects/xming/
    Xming server를 background로 실행
  2. Download and Install XShell 5, Xftp, https://www.netsarang.com/download/free_license.html
    XShell에서 등록정보>연결>터널링에서 X11 전달... 체크, X DISPLAY 선택
    XShell에서 gedit, idle 등 GUI application 실행이 가능하게 된다.

Programming Assignments

PA-1. Calculator Impl. (3/27까지)

Step 1 : 두 값을 입력받고,계산기의 기능 또한 입력받는다 Input(value1, value2, mode = [+, -, *, / ]
출력은 계산된 값을 디스플레이 합니다
필수 : loop을 돌면서 출력 값이 화면에 디스플레이 된 후 다시 입력 받을 수 있게 합니다
참고 : 유저가 두 개의 값을 입력받도록 User interface를 만들 것
Step 2 : 계산기를 사용하는 사람이 n명입니다. n명이 계산한 History를 dictionary로 관리 할 수 있게 수정하세요
dictionary에서는 다음과 같이 기록합니다.
{
   'user1_name':[value1,value2,mode=[+,-,*, /], datetime], 
   'user2_name':[value1,value2,mode=[+,-,*, /], datetime], 
  ...
}
 
Step2의 부가설명은 다음과 같습니다.
$>input user name : xxxx
$>input process type : 1 or 2 [1:calculator, 2:management]

* process type이 1일경우, Step1의 기능을 수행합니다. Step1의 과정이 종료된 후, 
  To be continue?(Y or N) 를 출력해서 계속 수행할지 물어보게 합니다.
  - Y일 경우, input user_name으로 사용자 입력을 기다립니다.
  - N일 경우, 프로그램을 종료합니다.
  process type이 2일경우, 그 동안의 히스토리를 출력하고, 메뉴선택 $>input user name : xxx 으로 돌아갑니다.


Step1,2의 NS-Chart를 꼭 제출하세요

PA-2. Make game on console Impl. (4/27까지- 중간고사로 인한 일주일 연장)

elcass 에서 프로토타입을 다운받아, 
Step 1 : 상대방을 dection하는 알고리즘을 설계/구현하여 running한다(상대방을 공격하는 function포함) 
Step 2 : 현재 하나의 종족을 위한 클래스만 구성되어 있으며, 이것을 1개이상의 종족으로 확장하여, step1을 수행할 것.

PaIr Programming Projects

2인 1조로 수행한다.

Team Project

팀구성
5인 내외로 팀을 구성하여 Team Project를 진행한다. 주제는 제한이 없다.
팀명(영문), 팀원, 팀장을 e-class에 제출
평가요소
팀 평가와 개인평가는 7:3
팀 평가(70%): 제안서(10%), 프로젝트의 난이도(15%), 완성도 및 활용가능성(30%), 발표(5%), 보고서의 품질(10%)
개인 평가(30%): 팀 공헌도 (상대평가)
최종결과 발표 및 시연 ()
최종결과를 시연하면서 발표한다.
제출물: PPT, 보고서(PDF), source code, project history (e-class에 제출)
팀 소스관리 repository
Download 계획서 양식(예시)Media:busiform.pdf
Download 계획서 양식Media:BusiModelForm.hwp

팀 구성

5인 1팀으로 프로젝트 팀을 구성하라. 자세한 사항은 e-class 팀프로젝트 참조하여 등록한다.

팀프로젝트 제안서 발표

일자 : 추후공지 주제 : 추후공지

제출
제안서(PPT 양식) - 2017/MM/DD
발표
배점
30점

소프트웨어 엔지니어링

현업에서의 소프트웨어 디자인 및 개발과정과 동적분석 방법

공지사항
추후공지

(주)퍼니셀 수석연구원 여기대 (삼성전자 소프트웨어엔지니어링 8년근무)

특강 참석전 준비사항

  • 추후 공지

모바일 소프트웨어 개발과 서버프로그래밍

현업에서의 안드로이드 기반의 소프트웨어 개발과 장고이외에 서버프레임워크에 대한 소개

공지사항
추후공지

(주)퍼니셀 책임연구원 강창남 (개발경력 7년)

특강 참석전 준비사항

  • 추후 공지

최종발표 및 시연

발표
팀별 10분
시연회
발표가 모두 끝난 후 15분간
제출물
보고서 (맨 마지막 장은 부록으로 source code list 첨부)
버전관리 이력
동료평가 실시

과거 인터넷응용 Team Project 결과물

2016 인터넷응용 Team Project 결과물

참고자료

Cygwin

Ubuntu

Apache, MySQL, and PHP

WireShark Protocol Anaylzer

  • WireShark download [1]:
  • WireShark 사용법 [2]