博客园_精神分裂

DotNet程序员面试问题评估

2011-07-26T06:40:00Z

欢迎各位Dotnet程序员回答。不需要回答出具体问题，只要标记大致程度即可。

1什么是DotNet的CLR? CLR作用是什么？

A不知道 B知道很少 C知道一些 D非常了解

2 DotNet中如何使用Win32的DLL？（没有reference可以添加）

A不知道 B知道很少 C知道一些 D非常了解

3 C#使用什么关键字实现可变个数参数(variable number parameters)？

A不知道 B知道很少 C知道一些 D非常了解

4 C#中的weak reference是什么？用于什么场合？

A不知道 B知道很少 C知道一些 D非常了解

5 C#中的using dispose模式是什么？用于什么场合？

A不知道 B知道很少 C知道一些 D非常了解

6 C#中Garbage Collection是什么？简介GC的internal工作方式(如果你是微软开发人员，如何实现GC)?

A不知道 B知道很少 C知道一些 D非常了解

7 C#中的关键字as, yield, out/ref, virtual/abstract/override？

A不知道 B知道很少 C知道一些 D非常了解

8 Strong name signature是什么？有什么用？

A不知道 B知道很少 C知道一些 D非常了解

9 字符串intern暂留机制是怎么一回事？

A不知道 B知道很少 C知道一些 D非常了解

10 Windows平台下多进程通讯方式？越多越好

A不知道 B知道很少 C知道一些 D非常了解

11 Delegate, Event, Action, Func都是什么？

A不知道 B知道很少 C知道一些 D非常了解

12 MVC, MVP, MVVM设计模式？

A不知道 B知道很少 C知道一些 D非常了解

13 除了工厂模式和单例模式，列举并且简单介绍你知道的设计模式以及应用场合？

A不知道 B知道很少 C知道一些 D非常了解

14 C#中overload和override如何实现？

A不知道 B知道很少 C知道一些 D非常了解

15 接口和抽象类有什么区别？都应用在什么场合？

A不知道 B知道很少 C知道一些 D非常了解

16 LINQ是什么？写一个简单的LINQ语句？

A不知道 B知道很少 C知道一些 D非常了解

17 C# Lambda是什么？写一个简单的lambda?

A不知道 B知道很少 C知道一些 D非常了解

18 C#中class与struct区别？

A不知道 B知道很少 C知道一些 D非常了解

19 是否听说过或者了解MEF, Unity, Prism?

A不知道 B知道很少 C知道一些 D非常了解

20 面向对象设计思想/原则有哪些？(SOLID)

A不知道 B知道很少 C知道一些 D非常了解

21 如何实现一个plugin插件可扩展系统？

A不知道 B知道很少 C知道一些 D非常了解

22 DotNet中的LinkedList与SortedList有什么不同？内部如何实现？

A不知道 B知道很少 C知道一些 D非常了解

23 设计一个字符串类(不能使用类库中的string class)?简要说明关键方法

A不知道 B知道很少 C知道一些 D非常了解

本文链接

System.Collections.Generic代码阅读笔记LinkedList SortedDictionary SortedList SortedSet

2011-07-21T14:37:00Z

代码来自ILSpy分析结果，与实际代码可能有些微出入。手写版http://min.us/mqjnYB

从下面可以看到，LinkedList是双向链表，但是SortedList实际上使用的还是数组。

而SortedDictionary与SortedSet关系非常紧密。

----------------------------------------------------------

LinkedList<T> 通过双向链表这种数据结构实现。

关键数据成员：LinkedListNode head;

很显然这是链表的头。每个Node会有Previous以及Next这样的property。

Find()功能通过遍历List实现，所以是O( n )

----------------------------------------------------------

Queue<T> 先进先出的队列。

关键数据成员： T[] _array; 毫无疑问，是通过数组来存放数据。

_tail; _head; _size;

有头有尾有大小，基本就是这样。

关键操作Enqueue()入队列 Dequeue()出队列。

----------------------------------------------------------

SortedDictionary<T> 键值对字典数据类型，接口是IDictionary<TKey, TValue>。

内部关键数据成员TreeSet< KeyValuePair<TKey, TValue> > _set;

而TreeSet继承了SortedSet，操作基本上都是通过类似这样：第一个值使用Key，第二个值使用Default（TValue）构造产生，然后调用_set的相关操作。

----------------------------------------------------------

SortedList<T> 排序列表

TKey[] keys;

TKey[] values;

_size;

Add()，通过Array.BinarySearch<TKey>找到索引位置，然后进行插入操作。O(log n)。

----------------------------------------------------------

另外要说一下，这里面的比较都是使用了IComparer，这实际上使用了设计模式中的策略模式，让用户可以自己定制。默认情况下是使用Comparer<T>.Default.

----------------------------------------------------------

SortedSet<T>

关键数据成员：SortedSet<T>.Node root;

插入操作为AddIfNotPresent()这个函数名字已经说明了一切。

内部构造使用的数据结构为红黑树（一种自平衡二叉搜索树），有IsBlack和IsRed，以及Left、Right这些property。

搜索、插入、删除都是O(log n)。

----------------------------------------------------------

另外要注意其中的Reverse()函数，使用了yield return xxx;以及yield break;这两种用法。

----------------------------------------------------------

Stack<T>

T[] _array; 后进先出，没啥可说的。

----------------------------------------------------------

HashSet<T>

关键数据成员：

int[] m_buckets;

HashSet<T>.Slot[] m_slots;

----------------------------------------------------------

Slot的定义如下：

internal struct Slot
{
internal int hashCode;
internal T value;
internal int next;
}

搜索或者是插入算法基本上是这个路子：

----------------------------------------------------------

int num = this.InternalGetHashCode(value);
for (int i = this.m_buckets[num % this.m_buckets.Length] - 1; i >= 0; i = this.m_slots[i].next)
{
//if (this.m_slots[i].hashCode == num && this.m_comparer.Equals(this.m_slots[i].value, value))
…
}

----------------------------------------------------------

这里是搜索，先算出一个哈希值，然后判断在那个桶中，拿到桶里面第一个元素（this.m_slots[i]）。

然后通过next这个成员变量来获取下一个索引位置，然后对hash代码以及通过comparer比较。

（图片来自http://en.wikipedia.org/wiki/Hash_table）

----------------------------------------------------------

插入操作也差不多，在这里面有一个this.m_freeList（一个int整数）保存了空闲列表位置，

然后把要插入的元素放在这个列表位置，再把m_freelist设置为这个列表位置的next。

因为空间可能不是连续的，所以我们使用的m_freelist这个位置与next未必是紧挨着的关系。

这个空闲列表的next关系维护，是由IncreaseCapacity()函数完成。其实C语言中的malloc函数也可以这样简单实现（当然实际中malloc肯定是复杂的多得多得多）。

----------------------------------------------------------

ILSpy是个好东西，最新版本在这里下载http://www.ilspy.net/

本文链接

String s = new String("xyz");创建了多少个String实例？

2011-07-21T12:48:00Z

在”传智播客DotNet面试宝典(改).pdf“有这样一道非常有意思，也比较有深度的题目。

String s = new String("xyz");创建了多少个String实例？

传智的老师告诉同学们：答案是两个，一个是"xyz"，一个是指向"xyz"的引用对象。

貌似很正确，很有道理。没错，"xyz"是一个字符串，而DotNet字符串（其实Java也是）有驻留intern这样一种机制。

