DEV Community: HappyToDev

🇫🇷 Framework Heroes News : la veille sur les frameworks pour la semaine 2024/40

HappyToDev — Tue, 08 Oct 2024 16:14:19 +0000

Edito

Et voici, votre condensé de la veille sur les frameworks de la semaine 40, du 30 septembre au 06 octobre 2024.

Pour cette première semaine d'octobre, les contributeurs de Framework Heroes n'ont pas chômé.

Catégorie Games

Godot XR Update - October 2024

Cet article détaille les avancées dans le support XR de Godot, incluant des améliorations en suivi de mouvement, pass-through, et la collaboration avec Meta pour optimiser l'expérience sur les appareils Quest.

Lire l'article

Catégorie web

Security Tip : Auto-secure Cookies FTW

Où on y découvre que Laravel a mis à jour le comportement des cookies pour qu'ils soient automatiquement sécurisés en correspondant au protocole de la requête (HTTP/HTTPS).

Lire l'article

A Guide to Laravel Pipelines | Ash Allen Design

où l'on apprends comment utiliser la classe Pipeline de Laravel pour décomposer des flux de travail complexes en processus isolés et ciblés, facilitant ainsi la gestion et le test des pipelines dans les applications Laravel.

Lire l'article

LangCountry launches v4

La version 4 de Laravel LangCountry introduit des macros Carbon pour une mise en forme directe des dates selon les spécifications linguistiques et géographiques.

Lire l'article

Laravel Roundup - October

Le "Laravel Roundup" d'octobre couvre les dernières nouvelles et mises à jour dans la communauté Laravel, incluant des outils, des packages récemment publiés, et des événements comme des meetups.

Lire l'article

Lunar - Headless E-Commerce for Laravel

Lunar est un package open-source pour Laravel qui introduit des fonctionnalités de commerce électronique headless modernes.

Lire l'article

Laravel Form Request and Data Validation Tutorial

Cet article explore comment utiliser les Form Requests de Laravel pour gérer la validation des données et l'autorisation dans une application web.

Lire l'article

Laravel Herd v1.11 Adds Forge Integration, Dump Updates, and More

La version 1.11 de Laravel Herd introduit une intégration avec Laravel Forge, des améliorations pour le débogage, et permet le partage de configurations de projet.

Lire l'article

Security Tip: Stop Using MD5 and SHA-1!

Cet article recommande d'arrêter d'utiliser les algorithmes MD5 et SHA-1 pour des raisons de sécurité, suggérant plutôt l'adoption de solutions plus sécurisées et performantes pour la vérification d'intégrité et la cryptographie.

Lire l'article

React Best Practices Every Developer Should Know

Cet article présente une compilation des meilleures pratiques pour les développeurs React, visant à améliorer la qualité et la maintenabilité du code.

Lire l'article

Building a Google Meet Clone with Next.js and Tailwind CSS - Part Two

Cet article explore la deuxième partie de la création d'un clone de Google Meet, en utilisant Next.js pour la structure et Tailwind CSS pour le style, avec l'intégration de fonctionnalités comme le chat et le partage d'écran.

Lire l'article

Introduction to Laravel Data V3

Cet article introduit la version 3 du package Laravel Data de Spatie, qui simplifie la création et la gestion des objets de données dans Laravel.

Lire l'article

Serverless Search with Laravel and Typesense

Cet article explore comment intégrer une fonctionnalité de recherche serverless dans une application Laravel en utilisant Typesense pour une recherche rapide et efficace.

Lire l'article

Laravel Auth Routes Tutorial

Ce tutorial explique comment configurer et utiliser les routes d'authentification fournies par Laravel pour gérer l'inscription, la connexion et la réinitialisation de mot de passe des utilisateurs.

Lire l'article

Et voilà pour les news de la semaine passée.

N'oubliez pas que Framework Heroes est fait pour vous et par vous. À ce titre, il a besoin de votre participation.

Comment ?

Simplement en venant partager de temps à autres des news sur vos frameworks préférés.

Newsletter "What's up devs ?" is born !

HappyToDev — Sun, 16 Jun 2024 21:35:38 +0000

Hi devs,

You may know that I publish a weekly French dev newsletter called "Quoi de neuf les devs ?".

But today, I'm delighted to announce that its English version is born.

It's called "What's up devs?" and it's in the same spirit as its French sister: to give you the latest development news every week.

