鴨子編譯器

『壹』 鴻蒙系統代碼開源，不擔心友商「抄襲」嗎

最近手機圈最火的話題恐怕就是華為宣布最快今年秋季，最晚明年春季就要正式發布自主研發的操作系統了。這是續華為自研麒麟晶元之後又一重磅炸彈，而華為的操作系統很有可能命名為鴻蒙，目前鴻蒙已經通過了注冊商標，離發布已經越來越近了

老用戶無需購買新華為手機就能用上。而友商手機，比如小米魅族甚至三星手機，都可以通過編譯後刷入，就像之前刷其它非官方ROM一樣，當然前提是要解BL鎖和ROOT。所以等到鴻蒙系統發布之後，只要想用，我們手上的手機都能夠用上，就看華為官方會不會放出適配包了

『貳』 軟體設計模式鴨子模擬器

假設我們需要設計出各種各樣的鴨子，一邊游泳戲水， 一邊呱呱叫。很明顯這時我們需要設計了一個鴨子超類（Superclass），並讓各種鴨子繼承此超類。

public abstract class Duck {
public void Swim() {
//會游泳
}
public abstract display();//各種外觀不一樣，所以為抽象
public void Quack() {
//會叫
}
}
每一隻鴨子就繼承Duck類
public class MallardDuck extends Duck {
public void display() {
// 外觀是綠色的
}
}
public class RedheadDuck extends Duck{
public void display(){
// 外觀是紅色的
}
}
好了，我們完成這些後，但是發現我們需要有一些鴨子是會飛的，應該怎麼修改呢？
也許你要說這很簡單，在Duck類裡面直接加入一個fly()方法，不就可以了。

public abstract class Duck {
public void Swim() {
//會游泳
}
public abstract display();//各種外觀不一樣，所以為抽象
public void Quack() {
//會叫
}
public void fly(){
//會飛
}
}
這時你會發現所有的鴨子都變成了會飛的,很明顯這是不對了，例如橡皮鴨顯然就不是了。
你也許想到了另一種方法，在會飛的鴨子類里才添加該方法不就可以了嘛，

public class MallardDuck extend Duck{
public void display(){
// 外觀是綠色的
}
public void fly(){
//會飛
}
}
這個方法看起來是很不錯，可是有很多種鴨子都會飛的時候，代碼的復用性很明顯是不夠好的,你不得不在
每一個會飛的鴨子類里去寫上同一個fly()方法,這可不是個好主意.
可能你又想到另一個方法：採用繼承和覆蓋，在Duck類里實現fly()方法，在子類里如果不會飛的就覆蓋它

public abstract class Duck {
public void Swim() {
//會游泳
}
public abstract display();//各種外觀不一樣，所以為抽象
public void Quack(){
//會叫
}
public void fly(){
//會飛
}
}
//橡皮鴨吱吱叫，不會飛
public class RubberDuck extend Duck{
public void quack(){
//覆蓋成吱吱叫
}
public void display{
//外觀是橡皮鴨
}
public void fly{
//什麼也不做
}
}

這樣我們真實現了確實能飛的鴨子才可以飛起來了，看起來主意不錯！問題到這兒似乎得到了解決
但我們現在有了一種新的鴨子，誘鉺鴨(不會飛也不會叫),看來需要這樣來寫
public class DecoyDuck extend Duck{
public void quack(){
//覆蓋，變成什麼也不做
}
public void display(){
//誘餌鴨
}
public void fly(){
//覆蓋，變成什麼也不做
}
}