抱歉的是，传智的老师没有料到，问这个问题的同学或者是公司太坏了。这道题的题目是错的，答案也不对。

大家手头有visualstudio的可以建立一个console程序试试看，能不能编译通过？！

至于答案为什么也不对，看看这篇非常详细的解释吧，虽然作者解释的是针对Java语言。

http://www.iteye.com/topic/774673

为什么Java能这样写？因为Java有这种构造函数String(String original)而DotNet中的String类没有。

稍微修改让它能够编译

static void Main(string[] args)
{
char[] chars = { 'w', 'o', 'r', 'd' };

String s2 = new String(chars);
String s3 = new String(chars);
int i = s2.Length;
int j = s3.Length;
Console.WriteLine(i + j);
}

如果我们用ILSpy看，结果如下，注意，其中只调用了两次newobj，分别是针对s2和s3。

.method private hidebysig static
void Main (
string[] args
) cil managed
{
// Method begins at RVA 0x2058
// Code size 57 (0x39)
.maxstack 3
.entrypoint
.locals init (
[0] char[] chars,
[1] string s2,
[2] string s3,
[3] int32 i,
[4] int32 j
)
IL_0000: ldc.i4.4
IL_0001: newarr [mscorlib]System.Char
IL_0006: dup
IL_0007: ldtoken field int64 '<PrivateImplementationDetails>{06FAE1C3-0E45-4AE7-A401-B8A7D1EFF5D6}'::'$$method0x6000001-1'
IL_000c: call void [mscorlib]System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(class [mscorlib]System.Array, valuetype [mscorlib]System.RuntimeFieldHandle)
IL_0011: stloc.0

IL_0012: ldloc.0
IL_0013: newobj instance void [mscorlib]System.String::.ctor(char[])
IL_0018: stloc.1

IL_0019: ldloc.0
IL_001a: newobj instance void [mscorlib]System.String::.ctor(char[])
IL_001f: stloc.2

IL_0020: ldloc.1
IL_0021: callvirt instance int32 [mscorlib]System.String::get_Length()
IL_0026: stloc.3

IL_0027: ldloc.2
IL_0028: callvirt instance int32 [mscorlib]System.String::get_Length()
IL_002d: stloc.s j

IL_002f: ldloc.3
IL_0030: ldloc.s j
IL_0032: add
IL_0033: call void [mscorlib]System.Console::WriteLine(int32)
IL_0038: ret
} // end of method Program::Main

本文链接

大连对日外包程序员如何提高自己基础水平以及一些C#的资料链接

2011-07-12T16:32:00Z

我在推上发了一些牢骚，有些朋友来面试，基础不是很扎实，理由是自己一直做对日外包，没有机会提升自己，掌握一些基础内容。

另外一个理由是公司只用了某某技术，没有用某某技术，只用了2.0，所以我不知道3.5、4.0等等。

这都不是理由。

这都不是理由！

这时候我假设自己是一个对日外包企业的程序员，吃完饭后老婆在看电视，我拿起Thinkpad笔记本，登录进著名的MSDN，开始继续自我提升的步骤。

坚持每天抽出半小时到一小时学习，足够你提升自己的水平！

这次也不推荐书了，只要能上网，就每天看一段MSDN的文章或者代码。保证能提高自己！

首先要知道自己缺少什么，有一个评估很有意思也很容易评估自己需要提升哪些地方：《程序员能力矩阵》http://static.icybear.net/%5BCN%5DProgrammer%20competency%20matrix.htm 这里假定我想提升Windows平台上DotNet、CSharp开发。

这里有一系列链接可以学习，每天一篇或者几天一篇应该没问题。其实比较好的办法是买本书系统学习，但我这里想说的是，资料到处都是，书籍唾手可及。

没用心不努力才是水平差基础薄弱的最大原因！

下面的链接没有什么系统性，如果有一两年经验了，看这些东西问题不大。

http://msdn.microsoft.com/en-us/library/3bwa4xa9.aspx Using Objects That Encapsulate Resources

这一篇要着重提一下，很多四五年经验的C#开发者，不知道using关键字的这种用法，怎么说呢，说你不求甚解好呢？还是说你不够努力好呢？

http://msdn.microsoft.com/en-us/library/dd642420.aspx Visual Studio 2010 Visual Basic and Visual C#

http://msdn.microsoft.com/en-us/library/618ayhy6.aspx C# Reference

http://msdn.microsoft.com/en-us/library/67ef8sbd.aspx C# Programming Guide

http://msdn.microsoft.com/en-us/library/dd460655.aspx Programming Concepts

http://msdn.microsoft.com/en-us/library/w0x726c2.aspx .NET Framework 4

http://msdn.microsoft.com/en-us/library/w0x726c2%28VS.90%29.aspx .NET Framework 3.5

http://msdn.microsoft.com/en-us/library/ff921347.aspx EnterpriseLibrary Unity MEF Prism这些概念，至少知道它们是什么

http://msdn.microsoft.com/zh-cn/magazine/default.aspx MSDN杂志

http://msdn.microsoft.com/en-us/library/orm-9780596516109-03.aspx C# 3.0 Cookbook, Third Edition: More than 250 solutions for C# 3.0 programmers

http://msdn.microsoft.com/en-us/library/orm-9780596527730-01.aspx C# 3.0 Design Patterns: Use the Power of C# 3.0 to Solve Real-World Problems

http://msdn.microsoft.com/en-us/library/k5532s8a.aspx .NET Framework 4 CLR Managed Execution Process

http://msdn.microsoft.com/en-us/library/f144e03t.aspx Automatic Memory Management （GC）

http://msdn.microsoft.com/en-us/library/ee787088.aspx Fundamentals of Garbage Collection

http://msdn.microsoft.com/en-us/library/ms404247.aspx Weak References

http://msdn.microsoft.com/en-us/library/ms172334.aspx Reflection and Generic Types

http://msdn.microsoft.com/en-us/library/a4a92379.aspx Accessing Custom Attributes

http://msdn.microsoft.com/en-us/library/ff519622.aspx Observer Design Pattern Best Practices

http://msdn.microsoft.com/en-us/library/sd10k43k.aspx Interoperating with Unmanaged Code

http://msdn.microsoft.com/en-us/library/hyz69czz.aspx Managed Threading Basics

http://msdn.microsoft.com/en-us/library/ms973850.aspx Microsoft .NET Framework FAQ

http://msdn.microsoft.com/en-us/library/ms973837.aspx Garbage Collector Basics and Performance Hints

http://msdn.microsoft.com/en-us/library/bb985748.aspx Displaying Metadata in .NET EXEs with MetaViewer

http://msdn.microsoft.com/en-us/library/ms973858.aspx Writing High-Performance Managed Applications : A Primer

http://msdn.microsoft.com/en-us/magazine/cc164086.aspx Implementing Coroutines for .NET by Wrapping the Unmanaged Fiber API

http://msdn.microsoft.com/en-us/library/aa479866.aspx Generics FAQ: .NET Framework

http://msdn.microsoft.com/en-us/library/aa479858.aspx Generics FAQ: Best Practices

http://msdn.microsoft.com/en-us/library/aa479859.aspx Generics FAQ: Fundamentals

http://msdn.microsoft.com/en-us/library/aa302329.aspx Improving String Handling Performance in .NET Framework Applications

