Every PHP programmer is familiar wi

Every PHP programmer is familiar with day-to-day tasks that can be tricky or cumbersome. The code above is a great example of a common mistake where a method could unexpectedly be called on a null object, causing an error that wouldn't be caught until runtime. Another example is a complex API, where developers may have a solid understanding of its semantics but still spend time looking up mundane method names in documentation.

At Facebook scale — with thousands of engineers shipping new code twice a day — slowdowns like these are even more problematic. Before Hack, we had a simple language with a quick feedback loop — but how could we mitigate the sorts of problems described above? Could early error detection coexist with rapid iteration, all while preserving our investment in PHP? Could improved code analysis and introspection help make developers more productive with tools like auto-complete?

Traditionally, dynamically typed languages allow for rapid development but sacrifice the ability to catch errors early and introspect code quickly, particularly on larger codebases. Conversely, statically typed languages provide more of a safety net, but often at the cost of quick iteration. We believed there had to be a sweet spot.

Thus, Hack was born. We believe that it offers the best of both dynamically typed and statically typed languages, and that it will be valuable to projects of all sizes.

The Hack language
Hack has deep roots in PHP. In fact, most PHP files are already valid Hack files. We made a conscious choice not to support a handful of deprecated functions and features that were incompatible with static typing (e.g. “variable variables” and the extract() function). We have also added many new features that we believe will help make developers more productive.

Our principal addition is static typing. We have developed a system to annotate function signatures and class members with type information; our type checking algorithm (the “type checker”) infers the rest. Type checking is incremental, such that even within a single file some code can be converted to Hack while the rest remains dynamically typed. Technically speaking, Hack is a “gradually typed*”* language: dynamically typed code interoperates seamlessly with statically typed code.

Within Hack's type system, we have introduced several features such as generics, nullable types, type aliasing, and constraints on type parameters. These new language features are unobtrusive, so the code you write with Hack will still look and feel like the dynamic language to which PHP programmers are accustomed.

However, Hack adds additional features beyond static type checking, including Collections, lambda expressions, and run-time enforcement of return types and parameter types.

Collections provide a clean, type-safe alternative to PHP arrays. We designed them specifically to work well with static typing and generics. The Collections API offers many classic higher-order functions such as map() and filter() to facilitate functional programming styles.

Lambda expressions give a concise syntax for creating closures. While PHP has closures, it requires the programmer to explicitly name the variables they need to use from enclosing scopes. With Hack's lambda expressions, we automatically infer these uses, saving you needless work. Lambda expressions make it more convenient to take full advantage of the Collections API.

Run-time enforcement of return types and parameter types (including scalar types like int and string) provides safety beyond what can be checked statically while type annotations are being gradually added to a codebase. Run-time enforcement helps programmers detect and diagnose certain kinds of problems more easily, and it helps HHVM's JIT produce more efficient code by making it safe to trust type annotations for optimization purposes.

Instantaneous type checking
During development, a PHP programmer typically goes back and forth rapidly between the source code and the browser. Engineers can iterate as quickly as they need, testing and tuning an experience until it's perfect.

Traditionally, a type checker would disrupt this feedback loop as it takes time to analyze the source code. We didn't want to slow the PHP workflow, so we came up with a new approach to reconcile instantaneous feedback with type safety.

Our solution was to architect the type checker as a local server that watches the filesystem. The server keeps all information about the source code in memory and automatically updates itself when a file changes on disk. This approach has paid off: the type checker typically runs in less than 200 milliseconds and rarely takes more than a second, making it easy to integrate into the development workflow without introducing a noticeable delay.

Code migration
Hack's type safety and refactoring benefits grow the more it is used within a codebase. Understanding that it would be difficult for some code to be completely transitioned to Hack right away, it was important to us that Hack be developed such that it can coexist directly with other PHP files as it is being introduced incrementally.

The rest of the conversion process, such as adding type annotations and using new language features, can be done as appropriate for the codebase. For example, a type annotation can be added for one function but left off another function, even in the same file. If a function parameter or class member does not have an explicit type annotation, the type checker considers its type to be dynamic, and it does not check the type of that value.

Within Facebook, we found that our engineers appreciated Hack enough that they started converting the majority of their own code voluntarily. With millions of lines of code in our tree, we also wanted some form of automation, so we built and use a number of code modification tools to assist the process (which we are releasing as part of Hack).

Don't worry, your PHP is safe!
HHVM is still a PHP runtime, and we intend to keep it that way. In fact, we are working hard to reach parity with PHP-5. One of HHVM's top priorities is to run unmodified PHP-5 source code, both for the community and because we rely on third-party PHP libraries internally.

HHVM is now a runtime that supports *both* PHP and Hack, so you can start to take advantage of Hack's new features incrementally.

Have fun with Hack!
We are delighted to open-source both Hack and the tools you can use to automatically convert your codebase. This is just the first step, and we are dedicated to continuing to evolve this software to make development even easier for both our own engineers and the broader community. Hack's value is *not* limited to big projects: with type information, good error messages, and fast feedback, small codebases can reap the benefits of Hack as well.

Next month, we will also introduce the language at the Hack Developer Day on the Facebook campus in Menlo Park, and we hope to see you there in person or online.

We would love to have your feedback on our work so far, and welcome you all to participate in the HHVM and Hack community.

Acknowledgements
There are many people who have contributed to the development of Hack.

The core Hack team consists of Julien Verlaguet, Joel Beales, Eugene Letuchy, Gabriel Levi, Joel Marcey, Erik Meijer, Alok Menghrajani, Bryan O'Sullivan, Drew Paroski, James Pearce, Joel Pobar, and Joshua Van Dyke Watzman.

A special thanks goes to our early community adopters for providing valuable feedback to make the language better: James Miller, Simon Welsh, Nils Adermann, Fabien Potencier, and Alexander Mols.

Hack is written primarily in OCaml. We would like to thank the Gallium team (INRIA) for the development of the OCaml language, and the Ocsigen team (CNRS - University of Paris Diderot - INRIA) for the development of the js_of_ocaml part of Ocsigen.

And, of course, thank you to everyone else who has helped make Hack the language it is today. The list is too exhaustive for a blog post, but you know who you are.

