DEV Community: Célien Boillat🇨🇭

ELI5 - Primitive data types in programming

Célien Boillat🇨🇭 — Tue, 06 Apr 2021 07:40:38 +0000

Introduction

New ELI5 series

Welcome to this first post of the new ELI5 series where I'm teaching myself various topics centered around coding and development in general and then explaining them to you in the most simple way for you to understand.

The Pretender

"Keep you in the dark, you know they all pretend".

I certainly was one of those people and I was embarrassed by it.

Primitive data types were the kind of simple programming concepts I did not learn in school and couldn't be bothered to look into until I stumbled over that particular term over and over when learning more advanced stuff like front-end frameworks.

There is no shame in not knowing everything but you can't keep procrastinating and pretending like you know when you do not.

What are primitive data types?

First, primitive data types are not data types that have not been properly civilized which would not make any sense anyway.

Fundamental building blocks

Primitive data types or primitive types as they are often called, are the basic building blocks of all programming languages. You could see them as simple bricks. A brick in itself is not of much use unless you are a rioter. But by assembling a multitude of those simple bricks, you can build a wall, which is still very basic but already much more useful than a single brick. You could then go on and build multiple walls and connect them together to eventually build a house which we humans have been doing for thousands of years.

That is exactly what we are doing as developers/programmers/engineers when we write code and manipulate data to get something useful out of it.

What characterizes primitive data types

Primitive data types are built-in types provided by a programming language, such as PHP and JavaScript as their basic building blocks as previously explained. They:

Are provided by the programming language
Have built-in support
Hold simple values like characters and numerics although some objects compositing primitive values can also be considered primitives themselves
Are the fastest language constructs
In most languages, they cannot be extended

Primitive types in PHP

Although PHP is a weakly typed language, it still uses types behind the scenes, even if you're not actively typing your variables.

Primitive data types in PHP include:

Strings (string) like "C" and "I love PHP"
Booleans (bool) like true and false
Integers (int) like 0, 1, 999, -1 etc...
Floating-point numbers (float) like 19.95 and 10.00

Those first four are in a subdivision called scalar types.

The next subdivision is called compound types:

Arrays ([]) like ["Elon", "Jordan", "Tanya"] and [1, 2, 3, -1, 999]
Objects ({}) like { first_name: "Elon", last_name: "Musk", hobby: "Trolling Twitter" }
Callable
Iterable

The last two I will not explain as they would require an entire article to do so, but I provided you with a link to the PHP documentation if you're interested.

Primitive types in JavaScript

JavaScript is also a weakly typed language like PHP.

Primitive data types in JavaScript include:

Strings (String) like "C" and "Why isn't this TypeScript?"
Numbers (Number) like 0, 1, -1, 999 but also 19.95 and -10.00
Booleans (Boolean) like true and false
Big Integers (BigInt) like 9007199254740991 and 0x1fffffffffffff which is a special notation
Symbols

The last one is a bit peculiar, so I provided you a link to the documentation if you're interested in it.

Closing word

That's the end of this short article and I hope you could learn something. There is of course much more to learn about primitive data types, of course, depending on the languages you use but that's the gist of it.

Resources

Debug your Laravel Application efficiently with Laravel Telescope

Célien Boillat🇨🇭 — Wed, 03 Mar 2021 19:07:06 +0000

What does Telescope do?

Laravel Telescope is an official Laravel package that's meant to help you debug a Laravel app locally.

While its main use is for debugging in a local environment, it can also be used in production.

Use cases

Inspect incoming requests
Inspect database queries for optimization and look out for the dreaded N+1
Preview mailables locally instead of actually sending them to a third party service like Mailtrap.io
Visualize dumped data without killing the page
Debug caching issues
View logs

And much more. Take a look at the official documentation for more info.

Intro

First, we need an existing Laravel application.
For sake of brevity, I'm just going to provide a link to the documentation instead.

Telescope can be used both locally while developing and in production, but the steps are a little different for each use case.

Use Telescope locally and in production

The installation to use Telescope both locally and in production is the shortest one.

Be warned that running Telescope in production might impact your app's performance. Disabling the watchers you don't absolutely require is advised.

Installation

First, head to the terminal and add Telescope to the project:

composer require laravel/telescope

Once Telescope has been successfully added to the project, publish its assets using the Artisan command:

php artisan telescope:install

That's it! Telescope is now installed and is ready to go.

In production, the number of entries saved to the database can become huge very rapidly, depending on your site's traffic. That's why you should be pruning data regularly with a scheduled Artisan command.

You can find out more about this subject in the official Telescope documentation.

Use Telescope for local development only

Installing Telescope locally for development only is also possible if you don't need it in production.

While you won't have any data for your production app, this use case has the benefit of not causing any performance hit to your app.

Installation

As for the installation for use in production, let's head to the terminal and add Telescope to the project using Composer:

composer require laravel/telescope --dev

Then we can publish Telescope's assets using Artisan:

php artisan telescope:install

And finally run the migrations:

php artisan migrate

Register the service provider manually

Remove the Telescope service provider registration from the application's config/app.php configuration file:

'providers' => [
    /*
     * Application Service Providers...
     */
    // ...
    // Remove the line below
    App\Providers\TelescopeServiceProvider::class,
],

This is done so Laravel doesn't register Telescope when it registers its other service providers in production.

/**
 * Register any application services.
 *
 * @return void
 */
public function register()
{
    if ($this->app->environment('local')) {
        $this->app->register(\Laravel\Telescope\TelescopeServiceProvider::class);
        $this->app->register(TelescopeServiceProvider::class);
    }
}

That registers the TelescopeServiceProvider from the vendor directory and then the one that's configured for you app.

Finally, the Telescope package should not be auto-discovered by Laravel.

Add Telescope's package to the dont-discoverarray in the composer.json file to ignore it when running Composer install and update commands in production:

"extra": {
    "laravel": {
        "dont-discover": [
            "laravel/telescope"
        ]
    }
},

Dashboard & authorization

To access Telescope's dashboard, you can visit your-app.test/telescope.

By default, the dashboard is only accessible in a local environment.

For production environments though, you need to specify which users are allowed to access the dashboard as it is protected by an authorization gate.

You can authorize users in your app's TelescopeServiceProvider.php file:

/**
 * Register the Telescope gate.
 *
 * This gate determines who can access Telescope in non-local  environments.
 *
 * @return void
 */
protected function gate()
{
    Gate::define('viewTelescope', function ($user) {
        return in_array($user->email, [
            // taylor@laravel.com
        ]);
    });
}

You don't need to specify any authorized user in a local environment as anyone is allowed, even unauthenticated.

Configuration

All of Telescope's configuration options can be found in its configuration file inside the app's config folder.

Be sure to review this file thoroughly to configure Telescope to your specific need.

While not in the config file itself, you can toggle Telescope's dark mode in your app's TelescopeServiceProvider.php file.

Upgrading Telescope

As stated in the official documentation, you should always review the changes when upgrading to a major version.

Re-publish Telescope's assets after upgrading:

php artisan telescope:publish

This process can also be automated by adding the last command into the post update scripts array in the composer.json file:

{
    "scripts": {
        "post-update-cmd": [
            "@php artisan telescope:publish --ansi"
        ]
    }
}

Diving deeper

This guide only covers installing and getting started with Laravel Telescope. There are a lot more subjects to cover like tags, watchers, etc.

Be sure to always review the official documentation.