標籤：

為什麼好多編程「牛人」不喜歡用Microsoft Visual Studio？

01-12

我認識的周圍很多編程不錯（相對）的人，比如搞ACM的或者本科攢了10萬+代碼的人，他們都反映不喜歡用VS甚至不會用，想了解下為什麼？此處對牛人加了雙引號僅表示我對此不確定，不帶有任何不敬的意思。

ACM，呵呵

用過就丟的東西用得著上 VS 么？

來看個 @唐飛虎 寫的題目答案：

#define LOCAL

/** ` Micro Mezzo Macro Flation -- Overheated Economy ., Ver 0.1 **/

#include &
#include &
#include &
#include &
#include &
#include &
#include &
#include &
#include &
#include &
#include &
#include &
#include &
#include &
#include &
#include &
#include &
#include & #include &
#include &

using namespace std;

#define REP(i, n__) for (int i=0;i&=int(a);--i)
#define REP_1(i, n__) for (int i=1;i&<=int(n__);++i) #define FOR_1(i, a, b) for (int i=int(a);i&<=int(b);++i) #define DWN_1(i, b, a) for (int i=int(b);i&>=int(a);--i)
#define REP_C(i, n) for (int n____=int(n),i=0;i&=a____;--i)
#define REP_N(i, n) for (i=0;i&=int(a);--i)
#define REP_1_C(i, n) for (int n____=int(n),i=1;i&<=n____;++i) #define FOR_1_C(i, a, b) for (int b____=int(b),i=a;i&<=b____;++i) #define DWN_1_C(i, b, a) for (int a____=int(a),i=b;i&>=a____;--i)
#define REP_1_N(i, n) for (i=1;i&<=int(n);++i) #define FOR_1_N(i, a, b) for (i=int(a);i&<=int(b);++i) #define DWN_1_N(i, b, a) for (i=int(b);i&>=int(a);--i)
#define REP_C_N(i, n) for (n____=int(n),i=0;i&=a____;--i)
#define REP_1_C_N(i, n) for (n____=int(n),i=1;i&<=n____;++i) #define FOR_1_C_N(i, a, b) for (b____=int(b),i=a;i&<=b____;++i) #define DWN_1_C_N(i, b, a) for (a____=int(a),i=b;i&>=a____;--i)

//#define ECH(it, A) for (typeof(A.begin()) it=A.begin(); it != A.end(); ++it)
#define ECH(it, A) for (__typeof(A.begin()) it=A.begin(); it != A.end(); ++it)
#define REP_S(it, str) for (char*it=str;*it;++it)
#define REP_G(it, u) for (int it=hd[u];it;it=suc[it])
#define DO(n) for ( int ____n ## __line__ = n; ____n ## __line__ -- ; )
#define REP_2(i, j, n, m) REP(i, n) REP(j, m)
#define REP_2_1(i, j, n, m) REP_1(i, n) REP_1(j, m)
#define REP_3(i, j, k, n, m, l) REP(i, n) REP(j, m) REP(k, l)
#define REP_3_1(i, j, k, n, m, l) REP_1(i, n) REP_1(j, m) REP_1(k, l)

#define ALL(A) A.begin(), A.end()
#define LLA(A) A.rbegin(), A.rend()
#define CPY(A, B) memcpy(A, B, sizeof(A))
#define INS(A, P, B) A.insert(A.begin() + P, B)
#define ERS(A, P) A.erase(A.begin() + P)
#define BSC(A, X) find(ALL(A), X) // != A.end()
#define CTN(T, x) (T.find(x) != T.end())
#define SZ(A) int(A.size())
#define PB push_back
#define MP(A, B) make_pair(A, B)
#define PTT pair&
#define fi first
#define se second

#define Rush for(int ____T=RD(); ____T--;)

#define Display(A, n, m) {
REP(i, n){
REP(j, m) cout &<&< A[i][j] &<&< " "; cout &<&< endl; } } #define Display_1(A, n, m) { REP_1(i, n){ REP_1(j, m) cout &<&< A[i][j] &<&< " "; cout &<&< endl; } } #pragma comment(linker, "/STACK:36777216") //#pragma GCC optimize ("O2") #define Ruby system("ruby main.rb") #define Haskell system("runghc main.hs") #define Python system("python main.py") #define Pascal system("fpc main.pas") typedef long long LL; //typedef long double DB; typedef double DB; typedef unsigned UINT; typedef unsigned long long ULL; typedef vector& VI;
typedef vector& VC;
typedef vector& VS;
typedef vector& VL;
typedef vector& VD;
typedef set& SI;
typedef set& SS;
typedef set& SL;
typedef set& SD;
typedef map& MII;
typedef map& MSI;
typedef map& MLI;
typedef map& MDI;
typedef pair& PII;
typedef pair& PIB;
typedef pair& PLL;
typedef vector& VII;
typedef vector& VVI;
typedef vector& VVII;

