It - 해당되는 글 17건

 

 

비제이퍼블릭에서 실용적이고 알찬 IT/컴퓨터 관련 일서(일본 서적) 번역을 위한 역자를 모집합니다.

 

관심이 있으신 미래의 역자께서는 다음의 이메일로 간단한 소개/관심분야/연락처를 남겨주시면 관련 서적들과 함께 연락드리도록 하겠습니다.

 

junepk@bjpublic.co.kr

 

시작하고자 하는 마음을 먹었다면, 나머지 반은 비제이퍼블릭이 “우주에 흔적을 남기고픈 IT 열정”으로 도와드리겠습니다. 감사합니다.

 


 

이런 책은 왜 없지? 꼭 필요할 텐데내가 하나 써볼까? 하러

 

이 원서 국내에 꼭 번역되면 좋을 텐데그래, 내가 한번 해보자! 하러 가기

 

내가 직접 쓰거나 번역엔 관심 없지만, 이런 책이 꼭 있었으면 좋을 텐데" 도서 하러 가기

 

시작이 반이다

시작하고자 하는 마음을 먹었다면,

나머지 은 비제이퍼블릭이 우주에 흔적을 남기고픈 IT 열정으로 도와드리겠습니다.

 

 

나도 미래의 저/역자!” 저/ 하기

 

IT/컴퓨터 분야 전문 출판사인 비제이퍼블릭에 미래의 저/역자로 등록해주세요.

관심 분야를 알려주시면, 표명하신 분야에 대한 저서를 기획하게 되거나 관심 분야의 원서를 번역 출간하게 될 때 저자 또는 역자로서 도서의 집필 또는 번역에 관심이 있는지 연락을 드리도록 하겠습니다.

 

* 비제이퍼블릭은 IT/컴퓨터 분야 전문 출판사입니다.

신고
Trackback 0 | Comment 0

 

 

[비제이퍼블릭 홈페이지]

모집부분 및 자격 요건

 모집부문

인원 

자격요건 

IT 도서부문
기획/편집자

 1

 신입·경력
 대졸(2,3년) 이상
 성별무관
 책에 대한 열정과 비전이 있는 분
 나이제한없음


근무 환경 

 급여부문

 회사 내규에 따름(면접 후 결정)

 연금/보험

 국민연금, 고용보험, 산재보험, 건강보험, 퇴직연금

 휴무/휴가

 주5일근무, 연차, 경조휴가

 생활편의

 중식제공, 주차비지원/주차가능

 여가지원

 체력단련비 지원, 휴가비 지원, 도서 구입비 지원

 
전형절차

       서류전형 > 1차 면접 > 2차 면접

 

제출서류 

 이력서 (희망연봉 반드시 명기)
 자기소개서

 * 경력사항과 자기소개서를 성실하게 작성해주시기 바랍니다 *

 양식이 필요한 경우 또는 참고용                                                                   

                                       입사지원서(비제이퍼블릭).doc


제출기한 및 접수처 

 제출기한

 4월 6일 ~ 4월 23일까지

 회사위치

 광화문 세종문화회관 부근.
    (3호선 경복궁역 7번 출구에서 300 미터,
     5호선 광화문역 1번 출구에서 500 미터)

 접수처

 bjpublic@bjpublic.co.kr (이메일 접수만 받습니다.)


문의사항

 문의처

 bjpublic@bjpublic.co.kr (이메일 문의만 받습니다.)


* 제출된 서류는 일체 반환하지 않습니다.

 

신고
Trackback 0 | Comment 0

오늘 드디어 비제이퍼블릭의 첫 두 도서(프로 ASP.NET MVC 프레임워크 + 오브젝티브-C 2.0)의 광고가 실린 마이크로소프트웨어(이하 '마소')의 10월호가 도착했습니다. 우려했던 것과는 달리 정말 짧은 시간에 만들어낸 것에 비해 만족할만한 상태로 당당히 실려 있었습니다.

 


이 광고를 보고 많은 개발자분들께서 저희 비제이퍼블릭 출판사에 조금이나마 관심을 가지고, 꾸준히 지켜봐주셨으면 하는 바램입니다.

참고로 비제이퍼블릭의 홈페이지에서는 IT/컴퓨터 도서 관련 집필/번역을 원하시는 개발자분들께서 제안을 하실 수 있도록 출간제의를 받고 있습니다. 다음 링크를 통해 정보를 기입해 주시면 확인하는대로 즉시 연락을 드리도록 하겠습니다.

[번역제의] [집필제의]

어느분에게나 활짝! 문이 열려있으니 언제라도 궁금하신 사항이 있으시면 부담없이 편하게 연락주시길 바랍니다.
junepk@bjpublic.co.kr
02-739-0739
김범준 실장

프로 ASP.NET MVC 프레임워크
카테고리 컴퓨터/IT
지은이 스티븐 샌더슨 (비제이퍼블릭, 2009년)
상세보기

Objective-C 2.0(오브젝티브-C 2.0)
카테고리 컴퓨터/IT
지은이 마크 달림플 (비제이퍼블릭, 2009년)
상세보기

신고
Trackback 0 | Comment 0


Apress의 Pro ASP.NET MVC Framework의 번역서인 『프로 ASP.NET MVC 프레임워크』가 10월 13일 출간 예정입니다.

현재 다음의 서점에서 예약 판매를 진행중에 있으나 오늘 부터 시작이 되어 도서의 서지정보가 아직 기입이 안된 사이트도 있는 점을 양해 부탁드립니다.


출간 예정일: 2009년 10월 13일
예약 판매일: 2009년 9월 25일 ~ 2009년 10월 12일
저자: 스티븐 샌더슨
역자: 김태영, 송원석
가격: 33,000원
ISBN: 978-89-962765-2-4
페이지: 700





[아마존 소개 보러가기]
[아마존 랭킹 보러가기]





예전 글(2009/09/14 - [출간예정]프로 ASP.NET MVC 프레임워크(Pro ASP.NET MVC Framework))에서도 알려드렸었지만, 이 책은 taeyo.net의 운영자이신 김태영(taeyo)님과 시삽이신 송원석(songgun)님께서 번역을 맡아 주셨습니다. 따라서, 도서를 읽고 궁금하신 점이 있으시면 언제든지 taeyo.net의 "ASP 게시판"에 올려주시면 여러 관계자분들께서 친절히 답변해 주시길 것입니다.

오늘은 도서와 저/역자분들의 간단한 소개를 먼저 해드리고 다음주 안으로 이 책의 4장인 "스포츠스토어: 실무 응용 프로그램" 부분을 공개해 드리도록 하겠습니다. 감사합니다.

책소개

이 책은 Apress의 Pro ASP.NET Framework(Sanderson 저)의 번역서로, 원서는 아마존(Amazon) 사이트의 프로그래밍/ASP 분야에서 출간 당시부터 베스트셀러에 속하여 현재까지 당당히 1위를 차지하고 있는 도서이다.

새로운 ASP.NET MVC 프레임워크는 마이크로소프트 웹 개발에 있어서 ASP.NET이 처음으로 공개된 2002년 이후 가장 큰 변화를 의미한다. ASP.NET MVC 프레임워크는 HTML 마크업, URL 스키마, 그리고 요청 및 응답의 사용을 매우 훌륭하게 제어할 수 있도록 지원해주고 있을 뿐만 아니라 깔끔한 응용 프로그램 아키텍처를 권장하고 단위 테스트에 대한 풍부한 지원을 제공해주며, 써드 파티 자바스크립트 라이브러리 및 Ajax 툴킷과도 손쉽게 통합할 수 있도록 지원해 주고 있다.
이 책은 단순히 ASP.NET MVC에서 어떤 기능들이 제공되는지, 그리고 그 기능들을 어떻게 사용하는지를 설명할 뿐만 아니라 그런 방식으로 설계된 이유는 무엇이며, 그 원리를 적용하여 여러분의 코드를 향상시킬 수 있는 방법은 무엇인지에 대해서도 깊게 이해할 수 있게 해준다.
또한 정상적으로 동작하는 기능들은 물론이고 여러분이 직면하게 될 제약 사항들과 대안들, 그리고 여러분이 사용하면 좋을 만한 오픈 소스 도구들에 대해서도 자유롭게 분석하고 검토하고 있다.