每當有新的鴨子子類出現或者鴨子新的特性出現，就不得不被迫在Duck類里添加並在所有子類里檢查可能需要覆蓋fly()和quark()...這簡直是無窮盡的惡夢。所以，我們需要一個更清晰的方法，讓某些（而不是全部）鴨子類型可飛或可叫。讓鴨子的特性能有更好的擴展性。
用一下介面的方式把fly()取出來，放進一個Flyable介面中，這樣只有會飛的鴨子才實現這個介面，當然我們也可以照此來設計一個Quackbable介面，因為不是所有的鴨子都會叫,也只讓會叫的鴨子才去實現這個介面.
但這個方法和上面提到的在子類里去實現fly一樣笨，如果幾十種都可以飛，你得在幾十個鴨子里去寫上一樣的fly(),如果一旦這個fly有所變更，你將不得不找到這幾十個鴨子去一個一個改它們的fly()方法。
因為改變鴨子的行為會影響所有種類的鴨子，而這並不恰當。Flyable與Quackable介面一開始似乎還挺不錯， 解決了問題（ 只有會飛的鴨子才繼承Flyable） ， 但是java的介面不具有實現代碼， 所以繼承介面無法達到代碼的復用。這意味著：無論何時你需要修改某個行為，你必須得往下追蹤並修改每一個定義此行為的類。
策略模式的第一原則：找出應用中可能需要變化之處，把它們獨立出來，不要和那些不需要變化的代碼混在一起。 好吧，回頭看一下這個Duck類，就我們目前所知，除了fly()和quack()的問題之外，Duck類還算一切正常，主要是鴨子的行為總是可能變化的，讓我們頭痛就在於這些行為的變化，那我們就把這些行為獨立出來。
為了要把這兩個行為從Duck 類中分開， 我們將把它們自Duck 類中取出，建立一組新類代表每個行為。我們建立兩組類（完全遠離Duck類），一個是「fly」相關的，一個是「quack」相關的，每一組類將實現各自 的動作。比方說，我們可能有一個類實現「呱呱叫」，另一個類實現「吱吱叫」，另一個類實現「安靜」。我們利用介面代表每組行為，比方說， FlyBehavior來代表飛的行為，QuackBehavior代表叫的行為，而讓每一種行為具體類來實現該行為介面。
在此，我們有兩個介面，FlyBehavior和QuackBehavior，還有它們對應的類，負責實現具體的行為：

public interface FlyBehavior {
public void fly();
}
public class FlyWithWings implements FlyBehavior{
public void fly{}{
//實現鴨子飛行
}
}
public class FlyNoWay implements FlyBehavior{
public void fly{}{
//什麼也不做，不會飛
}
}
public interface QuackBehavior{
public void quack();
}
public class Quack implements QuackBehavior{
public void quack(){
//實現鴨子呱呱叫
}
}
public class Squeak implements QuackBehavior{
public void quack(){
//實現鴨子吱吱叫
}
}
public class MuteQuack implements QuackBehavior{
public void quack(){
//什麼也不做，不會叫
}
}

實際上這樣的設計，我們已經可以讓飛行和呱呱叫的動作被其他的對象復用，因為這些行為已經與鴨子類無關了。如果我們新增一些行為，也不會影響到既有的行為類，也不會影響有已經使用到飛行行為的鴨子類。
好了，我們設計好鴨子的易於變化的行為部分後，該到了整合鴨子行為的時候了。
這時我們該想到策略模式的另一個原則了：
針對介面編程，而不是針對實現編程。
首先， 在鴨子中加入兩個實例變數，分別為「flyBehavior」與「quackBehavior」，聲明為介面類型（ 而不是具體類實現類型）， 每個變數會利用多態的方式在運行時引用正確的行為類型（ 例如：FlyWithWings 、Squeak...等）。我們也必須將Duck類與其所有子類中的fly()與quack()移除，因為這些行為已經被搬移到FlyBehavior與 Quackehavior類中了，用performFly()和performQuack()取代Duck類中的fly()與quack()。