template& inline T RD(T );
template& inline void OT(const T );
inline LL RD(){LL x; return RD(x);}
inline char RC(char c){scanf(" %c", c); return c;}
inline char RC(){char c; return RC(c);}
//inline char RC(char c){c = getchar(); return c;}
//inline char RC(){return getchar();}
inline DB RF(DB x){scanf("%lf", x); return x;}
inline DB RF(){DB x; return RF(x);}
inline char* RS(char *s){scanf("%s", s); return s;}

template& inline T0 RD(T0 x0, T1 x1){RD(x0), RD(x1); return x0;}
template& inline T0 RD(T0 x0, T1 x1, T2 x2){RD(x0), RD(x1), RD(x2); return x0;}
template& inline T0 RD(T0 x0, T1 x1, T2 x2, T3 x3){RD(x0), RD(x1), RD(x2), RD(x3); return x0;}
template& inline T0 RD(T0 x0, T1 x1, T2 x2, T3 x3, T4 x4){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4); return x0;}
template& inline T0 RD(T0 x0, T1 x1, T2 x2, T3 x3, T4 x4, T5 x5){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5); return x0;}
template& inline T0 RD(T0 x0, T1 x1, T2 x2, T3 x3, T4 x4, T5 x5, T6 x6){RD(x0), RD(x1), RD(x2), RD(x3), RD(x4), RD(x5), RD(x6); return x0;}
template& inline void OT(const T0 x0, const T1 x1){OT(x0), OT(x1);}
template& inline void OT(const T0 x0, const T1 x1, const T2 x2){OT(x0), OT(x1), OT(x2);}
template& inline void OT(const T0 x0, const T1 x1, const T2 x2, const T3 x3){OT(x0), OT(x1), OT(x2), OT(x3);}
template& inline void OT(const T0 x0, const T1 x1, const T2 x2, const T3 x3, const T4 x4){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4);}
template& inline void OT(const T0 x0, const T1 x1, const T2 x2, const T3 x3, const T4 x4, const T5 x5){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5);}
template& inline void OT(const T0 x0, const T1 x1, const T2 x2, const T3 x3, const T4 x4, const T5 x5, const T6 x6){OT(x0), OT(x1), OT(x2), OT(x3), OT(x4), OT(x5), OT(x6);}
inline char RC(char a, char b){RC(a), RC(b); return a;}
inline char RC(char a, char b, char c){RC(a), RC(b), RC(c); return a;}
inline char RC(char a, char b, char c, char d){RC(a), RC(b), RC(c), RC(d); return a;}
inline char RC(char a, char b, char c, char d, char e){RC(a), RC(b), RC(c), RC(d), RC(e); return a;}
inline char RC(char a, char b, char c, char d, char e, char f){RC(a), RC(b), RC(c), RC(d), RC(e), RC(f); return a;}
inline char RC(char a, char b, char c, char d, char e, char f, char g){RC(a), RC(b), RC(c), RC(d), RC(e), RC(f), RC(g); return a;}
inline DB RF(DB a, DB b){RF(a), RF(b); return a;}
inline DB RF(DB a, DB b, DB c){RF(a), RF(b), RF(c); return a;}
inline DB RF(DB a, DB b, DB c, DB d){RF(a), RF(b), RF(c), RF(d); return a;}
inline DB RF(DB a, DB b, DB c, DB d, DB e){RF(a), RF(b), RF(c), RF(d), RF(e); return a;}
inline DB RF(DB a, DB b, DB c, DB d, DB e, DB f){RF(a), RF(b), RF(c), RF(d), RF(e), RF(f); return a;}
inline DB RF(DB a, DB b, DB c, DB d, DB e, DB f, DB g){RF(a), RF(b), RF(c), RF(d), RF(e), RF(f), RF(g); return a;}
inline void RS(char *s1, char *s2){RS(s1), RS(s2);}
inline void RS(char *s1, char *s2, char *s3){RS(s1), RS(s2), RS(s3);}

