검색
[eBook 리얼타임 이벤트] 한빛미디어가 책 읽는 IT개발자를 응원합니다!


> > 97 Things Every Programmer Should Know
97 Things Every Programmer Should Know

크게보기 미리보기

97 Things Every Programmer Should Know

Kevlin Henney 지음 | 원서 | 2010년 02월 | OReilly Media

정가
36,000원
판매가
32,400원 (10% off)
이코인
1,620원 (5%)
배송비
무료 배송비란
상태
절판
독자리뷰
총 리뷰 0개 , 평균별점
블로거리뷰
총 리뷰 0
트랙백주소
http://www.hanbit.co.kr/trackback/9780596809492

페이지 : 256쪽 | ISBN : 9780596809492 | 난이도 : 초/중급 | 변환코드 : 8948

부록 : 없음

페이스북 트위터 미투데이 e메일
리뷰쓰기
  • 책소개
  • 저자소개
  • 목차
  • 독자리뷰
  • 블로거리뷰
  • 오탈자보기
  • 예제소스
  • 추천서적

책소개

With this book, you get 97 short and extremely useful programming tips from some of the most experienced and respected practitioners in the industry, including Uncle Bob Martin, Scott Meyers, Dan North, Linda Rising, Udi Dahan, Neal Ford, and many more. They encourage you to stretch yourself by learning new languages, looking at problems in new ways, following specific practices, taking responsibility for your work, and becoming as good at the entire craft of programming as you possibly can.

This wealth of practical knowledge contains principles that apply to projects of all types. You can read the book end to end, or easily browse through to find topics of particular interest. 97 Things Every Programmer Should Know is a useful reference and a source of inspiration.
  • Tap into the knowledge of expert programmers who have earned stellar reputations
  • Learn the basic wisdom every programmer needs, regardless of the language you use
  • Take advantage of the online presence that has evolved from this book project
맨위로

저자소개

Kevlin Henney
Kevlin Henney is an independent consultant and trainer. His work focuses on patterns and architecture, programming techniques and languages, and development process and practice. He has been a columnist for various magazines and online publications, including The Register, Better Software, Java Report, CUJ, and C++ Report. Kevlin is co-author of two volumes in the Pattern-Oriented Software Architecture series: A Pattern Language for Distributed Computing and On Patterns and Pattern Languages. He also contributed to 97 Things Every Software Architect Should Know.


맨위로

목차