public abstract class Duck(){
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;
public void swim(){
//會游泳
}
public abstract void display();//各種外觀不一樣，所以為抽象
public void performQuack(){
quackBehavior.quack();
}
public void performFly(){
flyBehavior.fly();
}

}
很容易，是吧？想進行呱呱叫的動作，Duck對象只要叫quackBehavior對象
去呱呱叫就可以了。在這部分的代碼中，我們不在乎QuackBehavior 介面的對象到底是什麼，我們只關心該對象
知道如何進行呱呱叫就夠了。
好吧！ 現在來關心如何設定flyBehavior 與quackBehavior的實例變數。
看看MallardDuck類：
public class MallardDuck extends Duck {
public MallardDuck() {
\\綠頭鴨使用Quack類處理呱呱叫，所以當performQuack() 被調用，就把責任委託給Quack對象進行真正的呱呱叫。
quackBehavior = new Quack();
\\使用FlyWithWings作為其FlyBehavior類型。
flyBehavior = new FlyWithWings();
}
}
所以，綠頭鴨會真的『呱呱叫』，而不是『吱吱叫』，或『叫不出聲』。這是怎麼辦到的？當MallardDuck實例化時，它的構造器會
把繼承來的quackBehavior實例變數初始化成Quack類型的新實例（Quack是QuackBehavior的具體實現類）。同樣的處理方式也可以用在飛行行為上： MallardDuck 的構造器將flyBehavior 實例變數初始化成FlyWithWings 類型的實例（
FlyWithWings是FlyBehavior的具體實現類）。
輸入下面的Duck類（Duck.java） 以及MallardDuck 類MallardDuck.java），並編譯之。
public abstract class Duck {

//為行為介面類型聲明兩個引用變數， 所有鴨子子類（在同一個packge）都繼承它們。
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;
public Duck() {
}
public abstract void display();
public void performFly() {
flyBehavior.fly();//委託給行為類
}
public void performQuack() {
quackBehavior.quack();//委託給行為類
}
public void swim() {
System.out.println("All cksfloat, even decoys!");
}
}

public class MallardDuck extends Duck {
public MallardDuck() {
quackBehavior = newQuack();
flyBehavior = newFlyWithWings();
}
public void display() {
System.out.println("I』m a real Mallard ck");
}
}
輸入FlyBehavior介面（FlyBehavior.java）與兩個行為實現類（FlyWithWings.java與FlyNoWay.java），並編譯之。
public interface FlyBehavior {//所有飛行行為類必須實現的介面
public void fly();
}
public class FlyWithWings implements FlyBehavior {//這是飛行行為的實現， 給「真會」飛的鴨子用 .. .
public void fly() {
System.out.println("I』m flying!!");
}
}
public class FlyNoWay implements FlyBehavior {//這是飛行行為的實現， 給「不會」飛的鴨子用（ 包括橡皮鴨和誘餌鴨）
public void fly() {
System.out.println("I can』t fly");
}
}

輸入QuackBehavior介面（QuackBehavior.java)及其三個實現類（Quack.java、MuteQuack.java、Squeak.java），並編譯之。
public interface QuackBehavior {
public void quack();
}
public class Quack implements QuackBehavior {
public void quack() {
System.out.println(「Quack」);
}
}
public class MuteQuack implements QuackBehavior {
public void quack() {
System.out.println(「<< Silence >>」);
}
}
public class Squeak implements QuackBehavior {
public void quack() {
System.out.println(「Squeak」);
}
}
輸入並編譯測試類（MiniDuckSimulator.java）

public class MiniDuckSimulator {
public static void main(String[] args) {
Duck mallard = new MallardDuck();
mallard.display();
//這會調用MallardDuck繼承來的performQuack() ，進而委託給該對象的QuackBehavior對象處理。（也就是說，調用繼承來的quackBehavior的quack()）
mallard.performQuack();
//至於performFly() ，也是一樣的道理。
mallard.performFly();
}
}
運行結果：
I』m a real Mallard ck
Quack
I』m flying!!