이 책의 설명과 따라하기 형식의 튜토리얼 등을 통해서 여러분은 다음과 같은 내용들을 알 수 있게 될 것이다.

  • 라우팅, 컨트롤러, 필터, 뷰, 모델 바인딩 등을 포함한 MVC 프레임워크의 강력한 기능들
  • 아키텍처: 모델-뷰-컨트롤러(MVC, Model-View-Controller) 패턴, 느슨한 결합, 테스트 용이성, 테스트 주도 개발(TDD, Test-Driven Development), 그리고 관련 디자인 패턴들
  • MVC 프레임워크의 요청 처리 파이프라인 확장 및 사용자 정의
  • MVC 응용 프로그램 보호 및 윈도우 서버로의 배포
  • MVC 응용 프로그램에서 ASP.NET 핵심 플랫폼 기능 사용하기
  • 기존 ASP.NET 응용 프로그램과의 통합 또는 ASP.NET MVC로의 마이그레이션

    http://taeyo.net
    책을 읽다가 궁금하거나 의아한 내용이 있다면 태오 사이트의 ‘ASP.NET 게시판’을 통해서 같이 이야기를 나누길 바란다. 내게 궁금한 것은 일반적으로 남에게도 궁금한 것이곤 하기에, 나중에라도 동일한 내용을 궁금해 하는 사람이 쉽게 찾아볼 수 있도록 하기 위해 역자는 그러한 궁금증을 게시판을 통해서 공유하길 좋아한다.


    독자대상: 초중급
    이 책은 ASP.NET과 C#에 어느 정도의 기본 지식을 가지고 있으면서 새로운 ASP.NET MVC 프레임워크를 사용하기 원하는 개발자들을 위한 책이다. 만약 여러분들이 웹폼으로 알려진 기존의 ASP.NET을 사용해 본 경험이 있다면 더욱 도움이 될 것이다.
    그러나 이 책은 초보자에게도 여전히 매우 유용하다. 예제들은 따라하기 방식으로 필요한 과정을 모두 친절히 설명하고 있으며, 아무 문제없이 작동되어 진다. 모든 코드들은 제대로 설명이 되어 있고 실용적이므로, ASP.NET MVC의 기초를 알기 원하는 모두에게 이 책을 권한다.


    *출판사 리뷰

    ASP.NET MVC는 모델-뷰-컨트롤러(MVC, Model-View-Controller) 아키텍처의 효율성과 깔끔함, 애자일 개발(Agile Development)의 최신 개념과 기술, 그리고 기존 ASP.NET 플랫폼에서 가장 뛰어난 부분들만을 결합한 마이크로소프트의 웹 개발 프레임워크이며, 웹 개발 프로젝트의 아주 사소한 부분들을 제외한 거의 모든 부분에 있어 상당한 이점들을 제공하는 "기존 ASP.NET 웹폼"에 대한 완벽한 대안이기도 하다.

    지난 몇 년 동안 우리들이 직접 경험해 왔던 것처럼, 마이크로소프트의 웹 개발 플랫폼들은 그 기능과 함께 (불행하게도) 복잡성도 점차 증가하고 있고 새로운 플랫폼들은 언제나 이전 플랫폼이 갖고 있던 단점들을 해소하고자 노력해왔다. 마찬가지로 ASP.NET MVC도 기존 ASP.NET 웹폼의 단점들을 해결하려는 목표를 갖고 설계되었으며, 특히 이번에는 간결함을 강조하고 있다.

    기존의 ASP.NET은 상당히 좋은 발상이었으며 처음에는 굉장한 기대를 모았으나, 현실은 예상했던 것보다 훨씬 더 복잡했다. 지난 몇 년간 실무에서 웹폼이 사용된 결과, ViewState, 페이지 수명 주기, HTML 기반의 콘트롤에 대한 제약, 관계 분리의 취약성, 테스트의 어려움 등에서 많은 문제점들이 발견되었다.

    마이크로소프트와 같은 거대 기업은 잠시 동안은 현재의 영광에 만족할 수 있겠지만, 언제까지나 그 상태로 안주할 수만은 없다. ASP.NET은 지금까지 큰 상업적 성공을 거뒀으나 그 동안 다른 웹 개발 업계는 계속 변화해왔으며, 비록 마이크로소프트가 꾸준히 웹폼의 문제점들을 해결해 나간다 하더라도 이미 웹폼의 주요 설계는 시대에 많이 뒤쳐진 것처럼 보인다.

    2007년 10월, 텍사스 오스틴에서 개최된 첫 번째 ALT.NET 컨퍼런스에서 마이크로소프트의 부사장 스콧 구스리(Scott Guthrie)는 지금까지 살펴본 비난들에 대한 직접적인 응답으로 명확하게 설계된 ASP.NET 기반의 새로운 MVC 웹 개발 플랫폼을 소개하고 시연했다. 이 새로운 플랫폼이 어떻게 ASP.NET이 갖고 있는 제약들을 극복하고 마이크로소프트의 플랫폼을 다시 첨단 기술로 복귀시킬 것인지 이 책을 통해서 함께 살펴보도록 하자.

    저자: 스티븐 샌더슨(STEVEN SANDERSON)

    그는 코모도어(Commodore) VIC-20 사용 설명서에 기재된 BASIC 프로그램을 따라 해보면서 처음 컴퓨터 프로그램을 접했다. 그리고 이것이 그가 처음 읽기를 배운 방법이기도 하다. 스티브는 영국의 셰필드(Sheffield)에서 태어났으며 캠브리지 대학에서 수학을 공부했고, 지금은 브리스톨(Bristol)에 거주하고 있다. 그는 거대 투자 은행과 조그마한 신생 기업에서 일했으며, 그 뒤로 독립하기 전까지 프리랜서 웹 개발자, 컨설턴트 및 트레이너로 중간 규모의 ISV에서 근무했다. 스티브는 영국의 .NET 커뮤니티에서 활동하면서 사용자 그룹에 참여하기 위해 노력하고 있으며, 기회가 허락될 때마다 컨퍼런스에서 무료 강연을 하고 있다. 그는 모든 형태의 기술적인 진보에 애착이 있으며, 반짝이는 LED만 갖고 있다면 어떤 기계 장치든 구입하곤 한다.


    기술 감수자: 앤디 올센(ANDY OLSEN)

    그는 영국에서 활동 중인 프리랜서 개발자이자 컨설턴트다. 앤디는 베타1 시절부터 .NET을 사용하여 작업해왔으며, Apress 출판사에서 C#, 비주얼 베이직, ASP.NET, 그리고 그 밖의 주제들을 다루는 몇 권의 책들을 공저하거나 감수했다. 그는 축구와 럭비의 열광적인 팬이며 달리기와 스키(비록 서툴지만)를 즐긴다. 지금은 그의 아내인 재인, 그리고 그의 아이들, 에밀리와 토마스와 함께 스완시(Swansea)의 해변에 거주하고 있고, 이제 막 서핑의 짜릿함을 발견하여 그가 경험한 그 어느 것보다도 멋져 보인다고 생각하고 있다.


    역자: 김태영(Taeyo)

    Taeyo라는 온라인 아이디로 유명한 그는 ASP/ASP.NET 기술에 관한 한 국내에서 전설적인 전도사로 불린다. Taeyo.NET이라는 유명 커뮤니티의 대표 운영자이며, 현재까지도 스테디셀러인 수 많은 책들의 저자이기도 하다. 더불어, 한국인으로서는 유일하게 Microsoft MVP Insider를 수상하기도 하였다. 현재는 ㈜이노가드에서 기술이사로 재직하고 있으며, 꾸준히 온라인을 통해서 다양한 웹 프로그래밍 기술을 공유하고 있다. 그를 만나보고 싶다면, 강남역이나 선릉역 주변의 선술집들을 둘러보라. 간혹 프로그래밍과 전혀 관계없는 주제로 신나있는 그를 볼 수 있을지도 모른다.


    역자: 송원석

    현재 ㈜이노가드에서 솔루션 사업부 차장으로 근무하고 있다. 지난 3년간 마이크로소프트 MVP(IIS)를 수상했으며, 국내 최대의 ASP & ASP.NET 커뮤니티인 Taeyo.NET에서 IIS 게시판 시삽으로 활동하고 있다. 최근 몇 년간 개인 홈페이지(http://www.egocube.pe.kr/)를 통해서 IIS7 관련 문서들의 번역 작업을 꾸준히 진행해오고 있으며, 특히 IIS 관리 자동화에 관심이 많다.

    *목차

    저자서문
    감사의글

    역자서문

    1부 ASP.NET MVC 소개

    1장. 전체 개요
       웹 개발의 간략한 역사

       최근의 웹 개발

       ASP.NET MVC 의 주요 장점

       누가 ASP.NET MVC 를 사용해야 하는가?

    2장. 첫 번째 ASP.NET MVC 응용 프로그램
       작업용 컴퓨터 준비하기

       새로운 ASP.NET MVC 프로젝트 생성하기

       웹 페이지 렌더링

       첫 응용 프로그램

    3장. 사전지식
       모델-뷰-컨트롤러(MVC, Model-View-Controller) 아키텍처의 이해

       도메인 모델링

       느슨하게 연결된 구성 요소 작성하기

       자동화된 테스트 시작하기

       새로운 C# 3 언어 기능들

    4장. 스포츠스토어: 실무 응용 프로그램
       시작하기

       도메인 모델 작업하기

       제품 목록 출력하기

       데이터베이스 연결하기

       IoC설정하기

       자동화된 테스트 생성하기

       사용자 정의 URL 스키마 구성하기

       모양 꾸미기

    5장. 스포츠스토어: 탐색 및 장바구니
       탐색 컨트롤 추가하기

       장바구니 구현하기

       주문 전송하기

    6장. 스포츠스토어: 관리기능 및 마무리 개선 작업
       카탈로그 관리 추가하기

       관리 기능 보안

       이미지 업로드

     

    2부 ASP.NET MVC 심화

    7장. ASP.NET MVC 프로젝트 개요
       비주얼 스튜디오로 MVC 애플리케이션 개발하기

       요청 처리 파이프라인

    8장 URL과 라우팅
       개발자가 제어할 수 있다

       라우트 설정하기

       출력용 URL 생성하기

       라우트를 단위 테스트하기

       중급 사용자 정의

       URL 스키마 지침

    9장. 컨트롤러와 액션
       개요

       입력 수신하기

       출력 생성하기

       필터에 재사용 가능한 동작 추가하기

       요청 처리 파이프라인의 일부인 컨트롤러

       컨트롤러와 액션 테스트하기

    10장. 뷰
       ASP.NET MVC와 뷰와의 조화

       웹폼 뷰 엔진 기초

       인라인 코드 사용하기

       MVC 뷰는 실제로 어떻게 동작하는가

       HTML 도우미 메서드 사용하기

       파샬 뷰 사용하기

       애플리케이션 로직을 갖는 재사용 가능한 위젯을 만들기 위해서 Html.RenderAction 사용하기

       마스터 페이지를 사용하여 페이지 레이아웃 공유하기

       사용자 정의 뷰 엔진 구현하기

       다른 뷰 엔진 사용하기

    11장. 데이터 엔트리
       모델 바인딩

       유효성 검사

       위저드와 다단계 폼

       검증

    12장. Ajax와 클라이언트 스크립팅
       왜 자바스크립트 툴킷을 사용해야만 하는가

       ASP.NET MVC의 Ajax 도우미

       ASP.NET MVC에서 jQuery 사용하기

    13장. 보안과 약점
       모든 입력은 위조될 수 있다

       크로스-사이트 스크립팅과 HTML 인젝션

       세션 하이재킹

       크로스 사이트 요청 위조(CSRF)

       SQL 인젝션

       MVC 프레임워크를 보안적으로 사용하기

    14장. 배포
       서버 요구사항

       IIS 기본

       애플리케이션 배포하기

       애플리케이션을 운영 서버에서도 잘 동작하게 만들기

    15장. ASP.NET 플랫폼 기능
       윈도우 인증

       폼 인증

       멤버십, 역할, 및 프로필

       URL 기반 권한 부여

       데이터 캐싱

       사이트 맵

       국제화

       성능

    16장. MVC와 웹폼의 결합
       MVC 응용 프로그램에서 웹폼 기술 사용하기

       웹폼 응용 프로그램에서 ASP.NET MVC 사용하기

    찾아보기





  • 신고
    Trackback 0 | Comment 0


    현재 10월 중(다음달)으로 번역서가 출간될 Apress의 프로 ASP.NET MVC 프레임워크(Pro ASP.NET MVC Framwork)를 출판사의 압박!으로 열심히 번역하고 계신 김태영(태오)님과 송원석(송군)님이 운영자이자 운영진으로 계신 Taeyo.net에서 작년(2008년)에 태오님께서 올리신 MVC 관련 강좌를 발견하였습니다. 4회까지 연재를 하신 것 같으신데, 모두 올려드리도록 하겠습니다. 원본은 다음 링크에서 확인 가능합니다.

    강좌 #2 [바로가기]

    웹 폼 기반의 개발과 MVC 기반의 개발


     

    M/V/C 로의 분리

    우선 웹 애플리케이션의 구조를 Model(모델), View(뷰), Controller(컨트롤러)로 분리하는 MVC 패턴에서 각각의 그러한 컴포넌트들의 역할에 대해서 먼저 살펴보도록 하겠습니다. 각각의 분리는 물리적인 분리라기 보다는 논리적인 분리임을 기억하시고 다음 내용을 살펴보시기 바랍니다.

    Model(모델)

    모델은 실제 로직을 구현하는 애플리케이션의 중요한 부분입니다. 이는 일반적으로 데이터베이스로부터 데이터를 가져와서 담아두거나, 데이터베이스로 저장하는 역할을 수행합니다. 주로 모델링을 통해서 산출된 엔터티들이 이러한 모델에 속하게 되지만, 작은 규모에서는 DataSet도 모델로서 사용될 수 있습니다.

    View(뷰)

    뷰는 사용자 인터페이스 즉, UI을 출력하는 컴포넌트입니다. 일반적으로 UI는 모델의 데이터를 기반으로 만들어집니다. 화면 출력과 관계된 로직을 포함할 수는 있지만, 사용자 입력이나 인터렉션, 업무와 관계된 로직은 결코 View가 가져서는 안됩니다. 이는 오로지 화면을 출력하기 위한 역할만을 담당하기 때문입니다.

    Controller(컨트롤러)

    어찌 보면 MVC에서 가장 핵심이 되는 컴포넌트입니다. 사용자의 인터렉션을 처리하고, 모델을 조작하며, 최종 UI로 출력될 뷰를 결정하는 역할을 담당합니다. 전체적인 코디네이터 역할을 한다고 볼 수 있는데요. 이는 사용자의 입력 값을 수신하고 데이터 모델을 통해서 필요한 데이터를 가져와 응답(Response)을 구성하는 전반적인 책임을 담당합니다.

    이러한 MVC 패턴에 따라 애플리케이션을 3개의 컴포넌트로 나누어 구성하게 되면, 각 요소 간에 연결을 보다 느슨하게 구성할 수가 있게 되기에 복잡한 애플리케이션을 관리하기에 용이하며, 병행 개발(동시에 각각의 컴포넌트를 개발하는 방식)이 가능하다는 장점이 있습니다. 그리고, 이러한 분리로 인해 기존의 ASP.NET 애플리케이션보다 훨씬 테스트하기가 용이하다는 이점을 얻을 수도 있습니다.

    기존 ASP.NET 애플리케이션은 테스트를 하기 위해서 사용자 입력에 따라 전반적인 ASP.NET의 프로세스(페이지 클래스를 생성, 초기화하고, 개체 트리에 속해있는 모든 컨트롤들을 생성하는 등) 를 모두 거쳐가며 테스트해야 했기에 그 절차가 약간 복잡했고 또한, 테스트를 위해서는 반드시 웹 서버가 요구된다는 제약이 있었지만, MVC 패턴을 적용해서 구성하게 되면 개별적인 컴포넌트를 독립적으로 테스트할 수 있게 되기에 애플리케이션의 개발과 테스트가 상대적으로 용이하다는 이점을 얻을 수 있으며, 이는 TDD(Test-Driven Development)에도 부합한다고 볼 수 있습니다.

    어떻게 모듈을 나눠야 하고, 어떤 코드를 어디에 작성해야 하는 지는 지금 고민하지 않아도 됩니다. 그에 대한 템플릿과 규칙을 ASP.NET MVC 프레임워크가 제공하고 있기에 그가 제안하는 규칙에 따라 개발을 하면 되기 때문이지요. 이에 대한 본격적인 이야기는 다음 강좌부터 시작합니다.

    웹 폼 기반의 개발과 MVC 기반의 개발

    조금쯤은 새로 사귄 친구의 편을 들어 설명하다 보니, 자칫하면 이러한 설명이 마치 기존의 ASP.NET 애플리케이션은 그다지 매력이 없고 MVC만이 훌륭한 것처럼 느껴지게 설명한 것도 같은데요. 앞에서도 말씀 드렸지만, 그게 꼭 그런 것만은 아닙니다. 기존 웹 폼 방식의 ASP.NET도 많은 장점들을 가지고 있으니까요. 말이 나온 김에 간단하게 두 기술이 가진 각각의 장점을 간략하게 정리해 보도록 하겠습니다.

    웹 폼 기반의 웹 애플리케이션의 장점

  • 각각의 페이지 단위로 기능을 작성하는 Page Controller 패턴을 사용한다.
    : 개별 화면 단위 중심적인 업무를 개발하기에 매우 적합하다.
  • 이벤트 중심의 프로그래밍 모델을 제공한다.
    : 다양한 이벤트를 제공하는 수 많은 서버 컨트롤이 제공되기에, 이벤트 중심적인 개발을 통해 업무 화면을 직관적으로 작성할 수 있다.
  • 뷰상태(ViewState)와 서버 기반의 폼을 사용하기에, 상태 정보를 관리하기에 용이하다.
  • MVC 기반의 웹 애플리케이션의 장점

  • 모든 요청을 단일 컨트롤러를 통해서 처리하는 Front Controller 패턴을 사용한다
    : 모든 요청을 단일 컨트롤러를 통해 처리하므로, 라우팅(routing) 하부구조를 지원하는 애플리케이션을 개발할 수 있다.
  • 애플리케이션을 3개의 논리 모듈로 분리하기에 애플리케이션의 복잡성을 관리하기 쉽게 한다.
  • 뷰상태나 서버 기반의 폼을 사용하지 않는다
    : 개발자가 애플리케이션의 동작방식을 전체적으로 제어할 수 있으므로 세밀하게 애플리케이션을 조작하고 싶은 이들에게 적합하다. 단, 이러한 기능(상태정보 관리)이 필요할 경우 추가적인 작업이 요구된다.
  • 이제 MVC 모델이 어떻게 우리를 즐겁게 해줄 수 있을 것인지 개념적으로는 약간의 기대가 충전되었을 것이라 생각합니다. 막상 사용하다 보면 웹 폼 기반의 개발이 그리워지는 경우도 적지 않지만(이벤트 프로그래밍 모델도 꽤나 개발에 편리한 모델이기에), MVC는 MVC대로 유용한 많은 기능들을 제공하기에 이를 통한 개발이 한동안은 꽤 선전하지 않을까 예상이 됩니다. 물론, 그렇다 하더라도 많은 애플리케이션은 여전히 웹 폼 기반으로 개발될 것이며, 심지어는 웹 폼 기반과 MVC 기반이 혼합되는 애플리케이션도 생겨날 수 있겠지만 말입니다.

    그렇다면, 이러한 지식을 머리에 담아두고, 다음 강좌부터는 본격적으로 ASP.NET MVC 프레임워크가 지원하는 기능들에 대해서 설명을 해보도록 하겠습니다. 프레임워크에서 지원하는 기능을 간략하게 살펴본 뒤, 그에 따라 가벼운 샘플 애플리케이션을 모델/뷰/컨트롤로로 분리하여 전체적인 구동 예제를 완성하는 식으로 강좌를 진행해 볼까 합니다.

    기대가 되신다면~ Talk 게시판에 응원의 글을 남겨주십시오!!! 감사합니다.




    신고
    Trackback 0 | Comment 0



    현재 10월 중(다음달)으로 번역서가 출간될 Apress의 프로 ASP.NET MVC 프레임워크(Pro ASP.NET MVC Framwork)를 출판사의 압박!으로 열심히 번역하고 계신 김태영(태오)님과 송원석(송군)님이 운영자이자 운영진으로 계신 Taeyo.net에서 작년(2008년)에 태오님께서 올리신 MVC 관련 강좌를 발견하였습니다. 4회까지 연재를 하신 것 같으신데, 모두 올려드리도록 하겠습니다. 원본은 다음 링크에서 확인 가능합니다.

    강좌 #3 [바로가기]

    MVC 애플리케이션 개발환경 설정

    이전 강좌의 피드백 중에는 "강좌의 내용이 너무 짧았다. 좀 더 상세하고 속 시원하게 말을 해주면 좋았을 것 같다"는 내용이 있었습니다만, 그 부분은 제가 확신을 가지고 말씀 드릴 수 있는 부분이 아니기 때문에 비교만을 해드린 것입니다. 더불어, Page 컨트롤러와 Front 컨트롤러의 차이나 장, 단점의 비교를 보다 구체적으로 해 주었으면 좋겠다는 의견도 있었습니다만, 이는 상당히 많은 이야기가 수반되어야 하기에 제 강좌에서는 설명을 생략(?)하고 관심이 있는 개발자들이 스스로 학습하시도록 방관(?)한 것이 사실입니다. ^^ 죄송합니다.

    사실, 웹 폼은 웹 폼만의 많은 장점을 가지고 있고(아이러니하게도 MVC가 지원되니깐 오히려 웹 폼의 장점이 더 눈에 잘 보이더군요), 장기간 동안 시장에서 사용되어 온 기술이기에 사용층도 폭도 매우 넓습니다. 그렇기에, MVC 프레임워크가 등장한 이후에도 많은 프로젝트들은 웹 폼 기반으로 이루어질 것으로 보입니다. 아직까지도 ASP 기술이 사용되고 있듯이, 기존 ASP.NET의 웹 폼 모델도 차후 오랫동안 꾸준히 사용될 것임이 자명하기 때문입니다. Microsoft가 웹 폼 모델도 꾸준히 업데이트하고 지원할 것이라고 말했듯이, MVC 모델은 기존 웹 폼 모델을 대체하기 위한 것이 아닌 병행적으로, 선택적으로 사용할 수 있는 개발 방법이기 때문입니다.

    그런 상황에서 제가 MVC가 새로 지원되는 기술이라는 이유로 강조해서 설명을 드리게 되면 혹시 몇몇 분들은 혹~해서 지나치게 MVC 기술에 대해 긍정적인 선입견을 갖게 될 수도 있기 때문에 저는 조심스럽게 말씀드릴 수 밖에 없습니다. 그 어떤 것이 절대적으로 좋은 것이 아니라, 상황과 환경, 시나리오에 따라 선택적으로 채택할 수 있는 기술이기 때문인 것이죠.

    A 경우에는 MVC가 B 경우에는 웹 폼이 좋다고 누구도 장담할 수 없을 것입니다. 그것은 다양한 환경적인 요소들에 의해 선택적으로 채택될 수 있는 것이기 때문입니다. MVC가 쿨하게 보이는 기술이기는 하지만 그것이 만능해답인 것은 아닙니다. 고로, 지금은 강좌를 통해서 단지 이 기술이 어떤 즐거움을 우리에게 선사할 것인지 정도를 느껴보시는 것으로 충분합니다. 어느 정도 익숙해지고 난 다음에서야 우리는 본격적으로 진지한 토론을 할 수 있을테니까요. 겉모습만을 살펴본 상태에서 침을 튀겨가며 무언가에 대해 섣부른 판단을 하는 것은 바람직하지 않습니다. 사람들이 겉만 보고 태오를 평가했다면, 아마도 저는 지금 개발자가 아닌 연예인이 되어 장동건과 쌍벽을 이루고 있을지도 모를 노릇이지만, 저는 개발자를 하고 있지 않습니까? (응? 브라우저는 왜 닫으시려는 것이어요? 네? 왜???)

    ASP.NET MVC 개발환경 구성하기

    자. 그렇다면, 이제 간단한 샘플 애플리케이션을 통해서 모델을 구성하고 개발하는 방법을 시작으로 MVC 각각의 단계를 파고들어 보도록 하겠습니다. 당장 소스 그대로 가져다 써먹을만한 실용적인 샘플을 다루는 것을 원하시는 분들도 있겠습니다만, 그렇게 하면 MVC에 대한 설명보다는 오히려 그 복잡한 구성에 대한 설명으로 강좌의 목적이 방향을 잃을 수 있기에, 예제는 간단한 것으로 진행하려는 것입니다. 진짭니다. 진짠데… (태오 쉿! 더 말하면, 진짜 티나!)

    우선, MVC 애플리케이션을 작성하기 위한 사전 준비가 필요한데요. 아시다시피, 현재는 이를 편하게 개발하려면 Visual Studio 2008이 필요합니다. 물론, 그러한 훌륭한 도구없이 메모장에서 개발을 할 수도 있겠습니다만, 그렇게 하려면 너무 많은 준비가 필요하기에 저는 VS 2008 기준으로 작성하도록 할까 합니다.

    VS 2008이 준비되신 분들은 이어서 계속 따라해 주시면 감사하겠고요. 도구가 없으신 분은 일단은 눈으로라도 따라해 봐 주시면 또한 감사하겠습니다.

    자. 그럼 시작해 볼까요? 고고싱!

    이라고 외치자마자 기운을 꺾어서 죄송합니다만, VS 2008 도구가 준비되었다고 바로 ASP.NET MVC 애플리케이션을 작성할 수 있는 것은 아닙니다. ^^; 현재 ASP.NET MVC는 preview 인 상태이기 때문에 , 이를 개발할 수 있게 돕는 별도의 설치파일을 다운로드 하셔서 설치하셔야 합니다. 그러니깐, 아직 ASP.NET MVC는 정식버전은 아니라는 것이죠(2008년 말 즈음 정식 버전이 나올 것으로 예상됩니다). 어쩌면 여러분이 이 강좌를 읽고 있는 시점에서는 설치 파일의 Beta 버전이 나왔을 수도 있습니다. 여러분은 현재 시점에서 최신의 ASP.NET MVC 설치파일을 다운로드 하셔서 설치하시기 바랍니다. ^^

    http://www.asp.net/downloads/3.5-extensions/

    설치하셨다면, 이제 본격적으로 시작을 해보도록 하겠습니다.

    자. 이제 VS 2008을 실행하시고요. 다음과 같이 C# 언어에서 Web 프로젝트 중 ASP.NET MVC Web Application을 선택하세요. 창 중간에 있는 설명에 (Preview)가 확실히 맞는지 확인하시기 바랍니다.

    제 VS 2008의 경우는 여러분의 화면보다 조금 복잡하게 보일 수도 있는데요. 이는 저의 경우는 기존 preview 버전도 설치가 되어 있기 때문에 프로젝트 템플릿이 살짝 꼬여있어서 그렇습니다. 그리고, 추가적으로 저의 경우는 VS 2008 한글판을 사용하고 있는데요(세미나 준비 때문에 어쩔 수 없이). 한글판을 사용하는 경우에는 ASP.NET MVC를 설치하더라도 [새 프로젝트] 창에 위의 그림과 같이 ASP.NET MVC Web Application이 나타나지 않을 수 있습니다. 현재 ASP.NET MVC는 영문 버전의 VS 2008만을 올바로 지원하기 때문이지요. 만일, 여러분이 한글판 VS 2008을 사용하고 있다면 다음의 글을 참고하셔서 ASP.NET MVC 설치 후 약간의 세팅을 하셔야 합니다. ^^ (그래서, 태오는 가급적 영문 VS 2008을 사용하실 것은 개인적으로 추천합니다). 하셔야 할 세팅은 태오 사이트의 Knowhow 게시판에 나와있습니다. 다음 링크를 참고하세요

    http://taeyo.net/forum/Content.aspx?SEQ=1317&TBL=KNOWHOW

    자. 이제 프로젝트를 생성하였다면, 다음과 같은 구조의 프로젝트를 보실 수 있을 것입니다. 저의 경우는 프로젝트 명이 MvcApplication2로 되었는데요. 여러분은 원하시는 프로젝트 명을 사용해도 무방하며, 아무런 변경을 하지 않았다면 아마도 MvcApplication1 이실 겁니다. ^^

    프로젝트 구조를 보시면 MVC 답게, Model과 Controller, View가 각각의 폴더로 존재하는 것을 확인하실 수 있습니다. 각각의 폴더에 각각의 모듈을 작성하시면 됩니다. 직관적이죠?

    여기서, 다시 한번 강조하고 넘어갈 부분은 MVC 애플리케이션은 기존의 웹 애플리케이션과는 달리 웹으로 통한 요청이 물리적인 aspx 파일에 "직접적으로" 도달하지 않는다는 것입니다. 기존 웹 애플리케이션은 aspx 페이지 단위로 화면을 만들고 그 페이지가 요청의 종점이었지만(예를 들면, http://taeyo.net/board/list.aspx와 같은 식으로 요청을 하죠), MVC 모델에서는 aspx가 실제적인 요청의 종점이 아니라는 것입니다. Aspx는 일종의 뷰 템플릿으로서 사용되며, 요청의 종점 즉, 최종 화면은 URL에 지정된 명령(?)에 따라 컨트롤러에 의해서 결정되게 됩니다. 해서, MVC 모델에서의 URL은 http://taeyo.net/Board/List 와 같은 식으로 구성이 됩니다. 이와 관계된 자세한 내용은 이어지는 강좌(아마도, URL Mapping 강좌)에서 보다 구체적으로 다룰 예정이니 그 때 다시 설명드리도록 하겠습니다.

    지금은 저 각각의 폴더들이 각각의 MVC 모듈을 배치하기 위해서 존재한다는 것만을 기억하시면 됩니다.
    폴더 구조와 실제 URL 경로와는 아무런 상관관계가 없다는 것 정도만을 알고 계시면 된다는 것이죠 ^^

    그럼 이제 Model을 실제로 작성하는 것을 시작으로 하여 예제를 시작해 보도록 하겠습니다.
    아시죠? 그 내용은 다음 강좌라는 거~





    신고
    Trackback 0 | Comment 0



    TCP/IP 소켓 프로그래밍』과 거의 비슷한 시기에 출시될 비제이퍼블릭의 세 번째 도서, 『프로 ASP.NET MVC 프레임워크』를 소개해 드립니다.

    이 책은 Apress Pro ASP.NET Framework by Sanderson(978-1-4302-1007-8)의 번역서로, 원서는 아마존(Amazon) programming/asp.net 분야에서 출간 당시부터 베스트셀러에 속하여 현재까지 당당히 1위를 차지하고 있는 도서입니다(물론 간혹 2위로 내려간 경우도 있긴 했습니다^^;)
    .

     


    [아마존 소개 보러가기]
    [아마존 랭킹 보러가기]


     

    그와 더불어, 현재 이 책의 번역서는 '태오(Taeyo)'라는 닉네임으로 많이 알려져 있는 taeyo.net 운영자이자 Microsoft MVP Insider 김태영 이노가드 기술이사(http://www.taeyo.net)'Songgun(송군)'이라는 닉네임을 쓰는 Microsoft IIS 분야 MVP이자 태오닷넷의 시삽 송원석 이노가드 차장(http://www.egocube.pe.kr)이 공동 번역을 진행하고 있습니다. 번역서는 10월 안에 출간할 수 있도록 최선을 다하고는 있지만, 출간 시점에 다시 공지해 드리도록 하겠습니다.

    또한 조만간 여러분께서 검토 가등하도록 이 책의 4장 부분인 [스포츠스토어 실무 응용 프로그램]의 원본과 번역본과 더 자세한 정보를 올려드리도록 하겠습니다.

    다음은 도서의 preface의 내용을 간단히 정리해 보았습니다.


    2007 12월에 처음 공표된 ASP.NET MVC는 당시 소프트웨어 개발자들에게 대단한 반향을 불러일으켰습니다. MVC 2002년에 발표된 ASP.NET 이후, 마이크로소프트의 웹 테크놀로지에 있어서 가장 흥미진진한 진보라고 할 수 있었습니다. 그리고 2009 3, 드디어 ASP.NET MVC 프레임워크 1.0 정식 버전이 발표되었습니다.

     

    『프로 ASP.NET MVC 프레임워크』는 C#과 일반적인 웹 개발 개념(HTML HTTP )에 대한 실무적인 이해가 있는 소프트웨어 개발자를 위한 책입니다. 이미 ASP.NET(지금은 MVC와 구별하기 위해 웹폼(WebForms)으로 알려져 있는)을 다뤄왔다면 가장 이상적이겠지만, PHP나 레일즈(Rails) 또는 다른 웹 개발 플랫폼을 사용한 경험이 있는 개발자 분들도 아무 문제없이 이 책을 읽으실 수 있습니다.

     

    이 책의 모든 샘플 코드는 C#으로 쓰여져 있습니다. 그 이유는 비주얼 베이직이나 어떤 다른 .NET 언어가 부적절하기 때문이 아니라, 단지 ASP.NET MVC 프로그래머들이 지금까지는 C#을 가장 많이 사용하고 있기 때문입니다. 한번도 LINQ .NET 3.5를 사용해본 적이 없다 할지라도 걱정할 필요가 없습니다. 3장의 후반부에서 새로운 C# 3에 대해 간결하게 소개하고 있습니다. 그러나 만약 C#을 전혀 접해본 경험이 없다면 다른 도서들을 참고해야 할 것입니다.

     

    이 책은 파트 I과 파트 II, 두 부분으로 나뉘어 있습니다.

     

    파트 I 부분인 1~6장에서는 빠른 시간 안에 잘 따라올 수 있도록 ASP.NET MVC의 신 개념과 현재의 웹 응용 프로그램 아키텍쳐 및 테스트와의 관계에 대해 큰 틀에서 살펴볼 것입니다. 그 중 4개 장은 독자가 직접 MVC의 새로운 개념을 실제 응용 프로그램을 작성하여 기초를 다질 수 있도록 하는 내용을 포함하고 있습니다.

     

    파트 II 부분인 7~16장까지는 MVC 프레임워크의 각 주요 기술들을 심오하게 다루어 거의 모든 MVC 프레임워크 특징으로부터 최대한의 성과를 이끌어낼 수 있도록 도움을 줄 것입니다. 그 중 몇 개 장에서는 보안, deployment와 같은 중요한 주제들과 웹폼 코드의 인테그레이션 또는 마이그레이션에 대한 내용을 포함하고 있습니다.


     

    PART 1 Introducing ASP.NET MVC

    CHAPTER 1 What’s the Big Idea? 3

    CHAPTER 2 Your First ASP.NET MVC Application1 5

    CHAPTER 3 Prerequisites 37

    CHAPTER 4 SportsStore: A Real Application 81

    CHAPTER 5 SportsStore: Navigation and Shopping Cart 121

    CHAPTER 6 SportsStore: Administration and Final Enhancements 171

     

    PART 2 ASP.NET MVC in Detail

    CHAPTER 7 Overview of ASP.NET MVC Projects 203

    CHAPTER 8 URLs and Routing 221

    CHAPTER 9 Controllers and Actions 259

    CHAPTER 10 Views 321

    CHAPTER 11 Data Entry 369

    CHAPTER 12 Ajax and Client Scripting 419

    CHAPTER 13 Security and Vulnerability 459

    CHAPTER 14 Deployment 477

    CHAPTER 15 ASP.NET Platform Features 505

    CHAPTER 16 Combining MVC and WebForms 555

    신고
    Trackback 1 | Comment 0
    Objective-C 2.0(오브젝티브-C 2.0)
    카테고리 컴퓨터/IT
    지은이 마크 달림플 (비제이퍼블릭, 2009년)
    상세보기


    웹 서핑중에 우연히 오브젝티브-C를 처음 시작하신는 분들이 가지는 궁금증을 어느 정도 해결해 줄만한 FAQ를 발견했습니다.
    번역을 해서 올릴까 0.1초 동안 생각을 했지만 능력 부족으로 포기하기로 하였습니다..^^;




    The Objective-C Language

    What is Objective-C?

    Objective-C was invented in the early 1980s by Dr. Brad Cox. The language was developed as an Object-Oriented layer on top of the popular C programming language (in this FAQ and in much other documentation on Objective-C, knowledge of C or a related language is assumed). Cox's original implementation was a preprocessor which generated C code, and was marketed by Stepstone.
    Objective-C is a true superset of C, so the language may vary depending on what version of the C language is supported by the compiler. The additions to C are few: a handful of new keywords, three extra types (of which only one, id, is frequently used) and the message-sending syntax.


    Where is the Objective-C standard?

    There is no standards document describing the Objective-C language as there is for C, C++ and other languages. The canonical descriptions of the language are therefore its implementations; see below.

    What variants of the language exist? How common are they?

    By far the most popular and actively-developed variant of Objective-C is that maintained by Apple, based on the GNU C Compiler. The 'vanilla' GNU C Compiler from the Free Software Foundation also supports the language; its implementation is very similar to that provided by Apple although newer features take some time to trickle down, and the two runtimes are not compatible with each other. David Stes' POC implementation is incompatible with the above two, and doesn't contain many of the features of Apple's Objective-C implementation. On the other hand, it does provide blocks (a Smalltalk feature, also found in Ruby) and class variables. POC is not considered further in this FAQ, due to its incompatibility with the popular Objective-C variants.

    What is Objective-C 2.0?

    With Mac OS X version 10.5 ("Leopard"), Apple introduced some incremental features to the Objective-C language. These features are being marketed as "Objective-C 2.0" and shall be referred to here as ObjC 2. See the section on ObjC 2 below, or where an answer needs further consideration under ObjC 2 discussion will appear in this font style. Currently ObjC 2 features are only available on the Apple runtime in Mac OS X version 10.5. The new features are entirely "opt-in" and there is no compatibility break with the existing Objective-C language.



    Objective-C Development Tools

    How are Objective-C source files named?

    The organisation of Objective-C source is typically similar to that of C or C++ source code, with declarations and object interfaces going into header files named with a .h extension, and definitions and object implementations going in files named with a .m (short for methods) extension.

    What compilers are available?

    The ubiquitous gcc is really the one Objective-C compiler (though there are two flavours, discussed below) found on almost all platforms.
    Historically, NeXT Computer (latterly NeXT Software) and Stepstone produced Objective-C compilers, however both companies no longer exist. NeXT's acquisition of Stepstone's Objective-C rights and Apple's subsequent acquisition of NeXT mean that Apple Computer now control their respective interests in Objective-C. Metrowerks also used to have an Objective-C compiler in their CodeWarrior development environment, but this is now defunct too.

    What development environments are available?

    Objective-C files can be edited in standard text editors, and editors such as emacs have syntax highlighting modes for the language. Integrated Development Environments with support for the Objective-C language include Apple's Xcode and GNUstep's ProjectCenter.



    Class Libraries

    What is a class library?

    With just an Objective-C compiler it's possible to go ahead and code, but you'd have to reinvent a lot of wheels before getting to any interesting programming. A class library provides a pre-made set of objects and classes, usually offering functionality such as containers, data handling and user interfaces.

    What are some of the class libraries available?

    Many of the class libraries available for Objective-C are derived from OpenStep, by NeXT Computer and Sun Microsystems. These include Apple's Mac OS X-specific Cocoa, and the cross-platform GNUstep. Both of these provide class libraries with a Foundation (containers, strings, networking/IPC etc) and AppKit (user interface components), as well as their own specific classes. Implementations of just the Foundation part include OpenDarwin's libFoundation.
    Swarm is an Objective-C framework for agent-based modeling.



    The Objective-C Preprocessor

    What's this #import thing?

    #import is a pre-processor directive similar to C's #include, except that it will not include the same file twice. This makes #ifdef guarding inside header files unnecessary. Some versions of gcc emit warnings when #import is used; you can turn those off with -Wno-import.

    How do I use comments in Objective-C?

    The same comment styles that C supports may be used. They are comments which start with // and run to the end of a line:

    // this is a BCPL-style comment

    and comments which start with /* and end with */:

    /* this is a C comment
     * it spans multiple lines
     * note that comments of this type cannot be nested!
     */



    Objects And Classes

    What type is an object?

    The Objective-C keyword id is a type corresponding to a reference to any object. More rigourous type-checking can be enforced by using a pointer to a specific class, such as MyClass *. Any object whose class is MyClass or one of its subclasses can then be used; an object of any other class used here would cause an error.

    What do self and super mean?

    self is a special variable available in method implementations to refer to the current object (i.e. the one which received the message to invoke this method). super can be used to have an object invoke its superclass's implementation of a method. One common use of both of these is in initialisation:

    -(id)init {
      if((self=[super init])) { // invoke superclass -init
        someIvar=[[MyClass alloc] init];
      }
      return self; //i.e. return this object
    }

    What are class objects?

    The object representing the class of another object can be returned by sending the -class message, as in:

    MyClass *someObject=[[MyClass alloc] init];
    id aClass=[someObject class];

    Class objects behave as instances of the root class (i.e. [aClass class] will return the root class). The object aClass is now the class object MyClass, and responds to class messages in the same way that sending messages to MyClass behaves; e.g. [[aClass alloc] init] will create a new instance of MyClass.

    What is nil ?

    nil is the null object, used to refer to uninitialised or cleared objects (and Nil is the null class object). Unlike in other languages, in Objective-C it is legal to send messages to nil ; the return value is nil for type id , 0 for simple C types such as int , and undefined for compound types such as struct . Both nil and Nil are defined as (id)0 .

    What is @defs?

    The @defs() keyword provides a list of C declarations of the in-memory layout of an object of a given class. It can therefore be used in generating a C API to Objective-C objects:

    struct MyClass_t {
      @defs(MyClass)
    };

    Note that using @defs is generally frowned upon because it breaks encapsulation, although if a library were to use @defs on an object within that library then this problem would not arise.

    How do I stop objects from sending specific messages?

    In short, you don't. You could have the parameters of a message include context information (such as -(id)doSomething:(id)sender) but then you're still dependent on the sender providing accurate context.



    If I changed the instance variables of a class, do I need to recompile everything?

    No - in the FSF and 32-bit Apple (i.e. NeXT) runtime environemnts, you should normally just have to recompile that class and all subclasses. Any C source which uses @defs() (or anywhere else you directly access instance variables) should be recompiled, as the in-memory layout of the class will have changed. Any parts of your code which just access the instance variables through accessor methods or KVC/KVO (see "What are key-value coding and key-value observing?" below) will not need recompiling.

    The reasons for recompilation above are known as the "fragile ivar" or "fragile base class" problem. In those runtimes, the position of an instance variable in an object is determined by the compiler, based on the size and layout of all preceding ivars including those in the object's superclasses. The 64-bit Apple runtime for Objective-C 2.0 doesn't suffer from the fragile base class problem; memory locations of instance variables are not determined in the same way. Therefore the above discussion doesn't apply to that environment. Note that the 64-bit environment doesn't support @defs() at all, so discussion of its behaviour is moot.

    Objective-C 2.0(오브젝티브-C 2.0)
    카테고리 컴퓨터/IT
    지은이 마크 달림플 (비제이퍼블릭, 2009년)
    상세보기



    Categories

    What is a category?

    A category is a way to add methods to a class which already exists. It appears in code as a second set of @interface and @implementation declarations, which contain methods that get added to the class when the category is loaded at runtime. Categories are only available in compilers which implement the gcc variant of Objective-C.

    How do you write a category?

    The interface declaration for a category looks like:

    @interface ClassName (CategoryName)
      -method;
    @end

    The category name has no influence at runtime, but it must be unique with respect to other categories on the same class, and it will appear in stack traces.
    The implementation declaration is similar:

    @implementation ClassName (CategoryName)
      -method {...}
    @end

    What's the point of categories?

    Categories can be used to split a single class's implementation into multiple files by splitting the implementation into categories and putting each one into a different file. Categories can also be used to add methods to a class whose source code you don't control, for example adding a -md5Sum method to a data container that's part of your class library.

    What if multiple categories implement the same method?

    Then the fabric of the Universe as we know it ceases to exist. Actually, that's not quite true, but certainly some problems will be caused. When a category implements a method which has already appeared in a class (whether through another category, or the class' primary @implementation), that category's definition overwrites the definition which was previously present. The original definition can no longer be reached by the Objective-C code. Note that if two categories overwrite the same method then whichever was loaded last "wins", which may not be possible to predict before the code is launched.

    Real problems can occur if the category implements a method with for an existing selector but with a different method signature than the replaced method, depending on the ABI of the running platform code expecting either behaviour may no longer work, and certainly at least one of them is broken.



    Protocols

    What is a protocol?

    A protocol is basically an interface without an implementation. It's a set of messages that are bundled up together in a convenient package. You can then use the protocol to declare that a class implements the entire set of messages, and check objects to see if they conform to the protocol. You can also use protocols in a variable type declaration to show that you need a certain set of methods but don't care about the actual class of the object.

    How do I declare a protocol?

    You declare a protocol like this:

    @protocol ProtocolName
    -method;
    @end

    It's possible for a protocol to inherit from another protocol, which works much like classes where the "parent" protocol's methods get added to the "child". In that case, the first line of the declaration would look like:

    @protocol ProtocolName <ParentProtocol>

    How do I declare a class to conform to a protocol?

    Write the class's interface declaration like this:

    @interface ClassName <ProtocolName>

    To declare conformance to multiple protocols, just separate the protocol names with commas.

    My class implements all the methods in a protocol, but I get a compiler warning.

    By default, when faced with a class like:

    @interface MyClass : NSObject <AProtocol>

    gcc will only look in the interface of MyClass for methods from the AProtocol protocol, and will issue a warning for each method not found there, even if the method is implemented by a superclass. Giving the -Wno-protocol argument to gcc makes it search the class hierarchy for protocol methods.

    How do I check whether an object conforms to a protocol?

    For Object, write:

    [obj conformsTo:@protocol(ProtocolName)]

    For NSObject, write:

    [obj conformsToProtocol:@protocol(ProtocolName)]

    How do I declare a variable type to conform to a protocol?

    To declare a variable which conforms to a protocol but otherwise has no restrictions on type, write:

    id <ProtocolName> obj;

    To declare a variable which is an instance of a certain class (or one of its subclasses) and which also conforms to a protocol, write:

    ClassName <ProtocolName> *obj;

    Note that this construct is rare.

    What's an "informal protocol"?

    An informal protocol isn't actually a protocol at all, but rather a category interface declaration with no corresponding implementation. Informal protocols are frequently used in Cocoa to declare a set of methods to the compiler in a situation where there is no point in having a formal protocol, for example where many methods are optional.

    What's a SEL? How do I get one?

    SEL is a C type referring to a method selector (i.e. they uniquely identify particular messages). They can be obtained through use of the @selector() keyword:

    SEL aSelector=@selector(doSomethingWithStuff:);

    or through use of a runtime function. The appropriate function is sel_getUid() on Apple gcc or sel_get_any_uid on GNU gcc.

    What do perform: and performSelector: do?

    They send the message corresponding to the specified selector to an object. That is, [obj performSelector:@selector(message)] is the same as writing [obj message] . The difference is that perform: and performSelector: can be passed a variable as its argument, whereas a plain [obj message] must always send the same message.

    What is an IMP? How do I get one?

    IMP is a C type referring to the implementation of a method, also known as an implementation pointer. It's a pointer to a function returning id, and with self and a method selector (available inside method definitions as the variable _cmd) as the first arguments:

    id (*IMP)(id, SEL, ...);

    With NSObject, you can obtain the IMP for a given method by doing:

    IMP imp=[obj methodForSelector:@selector(message)];

    For Object, do:

    IMP imp=[obj methodFor:@selector(message)];

    How do I send a message given an IMP?

    Dereference it, as with a C function pointer:

    id anObject, theResult;
    IMP someImp;
    SEL aSelector;
    // ...
    theResult=someImp(anObject,aSelector);

    Can I use IMP for methods returning non-idtypes?

    IMPs are pointers to methods which return id. Just using one with a SEL that doesn't return id could cause trouble, so you should provide a new prototype and cast to that instead:

    int (*foo)(id,SEL);
    int result;
    foo=(int(*)(id,SEL))[anArray methodForSelector:@selector(count)];
    result=foo(anArray,@selector(count));

    If you want to get an IMP using the Objective-C runtime functions, then use objc_msg_lookup(id,SEL) on the GNU runtime (thanks to Justin Hibbits for explaining this) and on the NeXT/Apple runtime, you could use class_getInstanceMethod(Class,SEL) to get a pointer to a struct objc_method, the method_imp member of which is the required IMP.

    Can I use SEL for methods returning non-id types?

    You can do this by either using your runtime's message sending functions directly, or by obtaining the IMP for the method and casting it as discussed in the previous question.

    In the Apple/NeXT runtime, the message sending function is objc_msgSend(id,SEL,...), but beware the many variants which need to be used depending on the return type of the method. See /usr/include/objc/objc-runtime.h or Objective-C Runtime Referencefor more details. A simple example might look like this:

            typedef int (*IntReturn)(id,SEL);
    	NSArray *ary=[NSArray alloc];
    	SEL initSel=@selector(initWithObjects:),countSel=@selector(count);
    	//id returned here
    	ary=objc_msgSend(ary,initSel,@"Hello",@"World",nil);
    	//int returned here
    	c=((IntReturn)objc_msgSend)(ary,countSel);
    	NSLog(@"%@: %d",ary,c);
    

    In the GNU runtime, you could use objc_msg_sendv(id,SEL,arglist_t), which is used for sending any message but requires more setup than objc_msgSend() as a calling frame must be constructed. This example is based on the GNUstep DO code, and as usual doesn't show any memory management (i.e. the calling frame should be destroyed).

            NSArray *ary=[[NSArray alloc] initWithObjects:@"Hello",@"World",nil];
            int *cp;
            SEL countSel=@selector(count);
            Method_t meth=class_get_instance_method([ary class],countSel);
            arglist_t frame=objc_calloc(8,1);
            const char *rettype=objc_skip_type_qualifiers(meth->method_types);
            int stackargs=atoi(objc_skip_typespec(rettype));
            frame->arg_ptr=stackargs?objc_calloc(stackargs,1):0;
            cp=(int *)objc_msg_sendv(ary,countSel,frame);
            NSLog(@"%@: %d",ary,*cp);
    

    Actually it is always simpler just to get the IMP and cast to the appropriate return type, as described in the previous question.

    Objective-C 2.0(오브젝티브-C 2.0)
    카테고리 컴퓨터/IT
    지은이 마크 달림플 (비제이퍼블릭, 2009년)
    상세보기



    Exceptions

    What is an exception?

    An exception is an event which occurs in running a program which causes the normal flow of the program to be interrupted. Programmers coming from other object-oriented languages such as Java will be familiar with exceptions. In Objective-C programming, it's typical to find exceptions used solely for programmer error (such as testing assertions), with user-visible errors being handled as part of the normal program flow.

    How do I use exceptions?

    Exceptions are available currently only with the NeXT gcc runtime; see "Why do people refer to GNU gcc and Apple/NeXT gcc?" below), and must be enabled with gcc's -fobjc-exceptions. Code which could throw an exception is contained in a @try block. This is then followed by one or more @catch blocks to process any exception thrown. A subsequent @finally block may contain code which should be run whether or not an exception occurred. An exception can be any object, and is thrown with the @throw keyword. An example:

    @try {
      //code which may cause an exception to be thrown
      ...
    }
    @catch(MyExceptionClass *ex) {
      // handle a custom exception
      ...
    }
    @catch(id *ex) {
      // generic exception handler
      ...
    }
    @finally {
      // this will happen whether or not an exception occurred.
      ...
    } 

    In the above case, two @catch blocks exist; one for a specific type of exception and one for catching generic exceptions. The most specific handler should always come first. Be warned that exceptions are fragile to changes in the call stack such as goto or return.

    Can exceptions be re-thrown?

    Yes; invoke @throw() with no arguments in the @catch block, in order to re-throw the caught exception.

    I've seen exception-handling code with macros like NS_DURING and NS_HANDLER . What's that?

    Before gcc had an exceptions syntax for Objective-C, Cocoa provided its own exception-handling mechanism, based on macro wrappers for the standard C longjmp() and setjmp() functions. The implementation of Objective-C's language exceptions (i.e. @try and friends) is currently binary compatible with NS_DURING and friends.



    Thread Synchronization

    What is @synchronized?

    @synchronized is a directive that supports simple locks for multithreaded programming. It is only available in the NeXT runtime by invoking the gcc -fobjc-exceptions flag (see Exceptions above). It allows an implicit associated lock with any object, without having to explicitly create or manage locks. If you are familiar with Java, it is basically identical to Java's synchronized construct.

    How do I use @synchronized ?

    The syntax is as follows:

    @synchronized(object) {
      ...
    }

    This will lock on "object", meaning that any other threads which hit a @synchronized directive with the same object will not proceed until this thread has exited its @synchronized block. It is basically the same as this code:

    [[object getLock] lock];
    ...
    [[object getLock] unlock];

    With the exception that the object itself is not responsible for having such methods or managing an explicit lock object.

    What are the advantages?

    Not having to explicitly create or destroy locks can make code easier to write and easier to read. @synchronized is also aware of return statements and exceptions, so you can be sure that the lock is always released even if the flow of control exits from the middle of the block.

    What are the disadvantages?

    @synchronized is slower than explicit locks, because the overhead of looking up the implicit lock is significant. It also always uses a recursive lock, which is slower than a non-recursive lock. It is also less flexible, not supporting condition variables or other advanced threading concepts.



    The gcc Objective-C Compiler

    Why do people refer to GNU gcc and Apple/NeXT gcc?

    The version of gcc used by Apple (and NeXT before them) provides a different Objective-C implementation (specifically, the runtime is different) from that distributed by the Free Software Foundation. Darwin and Mac OS X ship with the Apple gcc, upon which Cocoa depends. Typically other operating systems will have the GNU Objective-C variant, and it is this which GNUstep requires. However the source to both versions of the compiler are available so you could build whichever you want for your platform. Because Apple uses its own version of gcc, the features available in the two variants may differ at any time. Be sure to check the documentation for your version of gcc, to make sure that a feature you expect does indeed exist.

    How do I compile .m files?

    Without any reliance on class libraries, an invocation such as:

    gcc -c myfile.m -lobjc

    will work. Check the documentation for your class library otherwise: for instance with Cocoa you might use:

    gcc -framework Cocoa -c myfile.m

    What is Objective-C++?

    gcc supports the mixing of Objective-C and C++ in files named with a .mm extension, called Objective-C++. This allows, for example, Objective-C objects to be instance variables of C++ objects and vice versa. It does not allow Objective-C classes to inherit from C++ classes or vice versa. The Objective-C and C++ exception mechanisms are completely different too, so you cannot use a C++ catch to catch an @throw n exception.

    What is the class of string constants?

    If you use an Objective-C string literal such as @"Hello world!", then the class of the resulting object will usually be NXConstantString. This can be modified at compile-time though, using gcc's -fconstant-string-class argument. In Cocoa, the class of a string literal is NSConstantString. If you wish to change the constant string class, there is no restriction on the methods it implements but its ivar layout must be the same as that for N[SX]ConstantString (see objc/NXConstStr.h or Foundation/NSString.h) as its in-memory layout will be written into the executable by the compiler.



    Objective-C 2.0 Features

    What's the new for syntax?

    NSArray *bar=...;
    for (id foo in bar)
    {
      [foo doSomething];
    }
    

    will send the -doSomething message to every object in bar. In this respect the new for syntax is conceptually similar to a familiar object enumeration:

    NSArray *bar=...;
    NSEnumerator *e=[bar objectEnumerator];
    id foo;
    while(foo=[e nextObject])
    {
      [foo doSomething];
    }
    

    Although in fact the implementation is different so the new syntax can be much faster, especially on large collections. It also guards against the collection having mutated during the enumeration.

    What is the NSFastEnumeration protocol?

    NSFastEnumeration is the protocol to which collection classes must conform in order to support the ObjC 2 for..insyntax. It declares a single instance method, ��밹ountByEnumeratingWithState:objects:count: which provides a C array of objects used by the for..in loop.

    More information on how NSFastEnumeration is used and how for..in works is in the Objective-C 2.0 language guide.

    How do I start using the garbage collector?

    In principle, this is as simple as turning on the -fobjc-gc or -fobjc-gc-only code generation flag for GCC in your compile process. Certainly for new code that's about the size of it. However, bringing existing code into the garbage-collected world may involve some subtleties.

    In a garbage-collected environment, the traditional memory-management methods of -retain, -release and -autorelease are zeroed out; they not only don't do anything, they never get called. It's very rare for a custom object to override these methods (although Apple have recommended it in implementing the gang of four Singleton pattern), but very frequently an object will clean up any resources it uses in its -dealloc method. Again, this method never gets called in the garbage-collected environment. When an object is simply managing a collection of other objects (e.g. it has an NSString instance variable), then there's nothing to do; instance variables are by default strong references in the GC environment so the link between the object and the string will be honoured by the collector. When the object manages some custom memory, it must be capable of deallocating that memory when the object disappears.

    One way of achieving this, though not a recommended way, is to implement a -finalize method. This method is guaranteed to be called once when the object disappears, but there are few guaranteed preconditions; in particular, linked objects may (or may not) have already been collected. The garbage collector must wait until the -finalize method is complete before it may continue, so performing time-consuming operations inside this method is also not recommended. An object must not cause itself to be "resurrected" inside -finalize, which could happen if it refers to itself in a message to another object. Better would be to try and ensure that all referenced memory is managed by the GC, using NSMakeCollectable() on Core Foundation references, or declaring non-id instance variables with the __strong keyword. For more information, see the Garbage Collection Programming Guide.

    Objective-C 2.0(오브젝티브-C 2.0)
    카테고리 컴퓨터/IT
    지은이 마크 달림플 (비제이퍼블릭, 2009년)
    상세보기



    Cocoa and GNUstep

    How do I include the root class?

    #import <Foundation/NSObject.h>

    For completeness, note that NSProxy is also a root class.

    How can I forward messages between objects?

    If an object receives a message it doesn't respond to, the runtime will also send it a -forwardInvocation: message before an error occurs. This means that you can override the method -(void)forwardInvocation:(NSInvocation *)inv in your class to have unrecognised messages forwarded to other objects; see Forwarding at developer.apple.com. You also need to override -(NSMethodSignature *)methodSignatureForSelector:(SEL)selector otherwise it returns nil and forwardInvocation: does not get called.

    Here's a simple example of forwarding, which is used to internalise a loop performed on a collection class. That is, we're going to give collections a way to send a message to each of their contents. Firstly, a trampoline class CollectionTrampoline is required which, given a collection, forwards any message it receives to the contents of that collection. This is the interface for the class:

    @interface CollectionTrampoline : NSProxy
    {
    	id theCollection;
    }
    - (id)initOnCollection:(id)aCollection;
    @end
    

    Here are the instantiation and deallocation methods:

    - (id)initOnCollection:(id)aCollection
    {
    	theCollection=[aCollection retain];
    	return self;
    }
    
    - (void)dealloc
    {
    	[theCollection release];
    	[super dealloc];
    }
    

    As described above, we need to override -methodSignatureForSelector: to have forwarding work. There's no API provided for constructing method signatures, so here we find the method signature from the first object in the collection. If that doesn't work, then we supply a default method signature; that doesn't really matter because if we didn't already get a signature then either the collection is empty so no forwarding will occur, or the first object doesn't implement the method so we'll raise an exception before doing any work. Thanks to Michael Ash for supplying this example.

    - (NSMethodSignature *)methodSignatureForSelector:(SEL)aSelector
    {
      NSMethodSignature *sig = nil;
    
      if([theCollection count])
        sig = [[theCollection objectAtIndex:0] methodSignatureForSelector:aSelector];
    
      if(!sig)
        sig = [NSObject instanceMethodSignatureForSelector:@selector(release)];
    
       return sig;
    }
    

    Now our implementation of -forwardInvocation:. Here, an NSEnumerator is used to iterate through the objects, and the method is invoked on each. In this simple example, the return values from the objects is not considered. A complete example would build up a collection of the responses and pass that back.

    - (void)forwardInvocation:(NSInvocation *)anInv
    {
    	id i;
    	NSEnumerator *en=[theCollection objectEnumerator];
    	
    	while(i=[en nextObject])
    	{
    		[anInv invokeWithTarget:i];
    	}
    }
    

    Finally, the collection classes must have a way to return a trampoline object. Here's a category on NSArray to do that:

    @interface NSArray (Trampolines)
    - (id)do;
    @end
    
    @implementation NSArray (Trampolines)
    - (id)do
    {
    	return [[[CollectionTrampoline alloc] initOnCollection:self] autorelease];
    }
    @end
    

    Now this trampoline can be used to send a message to every object in a collection:

    [[anArray do] doSomething];

    How can I forward messages between remote objects?

    This is known in Cocoa and GNUstep as Distributed Objects, or DO. DO can be used to send messages to an object in a different process, in a different thread in the same process or even to a process running on a different system. The server application vends an object by registering it with a name service. A client application acquires a connection to this vended object by querying the name service, when it receives a proxy for the vended object. From there, DO is transparent; messages sent to the proxy object get forwarded to the remote object and its result passed back to the proxy as if the local object itself were performing the methods. Here's an example, with comments, which shows a simple use of DO; for more information see Apple DO guide or GNUstep DO tutorial. This example does not use networked DO, nor does it properly take care of errors.

    DOprotocol.h

    This protocol is included in both the server and the client, and describes the messages which the vended object can respond to. In this case, there is only one such message.

    @protocol DOExampleProtocol
    -(NSNumber *)myPid;
    @end

    DOserver.m

    The server process.

    #import <Cocoa/Cocoa.h>
    #import "DOprotocol.h"
    #import <sys/types.h>
    #import <unistd.h>
    
    @interface VendedObject : NSObject <DOExampleProtocol>{
    }
    -(NSNumber *)myPid;
    @end
    
    @implementation VendedObject
    -(NSNumber *)myPid
    {
    	NSLog(@"Vending out my pid...");
    	return [NSNumber numberWithInt:getpid()];
    }
    @end
    
    int main (int argc, const char * argv[]) {
        NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
    	VendedObject *vo=[[VendedObject alloc] init];
    
            //get the default DO connection
    	NSConnection *conn=[NSConnection defaultConnection];
    	BOOL status;
    
            //set which object we vend, and register with the name server	
    	[conn setRootObject:vo];
    	status=[conn registerName:@"VendingServer"];
    	if(status==NO)
    	{
    		NSLog(@"Couldn't register as VendingServer");
    		exit(EXIT_FAILURE);
    	}
    
            //now wait for connections
    	[[NSRunLoop currentRunLoop] run];
    	
        [pool release];
        return 0;
    }
    

    DOclient.m

    This client just looks on the local machine for a DO server with the appropriate name, then gets the pid of the remote process.

    #import <Foundation/Foundation.h>
    #import <stdlib.h>
    #import "DOprotocol.h"
    
    int main (int argc, const char * argv[]) {
        NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
    	
    	//specify a protocol below for compiler type checking
    	id <DOExampleProtocol> clientObject;
    	NSNumber *serverPid;
    	
    	/*find a server with the appropriate name and get a proxy from it.
    	 * using nil as the host means localhost-only.
    	 */
    	clientObject=(id <DOExampleProtocol>)[NSConnection rootProxyForConnectionWith
    RegisteredName:@"VendingServer" host:nil]; /* -setProtocolForProxy: tells the DO mechanism that the remote object * conforms to the specified protocol. This means that it doesn't check * messages in that protocol before sending them. Other messages not in * the given protocol may still be sent. */ [clientObject setProtocolForProxy:@protocol(DOExampleProtocol)]; if(clientObject==nil) { NSLog(@"Error: did not get a proxy object for VendingServer service"); exit(EXIT_FAILURE); } serverPid=[clientObject myPid]; if(serverPid!=nil) { NSLog(@"Remote server on pid %@",serverPid); } else { NSLog(@"Error, did not get the server's pid"); exit(EXIT_FAILURE); } [pool release]; return 0; }



    How does reference counting work?

    I'm in fact going to take this as an opportunity to answer the related question, "how do I manage object lifecycles in (Cocoa|GNUstep|Cocotron)" when there's no garbage collector around? There are two steps to generating most objects, allocating the memory for an instance and then initialising that instance. Both steps must be performed to have a useful instance of an object, so the messages are usually chained:

    GLObject *myObject = [[GLObject alloc] init];

    The above line says "allocate memory for an instance of a GLObject, and initialise it". Note that this myObject is my object; because I created it I have declared an interest in the existence of myObject.

    When creating a brand new class, there's a simple convention in the initialiser which gets all of the management details correct. -[GLObject init] would usually look like:

    - (GLObject *)init
    {
      if (self = [super init])
      {
        //do something with all of my own instance variables
      }
      return self;
    }

    This method first initialises the superclass (remember that an instance of a class can also be treated as an instance of its superclass), then performs any initialisation specific to this class. It only does that if the superclass' initialiser doesn't return nil, which is a conventional way to indicate that the initialisation didn't work.

    Note that it's rare to override +alloc, which does all the runtime-level memory grabbing (actually it doesn't, it calls +allocWithZone:, and that does all the memory grabbing).

    As mentioned above, I now own that initialised object. The other cases in which I own an object are if I create a -copy, or if I find some object that already exists, and I want it to stay around; in this last case I would send it a -retain message, which increments its reference count. If I don't want the object any more, I should -release it. The object will be deallocated (i.e. destroyed) only when all of the interested parties have released it; we say that the object's reference count has decreased to zero. When this happens, the object gets the -dealloc message. In an overridden -dealloc, the last task should be a call to [super dealloc].

    Any other object is not owned by me. I therefore do not need to worry about disposing of it; it's someone else's responsibility. Frequently, objects which I receive without taking ownership are said to be autoreleased objects. That means that they have been sent the -autorelease message before I got them. There is a class in Cocoa called NSAutoreleasePool, which manages deferred releasing of objects.

    A good article on reference counting is Hold Me, Use Me, Free Me.

    Note that the FSF version of GCC can use the Boehm conservative garbage collector in managing Objective-C memory, and not the Apple garbage collector.

    Ok, just One More Thing... I mentioned that allocation and initialisation are required in most cases. Of course, static objects (such as @"string constants" and @protocol()s) are written directly into the executable code and so never need initialising.

    How do I memory-manage @"strings"?

    I wrote in the refcounting answer that string constants - instances of NSConstantString declared like @"this" - are written directly into the application binary and therefore do not need to be initialised. Does this mean that they must be given special treatment in the reference-counted memory model?

    No. In fact, if you treat string constants just like other objects as described above and in the referenced article, you won't run into memory management issues with them. In particular, this means that if you create a string by doing:

    NSString *myString = @"Hello, world!";

    then you are not responsible for disposing of it.

    What are key-value coding and key-value observing?

    In Cocoa, Key-Value Coding (KVC) and Key-Value Observing (KVO) provide an indirect route to inspecting and modifying properties of an object. The principle use of KVC and KVO is in Cocoa Bindings, an efficient approach to synchronising an application's user interface with its data model.

    If the object myObject provides accessor methods such as -someVariable and -setSomeVariable , or an instance variable called someVariable or _someVariable , where someVariable is of type id , then the value of someVariable can be accessed (even if it's a derived property) through code such as:

    [myObject valueForKeyPath:@"someVariable"];
    [myObject setValue:@"Hello" forKeyPath:@"someVariable"];

    Another object, such as myOtherObject , could be notified when the value of someVariable changes through KVO:

    [myObject addObserver:myOtherObject forKeyPath:@"someVariable" options:NSKeyValue
    ObservingOptionNew context:NULL];

    now when someVariable is modified, myOtherObject will receive a -observerValueForKeyPath:ofObject:change:context: message.
    See the KVO Programming Guide and the KVC programming guide.


    Objective-C 2.0(오브젝티브-C 2.0)
    카테고리 컴퓨터/IT
    지은이 마크 달림플 (비제이퍼블릭, 2009년)
    상세보기



    신고
    Trackback 1 | Comment 0
    Objective-C 2.0(오브젝티브-C 2.0)
    카테고리 대학교재
    지은이 마크 달림플 (비제이퍼블릭, 2009년)
    상세보기

    진작에 올려드렸어야 하는 것인데 게으름으로 인하여 이제서야 몇 가지 아마존에 올라온 리뷰 내용을 올려드립니다. 안되는 능력으로 제가 직접 번역을 하는 바람에 번역의 질에 문제가 많으니 감안하시길 부탁드리겠습니다.^^;


    아마존에서는 여전히 높은 등수를 유지하고 있습니다(2009년 9월 6일 현재)

    #1 in  Books > Computers & Internet > Programming > C > Tutorials
    #2 in  Books > Computers & Internet > Programming > Introductory & Beginning
     


    28 of 31 people found the following review helpful:

    Very useful and a fun read, January 8, 2009

    By 

    S. Looker (Union City, CA USA) - See all my reviews  

    최근부터 책을 읽기 시작했습니다. 일단, 저는 이미 오브젝티브-C 익숙하다는 것을 알려드리고, 대체로 새로 출간된 도서로부터 하나, 또는 정도의 유용한 부분들을 발견하고는 한답니다.

    제가 책을 정말 즐겨 읽은 이유는 바로 다른 전문 서적들과는 달리 가볍게 읽을 있게 구성이 되었다는 것입니다. 딱딱하고 매력 없는 수백 줄의 문장들과 단지 페이지를 채우기 위해 같은 내용을 되풀이하는 다른 책들에 비해, 책은 오브젝트-C 순서에 맞게 순조롭게 설명을 하고 있습니다.


    각각의 주제들에 대해 흘러가듯 적당한 분량으로 설명을 하고 있는데, 결코 내용이 겹치거나 부풀려져 있지 않습니다. 예제들은 읽기 편하게 쓰여져 있고, 더불어 책에서 말하고자 하는 바를 분명히 나타내고 있습니다.

    [메모리 관리] 같은 부분의 설명은 매우 직관적으로 설명이 되어 있습니다. 오브젝티브-C 2.0 새로운 아이템에 대해서도 다루고 있고, 최신 버전의 Xcode 대한 내용도 포함하고 있습니다.

    적어도 C 언어 또는 비슷한 프로그래밍 언어에 대한 경험이 있는 사람들을 대상으로 쓰여졌기 때문에, 만약 이미 이런 언어들에 대한 지식이 없다면 책으로 오브젝티브-C 시작하기에는 무리가 있습니다. 책은 오브젝티브-C 다루고 있지만 코코아(Cocoa) 중요한 파트에 대해서도 살짝 다루고 있습니다.

    오브젝티브-C 처음 접하는 분들과 이미 오브젝티브-C 다룰 아는 프로그래머들이 필요할 때마다 바로 참고할 있는 서적으로 책을 강력 추천합니다.

     

     

    17 of 19 people found the following review helpful:

    Good intro for Mac or iPhone programming, January 4, 2009

    By 

    Timothy T. Hume - See all my reviews  

    책은 오브젝티브-C 입문용 도서로 손색이 없으며 Xcode 코코아에 대한 정보 또한 소개하고 있습니다.

    또한 다른 프로그래밍 언어에 경험은 있으나 아직 또는 아이폰을 위한 프로그래밍을 해보지 못한 프로그래머들에게 그것을 시도할 있는 준비를 갖출 있도록 도와줍니다.

    심지어 중급 또는 경험이 많은 프로그래머도 책에서 유용한 정보를 얻을 있을 것이라고 생각합니다.

     

    오브젝티브-C 배우기 위한 많은 정보를 책에서 발견할 있습니다. 또한 그런 정보들은 지나치지 않을 정도로 핵심적입니다. 만약 제가 오브젝티브-C 처음 시작했을 이런 도서가 있었다면 정말 도움이 되었으리라 생각합니다.

    Objective-C 2.0(오브젝티브-C 2.0)
    카테고리 대학교재
    지은이 마크 달림플 (비제이퍼블릭, 2009년)
    상세보기


    19 of 22 people found the following review helpful:

    stars Best Programming Book I've read in a loooooonnng time, January 12, 2009

    By 

    Biff (NY, USA) - See all my reviews

    이 책은 이제껏 제가 읽어본 책 중 최고의 프로그래밍 책이라고 말씀드릴 수 있습니다. 저는 "읽었다"라고 말한 부분을 강조하고 싶은데, 이 책을 참고서로 사용했다기 보다는 , 사실 처음부터 끝까지 한 번에 읽어버린, 이 책은 그 정도로 읽기 쉽게 쓰여진 책입니다. 얼마나 많은 기술 서적들이 이와 같이 읽힐 수 있다고 말할 수 있을까요?

    이 책의 설명들은 매우 간결하고 초보자이든 오랫동안의 경험이 있는 프로그래머이든 이해하기 쉽게 쓰였습니다. 이 책을 읽는 것 자체도 즐거웠을 뿐만 아니라 오브젝티브-C의 코드를 읽고 작성하는데도 많은 도움이 되었습니다. 저자는 기술 서적의 집필 방법에 새로운 장을 열었고, 저는 이 책이 당연히 그만큼 관심을 받을 만 하다고 생각합니다
    .

    마크 트웨인은 "단어(word)와 적합한 단어(right word)의 차이는 번개(lightning)와 반딧불이(lightning bug)와의 차이와 같다"라고 말했습니다. 이 책을 읽어본 결과, 저자는 적합한 단어를 쓰기 위해 매우 고심했다는 것을 알 수 있었습니다
    .

    저는 보통 도서 리뷰를 쓰지 않는 편이지만 이 책은 너무 훌륭해서 이렇게 리뷰를 남겨서라도 다른 사람들이 이 책에 대해 알기를 원했습니다.


    9 of 11 people found the following review helpful:

    Clear ~and~ funny, December 29, 2008

    By 

    L. Dill (Los Gatos, CA) - See all my reviews  

    책의 내용 이상 무엇을 바랄 있을까요?
    특히, 내용을 요약하고 중요한 부분을 나타낸 NOTE 마음에 들었습니다. 초보자가 만약 책을 보고 공부한다면 거의 노력 없이도 일정 수준의 오브젝티브-C 프로그래머가 있습니다. 책의 내용중의 문구처럼 즐기기만 하면 것입니다. " 장에서는 여러분은 개의 오브젝티브-C 프로그램을 작성했다. 재미있지 않았는가!"



    4 of 5 people found the following review helpful:

    A great introductory Obj-C book and tutorial, January 11, 2009

    By 

    M. Zabetian "Gadget Critic" (California) - See all my reviews  

    수년 , 냅스터가 다른 도서 하나로 프로그래밍을 배울 있었습니다. 현재, 책은 아이폰 프로그래밍을 배우기 위한 초석을 다질 있는 도서라고 생각합니다. 저자는 책이 흥미진진한 진행을 유지할 있도록 노력하였으며, 수많은 유추법을 통해 가리키자 하는 것을 기술하였습니다.

     

    책은 또한 샘플 프로그램의 작성과 맥과 아이폰 프로그래밍에 필요할 중요 컨셉들에 충분히 익숙해 있도록 Xcode 코코아에 대해서도 다루고 있습니다.

    목차는 C 언어의 확장에 대해 기술하는 것으로 시작하여 개체, 클래스, 메서드, 상속, 컴포지션, 메모리 관리, 카테고리, 프로토콜... 순으로 진행이 됩니다.


    저는 이 책을 아이폰과 맥 프로그래밍을 위한 오브젝티브-C를 배우고 싶어하는, 이미 C 언어에 대한 지식이 있는 프로그래머에게 강력하게 추천합니다. 여러분은 제가 그랬던 것처럼 이 책을 즐길 수 있을 것입니다.


    Objective-C 2.0(오브젝티브-C 2.0)
    카테고리 대학교재
    지은이 마크 달림플 (비제이퍼블릭, 2009년)
    상세보기

    신고
    Trackback 0 | Comment 0



    비제이퍼블릭의 첫 책인 ☞[오브젝티브-C 2.0]이 출간 시 이미 한 출판사에서 Objective-C 관련 도서가 출간이된 상태였으며, 얼마 후면 더 많은 도서가 출간될 것 같습니다. 그만큼 오브젝티브-c에 관심을 두고 계신 분들이 많다는 의미여서 좋기도 하지만, 한편으로는 모두 만만치 않은 경쟁도서(?)가 될것 같아 어떤 도서들이 출간될지 궁금하기도 합니다.^^ 이 시점에서 간단하게나마 저희 비제이퍼블릭의 도서만의 가장 큰 특징 두 가지를 소개해 드리도록 하겠습니다.

    다른 도서들과 비교시 오브젝티브-C 2.0 - 아이폰과 맥 OS X를 위한 Objective-C은 다음과 같은 특징이 있습니다.


    1. C 언어에 어느 정도 경험이 있는 독자를 대상으로 한다.
    - C 언어 기초를 이미 알고 있는 개발자분들(물론, 대부분 알고 계시겠죠?)을 위해 쓰여져, 책 내용상 C 언어에 대한 언급이 없이 바로 오브젝티브-C만의 핵심 내용만을 살펴볼 수 있도록 구성되어 있습니다. C 언어를 전혀 모르고 있다면 다른 C 언어 기본서를 참고하여 이 책을 읽어 나가야 하겠지만, C 언어를 이미 알고 있는 상태라면 오브젝티브-C 책에서 그 내용을 다시 살펴볼 필요가 전혀 없겠죠?^^

    2. Xcode에 대한 내용을 포함한다.
    다른 도서에 비해 맥(Mac) OS X에서의 개발 환경이 포함되어 있어, 맥 개발 환경에 익숙치 않은 사람들에게 빠르게 Xcode 에디터에 적응할 수 있도록 도와줍니다. 한 장(7장)에 걸쳐 맥에서 프로그래밍을 시작하는 아이폰 & 맥 애플리케이션 개발자분들이 더욱 쉽고 편하고 빠르게 접근할 수 있도록 생산성 부분에 초점을 두고 설명이 되어 있습니다.

    확대


    ↓더보기를 클릭하시면 7장 세부목차를 보실수 있습니다.

    더보기

    2009/08/06 - 아이폰과 맥 OS X 개발을 위한 오브젝티브-C(Objective-C) 2.0
    2009/07/30 - 아이폰과 맥 OS X 개발을 위한 오브젝티브-C(Objective-C) 2.0 [1장, 2장 공개]


    위의 목차에서도 알 수 있듯이, 7장에서는 아주 대표적인 몇개의 XCode 단축키를 알려주고 있습니다. 그래서, 그 단축키 모음을 올려드려야겠다....하고 생각하다가!! 웹서핑 중 다음의 사이트에서 아주 좋은 자료를 발견하였습니다.

    ☞ [Xcode 단축기 보러가기]

    클릭해서 들어가 보시면 알겠지만, Colin Wheeler라는 분이 Xcode의 단축기를 .png와 .pdf로 아주 잘 정리를 해놓았습니다.


    여담으로 실제로 보면 표지가 굉장히 이쁜데 웹에서는 조금 표현이 되지 않는 것 같아서 아쉽습니다.^^ 대부분 번역서의 경우 원서의 표지를 따라가는 경우가 많은데, 비제이퍼블릭에서는 앞으로도 비제이퍼블릭만의 을 나타낼 수 있는 표지로 여러분을 찾아 뵙도록 하겠습니다. 많은 관심 부탁드리겠습니다! 감사합니다.

    ※참고로 아이폰 관련 최근 뉴스를 하나 링크해 드립니다. 이제서야 아이폰 도입이 눈앞에 있다는 것을 느낄수 있는 기사인 것 같습니다.  ☞ 아이뉴스24


    Objective-C 2.0(오브젝티브-C 2.0) 상세보기



    신고
    Trackback 0 | Comments 2

    퍼블릭's Blog is powered by Daum & tistory