ผลลัพธ์ (ไทย) 1:

โปรแกรมเมอร์ PHP ทุกจะคุ้นเคยกับงานประจำวันที่ยุ่งยาก หรือยุ่งยาก รหัสข้างต้นเป็นตัวอย่างที่ดีของความผิดพลาดทั่วไปที่วิธีอาจโดยไม่คาดคิดถูกเรียกบนวัตถุ null ก่อให้เกิดข้อผิดพลาดที่จะไม่ติดจนกระทั่งขณะทำงาน อีกตัวอย่างหนึ่งคือ API ซับซ้อน ที่นักพัฒนาอาจมีความเข้าใจความหมายของความแข็ง แต่ยังคง ใช้เวลาหาวิธีโลกีย์ชื่อในเอกสารในมาตราส่วน Facebook — พันวิศวกรจัดส่งรหัสใหม่สองวัน — เทร์เช่นนี้จะยิ่งมีปัญหา ก่อนสับ เรามีภาษาที่เรียบง่ายกับวนผลตอบสนองอย่างรวดเร็ว — แต่วิธีได้เราลดประเภทของปัญหาที่อธิบายไว้ข้างต้นหรือไม่ ตรวจหาข้อผิดพลาดสามารถอยู่ร่วมกับการเกิดซ้ำอย่างรวดเร็ว ทั้งหมดในขณะที่การรักษาของเราลงทุนใน PHP สามารถปรับปรุงรหัสการวิเคราะห์และการทบทวนช่วยให้นักพัฒนามีประสิทธิภาพมากขึ้น ด้วยเครื่องมือต้องทำให้สมบูรณ์อัตโนมัติประเพณี ภาษาพิมพ์แบบไดนามิกช่วยให้การพัฒนาอย่างรวดเร็ว แต่เสียสละสามารถจับข้อผิดพลาดก่อน และ introspect รหัสอย่างรวดเร็ว โดยเฉพาะอย่างยิ่งบนใหญ่ codebases ในทางกลับกัน ฟิกแบบคงพิมพ์ภาษาให้เพิ่มเติม ของสุทธิความปลอดภัย แต่มักจะ ค่าการเกิดซ้ำอย่างรวดเร็ว เราเชื่อว่า ต้องมีจุดแห่งความหวานดังนั้น สับเกิด เราเชื่อว่า มันมีส่วนของภาษาไดนามิกตัวพิมพ์ และตัวพิมพ์ฟิกแบบคง และว่า มันจะเป็นประโยชน์กับโครงการทุกขนาดภาษาสับสับได้ฝังรากลึกใน PHP ในความเป็นจริง แฟ้ม PHP ส่วนใหญ่อยู่แล้วถูกสับแฟ้ม เราได้เลือกสติไม่ให้สนับสนุนหยิบไม่สนับสนุนให้ใช้ฟังก์ชันและคุณลักษณะที่เข้ากันกับแบบพิมพ์ (เช่น "ตัวแปรตัวแปร" และ extract() ฟังก์ชัน) นอกจากนี้เรายังได้เพิ่มคุณลักษณะใหม่ ๆ ทั้งหลายที่เราเชื่อว่าจะช่วยให้นักพัฒนาที่มีประสิทธิผลมากขึ้นนอกจากนี้หลักของเราจะคงพิมพ์ เราได้พัฒนาระบบเพื่ออธิบายประกอบฟังก์ชันลายเซ็นและสมาชิกคลาสชนิดข้อมูล ชนิดของการตรวจสอบอัลกอริทึม (ตัว "ชนิดตรวจสอบ") infers ส่วนเหลือ ตรวจสอบชนิดจะเพิ่มขึ้น เช่นว่าแม้ภายในแฟ้มเดียวกัน รหัสบางอย่างสามารถแปลงสับในขณะส่วนเหลือยังคงพิมพ์แบบไดนามิก เทคนิคพูด สับเป็นการ "ค่อย ๆ พิมพ์ * " * ภาษา: รหัสพิมพ์แบบไดนามิก interoperates มีฟิกแบบคงพิมพ์รหัสอย่างราบรื่นภายในระบบของสับชนิด เรามีแนะนำคุณลักษณะหลายประการเช่นข้อมูลทั่วไป ประเภท null ได้ ชนิดของนามแฝง และข้อจำกัดของพารามิเตอร์ชนิด คุณลักษณะเหล่านี้ภาษาใหม่มีแต่ั ดังนั้นรหัสที่คุณเขียน ด้วยสับจะยังคงรูปลักษณ์เช่นภาษาไดนามิกกับ PHP ที่โปรแกรมเมอร์จะคุ้นเคยอย่างไรก็ตาม สับเพิ่มคุณสมบัติเพิ่มเติมนอกเหนือจากการตรวจสอบชนิดถาวร ชุด นิพจน์แลมบ์ดา และบังคับคืนชนิดและชนิดของพารามิเตอร์ขณะใช้งานคอลเลกชันให้เป็นทางเลือกที่สะอาด ปลอดภัยชนิดการอาร์เรย์ของ PHP เราออกแบบให้โดยเฉพาะเหมาะกับการพิมพ์แบบคงและข้อมูลทั่วไป API ชุดมีฟังก์ชันขั้นสูงคลาสสิกมากเช่น map() และ filter() เพื่อให้ง่ายต่อการเขียนโปรแกรมแบบทำงานแลมบ์ดานิพจน์ให้ไวยากรณ์กระชับสร้างปิด ขณะที่ PHP มีปิด ต้องโปรแกรมเมอร์ชื่อตัวแปรที่จำเป็นต้องใช้จากล้อมขอบเขตอย่างชัดเจน ด้วยนิพจน์ของสับแลมบ์ดา เราโดยอัตโนมัติรู้เหล่านี้ใช้ บันทึกงานรวดเร็ว แลมบ์ดานิพจน์ให้สะดวกกว่าการใช้ประโยชน์จาก API ชุดเต็มบังคับใช้รันไทม์ของชนิดการส่งคืนสินค้าและพารามิเตอร์ชนิด (รวมทั้งชนิดสเกลาเช่น int และสายอักขระ) ให้ความปลอดภัยนอกเหนือจากที่ได้รับการตรวจฟิกแบบคงในขณะที่คำอธิบายของชนิดจะค่อย ๆ เพิ่มการ codebase ขณะใช้งานบังคับช่วยโปรแกรมเมอร์ตรวจสอบ และวินิจฉัยบางชนิดของปัญหาได้ง่ายขึ้น และช่วยให้จิตของ HHVM ผลิตรหัสที่มีประสิทธิภาพมากขึ้น โดยการทำให้ปลอดภัยเชื่อถือคำอธิบายชนิดเพื่อเพิ่มประสิทธิภาพชนิดกำลังตรวจสอบในระหว่างการพัฒนา โปรแกรมเมอร์ PHP ทั่วไปและกลับอย่างรวดเร็วระหว่างรหัสแหล่งที่มาและเบราว์เซอร์ วิศวกรสามารถทำซ้ำได้เร็วอย่างที่พวกเขาต้องการ การทดสอบ และปรับแต่งประสบการณ์จนกว่าจะสมบูรณ์ประเพณี การตรวจสอบชนิดจะรบกวนวนผลป้อนกลับนี้เป็นใช้เวลาในการวิเคราะห์รหัสแหล่งที่มา เราไม่ได้ต้องการช้าลำดับ PHP ดังนั้นเรามากับวิธีการกระทบยอดผลป้อนกลับที่กำลัง มีความปลอดภัยใหม่โซลูชันของเราให้ สถาปนิกตรวจสอบชนิดเป็นเซิร์ฟเวอร์เฉพาะที่นาฬิการะบบแฟ้มได้ เซิร์ฟเวอร์เก็บข้อมูลทั้งหมดเกี่ยวกับรหัสแหล่งที่มาในหน่วยความจำ และปรับปรุงตัวเองเมื่อการเปลี่ยนแปลงแฟ้มบนดิสก์โดยอัตโนมัติ วิธีการนี้ได้จ่ายเงินออก: ตัวตรวจสอบชนิดโดยทั่วไปทำงานในหน่วยมิลลิวินาทีน้อยกว่า 200 และใช้เวลากว่าสอง ทำให้ง่ายที่จะรวมไว้ในลำดับการพัฒนา โดยการแนะนำความล่าช้าไม่ค่อยย้ายรหัสสับของความปลอดภัยและการ refactoring ประโยชน์เติบโตมากขึ้นจะใช้ในการ codebase เข้าใจว่า มันจะยากสำหรับบางรหัสจะถูกทั้งหมด transitioned ไปสับทันที มันเป็นสิ่งสำคัญสำหรับเราที่สับได้รับการพัฒนาเช่นที่มันสามารถอยู่ร่วมกับไฟล์ PHP อื่น ๆ เท่านั้นเป็นการประมวลแบบเพิ่มหน่วยกระบวนการของการแปลง เช่นการเพิ่มชนิด คำอธิบายและการใช้คุณลักษณะใหม่ของภาษา สามารถทำได้ตามความเหมาะสมสำหรับการ codebase ตัวอย่าง อธิบายชนิดสามารถถูกเพิ่มสำหรับฟังก์ชันหนึ่ง ได้ออกฟังก์ชันอื่น แม้แต่ในไฟล์เดียวกัน ถ้าฟังก์ชันพารามิเตอร์หรือคลาสสมาชิกไม่มีการอธิบายชัดเจนชนิด ชนิดเป็นแบบไดนามิกพิจารณาตรวจสอบชนิด และตรวจสอบชนิดของค่าที่ภายใน Facebook เราพบว่า วิศวกรนิยมสับพอที่พวกเขาเริ่มต้นการแปลงส่วนใหญ่รหัสของตนเองด้วยความสมัครใจ มีล้านบรรทัดของรหัสในแผนภูมิของเรา เรายังต้องการบางรูปแบบอัตโนมัติ ดังนั้นเราสร้างขึ้น และใช้หมายเลขของรหัสการแก้ไขเครื่องมือเพื่อช่วยกระบวนการ (ซึ่งเราจะปล่อยเป็นส่วนหนึ่งของสับ)ไม่ต้องกังวล PHP ของคุณจะปลอดภัยHHVM จะยังคงรันไทม์ของ PHP และเราตั้งใจจะให้มันดัง ในความเป็นจริง เรากำลังทำงานหนักถึงพาริตี้กับ PHP 5 ระดับความสำคัญสูงสุดของ HHVM คือการวิ่ง unmodified PHP 5 รหัสแหล่งที่มา ทั้งในชุมชนและเนื่อง จากเราใช้ไลบรารีของ PHP อื่น ๆ ภายในHHVM คือตอนนี้ รันไทม์ที่สนับสนุน * ทั้ง * PHP และสับ เพื่อให้คุณสามารถเริ่มต้นการใช้ประโยชน์จากคุณลักษณะใหม่ของสับแบบเพิ่มหน่วยสนุกกับสับเรายินดีที่จะเปิดแหล่งสับและเครื่องมือที่คุณสามารถใช้เพื่อแปลง codebase ของคุณโดยอัตโนมัติ นี้เป็นเพียงก้าวแรก และเราได้อุทิศตนเพื่อดำเนินการต่อการพัฒนาซอฟต์แวร์นี้จะทำให้พัฒนาได้ง่ายขึ้นสำหรับวิศวกรของเราเองและชุมชนกว้างขึ้น ค่าของสับ * ไม่ * จำกัดโครงการขนาดใหญ่: ชนิดข้อมูล ข้อดี และความคิดเห็นอย่างรวดเร็ว เล็ก codebases สามารถเก็บเกี่ยวประโยชน์ของสับด้วยเดือนถัดไป เราจะแนะนำภาษาวันพัฒนาเครื่องในมหาวิทยาลัย Facebook ในเมนโลพาร์ก และเราหวังที่จะเห็นคุณมี หรือออนไลน์อยากได้คำติชมของคุณในการทำงานของเราเพื่อให้ห่างไกล และยินดีต้อนรับคุณทั้งหมดมีส่วนร่วมในชุมชน HHVM และสับถาม-ตอบมีคนจำนวนมากที่มีส่วนในการพัฒนาของสับทีมสับหลักประกอบด้วย Julien Verlaguet, Joel Beales, Eugene Letuchy, Gabriel Levi, Joel Marcey, Erik Meijer, Menghrajani ถึง โร งง Bryan, Drew Paroski, James Pearce, Joel Pobar และโยชูวา Van Dyke Watzmanขอบคุณเป็นพิเศษไปยังผู้รับบุตรบุญธรรมของเราชุมชนต้นการป้อนกลับเพื่อให้ภาษาดีมีคุณค่า: James มิลเลอร์ ชาว เวลส์ Simon, Nils Adermann, Fabien Potencier และอเล็กซานเดอร์ Molsสับเขียนหลักใน OCaml เราอยากจะขอบคุณทีมงานแกลเลียม (INRIA) สำหรับการพัฒนาภาษา OCaml และทีมงาน Ocsigen (CNRS -มหาวิทยาลัยปารีส Diderot - INRIA) สำหรับการพัฒนาของภาค js_of_ocaml Ocsigenและ แน่นอน ขอบคุณทุกคนที่มีส่วนช่วยให้สับภาษาวันนี้ รายการไม่ครบถ้วนสมบูรณ์เกินไปสำหรับการโพสต์บล็อก แต่คุณรู้ว่าคุณเป็นใคร

