代码大全（英文版）资源-CSDN文库

需积分: 50 188 浏览量 2014-03-01 23:09:02 上传评论 1 收藏 3.37MB DOCX 举报

《代码大全》是一本专注于提高软件工程实践水平的著作，旨在缩小行业专家、教授与商业实践中普遍做法之间的差距。作者关注的问题是许多高效编程技术在学术论文和期刊中被隐藏多年，才逐渐被广大程序员所采纳。近年来，尽管尖端的软件开发实践取得了显著进步，但普通商业实践并未跟上步伐。书中指出，很多软件项目仍然存在错误、延误和超出预算的问题，甚至无法满足用户需求。研究表明，一项研究成果通常需要5到15年甚至更长时间才能转化为商业实践。这本手册的目标就是加速这一过程，让普通程序员能够立即掌握关键的发现。因此，《代码大全》适合所有级别的程序员阅读，无论你是初学者还是有经验的开发者，都能从中受益。对于经验丰富的程序员来说，本书将帮助他们创建质量更高的软件，并提高工作效率，减少问题的出现。通过深入理解过去遇到的问题，你可以学会如何预防未来可能出现的问题。书中介绍的编程实践方法有助于管理大型项目，使你在项目需求变化时能够成功地维护和修改软件。对于初级和中级程序员，本书将提供一个全面的视角，揭示软件开发的最佳实践，指导如何编写可读性更强、可维护性更好的代码。它会教导你如何避免常见的编程陷阱，提高代码质量，从而提升整个项目的稳健性。书中可能涵盖的主题包括但不限于： 1. 设计模式和架构原则：如何设计易于理解和扩展的代码结构。 2. 测试驱动开发：如何利用单元测试和集成测试确保代码的正确性。 3. 代码重构：如何改进现有代码，提高其效率和可读性。 4. 错误处理：有效的异常处理策略，以及如何预防和修复错误。 5. 代码审查：团队合作中的最佳实践，如何通过审查提高代码质量。 6. 性能优化：如何分析和改进代码性能，避免不必要的计算和资源消耗。 7. 版本控制：如何利用Git等工具进行协作和版本管理。 8. 文档编写：编写清晰的注释和文档，以便他人理解和维护你的代码。 9. 持续集成/持续部署(CI/CD)：自动化构建和部署流程，确保快速迭代和可靠交付。《代码大全》不仅仅是一本技术指南，它还涵盖了软件开发过程中的软技能，如团队沟通、项目管理和时间管理，这些都是成功软件开发的关键组成部分。通过阅读这本书，你将能够提升自己的专业素养，更好地适应快速变化的软件开发环境。

资源详情

资源评论

Preface

The gap between the best software engineering practice and the average practice is

very wide—perhaps wider than in any other engineering discipline. A tool that

disseminates good practice would be important.

—Fred Brooks

My primary concern in writing this book has been to narrow the gap between the

knowledge of industry gurus and professors on the one hand and common commercial

practice on the other. Many powerful programming techniques hide in journals and

academic papers for years before trickling down to the programming public.

Although leading-edge software-development practice has advanced rapidly in recent

years, common practice hasn't. Many programs are still buggy, late, and over budget,

and many fail to satisfy the needs of their users. Researchers in both the software

industry and academic settings have discovered effective practices that eliminate most

of the programming problems that have been prevalent since the 1970s. Because these

practices aren't often reported outside the pages of highly specialized technical journals,

however, most programming organizations aren't yet using them today. Studies have

found that it typically takes 5 to 15 years or more for a research development to make

its way into commercial practice (Raghavan and Chand 1989, Rogers 1995, Parnas

1999). This handbook shortcuts the process, making key discoveries available to the

average programmer now.

Who Should Read This Book?

The research and programming experience collected in this handbook will help you to

create higher-quality software and to do your work more quickly and with fewer

problems. This book will give you insight into why you've had problems in the past and

will show you how to avoid problems in the future. The programming practices

described here will help you keep big projects under control and help you maintain and

modify software successfully as the demands of your projects change.

Experienced Programmers

This handbook serves experienced programmers who want a comprehensive, easy-to-

use guide to software development. Because this book focuses on construction, the most

familiar part of the software life cycle, it makes powerful software development

techniques understandable to self-taught programmers as well as to programmers with