雖然我們把行為設定成具體的類（通過實例化類似Quack 或FlyWithWings的行為類， 並指定到行為引
用變數中），但是還是可以在運行時輕易地改變該行為。
所以，目前的作法還是很有彈性的，只是初始化實例變數的作法不夠彈性罷了。
我們希望一切能有彈性，畢竟，正是因為一開始的設計的鴨子行為沒有彈性，才讓我們走到現在這條路。
我們還想能夠「指定」行為到鴨子的實例， 比方說， 想要產生綠頭鴨實例，並指定特定「類型」的飛行
行為給它。乾脆順便讓鴨子的行為可以動態地改變好了。換句話說，我們應該在鴨子類中包含設定行為的方法。
因為quackBehavior實例變數是一個介面類型，所以我們是能夠在運行時，透過多態動態地指定不同的QuickBehavior實現類給它。
我們在鴨子子類透過設定方法（settermethod）設定鴨子的行為，而不是在鴨子的構造器內實例化。
在Duck類中，加入兩個新方法：從此以後，我們可以「隨時」調用這兩個方法改變鴨子的行為。

public strate class Duck(){
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;
public void setFlyBehavior(FlyBehavior fb) {
flyBehavior = fb;
}
public void setQuackBehavior(QuackBehavior qb) {
quackBehavior = qb;
}

}
好了，讓我們再製造一個新的鴨子類型：模型鴨（ModelDuck.java）
public class ModelDuck extends Duck {
public ModelDuck() {
flyBehavior = new FlyNoWay();//初始狀態，我們的模型鴨是不會飛的。
quackBehavior = new Quack();//初始狀態，我們的模型鴨是可以叫的.
}
public void display() {
System.out.println("I』m a modelck");
}
}
建立一個新的FlyBehavior類型（FlyRocketPowered.java）
public class FlyRocketPowered implements FlyBehavior {
// 我們建立一個利用火箭動力的飛行行為。
public void fly() {
System.out.println("I』m flying with arocket!");
}
}

改變測試類（MiniDuckSimulator.java），加上模型鴨，並使模型鴨具有火箭動力。
public class MiniDuckSimulator {
public static void main(String[] args) {
Duck mallard = new MallardDuck();
mallard.performQuack();
mallard.performFly();
Duck model = new ModelDuck();
//第一次調用performFly() 會被委託給flyBehavior對象（也就是FlyNoWay對象），該對象是在模型鴨構造器中設置的。
model.performFly();
//這會調用繼承來的setter 方法，把火箭動力飛行的行為設定到模型鴨中。哇咧！ 模型鴨突然具有火箭動力飛行能力。
model.setFlyBehavior(new FlyRocketPowered());
//如果成功了， 就意味著模型鴨動態地改變行為。如果把行為的實現綁死在鴨子類中， 可就無法做到這樣。
model.performFly();
}
}
運行一下，看下結果
I』m a real Mallard ck
Quack
I』m flying!!
I』m a model ck
I can』t fly
I』m flying with a rocket!
如同本例一般，當你將兩個類結合起來使用，這就是組合（composition）。這種作法和『繼承』不同的地方在於，
鴨子的行為不是繼承而來，而是和適當的行為對象『組合』而來。
這是一個很重要的技巧。其實是使用了策略模式中的第三個設計原則， 多用組合，少用繼承。
現在來總結一下，鴨子的行為被放在分開的類中，此類專門提供某行為的實現。
這樣，鴨子類就不再需要知道行為的實現細節。
鴨子類不會負責實現Flyable與Quackable介面，反而是由其他類專門實現FlyBehavior與QuackBehavior，
這就稱為「行為」類。由行為類實現行為介面，而不是由Duck類實現行為介面。
這樣的作法迥異於以往，行為不再是由繼承Duck超類的具體實現而來， 或是繼承某個介面並由子類自行實現而來。
(這兩種作法都是依賴於「實現」， 我們被實現綁得死死的， 沒辦法更改行為,除非寫更多代碼)。
在我們的新設計中， 鴨子的子類使用介面（ FlyBehavior與QuackBehavior）所表示的行為，所以實際的實現不會被
綁死在鴨子的子類中。（ 換句話說， 特定的實現代碼位於實現FlyBehavior與QuakcBehavior的特定類中）,這樣我們就獲得了更大的靈活性和可擴展性。

『叄』 為什麼N8的視頻編輯器幻燈片製作只能支持32張照片

