|
|
本帖最后由 Gorgon_Meducer 于 2012-10-11 10:31 编辑
>>写在前面的话
傻孩子读书喜欢两种风格：
其一，书超级的厚，但是讲解非常通俗易懂，看起来轻松加愉快，每天阅读一点，用不了多久就能吃下一本厚厚的书，
相当有成就感——很多国外的原版书籍就是这种风格。典型的有《The Art of Assemble》、《Algorithms in
C》、《Operation System》、《Sams - C++ Primer Plus》。
其二，书相当薄，但是其中没有一句是废话，也没有一句故弄玄虚。讲述的多半是思想而非具体方法。
但凡遇到这两类书，我都回忍不住要据为己有——我一般轻易不敢去新华书店，去了必要花销百十大洋……心痛啊……
比起电子书籍，我更喜欢在自己的书上评点一番，写写画画。搞不好，这还是初中养成的坏习惯。
[技术类书籍]
《AI for Game Developers》
• Table of Contents
• Reviews
• Examples
• Reader Reviews
• Errata
• Academic
AI for Game Developers
By David M. Bourg, Glenn Seeman
Publisher : O'Reilly
Pub Date : July 2004
ISBN : 0-596-00555-5
Pages : 400
Written for the novice AI programmer, AI for Game Developers introduces you to techniques such as finite state machines, fuzzy logic, neural networks, and many others, in straightforward, easy-to-understand language, supported with code samples throughout the entire book (written in C/C++). From basic techniques such as chasing and evading, pattern movement, and flocking to genetic algorithms, the book presents a mix of deterministic (traditional) and non-deterministic (newer) AI techniques aimed squarely at beginners AI developers.
点击此处下载(文件大小:2.81M)
《C++ Primer Plus,Fourth Edition》
• Table of Contents
• Index
C++ Primer Plus, Fourth Edition
By Stephen Prata
Publisher : Sams Publishing
Pub Date : November 14, 2001
ISBN : 0672322234
Pages : 1128
C++ Primer Plus, Fourth Edition presents the ANSI C++ standard beginning with a discussion of the essential elements of C++ programming: loops, expressions, functions, and classes. It walks readers through the basics of object-oriented programming: classes, inheritance, templates, and exceptions, as well as the latest object-oriented programming techniques. C++ Primer Plus contains hundreds of sample programs. The friendly tone, concise programs, and end-of-chapter review exercises allow beginners to write their own programs immediately.
点击此处下载(文件大小:4.34M)
《Designing Embedded Communications Software》
by T. Sridhar
ISBN:157820125x
CMP Books © 2003 (207 pages)
With this foundation, you explore a development model that addresses the complete range of issues in the design of embedded communications software, including real-time operating systems, hardware and software partitioning, layering, and protocol stacks.
点击此处下载(文件大小:4.45M)
《Programming Embedded Systems》
By Michael Barr, Anthony Massa
...............................................
Publisher: O'Reilly
Pub Date: October 01, 2006
ISBN: 0-596-00983-6
Pages: 304
Overview
If you have programming experience and a familiarity with C--the dominant language in embedded systems--Programming Embedded Systems, Second Edition is exactly what you need to get started with embedded software. This software is ubiquitous, hidden away inside our watches, DVD players, mobile phones, anti-lock brakes, and even a few toasters. The military uses embedded software to guide missiles, detect enemy aircraft, and pilot UAVs. Communication satellites, deep-space probes, and many medical instruments would have been nearly impossible to create without embedded software.
The first edition of Programming Embedded Systems taught the subject to tens of thousands of people around the world and is now considered the bible of embedded programming. This second edition has been updated to cover all the latest hardware designs and development methodologies.
The techniques and code examples presented here are directly applicable to real-world embedded software projects of all sorts. Examples use the free GNU software programming tools, the eCos and Linux operating systems, and a low-cost hardware platform specially developed for this book. If you obtain these tools along with Programming Embedded Systems, Second Edition, you'll have a full environment for exploring embedded systems in depth. But even if you work with different hardware and software, the principles covered in this book apply.
Whether you are new to embedded systems or have done embedded work before, you'll benefit from the topics in this book, which include:
How building and loading programs differ from desktop or server computers
Basic debugging techniques--a critical skill when working with minimally endowed embedded systems
Handling different types of memory
Interrupts, and the monitoring and control of on-chip and external peripherals
Determining whether you have real-time requirements, and whether your operating system and application can meet those requirements
Task synchronization with real-time operating systems and embedded Linux
Optimizing embedded software for size, speed, and power consumption
Working examples for eCos and embedded Linux
So whether you're writing your first embedded program, designing the latest generation of hand-held whatchamacalits, or managing the people who do, this book is for you. Programming Embedded Systems will help you develop the knowledge and skills you need to achieve proficiency with embedded software.
Praise for the first edition: "This lively and readable book is the perfect introduction for those venturing into embedded systems software development for the first time. It provides in one place all the important topics necessary to orient programmers to the embedded development process. --Lindsey Vereen, Editor-in-Chief, Embedded Systems Programming
点击此处下载(文件大小:1.61M)
《GCC: Complete Reference》
Arthur Griffith
McGraw-Hill/Osborne
New York Chicago San Francisco
Lisbon London Madrid Mexico City
Milan New Delhi San Juan
Seoul Singapore Sydney Toronto
Introduction
It can be argued that the current free-software movement is the most important
thing happening in computing today. We are in the midst of a major shift from
all software being proprietary and closely held by individual companies to a large
body of software that can be freely acquired and used by anyone for any purpose.
Free software now includes not only programming language compilers and linkers,
but numerous utilities, graphical user interface environments, and even entire
operating systems.
Add all this to the fact that virtually all free software is compiled by GCC, and
it can be argued that GCC is the most important piece of software in the world. Of
course, programs are written in many languages, and there are compilers for these
languages, but for the most part these compilers are written and compiled using GCC.
At some point, all free software harks back to GCC. Some computer companies have
begun to drop support for their own compilers and simply install GCC instead. It’s
free for the taking and is constantly being extended and maintained.
With the addition of the two latest languages to the GCC family—Java and Ada—
the GCC compiler is spreading its wings even further. This brings the total number
of active languages in GCC to six: C, C++, Objective-C, Fortran, Java, and Ada.
Development is in progress on other languages, such as COBOL, and they will be
added to GCC if there is enough support behind them.
xxi
Milestones
The GNU Project was launched in 1984 for the purpose of developing a free operating
system. Richard Stallman is the founder of the GNU Project and the original author
of GCC.
The initial release of the first beta of GCC, release number 0.9, was on March 22, 1987.
The first actual release, version 1.0, was on May 23, 1987. In all there have been 108
releases from the very beginning to the release on which this book is based—version
3.1, released on May 5, 2002. That’s an average of one release every 1.7 months for
the last 15 years.
What’s Inside?
The purpose of this book is to provide information to those wishing to use GCC for
software development. A good bit of information can be found about GCC internals
that can be used to get you started in the direction of working inside the compiler, but
the main idea behind this book is to guide you through the steps of installing and using
the compiler to develop software. Any way that you care to measure software, GCC is
huge. And like most huge software systems, it contains useful features that you can use
only if you discover that they exist, determine exactly what it is they do, and figure out
how to use them. That’s the primary purpose of this book.
The book is divided into three parts. Part I, “The Free Software Compiler,” serves as
an introduction to the fundamentals of the compiler and includes instructions you can
follow to download and install it. Part II, “Using the Compiler Collection,” contains
detailed instructions for using the compiler. A chapter is dedicated to each of the six
programming languages, with several examples of each. Special chapters are included
to describe the preprocessor and techniques for linking objects produced from different
languages. Part III, “Peripherals and Internals,” includes chapters on linking, debugging,
cross-compiling, makefiles, and the GNU assembler. Part III also contains information
on the inner workings of both the front end and back end of the compiler.
GCC is the world’s champion in the number of command-line options available.
These options are listed alphabetically in Appendix D and cross-referenced in
Appendix C. Chapter 21 contains even more command-line options—the ones that have
to do with the specific computer hardware for which the compiler is generating code.
To give you a better idea of the topics covered in this book, here’s a short
description of each chapter:
Chapter 1 is a general introduction to the fundamental concepts of GCC,
including a list of its parts and the languages it compiles.
Chapter 2 contains procedures you can use to install GCC.
Chapter 3 describes the workings of the preprocessor and how you can employ
it to process the source code of a language.
xxii G C C : T h e C o m p l e t e R e f e r e n c e
Chapter 4 contains examples of compiling and linking C.
Chapter 5 contains examples of compiling and linking C++.
Chapter 6 contains examples of compiling and linking Objective-C.
Chapter 7 contains examples of compiling and linking Fortran.
Chapter 8 contains examples of compiling and linking Java.
Chapter 9 contains examples of compiling and linking Ada.
Chapter 10 contains examples of mixing two languages to create a single
executable.
Chapter 11 explains how the internationalization facilities can be employed
in your compiled program to allow its displayed strings to be modified to fit
a locale.
Chapter 12 contains examples of producing and using static and shared
libraries.
Chapter 13 explains the fundamentals of using the GNU debugger.
Chapter 14 describes the use of make and its associated utilities.
Chapter 15 discusses the GNU assembler and describes how you can use it in
conjunction with GCC.
Chapter 16 describes the process required to configure GCC to compile and link
programs to be executed on another computer.
Chapter 17 describes how GCC can be used to produce code for an embedded
system.
Chapter 18 contains examples of generating useful output from the compiler
other than object code.
Chapter 19 describes the rudiments of using lex and yacc to create a language
front end for GCC.
Chapter 20 describes the content of the intermediate language produced by the
compiler front end and read by the compiler back end.
Chapter 21 contains a list of the command-line options that apply versions of
GCC running on specific hardware.
Appendix A contains a copy of the GNU Public License.
Appendix B lists the environment variables that effect GCC.
Appendix C is a cross-reference of the command-line options by category.
Appendix D is an alphabetical listing of the command-line options.
Appendix E is a glossary.
点击此处下载 ourdev_359271.pdf(文件大小:5.73M) (原文件名:GCC--Complete Reference.pdf)
《Microsoft Windows驱动程序模型设计》
PUBLISHED BY
微软出版社
微软公司的子公司
One Microsoft Way Redmond, Washington 98052-6399
版权 沃尔特 oney 1999 所有版权保留.
没有出版者的书面许可这本书的内容的任何部份不可以复制或传播不论何种形式的或无论如何。
Library of Congress Cataloging-in-Publication Data Oney, Walter.
Programming the Microsoft Windows Driver Model p. cm. Includes index.
ISBN 0-7356-0588-2
1. Microsoft Windows NT device drivers (Computer programs)
2. Computer programming. I. Title QA76.76.D49O54 1999 005.7'126--dc21 99-33878 CIP
印刷和装订于美国。
1 2 3 4 5 6 7 8 9 QMQM 4 3 2 1 0 9
发行在加拿大by企鹅书业加拿大股份有限公司
此书的CIP目录分类档案生效在英国图书馆。
Microsoft Press books are available through booksellers and distributors worldwide. For further information about international editions, contact your local Microsoft Corporation office or contact Microsoft Press International directly at fax (425) 936-7329. Visit our Web site at mspress.microsoft.com. Intel is a registered trademark of Intel Corporation. Microsoft, Microsoft Press, MSDN, Visual C++, Visual Studio, Win32, Windows, and Windows NT are either registered trademarks or trademarks of Microsoft Corporation in the United States and/or other countries. Other product and company names mentioned herein may be the trademarks of their respective owners. The example companies, organizations, products, people, and events depicted herein are fictitious. No association with any real company, organization, product, person, or event is intended or should be inferred.
采集编辑: Ben Ryan
项目编辑: Devon Musgrave
技术编辑: Robert Lyon
点击此处下载 ourdev_469677.rar(文件大小:6.88M) (原文件名:Microsoft Windows驱动程序模型设计.rar)
Professional
Visual Studio® 2008 Extensibility
Professional Visual Studio® 2008 Extensibility
Published by
Wiley Publishing, Inc.
10475 Crosspoint Boulevard
Indianapolis, IN 46256
Copyright © 2008 by Wiley Publishing, Inc., Indianapolis, Indiana
Published simultaneously in Canada
ISBN: 978-0-470-23084-8
Manufactured in the United States of America
10 9 8 7 6 5 4 3 2 1
Library of Congress Cataloging-in-Publication Data is available from the publisher
Introduction
Visual Studio is a development IDE created by Microsoft to enable easier development for Microsoft
programming languages and development technologies. Visual Studio has been the most popular IDE
for working with Microsoft development products for a decade.
Visual Studio, itself, is extensible. This extensibility has many aspects and includes several options.
Extensibility is a key feature of Visual Studio — important enough to dedicate a book (or even several
books) to the subject. A growing number of community requests for more resources on Visual Studio
Extensibility encouraged Wrox to think about publishing such a book. Unlike other Microsoft
technologies, this part of Visual Studio doesn ’ t have rich resources. Only a few books have been written,
back in the days of .NET 1.0 and 1.1, and they didn ’ t cover the topic thoroughly (they just focused on
add - ins and macros). Moreover, some new features have been added to VS Extensibility over the years
that definitely warrant coverage in a book.
Wrapping Up
When Katie Mohr, the acquisitions editor of this book, suggested that I work on a title about Visual
Studio add - ins and extensions with C#, I had no idea how broad and deep this topic could be! During
the writing process, I learned many new things, which made me change a lot in the book, even its title!
To ensure that readers understand the subject correctly, this introduction is somewhat different from
most other Wrox books. I ’ m assuming that readers have at least a minimum level of knowledge about
topics related to Visual Studio Extensibility before reading the book. I won ’ t be leaving the main topic to
teach general .NET concepts, because I want to keep chapters as short and simple as possible.
Technology evolves quickly, so developers need to quickly learn new techniques and concepts. Of
course, books can ’ t reflect everything about a topic, so I thought it would be a good idea to share some
ideas, tricks, and new material about Visual Studio Extensibility on an online resource. With that in
mind, I ’ ve joined with the authors of Professional Visual Studio 2008 (Wrox, 2008) to set up a dedicated
website about Visual Studio, in order to write about related topics and provide readers with additional
help. This site is online at www.professionalvisualstudio.com . A work in progress, the authors of
Professional Visual Studio 2008 and I are continuously improving and adding to this site, and developing
it further to be another resource about Visual Studio.
You can also check out my blog at www.nayyeri.net where I share technical material with my
subscribers. I use both sites as complementary resources for the content provided in this book.
About Visual Studio Extensibility
Working on a book about Visual Studio Extensibility (VSX) and spending a lot of time on aspects of this
topic in depth (or at least more depth than what most developers are accustomed to), I found that many
developers consider Visual Studio Extensibility a hard topic to learn, and its APIs very complex.
Microsoft has made several attempts to address this in recent months (before the release of Visual Studio
2008 and in parallel with it), and one of its main strategies was generating a good solid community for
Visual Studio Extensibility.
Despite this support, however, anyone who is working with VSX needs a good understanding of the
current position of the topic and its community. Note that I ’ m writing this introduction in December
2007, just a few weeks after Visual Studio 2008 was released and while Microsoft was trying hard to fill
the holes that I outline in a moment.
I agree that Visual Studio Extensibility is hard to learn, especially in comparison with most .NET - related
topics, but this isn ’ t because of its inherent nature, which I ’ ll say more about in a moment. I also
agree that Visual Studio APIs, especially those related to extensibility features, aren ’ t written well. Some
call these APIs “ dirty ” because there is no good structure, naming convention, or consistency between
these APIs.
This Old COM - Based Product
One reason for the difficulty is that Visual Studio is now 10 years old. This product was created in COM
days for COM programming, but migrated to .NET. Now that .NET is the common way to develop
software for Microsoft products, developers learn .NET codes easier and faster because it has more
references from which to learn, and because .NET has a great design, with simplicity at its core.
Visual Studio is built on COM components, and most of traditional extensibility relies heavily on COM
programming. Moving forward from COM to .NET, Visual Studio has revamped itself in order to look
more familiar to .NET users, while retaining its COM nature. It has used .NET and COM interoperability
at advanced levels to do this. However, many .NET developers may not know about .NET and COM
interoperability at this level, making it hard for them to work with Visual Studio Extensibility.
Some new features of Visual Studio Extensibility are based on newer technologies, and thus are easier to
learn — or at least Microsoft has tried to provide these extensibility points in a way that developers can
work with easily, without worrying about the underlying layers. An example of this is code snippets,
which are easy to develop and deploy even when you don ’ t know what ’ s going on under the hood. In
any case, the main extensibility options, such as add - ins, VSPackages, and the Visual Studio Shell, rely
on COM components and interfaces.
Variety of Extensibility Options
Another reason for its difficulty is the sheer variety of Visual Studio Extensibility options. During the
past 10 years, Visual Studio has continued to grow and new extensibility features have been added to it.
Learning all these options with their different purposes, natures, and implementations isn ’ t so easy.
Many extensibility features are broad topics themselves, such as add - ins, macros, the Visual Studio Shell,
or the new domain - specific language tools in Visual Studio. Conversely, extensibility options can be
grouped at different levels based on their priority. Learning all these topics can present quite a challenge,
especially because these options aren ’ t closely related to general .NET programming topics — they ’ re
completely new and specific to Visual Studio.
...
点击此处下载 ourdev_484523.rar(文件大小:7.48M) (原文件名:Professional Visual Studio Extensibility.rar)
《Beginning C# 2008 Databases》
Because most real-world applications interact with data stored in relational databases,
every C# programmer needs to know how to access that data. This book specifically covers
how to interact with the SQL Server 2005 database using C# 2008. This book also covers
LINQ and ADO.NET 3.5, the most exciting features of .NET Framework 3.5. The chapters
that shed light on database concepts will help you understand those concepts better than
you would have learning them from a pure database concepts book. We also cover many
new features of T-SQL, which SQL Server 2005 now incorporates.
This book has been written in such a way that beginners will easily understand the
text and even professionals will benefit from the instruction within. If you want to use
Visual Studio 2008 to build database applications, this is the right book for you; the text
will not only walk you through all the concepts that an application developer may have
to use, but also explain each piece of code you will write for example applications.
The chapters in this book are organized in such a manner that you will build a strong
foundation before moving on to more advanced techniques.
Who This Book Is For
If you are an application developer who likes to interact with databases using C#, this
book is for you, as it covers programming SQL Server 2005 using C# 2008.
This book does not require or even assume that you have sound knowledge of C# 2.0
and SQL Server 2000 and database concepts. We have covered all the fundamentals that
other books assume a reader must have before moving on with the chapters.
This book is a must for any application developer who intends to interact with databases
using C# 2008 as the development tool; if this is you, then this book is a must.
What This Book Covers
This book covers Visual Studio 2008, SQL Server 2005, C# 2008, LINQ, and ADO.NET 3.5.
All these topics are covered in the form of chapters that explain these tools and technologies
using various concepts and code examples. We also modeled the applications used
in this book on real-life applications, so you can utilize the concepts that you will learn
throughout this book in your professional life.
点击此处下载 ourdev_527201.pdf(文件大小:11.64M) (原文件名:Beginning C# 2008 Databases.pdf)
《The Art of Assembly Language》
Why Would Anyone Learn This Stuff? Forward
Amazing! You’re actually reading this. That puts you into one of three categories: a student who is
being forced to read this stuff for a class, someone who picked up this book by accident (probably
because you have yet to be indoctrinated by the world at large), or one of the few who actually have an
interest in learning assembly language.
Egads. What kind of book begins this way? What kind of author would begin the book with a forward
like this one? Well, the truth is, I considered putting this stuff into the first chapter since most people never
bother reading the forward. A discussion of what’s right and what’s wrong with assembly language is very
important and sticking it into a chapter might encourage someone to read it. However, I quickly found
that university students can skip Chapter One as easily as they can skip a forward, so this stuff wound up
in a forward after all.
So why would anyone learn this stuff, anyway? Well, there are several reasons which come to mind:
• Your major requires a course in assembly language; i.e., you’re here against your will.
• A programmer where you work quit. Most of the source code left behind was written
in assembly language and you were elected to maintain it.
• Your boss has the audacity to insist that you write your code in assembly against your
strongest wishes.
• Your programs run just a little too slow, or are a little too large and you think assembly
language might help you get your project under control.
• You want to understand how computers actually work.
• You’re interested in learning how to write efficient code.
• You want to try something new.
Well, whatever the reason you’re here, welcome aboard. Let’s take a look at the subject you’re about
to study.
单击这里下载
《The Object-Oriented Programming with ANSI-C》
Preface
No programming technique solves all problems.
No programming language produces only correct results.
No programmer should start each project from scratch.
Object-oriented programming is the current cure-all — although it has been
around for much more then ten years. At the core, there is little more to it then
finally applying the good programming principles which we have been taught for
more then twenty years. C++ (Eiffel, Oberon-2, Smalltalk ... take your pick) is the
New Language because it is object-oriented — although you need not use it that
way if you do not want to (or know how to), and it turns out that you can do just as
well with plain ANSI-C. Only object-orientation permits code reuse between projects
— although the idea of subroutines is as old as computers and good programmers
always carried their toolkits and libraries with them.
This book is not going to praise object-oriented programming or condemn the
Old Way. We are simply going to use ANSI-C to discover how object-oriented programming
is done, what its techniques are, why they help us solve bigger problems,
and how we harness generality and program to catch mistakes earlier. Along
the way we encounter all the jargon — classes, inheritance, instances, linkage,
methods, objects, polymorphisms, and more — but we take it out of the realm of
magic and see how it translates into the things we have known and done all along.
I had fun discovering that ANSI-C is a full-scale object-oriented language. To
share this fun you need to be reasonably fluent in ANSI-C to begin with — feeling
comfortable with structures, pointers, prototypes, and function pointers is a must.
Working through the book you will encounter all the newspeak — according to
Orwell and Webster a language ‘‘designed to diminish the range of thought’’ — and
I will try to demonstrate how it merely combines all the good programming principles
that you always wanted to employ into a coherent approach. As a result, you
may well become a more proficient ANSI-C programmer.
The first six chapters develop the foundations of object-oriented programming
with ANSI-C. We start with a careful information hiding technique for abstract data
types, add generic functions based on dynamic linkage and inherit code by judicious
lengthening of structures. Finally, we put it all together in a class hierarchy that
makes code much easier to maintain.
Programming takes discipline. Good programming takes a lot of discipline, a
large number of principles, and standard, defensive ways of doing things right. Programmers
use tools. Good programmers make tools to dispose of routine tasks
once and for all. Object-oriented programming with ANSI-C requires a fair amount
of immutable code — names may change but not the structures. Therefore, in
chapter seven we build a small preprocessor to create the boilerplate required. It
looks like yet another new object-oriented dialect language (yanoodl perhaps?) but
it should not be viewed as such — it gets the dull parts out of the way and lets us
concentrate on the creative aspects of problem solving with better techniques. ooc
(sorry) is pliable: we have made it, we understand it and can change it, and it
writes the ANSI-C code just like we would.
The following chapters refine our technology. In chapter eight we add dynamic
type checking to catch our mistakes earlier on. In chapter nine we arrange for
automatic initialization to prevent another class of bugs. Chapter ten introduces
delegates and shows how classes and callback functions cooperate to simplify, for
example, the constant chore of producing standard main programs. More chapters
are concerned with plugging memory leaks by using class methods, storing and
loading structured data with a coherent strategy, and disciplined error recovery
through a system of nested exception handlers.
Finally, in the last chapter we leave the confines of ANSI-C and implement the
obligatory mouse-operated calculator, first for curses and then for the X Window
System. This example neatly demonstrates how elegantly we can design and
implement using objects and classes, even if we have to cope with the idiosyncrasies
of foreign libraries and class hierarchies.
Each chapter has a summary where I try to give the more cursory reader a rundown
on the happenings in the chapter and their importance for future work. Most
chapters suggest some exercises; however, they are not spelled out formally,
because I firmly believe that one should experiment on one’s own. Because we are
building the techniques from scratch, I have refrained from making and using a
massive class library, even though some examples could have benefited from it. If
you want to understand object-oriented programming, it is more important to first
master the techniques and consider your options in code design; dependence on
somebody else’s library for your developments should come a bit later.
An important part of this book is the enclosed source floppy — it has a DOS file
system containing a single shell script to create all the sources arranged by chapter.
There is a ReadMe file — consult it before you say make. It is also quite instructive
to use a program like diff and trace the evolution of the root classes and ooc reports
through the later chapters.
The techniques described here grew out of my disenchantment with C++ when
I needed object-oriented techniques to implement an interactive programming
language and realized that I could not forge a portable implementation in C++. I
turned to what I knew, ANSI-C, and I was perfectly able to do what I had to. I have
shown this to a number of people in courses and workshops and others have used
the methods to get their jobs done. It would have stopped there as my footnote to
a fad, if Brian Kernighan and my publishers, Hans-Joachim Niclas and John Wait,
had not encouraged me to publish the notes (and in due course to reinvent it all
once more). My thanks go to them and to all those who helped with and suffered
through the evolution of this book. Last not least I thank my family — and no,
object-orientation will not replace sliced bread.
Hollage, October 1993
Axel-Tobias Schreiner
单击这里下载
[技术思想类书籍]
《大道至简单：软件工程实践者的思想》
【作 者】周爱民 [同作者作品] [作译者介绍]
【出 版 社】 电子工业出版社 【书 号】 9787121038693
【出版日期】 2007 年3月 【
开 本】 16开 【页 码】 168 【版 次】1-1
【内容简介】
本书提出了审视软件工程的全新视角和软件工程的体系模型（EHM，软件工程层状模型）本书用非工程的方式重新解析软件工程现象，全面、细致而深刻地分析了工程中各个环节的由来、价值及其内在关系。综合论述开发、工程二者的现状，例如对程序员“工匠思想”的起源进行广征博引的分析，也对工程中“敏捷过程”的经验主义本质进行深至髓质的论证。全书语言轻快，可读性强，薄且有味。
本书是在“思想方法学”这一软件工程尚未涉足过的领域中的实习之作。作者亲历国内软件工程的英雄时代、泡沫时代，从失败中醒觉而创建独特的思考方法，对软件开发、工程中的现状深刻反思，从而完成这本专著。在缺乏独立思维、对国外工程理论亦步亦趋的国内工程界、开发业界，该书无疑是一份激荡新思的佳作。本书是第一本讨论软件工程思想本源的书籍，也是第一本从工程实践出发溯源而论的佳作。
【作译者介绍】
作者: 周爱民
周爱民(Aimingoo)，有十余年的软件开发、项目管理、团队建设的经验。曾任多家软件公司高级程序设计师、项目经理、部门经理、区域总经理等职，现任上海盛大网络平台架构师。目前主要从事软件工程、体系架构和语言基础方面的研究与实践。
■2001年，主持完成的“极光数据处理仓库中心系统”被河南省信息产业厅授予省高新技术产品二等奖。
■2003年，被美国Borland公司授予 “Borland Delphi产品专家”称号。
■2004年，出版《Delphi源代码分析》，被誉为“Delphi领域精品著作”。
■2005年，发.. << 查看详细
[同作者作品]
Delphi源代码分析
大道至简:软件工程实践者的思想
JAVASCRIPT语言精髓与编程实践
本书提供作译者介绍
周爱民，有十余年的软件开发、项目管理、团队建设的经验。曾任多家软件公司高级程序设计师、项目经理、部门经理、区域总经理等职，现任上海盛大网络平台架构师。目前主要从事软件工程、体系架构和语言基础方面的研究与实践。
2001年，主持完成的“极光数据处理仓库中心系统”被河南省信息产业厅授予省高新技术产品二等奖。
2003年，被美国Borland公司授予“Borland Delphi产品专家”称号。
2004年，出版《Delphi源代码分析》，被誉为“Delphi领域精品著作”。
2005年，发布《大道.. << 查看详细
【目录信息】
对第一版的赞扬
精彩在于思考
停下来，思考才是进步本质
屏幕上的第四种颜色
再版前言
致谢
第一章 编程的精义
第一节 编程的精义
第二节 能不能学会写程序的问题
第三节 程序=算法+结构
第四节 语言
第五节 在没有工程的时代
第二章 是懒人造就了方法
第一节 是懒人造就了方法
第二节 一百万行代码是可以写在一个文件里的
第三节 你桌上的书是乱的吗
第四节 我的第一次思考：程序=算法+结构+方法
第三章 团队缺乏的不只是管理
第一节 三个人的团队
第二节 做项目=死亡游戏
第三节 做ISO质量体系的教训
第四节 谁动摇了你的制度
第五节 “那我们就开始开发吧”
第六节 组织的学问：角色
第七节 跟随蚂蚁，但不要栽进蚂蚁洞里
第八节 “什么是增值税发票？”
第四章 流于形式的沟通
第一节 客户不会用C，难道就会用UML吗
第二节 项目文档真的可以用甲骨文来写
第三节 沟通的三层障碍
第四节 最简沟通
第五节 为不存在的角色留下沟通的渠道
第六节 流于形式的沟通
第五章 失败的过程也是过程
第一节 做过程不是做工程
第二节 做过场
第三节 实现，才是目的
第四节 过程不是死模型
第五节 “刻鹄类鹜”与“画虎类狗”
第六节 工程不是做的，是组织的
第六章 谁是解结的人
第一节 是谁的问题
第二节 正视你的成功
第三节 总得先做点儿什么吧
第四节 你不是团队的腿
第五节 三鼓而竭
第六节 先人后已
第七节 自相矛盾
第七章 从编程到工程
第八章 你看得到工具的本质吗
第九章 现实中的软件工程
第十章 是思考还是思想
附录一 与蒋涛就电子版序的对话
附录二 愚公移山记
附录三 愚公移山记（文言）
前言后语 |
本帖子中包含更多资源
您需要 登录 才可以下载或查看，没有帐号？注册
x
|
[复制链接]
发表于 2008-4-7 21:48:38
楼主
