学习计算机专业应该知道的

只可惜看到的有点晚了，英文原文，后面有不完全翻译：

Given the expansive growth in the field,it's become challenging to discern what belongs in a modern computer sciencedegree.

My own faculty is engaging in this debate,so I've coalesced my thoughts as an answer to the question, "What shouldevery computer science major know?"

I've tried to answer this question as theconjunction of four concerns:

1. What should every student know to get agood job?

2. What should every student know to maintainlifelong employment?

3. What should every student know to entergraduate school?

4. What should every student know to benefitsociety?

My thoughts below factor into both generalprinciples and specific recommendations relevant to the modern computinglandscape.

Computer science majors: feel free to usethis as a self-study guide.

Please email or tweet with suggestions foraddition and deletion.

Update: Thanks for the suggestions andreminders! I'll incorporate them as I receive them to keep this a livingdocument.

Portfolio versus resume

Having emerged from engineering andmathematics, computer science programs take a resume-based approach to hiringoff their graduates.

A resume says nothing of a programmer'sability.

Every computer science major should build aportfolio.

A portfolio could be as simple as apersonal blog, with a post for each project or accomplishment. A betterportfolio would include per-project pages, and publicly browsable code (hostedperhaps on github or Google code).

Contributions to open source should belinked and documented.

A code portfolio allows employers todirectly judge ability.

GPAs and resumes do not.

Professors should design course projects toimpress on portfolios, and students, at the conclusion of each course, shouldtake time to update them.

Examples

Edward Yang's web site.

Michael Bradshaw's web site.

Github is my resume.

Technical communication

Lone wolves in computer science are anendangered species.

Modern computer scientists must practicepersuasively and clearly communicating their ideas to non-programmers.

In smaller companies, whether or not aprogrammer can communicate her ideas to management may make the differencebetween the company's success and failure.