ผลลัพธ์ (ไทย) 2:

ทุกโปรแกรมเมอร์ PHP เป็นที่คุ้นเคยกับงานแบบวันต่อวันนั้นอาจเป็นเรื่องยุ่งยากหรือยุ่งยาก รหัสข้างต้นเป็นตัวอย่างที่ดีของความผิดพลาดทั่วไปที่วิธีการอาจจะเรียกว่าไม่คาดคิดบนวัตถุ null ก่อให้เกิดข้อผิดพลาดที่จะไม่ถูกจับจนรันไทม์ อีกตัวอย่างหนึ่งคือ API ที่ซับซ้อนที่นักพัฒนาอาจจะมีความเข้าใจที่มั่นคงของความหมายของมัน แต่ยังคงใช้เวลามองขึ้นชื่อวิธีโลกีย์ในเอกสาร. ที่ระดับ Facebook - มีหลายพันวิศวกรจัดส่งรหัสใหม่วันละสองครั้ง - ชะลอตัวเช่นนี้มากยิ่งขึ้น เป็นปัญหา ก่อนที่จะสับเรามีภาษาที่เรียบง่ายด้วยห่วงความคิดเห็นที่รวดเร็ว - แต่วิธีการที่เราสามารถลดประเภทของปัญหาที่อธิบายไว้ข้างต้น? การตรวจสอบข้อผิดพลาดในช่วงต้นอาจจะอยู่ร่วมกันกับการทำซ้ำอย่างรวดเร็วทั้งหมดในขณะที่การรักษาการลงทุนของเราใน PHP? การวิเคราะห์รหัสที่ดีขึ้นและความช่วยเหลือวิปัสสนาจะทำให้นักพัฒนามีประสิทธิผลมากขึ้นด้วยเครื่องมือเช่นอัตโนมัติสมบูรณ์? ตามเนื้อผ้าภาษาพิมพ์แบบไดนามิกอนุญาตให้มีการพัฒนาอย่างรวดเร็ว แต่เสียสละความสามารถในการจับข้อผิดพลาดในช่วงต้นและใคร่ครวญรหัสได้อย่างรวดเร็วโดยเฉพาะอย่างยิ่งใน codebases ขนาดใหญ่ ตรงกันข้ามภาษาพิมพ์แบบคงที่ให้มากขึ้นของความปลอดภัยสุทธิ แต่บ่อยครั้งที่ค่าใช้จ่ายของการทำซ้ำอย่างรวดเร็ว เราเชื่อว่าจะต้องมีจุดหวาน. ดังนั้นสับเกิด เราเชื่อว่าจะนำเสนอสิ่งที่ดีที่สุดของทั้งสองภาษาพิมพ์แบบไดนามิกและการพิมพ์แบบคงที่และมันจะมีคุณค่าให้กับโครงการทุกขนาด. ภาษาสับสับได้หยั่งรากลึกใน PHP ในความเป็นจริงมากที่สุดไฟล์ PHP ไฟล์ที่มีอยู่แล้วสับที่ถูกต้อง เราทำทางเลือกที่ไม่ได้ใส่ใจที่จะสนับสนุนกำมือของฟังก์ชั่นเลิกและคุณสมบัติที่เข้ากันไม่ได้กับการพิมพ์แบบคงที่ (เช่น "ตัวแปรตัวแปร" และสารสกัดจากฟังก์ชัน ()) เรายังได้เพิ่มคุณสมบัติใหม่ ๆ ที่เราเชื่อว่าจะช่วยให้นักพัฒนาที่มีประสิทธิผลมากขึ้น. นอกจากนี้หลักของเราคือการพิมพ์แบบคงที่ เราได้พัฒนาระบบที่จะอธิบายการทำงานและลายเซ็นสมาชิกระดับมีข้อมูลประเภท; ขั้นตอนวิธีการตรวจสอบชนิดของเรา ("ตรวจสอบการพิมพ์") อ้างถึงส่วนที่เหลือ การตรวจสอบชนิดเป็นที่เพิ่มขึ้นดังกล่าวว่าแม้จะอยู่ในไฟล์เดียวรหัสบางอย่างที่สามารถแปลงเป็นสับในขณะที่ส่วนที่เหลือยังคงพิมพ์แบบไดนามิก เทคนิคการพูดสับเป็น "พิมพ์ค่อยๆ *" ภาษา *: รหัสพิมพ์แบบไดนามิก interoperates ต่อเนื่องกับรหัสพิมพ์แบบคงที่. ภายในระบบการพิมพ์สับของเราได้แนะนำคุณสมบัติหลายอย่างเช่นยาประเภท nullable, aliasing ชนิดและข้อ จำกัด ในพารามิเตอร์ประเภท คุณสมบัติเหล่านี้ภาษาใหม่ที่สร้างความรำคาญดังนั้นรหัสที่คุณเขียนด้วยสับจะยังคงมองและความรู้สึกเช่นเดียวกับภาษาแบบไดนามิกที่เขียนโปรแกรม PHP จะคุ้นเคย. แต่สับเพิ่มคุณสมบัติเพิ่มเติมนอกเหนือจากการตรวจสอบชนิดคงที่รวมทั้งคอลเลกชัน, การแสดงออกแลมบ์ดาและ Run- การบังคับใช้ช่วงเวลาของการกลับมาชนิดและประเภทพารามิเตอร์. คอลเลกชันให้สะอาดทางเลือกชนิดที่ปลอดภัยที่จะ PHP อาร์เรย์ เราได้รับการออกแบบมาโดยเฉพาะเพื่อให้พวกเขาทำงานได้ดีกับการพิมพ์แบบคงที่และทั่วไป คอลเลกชัน API มีหลายคลาสสิกฟังก์ชั่นขั้นสูงเช่นแผนที่ () และตัวกรอง () เพื่ออำนวยความสะดวกรูปแบบโปรแกรมการทำงาน. แลมบ์ดาสำนวนให้รัดกุมไวยากรณ์สำหรับการสร้างการปิด ในขณะที่ PHP มีการปิดก็ต้องเขียนโปรแกรมที่จะตั้งชื่ออย่างชัดเจนตัวแปรที่พวกเขาต้องการที่จะใช้จากขอบเขตการปิดล้อม ด้วยการสับของการแสดงออกแลมบ์ดาเราจะสรุปการใช้งานเหล่านี้ช่วยประหยัดการทำงานไม่มีความจำเป็น การแสดงออกแลมบ์ดาทำให้มันสะดวกกว่าที่จะใช้ประโยชน์จากคอลเลกชัน API. บังคับใช้ในขณะทำงานประเภทผลตอบแทนและชนิดพารามิเตอร์ (รวมถึงประเภทเกลาเช่น int และสตริง) ให้ความปลอดภัยเกินกว่าสิ่งที่สามารถตรวจสอบได้แบบคงที่ในขณะที่คำอธิบายประกอบชนิดมีการเพิ่มค่อยๆ codebase การบังคับใช้เวลาทำงานจะช่วยให้การเขียนโปรแกรมการตรวจสอบและวินิจฉัยบางชนิดของปัญหาได้ง่ายขึ้นและมันจะช่วยให้ JIT HHVM ของผลิตรหัสที่มีประสิทธิภาพมากขึ้นโดยการทำให้มันปลอดภัยที่จะไว้วางใจคำอธิบายประกอบชนิดเพื่อวัตถุประสงค์ในการเพิ่มประสิทธิภาพ. การตรวจสอบชนิดทันทีในระหว่างการพัฒนาโปรแกรม PHP มักจะกลับไปและ ออกมาอย่างรวดเร็วระหว่างซอร์สโค้ดและเบราว์เซอร์ วิศวกรสามารถย้ำเป็นอย่างที่พวกเขาต้องการการทดสอบและการปรับแต่งประสบการณ์จนกว่าจะสมบูรณ์แบบ. ตามเนื้อผ้าตรวจสอบชนิดจะทำลายห่วงความคิดเห็นนี้มันต้องใช้เวลาในการวิเคราะห์รหัสที่มา เราไม่ได้ต้องการที่จะชะลอตัวเวิร์กโฟลว์ PHP, เพื่อให้เราขึ้นมาด้วยวิธีการใหม่ที่จะเจรจาต่อรองข้อเสนอแนะทันทีที่มีความปลอดภัยประเภท. วิธีการแก้ปัญหาของเราคือการตรวจสอบสถาปนิกประเภทเป็นเซิร์ฟเวอร์ในท้องถิ่นที่นาฬิการะบบแฟ้ม เซิร์ฟเวอร์เก็บข้อมูลทั้งหมดที่เกี่ยวกับแหล่งที่มาของรหัสในหน่วยความจำและจะปรับปรุงตัวเองเมื่อมีการเปลี่ยนแปลงไฟล์บนดิสก์ วิธีการนี้ได้จ่ายเงินออก:. ตรวจสอบชนิดมักจะทำงานในเวลาน้อยกว่า 200 มิลลิวินาทีและไม่ค่อยใช้เวลากว่าสองทำให้มันง่ายที่จะรวมเข้ากับเวิร์กโฟลว์การพัฒนาโดยไม่ต้องแนะนำล่าช้ารหัสการโยกย้ายความปลอดภัยชนิดสับและผลประโยชน์ refactoring เติบโตมากขึ้น มันถูกใช้ภายใน codebase การทำความเข้าใจว่ามันจะเป็นเรื่องยากสำหรับรหัสบางอย่างที่จะได้รับการเปลี่ยนอย่างสมบูรณ์การสับทันทีมันเป็นสิ่งสำคัญสำหรับเราที่สับได้รับการพัฒนาดังกล่าวว่าสามารถอยู่ร่วมกันได้โดยตรงกับไฟล์ PHP อื่น ๆ ในขณะที่มันจะถูกนำขึ้นเรื่อย ๆ . ส่วนที่เหลือของขั้นตอนการแปลง เช่นการเพิ่มคำอธิบายประกอบชนิดและใช้คุณลักษณะภาษาใหม่สามารถทำได้ตามความเหมาะสมสำหรับ codebase ยกตัวอย่างเช่นคำอธิบายประกอบชนิดสามารถเพิ่มฟังก์ชั่นสำหรับหนึ่ง แต่ซ้ายปิดฟังก์ชั่นอื่นแม้จะอยู่ในไฟล์เดียวกัน ถ้าพารามิเตอร์ฟังก์ชั่นหรือสมาชิกในระดับไม่ได้มีคำอธิบายประกอบอย่างชัดเจนประเภท, ตรวจสอบการพิจารณาประเภทประเภทที่จะเป็นแบบไดนามิกและมันก็ไม่ได้ตรวจสอบชนิดของค่าที่. ภายใน Facebook, เราพบว่าวิศวกรของเราชื่นชมสับพอที่จะทำให้พวกเขาเริ่มต้น ส่วนใหญ่ของการแปลงรหัสของตัวเองโดยสมัครใจ มีนับล้านของบรรทัดของรหัสในต้นไม้ของเราเรายังต้องการรูปแบบของระบบอัตโนมัติบางอย่างเพื่อให้เราสร้างและใช้จำนวนของเครื่องมือการปรับเปลี่ยนรหัสเพื่อช่วยให้กระบวนการ (ซึ่งเราจะปล่อยเป็นส่วนหนึ่งของสับ). ไม่ต้องกังวลของคุณ PHP เป็นปลอดภัย! HHVM ยังคงเป็นรันไทม์ PHP, และเราตั้งใจที่จะให้มันเป็นอย่างนั้น ในความเป็นจริงที่เรากำลังทำงานอย่างหนักที่จะไปถึงความเท่าเทียมกันกับ PHP-5 หนึ่งในความสำคัญด้านบน HHVM คือการใช้ PHP-5 รหัสที่มาแปรทั้งชุมชนและเพราะเราพึ่งพาห้องสมุด PHP บุคคลที่สามภายใน. HHVM อยู่ในขณะนี้รันไทม์ที่สนับสนุน * ทั้ง * PHP และสับเพื่อให้คุณสามารถเริ่มต้นที่จะ ใช้ประโยชน์จากการสับของคุณสมบัติใหม่ที่เพิ่มขึ้น. ขอให้สนุกกับสับ! เรามีความยินดีที่จะเปิดแหล่งที่มาทั้งสับและเครื่องมือที่คุณสามารถใช้ในการแปลงโดยอัตโนมัติ codebase ของคุณ นี่เป็นเพียงขั้นตอนแรกและเรามีความมุ่งมั่นที่จะดำเนินการต่อที่จะพัฒนาซอฟต์แวร์นี้เพื่อให้การพัฒนายิ่งขึ้นสำหรับทั้งวิศวกรของเราเองและชุมชนในวงกว้าง ค่าตัดคือ * ไม่ * จำกัด ให้กับโครงการใหญ่ที่มีข้อมูลประเภทข้อความผิดพลาดที่ดีและข้อเสนอแนะอย่างรวดเร็ว codebases ขนาดเล็กที่สามารถเก็บเกี่ยวผลประโยชน์ของสับเช่นกัน. เดือนถัดไปเรายังจะแนะนำภาษาที่วันพัฒนาสับบน มหาวิทยาลัย Facebook ในเมนโลพาร์คและเราหวังที่จะเห็นคุณมีในคนหรือออนไลน์. เรารักที่จะมีข้อเสนอแนะของคุณในการทำงานของเราเพื่อให้ห่างไกลและยินดีต้อนรับทุกท่านที่มีส่วนร่วมในชุมชน HHVM และสับ. กิตติกรรมประกาศมีหลายคนเป็นใคร มีส่วนร่วมในการพัฒนาของสับ. แกนสับทีมประกอบด้วยมั๊ย Verlaguet โจเอล Beales, ยู Letuchy กาเบรียลลีวายส์, โจเอล Marcey, เอริคเมย์เยอร์, ​​Alok Menghrajani ไบรอันซัลลิแวนดึง Paroski เจมส์เพียร์ซ, โจเอล Pobar และ . โจชัวรถตู้คัน Watzman ขอขอบคุณเป็นพิเศษไปที่ชุมชนของเราเริ่มต้น adopters ในการให้ข้อเสนอแนะที่มีคุณค่าที่จะทำให้ภาษาที่ดีกว่า:. เจมส์มิลเลอร์, ไซมอนเวลส์, นิลส์ Adermann, Fabien Potencier และอเล็กซานเด Mols สับเป็นลายลักษณ์อักษรเป็นหลักใน OCaml เราอยากจะขอขอบคุณทีมแกลเลียม (INRIA) สำหรับการพัฒนาของภาษา OCaml และทีม Ocsigen (CNRS - มหาวิทยาลัย Diderot ปารีส - INRIA). สำหรับการพัฒนาในส่วนของ js_of_ocaml Ocsigen และแน่นอนขอขอบคุณ เพื่อคนอื่น ๆ ที่ได้มีส่วนช่วยให้สับภาษาที่เป็นอยู่ในปัจจุบัน รายการจะหมดแรงเกินไปสำหรับการโพสต์บล็อก แต่คุณรู้ว่าคุณเป็นใคร

