Saturday 15 November 2014

Here Are Most Important 97 Things Every Programmer Should Know

  1. Tap into the wisdom of experts to learn what every programmer should know, no matter what language you use. 

  2. 97 Things Every Programmer S


  3. With the 97 short and extremely useful tips for programmers , you'll expand your skills by adopting new approaches to old problems, learning appropriate best practices, and honing your craft through sound..


  4.  1 Act with Prudence

  5.  2 Apply Functional Programming Principles

  6.  3 Ask, "What Would the User Do?" (You Are Not the User)

  7.  4 Automate Your Coding Standard

  8.  5 Beauty Is in Simplicity

  9.  6 Before You Refactor

  10.  7 Beware the Share

  11.  8 The Boy Scout Rule

  12.  9 Check Your Code First Before Looking to Blame Others

  13.  10 Choose Your Tools with Care

  14.  11 Code in the Language of the Domain

  15.  12 Code Is Design

  16.  13 Code Layout Matters

  17.  14 Code Reviews

  18.  15 Coding with Reason

  19.  16 A Comment on Comments

  20.  17 Comment Only What the Code Cannot Say

  21.  18 Continuous Learning

  22.  19 Convenience Is Not an -ility

  23.  20 Deploy Early and Often

  24.  21 Distinguish Business Exceptions from Technical

  25.  22 Do Lots of Deliberate Practice

  26.  23 Domain-Specific Languages

  27.  24 Don't Be Afraid to Break Things

  28.  25 Don't Be Cute with Your Test Data

  29.  26 Don't Ignore That Error!

  30.  27 Don't Just Learn the Language, Understand Its Culture

  31.  28 Don't Nail Your Program into the Upright Position

  32.  29 Don't Rely on "Magic Happens Here"

  33.  30 Don't Repeat Yourself

  34.  31 Don't Touch That Code!

  35.  32 Encapsulate Behavior, Not Just State

  36.  33 Floating-Point Numbers Aren't Real

  37.  34 Fulfill Your Ambitions with Open Source

  38.  35 The Golden Rule of API Design

  39.  36 The Guru Myth

  40.  37 Hard Work Does Not Pay Off

  41.  38 How to Use a Bug Tracker

  42.  39 Improve Code by Removing It

  43.  40 Install Me

  44.  41 Interprocess Communication Affects Application Response Time

  45.  42 Keep the Build Clean

  46.  43 Know How to Use Command-Line Tools

  47.  44 Know Well More Than Two Programming Languages

  48.  45 Know Your IDE

  49.  46 Know Your Limits

  50.  47 Know Your Next Commit

  51.  48 Large, Interconnected Data Belongs to a Database

  52.  49 Learn Foreign Languages

  53.  50 Learn to Estimate

  54.  51 Learn to Say, "Hello, World"

  55.  52 Let Your Project Speak for Itself

  56.  53 The Linker Is Not a Magical Program

  57.  54 The Longevity of Interim Solutions

  58.  55 Make Interfaces Easy to Use Correctly and Hard to Use Incorrectly

  59.  56 Make the Invisible More Visible

  60.  57 Message Passing Leads to Better Scalability in Parallel Systems

  61.  58 A Message to the Future

  62.  59 Missing Opportunities for Polymorphism

  63.  60 News of the Weird: Testers Are Your Friends

  64.  61 One Binary

  65.  62 Only the Code Tells the Truth

  66.  63 Own (and Refactor) the Build

  67.  64 Pair Program and Feel the Flow

  68.  65 Prefer Domain-Specific Types to Primitive Types

  69.  66 Prevent Errors

  70.  67 The Professional Programmer

  71.  68 Put Everything Under Version Control

  72.  69 Put the Mouse Down and Step Away from the Keyboard

  73.  70 Read Code

  74.  71 Read the Humanities

  75.  72 Reinvent the Wheel Often

  76.  73 Resist the Temptation of the Singleton Pattern

  77.  74 The Road to Performance Is Littered with Dirty Code Bombs

  78.  75 Simplicity Comes from Reduction

  79.  76 The Single Responsibility Principle

  80.  77 Start from Yes

  81.  78 Step Back and Automate, Automate, Automate

  82.  79 Take Advantage of Code Analysis Tools

  83.  80 Test for Required Behavior, Not Incidental Behavior

  84.  81 Test Precisely and Concretely

  85.  82 Test While You Sleep (and over Weekends)

  86.  83 Testing Is the Engineering Rigor of Software Development

  87.  84 Thinking in States

  88.  85 Two Heads Are Often Better Than One

  89.  86 Two Wrongs Can Make a Right (and Are Difficult to Fix)

  90.  87 Ubuntu Coding for Your Friends

  91.  88 The Unix Tools Are Your Friends

  92.  89 Use the Right Algorithm and Data Structure

  93.  90 Verbose Logging Will Disturb Your Sleep

  94.  91 WET Dilutes Performance Bottlenecks

  95.  92 When Programmers and Testers Collaborate

  96.  93 Write Code As If You Had to Support It for the Rest of Your Life

  97.  94 Write Small Functions Using Examples

  98.  95 Write Tests for People

  99.  96 You Gotta Care About the Code

  100.  97 Your Customers Do Not Mean What They Say

  101. Source: http://goo.gl/Hp6HVk

No comments:

Post a Comment

Download

Subscribe