formal training.

Technical Leads

Many technical leads have used Code Complete to educate less-experienced

programmers on their teams. You can also use it to fill your own knowledge gaps. If

you're an experienced programmer, you might not agree with all my conclusions (and I

would be surprised if you did), but if you read this book and think about each issue,

only rarely will someone bring up a construction issue that you haven't previously

considered.

Self-Taught Programmers

If you haven't had much formal training, you're in good company. About 50,000 new

developers enter the profession each year (BLS 2004, Hecker 2004), but only about

35,000 software-related degrees are awarded each year (NCES 2002). From these

figures it's a short hop to the conclusion that many programmers don't receive a formal

education in software development. Self-taught programmers are found in the emerging

group of professionals—engineers, accountants, scientists, teachers, and smallbusiness

owners—who program as part of their jobs but who do not necessarily view themselves

as programmers. Regardless of the extent of your programming education, this

handbook can give you insight into effective programming practices.

Students

The counterpoint to the programmer with experience but little formal training is the

fresh college graduate. The recent graduate is often rich in theoretical knowledge but

poor in the practical know-how that goes into building production programs. The

practical lore of good coding is often passed down slowly in the ritualistic tribal dances

of software architects, project leads, analysts, and more-experienced programmers.

Even more often, it's the product of the individual programmer's trials and errors. This

book is an alternative to the slow workings of the traditional intellectual potlatch. It

pulls together the helpful tips and effective development strategies previously available

mainly by hunting and gathering from other people's experience. It's a hand up for the

student making the transition from an academic environment to a professional one.

Where Else Can You Find This

Information?

This book synthesizes construction techniques from a variety of sources. In addition to

being widely scattered, much of the accumulated wisdom about construction has resided

outside written sources for years (Hildebrand 1989, McConnell 1997a). There is nothing

mysterious about the effective, high-powered programming techniques used by expert

programmers. In the day-to-day rush of grinding out the latest project, however, few

experts take the time to share what they have learned. Consequently, programmers may

have difficulty finding a good source of programming information.

The techniques described in this book fill the void after introductory and advanced

programming texts. After you have read Introduction to Java, Advanced Java, and

Advanced Advanced Java, what book do you read to learn more about programming?

You could read books about the details of Intel or Motorola hardware, Microsoft

Windows or Linux operating-system functions, or another programming language—you

can't use a language or program in an environment without a good reference to such

details. But this is one of the few books that discusses programming per se. Some of the

most beneficial programming aids are practices that you can use regardless of the

environment or language you're working in. Other books generally neglect such

practices, which is why this book concentrates on them.

Few practicing programmers have the time to read through the hundreds of books and

journal articles that have been distilled into this handbook. The research and realworld

experience gathered into this handbook will inform and stimulate your thinking about

your projects, enabling you to take strategic action so that you don't have to fight the

same battles again and again.

Absence of hype Some software books contain 1 gram of insight swathed in 10 grams

of hype. This book presents balanced discussions of each technique's strengths and

weaknesses. You know the demands of your particular project better than anyone else.

This book provides the objective information you need to make good decisions about

your specific circumstances.

Concepts applicable to most common languages This book describes techniques you

can use to get the most out of whatever language you're using, whether it's C++, C#,

Java, Microsoft Visual Basic, or other similar languages.

Numerous code examples The book contains almost 500 examples of good and bad

code. I've included so many examples because, personally, I learn best from examples. I

think other programmers learn best that way too.

The examples are in multiple languages because mastering more than one language is

often a watershed in the career of a professional programmer. Once a programmer

realizes that programming principles transcend the syntax of any specific language, the

doors swing open to knowledge that truly makes a difference in quality and

productivity.

To make the multiple-language burden as light as possible, I've avoided esoteric

language features except where they're specifically discussed. You don't need to

understand every nuance of the code fragments to understand the points they're making.

If you focus on the point being illustrated, you'll find that you can read the code

regardless of the language. I've tried to make your job even easier by annotating the

significant parts of the examples.

Access to other sources of information This book collects much of the available

information on software construction, but it's hardly the last word. Throughout the

chapters, "Additional Resources " sections describe other books and articles you can

read as you pursue the topics you find most interesting.

Book website Updated checklists, books, magazine articles, Web links, and other