ผลลัพธ์ (ไทย) 3:

ทุก PHP โปรแกรมเมอร์คุ้นเคยกับงานแบบวันต่อวัน ที่อาจดูซับซ้อน หรือยุ่งยาก รหัสข้างต้นเป็นตัวอย่างที่ดีของการผิดพลาดทั่วไปที่ไม่คาดคิดเป็นวิธีเรียกวัตถุ null , ก่อให้เกิดข้อผิดพลาดที่ไม่ถูกจับ จนกระทั่งทำงาน . อีกตัวอย่างคือ API ที่ซับซ้อนที่นักพัฒนาอาจจะมีความเข้าใจที่มั่นคงของความหมาย แต่ยังใช้เวลามองชื่อวิธีการทางโลกในเอกสาร

ที่ Facebook ขนาด - มีหลายพันของวิศวกรจัดส่งรหัสใหม่สองวัน - ชะลอตัวแบบนี้เป็นปัญหามากขึ้น ก่อนที่จะสับเราก็มีภาษาง่ายๆด้วยห่วง - ตอบสนองที่รวดเร็วแต่เราจะลดประเภทของปัญหาที่อธิบายไว้ข้างต้น ? สามารถตรวจหาข้อผิดพลาดอยู่ร่วมกับการทำซ้ำทั้งหมดในขณะที่การรักษาเงินลงทุนของเราใน PHP ? สามารถปรับปรุงการวิเคราะห์รหัสและวิปัสสนาช่วยให้นักพัฒนามากขึ้นด้วยเครื่องมือเช่นอัตโนมัติสมบูรณ์

