features of Hack Language

• Type Annotations allow for PHP code to be explicitly typed on parameters, class member variables and return values:

  <?hh
  class MyClass {
    const int MyConst = 0;
    private string $x = '';
    public function increment(int $x): int {
      $y = $x + 1;
      return $y;
    }
  }

• Generics allow classes and methods to be parameterized (i.e., a type associated when a class is instantiated or a method is called) in the same vein as statically type languages like C# and Java):

  <?hh
  class Box<T> {
    protected T $data;
  
    public function __construct(T $data) {
      $this->data = $data;
    }
  
    public function getData(): T {
      return $this->data;
    }
  }

• Nullable Types are supported by Hack through use of the ? operator. This introduces a safer way to deal with nulls and is very useful for primitive types that don’t generally allow null as one of their values, such as bool and int (using ?bool and ?int respectively). The operator can be used on any type or class.
• Collections enhance the experience of working with PHP arrays, by providing first class, built-in parameterized types such as Vector (an ordered, index-based list), Map (an ordered dictionary), Set (a list of unique values), and Pair (an index-based collection of exactly two elements).
• Lambdas offer similar functionality to PHP closures, but they capture variables from the enclosing function body implicitly and are less verbose:

  <?hh
  function foo(): (function(string): string) {
    $x = 'bar';
    return $y ==> $x . $y;
  }
  function test(): void {
    $fn = foo();
    echo $fn('baz'); // barbaz
  }

Other significant features of Hack include Shapes, Type Aliasing, Async support, and much more.

The JIT Compiler

Rather than directly interpret or compile PHP code directly to C++, HHVM compiles Hack and PHP into an intermediate bytecode. This bytecode is then translated into x64 machine code dynamically at runtime by a just-in-time (JIT) compiler. This compilation process allows for all sorts of optimizations that cannot be made in a statically compiled binary, thus enabling higher performance of your Hack and PHP programs.

HHVM

HHVM is an open-source virtual machine designed for executing programs written in Hack and PHP. HHVM uses a just-in-time (JIT) compilation approach to achieve superior performance while maintaining the development flexibility that PHP provides.

HHVM runs much of the world’s existing PHP. Developers and hosts are adopting HHVM. We are aware of minor incompatibilities (please open issues when you find them), but we can run the top 20 Github PHP frameworks out of the box. The HHVM team, along with many wonderful community members, has made it a stated, high priority goal to run all existing PHP code existing out in the wild.

HHVM Features

• The Hack Language
• JIT Compilation
• HNI
• FastCGI support
• Increasing PHP5 Parity
• hphpd debugger
• …. and many more

Have fun with Hack!

Open-source both Hack and the tools you can use to automatically convert your codebase is to be open source. This is just the first step, and they(Facebook) are dedicated to continuing to evolve this software to make development even easier for 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.

The Hack language

Hack has deep roots in PHP. In fact, most PHP files are already valid Hack files. Facebook 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).There also added many new features that will help make developers more productive.

Their principal addition is static typing. They have developed a system to annotate function signatures and class members with type information; the 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, there have 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. It designed 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, it 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.

Hack: a new programming language

Today facebook are releasing Hack, a programming language developed for HHVM that interoperates seamlessly with PHP. Hack reconciles the fast development cycle of PHP with the discipline provided by static typing, while adding many features commonly found in other modern programming languages.

Hack had been deployed at Facebook and it has been a great success. Over the last year, they have migrated nearly entire PHP codebase to Hack. 

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, facebook had a simple language with a quick feedback loop — but how could they mitigate the sorts of problems described above? Could early error detection coexist with rapid iteration, all while preserving their 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. It offers the best of both dynamically typed and statically typed languages, and that it will be valuable to projects of all sizes.

Source