I'll try to keep the same rhythm as the French version, so I'll publish it every Friday. Occasionally, the newsletter may be published on Saturday, depending on how tired I am ;-)

So I leave you with this newsletter, which I'm very proud to present to you.

I hope you enjoy reading it as much as I enjoyed writing it.

Don't hesitate to give your opinion on the topics and content. I'll be reading your comments very carefully to improve this newsletter.

In this first issue, we'll be talking about

✅ Go,
✅ PostgreSQL,
✅ CSS,
✅ HTTP/3,
✅ Laravel,
✅ Python,
✅ SQLite
and much more...

Take care and see you next friday !!

LinKeeper - Lesson 03 - Tests and ressources

HappyToDev — Sun, 28 Apr 2024 08:56:38 +0000

In this episode, we're going to take FilamentPHP a step further.

But first, we're going to set up our testing environment.

To do this, we're going to use PestPHP. PestPHP is already present because it was installed at the same time as Laravel.

To get to grips with Pest, we're going to create two very simple tests. Once we have the basics down, we can develop the rest of our application based on the tests.

What we'll be looking at today :

Prior configuration of Pest
- Using SQLite for testing
- Refresh the database for each test
- Load a default account before each test
- Remove the tests provided by default by PestPHP
Checking the administration home page
- Running the test
- Correct the 403 error
- Run the test again
Testing the user profile
- Run the tests
a user can see the list of links associated with them
- Let's create our tests for the Links page
- Let's create the Links page
Conclusion

Prior configuration of Pest

Using SQLite for testing

In order to separate your application's database from the one used for testing, we're going to modify the phpunit.xml file located at the root of your project.

Simply uncomment the following two lines:

        <!-- <env name="DB_CONNECTION" value="sqlite"/> -->
        <!-- <env name="DB_DATABASE" value=":memory:"/> -->

        <env name="DB_CONNECTION" value="sqlite"/>
        <env name="DB_DATABASE" value=":memory:"/>

This will allow Pest, which is a PHPUnit overlay, to use SQLite as its database engine and use it directly in memory.

Refresh the database for each test

Load a default account before each test

We're going to be doing a lot of work with FilamentPHP administration. So to avoid repeating for each test that we want to connect with a registered user, we'll simply tell Pest that for each test, it will act as if it were connected with the user with id #1.

To make this user ex

To do this, we'll edit the tests\TestCase.php file and add the following setUp function:


    protected function setUp(): void
    {
        parent::setUp();

        $this->actingAs(User::find(1));
    }

So before each test is run, the actingAs function will define the user with id #1 as the logged-in user. Here it's my HappyToDev account.

Remove the tests provided by default by PestPHP

When you install Pest, it provides you with two default tests:

tests\Feature\ExampleTest.php
tests\Unit\ExampleTest.php

You can delete them or keep them for inspiration.

Checking the administration home page

In this test, we'll go to the /admin page to check that

an HTTP 200 code is received
we can see 'Dashboard' on the page
we can see the name of our application 'LinKeeper' on the page

We'll start by creating a test file using Artisan.

php artisan pest:test GeneralAdminPageTest

By default, the tests created will be stored directly in the tests\Feature directory.

Here are the contents of the file :

<?php

use Illuminate\Support\Facades\Config;

it('can view admin page', function () {
    $response = $this->get('/admin');

    $response
        ->assertStatus(200)
        ->assertSee('Dashboard')
        ->assertSee(Config('APP_NAME'));
});

Explanation:

We ask for get access to the /admin page and we get the response.

In this response, we check that we do indeed have an HTTP 200 code, that in the HTML code returned we do indeed have the word Dashboard and that we do indeed see the name of the application defined in our .env file, in this case LinKeeper. To do this, use the config() helper.

Running the test

To run the test, at the root of your project, run the following command:

./vendor/bin/pest

Normally you should get a 403 error, so your test will not pass.

Correct the 403 error

To correct this, you need to read the FilamentPHP documentation which indicates that when you go into production, you need to modify the User model to avoid hitting a wall with the 403 error.

I'll leave it to you to implement the necessary changes so that your test can pass.

If you encounter the slightest difficulty, let me know in the comments.

Run the test again

If you have correctly made the changes requested in the documentation, you should get this result when you run your tests.

Testing the user profile

We saw in lesson 2 that we normally have access to the user's profile. Let's set up a test to check this.

php artisan pest:test UserProfileTest

