andrea-chiarelli

I have over 20 years of experience as a software engineer and technical author. Throughout my career, I've used several programming languages and technologies for the projects I was involved in, ranging from C# to JavaScript, ASP.NET to Node.js, Angular to React, SOAP to REST APIs, etc.

In the last few years, I've been focusing on simplifying the developer experience with Identity and related topics, especially in the .NET ecosystem.

Principal Developer Advocate

Andrea Chiarelli

What's new in .NET 6? What are the main relevant features brought by the new version of the .NET platform? Let's take a quick look.

With the release of .NET 6, Microsoft consolidates its plan to create a unified platform to develop applications for any device and operating system. Together with this vision, .NET 6 brings many new features aiming to simplify development and gain performance. Let's take a quick look at the main points.

## Unified Platform Support
The vision of a [unified platform for the .NET world started with .NET 5](https://auth0.com/blog/dotnet-5-whats-new/). That release was meant to be the unified successor of [the various .NET flavors: .NET Framework, .NET Standard, .NET Core, Mono](https://auth0.com/blog/navigating-dotnet-maze/), etc. Beyond this goal, .NET 5 wanted to be a development platform to create any kind of application for any platform. However, at that time, an important piece was missing to complete the puzzle: a unified framework to create cross-platform UIs. Now, with [.NET MAUI](https://devblogs.microsoft.com/dotnet/announcing-net-maui-preview-10/), i.e., the **.NET Multi-platform App UI** framework, the puzzle is complete. Although at the time of writing [.NET MAUI is in preview](https://devblogs.microsoft.com/dotnet/announcing-net-maui-preview-10/), it is mature enough to be considered part of the .NET 6 release.

Now with .NET 6, you can really create the application you want and run it practically everywhere: from desktop to mobile, from the web to the cloud.

![.NET 6 unified platform](https://images.ctfassets.net/23aumh6u8s0i/GOa5gfL6LckpRRhqaBRJe/69341464075cbd46cf88fcbe36af4aa5/dotnet-unified-platform.png)

<p align="center">
[[*Source: Microsoft*](https://devblogs.microsoft.com/dotnet/announcing-net-6/)]
</p>

In particular, the new [.NET MAUI](https://github.com/dotnet/maui) framework allows you to build desktop and mobile native user interfaces with a single codebase.

![.NET MAUI overview](https://images.ctfassets.net/23aumh6u8s0i/4WkvXpMRwu7j5T82HiW04A/069649d85ea4e1def0831672b5fc8698/dotnet-maui-overview.png)

<p align="center">
[[*Source: Microsoft*](https://devblogs.microsoft.com/dotnet/introducing-net-multi-platform-app-ui/)]
</p>

## Simplified Development
One of the main goals of the .NET 6 release is to provide developers with features that simplify their work. You can find support for simplified development throughout the platform, but three contexts are really exciting: new C# features, Hot Reload support, and minimal web APIs.

### C# 10 features
.NET 6 brings you [C# 10 with plenty of new features](https://devblogs.microsoft.com/dotnet/welcome-to-csharp-10/) that help you write code more easily. Let's take a quick look at a few of them.

#### Global and implicit usings

As a C# developer, you know how annoying it is to declare the same namespace in every file of your project. Consider, for example, the `System` namespace. Its use is very common, and I'm pretty sure you forget it all the time and let Visual Studio suggest it.

Now you can declare namespaces using a global `using`, as shown in the following example:

```csharp
global using System;
```

With this declaration, you don't need to insert the `using System;` declaration in all files anymore. You can declare a namespace through `global using` in any file, and it will be available in the entire project.

If you prefer (and I think it's a good practice), you can declare your namespaces in a file named `GlobalUsings.cs`.

You can also take advantage of implicit `using`s by configuring the `<ImplicitUsings>` element in your `.csproj` file, as shown below:

```xml
<PropertyGroup>
    
    <ImplicitUsings>enable</ImplicitUsings>
</PropertyGroup>
```

This way, the compiler will automatically add the required `global using` directives based on the type of your project.

#### New namespace syntax

You know that the usual way to declare a namespace is as follows:

```csharp
namespace Geometry
{
  class Triangle 
  {
    // ...class members...
  }
}
```

Now you can use the file-scoped namespace syntax to get the same result:

```csharp
namespace Geometry

class Triangle 
{
  // ...class members...
}
```

With this approach, everything you define in the current file belongs to the declared namespace. By removing a nesting level, you make the code a bit cleaner. However, you can't create nested namespaces with this new syntax.

#### Natural types for lambda expressions

Consider the following assignment of a lambda expression to a variable:

```csharp
Func<string, int> parse = (string s) => int.Parse(s);
```

You need to declare the target type of the lambda expression, `Func<string, int>` in the example. Starting with C# 10, you can write the above code as follows:

```csharp
var parse = (string s) => int.Parse(s);
```

The compiler will try to infer the "natural" type of the lambda expression.

### Hot Reload
To improve the developer's productivity, .NET 6 extends [the Hot Reload feature](https://devblogs.microsoft.com/dotnet/announcing-net-6/#hot-reload) to Visual Studio and almost any type of project. It allows you to run an application in your development environment, make changes, and get the changes applied without stopping, rebuilding, and rerunning the application.

In previous .NET releases, this feature was available just for the .NET CLI via the `dotnet watch` command. Not without [some minor hiccups with the community](https://www.theverge.com/2021/10/22/22740701/microsoft-dotnet-hot-reload-removal-decision-open-source), you can now benefit from it in [Visual Studio 2022](https://devblogs.microsoft.com/dotnet/update-on-net-hot-reload-progress-and-visual-studio-2022-highlights/#improved-user-experience-in-visual-studio-2022) as well by simply clicking a button:

![Visual Studio 2022 Hot Reload button](https://images.ctfassets.net/23aumh6u8s0i/3wu09sA8C4IQ5uKfmGoITK/e13d618f3f497e72281665de780b472d/vs2022-hot-reload-button.png)

<p align="center">
[[*Source: Microsoft*](https://devblogs.microsoft.com/dotnet/update-on-net-hot-reload-progress-and-visual-studio-2022-highlights/)]
</p>

### Minimal web APIs
One astonishing feature introduced by .NET 6 to simplify your code is [minimal web APIs](https://docs.microsoft.com/en-us/aspnet/core/fundamentals/minimal-apis). Along the lines of top-level statements, now you can build a fully working web API application with a few lines of code. Consider the following sample:

```csharp
//Program.cs
var app = WebApplication.CreateBuilder(args).Build();

app.MapGet("/", () => "Hello World!");
app.Run();
```

This is all the code you need to run a simple *Hello World!* web API.

If you have some experience building web APIs with ASP.NET Core, you know that you usually need a more articulate project. You need at least a `Program.cs` file with the setup code for the application, a `Startup.cs` file where you configure your API, and a controller class defining the API routes and implementing the endpoints.

That's a lot of simplification!

## Performance Improvements
In the last years, the .NET team put a lot of effort into improving the platform performance in compiling and execution time and reducing memory consumption. With .NET 6, you can appreciate these improvements in many parts of the framework. For example, the effort to [improve inner-loop performance](https://github.com/dotnet/core/issues/5510) in building .NET projects has given awesome results, as you can see from the following diagram:

![dotnet6-build-improvements](https://images.ctfassets.net/23aumh6u8s0i/2ZVS4o4DKc6OroBO0Lb76b/187a5cbf18d934d9a1cefae71f1535f5/dotnet6-build-improvements.png)

<p align="center">
[[*Source: Microsoft*](https://devblogs.microsoft.com/dotnet/announcing-net-6-preview-2/)]
</p>

Other performance improvements include the IO subsystem. For example, the `FileStream` class [was almost completely rewritten](https://devblogs.microsoft.com/dotnet/file-io-improvements-in-dotnet-6/) with amazing results even with respect to .NET 5, as the following table summarizes for the writing operation:

![FileStream performance improvement](https://images.ctfassets.net/23aumh6u8s0i/6RgFjbKytdIQk6pHtEaHxT/1d524bb8a02e4688979d71f3151aef3f/filestream-performance-improvement.png)

<p align="center">
[[*Source: Microsoft*](https://devblogs.microsoft.com/dotnet/announcing-net-6/)]
</p>
You can check out [a detailed report on performance improvements in .NET 6](https://devblogs.microsoft.com/dotnet/performance-improvements-in-net-6/) with related benchmarks for more information.

## Summary

This quick overview of .NET 6 shows that this is a consolidation release of the .NET platform. It aims to complete the unified platform vision started with .NET 5, improves the internals of the platform to provide the best performance, and starts a process of development simplification that probably will go further in future releases.

<include src="asides/DotNetCore" />

.NET 6 Highlights

Learn about the new features introduced by the .NET Core 3.0 release.

Exploring .NET Core 3.0. What's New?

5e074956ee8ba1fea26e30d28c190495?s=300 avatar

5e074956ee8ba1fea26e30d28c190495?s=300

Full stack developer creating content at Auth0. I love taking a deep dive into hard-to-understand concepts and creating content that makes them easier to grasp. In my free time you can usually find me reading, hanging out with my dogs, or curling in the squat rack.

Former Developer Content Manager

Holly Guevara

Learn what's new and what has changed in the new PHP 8 release.



The long-anticipated GA release of **PHP 8.0 is scheduled for November 26th, 2020**. Let's take a look at a few of the new additions in PHP 8 and who is supporting it at release.

## New Additions

### Union types

PHP 8 now supports union types, which allow you to declare more than one type in your classes or arguments. Before version 8, PHP already supported two special union types: `nullable` and `iterable`. 

<include src="AmpWarning" fullUrl="https://auth0.com/blog/whats-new-php-8"/>

``` php  
// Nullable - return type can be string or null
function getUsername() : ?string {
  return $this->username;
}

// Iterable pseudo-type - return type can be array or
// instance of Traversable
function iterate() : iterable {
  // ...
}
```

In PHP 8, these special union types have been extended to include several combinations, with [a few exceptions](https://wiki.php.net/rfc/union_types_v2#supported_types).

``` php  
// Union - return type can be int or float
function getNumber() : int|float {
  return $this->number;
}

// Nullable implemented as new union type
function getUsername() : string|null {
  return $this->username;
}
```

### `mixed` Types

PHP 8 introduces a new pseudo-type to the PHP type system: `mixed`. This pseudo-type allows you to declare a value of any type without excluding type information altogether.

From the [Mixed Type RFC](https://wiki.php.net/rfc/mixed_type_v2):

> An explicit mixed type would allow people to add types to parameters, class properties, and function returns to indicate that the type information wasn't forgotten about, it just can't be specified more precisely, or the programmer explicitly decided not to do so.

To get an idea of all types that `mixed` type includes, here's `mixed` represented as a union type:

``` php  
array|bool|callable|int|float|null|object|resource|string
```

### JIT (Just in Time compiler)

In a compiled language, the source code is converted to computer-readable code ahead of time. Interpreted languages, on the other hand, convert the source code as it's executed, which is much slower. PHP is an interpreted language, and there have been [several tactics](https://www.ionos.com/community/hosting/php/php-7-opcache-speed-up-websites-noticeably/) used to improve PHP performance in the past.

The latest step in speeding up performance is the addition of the [JIT compiler](https://hacks.mozilla.org/2017/02/a-crash-course-in-just-in-time-jit-compilers/) in PHP 8.

The JIT compiler is sort of a middle ground between compilation and interpretation. It will compile and cache some sections of code at runtime so that the compiled version can be used instead of the interpreted version. This *could* lead to huge performance gains for PHP, but with some caveats. Generally, JIT compilers **mostly benefit CPU-intensive applications**, such as 3D rendering or large mathematical computations. If you're using PHP for web applications, you may not see a substantial performance boost by enabling the JIT compiler.

> 👩‍💻 Note: JIT is not enabled by default. Check out this excellent guide about [how to enable JIT in PHP 8](https://stitcher.io/blog/php-8-jit-setup).

### str_contains function 

The new [`str_contains`](https://wiki.php.net/rfc/str_contains) function can be used to check if a given string contains another string.

``` php  
str_contains ( string $haystack , string $needle ) : bool
```

#### Example:

``` php  
str_contains("PHP is cool!", "PHP"); // true 
str_contains("PHP is cool!", "php"); // false 
str_contains("PHP is cool!", "not"); // false 
```

> 👩‍💻 Note: `str_contains()` is case-sensitive

### Named Arguments

[Named arguments](https://wiki.php.net/rfc/named_params) are another new addition to PHP 8. With named arguments, you can now pass an argument to a function based on the parameter name. This means that the order in which arguments are passed won't matter, as the name will be used to determine the parameter.

#### Example

``` php  
createUser(id: 1, username: hollylawly);
// position of argument doesn't matter
createUser(username: hollylawly, id: 1);
```

### `match` Expressions

The `match` expression introduced in PHP 8 is similar to the `switch` statement, but with a few improvements:

- `match` evaluates to the result of the expression, so you don't need to remember to set some variable at every case
- No type coercion like in `switch` statements
- Implicit `break` is added after every arm, so if you forget to add a `break`, you won't experience [fallthrough](https://en.wikipedia.org/wiki/Switch_statement#Fallthrough)

#### Example

``` php  
$operation = 'write';

// Switch statement
switch ($operation) {
  case 'read':
    $message = 'Viewed!';
    break;
  case 'write':
    $message = 'Created!';
    break;
  case 'update':
    $message = 'Updated!';
    break;
  case 'delete':
    $message = 'Deleted!';
    break;
}

// Equivalent match expression
$message = match ($operation) {
  'read' => 'Viewed!',
  'write' => 'Created!',
  'update' => 'Updated!',
  'delete' => 'Deleted!',
}
```

> 👩‍💻 Note: `match` is now a reserved keyword

### Trailing commas in parameters lists

This one is pretty straightforward but bound to make a lot of people happy! Like argument lists, you can now also leave the trailing comma off at the end of parameter lists.

``` php  
function myFunction(
  param1,
  param2,
  param3,
) {
  // ...
}
```

An additional bonus of this is that it simplifies diffs where a parameter is added. Instead of two lines changing (adding a comma to the last parameter and the line with the new parameter), only one line would be highlighted.

``` php  

// --- Diff with no trailing comma
// Before
function myFunction(
  param1,
  param2,
  param3
) {
  // ...
}

// After
function myFunction(
  param1,
  param2,
  param3,  // 👈 this line changed
  param4   // 👈 this line changed
) {
  // ...
}

// --- Diff with trailing comma
// Before
function myFunction(
  param1,
  param2,
  param3,
) {
  // ...
}

// After
function myFunction(
  param1,
  param2,
  param3,
  param4,   // 👈 this line changed
) {
  // ...
}
```

## PHP 8 Support

Because PHP 8 has been on the horizon for so long, a lot of community work has already been done to make sure that it's supported across the web. But before you upgrade, you should make sure it's being supported wherever you use it.

Here is the current **support status** of some popular projects, frameworks, applications, and more.

### WordPress

WordPress plans to [support PHP 8 in their next release (v5.6)](https://make.wordpress.org/core/2020/10/06/call-for-testing-php-8-0/), which is currently scheduled for December 8th, 2020. This doesn't affect the  minimum required version, which is currently PHP 5.6.2.

Because this is a major version change, a lot of testing is required. If you're interested in helping out the WordPress community with PHP 8 testing, be sure to check out their [call for testing](https://make.wordpress.org/core/2020/10/06/call-for-testing-php-8-0/).

### Laravel

The Laravel team completed all updates needed for PHP 8 support well ahead of time. This includes updates to the following projects:

- [Faker](https://github.com/FakerPHP/Faker/pull/1)
- [`guzzlehttp`](https://github.com/guzzle/guzzle/pull/2808)
- [`mockery`](https://github.com/mockery/mockery/pull/1088)
- [`doctrine/dbal`](https://github.com/doctrine/dbal/pull/4347)
- [PHPUnit](https://github.com/sebastianbergmann/phpunit/issues/4325)

For a full list, check out [Laravel's Full PHP 8.0 Support PR](https://github.com/laravel/framework/pull/33388).

### Auth0

The [Auth0 PHP SDK](https://github.com/auth0/auth0-PHP) has been updated to fully support PHP 8 right out of the gate, so you can get up and running with it immediately!

If you're interested in an easy-to-use solution for adding authentication and authorization to your PHP application, be sure to sign up for a <a href="https://auth0.com/signup" data-amp-replace="CLIENT_ID" data-amp-addparams="anonId=CLIENT_ID(cid-scope-cookie-fallback-name)">free Auth0 account</a> to get started.

With Auth0, you only have to write a few lines of code to get:

- A solid [identity management solution](https://auth0.com/user-management), including [single sign-on](https://auth0.com/docs/sso/single-sign-on)
- [User management](https://auth0.com/docs/user-profile)
- Support for [social identity providers (like Facebook, GitHub, Twitter, etc.)](https://auth0.com/docs/identityproviders)
- [Enterprise identity providers (Active Directory, LDAP, SAML, etc.)](https://auth0.com/enterprise)
- Our [own database of users](https://auth0.com/docs/connections/database/mysql)
- [And much more](https://auth0.com/blog/auth0-features-to-fall-in-love-with/).

To get up and running quickly, check out the [PHP Quickstart](https://auth0.com/docs/quickstart/webapp/php/01-login).

### Symfony

The Symfony team is ready to support PHP 8 right out of the gate. If you're curious about the process of supporting PHP 8 in Symfony, be sure to check out [this video where Nikita Popov of JetBrains interviews Nikolas Grekas](https://www.youtube.com/watch?v=c3bpTBjhK2Y), Symfony's principal engineer.

> "We are quite happy. It went very smoothly. PHP 8 is pretty easy to support."
> &mdash; Nicolas Grekas

## Wrap Up

A lot of work has gone into the release of PHP 8, and the PHP community is no doubt excited to get their hands on it.

For a full list of changes or to get some context on why something was introduced, be sure to check out the [implemented RFCs for PHP 8](https://wiki.php.net/rfc#php_80).

Let me know in the comments below what new features you're most excited about and if you plan to upgrade right out of the gate. Thanks for reading!

What's New in PHP 8

Learn about the new features and changes in the latest Laravel 8 release.




It feels like just yesterday we were reading about what's coming in Laravel 6. And here we are today, learning about what's new in Laravel 8! 🤯

Whether you're getting started with Laravel or just want to check out the [latest and greatest](https://laravel.com/docs/8.x/releases), keep on reading.

## Laravel Jetstream

[Laravel Jetstream](https://jetstream.laravel.com/1.x/introduction.html), the new Laravel application scaffolding, was released with the new version of Laravel.

Jetstream provides a fantastic starting point for your Laravel applications with the following built-in options:

- Login and registration
- Email verification
- Two-factor authentication (2FA)
- Session management
- [Laravel Sanctum](https://laravel.com/docs/8.x/sanctum) API support
- Designed with Tailwind CSS
- Choice of two frontend stacks: [**Livewire + Blade**](https://laravel-livewire.com/) or [**Inertia.js + Vue.js**](https://inertiajs.com/)

![Laravel Jetstream Livewire installation](https://images.ctfassets.net/23aumh6u8s0i/5bC4p3YLjRj30EO0VlIRSs/aa91442260d3618589c60fcd808383f6/laravel-jetstream-livewire)

### How to use Laravel Jetstream

You can create a new application with Jetstream using the [Laravel installer](https://laravel.com/docs/8.x/installation#installing-laravel). Make sure the Laravel installer is updated to `v4.0`, and then run the following:

``` bash  
laravel new your-project --jet
```

Choose which stack you want to use: Livewire or Inertia. Next, run your database migrations with:

``` bash  
php artisan migrate
```

Finally, see your application at [`http://localhost:8000`](http://localhost:8000) by running:

``` bash  
php artisan serve
```

And now, you're ready to [explore your new Laravel Jetstream application](https://jetstream.laravel.com/1.x/installation.html)!

If you'd prefer to use Composer, you can find the [Composer installation instructions](https://jetstream.laravel.com/1.x/installation.html#composer-installation) in the Laravel Jetstream documentation.

## Models Updates

### Welcome back, `Models` directory!

The `app/Models` directory is back! Years ago, when Laravel 5 launched, a lot of developers noticed the `Models` directory was missing. Instead, new models were created directly in the `app` directory. Surprisingly, this caused quite the uproar in the community. You could still manually create the folder, and a lot of developers did, but it was considered an extra nuisance by some.

With Laravel 8, the beloved `app/Models` directory has been restored! If you prefer the old structure, you can always modify your codebase to remove the `Models` directory again.

### Model factory classes

[Taylor Otwell](https://github.com/taylorotwell) spent some time rewriting the Eloquent model factories as classes.

Let's compare the changes by looking at the default `User` factories from both Laravel 7 and 8. 

**User factory in Laravel 7.x:**

``` php  
// database/factories/UserFactory.php

use Faker\Generator as Faker;
use Illuminate\Support\Str;

$factory->define(App\User::class, function (Faker $faker) {
    return [
        'name' => $faker->name,
        'email' => $faker->unique()->safeEmail,
        'email_verified_at' => now(),
        'password' => '$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi', // password
        'remember_token' => Str::random(10),
    ];
});
```

**User factory in Laravel 8:**

``` php  
// database/factories/UserFactory.php

namespace Database\Factories;

use App\Models\User;
use Illuminate\Database\Eloquent\Factories\Factory;
use Illuminate\Support\Str;

class UserFactory extends Factory
{
    /**
     * The name of the factory's corresponding model.
     *
     * @var string
     */
    protected $model = User::class;

    /**
     * Define the model's default state.
     *
     * @return array
     */
    public function definition()
    {
        return [
            'name' => $this->faker->name,
            'email' => $this->faker->unique()->safeEmail,
            'email_verified_at' => now(),
            'password' => '$2y$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi', // password
            'remember_token' => Str::random(10),
        ];
    }
}
```

In Laravel 8, factories are now classes that extend the base Laravel factory class. Glancing at the default file, you'll see the `model` property and `definition` method. The `definition` method then returns the model attributes.

Compare this to Laravel 7 and below, where the `UserFactory` is defined with a [Closure](https://www.php.net/manual/en/class.closure.php) and returns the specified model attributes.

Both of these still have access to Faker, as expected. Let's look at the difference between *using* factories in Laravel 7 versus Laravel 8.

**Using factories in Laravel 7:**

Before this update, you would use the `factory` helper function in your seeder files to generate model instances.

``` php  
// database/seeds/UserSeeder.php

class UserSeeder extends Seeder
{
  /**
  * Run the database seeds.
  *
  * @return void
  */
  public function run()
  {
    // Create three App\User instances
    $users = factory(App\User::class, 3)->create();
  }
}
```

**Using factories in Laravel 8:**

With Laravel 8, you can use the `factory` directly on the model instance. This is because the default models now include a `HasFactory` trait, as shown in the simplified code below. 

``` php  
// database/seeders/UserSeeder.php

class UserSeeder extends Seeder
{
  /**
    * Run the database seeds.
    *
    * @return void
    */
  public function run()
  {
    // Create three App\User instances
    User::factory(3)->create();
  }
}
```

``` php  
// app/Models/User.php
<?php
namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
// ...

class User extends Authenticatable
{
    use HasFactory;
    // ...
}

```

> ❗ If you have existing factories on a Laravel 7.x project or older and you're planning on upgrading, you can use the [`laravel/legacy-factories`](https://github.com/laravel/legacy-factories) package that was created to simplify the upgrade process.

## Migration Squashing

😱 Laravel 8 introduces another exciting feature: migration squashing! No longer do you have to scroll for five minutes when you open up your `migrations` folder! With migration squashing, you can now condense your migration files into a single SQL file with the following commands:

``` bash  
php artisan schema:dump
php artisan schema:dump --prune
```

Laravel will write the new `schema` file to `database/schema`. Then when you run your migrations, Laravel will run the SQL from the schema file first before moving on to anything created later in the `migrations` folder.

> Note: Migration squashing is currently only supported for MySQL and Postgres.

## Job Batching

In Laravel, jobs are tasks that can be performed as part of a queue to accomplish something in the background. The new [job batching feature](https://laravel.com/docs/8.x/queues#job-batching) allows you to execute several [jobs](https://laravel.com/docs/8.x/queues#creating-jobs) together.

To use the new batching feature, first define your job as you normally would. The example below has been simplified to show the new `Batchable` trait.

``` php  
<?php
namespace App\Jobs;

use Illuminate\Bus\Batchable;
// ...

class SendEmail implements ShouldQueue
{
  use Batchable;

  /**
    * Execute the job.
    *
    * @return void
    */
  public function handle()
  {
    if ($this->batch()->cancelled()) {
      // Detected cancelled batch...

      return;
    }
    // Batched job executing...
  }
}
```

Once you have your job defined, you can dispatch a batch of jobs in your controller using the `batch` method of the `Bus` facade.

``` php  
  use App\Jobs\SendEmail;
  use App\User;
  use Illuminate\Bus\Batch;
  use Illuminate\Support\Facades\Batch;
  use Throwable;

  $batch = Bus::batch([
    new SendEmail(User::find(1)),
    new SendEmail(User::find(2)),
    new SendEmail(User::find(3)),
  ])->then(function (Batch $batch) {
    // All jobs completed successfully...
  })->catch(function (Batch $batch, Throwable $e) {
    // First batch job failure detected...
  })->finally(function (Batch $batch) {
    // The batch has finished executing...
  })->dispatch();

  return $batch->id;
```

You'll also notice the addition of the `then`, `catch`, and `finally` methods. You can use these to define completion callbacks for your batch of jobs.

## Better Rate Limiting


**Rate limiting in Laravel 7**

``` php  
Route::middleware('auth:api', 'throttle:10,1')->group(function () {
  Route::get('/login', function () {
    //
  });
});
```

**Rate limiting in Laravel 8**

In Laravel 8, you can define your rate limiters in `app/Providers/RouteServiceProvider.php` using the `for` method of the `RateLimiter` facade. The `for` method will accept a name and a Closure, which returns the rate limiting details that you set up. 

``` php  
use Illuminate\Cache\RateLimiting\Limit;
use Illuminate\Support\Facades\RateLimiter;

RateLimiter::for('login', function (Request $request) {
  return Limit::perMinute(10);
});
```

You can now apply this pre-configured rate limiter to routes with `throttle:` followed by the rate limiter name.

``` php  
Route::middleware(['throttle:login'])->group(function () {
  Route::post('/login', function () {
    //
  });
  Route::post('/register', function () {
    //
  });
});
```

> Note: The `throttle` middleware API from previous Laravel versions will still remain functional.

For more about rate limiting options, see the [Laravel routing docs](https://laravel.com/docs/8.x/routing#rate-limiting). 

## Maintenance Mode

Laravel 8 also brings some improvements to maintenance mode. Maintenance mode is a really helpful feature that allows you to "disable" your application while you're making updates to it.

In previous versions, you would have to specify the IPs that would still be allowed to access the application with the `allow` option:

``` bash  
php artisan down --allow=127.0.0.1 --allow=192.168.0.0/16
```

With Laravel 8, you no longer need to allow certain IPs explicitly. Instead, you can use the `secret` option to create a maintenance mode bypass token:

``` bash  
php artisan down --secret="1630542a-246b-4b66-afa1-dd72a4c43515"
```

You can then access your application while in maintenance mode by appending the token to your application's URL, e.g., `https://example.com/1630542a-246b-4b66-afa1-dd72a4c43515`. The bypass cookie will be saved to your browser, and you can continue navigating your application from its normal URL, e.g., `https://example.com`.

## Routing Namespacing

In Laravel 8, the `namespace` property in `app/Providers/RouteServiceProvider.php` is now `null` by default, as you can see below.

``` php  
// app/Providers/RouteServiceProvider.php
<?php

namespace App\Providers;

// ...
class RouteServiceProvider extends ServiceProvider
{
    // ...
    /**
     * If specified, this namespace is automatically applied to your controller routes.
     *
     * In addition, it is set as the URL generator's root namespace.
     *
     * @var string
     */
    protected $namespace = null; // <--- LARAVEL 8 CHANGE
    // ...
}
```

In previous versions, the `$namespace` property was set to `App\Http\Controllers`.

This change means that controller route definitions will no longer include automatic namespace prefixing. The example below demonstrates how routing namespacing differs between Laravel 7 and Laravel 8.

**Laravel 7:**

``` php  
// routes/web.php

Route::get('/posts', 'PostController@index'); 
```

**Laravel 8:**

``` php  
// routes/web.php
use App\Http\Controllers\PostController;

Route::get('/posts', [PostController::class, 'index']);
```

If you prefer the old way, you can change the `$namespace` value back to `App\Http\Controllers` in `app/Providers/RouteServiceProvider.php`.

For more about routing namespacing updates, see the [Laravel routing documentation](https://laravel.com/docs/8.x/routing#basic-routing).

## Wrap Up

As always, Taylor Otwell and the rest of the Laravel team have been hard at work to deliver us some awesome and welcome updates to Laravel! Now that you have some background about what's new and what changed with Laravel 8, feel free to go off and [explore on your own](https://laravel.com/docs/8.x)! Leave a comment below letting me know your favorite change in Laravel 8 and what you're planning on building. Cheers!

<include src="asides/AboutAuth0" />


What's New in Laravel 8?

Learn the new features introduced by ECMAScript 2020 in JavaScript.



New exciting features are coming for JavaScript!

Even if the final approval of the new [ECMAScript 2020 (ES2020) language specification](https://tc39.es/ecma262/2020/) will be in June, you can start to take a look and try them right now!

![ES2020 Language Specification](https://images.ctfassets.net/23aumh6u8s0i/5oyMaGaQ9iZXB4MTfD1qFO/c19e21f7f828fe12b3022454f9e39a12/es2020-language-specification)

Follow me in this article to explore what's new.

## Dealing with Modules

Some important innovations concern modules. Among these, a feature that developers have been requesting for a long time is the dynamic import. But let's go in order and see them in detail.

### Dynamic imports

The current mechanism for importing modules is based on static declarations like the following:

```javascript
import * as MyModule from "./my-module.js";
```

This statement has a couple of constraints:

- all the code of the imported module is evaluated at the load time of the current module
- the specifier of the module (`"./my-module.js"` in the example above) is a string constant, and you can not change it at runtime

These constraints prevent loading modules conditionally or on-demand. Also, evaluating each dependent module at load time affects the performance of the application.

The new `import()` statement solves these issues by allowing you to import modules dynamically. The statement accepts a module specifier as an argument and returns a promise. Also, the module specifier can be any expression returning a string. This is great news because we can now load JavaScript modules at runtime as in the following example:

```javascript
const baseModulePath = "./modules";
const btnBooks = document.getElementById("btnBooks");
let bookList = [];

btnBooks.addEventListener("click", async e => {
  const bookModule = await import(`${baseModulePath}/books.js`);
  
  bookList = bookModule.loadList();
});
```

This code shows how to load the `books.js` module right when the user clicks the `btnBooks` button. After loading the module, the click event handler will use the `loadList()` function exported by the module. Note how the module to import is specified through a string interpolation.

<include src="TweetQuote" quoteText="The long-awaited dynamic import is now available in JavaScript ES2020."/>

### Import meta data

The `import.meta` object provides metadata for the current module. The JavaScript engine creates it, and its current available property is `url`. This property's value is the URL from which the module was loaded, including any query parameter or hash.

As an example, you could use the `import.meta.url` property to build the URL of a `data.json` file stored in the same folder of the current module. The following code gets this result:

```javascript
const dataUrl = new URL("data.json", import.meta.url);
```

In this case, the `import.meta.url` provides the `URL` class with the base URL for the `data.json` file.

### New export syntax

The `import` statement introduced by the ECMAScript 2015 specifications provides you with many forms of modules importing. The following are a few examples:

```javascript
import {value} from "./my-module.js";
import * from "./my-module.js";
```

In some cases, you may need to export objects imported from another module. A handy `export` syntax may help you, as shown in the following:

```javascript
export {value} from "./my-module.js";
export * from "./my-module.js";
```

This symmetry between import and export statements is convenient from a developer experience standpoint. However, a specific case wasn't supported before these new specifications:

```javascript
import * as MyModule from "./my-module.js";
```

To export the `MyModule` namespace, you should use two statements:

```javascript
import * as MyModule from "./my-module.js";
export {MyModule};
```

Now, you can get the same result with one statement, as shown below:

```javascript
export * as MyModule from "./my-module.js";
```

This addition simplifies your code and keeps the symmetry between `import` and `export` statements.

## Data Types and Objects

The new ES2020 specifications introduce a new data type, a standardized global object, and a few methods that simplify the developer's life. Let's take a look.

### BigInt and arbitrary precision integers

As you know, JavaScript has only one data type for numbers: the `Number` type. This primitive type allows you to represent 64-bit floating-point numbers. Of course, it also represents integers, but the maximum representable value is 2^53, corresponding to the `Number.MAX_SAFE_INTEGER` constant.

Without going into the internal details of integer representation, there are situations where you may need a higher precision. Consider the following cases:

- interaction with other systems that provide data as 64-bit integers, such as GUIDs, account numbers, or object IDs
- result of complex mathematical calculations requiring more than 64 bits

The workaround for the first case is representing data as strings. Of course, this workaround doesn't work for the second case.

The new `BigInt` data type aims to solve these issues. You represent a literal `BigInt` by simply appending the letter `n` to a number, as shown in this example:

```javascript
const aBigInteger = 98765432123456789n;
```

You can also use the `BigInt()` constructor the same way you use the `Number()` constructor:

```javascript
const aBigInteger = BigInt("98765432123456789");
```

The `typeof` operator now returns the `"bigint"` string when applied to a `BigInt` value:

```javascript
typeof aBigInteger		//output: "bigint"
```

Keep in mind that `Number` and `BigInt` are different types, so you cannot mix them. For example, the attempt to add a `Number` value to a `BigInt` value throws a `TypeError` exception, as shown by the following picture:

![Mixing BigInts and Numbers throws a TypeError exception](https://images.ctfassets.net/23aumh6u8s0i/1YxzmHqbHvpg1d7GC6lvV9/7949ca9ffddfa1549b4970f884f75e71/mixing-bigint-number)

You have to explicitly convert the `Number` value to a `BigInt` value by using the `BigInt()` constructor.

<include src="TweetQuote" quoteText="The BigInt data type is a new 'big' addition to JavaScript."/>

### The matchAll() method for regular expressions

You have several ways to get all matches for a given regular expression. The following is one of these ways, but [you can use other approaches](https://2ality.com/2018/02/string-prototype-matchall.html#getting-all-matches-for-a-regular-expression):

```javascript
const regExp = /page (\d+)/g;
const text = 'text page 1 text text page 2';
let matches;

while ((matches = regExp.exec(text)) !== null) {
  console.log(matches);
}
```

This code matches all the *page x* instances within the `text` variable through iteration. At each iteration, the `exec()` method runs over the input string, and you obtain a result like the following:

```shell
["page 1", "1", index: 5, input: "text page 1 text text page 2", groups: undefined]
["page 2", "2", index: 22, input: "text page 1 text text page 2", groups: undefined]
```

The `matchAll()` method of `String` objects allows you to get the same result but in a more compact way and with better performance. The following example rewrites the previous code by using this new method:

```javascript
const regExp = /page (\d+)/g;
const text = 'text page 1 text text page 2';
let matches = [...text.matchAll(regExp)];

for (const match of matches) {
  console.log(match);
}
```

The `matchAll()` method returns an iterator. The previous example uses the spread operator to collect the result of the iterator in an array.

### The globalThis object

Accessing the global object requires different syntaxes, depending on the JavaScript environment. For example, in a browser, the global object is `window`, but you cannot use it within a Web Worker. In this case, you need to use `self`. Also, in Node.js the global object is `global`.

This leads to issues when writing code intended to run in different environments. You might use the `this` keyword, but it is `undefined` in modules and in functions running in [strict mode](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode).

The `globalThis` object provides a standard way of accessing the global object across different JavaScript environments. So, now you can write your code in a consistent way, without having to check the current running environment. Remember, however, to minimize the use of global items, since it is considered [a bad programming practice](https://wiki.c2.com/?GlobalVariablesAreBad).

### The Promise.allSettled() method

Currently, JavaScript has two ways to combine promises: `Promise.all()` and `Promise.race()`.

Both methods take an array of promises as an argument. The following is an example of using `Promise.all()`:

```javascript
const promises = [fetch("/users"), fetch("/roles")];
const allResults = await Promise.all(promises);
```

`Promise.all()` returns a promise that is fulfilled when all the promises fulfilled. If at least one promise is rejected, the returned promise is rejected. The rejection reason for the resulting promise is the same as the first rejected promise.

This behavior doesn't provide you with a direct way to get the result of all the promises when at least one of them is rejected. For example, in the code above, if `fetch("/users")` fails and the corresponding promise rejected, you don't have an easy way to know if the promise of `fetch("/roles")` is fulfilled or rejected. To have this information, you have to write some additional code.

The new `Promise.allSettled()` combinator waits for all promises to be settled, regardless of their result. So, the following code lets you know the result of every single promise:

```javascript
const promises = [fetch("/users"), fetch("/roles")];
const allResults = await Promise.allSettled(promises);
const errors = results
  .filter(p => p.status === 'rejected')
  .map(p => p.reason);
```

In particular, this code lets you know the reason for the failure of each rejected promise.

## New operators

A couple of new operators will make it easier to write and to read your code in very common operations. Guess which ones?

### The nullish coalescing operator

How many times you've seen and used expressions like the following?

```javascript
const size = settings.size || 42;
```

Using the `||` operator is very common to assign a default value when the one you are attempting to assign is `null` or `undefined`. However, this approach could lead to a few potentially unintended results.

For example, the `size` constant in the example above will be assigned the value `42` also when the value of `settings.size` is `0`. But the default value will also be assigned when the value of `settings.size` is `""` or `false`.

To overcome these potential issues, now you can use the *nullish coalescing operator* (`??`). The previous code becomes as follows:

```javascript
const size = settings.size ?? 42;
```

This grants that the default value `42` will be assigned to the `size` constant only if the value of `settings.size` is `null` or `undefined`.

### Optional chaining

Consider the following example:

```javascript
const txtName = document.getElementById("txtName");
const name = txtName ? txtName.value : undefined;
```

You get the textbox with `txtName` as its identifier from the current HTML document. However, if the HTML element doesn't exist in the document, the `txtName` constant will be `null`. So, before accessing its `value` property, you have to make sure that `txtName` is not `null` or `undefined`. 

The optional chaining operator (`?.`) allows you to have a more compact and readable code, as shown below:

```javascript
const txtName = document.getElementById("txtName");
const name = txtName?.value;
```

As in the previous example, the `name` constant will have the the value of `txtName.value` if `txtName` is not `null` or `undefined`; `undefined` otherwise.

The benefits of this operator are much more appreciated in complex expressions like the following:

```javascript
const customerCity = invoice?.customer?.address?.city;
```

You can apply the optional chaining operator also to dynamic properties, as in the following example:

```javascript
const userName = user?.["name"];
```

In addition, it applies to function or method calls as well:

```javascript
const fullName = user.getFullName?.();
```

In this case, if the `getFullName()` method exists, it is executed. Otherwise, the expression returns `undefined`.

<include src="TweetQuote" quoteText="The nullish coalescing operator and the optional chaining are now a reality in JavaScript."/>

## Using the New Features

Throughout this article, you got an overview of ES2020's new features, and you're probably wondering when you'll be able to use them.

According to [caniuse.com](https://caniuse.com/), all recent major browsers but Internet Explorer already support the new features brought by ECMAScript 2020. However, at the time of writing, Safari is not supporting the new `BigInt` data type and the `matchAll()` method.

The [latest version of Node.js](https://auth0.com/blog/nodejs-v-14-whats-new/) supports all the features as well, including [dynamic import](https://nodejs.org/api/esm.html#esm_import_expressions) for [enabled ECMAScript modules](https://nodejs.org/api/esm.html#esm_enabling).

Finally, also the latest versions of the most popular transpilers, like [Babel](https://babeljs.io/blog/2020/01/11/7.8.0) and [TypeScript](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-8.html#-es2020-for-target-and-module), allow you to use the latest ES2020 features.

<include src="asides/JavascriptAtAuth0" />

## Summary

At the end of this quick journey, you learned the new amazing features you can use in JavaScript. Although the final specifications will be approved in June, you do not have to wait. Most popular JavaScript environments are ready. You can use them right now!


JavaScript: What's New in ECMAScript 2020

Learn about the new Composition API in Vue 3 and how it compares to the Options API



The long-awaited [Vue.js 3](https://vuejs.org/) is scheduled for release in the 1st quarter of 2020. The announcement of a new API, the Composition API, resulted in some [controversy in the Vue community](https://www.reddit.com/r/vuejs/comments/c319el/vue_3_will_change_vue_in_a_big_way_current_syntax/). It has since simmered down, but what is the Composition API anyway?

Although Vue 3, in its entirety, hasn't been released yet, the Composition API is already out and ready to use. In this article, we'll take a look at why the Composition API was introduced, how it works, and how it compares to the options-based API. At the end, we'll build two versions of the same component: one with the Composition API and one with the options-based API!

![Vue 3 Composition API vs Options API](https://images.ctfassets.net/23aumh6u8s0i/4iCUUq6ilCnIyOwPWQEVaI/c6621244683eef1b975f3c54391343f6/vue-3-composition-api-vs-options)

## What is the Composition API

Just to get the obvious concern out of the way, this new API **will not break** current Vue 2.x options-based code! We can even continue to use the Options API in Vue 3. The Composition API is just an addition to the language that was created to address the limitations of the Options API used in Vue 2. We'll touch on those limitations in the next section.

For now, let's talk about *what* it is.

Evan You, the creator of Vue, has described the Composition API as a **reactive API coupled with the ability to register lifecycle hooks using globally imported functions**. This is a little hard to digest, but the main point is that the Composition API provides a different way to manage reactivity at all points in an application, without compromising organization and readability.

At the root of it, the Composition API isn't really adding anything new to the language. Instead, think about it this way: it's exposing some of the internal functions (aka, magic) that Vue already uses, allowing us to use these functions directly in components.

<include src="TweetQuote" quoteText="The Vue 3 Composition API makes Vue internal functions available for use in your Vue applications."/>

> [Adam Wathan](https://twitter.com/adamwathan) has an excellent podcast called [Full Stack Radio](http://www.fullstackradio.com/). If you're interested in learning more about the Composition API and Vue 3 in general, I'd highly recommend checking out [Episode 129: Evan You &mdash; What's Coming in Vue.js 3.0](http://www.fullstackradio.com/129), where Adam talks in-depth about the Composition API with [Evan You](https://twitter.com/youyuxi).

<AmpContent>
    <include src="TweetQuote" quoteText="New @fullstackradio is out! I talk to @youyuxi about all of the features and changes coming in Vue.js 3.0 🎉 Super deep-dive with lots of technical discussion, brace yourself! 😄"/>

</AmpContent>

<NonAmpContent>

  <blockquote class="twitter-tweet"><p lang="en" dir="ltr">🚀 New <a href="https://twitter.com/fullstackradio?ref_src=twsrc%5Etfw">@fullstackradio</a> is out!<br><br>I talk to <a href="https://twitter.com/youyuxi?ref_src=twsrc%5Etfw">@youyuxi</a> about all of the features and changes coming in Vue.js 3.0 🎉<br><br>Super deep-dive with lots of technical discussion, brace yourself! 😄<a href="https://t.co/zz9UIA96XE">https://t.co/zz9UIA96XE</a> <a href="https://t.co/cQlfyGQ5RG">pic.twitter.com/cQlfyGQ5RG</a></p>&mdash; Adam Wathan (@adamwathan) <a href="https://twitter.com/adamwathan/status/1199648232420364288?ref_src=twsrc%5Etfw">November 27, 2019</a></blockquote> <script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>

</NonAmpContent>

## Why the Change?

Before we jump into the comparison, let's look at some of the pain points in Vue 2 that the Composition API aims to solve.

### Better extensibility and organization

One major concern among developers was that their Vue projects became hard to manage as they grew in size and complexity.

In Vue 2.x, components are organized using options such as `data`, `mounted`, `methods`, etc. Because of this, logic isn't really grouped by feature, which can make it hard to read through a large and complex file. Readers would often have to scroll back and forth to follow what's going on. Another downside of this organization is that it made logic reuse difficult, as features are split up unintuitively in a component.

The [Composition API RFC includes this excellent diagram](https://vue-composition-api-rfc.netlify.com/#code-organization) showing the flow of different concerns in the same component built with both the Options API and Composition API. Each color represents a different logical concern. As shown, using composition functions with the Composition API allows for better organization in components.

![Vue 3 Composition API vs Options API code structure](https://images.ctfassets.net/23aumh6u8s0i/7E7YcG8WeU1RzSicIp5p50/9e07fbb2098fa81496f5e9ca4f3c8e62/vue-3-composition-vs-options-organization)

### Better TypeScript support

The next issue with Vue 2.x was that the sometimes confusing nature of `this` inside components often made it difficult to use TypeScript. The Options API relies on a lot of "magic" from the Vue compiler.

The Composition API, however, uses those internal functions directly, so `this` behaves as expected in JavaScript. This allows for much better TypeScript support when using the Composition API.

## Options API vs. Composition API

The best way to understand the changes is to see it in action.

Let's build out a simple component that allows the user to add two numbers with the press of a button. First, we'll quickly review how that would be done with the options-based API. Then we'll rebuild that same component with the Composition API to illustrate the differences.

![Vue 3 Composition API sample application](https://images.ctfassets.net/23aumh6u8s0i/6y4oOSD5MuurfOLNZ1ddJg/983b6510894c2974a18ce113550e7b06/vue-3-composition-api-app)

### Building with Options API

Here's what we'll need to create the simple addition calculator pictured above:

* **3 variables** &mdash; 1st number to add, 2nd number to add, sum
* **2 input boxes** &mdash; 1st number to add, 2nd number to add
* A **method** to add the two numbers together

And here's how it's done in Vue 2:

``` html  

<template>
    <div class="add">
        <h3>Addition Calculator</h3>
        <form id="sum">
            <input type="text" class="form-control" v-model="num1">
            <input type="text" class="form-control" v-model="num2">
            <button @click="addNumbers" type="button" class="btn btn-light">
                Add me!
            </button>
        </form>
        <p><strong>Sum:</strong> {{ sum }}</p>
    </div>
</template>
<script>
export default {
    name: 'Add',
    data() {
        return {
            num1: 0,
            num2: 0,
            sum: 0
        };
    },
    methods: {
        addNumbers: function () {
            this.sum = parseInt(this.num1) + parseInt(this.num2);
        }
    }
}
</script>
<style scoped>
    .add {
        background: #d67182;
        box-shadow: 1px 3px 6px #a3a3a3;
        padding: 50px 30px;
        width: 300px;
        text-align: center;
        margin: 80px auto;
    }
    p, h3 {
        color: #FFFFFF;
    }
    #sum {
        margin-top: 25px;
    }
    .form-control {
        margin-bottom: 15px;
    }
    .btn {
        margin-bottom: 30px;
    }
</style>

```

> **Note**: We can use `computed` here instead of `addNumbers` to get the value for `sum` and forego the button altogether. However, we're just going to put it into a separate method to demonstrate how functions and code structure works in the Composition API.

With the Vue 2 options-based API, we have our reactive data object returned in the `data()` function. Then the `AddNumbers()` function will be registered in the `methods` property. To access the variables from `data()`, we must use `this`.

Now, `this` is nested inside the method, so it should refer to the method's object instead of the entire instance, but it doesn't. Vue is working behind the scenes here to handle this for us. In general, this is pretty straightforward and intuitive, but in more complicated cases, this behind the scenes handling can cause unexpected behavior of `this`.

This "magic" is also part of what has made TypeScript support tough in Vue 2. Now let's look at how this same component is built with the Vue 3 Composition API.

### Building with Composition API

To keep this short, we'll just focus on building the component here. If you'd like to practice with the Composition API and rebuild this on your own, the Composition API can be added into a new Vue 2 project by running the following in your terminal:

```
vue create project-name
npm install @vue/composition-api 
```

Then in the `main.js` file:

```js
import Vue from 'vue';
import VueCompositionApi from '@vue/composition-api';

Vue.use(VueCompositionApi);
```

> For more information on this, check out the [official Vue Composition API repo](https://github.com/vuejs/composition-api).  

Now onto the final act 🎩! Let's rebuild the addition component using the Composition API. We're going to exclude the `<style>` section because nothing changes there. 

``` html  

<template>
    <div class="add">
        <h3>Addition Calculator</h3>
        <form id="sumComp">
            <input type="text" class="form-control" v-model="num1">
            <input type="text" class="form-control" v-model="num2">
            <button @click="addNumbers" type="button" class="btn btn-light">
            Add me!
        </button>
        </form>
        <p><strong>Sum:</strong> {{ sum }}</p>
    </div>
</template>
<script>
import { ref } from '@vue/composition-api';
export default {
    name: 'AddComposition',
    setup() {
        let num1 = ref(0);
        let num2 = ref(0);
        let sum = ref(0);
        function addNumbers() {
            sum.value = parseInt(num1.value) + parseInt(num2.value);
        }
        return {
            num1,
            num2,
            sum,
            addNumbers
        }
    }
}
</script>

```

First, we're importing the functions we need to use from the Composition API at the top. In this case, that's just `ref`.

Next, notice that everything is now inside a `setup()` function. Any functions or properties that need to be used in the template should go in `setup()` since this is how they're returned to the template.

Inside `setup()`, the reactive variables we're using are defined at the top as standalone variables, as opposed to a return object in the `data()` function.

The function `addNumbers()` is also hanging out on its own instead of nested in the `methods` property. We can now easily reuse our functions across component instances, which will significantly improve the readability of large codebases. Notice also that `this` is no longer needed to reference variables! Using the Composition API functions directly instead of through [Vue component options](https://012.vuejs.org/api/options.html) removes the `this` magic that was occurring behind the scenes.

Finally, we're returning the functions and properties to the template.

#### Reactivity: ref vs reactive

One new thing here is the use of `ref` in the variables, e.g., `let num1 = ref(0)`. This is how we're making our variables reactive! There are two functions that can be used to handle state and reactivity: `ref` and `reactive`.

**`ref()`**

`ref`, as shown in this example, takes a value and returns a reactive reference object. This object has a single value: `.value` that points to the value provided. Notice the use of `.value` on the variables in the `addNumbers()` method.

Refs can be created directly, as we've done here, or by using `computed()`.

The `computed()` getter function will return an immutable (can't be changed) `ref` object thats value can be accessed with `.value()`. It can also accept an object with a setter function to make it mutable if necessary.

Earlier, we mentioned that it would be better to find the sum of the numbers with `computed()`, but we kept it in the method for demonstration's sake.

Here's how it would be done using `computed()`:

```js
let sum = computed(() => parseInt(num1.value) + parseInt(num2.value));
```

Make sure to add `computed` to the import at the top as well:

```js
import { computed } from '@vue/composition-api';
```

> **Note**: Because `computed()` creates a ref, it can be used with [primitive values](https://developer.mozilla.org/en-US/docs/Glossary/Primitive) as well. Normally the primitive value would get lost because primitives (essentially non-object values, such as a number) are passed by value, not reference. `ref`, however, will wrap the value and create an object. The value of the object can be referenced with `ref.value`. And then, when the `computed()` value changes, `ref.value` will change as well.

**`reactive()`**

The next way to handle reactivity is by using `reactive`. This is equivalent to `Vue.observable()` from Vue 2.x. It accepts an object and returns a proxy to that object that will be tracked. In this example, we're using `ref` for reactivity, but we could easily use `reactive` instead, like so:

```js
let state = reactive({ 
    num1: 0,
    num2: 0,
    sum: 0
})
```

If done this way, then `addNumbers()` would change to:

```js
function addNumbers() {
    sum = parseInt(num1) + parseInt(num2);
}
```

This was a very simple example of a component built with the Composition API, but hopefully it has demonstrated how the new API can lead to better code organization and less "magic".

While waiting for Vue 3 to come out, why not experiment with **adding authentication to your Vue 2 application**? Follow the example below to add authentication to a Vue.js + Node.js application or check out [this beginner tutorial to build an events showcase app using the Vue Options API](https://auth0.com/blog/beginner-vuejs-tutorial-with-user-login/). Remember, the Options API will still be useable in Vue 3, so there's no harm at all in starting with Vue 2 now. 

<include src="asides/Vue" />

## Summary

We've now gone over what the Composition API is, why it was necessary, and how you can build a component using it. The Composition API is already published and ready to use, so make sure you go [check it out on GitHub](https://github.com/vuejs/composition-api)! Let me know below if you'll be trying out the Composition API or sticking to the options-based API. Thanks for reading!

---


Getting Started with Vue 3: Composition API

Learn about the new features and products in the recent Laravel 6.0 release.

"whats-new"