ผ้าแบบไดนามิกที่พิมพ์ภาษาให้พัฒนาอย่างรวดเร็ว แต่เสียสละความสามารถที่จะจับข้อผิดพลาดในวัยเด็กและใคร่ครวญรหัสได้อย่างรวดเร็วโดยเฉพาะอย่างยิ่งใน codebases ขนาดใหญ่ ในทางกลับกัน ส่วนพิมพ์ภาษาให้มากขึ้นของเครือข่ายความปลอดภัย แต่บ่อยครั้งที่ค่าใช้จ่ายของการได้อย่างรวดเร็ว . เราเชื่อว่ามันต้องมีจุดหวาน

ดังนั้นสับเกิดเราเชื่อว่ามันมีที่ดีที่สุดของทั้งแบบไดนามิกและพิมพ์พิมพ์ด้วยภาษา และนั่นมันก็จะมีค่าโครงการทุกขนาด ภาษา


สับสับได้ฝังรากลึกใน PHP ในความเป็นจริง ไฟล์ PHP ส่วนใหญ่แล้วไฟล์ตัดที่ถูกต้อง เราเลือกที่จะไม่สนับสนุนสติหยิบปฏิเสธหน้าที่และคุณสมบัติที่เข้ากันไม่ได้กับการพิมพ์แบบคงที่ ( เช่น" ตัวแปรตัวแปรและฟังก์ชัน extract() ) นอกจากนี้เรายังเพิ่มคุณสมบัติใหม่หลายอย่างที่เราเชื่อว่าจะช่วยให้นักพัฒนามากขึ้น

นอกจากนี้หลักของเราคือการ พิมพ์แบบคงที่ เราได้พัฒนาระบบเพื่ออธิบายฟังก์ชันและคลาสสมาชิกลายเซ็นกับข้อมูลประเภท ของเราประเภทของขั้นตอนวิธีการตรวจสอบ ( " ตรวจสอบ " ประเภท ) เกี่ยวกับเรื่องของที่พัก ตรวจสอบประเภทที่เพิ่มเช่นว่าแม้จะอยู่ในไฟล์เดียวรหัสบางอย่างสามารถแปลงสับในขณะที่ส่วนที่เหลือยังคงเป็นแบบไดนามิกพิมพ์ เทคนิคการพูด สับเป็น " ค่อยๆพิมพ์ * " * * * * ภาษา : พิมพ์รหัสแบบไดนามิก interoperates ต่อเนื่องกับส่วนพิมพ์รหัส

ภายในระบบชนิดสับ เราได้แนะนำคุณสมบัติหลายประการ เช่น ข้อมูลทั่วไป ประเภท ชนิด nullable aliasing ,และข้อจำกัดในพารามิเตอร์ชนิด เหล่านี้มีภาษาใหม่ รุกเพื่อโค้ดที่คุณเขียนด้วยสับจะยังคงมองและรู้สึกว่าภาษาแบบไดนามิกที่โปรแกรมเมอร์ PHP คุ้นเคย

แต่สับเพิ่มคุณสมบัติเพิ่มเติมนอกเหนือจากการตรวจสอบ ประเภทคงที่ รวมทั้งคอลเลกชัน , การแสดงออกแลมบ์ดาและระยะเวลาการบังคับใช้ประเภทส่งคืนและชนิดพารามิเตอร์ .

คอลเลกชันให้สะอาดปลอดภัยทางเลือกชนิดอาร์เรย์ PHP ที่เราออกแบบไว้ โดยเฉพาะทำงานกับพิมพ์และข้อมูลทั่วไปคงที่ คอลเลกชัน API มีฟังก์ชั่นขั้นสูงคลาสสิกมากมาย เช่น map() filter() เพื่อความสะดวกและรูปแบบโปรแกรมการทำงาน

ส่งสำนวนให้รัดกุมไวยากรณ์สำหรับการสร้างการปิด . ในขณะที่ PHP ได้ปิดต้องการโปรแกรมเมอร์อย่างชัดเจนชื่อตัวแปรที่พวกเขาต้องใช้จากการปิดล้อมขอบเขต . กับสับของ lambda แสดงออก เราโดยอัตโนมัติ สรุปว่าใช้เหล่านี้ให้คุณประหยัดไม่ทำงาน นิพจน์แลมดาให้สะดวกมากขึ้นเพื่อใช้ประโยชน์จากคอลเลกชัน API .

วิ่งเวลาการบังคับใช้ประเภทส่งคืนและประเภทพารามิเตอร์ ( รวมถึงประเภทเช่น int สเกลาร์และสตริง ) มีความปลอดภัยนอกเหนือจากสิ่งที่สามารถตรวจสอบได้ด้วยในขณะที่การจัดการประเภทที่ถูกเพิ่มเข้ามาเรื่อย ๆไป codebase . เรียกใช้เวลาช่วยให้โปรแกรมเมอร์ตรวจสอบและวินิจฉัยโรคบางชนิดของปัญหาได้ง่ายขึ้นและมันช่วยให้ hhvm เป็นจิตสร้างรหัสที่มีประสิทธิภาพมากขึ้นโดยการทำให้มันปลอดภัยที่จะเชื่อประเภทอื่นเพื่อเพิ่มประสิทธิภาพระบบการตรวจสอบ
.

พิมพ์ในระหว่างการพัฒนา PHP โปรแกรมเมอร์มักจะไปไปมาอย่างรวดเร็วระหว่างซอร์สโค้ดและเบราว์เซอร์ วิศวกรสามารถย้ำให้เร็วที่สุดเท่าที่พวกเขาต้องการ ทดสอบและปรับแต่งประสบการณ์จนกว่าจะสมบูรณ์แบบ

ผ้าประเภทนี้จะรบกวนตรวจสอบความคิดเห็นลูปเป็นมันต้องใช้เวลาวิเคราะห์รหัสแหล่งที่มา เราไม่ได้ต้องการที่จะชะลอ PHP เวิร์กโฟลว์ดังนั้นเราขึ้นมาด้วยวิธีการใหม่เพื่อปรับความเข้าใจทันทีความคิดเห็นกับตู้ประเภท

ทางออกของเราคือสถาปนิกประเภทตรวจสอบเป็นท้องถิ่นเซิร์ฟเวอร์ที่นาฬิการะบบแฟ้ม .เซิร์ฟเวอร์เก็บข้อมูลเกี่ยวกับรหัสแหล่งที่มาในหน่วยความจำทั้งหมดโดยอัตโนมัติและปรับปรุงตัวเองเมื่อมีการเปลี่ยนแปลงของไฟล์บนดิสก์ วิธีนี้ได้ผลแล้ว : ประเภทตรวจสอบมักจะอยู่ในน้อยกว่า 200 มิลลิวินาที และแทบจะใช้เวลามากกว่าสองทำให้ง่ายที่จะรวมเข้าไปในแนวทางการพัฒนาโดยไม่ต้องแนะนำความล่าช้าเห็นได้ชัด


รหัสการย้ายถิ่นตู้ชนิดสับและวาริทประโยชน์เติบโตยิ่งใช้ภายใน codebase . เข้าใจว่ามันคงยากสำหรับบางรหัสที่จะสมบูรณ์เปลี่ยนสับทันที มันเป็นสิ่งสำคัญสำหรับเราที่สับได้รับการพัฒนาเช่นว่านั้นสามารถอยู่ร่วมกันได้โดยตรงกับไฟล์ PHP อื่น ๆมันถูกแนะนำแบบเพิ่มหน่วย

ส่วนที่เหลือของขั้นตอนการแปลงเช่นการเพิ่มบันทึกย่อที่พิมพ์และใช้คุณลักษณะภาษาใหม่ สามารถกระทำได้ตามความเหมาะสมกับ codebase . ตัวอย่างเช่นประเภทหมายเหตุสามารถเพิ่มฟังก์ชันหนึ่งแต่ซ้ายปิดฟังก์ชั่นอื่น ในไฟล์เดียวกัน ถ้าฟังก์ชันพารามิเตอร์ หรือ ระดับสมาชิก ไม่ได้มีบันทึกย่อพิมพ์ชัดเจน ประเภทการพิจารณาชนิดของมันเป็นแบบไดนามิกและมันไม่ได้ตรวจสอบประเภทของค่า

ภายใน Facebook , เราพบว่าวิศวกรของเราชื่นชมสับเพียงพอที่พวกเขาเริ่มต้นการแปลงส่วนใหญ่ของรหัสของตนเองโดยสมัครใจ กับหลายบรรทัดของรหัสในต้นไม้ของเรา เรายังต้องการบางแบบอัตโนมัติ ดังนั้นเราได้สร้างและใช้หมายเลขของเครื่องมือแก้ไขรหัสที่จะช่วยให้กระบวนการ ( ซึ่งเราจะปล่อยเป็นส่วนหนึ่งของการ Hack นะ

)ไม่ต้องห่วง , PHP ของคุณจะปลอดภัย !
hhvm ยังคงเป็น PHP รันไทม์และเราตั้งใจให้มันเป็นแบบนั้น ในความเป็นจริง เรากำลังทำงานอย่างหนักเพื่อบรรลุความเท่าเทียมกันกับ php-5 . หนึ่งใน hhvm ด้านบนลำดับความสำคัญคือการใช้ php-5 แปรรหัสแหล่งที่มา ทั้งชุมชน และเนื่องจากเราพึ่งพาบุคคลที่สามห้องสมุด PHP ภายใน

hhvm คือตอนนี้รันไทม์สนับสนุน * * PHP และสับเพื่อให้คุณสามารถเริ่มต้นการใช้ประโยชน์จากสับเป็นคุณสมบัติใหม่แบบเพิ่มหน่วย

ขอให้สนุกกับสับ
เรายินดีที่จะเปิดทั้งสับ และเครื่องมือที่คุณสามารถใช้เพื่อแปลงโดยอัตโนมัติ codebase ของคุณ นี้เป็นเพียงขั้นตอนแรก และเราจะทุ่มเทอย่างต่อเนื่องเพื่อพัฒนาซอฟต์แวร์นี้เพื่อให้พัฒนาได้ง่ายขึ้นทั้งวิศวกรของเราเองและกว้างของชุมชนค่าตัดจะ * ไม่ * ( โครงการใหญ่ : ข้อมูลประเภท ข้อความแสดงข้อผิดพลาดที่ดีและความคิดเห็นอย่างรวดเร็ว codebases ขนาดเล็กที่สามารถเก็บเกี่ยวผลประโยชน์ของการ Hack เช่นกัน

เดือนหน้า เราจะแนะนำภาษาในวันพัฒนาสับบน Facebook วิทยาเขตในเมนโล พาร์ค และเราหวังที่จะเห็น คุณมีในคนหรือออนไลน์

เราชอบที่จะมีความคิดเห็นของคุณในงานของเราเพื่อให้ห่างไกลและยินดีต้อนรับทุกท่านที่จะเข้าร่วมใน hhvm เจาะชุมชน

ขอบคุณ
มีหลายคนมีส่วนในการพัฒนาตัด

แกนสับทีมประกอบด้วย จูเลียน verlaguet โจเอลบีลึส ยูจีน letuchy เกเบรียล เลวี โจเอล marcey , เอริก ไมเยอร์ข้อเสนอ menghrajani , ไบรอัน o'sullivan วาด paroski เจมส์ เพียร์ซ โจเอล pobar และโจชัวรถตู้คัน watzman .

ขอขอบคุณเป็นพิเศษไป adopters ชุมชนของเราก่อนเสนอความคิดเห็นอันมีค่าที่จะทำให้ภาษาดีขึ้น เจมส์ มิลเลอร์ ไซมอน เวลส์ นีลส์ adermann Fabien , potencier อเล็กซานเดอร์ mols

สับถูกเขียนเป็นหลักใน ocaml . เราอยากจะขอบคุณทีมงานแกลเลียม ( inria ) สำหรับการพัฒนาของ ocaml ภาษาและทีมงาน ocsigen ( cnrs - มหาวิทยาลัยแห่งปารีส ดีเดอโร - inria ) สำหรับการพัฒนาของ js_of_ocaml ส่วนหนึ่งของ ocsigen .

และ แน่นอน ขอบคุณทุกคนที่ช่วยให้ตัดภาษามันคือวันนี้ รายการมันใช่สำหรับบล็อก แต่คุณรู้ว่าคุณเป็นใคร