and add the following code:

it('has user profile page', function () {
    actingAs(User::find(1))->get('/admin/profile')
    ->assertStatus(200)
    ->assertSee('Profile')
    ->assertSee('Save changes');
});

This will allow us to check that when I'm logged in with the user with id #1 (my user) I do indeed get an HTTP 200 code when I go to the /admin/profile page and I can see the words: 'Profile' and 'Save changes'.

This is a very simple test, but it validates that the user does indeed have access to this page.

Run the tests

As before, run the appropriate command in your terminal:

./vendor/bin/pest

and you should get the following result:

Now that we've taken our first steps with tests, we'll be able to take a test-driven development approach using PestPHP throughout this project.

a user can see the list of links associated with them

This is the next stage in the development of our application.

As we are using FilamentPHP for the backend, a number of features are being developed by the FilamentPHP teams and the aim here will not be to test how well Filament works as I have no doubt that this has been tested extensively.

To view the list of links, the user will have a Links link in the dashboard menu and this link, by FilamentPHP convention, will lead to an admin/links address.

Let's create our tests for the Links page

Let's create a new test, using artisan :

php artisan pest:test PageLinksTest

First of all, we want to make sure that the page is accessible.

To do this, we're going to add the following code to our PageLinksTest file:

it("can access the user's links page and see 'Links' on the page", function () {
    $response = $this->get('/admin/links');

    $response
        ->assertOk()
        ->assertSeeText('Links');
});

This code will ask PestPHP to load the /admin/links page and to check firstly that the page returns the HTTP code 200 and then to ensure that the word 'Links' is present in the page.

You can run the tests with the --filter option to execute only the test that matches the regex passed in parameter (see doc). For example with :

./vendor/bin/pest --filter "links page"

PestPHP will only run our last test because 'links page' is present in its description.

This avoids having to run all the tests each time, especially when you have to iterate several times when setting up your test.

The test fails and that's normal because the Links page doesn't exist at the moment.

But now that the test is here and has failed, it tells us exactly what to do:

Expected response status code [200] but received 404.

We were expecting an HTTP 200 code and instead we get a 404, which means that the requested page doesn't exist.

We simply need to create it.

Let's create the Links page

The 'Links' page will be a FilamentPHP administration page. It will therefore be a resource.

If I take the definition from the tutorial provided with PestPHP :

In Filament, resources are static classes used to build CRUD interfaces for your Eloquent models. They describe how administrators can interact with data from your panel using tables and forms.

We therefore understand that each Eloquent model will be associated with a resource in FilamentPHP.

It is therefore time to create our resource associated with our Link model, which is itself linked to our 'links' table in our database.

php artisan make:filament-resource Link

In our application tree, under app/Filament/Resources, we can see a LinkResource directory and a LinkResource.php file.

The LinkResource directory itself has a Pages sub-directory which contains the CreateLink.php, EditLink.php and ListLinks.php files. We'll talk about these later in this tutorial, so don't worry about these extra files for now.

FilamentPHP, via this Artisan command, will generate the following skeleton for you:

<?php

namespace App\Filament\Resources;

use App\Filament\Resources\LinkResource\Pages;
use App\Filament\Resources\LinkResource\RelationManagers;
use App\Models\Link;
use Filament\Forms;
use Filament\Forms\Form;
use Filament\Resources\Resource;
use Filament\Tables;
use Filament\Tables\Table;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\SoftDeletingScope;

class LinkResource extends Resource
{
    protected static ?string $model = Link::class;

    protected static ?string $navigationIcon = 'heroicon-o-rectangle-stack';

    public static function form(Form $form): Form
    {
        return $form
            ->schema([
                //
            ]);
    }

    public static function table(Table $table): Table
    {
        return $table
            ->columns([
                //
            ])
            ->filters([
                //
            ])
            ->actions([
                Tables\Actions\EditAction::make(),
            ])
            ->bulkActions([
                Tables\Actions\BulkActionGroup::make([
                    Tables\Actions\DeleteBulkAction::make(),
                ]),
            ]);
    }

    public static function getRelations(): array
    {
        return [
            //
        ];
    }

    public static function getPages(): array
    {
        return [
            'index' => Pages\ListLinks::route('/'),
            'create' => Pages\CreateLink::route('/create'),
            'edit' => Pages\EditLink::route('/{record}/edit'),
        ];
    }
}