content are provided on a companion website at cc2e.com. To access information

related to Code Complete, 2d ed., enter cc2e.com/ followed by a four-digit code, an

example of which is shown here in the left margin. These website references appear

throughout the book.

Why This Handbook Was Written

The need for development handbooks that capture knowledge about effective

development practices is well recognized in the software-engineering community. A

report of the Computer Science and Technology Board stated that the biggest gains in

software-development quality and productivity will come from codifying, unifying, and

distributing existing knowledge about effective software-development practices (CSTB

1990, McConnell 1997a). The board concluded that the strategy for spreading that

knowledge should be built on the concept of software-engineering handbooks.

The Topic of Construction Has Been Neglected

At one time, software development and coding were thought to be one and the same.

But as distinct activities in the software-development life cycle have been identified,

some of the best minds in the field have spent their time analyzing and debating

methods of project management, requirements, design, and testing. The rush to study

these newly identified areas has left code construction as the ignorant cousin of software

development.

Discussions about construction have also been hobbled by the suggestion that treating

construction as a distinct software development activity implies that construction must

also be treated as a distinct phase. In reality, software activities and phases don't have to

be set up in any particular relationship to each other, and it's useful to discuss the

activity of construction regardless of whether other software activities are performed in

phases, in iterations, or in some other way.

Construction Is Important

Another reason construction has been neglected by researchers and writers is the

mistaken idea that, compared to other software-development activities, construction is a

relatively mechanical process that presents little opportunity for improvement. Nothing

could be further from the truth.

Code construction typically makes up about 65 percent of the effort on small projects

and 50 percent on medium projects. Construction accounts for about 75 percent of the

errors on small projects and 50 to 75 percent on medium and large projects. Any

activity that accounts for 50 to 75 percent of the errors presents a clear opportunity for

improvement. (Chapter 27 contains more details on these statistics.)

Some commentators have pointed out that although construction errors account for a

high percentage of total errors, construction errors tend to be less expensive to fix than

those caused by requirements and architecture, the suggestion being that they are

therefore less important. The claim that construction errors cost less to fix is true but

misleading because the cost of not fixing them can be incredibly high. Researchers have

found that small-scale coding errors account for some of the most expensive software

errors of all time, with costs running into hundreds of millions of dollars (Weinberg

1983, SEN 1990). An inexpensive cost to fix obviously does not imply that fixing them

should be a low priority.

The irony of the shift in focus away from construction is that construction is the only

activity that's guaranteed to be done. Requirements can be assumed rather than

developed; architecture can be shortchanged rather than designed; and testing can be

abbreviated or skipped rather than fully planned and executed. But if there's going to be

a program, there has to be construction, and that makes construction a uniquely fruitful

area in which to improve development practices.

剩余63页未读，继续阅读

评论收藏

内容反馈

代码大全（英文版）

评论0

最新资源

代码大全（英文版）

评论0

最新资源

相关推荐

代码大全英文版

代码大全 英文版

代码大全2 英文版

代码大全1

代码大全2 中文版附英文版(完整清晰pdf版)

空白文件生成器(EmptyFilesCreator)v1.0英文绿色免费版

ZedGraph源码全英文

代码大全第二版英文版

代码大全（英文版 第二版）.mobi

Code Complete 2nd（代码大全 英文版）

code complete（2edition） 代码大全 英文版

代码大全英文版(mobi格式)

代码大全（英文版）chm格式

代码大全2 中文版英文版

[代码大全2中文版和英文版(完整清晰版)].rar

中文转英文代码

英文打字游戏源代码

中国省市区数据库（含邮编、行政代码、区号、英文缩写）

对26个英文字母进行哈夫曼编码

html颜色代码表、颜色英文代码全集

代码大全2中文版和英文版(完整清晰版)part4

代码大全中文版2

《Steve McConnell代码大全第二版（中英文双份）》

代码大全 pdf chm 英文版

[代码大全2中文版和英文版(完整清晰版)].part05.rar

代码大全2英文版（chm）

代码大全2中文版和英文版(完整清晰版)

代码大全2中文版和英文版(完整清晰版)part1

代码大全英文版

代码大全（英文版第二版）.mobi

Code Complete 2nd（代码大全英文版）

code complete（2edition）代码大全英文版