因為軟體本身還不完善啊~~

『肆』 笑話徵集

有一天，三個探險家終於尋找到「希望之谷」，傳說中，只要站在山谷邊大
喊心中 想要的東西，然後往山谷中跳下去，就會得到滿坑滿谷所想要的東西。於是他們三個決定試看看。
第一個是個色鬼，因此他大喊「女人！女人！」往下一跳果真有滿坑滿谷的 美女正 等著他.
第二個是個書獃子，喊了「書書書書書！」然後，跳到山谷里也得到滿坑滿
谷的書.
第三個是個優柔寡斷的人，左思右想總是無法決定自己的最愛，過了一個小
時以 後，他終於下定決心，覺得還是鈔票最有用了，於是他走向山谷邊.一不小心踢到一顆 石頭，他罵了一聲「shit！」不料一個重心不穩跌下山谷.

『伍』 創業項目該如何選擇技術

選擇方式：

選擇適合自己的企業類型：
工商企業的類型主要有四大類，即零售業、服務業、製造業和批發業。從事零售業和服務業所需資金較少，容易進入；而從事製造業和批發業則需要大量的資金，但也提供巨大的潛在報酬。
大學生要選擇真正適合自己的企業類型，必須綜合考慮多方面的因素。首先是個性因素，即自己的興趣、愛好等。如果喜歡與人打交道，就可以考慮服務業；如果不喜歡與人打交道，而更喜歡解決工程技術性問題，就應該考慮製造業。其次是技術專長與工作經驗。技術專長是一個人具備的所有專業知識和技能，是重要的創業資本。從事自己最擅長的行業，是創業成功的重要保障。第三是資金需求。企業類型不同，所需投入的資金數量也不同，資金回收的周期也不同。資金需求量最大的是製造業，資金投入大，回收較慢；而資本需求量最小的是服務業。要根據自己的資金情況和創業項目所需資金的數量，權衡選擇適當的投資項目。第四是人脈。如果在所要從事的行業里有自己的親人、朋友或認識的專家，』那麼他們會給你提供很多有價值的信息、建議和幫助，當然也可以提供資金方面的幫助。總之，要根據各類企業的特點和要求，結合自身的創業條件，初步確定要從事的行業。

選擇適合自己的創業領域：
大學生具有一定的專業知識，思維活躍，容易接受新事物，這有利於創業的開展。但是，由於沒有進入社會，大學生在商業意識及管理、營銷等方面的實際經驗比較缺乏，這對創業增加了風險。所以，大學生創業既有優勢，也有局限，在創業方向和創業領域的選擇上應該揚長避短，尋找適合自己發展的道路。
目前，適合大學生創業的領域很多。具體來講，一是高科技領域。大學生可以利用自身的知識及學校資源，進行科技成果的應用開發。二是智力服務。智力是大學生的資本，智力服務創業項目一般成本低、見效快，如咨詢、家教、翻譯、計算機維修維護、設計工作室等。三是信息技術。IT產業一直被譽為創業「金礦」，大學生在計算機使用方面具有優勢，可利用自己的知識技能進行網上創業。四是連鎖加盟。對創業資源十分有限的大學生來說，通過連鎖加盟形式創業，可以快速掌握經營所需要的知識和經驗，從而降低風險，提高創業成功率。五是創意小店。如手工製造、特色專櫃等。這種小店規模不大，經營相對簡單，對社會經驗、管理、營銷、財務要求等也都不高，比較適合初次創業者。六是代理。從代理起家，從銷售入手，相對比較簡單，投入也會小一些，能達到降低創業風險，快速積累第一桶金的目的。從做代理商開始創業，最後做大做強的例子有很多，著名的聯想集團就是這么起家並成長起來的。