Let's not worry about that for the moment. But let's run our test again:

./vendor/bin/pest --filter "links page"

We can see that this time our test is green.

If we go to the admin/links page, we can see that the page does exist (HTTP code 200) and that it does indeed say 'Links'. This is why our test turns green.

However, we soon realise that something isn't quite right. There seem to be records but nothing is visible in the table that shows us the links.

This is normal, we'll need to configure our resource file.

Conclusion

We'll stop here for episode 3.

In this chapter, we started doing TDD for our application development and touched on resources in FilamentPHP.

In the next episode, we'll continue our testing strategy with PestPHP and get to know FilamentPHP's resources better.

As usual, I look forward to your comments below.

See you soon.

Linkeeper - Lesson 02 - Start playing with Filament

HappyToDev — Wed, 10 Apr 2024 16:15:15 +0000

Ok, now your application is set.

We can dive in something more concrete.

an user can signin, login, logout and manage his account
a link has a name, a status (published or not) and obviously a link
- Let's think about table schema
- Let's migrate
- Define model and relationship
- We need fake datas to plays with
  - The factories
  - The seeder

What we need to manage our links.

Remember what I said in the first part :

an user can signin, login, logout and manage his account

a user can see a list of their links

an user can add, edit or delete a link

an user can have a shareable link to share his links with the world

a link has a name, a status (published or not) and obviously a link. May be we will add some options later.

an user can signin, login, logout and manage his account

This is done with Filament. In fact, no completely, we can login, logout but not register or even manage our own account.

But, you will see it's very easy to add register and profile page for users.

In app/Providers/Filament/AdminPanelProvider.php

you have to add only 2 lines under login() function call to implement both functionnalities :

class AdminPanelProvider extends PanelProvider
{
    public function panel(Panel $panel): Panel
    {
        return $panel
            ->default()
            ->id('admin')
            ->path('admin')
            ->login()
            // Lesson 2 : here we add registration and profile page
            ->registration() // registration
            ->profile()      // profile management
            ->colors([
                'primary' => Color::Amber,
            ])
            ->discoverResources(in: app_path('Filament/Resources'), for: 'App\\Filament\\Resources')
            ->discoverPages(in: app_path('Filament/Pages'), for: 'App\\Filament\\Pages')
            ->pages([
                Pages\Dashboard::class,
            ])
            ->discoverWidgets(in: app_path('Filament/Widgets'), for: 'App\\Filament\\Widgets')
            ->widgets([
                Widgets\AccountWidget::class,
                Widgets\FilamentInfoWidget::class,
            ])
            ->middleware([
                EncryptCookies::class,
                AddQueuedCookiesToResponse::class,
                StartSession::class,
                AuthenticateSession::class,
                ShareErrorsFromSession::class,
                VerifyCsrfToken::class,
                SubstituteBindings::class,
                DisableBladeIconComponents::class,
                DispatchServingFilamentEvent::class,
            ])
            ->authMiddleware([
                Authenticate::class,
            ]);
    }
}

Go back to your login page : http://linkeeper.com/admin/login and you will see

that the link for signup has been added.

If you login, you will see under your menu the new sub menu 'Profile'

It allows you to edit your nickname, your e-mail address and change your password.

So, after this very cool step we can check the first functionnality :

✅ an user can signin, login, logout and manage his account

an user can add, edit or delete a link

an user can have a shareable link to share his links with the world

a link has a name, a status (published or not) and obviously a link. May be we will add some options later.

a link has a name, a status (published or not) and obviously a link

I know it is not in the order of the list, but first it's me writing, second I need to define table links and its fields before an user can add link, right ?

So let me do this ! 🤣

Let's think about table schema

Ok, what will be the fields in our table links ?

Of course an id, an url, a short description, a published status (published or not), a user_id foreign key and finally the classicals created_at and updated_at.

The user_id is to define the relationship between a user and a link.

In fact, we can resume this relation by :

a user can have 0, 1 or many links
a link (unique by its id) belongs to one and only one user

This is why we use a one-to-many relationship.

What do you thing, is something missing ? Tell me in the comment if you think I forgot something.

Ok, now we have to prepare the migration for links table.

php artisan make:migration create_links_table

Now we have to edit this migration to add fields to the table. So, let's edit the migration file