http://msdn.microsoft.com/en-us/library/ms973880.aspx The Microsoft Shared Source CLI Implementation Refresh

http://msdn.microsoft.com/en-us/library/bb985613.aspx Migrating Native Code to the .NET CLR

http://msdn.microsoft.com/en-us/magazine/cc164123.aspx Calling Win32 DLLs in C# with P/Invoke

http://msdn.microsoft.com/en-us/magazine/cc164139.aspx The CLR’s Thread Pool

http://msdn.microsoft.com/en-us/magazine/cc164094.aspx Introducing Generics in the CLR

http://msdn.microsoft.com/en-us/library/ms973893.aspx Object Serialization in the .NET Framework

http://msdn.microsoft.com/en-us/library/ms973872.aspx An Overview of Managed/Unmanaged Code Interoperability

http://msdn.microsoft.com/en-us/library/ms973838.aspx Performance Considerations for Run-Time Technologies in the .NET Framework

http://msdn.microsoft.com/en-us/library/ms973839.aspx Performance Tips and Tricks in .NET Applications

http://msdn.microsoft.com/en-us/library/aa302338.aspx Primary Interop Assemblies (PIAs)

http://msdn.microsoft.com/en-us/library/bb264782.aspx Profiler Stack Walking in the .NET Framework 2.0: Basics and Beyond

http://msdn.microsoft.com/en-us/library/aa302324.aspx Using the .NET Framework SDK Interoperability Tools

http://msdn.microsoft.com/en-us/library/ms973826.aspx Using the ECMA Standards: An Interview with Miguel de Icaza

本文链接

C语言中if (p==NULL)的是与非

2011-07-05T12:57:00Z

博客园cnblogs不知为何最近开始渐有C语言开发重启的迹象，不少人开始写一些C语言的教程。

其中看到一段有趣的留言，提到这个写法：if (p == NULL)，

有人说这是不好的~，经典不提倡的~，会写错出问题的~，华为都禁止的~。

我倒是有些不同的看法。

首先这种写法是有问题，一般来讲对于空指针可以这样写

if ( p )

或者反义是这样 if ( !p )

既简单，还节省字数。

如果是想写的比较容易懂，那么if (p == NULL) 是我提倡的方式。

你可以很简单的读成“如果p等于空值”，反过来的方式NULL==p就有些别扭，不是给人看的。

有人提到p==NULL很容易写成p=NULL，代码出错啦！会有bug啦！

好吧，我承认这是一种可能性，在早期编译器不完善的时候的确如此。那时候还提倡用匈牙利命名法，因为编译器对类型识别支持不好，很容易写出胡乱转型的代码（当然现在的C语言也容易）。但是针对正在使用的编译器以及将来更先进的编译器，在条件判断中使用p==NULL不是问题。

做一个很简单的实验，使用VC2010，项目设置为compile as C，注意关键一点“把warning级别提高到最高级别4”，这时候if (p=NULL )会得到如下警告：

1>purec.cpp(10): warning C4706: assignment within conditional expression

很简单吧，不需要你使用那种反人类常识的代码规范。

使用GCC（v4.5.2 in Ubuntu11.4）也很容易，它有一个编译选项-Wall，警告信息如下：

/home/sun/foobar-sample/main.c:24:2: warning: suggest parentheses around assignment used as truth value

如果工具支持，为何不使用一种更为合乎阅读习惯的方式呢，BTW，我查找了一下经典的K&R，其中==的使用都是我提到的p==0这种方式，其它更为经典的（有么？）我就不知道了。

本文链接

C#研究系列-List<>与ArrayList的几个研究心得及问题（上）2011-04-15T15:55:00Z
代码放在https://gist.github.com/921076 上了，看不到的请留言。
第一个心得，是我看某本书提到，IList用起来要比ArrayList快。
这里面用到了我上一篇博客提到的高精度计时器（在这里能看到代码 http://sunxiunan.com/?p=1829 ）
在开始定义了两个类。

//---------------------
    // public class List : IList, ICollection, IEnumerable, IList, ICollection, IEnumerable
    class CFromList : List
{}
    // public class ArrayList : IList, ICollection, IEnumerable, ICloneable
    class CFromArrayList : ArrayList
{}
//---------------------
List和ArrayList的定义在注释中给出，可以看出来其实都差不多。ArrayList只是多了ICloneable，还少了几个泛型接口继承。
在后面代码中都用Add方法向list中添加int类型数据，然后通过foreach形式枚举数据，注意！枚举部分的代码是有问题的，我们在（下）中会提到。
这里还要推荐一个非常棒的工具ILSpy，是sharpdevelop开发的，强烈建议dotnet程序员都下载使用。
我把ILSpy disassemble出来的C#代码和IL代码分别列在后面。注意对于ArrayList的foreach语句，C#形式的代码与源代码有些差别（79到96行），编译器加入一个IEnumerator enumerator2 = cFromArrayList.GetEnumerator();本地变量。
另外使用int num5 = (int)enumerator2.Current;这样访问iterator。而且还加入了IDisposable的finally部分。
再继续看IL代码部分，对于List形式，IL代码没有box装箱指令，而ArrayList在145行有个box指令，这是性能差别之一。
但是奇怪的是，在枚举部分，ILSpy生成的（以及ILDasm）IL代码，对于ArrayList和List而言，基本上差别不大，一样也有对MoveNext和Current以及IDisposable接口的调用。
只不过ArrayList多出unbox和box的指令。
运行结果如我们所料，List要比ArrayList快不少。
但是我们在枚举部分的代码是有问题的，我明天在（下）中会介绍。
    // public class List<T> : IList<T>, ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable
    class CFromList : List<int>{}
    // public class ArrayList : IList, ICollection, IEnumerable, ICloneable
    class CFromArrayList : ArrayList{}
    public partial class Form1 : Form
    {
        private void button1_Click(object sender, EventArgs e)
        {
            CFromList list1 = new CFromList();
            CFromArrayList list2 = new CFromArrayList();
            ////////////////////////////
            HighResolutionTimer timera = new HighResolutionTimer();
            for (int i = 0; i < 100000; i++)
            {
                list1.Add(i - 99999);
            }
            Int64 reta = timera.Stop();
            ////////////////////////////
            HighResolutionTimer timerb = new HighResolutionTimer();
            for (int i = 0; i < 100000; i++)
            {
                list2.Add(i - 99999);
            }
            Int64 retb = timerb.Stop();
            ////////////////////////////
            int index = 0;
            HighResolutionTimer timer1 = new HighResolutionTimer();
            foreach (int elem1 in list1)
            {
                list1[index++] = elem1 + 99;                
            }
            Int64 ret1 = timer1.Stop();
            ////////////////////////////
            index = 0;
            HighResolutionTimer timer2 = new HighResolutionTimer();
            foreach (int elem2 in list2)
            {
                list2[index++] = elem2 + 99;
            }
            Int64 ret2 = timer2.Stop();
            ////////////////////////////
      }
   }