template& inline void RST(T A){memset(A, 0, sizeof(A));}
template& inline void RST(T0 A0, T1 A1){RST(A0), RST(A1);}
template& inline void RST(T0 A0, T1 A1, T2 A2){RST(A0), RST(A1), RST(A2);}
template& inline void RST(T0 A0, T1 A1, T2 A2, T3 A3){RST(A0), RST(A1), RST(A2), RST(A3);}
template& inline void RST(T0 A0, T1 A1, T2 A2, T3 A3, T4 A4){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4);}
template& inline void RST(T0 A0, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5);}
template& inline void RST(T0 A0, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6){RST(A0), RST(A1), RST(A2), RST(A3), RST(A4), RST(A5), RST(A6);}
template& inline void FLC(T A, int x){memset(A, x, sizeof(A));}
template& inline void FLC(T0 A0, T1 A1, int x){FLC(A0, x), FLC(A1, x);}
template& inline void FLC(T0 A0, T1 A1, T2 A2, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x);}
template& inline void FLC(T0 A0, T1 A1, T2 A2, T3 A3, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x);}
template& inline void FLC(T0 A0, T1 A1, T2 A2, T3 A3, T4 A4, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x);}
template& inline void FLC(T0 A0, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x);}
template& inline void FLC(T0 A0, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6, int x){FLC(A0, x), FLC(A1, x), FLC(A2, x), FLC(A3, x), FLC(A4, x), FLC(A5, x), FLC(A6, x);}
template& inline void CLR(priority_queue&, less& &> Q){while (!Q.empty()) Q.pop();}
template& inline void CLR(priority_queue&, greater& &> Q){while (!Q.empty()) Q.pop();}
template& inline void CLR(T A){A.clear();}
template& inline void CLR(T0 A0, T1 A1){CLR(A0), CLR(A1);}
template& inline void CLR(T0 A0, T1 A1, T2 A2){CLR(A0), CLR(A1), CLR(A2);}
template& inline void CLR(T0 A0, T1 A1, T2 A2, T3 A3){CLR(A0), CLR(A1), CLR(A2), CLR(A3);}
template& inline void CLR(T0 A0, T1 A1, T2 A2, T3 A3, T4 A4){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4);}
template& inline void CLR(T0 A0, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5);}
template& inline void CLR(T0 A0, T1 A1, T2 A2, T3 A3, T4 A4, T5 A5, T6 A6){CLR(A0), CLR(A1), CLR(A2), CLR(A3), CLR(A4), CLR(A5), CLR(A6);}
template& inline void CLR(T A, int n){REP(i, n) CLR(A[i]);}

template& inline T SRT(T A){sort(ALL(A)); return A;}
template& inline T SRT(T A, C B){sort(ALL(A), B); return A;}

// &<&<= ` 0. Daily Use ., template& inline void checkMin(T a,const T b){if (b& inline void checkMax(T a,const T b){if (a& inline void checkMin(T a, T b, const T x){checkMin(a, x), checkMin(b, x);}
template& inline void checkMax(T a, T b, const T x){checkMax(a, x), checkMax(b, x);}
template & inline void checkMin(T a, const T b, C c){if (c(b,a)) a = b;}
template & inline void checkMax(T a, const T b, C c){if (c(a,b)) a = b;}
template& inline T min(T a, T b, T c){return min(min(a, b), c);}
template& inline T max(T a, T b, T c){return max(max(a, b), c);}
template& inline T min(T a, T b, T c, T d){return min(min(a, b), min(c, d));}
template& inline T max(T a, T b, T c, T d){return max(max(a, b), max(c, d));}
template& inline T sqr(T a){return a*a;}
template& inline T cub(T a){return a*a*a;}
inline int Ceil(int x, int y){return (x - 1) / y + 1;}