發現商機，選擇創業項目
商機即商業機會，也叫市場機會，是指市場中客觀存在的未被滿足的需求。企業存在的價值，就在於滿足市場需求。另外，人們在生活中總是存在這樣那樣的困難和不便，而尋求解決這些問題的方法也往往給創業者帶來創業的契機。所以，需求帶來商機，問題孕育商機。商機是驅使創業者進行創業的直接動因。
發現商機的方法很多，常用的方法是頭腦風暴法和實地考察法。所謂「頭腦風暴法」，就是讓人們圍繞某一問題，打開思路，充分發揮想像力，提出盡可能多的有助於解決該問題的建議和想法。運用頭腦風暴法可以激發每個人的創造力，使每個人從中受到啟發，最終找到合適的創意或解決辦法。所謂「實地考察法」，就是對特定地區進行實地考察，了解人們的需求或生活中存在的問題，從中尋找可以把握的商機。
創業的過程就是尋找和發現、識別有價值的、可以利用的商業機會的過程。一個商業機會是否具有價值，要看它是否能夠真正滿足顧客的需求；判斷商業機會的大小和發展前景，要考慮其能提供可贏利空間的大小及風險如何。另外，創業者在識別商機時，還要考慮該項目是否符合自己的能力水平及各方面條件，與競爭對手相比是否具有競爭優勢等。總之，應綜合考慮各方面因素，要選擇那些既有市場發展前景，又符合創業者自身條件的創業項目

『陸』 fm in game editor 和fmrte的區別

fm in game editor和fmrte都是Football Manager（足球經理）系列游戲的存檔修改器，它們最根本的區別是前者來自官方，需要在steam上花錢單獨購買，而後者則是第三方開發的，屬於免費軟體（接受捐贈）。

fm in game editor作為官方開發的收費軟體，有查看球員和職員數據，和添加球員的功能，但它的使用不是實時的，修改以後要重新開始游戲才能產生效果，而且使用它修改過的存檔將無法獲得游戲成就。它的優點在於存檔能夠保證絕對安全，缺點則是限制太多，功能太少。

『柒』 c#多態的運行機理

描述一下C++的，應該差不多

1、編譯器發現一個類中有虛函數，編譯器會立即為此類生成虛擬函數表 vtable（後面有對vtable的分析）。虛擬函數表的各表項為指向對應虛擬函數的指針。

2、編譯器在此類中隱含插入一個指針vptr（對vc編譯器來說，它插在類的第一個位置上）。

有一個辦法可以讓你感知這個隱含指針的存在，雖然你不能在類中直接看到它，但你可以比較一下含有虛擬函數時的類的尺寸和沒有虛擬函數時的類的尺寸，你能夠發現，這個指針確實存在。

class cnovirtualfun
{
private:
long lmember;
public:
long getmembervalue（);
} class chavevirtualfun
{
private:
long lmember;
public:
virtual long getmembervalue（);
}

cnovirtualfun obj;
sizeof(obj) -> == 4;
chavevirtualfun obj;
sizeof(obj) -> == 8;

3、在調用此類的構造函數時，在類的構造函數中，編譯器會隱含執行vptr與vtable的關聯代碼，將vptr指向對應的vtable。這就將類與此類的vtable聯系了起來。

4、在調用類的構造函數時，指向基礎類的指針此時已經變成指向具體的類的this指針，這樣依靠此this指針即可得到正確的vtable，從而實現了多態性。在此時才能真正與函數體進行連接，這就是動態聯編。

『捌』 小鴨子的生活2的編輯器里為什麼我的鴨子走的很慢

咕~~(╯﹏╰)b

『玖』 類型系統的類型檢查