Unfortunately, this is not something fixedwith the addition of a single class (although a solid course in technicalcommunication doesn't hurt).

More classes need to provide students theopportunity to present their work and defend their ideas with oralpresentations.

Specific recommendations

I would recommend that students master apresentation tool like PowerPoint or (my favorite) Keynote. (Sorry, as much asI love them, LaTeX-based presentation tools are just too static.)

For producing beautiful mathematicaldocumentation, LaTeX has no equal. All written assignments in technical coursesshould be submitted in LaTeX.

Recommended reading

Writing for Computer Science by Zobel.

Even a Geek Can Speak by Asher.

The LaTeX Companion.

The TeXbook by Knuth. (Warning: Expertsonly.)

Notes on Mathematical Writing.

Simon Peyton-Jones's advice on How to Givea Good Research Talk.

My advice on how to send and reply toemail.

An engineering core

Computer science is not quite engineering.

But, it's close enough.

Computer scientists will find themselvesworking with engineers.

Computer scientists and traditionalengineers need to speak the same language--a language rooted in real analysis,linear algebra, probability and physics.

Computer scientists ought to take physicsthrough electromagnetism. But, to do that, they'll need take up throughmultivariate calculus, (and differential equations for good measure).

In constructing sound simulations, acommand of probability and (often times) linear algebra is invaluable. Ininterpreting results, there is no substitute for a solid understanding ofstatistics.

Recommended reading

Calculus by Spivak.

All of Statistics: A Concise Course inStatistical Inference by Wasserman.

The Unix philosophy

Computer scientists should be comfortablewith and practiced in the Unix philosophy of computing.

The Unix philosophy (as opposed to Unixitself) is one that emphasizes linguistic abstraction and composition in orderto effect computation.

In practice, this means becomingcomfortable with the notion of command-line computing, text-file configurationand IDE-less software development.

Specific recommendations

Given the prevalence of Unix systems,computer scientists today should be fluent in basic Unix, including the abilityto:

navigate and manipulate the filesystem;

compose processes with pipes;

comfortably edit a file with emacs and vim;

create, modify and execute a Makefile for asoftware project;

write simple shell scripts.

Students will reject the Unix philosophyunless they understand its power. Thus, it's best to challenge students tocomplete useful tasks for which Unix has a comparative advantage, such as:

Find the five folders in a given directoryconsuming the most space.

Report duplicate MP3s (by file contents,not file name) on a computer.

Take a list of names whose first and lastnames have been lower-cased, and properly recapitalize them.

Find all words in English that have x astheir second letter, and n as their second-to-last.

Directly route your microphone input overthe network to another computer's speaker.

Replace all spaces in a filename withunderscore for a given directory.

Report the last ten errant accesses to theweb server coming from a specific IP address.

Recommended reading

The Unix Programming Environment byKernighan and Pike.

The Linux Programming Interface: A Linuxand UNIX System Programming Handbook by Kerrisk.

Unix Power Tools by Powers, Peek, O'Reillyand Loukides.

commandlinefu.

Linux Server Hacks.

The single Unix specification.

Systems administration

Some computer scientists sneer at systemsadministration as an "IT" task.

The thinking is that a computer scientistcan teach herself how to do anything a technician can do.

This is true. (In theory.)

Yet this attitude is misguided: computerscientists must be able to competently and securely administer their ownsystems and networks.

Many tasks in software development are mostefficiently executed without passing through a systems administrator.

Specific recommendations

Every modern computer scientist should beable to:

Install and administer a Linuxdistribution.

Configure and compile the Linux kernel.

Troubleshoot a connection with dig, pingand traceroute.

Compile and configure a web server likeapache.

Compile and configure a DNS daemon likebind.

Maintain a web site with a text editor.

Cut and crimp a network cable.

Recommended reading

UNIX and Linux System AdministrationHandbook by Nemeth, Synder, Hein and Whaley.

Programming languages

Programming languages rise and fall withthe solar cycle.

A programmer's career should not.

While it is important to teach languagesrelevant to employers, it is equally important that students learn how to teachthemselves new languages.

The best way to learn how to learnprogamming languages is to learn multiple programming languages and programmingparadigms.

The difficulty of learning the nth languageis half the difficulty of the (n-1)th.

Yet, to truly understand programminglanguages, one must implement one. Ideally, every computer science major wouldtake a compilers class. At a minimum, every computer science major shouldimplement an interpreter.

Specific languages

The following languages provide areasonable mixture of paradigms and practical applications:

Racket;

C;

JavaScript;

Squeak;

Java;

Standard ML;

Prolog;

Scala;

Haskell;

C++; and

Assembly.

Racket

Racket, as a full-featured dialect of Lisp,has an aggressively simple syntax.

For a small fraction of students, thissyntax is an impediment.

To be blunt, if these students have afundamental mental barrier to accepting an alien syntactic regime even temporarily,they lack the mental dexterity to survive a career in computer science.

Racket's powerful macro system andfacilities for higher-order programming thoroughly erase the line between dataand code.

If taught correctly, Lisp liberates.

Recommended reading

How to Design Programs by Felleisen,Findler, Flatt and Krishnamurthi.

The Racket Docs.

ANSI C

C is a terse and unforgiving abstraction ofsilicon.

C remains without rival in programmingembedded systems.

Learning C imparts a deep understanding ofthe dominant von Neumann architecture in a way that no other language can.

Given the intimate role poor C programmingplays in the prevalence of the buffer overflow security vulnerabilities, it iscritical that programmers learn how to program C properly.

Recommended reading

ANSI C by Kernighan and Ritchie.

JavaScript

JavaScript is a good representative of thesemantic model popular in dynamic, higher-order languages such as Python, Rubyand Perl.

As the native language of the web, itspragmatic advantages are unique.

Recommended reading

JavaScript: The Definitive Guide byFlanagan.

JavaScript: The Good Parts by Crockford.

Effective JavaScript: 68 Specific Ways toHarness the Power of JavaScript by Herman.

Squeak

Squeak is a modern dialect of Smalltalk,purest of object-oriented languages.

It imparts the essence of"object-oriented."

Recommended reading

Introductions to Squeak

Java

Java will remain popular for too long toignore it.

Recommended reading

Effective Java by Bloch.

Standard ML

Standard ML is a clean embodiment of theHindley-Milner system.

The Hindley-Milner type system is one ofthe greatest (yet least-known) achievements in modern computing.

Though exponential in complexity, typeinference in Hindley-Milner is always fast for programs of human interest.

The type system is rich enough to allow theexpression of complex structural invariants. It is so rich, in fact, thatwell-typed programs are often bug-free.

Recommended reading

ML for the Working Programmer by Paulson.

The Definition of Standard ML by Milner,Harper, MacQueen and Tofte.

Prolog

Though niche in application, logicprogramming is an alternate paradigm for computational thinking.

It's worth understanding logic programmingfor those instances where a programmer may need to emulate it within anotherparadigm.

Another logic language worth learning isminiKanren. miniKanren stresses pure (cut not allowed) logic programming. Thisconstraint has evolved an alternate style of logic programming calledrelational programming, and it grants properties not typically enjoyed byProlog programs.

Recommended reading

Learn Prolog Now!

Another tutorial.

miniKanren.

Scala

Scala is a well-designed fusion offunctional and object-oriented programming languages. Scala is what Java shouldhave been.

Built atop the Java Virtual Machine, it iscompatible with existing Java codebases, and as such, it stands out as the mostlikely successor to Java.

Recommended reading

Programming in Scala by Odersky, Spoon andVenners.

Programming Scala by Wampler and Payne.

Haskell

Haskell is the crown jewel of theHindley-Milner family of languages.

Fully exploiting laziness, Haskell comesclosest to programming in pure mathematics of any major programming language.

Recommended reading

Learn You a Haskell by Lipovaca.

Real World Haskell by O'Sullivan, Goerzenand Stewart.

ISO C++

C++ is a necessary evil.

But, since it must be taught, it must betaught in full.

In particular, computer science majorsshould leave with a grasp of even template meta-programming.

Recommended reading

The C++ Programming Language by Stroustrup.

C++ Templates: The Complete Guide byVandevoorde and Josuttis.

Programming Pearls by Bentley.

Assembly

Any assembly language will do.

Since x86 is popular, it might as well bethat.

Learning compilers is the best way to learnassembly, since it gives the computer scientist an intuitive sense of howhigh-level code will be transformed.

Specific recommendations

Computer scientists should understandgenerative programming (macros); lexical (and dynamic) scope; closures;continuations; higher-order functions; dynamic dispatch; subtyping; modules andfunctors; and monads as semantic concepts distinct from any specific syntax.

Recommended reading

Structure and Interpretation of ComputerPrograms by Abelson, Sussman and Sussman.

Lisp in Small Pieces by Queinnec.

Discrete mathematics

Computer scientists must have a solid graspof formal logic and of proof. Proof by algebraic manipulation and by naturaldeduction engages the reasoning common to routine programming tasks. Proof byinduction engages the reasoning used in the construction of recursivefunctions.

Computer scientists must be fluent informal mathematical notation, and in reasoning rigorously about the basicdiscrete structures: sets, tuples, sequences, functions and power sets.

Specific recommendations

For computer scientists, it's important tocover reasoning about:

trees;

graphs;

formal languages; and

automata.

Students should learn enough number theoryto study and implement common cryptographic protocols.

Recommended reading

How to Prove It: A Structured Approach byVelleman.

How To Solve It by Polya.

Data structures and algorithms

Students should certainly see the common(or rare yet unreasonably effective) data structures and algorithms.

But, more important than knowing a specificalgorithm or data structure (which is usually easy enough to look up), computerscientists must understand how to design algorithms (e.g., greedy, dynamicstrategies) and how to span the gap between an algorithm in the ideal and thenitty-gritty of its implementation.

Specific recommendations

At a minimum, computer scientists seekingstable long-run employment should know all of the following:

hash tables;

linked lists;

trees;

binary search trees; and

directed and undirected graphs.

Computer scientists should be ready toimplement or extend an algorithm that operates on these data structures,including the ability to search for an element, to add an element and to removean element.

For completeness, computer scientistsshould know both the imperative and functional versions of each algorithm.

Recommended reading

CLRS.

Any of the Art of Computer Programmingseries by Knuth.

Theory

A grasp of theory is a prerequisite toresearch in graduate school.

Theory is invaluable when it provides hardboundaries on a problem (or when it provides a means of circumventing whatinitially appear to be hard boundaries).

Computational complexity can legitimatelyclaim to be one of the few truly predictive theories in all of computer"science."

A computer scientist must know where theboundaries of tractability and computability lie. To ignore these limitsinvites frustration in the best case, and failure in the worst.

Specific recommendations

At the undergraduate level, theory shouldcover at least models of computation and computational complexity.

Models of computation should coverfinite-state automata, regular languages (and regular expressions), pushdownautomata, context-free languages, formal grammars, Turing machines, the lambdacalculus, and undecidability.

At the undergraduate level, students shouldlearn at least enough complexity to understand the difference between P, NP,NP-Hard and NP-Complete.

To avoid leaving the wrong impression,students should solve a few large problems in NP by reduction to SAT and theuse of modern SAT solvers.

Recommended reading

Introduction to the Theory of Computationby Sipser.

Computational Complexity by Papadimitriou.

Algorithms by Sedgewick and Wayne.

Introduction to Algorithms by Cormen,Leiserson, Rivest and Stein.

Architecture

There is no substitute for a solidunderstanding of computer architecture.

Computer scientists should understand acomputer from the transistors up.

The understanding of architecture shouldencompass the standard levels of abstraction: transistors, gates, adders,muxes, flip flops, ALUs, control units, caches and RAM.

An understanding of the GPU model ofhigh-performance computing will be important for the foreseeable future.

Specific recommendations

A good understanding of caches, buses andhardware memory management is essential to achieving good performance on modernsystems.

To get a good grasp of machinearchitecture, students should design and simulate a small CPU.

Recommended reading

nand2tetris, which constructs a computerfrom the ground up.

Computer Organization and Design byPatterson and Hennessy.

"What every programmer should knowabout memory" by Drepper.

Operating systems

Any sufficiently large program eventuallybecomes an operating system.

As such, computer scientists should beaware of how kernels handle system calls, paging, scheduling,context-switching, filesystems and internal resource management.

A good understanding of operating systemsis secondary only to an understanding of compilers and architecture forachieving performance.

Understanding operating systems (which Iwould interpret liberally to include runtime systems) becomes especiallyimportant when programming an embedded system without one.

Specific recommendations

It's important for students to get theirhands dirty on a real operating system. With Linux and virtualization, this iseasier than ever before.

To get a better understanding of thekernel, students could:

print "hello world" during theboot process;

design their own scheduler;

modify the page-handling policy; and

create their own filesystem.

Recommended reading

Linux Kernel Development by Love.

Networking

Given the ubiquity of networks, computerscientists should have a firm understanding of the network stack and routingprotocols within a network.

The mechanics of building an efficient,reliable transmission protocol (like TCP) on top of an unreliable transmissionprotocol (like IP) should not be magic to a computer scientist. It should becore knowledge.

Computer scientists must understand thetrade-offs involved in protocol design--for example, when to choose TCP andwhen to choose UDP. (Programmers need to understand the larger socialimplications for congestion should they use UDP at large scales as well.)

Specific recommendations

Given the frequency with which the modernprogrammer encounters network programming, it's helpful to know the protocolsfor existing standards, such as:

802.3 and 802.11;

IPv4 and IPv6; and

DNS, SMTP and HTTP.

Computer scientists should understandexponential back off in packet collision resolution and the additive-increasemultiplicative-decrease mechanism involved in congestion control.

Every computer scientist should implementthe following:

an HTTP client and daemon;

a DNS resolver and server; and

a command-line SMTP mailer.

No student should ever pass an introneworking class without sniffing their instructor's Google query off wireshark.

It's probably going too far to require allstudents to implement a reliable transmission protocol from scratch atop IP,but I can say that it was a personally transformative experience for me as astudent.

Recommended reading

Unix Network Programming by Stevens, Fennerand Rudoff.

Security

The sad truth of security is that themajority of security vulnerabilities come from sloppy programming. The saddertruth is that many schools do a poor job of training programmers to securetheir code.

Computer scientists must be aware of themeans by which a program can be compromised.

They need to develop a sense of defensiveprogramming--a mind for thinking about how their own code might be attacked.

Security is the kind of training that isbest distributed throughout the entire curriculum: each discipline should warnstudents of its native vulnerabilities.

Specific recommendations

At a minimum, every computer scientistneeds to understand:

social engineering;

buffer overflows;

integer overflow;

code injection vulnerabilities;

race conditions; and

privilege confusion.

A few readers have pointed out thatcomputer scientists also need to be aware of basic IT security measures, suchhow to choose legitimately good passwords and how to properly configure afirewall with iptables.

Recommended reading

Metasploit: The Penetration Tester's Guideby Kennedy, O'Gorman, Kearns and Aharoni.

Security Engineering by Anderson.

Cryptography

Cryptography is what makes much of ourdigital lives possible.

Computer scientists should understand andbe able to implement the following concepts, as well as the common pitfalls indoing so:

symmetric-key cryptosystems;

public-key cryptosystems;

secure hash functions;

challenge-response authentication;

digital signature algorithms; and

threshold cryptosystems.

Since it's a common fault in implementationsof cryptosystems, every computer scientist should know how to acquire asufficiently random number for the task at hand.

At the very least, as nearly every databreach has shown, computer scientists need to know how to salt and hashpasswords for storage.

Specific recommendations

Every computer scientist should have thepleasure of breaking ciphertext using pre-modern cryptosystems with hand-rolledstatistical tools.

RSA is easy enough to implement thateveryone should do it.

Every student should create their owndigital certificate and set up https in apache. (It's surprisingly arduous todo this.)

Student should also write a console webclient that connects over SSL.

As strictly practical matters, computerscientists should know how to use GPG; how to use public-key authentication forssh; and how to encrypt a directory or a hard disk.

Recommended reading

Cryptography Engineering by Ferguson,Schneier and Kohno.

Software testing

Software testing must be distributedthroughout the entire curriculum.

A course on software engineering can coverthe basic styles of testing, but there's no substitute for practicing the art.

Students should be graded on the test casesthey turn in.

I use test cases turned in by studentsagainst all other students.

Students don't seem to care much aboutdeveloping defensive test cases, but they unleash hell when it comes tosandbagging their classmates.

User experience design

Programmers too often write software forother programmers, or worse, for themselves.

User interface design (or more broadly,user experience design) might be the most underappreciated aspect of computerscience.

There's a misconception, even amongprofessors, that user experience is a "soft" skill that can't betaught.

In reality, modern user experience designis anchored in empirically-wrought principles from human factors engineeringand industrial design.

If nothing else, computer scientists shouldknow that interfaces need to make the ease of executing any task proportionalto the frequency of the task multiplied by its importance.

As a practicality, every programmer shouldbe comfortable with designing usable web interfaces in HTML, CSS andJavaScript.

Recommended reading

Paul Graham's essay on Web 2.0.

"The Absolute Minimum Every SoftwareDeveloper Absolutely, Positively Must Know About Unicode and CharacterSets" by Spolsky.

HTML and CSS: Design and Build Websites byDuckett.

JavaScript: The Definitive Guide byFlanagan.

Visualization

Good visualization is about rendering datain such a fashion that humans perceive it as information. This is not an easything to do.

The modern world is a sea of data, andexploiting the local maxima of human perception is key to making sense of it.

Recommended reading

The Visual Display of QuantitativeInformation by Tufte.

Parallelism

Parallelism is back, and uglier than ever.

The unfortunate truth is that harnessingparallelism requires deep knowledge of architecture: multicore, caches, buses,GPUs, etc.

And, practice. Lots of practice.

Specific recommendations

It is not at all clear what the"final" answer on parallel programming is, but a few domain-specificsolutions have emerged.

For now, students should learn CUDA andOpenCL.

Threads are a flimsy abstraction forparallelism, particularly when caches and cache coherency are involved. But,threads are popular and tricky, so worth learning. Pthreads is a reasonablyportable threads library to learn.

For anyone interested in large-scaleparallelism, MPI is a prerequisite.

On the principles side, it does seem thatmap-reduce is enduring.

Software engineering

The principles in software engineeringchange about as fast as the programming languages do.

A good, hands-on course in the practice ofteam software construction provides a working knowledge of the pitfallsinherent in the endeavor.

It's been recommended by several readersthat students break up into teams of three, with the role of leader rotatingthrough three different projects.

Learning how to attack and maneuver througha large existing codebase is a skill most programmers will have to master, andit's one best learned in school instead of on the job.

Specific recommendations

All students need to understand centralizedversion control systems like svn and distributed version control systems likegit.

A working knowlege of debugging tools likegdb and valgrind goes a long way when they finally become necessary.

Recommended reading

Version Control by Example by Sink.

Formal methods

As the demands on secure, reliable softwareincrease, formal methods may one day end up as the only means for deliveringit.

At present, formal modeling andverification of software remains challenging, but progress in the field issteady: it gets easier every year.

There may even come a day within thelifetime of today's computer science majors where formal software constructionis an expected skill.

Every computer scientist should be at leastmoderately comfortable using one theorem prover. (I don't think it matterswhich one.)

Learning to use a theorem proverimmediately impacts coding style.

For example, one feels instinctivelyallergic to writing a match or switch statement that doesn't cover allpossibilities.

And, when writing recursive functions,users of theorem provers have a strong urge to eliminate ill-foundedness.

Recommended reading

Software Foundations.

Graphics and simulation

There is no discipline more dominated by"clever" than graphics.

The field is driven toward, even definedby, the "good enough."

As such, there is no better way to teachclever programming or a solid appreciation of optimizing effort than graphicsand simulation.

Over half of the coding hacks I've learnedcame from my study of graphics.

Specific recommendations

Simple ray tracers can be constructed inunder 100 lines of code.

It's good mental hygiene to work out thetransformations necessary to perform a perspective 3D projection in a wireframe3D engine.

Data structures like BSP trees andalgorithms like z-buffer rendering are great examples of clever design.

In graphics and simulation, there are manymore.

Recommended reading

Mathematics for 3D Game Programming andComputer Graphics by Lengyel.

Robotics

Robotics may be one of the most engagingways to teach introductory programming.

Moreover, as the cost of robotics continuesto fall, thresholds are being passed which will enable a personal roboticsrevolution.

For those that can program, unimaginabledegrees of personal physical automation are on the horizon.

Related posts

Multitouch gesture control for a robot.

Artificial intelligence

If for no other reason than its outsizedimpact on the early history of computing, computer scientists should studyartificial intelligence.

While the original dream of intelligentmachines seems far off, artificial intelligence spurred a number of practicalfields, such as machine learning, data mining and natural language processing.

Recommended reading

Artificial Intelligence by Russell andNorvig.

Machine learning

Aside from its outstanding technicalmerits, the sheer number of job openings for "relevance engineer,"indicates that every computer scientist should grasp the fundamentals ofmachine learning.

Machine learning doubly emphasizes the needfor an understanding of probability and statistics.

Specific recommendations

At the undergraduate level, core conceptsshould include Bayesian networks, clustering and decision-tree learning.

Recommended reading

Machine Learning by Mitchell.

Databases

Databases are too common and too useful toignore.

It's useful to understand the fundamentaldata structures and algorithms that power a database engine, since programmersoften enough reimplement a database system within a larger software system.

Relational algebra and relational calculusstand out as exceptional success stories in sub-Turing models of computation.

Unlike UML modeling, ER modeling seems tobe a reasonable mechanism for visualing encoding the design of and constraintsupon a software artifact.

Specific recommendations

A computer scientist that can set up andoperate a LAMP stack is one good idea and a lot of hard work away from runningtheir own company.

Recommended reading

SQL and Relational Theory by Date.

Non-specific reading recommendations

Gödel, Escher, Bach by Hofstadter.

Nick Black's advice for MS students.

What else?

My suggestions are limited by blind spotsin my own knowledge.

What have I not listed here that should beincluded?

每个程序员应该知道的是什么，每个人都有不同的见解，并且在中国有绝大一部分的程序员都认为是C、JAVA等语言、框架、堆、栈、算法、数据结构、工具等等，但是远远不够，原文中作者以及贡献者给出了几乎涵盖所有内容的一个回答。

文中提出第一能力是技术沟通，每一个做过开发或者运维的同学都知道，无论做什么项目首先最重要的是沟通，是团队协作。现在软件开发项目不是靠一个人单打独斗完成的，是需要各方位人员共同协作实现的。如文中所说Lone wolves in computer science are an dangered species.或许单打独斗可以完成一时的成功，但必不可长久维持。

其次是Unix哲学，在我理解是Unix 设计思想理念，可以说现在近半个世纪的计算机的繁荣发展就是建立在Unix的实现的基础之上。Linux、MacOS包括Windows其设计理念大多都是源于Unix的设计理念，so如果如果你是程序员，那么你一定要知道并理解Unix哲学。在文中，作者给出一些具体建议和推荐阅读属于必看的。

第三是编程语言，这里都不一一详述了，只能说每个人都有适合自己的一套风格。

第四是离散数学，这部分内容我也没有深入研究，只知道一点是离散数学讲的是逻辑论证的内容。

第五是数据结构与算法，我的理解是如果逻辑论证的离散数据是基石的话，那么数据结构和算法就是房屋的砖石和水泥。如作者所说，如果你想要找一个长久稳定的工作的话，那你必须掌握 hash tables 、linked lists、trees、binary search trees、directed and undirected graphs。

第六是原理，有一点非常好，我们所有工作的内容都应该是有边界的、可定义的、可实现的。而原理则是提供边界定义的手段，判定当前问题是否可以实现，原理是非常宝贵的。原理应该包括计算模型和计算复杂性。计算模型包括有限状态机(finite-state automata)、正则表达式、push-downautomata、context-free languages、formal languages、图灵机(Turing machines)、lanbda 演算(the lambda calculus)、和不可判定性(undecidability)。状态机之类在我理解可能就是流程图吧（求指导），其他的更需要指导。

第七是Architecture，我通俗翻译一下大概是微机原理，CPU -->AU-->CS-->register-->cache-->RAM-->ROM

第八是OS，任何足够大的程序都回成为操作系统，我赞同。同时操作系统应该具备可以执行的code，调度系统，文件系统，页面修改处理策略（一点不懂）。

第九是网络（Networking），对于网络协议。。。，是人制定的信息传输的规范格式，你要接发信息，那么你必须按照我制定的一个个规范格式来，怎么发送，怎么接收。不然，哼哼。。。

第十是安全，加密算法、Hacking你需要了解一下！！

第十一是加密，同上一个范围

真的感觉到自己水平有限，其余还有软件测试、虚拟化、机器学习等。