// &<&<= ` 1. Bitwise Operation ., namespace BO{ inline bool _1(int x, int i){return bool(x1&<&&> 1) 0x55555555) | ((x &<&< 1) 0xaaaaaaaa); x = ((x &>&> 2) 0x33333333) | ((x &<&< 2) 0xcccccccc); x = ((x &>&> 4) 0x0f0f0f0f) | ((x &<&< 4) 0xf0f0f0f0); x = ((x &>&> 8) 0x00ff00ff) | ((x &<&< 8) 0xff00ff00); x = ((x &>&>16) 0x0000ffff) | ((x &<&<16) 0xffff0000); return x; } inline LL reverse_bits(LL x){ x = ((x &>&> 1) 0x5555555555555555LL) | ((x &<&< 1) 0xaaaaaaaaaaaaaaaaLL); x = ((x &>&> 2) 0x3333333333333333LL) | ((x &<&< 2) 0xccccccccccccccccLL); x = ((x &>&> 4) 0x0f0f0f0f0f0f0f0fLL) | ((x &<&< 4) 0xf0f0f0f0f0f0f0f0LL); x = ((x &>&> 8) 0x00ff00ff00ff00ffLL) | ((x &<&< 8) 0xff00ff00ff00ff00LL); x = ((x &>&>16) 0x0000ffff0000ffffLL) | ((x &<&<16) 0xffff0000ffff0000LL); x = ((x &>&>32) 0x00000000ffffffffLL) | ((x &<&<32) 0xffffffff00000000LL); return x; } template& inline bool odd(T x){return x1;}
template& inline T low_bit(T x) {return x -x;}
template& inline T high_bit(T x) {T p = low_bit(x);while (p != x) x -= p, p = low_bit(x);return p;}
template& inline T cover_bit(T x){T p = 1; while (p &< x) p &<&<= 1;return p;} inline int low_idx(int x){return __builtin_ffs(x);} inline int low_idx(LL x){return __builtin_ffsll(x);} inline int high_idx(int x){return low_idx(reverse_bits(x));} inline int high_idx(LL x){return low_idx(reverse_bits(x));} inline int clz(int x){return __builtin_clz(x);} inline int clz(LL x){return __builtin_clzll(x);} inline int ctz(int x){return __builtin_ctz(x);} inline int ctz(LL x){return __builtin_ctzll(x);} inline int parity(int x){return __builtin_parity(x);} inline int parity(LL x){return __builtin_parityll(x);} inline int lg2(int a){return 31 - __builtin_clz(a);} inline int count_bits(int x){return __builtin_popcount(x);} inline int count_bits(LL x){return __builtin_popcountll(x);} } using namespace BO; template& inline T RD(T x){
//cin &>&> x;
// scanf("%d", x);
char c; for (c = getchar(); c &< "0"; c = getchar()); x = c - "0"; for (c = getchar(); "0" &<= c c &<= "9"; c = getchar()) x = x * 10 + c - "0"; //char c; c = getchar(); x = c - "0"; for (c = getchar(); c &>= "0"; c = getchar()) x = x * 10 + c - "0";
return x;
}