Chapter 1 : Act with Prudence 
Chapter 2 : Apply Functional Programming Principles 
Chapter 3 : Ask, "What Would the User Do?" (You Are Not the User) 
Chapter 4 : Automate Your Coding Standard 
Chapter 5 : Beauty Is in Simplicity 
Chapter 6 : Before You Refactor 
Chapter 7 : Beware the Share 
Chapter 8 : The Boy Scout Rule 
Chapter 9 : Check Your Code First Before Looking to Blame Others 
Chapter 10 : Choose Your Tools with Care 
Chapter 11 : Code in the Language of the Domain 
Chapter 12 : Code Is Design 
Chapter 13 : Code Layout Matters 
Chapter 14 : Code Reviews 
Chapter 15 : Coding with Reason 
Chapter 16 : A Comment on Comments 
Chapter 17 : Comment Only What the Code Cannot Say
Chapter 18 : Continuous Learning
Chapter 19 : Convenience Is Not an -ility
Chapter 20 : Deploy Early and Often
Chapter 21 : Distinguish Business Exceptions from Technical
Chapter 22 : Do Lots of Deliberate Practice
Chapter 23 : Domain-Specific Languages
Chapter 24 : Don't Be Afraid to Break Things
Chapter 25 : Don't Be Cute with Your Test Data
Chapter 26 : Don't Ignore That Error!
Chapter 27 : Don't Just Learn the Language, Understand Its Culture
Chapter 28 : Don't Nail Your Program into the Upright Position
Chapter 29 : Don't Rely on "Magic Happens Here"
Chapter 30 : Don't Repeat Yourself
Chapter 31 : Don't Touch That Code!
Chapter 32 : Encapsulate Behavior, Not Just State
Chapter 33 : Floating-Point Numbers Aren't Real
Chapter 34 : Fulfill Your Ambitions with Open Source
Chapter 35 : The Golden Rule of API Design
Chapter 36 : The Guru Myth
Chapter 37 : Hard Work Does Not Pay Off
Chapter 38 : How to Use a Bug Tracker
Chapter 39 : Improve Code by Removing It
Chapter 40 : Install Me
Chapter 41 : Interprocess Communication Affects Application Response Time
Chapter 42 : Keep the Build Clean
Chapter 43 : Know How to Use Command-Line Tools
Chapter 44 : Know Well More Than Two Programming Languages
Chapter 45 : Know Your IDE
Chapter 46 : Know Your Limits
Chapter 47 : Know Your Next Commit
Chapter 48 : Large, Interconnected Data Belongs to a Database
Chapter 49 : Learn Foreign Languages
Chapter 50 : Learn to Estimate
Chapter 51 : Learn to Say, "Hello, World"
Chapter 52 : Let Your Project Speak for Itself
Chapter 53 : The Linker Is Not a Magical Program
Chapter 54 : The Longevity of Interim Solutions
Chapter 55 : Make Interfaces Easy to Use Correctly and Hard to Use Incorrectly
Chapter 56 : Make the Invisible More Visible
Chapter 57 : Message Passing Leads to Better Scalability in Parallel Systems
Chapter 58 : A Message to the Future
Chapter 59 : Missing Opportunities for Polymorphism
Chapter 60 : News of the Weird: Testers Are Your Friends
Chapter 61 : One Binary
Chapter 62 : Only the Code Tells the Truth
Chapter 63 : Own (and Refactor) the Build
Chapter 64 : Pair Program and Feel the Flow
Chapter 65 : Prefer Domain-Specific Types to Primitive Types
Chapter 66 : Prevent Errors
Chapter 67 : The Professional Programmer
Chapter 68 : Put Everything Under Version Control
Chapter 69 : Put the Mouse Down and Step Away from the Keyboard
Chapter 70 : Read Code
Chapter 71 : Read the Humanities
Chapter 72 : Reinvent the Wheel Often
Chapter 73 : Resist the Temptation of the Singleton Pattern
Chapter 74 : The Road to Performance Is Littered with Dirty Code Bombs
Chapter 75 : Simplicity Comes from Reduction
Chapter 76 : The Single Responsibility Principle
Chapter 77 : Start from Yes
Chapter 78 : Step Back and Automate, Automate, Automate
Chapter 79 : Take Advantage of Code Analysis Tools
Chapter 80 : Test for Required Behavior, Not Incidental Behavior
Chapter 81 : Test Precisely and Concretely
Chapter 82 : Test While You Sleep (and over Weekends)
Chapter 83 : Testing Is the Engineering Rigor of Software Development
Chapter 84 : Thinking in States
Chapter 85 : Two Heads Are Often Better Than One
Chapter 86 : Two Wrongs Can Make a Right (and Are Difficult to Fix)
Chapter 87 : Ubuntu Coding for Your Friends
Chapter 88 : The Unix Tools Are Your Friends
Chapter 89 : Use the Right Algorithm and Data Structure
Chapter 90 : Verbose Logging Will Disturb Your Sleep
Chapter 91 : WET Dilutes Performance Bottlenecks
Chapter 92 : When Programmers and Testers Collaborate
Chapter 93 : Write Code As If You Had to Support It for the Rest of Your Life
Chapter 94 : Write Small Functions Using Examples
Chapter 95 : Write Tests for People
Chapter 96 : You Gotta Care About the Code
Chapter 97 : Your Customers Do Not Mean What They Say Appendix : Contributors 
Colophon
맨위로
독자리뷰
(총 리뷰 0개 , 평균별점 )   
리뷰쓰기
맨위로
블로거리뷰
(총 리뷰 0개)
 
맨위로

예제소스

등록된 예제소스가 없습니다.
맨위로

  • 회사소개
  • 인재채용
  • 기획 및 원고 모집
  • 이용약관
  • 개인정보취급방침
  • 고객센터
  • 사이트맵
Copyrightⓒ1993-2010 Hanbit Media, Inc. All rights reserved.

경영혁신형 중소기업 인증 소비자피해보상보험 가입사실확인 애니서트 인증마크