<?php

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    /**
     * Run the migrations.
     */
    public function up(): void
    {
        Schema::create('links', function (Blueprint $table) {
            $table->id();
            $table->string('url');
            $table->string('description', 255)->nullable();
            $table->boolean('published')->default(false);
            $table->foreignId('user_id')->constrained('users')->onDelete('cascade');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     */
    public function down(): void
    {
        Schema::dropIfExists('links');
    }
};

Let's migrate

Ok, it's time to migrate. For that, we can use (again) Artisan.

php artisan migrate

Remember if you make something wrong or you want to modify immediately the schema, you can rollback your migration with :

php artisan migrate:rollback

And if you want to see the status of your migrations, you can use :

php artisan migrate:status

Look at this screenshot captured before running the last migration.

We can see two things :

first the migration for the links table was not run already
second the three first migrations was launched in the same sequence : the sequence number [1]

Define model and relationship

The next step is to define the Link model and adapt User model.

We will use again Artisan :

php artisan make:model Link

Now we have to tell the model that a link belongs to an user.

Add this function to the model class Link:

    public function user()
    {
        return $this->belongsTo(User::class);
    }

To finish with the model, we have to update the model User by adding it a function links

    public function links()
    {
        return $this->hasMany(Link::class);
    }

We need fake datas to plays with

After defining our database schema, let's do something very important.

Create fake datas to play with. Please do not use production datas from your database during development.
For many reasons such as ethics, confidentiality and security. We are professionals, so let's act accordingly.

The factories

By default Laravel comes with User factory, so we just need to create a Link factory.

php artisan make:factory Link

In the generated definition function we put this code :

    public function definition(): array
    {
        return [
            'url' => fake()->url(),
            'description' => fake()->sentence(5),
            'published' => fake()->boolean(80),
        ];
    }

Factories use Faker to generate fake datas but very close to real datas.

In this code, we generate :

an url
a description based on a sentence of 5 words. In fact, as I let the second parameter of sentence method by default (true), sentence will generate sentences with approximately 5 words. It could be four, five, six or even seven words.
true or false for the published field with a minimum true percentage of 80%

The seeder

Laravel comes with database/seeders/DatabaseSeeder.php

We have to edit it to use our factory.

Here it is the code :

    /**
     * Seed the application's database.
     */
    public function run(): void
    {
        User::factory()->create([
            'name' => 'Happytodev',
            'email' => 'happytodev@gmail.com',
            'email_verified_at' => now(),
            'password' => Hash::make('Password*'),
            'remember_token' => Str::random(10),
        ]);

        User::factory()
            ->count(10)
            ->create()
            ->each(function ($user) {
                Link::factory()
                    ->count(rand(2, 10))
                    ->create(['user_id' => $user->id]);
            });
    }

Some explanations :

First I create my own user to connect easily each time with my own email
Second part does this
- create 10 fake users
- for every user create between 2 and 10 links, during the creation we told that the user_id fiels must be filled with the current created user->id.

And now, the magic could begin.

Let's go back in your terminal, and launch simply this command :

php artisan db:seed

Go into your DB viewer, and check the tables users and links.

You should see something like that :

users table
links table

If you want to check everything works fine, we can go a walk in Tinker.

php artisan tinker

Tinker will let us to play with our datas and check the relationship is currently working.

User::find(6)->links()->get(['id', 'url', 'published', 'user_id']);

Here, we ask to find every link for the user with id = 6. We ask too to get only interesting fields.

Seeing these results, we can improve immediately something.

What if, we only want the published links ?

So you can do it like this :

> User::find(6)->links()->where('published', 1)->get(['id', 'url', 'published', 'user_id']);

But there is a better way to do this and don't repeat yourself later. We can use Scopes.

A scope can add a bunch of query to your query. Scopes can be global or local. I let you consult the documentation to see more.

Here we will use a local scope.

Go to your link model and add this function :

    /**
     * Scope a query to only include published links.
     */
    public function scopePublished(Builder $query): void
    {
        $query->where('published', 1);
    }

Now, if in Tinker we use the following query :

User::find(6)->links()->published()->get(['id', 'url', 'published', 'user_id']);

we will obtain only the published links from user with id = 6.

And voilà, we can cross this point in our list :

✅ an user can signin, login, logout and manage his account

a user can see a list of their links

an user can add, edit or delete a link

an user can have a shareable link to share his links with the world

✅ a link has a name, a status (published or not) and obviously a link. May be we will add some options later.

Well, we'll stop here for today.

In this longer chapter, we saw introduction to :

how to add functionnality to login page in Filament
models
factory
seeder
Tinker
scopes

As usual, I wait for your comments below.

See you.

Linkeeper - Lesson 01 - Installation

HappyToDev — Wed, 10 Apr 2024 15:00:00 +0000

In this little serie, we will learn the basics about Laravel through a little application LinKeeper.

It goal is to keep your links and share them to the world.

So, what we need ?

We have to bring solutions to these definitions :

an user can signin, login, logout and manage his account
a user can see a list of their links
an user can add, edit or delete a link
an user can have a shareable link to share his links with the world
a link has a name, a status (published or not) and obviously a link. May be we will add some options later.

The purpose here is to discover the basic concepts of Laravel and FilamentPHP.

In this serie, I will use Laravel 11 and FilamentPHP 3.

Let's go and beginning with the very basic : the install

Installing Laravel
- Launch install with Laravel Installer
- Laravel is installed 🎉
- Check the install
FilamentPHP install
- Create a first user
- Check the install
Change the name of application

Installing Laravel

As every Laravel project, we have to launch the laravel install.

If you have the laravel installer it's as easy as type laravel new linkeeper in your favorite terminal.

If you prefer composer, just use this command instead composer create-project laravel/laravel linkeeper

Follow theses steps, which consisting to keep default choices and click enter three times 😉.

Launch install with Laravel Installer

Laravel is installed 🎉

As we have choose sqlite as database there is no more configuration needed, except APP_NAME, APP_TIMEZONE if you want.

For more simplicity, I let the language setting with default value. Feel free to change it if you need.

Check the install

Personnaly, I work on Mac with Herd. I can check http://linkeeper.test on my browser.

Everything seems ok !

If you need to work with https, it's perfectly possible with Herd in a single click.

Go to Herd settings, choose 'Sites' tab and search for your current url. Here : linkeeper.test.

Look for the lock and click on it to activate https.

Easy, peasy ! No ?

FilamentPHP install

Now, we have to install FilamentPHP. Sincerely, you don't need me for these steps, you just have to look at the incredible documentation of Laravel and Filament.

But, if you are already here, let's keep forwarding together 🤣

So, just copy / paste the 'Get Started' tutorial :

composer require filament/filament:"^3.2" -W

php artisan filament:install --panels

Let the default choice when Filament ask for id :

And voilà! Filament is installed.

Create a first user

We need an user to start play with Filament.

php artisan make:filament-user

Here too, answer questions for your name, email and password.

Check the install

Let's go to the link provided to ensure that everything is ok.

Enter your credentials and if everything is ok, you will see something like that :

Change the name of application

As you can see in the top left corner the name of the app is "Laravel", let's change this for "LinKeeper".

Open your project in your favorite IDE or if you prefer for this minor change, type nano .envin your terminal.

You just have to change the APP_NAME key :

If your name has spaces, you have to use the quote for your name.

ctrl + x to exit, say 'yes' when nano asked you if you want to save your file and confirm the name of the file (.env) by pressing return key.

Your .env file is now saved, you can reload your page and you will see the name of the app changed in the top left corner.

This is the end of this first part. In the next episode, we'll see how to start playing with Filament and models.

Don't hesitate to comment if you have question or if you see a mistake.

Quoi de neuf les devs ? #80 avec l'interview de Gabin Aurèche

HappyToDev — Tue, 09 Apr 2024 10:05:06 +0000

Hello à toutes et à tous 😉,

J'ai le plaisir de vous partager le nouveau numéro de "Quoi de neuf les devs ?" sorti samedi dernier.

J'y recevais @gabinaureche, il est dev et donne également très régulièrement des conseils sur les structures d’entreprise, sur l’argent en entreprise.

Comme chaque semaine, vous retrouverez les autres rubriques avec toujours le plein d’actualité sur le monde du dev.

Cette semaine, parmi tous les sujets abordés, on parlera entre autres de
✅ Go,
✅ QR Code,
✅ Redis,
✅ Side project,
✅ Email,
✅ FFmpeg,
✅ et bien d’autres sujets encore

Bonne lecture!

Si le contenu vous plait et que vous souhaitez me soutenir, abonnez vous et rejoignez plus de 1700 pros de l'IT d'ores et déjà abonné.e.s.

PS : Quel.le dev souhaiteriez vous voir interviewé.e dans un prochain numéro ?