類型檢查所進行的檢驗處理以及實行類型的約束，可發生在編譯時期（靜態檢查）或運行時期（動態檢查）。靜態類型檢查是在編譯器所進行語義分析中進行的。如果一個語言強制實行類型規則（即通常只允許以不丟失信息為前提的自動類型轉換）就稱此處理為強類型，反之稱為弱類型。 如果一個編程語言的類型檢查，可在不測試運行時期表達式的等價性的情況下進行，該語言即為靜態類型的。一個靜態類型的編程語言，是在運行時期和編譯時期之間的處理階段下重視這些區別的。如果程序的獨立模塊，可進行各自的類型檢查(獨立編譯)，而無須所有會在運行時出現的模塊的那些信息，該語言即具有一個編譯時期階段。如果一個編程語言支持運行時期（動態）調度已標記的數據，該語言即為動態類型的。如果一個編程語言破壞了階段的區別，因而類型檢查需要測試運行時期的表達式的等價性，該語言即為依存類型的。
在動態類型中，經常在運行時期進行類型標記的檢查，因為變數所約束的值，可經由運行路徑獲得不同的標記。在靜態類型編程語言中，類型標記使用辨識聯合類型表示。
動態類型經常出現於腳本語言和RAD語言中。動態類型在解譯語言中極為普遍，編譯語言則偏好無須運行時期標記的靜態類型。對於類型和隱式類型語言較完整的列表參見類型和隱式類型語言。
術語推斷類型（鴨子類型，ck typing）指的是動態類型在語言中的應用方式，它會「推斷」一個數值的類型。
某些靜態語言有一個「後門」，在這些編程語言中，能夠編寫一些不被靜態類型所檢查的代碼。例如，Java 和 C-風格的語言有「轉型」可用。在靜態類型的編程語言中，不必然意味著缺乏動態類型機制。例如 Java 使用靜態類型，但某些運算需要支持運行時期的類型測試，這就是動態類型的一種形式。更多靜態和動態類型的討論，請參閱編程語言。 對靜態類型和動態類型兩者之間的權衡也是必要的。
靜態類型在編譯時期時，就能可靠地發現類型錯誤。因此通常能增進最終程序的可靠性。然而，有多少的類型錯誤發生，以及有多少比例的錯誤能被靜態類型所捕捉，仍有爭論。靜態類型的擁護者認為，當程序通過類型檢查時，它才有更高的可靠性。雖然動態類型的擁護者指出，實際流通的軟體證明，兩者在可靠性上並沒有多大差別。可以認為靜態類型的價值，在於增進類型系統的強化。強類型語言（如 ML 和 Haskell）的擁護者提出，幾乎所有的臭蟲都可以看作是類型錯誤，如果編寫者以足夠恰當的方式，或者由編譯器推斷來聲明一個類型。
靜態類型通常可以編譯出速度較快的代碼。當編譯器清楚知道所要使用的數據類型，就可以產生優化過後的機器碼。更進一步，靜態類型語言中的編譯器，可以更輕易地發現較佳捷徑。某些動態語言（如 Common Lisp）允許任意類型的聲明，以便於優化。以上理由使靜態類型更為普及。參閱優化。
相較之下，動態類型允許編譯器和解譯器更快速的運作。因為源代碼在動態類型語言中，變更為減少進行檢查，並減少解析代碼。這也可減少編輯－編譯－測試－除錯的周期。
靜態類型語言缺少類型推斷（如 Java），而需要編寫者聲明所要使用的方法或函數的類型。編譯器將不允許編寫者忽略，這可為程序起附加性說明文件的作用。但靜態類型語言也可以無須類型聲明，所以與其說是靜態類型的代價，倒不如說是類型聲明的報酬。
靜態類型允許構造函數庫，它們的用戶不太可能意外的誤用。這可作為傳達庫開發者意圖的額外機制。
動態類型允許建構一些靜態類型系統所做不出來的東西。例如，eval 函數，它使得運行任意數據作為代碼成為可能（不過其代碼的類型仍是靜態的）。此外，動態類型容納過渡代碼和原型設計，如允許使用字元串代替數據結構。靜態類型語言最近的增強（如 Haskell 一般化代數數據類型）允許 eval 函數以類型安全的方式撰寫。
動態類型使元程序設計更為強大，且更易於使用。例如 C++ 模板的寫法，比起等價的 Ruby 或 Python 寫法要來的麻煩。更高度的運行時期構成物，如元類型(metaclass)和內觀(Introspection)，對靜態類型語言而言通常更為困難。