int ____Case; template& inline void OT(const T x){
//if (x == -1) printf("Case %d: NO
", ++____Case);
//else printf("Case %d: %d
", ++____Case, x);
//printf("%I64d
", x);
//printf("%.2lf
", x);
printf("%d
", x);
// cout &<&< x &<&< endl; } /* .................................................................................................................................. */ const int N = 5e4 + 19; int a[N] , n , Q; const int M = 1e6 + 9; int qx , qy; namespace Persistent_tree{ const int TN = N * 60 * 50; int T[N]; int l[TN] , r[TN] , c[TN] , tot , pre[N]; int build(int L , int R){ int rt = ++ tot; if (L &>= R) return rt;
int mid = L + R &>&> 1;
l[rt] = build(L , mid);
r[rt] = build(mid + 1 , R);
c[rt] = 0;
return rt;
}
int update(int rt , int p , int d){
int nrt = ++tot , root = nrt;
c[nrt] = c[rt] + d;
int L = 0 , R = n;
int mid ;
while (L &< R){ mid = L + R &>&> 1;
if (p &<= mid){ l[nrt] = ++ tot , r[nrt] = r[rt]; nrt = l[nrt] , rt = l[rt] , R = mid; } else{ l[nrt] = l[rt] , r[nrt] = ++tot; nrt = r[nrt] , rt = r[rt] , L = mid + 1; } c[nrt] = c[rt] + d; } return root; } int query(int rt){ //Query prefix int res = 0 , L = 0 , R = n; int mid ; while(L &< R){ mid = L + R &>&> 1;
if (qx &<= mid){ rt = l[rt]; R = mid; } else{ res += c[l[rt]]; rt = r[rt]; L = mid + 1; } } return res;// + c[rt]; } }; #define PT Persistent_tree namespace BIT{ void Modify(int rt , int x , int y){ for ( ; rt &<= n ; rt += low_bit(rt)){ PT::T[rt] = PT::update(PT::T[rt] , x , -1) ; PT::T[rt] = PT::update(PT::T[rt] , y , 1); } x = y; } int lsum(int rt){ int ret = PT::query(PT::pre[rt]); for( ; rt ; rt ^= low_bit(rt)) ret += PT::query(PT::T[rt]); return ret; } int query(int l, int r){ return lsum(r) - lsum(l - 1); } }; int Pre[N]; SI H[M]; SI :: iterator iter; int main(){ //freopen("0.txt" , "r" , stdin); RD(n , Q); PT::tot = 0; #define BT BIT REP_1(i , n) RD(a[i]); int Null = PT::build(0 , n); REP_1(i , n) PT::T[i] = Null; REP_1(i , n){ iter = H[a[i]].lower_bound(i); if(iter != H[a[i]].begin())Pre[i] = *--iter; H[a[i]].insert(i); } PT::pre[0] = Null; REP_1(i , n) PT::pre[i] = PT::update(PT::pre[i - 1] , Pre[i] , 1); char op; DO(Q){ RC(op); qx = RD() + 1; qy = RD(); if (op == "M"){ if (a[qx] == qy) continue; SI sx = H[a[qx]] , sy = H[qy]; sx.erase(qx); iter = sx.lower_bound(qx); if(iter != sx.end()) BT::Modify(*iter , Pre[*iter] , Pre[qx]); iter = sy.lower_bound(qx); if (iter == sy.begin()) BT::Modify(qx , Pre[qx] , 0); else BT::Modify(qx , Pre[qx] , *--sy.lower_bound(qx)); if (iter != sy.end()) BT::Modify(*iter , Pre[*iter] , qx); sy.insert(qx); a[qx] = qy; } else OT(BT::query(qx , qy)); } }

因為你遇上的人水平不夠高。ACM大神不一定是編程高手，他們的目標是更迅速，而不是更高的編程水平。本科代碼量10萬行+的，有啥，我高中就達到了。

看過笑傲江湖沒有。那裡面水平低的劍宗，靠的是劍。高一點的氣宗，講究不用劍，飛花摘葉即可傷人。那已經被認為是高手了。但水平絕頂的獨孤求敗、風清揚、令狐沖，又是用劍的。

真想stick to console也可以用msbuild + vim，手寫.proj。真正微軟系的大型項目大多都是用msbuild。很多所謂高手都是半桶水還不願意學習的。。。

1、我寫java、clojure、javascript。未來可能要寫python。

2、為了玩各種新鮮玩意兒，我用ubuntu～就圖包管理好用

==

用vim和intellij就很爽了，還讓我用vsc？

因為題主對「牛人」的標準過低（自己一個人就可以認得很多個，肯定不是國家級別的，頂多是省級或者市級），需要VS市場佔有率增加到99.99%以上才可能出現所有編程「牛人」都喜歡用Microsoft Visual Studio情況。

但是VS市場佔有率可能有99.99%么？

所以這問題並沒有什麼用。

VS就是一個工具而已，不是萬能葯。就算是一般人，也應該針對自己的不同需求使用最適合的工具，更不用說牛人了。

Stack Overflow Developer Survey 2015

你看，win7win8份額加起來大概50%，也就是說VS使用者份額應該遠低於50%。

那麼發現好多人不用VS不是很正常么，有什麼好奇怪的啊。

好不容易有了一身本領，結果用一些爛工具來抵消自己的輸出性能的，實為idiot。

所以在windows上我們要用VS，在linux上我們要用vim（放棄垃圾emacs！）

===========================

作為一酷愛折磨linker的正確的C++程序員，VS我最喜歡的就是佔用內存極少的cl.exe、intellisense和debugger了。同樣是那麼多內存的機器，在Windows上編譯GacUI就只要幾分鐘，在Linux上編譯就會瘋狂消耗虛擬內存。

不過有一次VS也幫不了我。那會兒我還在讀書，寫一個Haskell那樣子的類型推導程序。推導是遞歸的，而且都是那幾個函數來回遞歸，因此無論是看callstack還是看變數都完全失去了意義，只能通過運行完之後在幾個M的log裡面找找看有沒有錯誤。

那作為一個程序員要怎呢辦呢？

好好鍛煉身體，長一身肌肉，看log也更快了！

他們一定沒寫過企業級應用吧。

一個大型工程動輒就超過100W行，超過1000人同時開發和維護，你用文本編譯器倒是試試啊。

他們寫的是java吧

不用IDE的程序員，一般來說，要麼是做前端的，要麼是寫演算法還能很自信覺得BUG比較少的。

VS、Eclipse等開發工具，我們姑且不說各種炫酷的項目管理類的工具、文檔工具，單單是輔助編程的功能，在一個超過幾百行的項目中都是不可或缺的。

比如：

1. 對一堆堆依賴項進行管理（好幾十個.jar文件、.dll文件難道要手寫？當然也可以手寫ant、maven、gradle、makefile，不過很蛋疼）；

2. 極強、極方便的debug功能（gdb？用gdb簡直就是自虐，除非那個程序已經在伺服器上跑了）；

3. 代碼編寫的輔助（雖然Sublime等都可以，但是相比IDE還是弱爆了）；

4. 開發、編譯、運行環境自動配置、集成（手寫好幾十個參數的編譯選項，你在逗我？GUI可是打幾個勾就能完成了）；

5. 編寫時檢查（沒有這個功能，我寫一個JavaBean可能都會把字母打錯）。

就我個人而言，除非一個代碼只需要改那麼一小點並且不用編譯以至於我懶得開IDE，或者寫個小程序來測試一下，否則我都會開著IDE去乾的。

很簡單啊，買不起。

我承認，為了再不用盜版努力這麼多年挺裝逼的，要是不要節操，我錢比現在賺的多多了。

我樂意啊。

感謝我的家人容忍了我的任性。

不過其實Linux和那些編輯器沒有你們想的那麼難用。

我本科也寫了十幾萬行代碼，聽起來很牛逼，其實只是因為有一半以上是彙編，還有當時沒有現成的圖形庫

//

當時也不用VS，因為我用的是Turbo C

//

哦，對了，那是93年，VS還叫做Microsoft C

//

後來上班了用VS，一年也寫不了幾萬行代碼，幸好我們不是按照代碼行數發薪水

//

所以我也不知道我在回答什麼，因為我不知道題主在問什麼

//

還有，我不是高手，以上

我靠 本科寫代碼（除了項目）需要vs？你在逗我？

目測題主小白

vs用來項目開發的

本科寫十萬代碼都是些不需要外接庫外部依賴和Sdk的玩意

演算法 數據結構 彙編加起來什麼特殊的東西都不用調用用vs就是給自己找不痛快

況且cb sb vim這種編輯器 體量僅是vs的百分之一

說回來acm的人你讓他去搞項目 開發win軟體，語言c++或c# 我到想看看不用vs用什麼

工具用慣了就和心意連在一起，用什麼工具也代表了這個人的思維習慣，牛人鄙視的其實是那種離開單步調試就不會寫程序的人，恰好VisualStudio在這方面做得極好，在非Windows上雖然用不了VisualStudio，不過你們沒聽說過VisualGDB嗎？

這個問題誰邀我進來的？

你先在Linux/Unix/Mac給我裝個visual studio。

左姐姐贊了我好開心呢~

這樣說，我學競賽的時候用的gedit 和mingw，代碼清爽宜人，瞬間編譯運行，養成代碼調試的好習慣，越用越爽。

後來實慣用c#寫遊戲，用VS，codemap 閱讀長代碼真是爽，查看函數引用真是爽，api 補全真是爽，越用越爽，一度變成vs腦殘粉。

後來實習結束碰巧做oj，順手點開vs寫代碼，卧槽怎麼還要建工程，什麼破玩意兒，然後關了繼續用文本編輯器加編譯器。。

所以說，用什麼工具是由需求決定的，acm大神不用重量級ide可能因為他只想寫個網路流

然而我們實驗開發的面向市場的軟體都是用VS、、、、、

直接問他們。

其實梅西之所以踢得好，和他穿什麼鞋沒什麼關係的。

因為他們支持正版

因為vs打開慢，一卡一卡的…

acmer代碼短，也沒必要用vs，vim就夠了&>?

推薦閱讀：

※「Monokai」這個詞是什麼意思？
※如何評價Tinyfool在swiftcon大會上發言跑題被罵一事？

TAG:編程 | MicrosoftVisualStudio |