///////////////////////////////////////////////////////
// result from ILSpy
CFromList cFromList = new CFromList();
CFromArrayList cFromArrayList = new CFromArrayList();
HighResolutionTimer highResolutionTimer = new HighResolutionTimer();
for (int i = 0; i < 100000; i++)
{
cFromList.Add(i - 99999);
}
long num = highResolutionTimer.Stop();
HighResolutionTimer highResolutionTimer2 = new HighResolutionTimer();
for (int i = 0; i < 100000; i++)
{
cFromArrayList.Add(i - 99999);
}
long num2 = highResolutionTimer2.Stop();
int num3 = 0;
HighResolutionTimer highResolutionTimer3 = new HighResolutionTimer();
foreach (int current in cFromList)
{
cFromList[num3++] = current + 99;
}
long num4 = highResolutionTimer3.Stop();
num3 = 0;
HighResolutionTimer highResolutionTimer4 = new HighResolutionTimer();
IEnumerator enumerator2 = cFromArrayList.GetEnumerator();
try
{
while (enumerator2.MoveNext())
{
int num5 = (int)enumerator2.Current;
cFromArrayList[num3++] = num5 + 99;
}
}
finally
{
IDisposable disposable = enumerator2 as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
long num6 = highResolutionTimer4.Stop();
//////////////////////////////////////////////////
// result from ILSpy IL format
IL_0000: nop
IL_0001: newobj instance void WindowsFormsApplication1.CFromList::.ctor()
IL_0006: stloc.0
IL_0007: newobj instance void WindowsFormsApplication1.CFromArrayList::.ctor()
IL_000c: stloc.1
IL_000d: newobj instance void WindowsFormsApplication1.HighResolutionTimer::.ctor()
IL_0012: stloc.2
IL_0013: ldc.i4.0
IL_0014: stloc.3
IL_0015: br.s IL_002b
// loop start (head: IL_002b)
IL_0017: nop
IL_0018: ldloc.0
IL_0019: ldloc.3
IL_001a: ldc.i4 99999
IL_001f: sub
IL_0020: callvirt instance void [mscorlib]System.Collections.Generic.List`1<int32>::Add(!0)
IL_0025: nop
IL_0026: nop
IL_0027: ldloc.3
IL_0028: ldc.i4.1
IL_0029: add
IL_002a: stloc.3
IL_002b: ldloc.3
IL_002c: ldc.i4 100000
IL_0031: clt
IL_0033: stloc.s 17
IL_0035: ldloc.s 17
IL_0037: brtrue.s IL_0017
// end loop
IL_0039: ldloc.2
IL_003a: callvirt instance int64 WindowsFormsApplication1.HighResolutionTimer::Stop()
IL_003f: stloc.s 4
IL_0041: newobj instance void WindowsFormsApplication1.HighResolutionTimer::.ctor()
IL_0046: stloc.s 5
IL_0048: ldc.i4.0
IL_0049: stloc.3
IL_004a: br.s IL_0065
// loop start (head: IL_0065)
IL_004c: nop
IL_004d: ldloc.1
IL_004e: ldloc.3
IL_004f: ldc.i4 99999
IL_0054: sub
IL_0055: box int32
IL_005a: callvirt instance int32 [mscorlib]System.Collections.ArrayList::Add(object)
IL_005f: pop
IL_0060: nop
IL_0061: ldloc.3
IL_0062: ldc.i4.1
IL_0063: add
IL_0064: stloc.3
IL_0065: ldloc.3
IL_0066: ldc.i4 100000
IL_006b: clt
IL_006d: stloc.s 17
IL_006f: ldloc.s 17
IL_0071: brtrue.s IL_004c
// end loop
IL_0073: ldloc.s 5
IL_0075: callvirt instance int64 WindowsFormsApplication1.HighResolutionTimer::Stop()
IL_007a: stloc.s 6
IL_007c: ldc.i4.0
IL_007d: stloc.s 7
IL_007f: newobj instance void WindowsFormsApplication1.HighResolutionTimer::.ctor()
IL_0084: stloc.s 8
IL_0086: nop
IL_0087: ldloc.0
IL_0088: callvirt instance valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<!0> [mscorlib]System.Collections.Generic.List`1<int32>::GetEnumerator()
IL_008d: stloc.s 18
.try {
IL_008f: br.s IL_00af
// loop start (head: IL_00af)
IL_0091: ldloca.s 18
IL_0093: call instance !0 [mscorlib]System.Collections.Generic.List`1/Enumerator<int32>::get_Current()
IL_0098: stloc.s 9
IL_009a: nop
IL_009b: ldloc.0
IL_009c: ldloc.s 7
IL_009e: dup
IL_009f: ldc.i4.1
IL_00a0: add
IL_00a1: stloc.s 7
IL_00a3: ldloc.s 9
IL_00a5: ldc.i4.s 99
IL_00a7: add
IL_00a8: callvirt instance void [mscorlib]System.Collections.Generic.List`1<int32>::set_Item(int32, !0)
IL_00ad: nop
IL_00ae: nop
IL_00af: ldloca.s 18
IL_00b1: call instance bool [mscorlib]System.Collections.Generic.List`1/Enumerator<int32>::MoveNext()
IL_00b6: stloc.s 17
IL_00b8: ldloc.s 17
IL_00ba: brtrue.s IL_0091
// end loop
IL_00bc: leave.s IL_00cd
} // end .try
finally {
IL_00be: ldloca.s 18
IL_00c0: constrained. valuetype [mscorlib]System.Collections.Generic.List`1/Enumerator<int32>
IL_00c6: callvirt instance void [mscorlib]System.IDisposable::Dispose()
IL_00cb: nop
IL_00cc: endfinally
} // end handler
IL_00cd: nop
IL_00ce: ldloc.s 8
IL_00d0: callvirt instance int64 WindowsFormsApplication1.HighResolutionTimer::Stop()
IL_00d5: stloc.s 10
IL_00d7: ldc.i4.0
IL_00d8: stloc.s 7
IL_00da: newobj instance void WindowsFormsApplication1.HighResolutionTimer::.ctor()
IL_00df: stloc.s 11
IL_00e1: nop
IL_00e2: ldloc.1
IL_00e3: callvirt instance class [mscorlib]System.Collections.IEnumerator [mscorlib]System.Collections.ArrayList::GetEnumerator()
IL_00e8: stloc.s 19
.try {
IL_00ea: br.s IL_0114
// loop start (head: IL_0114)
IL_00ec: ldloc.s 19
IL_00ee: callvirt instance object [mscorlib]System.Collections.IEnumerator::get_Current()
IL_00f3: unbox.any int32
IL_00f8: stloc.s 12
IL_00fa: nop
IL_00fb: ldloc.1
IL_00fc: ldloc.s 7
IL_00fe: dup
IL_00ff: ldc.i4.1
IL_0100: add
IL_0101: stloc.s 7
IL_0103: ldloc.s 12
IL_0105: ldc.i4.s 99
IL_0107: add
IL_0108: box int32
IL_010d: callvirt instance void [mscorlib]System.Collections.ArrayList::set_Item(int32, object)
IL_0112: nop
IL_0113: nop
IL_0114: ldloc.s 19
IL_0116: callvirt instance bool [mscorlib]System.Collections.IEnumerator::MoveNext()
IL_011b: stloc.s 17
IL_011d: ldloc.s 17
IL_011f: brtrue.s IL_00ec
// end loop
IL_0121: leave.s IL_0140
} // end .try
finally {
IL_0123: ldloc.s 19
IL_0125: isinst class [mscorlib]System.IDisposable
IL_012a: stloc.s 20
IL_012c: ldloc.s 20
IL_012e: ldnull
IL_012f: ceq
IL_0131: stloc.s 17
IL_0133: ldloc.s 17
IL_0135: brtrue.s IL_013f
IL_0137: ldloc.s 20
IL_0139: callvirt instance void [mscorlib]System.IDisposable::Dispose()
IL_013e: nop
IL_013f: endfinally
} // end handler
IL_0140: nop
IL_0141: ldloc.s 11
IL_0143: callvirt instance int64 WindowsFormsApplication1.HighResolutionTimer::Stop()
IL_0148: stloc.s 13


本文链接

如何学习使用C++一个实用主义者的观点

2011-03-31T03:29:00Z

最近CoolShell连续发了两篇文字，《如何学习C语言》以及《如何学习C++》。我在twitter发了一些牢骚，因为我也曾经写过一篇《漫谈C语言及如何学习C语言》http://sunxiunan.com/?p=1661 ，文字写的还算用心，可惜反响不是很热烈。

最近C++社区最大的新闻，毫无疑问就是最新标准终于Final Draft了，C++2011终于有望实现。

可是，谁会关心呢？

国内C++译作圈比较出名的就这几个人，刘未鹏PongBa，自从进入微软以后好像更加关注心智方面的研究，关于C++的文字几乎就没了。孟岩http://blog.csdn.net/myan 也是很久没有新博客文字，也少见C++方面的内容。荣耀，好像也是非常低调。最出名的莫过台湾的侯捷老师，他现在忙于企业培训，估计没啥时间写新文字。这些人里面关于C++最新标准的，还是刘未鹏在07年写的C++0X漫谈。

07年啊！！那时候房价还没有这么高！！物价也没有这么高！！！车也没有这么多！！！路也没有这么堵！！搞C++的程序员你伤不起啊！！！

瞎扯一下，回到正题。（一个初学者）如何学习以及使用C++。

看完coolshell的文字，以及刘未鹏曾经写过的《学习C++：实践者的方法》http://blog.csdn.net/pongba/archive/2007/12/11/1930150.aspx
可以发现他们都倾向于这样一种个人觉得并不很好的方式：列书单。

我在《漫谈C语言及如何学习C语言》也列书单，但不仅仅列书单。一个初学者光靠看书，只能完成学习过程中30%甚至更少的进度。

想学好C++，能真正把C++用起来，必须要读、写、看、说多种手段多种方法结合使用。

另外我个人对C++的态度，就是不要学习使用它的全部，把它的基础部分掌握了就好，足够用了。比如模板元编程这种高级话题，初学者不要牵扯过多，以免一叶障目不见泰山。学编程是干嘛的？如果是为了使用，那就学最核心最基本的那些好了。

在你学习C++之前，先明确自己的目的，为什么要学C++？为什么要用C++？可能是大学老师要你学，可能是公司开发项目需要你学。如果没有目的没有需求，不要用学习C++来折磨自己了，学点英语，学点Python编程都比学C++好玩有用多了。

学习C++之间，还需要准备一下练习环境。我这里偷一下懒，在《漫谈C语言及如何学习C语言》http://sunxiunan.com/?p=1661 这里提到的开发工具全都支持C++开发，所以你在里面选择一个安装就可以了。在Windows下开发，我建议大家安装VC2010和SP1（怎么搞到？别问我，问迅雷吧），新版本虽然有些慢，但是支持Win7操作系统，对C++标准支持更好。不是像有些人说的2003到2010没啥变化，这种人估计从来不看release note吧？！至于VC6，还是抛弃了吧。

还有一点想罗嗦一下，C++最好不要作为你的第一门编程语言，选择C语言更适合。首先是你在C语言中学到的东西，基本上在C++都可以用，包括一直遭人唾骂的MACRO宏。另外C语言入门级好书很多。而C++入门级好书不好选。如何学习C语言，看我《漫谈C语言及如何学习C语言》吧，用心点的话，大概需要半年到一年时间就足够了。

第一阶段，读书。

建议大家先一次买齐下面5本书，其他书籍不对初学者推荐：

stanly lippman的《C++ Primer》
《Effective C++:改善程序与设计的55个具体做法:第3版》
《C++标准程序库—自修教程与参考手册》侯捷孟岩翻译
《More Effective C++：35个改善编程与设计的有效方法(中文版)》
《C++编程规范:101条规则、准则与最佳实践》

第一本书非常难选，我这里建议几个候选者，读者可以到书店去翻看一下，哪一本觉得合口味就用哪一本。

候选者A，钱能老师的《C++程序设计教程(修订版)–设计思想与实现》 http://product.china-pub.com/46574
我上学的时候，翻过钱能写的C++书，感觉还不错。至于这一本实话实话我没看过，但是按照国人教学风格应该是一板一眼的。

候选者B，stanly lippman的《essential C++》，这本书我有，但是感觉不适合作为初学者使用，如果你有一两年编程经验，看看这本书也许还行。

候选者C，stanly lippman的《C++ Primer》，基本上用这本书入门，应该是比较花费时间的，但也很正统，这本书买了肯定不白瞎。

我推荐A+C，或者你到图书馆选择随便选一本《C++设计教程》作为A的替代，先知道一下皮毛。

初学者阶段需要注意的是，每看完一段，都（必须的！）要自己做做上机实验，把章节后面的练习，文章中的代码示例，自己动手把程序敲进去，编译一下，运行起来，调试调试。这一步非常重要，如果你做不到，那就学不好。

至于IDE如何调试，如何设置断点，如何建立、配置项目，不属于这篇文字范畴，但有问题的话，欢迎留言，我会尽量解答。

C++包含几个方面范式，一个是传统的结构化编程，一个是面向对象程序设计，一个是基于模板编程，还有就是STL标准模板库的使用。

读者可以按部就班，先学习结构化编程，主要掌握基本的程序语法、关键字、数据结构，比如const的使用，4种xxx_cast概念等等。

面向对象编程，要数量掌握class、new、delete，对象（资源）管理，对象生命周期，构造、析构、拷贝构造、拷贝赋值这些与对象实例相关的内容，了解一下多态、继承、重载、覆盖、operator重载这些内容。另外简单了解一下多重继承、异常处理机制等等概念。写写例子实现一下，其实都不难理解。

模板方面的内容，不要挖的太深，了解并且实验一下如何定义模板类模板函数偏特化这些基本知识就够了。我可能用的比较浅，但是我八年工作经历来看，模板的内容属于不常使用的。

STL方面，掌握几个基本的类型比如vector、list、map、set、string，了解一些基本算法，比如find之类，基本上工作就足够了。

在这里要推荐第二本C++必须有的书籍《C++标准程序库—自修教程与参考手册》侯捷孟岩翻译。这是一本必须放在手边的书籍，因为MSDN关于STL的内容写得真是太烂了，比其它内容差的太多太多。前面介绍的STL，有了这本书在一边辅助，有问题一查便知。

我一直在提的就是了解基本就足够了。没错！对于初学者而言，千万不要想着什么都学什么都会。C++的内容太多陷阱重重，什么都想知道，只能是胡子眉毛一把抓。抓主干抓基本抓核心，对我提到的内容，注意不同的层次：掌握、熟悉、了解，这些内容多看看，其它的碰到了在深入学习。

C++第三方library，比如boost，如果没有必要，不建议大家学习和使用在自己的项目中。当然也有例外，比如asio和boost-python都是最近风头很劲的库，做网络编程或者配合python的话，可以选择。

如果对于C++基本语法以及common knowledge有了认识了解，下面需要增加的就是工程实践设计方面的内容，基本上大家都推荐这几本，我也不例外。
《Effective C++:改善程序与设计的55个具体做法:第3版》
《More Effective C++：35个改善编程与设计的有效方法(中文版)》
《C++编程规范:101条规则、准则与最佳实践》

这三本书的风格都是条目式，内容很实在，不玩虚的不炫技，里面的内容都可以立刻用在工程实践当中。

另外需要说明的是，纯粹C++知识对于实际编程工作是不够的，必须结合特定领域，比如Windows下编程你要知道SDK API，Linux编程你要知道常用的system call，数据库编程要知道一些如何连接查询更新的步骤。这些没法在这里一一介绍，可以咨询公司内的其他同事，或者留言给我好了。

看完这几本书，可能你对C++的了解已经上了一个台阶，这时候就不要继续死读书了，该动手做点什么了。

第二阶段，写代码。

书读百遍其义自现，代码写的多，bug就会多。开场诗念完就讲讲如何写代码。这其实是非常难的一步，有不少朋友书读了很多，但是就是写不出一行代码，或者写出来的还是非常奇怪充斥着低级错误的代码。这就是熟练度不够的缘故。

平时喝茶的时间拿出来，想想代码该如何设计；平时泡妞的时间拿出来，想想这个函数有没有更好的实现；看到winzip、迅雷、QQ，想想如果自己写该如何实现功能。不仅要想，还要动手做一做。

如果你是做Windows编程，这里推荐一下codeproject.com，这个网站上的项目设计了Windows开发的方方面面，比如GDI如何操作，数据库，控件菜单窗口消息循环等等，都比较短小精干，而且都包含了整个项目代码下载（而不仅仅是某个片段），下载以后编译调试一下，会对自己提高帮助很大。

现在坊间也有一些step by step的书籍，教你如何一步步实现某个功能，这种书可以根据书评销量选一本然后照着实践编程。

第三阶段，看高人编程。

这一步针对读者已经工作而且公司中有高手存在的情况。跟高手拉好关系，然后坐在一边看他编程，一般有些人不喜欢别人看，但是如果你表现出很仰慕的表情，问题应该不大。一般比较靠谱的软件公司对于新人都会指定一个导师，如果幸运的话，你就看你的导师如何编程好了。

其实这是学徒到大师中很关键的一步，有个词叫”传帮带“，就是师傅手把手的教。其实编程也是一门手艺，如果没看过师傅真实的工作状态，想变成高手要比较困难一些。

看高人编程看什么，看他如何写代码，如何思考，用了哪些工具、快捷键，遇到问题怎么调试怎么跟踪的？这些都是书本上很少见，但是工程实践中又非常有用的东西。

第四阶段，分享知识。

自己水平够不够，一做分享就知道。

不少公司都会定期举行技术分享会这类活动，或者有些地方社区也会搞搞技术分享。如果你觉得自己学的差不多了，就试着把自己知道的讲出来，分享给其他人。

这样做有几个好处，一个是增加你对知识的了解。我做过不少ppt，当自己想说点什么的时候才知道自己有多深浅哪个地方还欠缺，这个办法万试万灵。在问答环节，你还可以与其他人互动，其他人的问题未必你都懂，这时候就可以继续深入学习。另外可以增加你自己的技术知名度，是一个很好的广告效应。

如果没有类似的技术分享怎么办？

我建议读者注册一个stackoverflow.com的账号，到那里去回答问题，一样也是非常好的分享方式。

本文链接

个人常用的免费iPad app软件(个人风格突出且不需越狱)

2011-03-24T02:43:00Z

我的iPad系统是iOS4.3没有越狱，推荐下面这些免费软件给各位iPad玩家。

这些软件都是通过美国app store下载来的，不用信用卡注册一个美国app store其实很简单，就是购买一个free的软件就行了。某些情况下也许需要翻墙。

下面推荐的软件都是免费的，在app store中可以搜索名字找到下载。不需要越狱也不需要破解，基本上已经满足了我日常需求。

先说说我觉得应该有但是现在还不够好（或者我还不知道的）软件：

1）浏览器，safari无法浏览桌面版google reader，太惨了，是我最不可容忍的。Firefox或者Chrome有iOS版本么？或者有什么软件浏览google reader比较像是正常浏览器的？

2）pdf阅读软件，我想要的pdf阅读器其实就需要两个功能，一个是固定缩放比例，一个是固定缩放view或者说是切白边的功能，Apabi可以切白边，但是不能固定缩放。而且我也不喜欢翻页模式，如果能做成电脑上那种pdf连续阅读模式就更好了，为什么非要模拟实体书阅读呢？这些程序设计者其实也进入一个误区。当然也可以买ibook或者kindle，那是另外一个事情了。

3）游戏方面，没有特别好玩的，操作感以及游戏大作各方面比较，都比psp差多了，这让我也感到很欣慰，psp不需要下岗。至于愤怒的小鸟，其实不很好玩。玩游戏还是需要有手柄才有感觉。

我推荐的这些软件主要分几大类，下面让我一一道来：

编程技术相关

推荐软件就是一个Zite。由于没有碰到好的RSS阅读软件，或者有些软件（比如MobileRSS之类）的阅读习惯与google reader差别太大，基本不推荐。

http://itunes.apple.com/us/app/zite/id419752338?mt=8&ls=1

Zite这个软件号称是可以学习你的阅读习惯，进入软件以后可以先定制自己喜欢的频道，或者加上自己感兴趣的tag keyword，不过要注意这些tag关键字都是Zite预置的，现在还不存在你自己添加个新关键字的可能。

在文章阅读页面，可以选择”喜欢“”不喜欢“，或者“一直给我推荐这个网站文章”“分享到twitter/FB/Email"等等功能。所谓能自我学习，也就是从读者不断地点击喜欢不喜欢来计算权值，进行文章推荐的吧。

由于没有VPN，所以只能把自己喜欢的文章用email发给自己。

英语、时事相关

推荐《The Economist》《usa today》《nytimes》《CNN》《NPR》。

免费版的经济学人《The Economist》只能看到“Editor' s highlights"，但是基本上也足够了，因为不像是技术文章那么容易看懂。另外”经济学人“还可以下载音频

收听，选择右上角的耳机图标就可以了。

在通过听看新闻学英语的这些资源中，比较推荐”CNN“和”NPR“，因为他们几乎所有的音视频都有脚本字幕（transcript），如果遇到看不懂听不懂的，看看脚本就可以了。

杂项新闻相关

推荐iWeekly周末画报，Zaker，Flipboard。

其中周末画报相对制作比较精美，而Zaker由于来源比较混杂，排版不是很好看，有了Zite以后，基本上就不用Zaker了。

游戏相关

推荐TradeNations。

除了切水果，跳跃忍者，愤怒的小鸟这一类大家总所周知的游戏，TradeNations算是一个社交加农场养成类的游戏，你可以加好友，然后到好友的农场里进行交易，买花买家具买衣服等等，这个游戏是tinyfool在twitter上推荐，还真是挺好玩，每天稍微打理一下就可以了，如果你也玩了这个游戏，欢迎加我的账号sagasw。

读书相关

推荐CloudReader，Stanza，Apabi Reader（方正阅读器），ibook，kindle。

没有特别出色的，相比来说Apabi特点突出一些，但也不是很好用。基本上ibook，kindle，Apabi阅读pdf都属于残废。但是我已经想到一个用ipad阅读pdf的方法，正在研究中。

免费、限期免费相关

推荐”app每日推送“以及”软件游戏猎手“这两款。

本文链接

高级软件工程师面试问题 Interview SeniorSoftwareEngineers

2011-02-23T15:35:00Z

hanselman这篇文章很有意思，尽管不是每个问题都很值得作为面试问题出现，但是很多都值得去仔细想想。

一个优秀的面试问题，尤其是针对Senior Engineer的面试问题，不应该仅仅是问某个api的用法，某个很容易从帮助中找到的内容。有发散性，可以基于问题进行扩展的问题才是一个比较好的问题。

下面是一个非常长的问题列表，主要是关于面向对象设计，设计模式，以及一些实际工程中会用到概念，都是比较基本的，但是也非常能考察一个高级工程师的水平，因为会牵涉到非常多方面。

另外要说明的是下面很多概念性问题可以直接从wiki维基百科上找到答案。另外我会标记出个人觉得比较值得问的问题。

原文在这里 http://www.hanselman.com/blog/NewInterviewQuestionsForSeniorSoftwareEngineers.aspx

# What is something substantive that you’ve done to improve as a developer in your career?

有没有做过什么比较实质性的事情来提升你的程序员职业水平？

好问题。我的回答：这个很难说，我的做法是坚持学习，坚持写技术类博客。另外有些经验在这里提到过http://sunxiunan.com/?p=1799

# Would you call yourself a craftsman (craftsperson) and what does that word mean to you?

不敢叫自己大师啊，那得多牛逼？！

# Implement a <basic data structure> using <some language> on <paper|whiteboard|notepad>.

用某种语言在纸面上实现一个基本的数据结构。(用近似真实格式的伪代码来表达?)

好问题。我的回答，找一本基础的数据结构书籍吧，比如这一本《数据结构与算法分析：C语言描述（原书第2版）》

# What is SOLID?

参考http://en.wikipedia.org/wiki/Solid_%28object-oriented_design%29

这个solid不是说“结实的”，而是面向对象五大原则的简称：单一责任原则，开闭原则，莱西科夫替换原则，接口分离原则，依赖倒置原则。

好问题。这几个原则的确应该背下来，太基础了。

# Why is the Single Responsibility Principle important?

为什么单一责任原则重要？

好问题。我的回答，因为职责明确，设计就不容易混乱，即使有后续变化也是可控的。

# What is Inversion of Control? How does that relate to dependency injection?

参考http://en.wikipedia.org/wiki/Inversion_of_control

实际中的例子，通知开会，一种可以打电话通知到每个人（这属于中心控制型的，必须有个controller/manager之类的）；也可张贴一个告示，大家自己来看，这属于事件响应型的。

# How does a 3 tier application differ from a 2 tier one?

三层应用与两层应用的区别是什么？

我只知道MVC三层应用。

# Why are interfaces important?

为什么接口重要？

好问题。接口的重要在于消费者（客户端）不需要了解生产者（服务端）的细节，接口相当于合同，当合同不变的时候，谁生产如何生产都不是消费者关心的问题。

# What is the Repository pattern? The Factory Pattern? Why are patterns important?

关于设计模式的问题，

第一个参考http://msdn.microsoft.com/en-us/library/ff649690.aspx

工厂模式基本上是众人皆知的模式了。

为何模式重要？我不觉得模式重要，模式的重要性在于让你能“喔！原来是这个”。但是对于一个没有几年编程经验的开发者而言，模式只能让你更混乱。

设计模式很多情况下是通过加入一个抽象层来解决耦合之类的问题，但是层次越多越复杂，就好比单位中领导的级别越多越官僚一样。

# What are some examples of anti-patterns?

反模式？少用模式，多写点清晰的代码吧。

# Who are the Gang of Four? Why should you care?

四人组，名字叫不上来，但是他们是设计模式的总结者。

# How do the MVP, MVC, and MVVM patterns relate? When are they appropriate?

这也是微软特色，大家只要知道MVC就行了，其实大家现在用的都是MVC，但是由于水平高低，效果就是千差万别。

啥MVP，MVVM我不知啊（也不是不知，只知道MVVM是wpf的一个概念，可我也不用wpf啊）

# Explain the concept of Separation of Concerns and it’s pros and cons.

参考http://en.wikipedia.org/wiki/Separation_of_concerns

我也不是了解的很细。

# Name three primary attributes of object-oriented design. Describe what they mean and why they’re important.

封装/继承/多态？

参考这里吧http://en.wikipedia.org/wiki/Object-oriented_programming

学C++这几个概念是基础啊

# Describe a pattern that is NOT the Factory Pattern? How is it used and when?

不是工厂模式，我知道个单件模式。还有模板模式/facade模式/strategy模式，具体也要翻翻书，很少有意识的套用。

# You have just been put in charge of a legacy code project with maintainability problems. What kind of things would you look to improve to get the project on a stable footing?

第一步，先把代码用最大警告级别编译一遍，然后fix所有值得fix的warning。

好问题。

# Show me a portfolio of all the applications you worked on, and tell me how you contributed to design them.

如果光是看文档，很难说到实质上。

好问题。

# What are some alternate ways to store data other than a relational database? Why would you do that, and what are the trade-offs?

好问题，很多啦，内存/文件/云存储/nosql等等。tradeoff就看你的应用需求了。blabla。。。

# Explain the concept of convention over configuration, and talk about an example of convention over configuration you have seen in the wild.

好问题。

我能想到的就是买车开车，很少有人买到车以后，拿着说明书调试这个那个，一般都是直接上路，因为汽车厂会给你一个比较不错的默认配置，也就是所谓的“方便”。

这个方便也保证了你开其它车，基本上都差不多，不用重新配置或者学习什么。

所谓方便”convention“就是把相对不错/比较普遍适用的配置都内置好了，用就是了。

# Explain the differences between stateless and stateful systems, and impacts of state on parallelism.

解释有状态与无状态系统，以及有状态系统在并行上的影响。

好问题。这个说不好。有状态系统因为保持状态，并发运行时的访问/修改需要有锁同步机制。

# Discuss the differences between Mocks and Stubs/Fakes and where you might use them (answers aren’t that important here, just the discussion that would ensue).

跟TDD相关的问题。不会哦。

# Discuss the concept of YAGNI and explain something you did recently that adhered to this practice.

解释“YAGNI”。

最简单的例子是当我们定义接口，会特意预留出一两个参数，说是为了将来使用，其实，没有将来。屁嘞！你根本不需要它！

不是说不考虑可扩展性，但是要基于可预测的基础上。

# Explain what is meant by a sandbox, why you would use one, and identify examples of sandboxes in the wild.

比如把虚拟机比如vmware virtualbox作为沙箱，用起来可以隔离风险。大不了重启，或者删除之。

# Concurrency

* What’s the difference between Locking and Lockless (Optimistic and Pessimistic) concurrency models?

* What kinds of problems can you hit with locking model? And a lockless model?

* What trade offs do you have for resource contention?

* How might a task-based model differ from a threaded model?

* What’s the difference between asynchrony and concurrency?

这些问题不错。并发相关的问题，设计多用户高性能系统必知。

# Are you still writing code? Do you love it?

我喜欢编程。

# You’ve just been assigned to a project in a new technology how would you get started?

如果是我，先了解这个技术的风险。小心求证，尽量缩小使用范围，否则是很致命的。

# How does the addition of Service Orientation change systems? When is it appropriate to use?

不懂。

# What do you do to stay abreast of the latest technologies and tools?

我跟的很紧哦！

# What is the difference between "set" logic, and "procedural" logic. When would you use each one and why?

不懂要问什么。

# What Source Control systems have you worked with?

ClearCase.很难用。最近不少问题都是跟CC相关的。

# What is Continuous Integration? Have you used it and why is it important?

持续集成。这个概念跟TDD也挂钩。

# Describe a software development life cycle that you’ve managed.

涉及的还是传统模型，不是scrum型的。

# How do you react to people criticizing your code/documents?

批评没问题，但是要有道理有根据。

# Whose blogs or podcasts do you follow? Do you blog or podcast?

这就很多了，看我以前写的文章吧。

# Tell me about some of your hobby projects that you’ve written in your off time.

主要是Lua和Py的，appengine上的比较多。

# What is the last programming book you read?

最近看得是《C++ FAQs》中文版。翻译的一般，内容也比较陈旧。更坚定了我使用C风格的C++的决心。

# Describe, in as much detail as you think is relevant, as deeply as you can, what happens when I type "cnn.com" into a browser and press "Go".

尽可能详细深入的描述，当你在浏览器敲网址然后go后面的技术细节。

好问题。很发散，绝对能看出面试者的技术厚度。

# Describe the structure and contents of a design document, or a set of design documents, for a multi-tiered web application.

# What’s so great about <cool web technology of the day>?

# How can you stop your DBA from making off with a list of your users’ passwords?

# What do you do when you get stuck with a problem you can’t solve?

参考这里计算机编程新人入行指导

http://sunxiunan.com/?p=961

# If your database was under a lot of strain, what are the first few things you might consider to speed it up?

先profiling哦！

# What is SQL injection?

# What’s the difference between unit test and integration test?

单元测试应该是程序员做。集成测试就牵扯到tester了。

# Tell me about 3 times you failed.

# What is Refactoring ? Have you used it and it is important? Name three common refactorings.

我一直在重构自己的代码。重构原则参考这里

C++项目代码规范（偶自用）http://sunxiunan.com/?p=1787

# You have two computers, and you want to get data from one to the other. How could you do it?

命名管道，socket，共享文件夹，路子还是很多的。

# Left to your own devices, what would you create?

# Given Time, Cost, Client satisfaction and Best Practices, how will you prioritize them for a project you are working on? Explain why.

这个很值得问。

# What’s the difference between a web server, web farm and web garden? How would your web application need to change for each?

# What value do daily builds, automated testing, and peer reviews add to a project? What disadvantages are there?

都是为了提升代码质量，但是会延长工期。

# What elements of OO design are most prone to abuse? How would you mitigate that?

# When do you know your code is ready for production?

看bug fix的统计曲线。

本文链接

理解Node.js事件驱动编程

2011-02-01T10:43:00Z

Node.js现在非常活跃，相关生态社区已经超过Lua（基本上比较知名的功能都有nodejs模块实现）。

但是我们为何要使用Node.Js？相比传统的webserver服务模式，nodejs有什么优点优势？

Node.Js是基于javascript语言，建构在google V8 engine以及Linux上的一个非阻塞事件驱动IO框架。nodejs是单进程单线程，但是基于V8的强大驱动力，以及事件驱动模型，nodejs的性能非常高，而且想达到多核或者多进程也不是很难（现在已经有大量的第三方module来实现这个功能）。

这里主要不是介绍nodejs具体应用代码，而是想介绍一下事件驱动编程。

在这篇文章（1）里面，Dan York介绍了两种典型的事件驱动实例。

第一个例子是关于医生看病。

在美国去看医生，需要填写大量表格，比如保险、个人信息之类，传统的基于线程的系统（thread-based system），接待员叫到你，你需要在前台填写完成这些表格，你站着填单，而接待员坐着看你填单。你让接待员没办法接待下一个客户，除非完成你的业务。

想让这个系统能运行的快一些，只有多加几个接待员，人力成本需要增加不少。

基于事件的系统（event-based system）中，当你到窗口发现需要填写一些额外的表格而不仅仅是挂个号，接待员把表格和笔给你，告诉你可以找个座位填写，填完了以后再回去找他。你回去坐着填表，而接待员开始接待下一个客户。你没有阻塞接待员的服务。

你填完表格，返回队伍中，等接待员接待完现在的客户，你把表格递给他。如果有什么问题或者需要填写额外的表格，他给你一份新的，然后重复这个过程。

这个系统已经非常高效了，几乎大部分医生都是这么做的。如果等待的人太多，可以加入额外的接待员进行服务，但是肯定要比基于线程模式的少得多。

第二个例子是快餐店点餐。

在基于线程的方式中（thread-based way）你到了柜台前，把你的点餐单给收银员或者给收银员直接点餐，然后等在那直到你要的食物准备好给你。收银员不能接待下一个人，除非你拿到食物离开。想接待更多的客户，容易！加更多的收银员！

当然，我们知道快餐店其实不是这样工作的。他们其实就是基于事件驱动方式，这样收银员更高效。只要你把点餐单给收银员，某个人已经开始准备你的食物，而同时收银员在进行收款，当你付完钱，你就站在一边而收银员已经开始接待下一个客户。在一些餐馆，甚至会给你一个号码，如果你的食物准备好了，就呼叫你的号码让你去柜台取。关键的一点是，你没有阻塞下一个客户的订餐请求。你订餐的食物做好的事件会导致某个人做某个动作（某个服务员喊你的订单号码，你听到你的号码被喊到去取食物），在编程领域，我们称这个为回调（callback function）。

Node.Js做了什么工作呢？

传统的web server多为基于线程模型。你启动Apache或者什么server，它开始等待接受连接。当收到一个连接，server保持连接连通直到页面或者什么事务请求完成。如果他需要花几微妙时间去读取磁盘或者访问数据库，web server就阻塞了IO操作（这也被称之为阻塞式IO).想提高这样的web server的性能就只有启动更多的server实例。

相反的，Node.Js使用事件驱动模型，当web server接收到请求，就把它关闭然后进行处理，然后去服务下一个web请求。当这个请求完成，它被放回处理队列，当到达队列开头，这个结果被返回给用户。这个模型非常高效可扩展性非常强，因为webserver一直接受请求而不等待任何读写操作。（这也被称之为非阻塞式IO或者事件驱动IO）

考虑下面这个过程：

1，你用浏览器访问nodejs服务器上的"/about.html"

2，nodejs服务器接收到你的请求，调用一个函数从磁盘上读取这个文件。

3，这段时间，nodejs webserver在服务后续的web请求。

4，当文件读取完毕，有一个回调函数被插入到nodejs的服务队列中。

5，nodejs webserver运行这个函数，实际上就是渲染（render）了about.html页面返回给你的浏览器。

好像就节省了几微秒时间，但是这很重要！特别是对于需要相应大量用户的web server。

这也就是为什么Node.Js这么热这么惹人关注。而且它还使用了一个非常通用的编程语言Javascript，也让开发者可以快速容易的编写高可扩展性服务器。

(1) http://code.danyork.com/2011/01/25/node-js-doctors-offices-and-fast-food-restaurants-understanding-event-driven-programming/

本文链接