IPv6, HTTPS & HTTP/2.0
+Welcome 2016!
+ +Thanks [Aeris](https://twitter.com/aeris22) for your help, check [his french blog post](https://blog.imirhil.fr/2015/09/02/cryptcheck-verifiez-implementations-tls.html) about SSL security. diff --git a/content/posts/2016-12-07-laravel-foreign-relations.md b/content/posts/2016-12-07-laravel-foreign-relations.md new file mode 100644 index 0000000..08b0478 --- /dev/null +++ b/content/posts/2016-12-07-laravel-foreign-relations.md @@ -0,0 +1,167 @@ +--- +title: "Laravel Foreign Relations" +image: /images/stripe.png +thumbnail: /images/thumbnail-stripe.png +code: https://framagit.org/ThibaudDauce/laravel-foreign-relations +description: In this article, I'll create a proof of concept using Laravel's Eloquent relations to fetch a foreign data source as Stripe. +lang: en +website: dev +--- + +The Laravel community is a huge fan of [Stripe](https://stripe.com). As Laravel, Stripe provides a great API to interact with the product. In this article, I'll create a proof of concept using Laravel's Eloquent relations to fetch a foreign data source as Stripe. The same idea could be applied to other foreign data providers. + + + +### Laravel's relation mecanism + +As you may know, you can [define relations](https://laravel.com/docs/5.3/eloquent-relationships) with Laravel. In your model, `hasMany`, `belongsTo` or `belongsToMany` are already-provided helpers to create links between your models. + +```php +hasMany(Comment::class); + } +} +``` + +But behind the scene, these methods returns children of the `Relation` object. These children could be `HasMany`, `BelongsTo`, `BelongsToMany`, etc. The `Relation` object is an abstract class you need to extend to build a new type of relations. This class is tightly tied with the Eloquent Builder class, which is a big problem. Laravel assumes Eloquent models in both sides of our relation. But in our case, it's one Eloquent model and one `Stripe\Customer` object. + +### Building the `StripeRelation` + +`StripeRelation` is my child for the `Relation` object. It will fetch and hydrate my models with the customers from Stripe. + +#### Constructor + +In order to build a `Relation` object, Laravel needs a builder from the foreign class and the instance of the main model. In our example, the foreign class is `Stripe\Customer` and the main model is `App\User`. + +First problem: I don't have an Eloquent builder for Stripe customers. I'll need [to create my own](#building-the-stripequerybuilder). + +```php +public function __construct(Model $model) +{ + parent::__construct(app(StripeQueryBuilder::class), $model); +} +``` + +#### `addConstraints` and `addEagerConstraints` + +The main goal of these methods is to set a `where` clause on the query builder with "id = stripe_id" or "id in [stripe_id_1, stripe_id_2, stripe_id_3]". Since my query builder is a special one, and I know it will be a custom `StripeQueryBuilder`, I can set two public properties `id` for when I need to fetch one Stripe customer, `ids` when I need to fetch all Stripe customers for a collection of users. We will see in the next part how we use these information to fetch the customers from Stripe. + +```php +public function addConstraints() +{ + $this->query->id = $this->parent->{$this->localKey}; +} + +public function addEagerConstraints(array $models) +{ + $this->query->ids = $this->getKeys($models, $this->localKey); +} +``` + +In these methods `$this->localKey` is the name of the attribute of the user model which contains the Stripe ID (default to `stripe_id`). + +#### `initRelation` + +This method sets the default foreign model for all the users. I don't have a default Stripe model so I just return the unchanged array of models. + +#### `getResults` + +The name of this method is misleading, its goal is just to fetch one foreign model (one Stripe customer) for one parent model (one user) when you simply type `$user->stripe`. I can delegate the API call to my `StripeQueryBuilder` class. The `stripe_id` of the user has already been set in the `StripeQueryBuilder` by the parent `Relation` class with `addConstraints`. + +```php +public function getResults() +{ + return $this->query->first(); +} +``` + +#### `match` + +This method is called when you try to load the relation on a collection to avoid the [N + 1 problem](https://laravel.com/docs/5.3/eloquent-relationships#eager-loading). It takes three arguments: + +- the models — an array of users which needs to be populated with the customers from Stripe +- the results — an Eloquent Collection from the query builder (basicaly a call to `$query->addEagerConstraints()->get()`) which contains for each Stripe ID the Stripe customer associated +- the relation — the name of the current relation being processed + +The logic is simple, loop over the models and set the relation to whatever is in the `$results` collection: + +```php +public function match(array $models, Collection $results, $relation) +{ + foreach ($models as $model) { + $model->setRelation($relation, $results[$model->{$this->localKey}]); + } + + return $models; +} +``` + +### Building the `StripeQueryBuilder` + +Now we need to build our `StripeQueryBuilder` which will call the Stripe API to fetch the requested customers. My class needs to extend the Eloquent Builder and override some methods. Most of the methods will not be changed so it will be impossible to call more *intelligent* methods like `$user->stripe()->update(['delinquent' => true])`. + +#### Constructor + +The parent model needs a Query. I will simply mock it. + +```php +public function __construct() +{ + parent::__construct(Mockery::mock(QueryBuilder::class)); +} +``` + +#### `first` + +The `first` method fetch one customer based on the ID previously set in the `$id` attribute of the Query Builder. + +```php +public function first($columns = ['*']) +{ + if ($this->id) { + return Customer::retrieve($this->id); + } + + throw new \Exception("'first' method called with no ID provided."); +} +``` + +#### `get` + +It's impossible to ask Stripe for all customers with IDs in an array (a simple `WHERE IN` with SQL). I need to fetch all customers and then filter them with PHP. The maximum number of customers for each request is 100. So I need to ask for 100 customers until Stripe tells me that there is no more or all my IDs have been found. + +```php +public function get($columns = ['*']) +{ + $models = new Collection; + + if ($this->ids) { + $totalCount = count($this->ids); + + foreach ($this->fetchAllStripeCustomers() as $customer) { + if (in_array($customer->id, $this->ids)) { + $models[$customer->id] = $customer; + } + + if ($totalCount === $models->count()) { + // All models were found, no need to continue to fetch the customers. + break; + } + } + } + + return $models; +} +``` + +### Conclusion + +This project is a very basic implementation. It's probably possible to do more. But it shows how you can keep a simple API for your models even with foreign relations. The working final project is available on [https://framagit.org/ThibaudDauce/laravel-foreign-relations](https://framagit.org/ThibaudDauce/laravel-foreign-relations). + +I may put this work in a package if some people are interested. + +Eventually, for french artisan, I offer Laravel trainings, just visit [https://www.formations-laravel.fr](https://www.formations-laravel.fr) and send me a message! diff --git a/content/posts/2016-12-15-laravel-recursive-migrations.md b/content/posts/2016-12-15-laravel-recursive-migrations.md new file mode 100644 index 0000000..712a6a5 --- /dev/null +++ b/content/posts/2016-12-15-laravel-recursive-migrations.md @@ -0,0 +1,189 @@ +--- +title: "Laravel Recursive Migrations" +image: /images/migrations-subdirectories.png +thumbnail: /images/thumbnail-migrations-subdirectories.png +code: https://framagit.org/ThibaudDauce/laravel-recursive-migrations +description: This package allows to put Laravel migrations into sub-directories. Let's build it together! +lang: en +website: dev +--- + +I'm currently developing the [Quantic Telecom](https://www.quantic-telecom.net) website with Laravel. My `app` folder is well-organized as my `views` and my `resources` but not my migrations because the Laravel `php artisan migrate` command doesn't run nested migrations. My package [`thibaud-dauce/laravel-recursive-migrations`](https://framagit.org/ThibaudDauce/laravel-recursive-migrations) will allow us to put migrations into sub-directories. + +In this blog post, I will go through the development of this package. For information, I found two links speaking about this particular problem: on StackOverflow ["Laravel running migrations on “app/database/migrations” folder recursively"](http://stackoverflow.com/questions/21641606/laravel-running-migrations-on-app-database-migrations-folder-recursively) and this issue on Github ["[Proposal/Enhancement] Artisan CLI Migrate command does not go through all sub folders of the migrations folder."](https://github.com/laravel/framework/issues/2561) + +The goal of my package is not to create new commands like `submigrate`, `submigrate:rollback`… I want to keep the original names `migrate`, `migrate:rollback` and add an option `--recursive` which will look into all sub-directories. + + + +When thinking about this problem, several solutions came into my mind: + +- Extending [`Illuminate\Database\Migrations\Migrator`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Database/Migrations/Migrator.php) +- Extending all commands (migrate, refresh, reset…) + +### Extending [`Illuminate\Database\Migrations\Migrator`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Database/Migrations/Migrator.php) + +The easiest approach is to extend the [`Illuminate\Database\Migrations\Migrator`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Database/Migrations/Migrator.php) and override the [`getMigrationFiles()`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Database/Migrations/Migrator.php#L298-L307) method. This method currently use the [`glob()`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Filesystem/Filesystem.php#L364-L367) method of the filesystem to get all files in the migration directory following the "*_*.php" pattern. Using the [`allFiles()`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Filesystem/Filesystem.php#L398-L401) recursive method instead should do the trick. + +The main benefit of this approach is to act on all commands (migrate, rollback, reset…) with only one change because the [`Migrator`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Database/Migrations/Migrator.php) is used by all of them. But the drawback is that the [`Migrator`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Database/Migrations/Migrator.php) is a low level class, so it can't access the command's flags. So I will be forced to apply migrations recursively all the time. + +### Extending all commands + +Extending the commands' classes will allow me to override some of their methods and modify their behavior. It seems to be a good option for me. The only disadvantage is the fact that I need to create a new class for each of the migrations' commands: [`MigrateCommand`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Database/Console/Migrations/MigrateCommand.php), [`RefreshCommand`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Database/Console/Migrations/RefreshCommand.php), [`ResetCommand`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Database/Console/Migrations/ResetCommand.php), [`RollbackCommand`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Database/Console/Migrations/RollbackCommand.php) and [`StatusCommand`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Database/Console/Migrations/StatusCommand.php). But I can manage the duplicate code with some traits. + +So, I will split the work into two traits. The first one will be in charged of fetching subdirectories and will be general (pure and not linked to Laravel or the migration system). The second one, the ugly one, will need to be add to a child of the [`Illuminate\Database\Console\Migrations\BaseCommand`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Database/Console/Migrations/BaseCommand.php) and will override the [`getMigrationPaths()`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Database/Console/Migrations/BaseCommand.php#L24-L36), [`getOptions()`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Database/Console/Migrations/MigrateCommand.php#L104-L119) and [`call()`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Console/Command.php#L179-L186) methods. I think it's often a bad choice to force a trait into an inheritance tree, but I couldn't find another solution… + +#### My first trait: [`Subdirectories`](https://framagit.org/ThibaudDauce/laravel-recursive-migrations/blob/master/src/Subdirectories.php) + +This trait will be pure. It will fetch the sub-directories for a path. I could have done a service class injected by the container but I thought it will be over complicated for some business logic that will never change (sub-directories will always be sub-directories). A service class would have given more flexibility to the end user by allowing him to change or extend my implementation. + +The first method of this trait will fetch all sub-directories in a path with the help of the [`Finder`](https://github.com/symfony/symfony/blob/3.2/src/Symfony/Component/Finder/Finder.php) component: + +```php +/** + * Fetch all subdirectories from a path. + * The original path is included in the array. + * + * @param string $path + * @return string[] + */ +protected function subdirectories($path) +{ + return Collection::make(Finder::create()->in($path)->directories()) + ->map(function (SplFileInfo $directory) { + return $directory->getPathname(); + }) + ->prepend($path) + ->values() + ->toArray(); +} +``` + +The second method will flatMap the result of the first method for multiple base paths. flatMap is a function which map all element in an array to an array (you get an array of array) and then merge all arrays into one. + +```php +/** + * Fetch all subdirectories from an array of base paths. + * The original paths are included in the array. + * + * @param string[] $paths + * @return string[] + */ +protected function allSubdirectories($paths) +{ + return Collection::make($paths) + ->flatMap(function ($path) { + return $this->subdirectories($path); + }) + ->toArray(); +} +``` + +#### My second trait: [`RecursiveMigrationCommand`](https://framagit.org/ThibaudDauce/laravel-recursive-migrations/blob/master/src/RecursiveMigrationCommand.php) + +The goal of this trait is to provide new methods for the children of [`Illuminate\Database\Console\Migrations\BaseCommand`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Database/Console/Migrations/BaseCommand.php). It will use the previously seen [`Subdirectories`](https://framagit.org/ThibaudDauce/laravel-recursive-migrations/blob/master/src/Subdirectories.php) trait. + +First, it will add the `--recursive` option. Nothing special here to the [`getOptions()`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Database/Console/Migrations/MigrateCommand.php#L104-L119) method. + +```php +/** + * Get the console command options. + * + * @return array + */ +protected function getOptions() +{ + return array_merge(parent::getOptions(), [ + ['recursive', 'r', InputOption::VALUE_NONE, 'Indicates if the migrations should be run recursively (nested directories).'] + ]); +} +``` + +Then, it will add the sub-directories to the migration paths if the flag is set. The [`allSubdirectories()`](https://framagit.org/ThibaudDauce/laravel-recursive-migrations/blob/master/src/Subdirectories.php#L36-43) method comes from the [`Subdirectories`](https://framagit.org/ThibaudDauce/laravel-recursive-migrations/blob/master/src/Subdirectories.php) trait. + +```php +/** + * Get all of the migration paths. + * + * @return array + */ +protected function getMigrationPaths() +{ + $paths = parent::getMigrationPaths(); + return $this->option('recursive') ? $this->allSubdirectories($paths) : $paths; +} +``` + +And finally, the last one, `call()`, is only required for the [`RefreshCommand`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Database/Console/Migrations/RefreshCommand.php). [`RefreshCommand`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Database/Console/Migrations/RefreshCommand.php) does not contain any logic. It's only a wrapper around the [`ResetCommand`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Database/Console/Migrations/ResetCommand.php) and the [`MigrateCommand`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Database/Console/Migrations/MigrateCommand.php). Internally, it calls the others commands with the [`call()`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Database/Console/Migrations/RefreshCommand.php#L50-L66) method, passing its arguments like "step", "database" or "path"… But in this implementation, it will not pass the "recursive" flag to the other commands. I need to set it if the command called is a *migrate* command: + +```php +/** + * Call another console command. + * + * @param string $command + * @param array $arguments + * @return int + */ +public function call($command, array $arguments = []) +{ + if (starts_with($command, 'migrate')) { + $arguments['--recursive'] = $this->option('recursive'); + } + + parent::call($command, $arguments); +} +``` + +#### New Commands + +I also need to create my own commands for the [`MigrateCommand`](https://framagit.org/ThibaudDauce/laravel-recursive-migrations/blob/master/src/Commands/MigrateCommand.php), [`RefreshCommand`](https://framagit.org/ThibaudDauce/laravel-recursive-migrations/blob/master/src/Commands/RefreshCommand.php), [`ResetCommand`](https://framagit.org/ThibaudDauce/laravel-recursive-migrations/blob/master/src/Commands/ResetCommand.php), [`RollbackCommand`](https://framagit.org/ThibaudDauce/laravel-recursive-migrations/blob/master/src/Commands/RollbackCommand.php) and [`StatusCommand`](https://framagit.org/ThibaudDauce/laravel-recursive-migrations/blob/master/src/Commands/StatusCommand.php). All the implementations are the same thanks to the [`RecursiveMigrationCommand`](https://framagit.org/ThibaudDauce/laravel-recursive-migrations/blob/master/src/RecursiveMigrationCommand.php) trait. For example, my [`MigrateCommand`](https://framagit.org/ThibaudDauce/laravel-recursive-migrations/blob/master/src/Commands/MigrateCommand.php): + +```php +app->extend('command.migrate', function () { + return new MigrateCommand($this->app['migrator']); +}); + +$this->app->extend('command.migrate.rollback', function () { + return new RollbackCommand($this->app['migrator']); +}); + +$this->app->extend('command.migrate.refresh', function () { + return new RefreshCommand($this->app['migrator']); +}); + +$this->app->extend('command.migrate.reset', function () { + return new ResetCommand($this->app['migrator']); +}); + +$this->app->extend('command.migrate.status', function () { + return new StatusCommand($this->app['migrator']); +}); +``` + +I didn't found a way to override the first binding with `bind()` because the [`MigrationServiceProvider`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Database/MigrationServiceProvider.php) is deferred by the [`ConsoleSupportServiceProvider`](https://github.com/laravel/framework/blob/5.3/src/Illuminate/Foundation/Providers/ConsoleSupportServiceProvider.php) so it will register his binding after mines. If I also defer my service provider, I get a "Provider already exists!" exception. + +So, I need to use the `extend()` method which is not really the correct one I think. The extend method will first resolve the previous binding and give it to my closure. In my service provider, I don't care of the previous instance of the command since I create a new one (a new child) from scratch. + +### Conclusion + +The project is missing PHPUnit tests even if I already try the commands by hand in a fresh Laravel project. But it's available now on [Packagist](https://packagist.org/packages/thibaud-dauce/laravel-recursive-migrations) and on [Git](https://framagit.org/ThibaudDauce/laravel-recursive-migrations). Please open an issue if you find anything wrong in it. + +I discover a lot about the migration system in Laravel during this little project, and I encourage you to dig in the source code of the framework: you'll learn a lot! diff --git a/content/posts/2017-02-13-pattern-matching-in-php.md b/content/posts/2017-02-13-pattern-matching-in-php.md new file mode 100644 index 0000000..97ce465 --- /dev/null +++ b/content/posts/2017-02-13-pattern-matching-in-php.md @@ -0,0 +1,161 @@ +--- +title: "Pattern Matching in PHP" +image: /images/pattern-matching.png +thumbnail: /images/thumbnail-pattern-matching.png +code: https://gitlab.com/thibauddauce/pattern-matching +description: How to build a pattern matching library in PHP? +lang: en +website: dev +--- + +I'm a big fan of Haskell and one of my favorite feature of this awesome language is pattern matching. If you don't know what's pattern matching, it's this: + +```hs +data Customer = Student | Individual + +getPrice :: Customer -> Int +getPrice Student = 10 +getPrice Individual = 30 +``` + +The main advantage is, if I add a possibility in my type, for example `data Customer = Student | Individual | Company`, the Haskell compiler will tell me that my function is missing a pattern. I will need to provide a `getPrice Company = ?`. + +Of course, in PHP we don't have a compiler but we can still have some checks… + + + +### The problem + +Imagine I have a class for my customer: + +```php +type === self::STUDENT) { + return 10; + } elseif ($this->type === self::INDIVIDUAL) { + return 30; + } else { + throw new InvalidArgumentException('Neither student nor individual.'); + } + } +} +``` + +By the way, pay attention of how 4 lines of code became 18 lines. But, of course, Haskell is a incomprehensible language ;-) + +If I have my unit tests like these: + +```php +$customer = new Customer; // in real life, I would use a name constructor… +$customer->type = Customer::STUDENT; + +$this->assertEquals(10, $customer->getPrice()); +``` + +```php +$customer = new Customer; +$customer->type = Customer::INDIVIDUAL; + +$this->assertEquals(30, $customer->getPrice()); +``` + +If latter, I add a new type `const COMPANY = 'company'` in my class, my tests will remain green. If I use this `if() {} elseif () {} else {}` in a lot of places, it will be difficult to catch all occurrences. + +### The solution + +Use [my small pattern matching library](https://gitlab.com/thibauddauce/pattern-matching) (or build your own, it's only a mater of hours…): + +```php +match($this->type, $actions); + } + + public function getPrice() + { + $this->patternMatchOnType([ + self::STUDENT => 10, + self::INDIVIDUAL => 30, + ]); + } +} +``` + +If I add a new type and I change my enumerate definition in one place `new Pattern([self::STUDENT, self::INDIVIDUAL, self::COMPANY])`, my previous tests are now failing with a new exception: + +```html +MissingPatternsDuringMatch: 'company' was missing during the match. +Expected patterns were 'student', 'individual', 'company' and received patterns were 'student', 'individual'. +``` + +Even if, I never wrote a test to check if the price for a company is correct. + +### Extra features of my library + +You can check [the test file](https://gitlab.com/thibauddauce/pattern-matching/blob/master/tests/PatternTest.php) for all features. + +#### Checks + +My `match()` function is three simple checks happening every time. It means, it raises an exception even if the pattern could be resolved. + +- there is no missing pattern in the array (all cases must have a response) +- there is no extra pattern in the array (if a type is removed, I want to remove all the occurrences of the dead code) +- the value provided is in the pattern list + +#### Callbacks + +If your application is doing expensive work for each pattern (more expensive than returning "10" or "30"), you can wrap the result in a callback: + +```php +$this->patternMatchOnType([ + self::STUDENT => function() { + return StudentPrice::fetchFromFile(); + }, + self::INDIVIDUAL => function() { + return Price::where('type', self::INDIVIDUAL)->first()->value; + }, +]); +``` + +#### Callbacks arguments + +And you can also give arguments to your callbacks with `with`: + +```php +public function patternMatchOnType(array $actions) +{ + return (new Pattern([self::STUDENT, self::INDIVIDUAL])) + ->with($this) // The callbacks will receive the instance of the customer + ->match($this->type, $actions); +} + +public function getPrice() +{ + $this->patternMatchOnType([ + self::STUDENT => 10, + self::INDIVIDUAL => function(Customer $customer) { + return IndividualPrice::where('age', '>', $customer->age)->first()->value; + }, + ]); +} +``` + +Even if, in this case, you could simply use `$this->age` inside the callback. diff --git a/content/posts/2017-07-18-your-app-doesnt-have-users.md b/content/posts/2017-07-18-your-app-doesnt-have-users.md new file mode 100644 index 0000000..f71d738 --- /dev/null +++ b/content/posts/2017-07-18-your-app-doesnt-have-users.md @@ -0,0 +1,56 @@ +--- +title: "Your app doesn't have \"users\"" +image: /images/your-app-doesnt-have-users.png +thumbnail: /images/thumbnail-your-app-doesnt-have-users.png +description: The most important part of your code is how you're naming things. Don't forget your first class! +lang: en +website: dev +--- + +I'm a big fan of Laravel. The thing I like the most about the community is the focus on understandable code. Not patterns, not architectures, but how to choose the best API for a task so the result is readable as plain English. + +But today, I want to talk about one name that Laravel's developers often get wrong. + + + +--- + +The default installation of Laravel comes with a `User` class and a migration to create a `users` table. Why? Because, obviously, every application has users. + +*That's not true.* + +Adam Wathan is a Laravel developer who provides an awesome course to learn how to build great applications: ["Test Driven Laravel"](https://adamwathan.me/test-driven-laravel/). + + + +TicketBeast, the Test Driven Laravel sample application, is about promoters and concerts, but in the application there is a `User` class and a `Concert` class but no `Promoter` class. + +He is also producing free lives, twice a week, on his [YouTube channel](https://www.youtube.com/channel/UCy1H38XrN7hi7wHSClfXPqQ/videos) where he builds [KiteTail](https://kitetail.co/). Adam put a lot of thought into the name of his users and eventually chose **"makers"** after a few videos. But once again, there is no `Maker` class in KiteTail. + +If you watch (and you should) the new series at Laracasts ["Let's Build A Forum with Laravel and TDD"](https://laracasts.com/series/lets-build-a-forum-with-laravel/), you will notice that Jeffrey also uses the `User` class. But this time, he really uses the term "user" when speaking and writing descriptions for his tests. + +On the other hand, in the second video, he used the term **"creator"** for "a thread has a creator" and he renamed his relation from `user()` to `creator()`. That's much more readable than `user()`, because what is the user of a thread anyway? If the default doesn't seem right for you, don't use it! + +When you don't use the default, Laravel will look for a "creator_id" column in the table instead of a "user_id" one. Jeffrey chose to override the default with `return $this->belongsTo(User::class, 'user_id');`, but I think it could have been better to embrace the new term and rename the table's column from "user_id" to "creator_id". If you need to speak about this table, you could then say "I store the ID of the creator with the body of the thread" instead of "I store the ID of the user with the body of the thread". The first one seems much more natural to me. + +--- + +Thread **creator**, concert **promoter**, product **maker**, it's only three examples among many. + +The most important thing to keep in mind is that you should name your classes as it feels natural to **you**. For example, I would use **"members"** to designate the users of a forum but Jeffrey seems to use **"users"** naturally. There is no right or wrong here (as often in development), you only need to choose the correct one so you can speak about your code without translating anything. + +So next time you run `laravel new my-project`, don't be lazy, take 5 minutes to think about your product and if you need to rename your `User` class into something else. It's always easier when it's done on a fresh project :-) + +I choose to speak about `User` because I think it's often forgotten but it's also true in most applications for "status", "data", "items", "result", "payload"… But don't forget that in a `Collection` class, "items" is perfectly natural, and in the Guzzle HTTP library, "payload" is fine too. + +If you want to learn more about it: + +- [https://murze.be/2017/06/the-status-antipattern/](https://murze.be/2017/06/the-status-antipattern/) +- [http://twentypercent.fm/naming-things](http://twentypercent.fm/naming-things) + +And if you want to learn how to improve your code: + +- [https://adamwathan.me/test-driven-laravel/](https://adamwathan.me/test-driven-laravel/) +- [Adam's YouTube channel](https://www.youtube.com/channel/UCy1H38XrN7hi7wHSClfXPqQ/videos) +- [Laracasts](https://laracasts.com/) +- For french speakers: [Formations Laravel](https://www.formations-laravel.fr/) diff --git a/content/posts/2017-07-26-improvements-of-the-new-Responsable-interface-in-Laravel.md b/content/posts/2017-07-26-improvements-of-the-new-Responsable-interface-in-Laravel.md new file mode 100644 index 0000000..0ee9267 --- /dev/null +++ b/content/posts/2017-07-26-improvements-of-the-new-Responsable-interface-in-Laravel.md @@ -0,0 +1,198 @@ +--- +title: "Improvements of the new Responsable interface in Laravel" +image: /images/responsable.png +thumbnail: /images/thumbnail-responsable.png +description: "Laravel 5.5 will ship with a new feature: the Responsable interface. Why not add some sugar to it?" +lang: en +website: dev +--- + +The new `Responsable` interface in Laravel is really awesome, it allows us to simplify our controllers with custom responses objects. + +But one of the complexity with responses is the content negotiation and [the new feature](https://github.com/laravel/framework/commit/c0c89fd73cebf9ed56e6c5e69ad35106df03d9db) doesn't help us on this. How could we solve this problem? + + + +--- + +### The new feature + +First, let's look at how Laravel uses the `Responsable` interface in the Router. + +```php +if ($response instanceof Responsable) { + $response = $response->toResponse(); +} + +if ($response instanceof PsrResponseInterface) { + $response = (new HttpFoundationFactory)->createResponse($response); +} elseif (! $response instanceof SymfonyResponse && + ($response instanceof Arrayable || + $response instanceof Jsonable || + $response instanceof ArrayObject || + $response instanceof JsonSerializable || + is_array($response))) { + $response = new JsonResponse($response); +} elseif (! $response instanceof SymfonyResponse) { + $response = new Response($response); +} +``` + +The only method on the `Respondable` interface is the `toResponse` method. Then, if the response is `Jsonable` or something similar, Laravel will use the `JsonResponse` which `json_encode` all the data. + +### Adding Content Negotiation + +There is no sign of Content-Negotiation in this method. So if I need to build a response in JSON or in HTML depending of the type the request, I will have some conditions in my controller: + +```php +public function index() +{ + $users = User::all(); + + if (request()->wantsJson()) { + return new UsersJsonResponse($users); + } + + return new UsersHtmlResponse($users); +} +``` + +Not too bad, thanks to the awesome `wantsJson()` method, but it could be better (especially if my controller is not a simple database query): + +```php +public function index() +{ + $users = User::all(); + + return UsersResponse($users); +} +``` + +Better! Now let's dive in the `UsersResponse`: + +```php +class UsersResponse implements Responsable +{ + public $users; + + public function __construct($users) + { + $this->users = $users; + } + + public function toResponse() + { + if (request()->wantsJson()) { + return $this->users; + } + + return view('users.index', ['users' => $this->users]); + } +} +``` + +### Avoiding conditionals with polymorphism + +It's often a good thing to replace conditionals by polymorphism. I would rather prefer this response with a new `NegociateContent` trait: + +```php +class UsersResponse implements Responsable +{ + use NegociateContent; + + public $users; + + public function __construct($users) + { + $this->users = $users; + } + + public function toJsonResponse() + { + return $this->users; + } + + public function toHtmlResponse() + { + return view('users.index', ['users' => $this->users]); + } +} +``` + +Or this one which extends a new `BaseResponse`: + +```php +class UsersResponse extends BaseResponse +{ + public $users; + + public function __construct($users) + { + $this->users = $users; + } + + public function toJsonResponse() + { + return $this->users; + } + + public function toHtmlResponse() + { + return view('users.index', ['users' => $this->users]); + } +} +``` + +The `NegociateContent` or the `BaseResponse` implementations are really straightforward. We can add more checks and content type if needed of course. + +```php +class BaseResponse implements Respondable +{ + public function toResponse() + { + if (request()->wantsJson()) { + return $this->toJsonResponse(); + } + + return $this->toHtmlResponse(); + } +} +``` + +### Let's try to build the same `view` helper as in mailables + +We can even simplify the `toHtmlResponse` method with the same concept as in `Mailable`. As you may know, in mailables, all public properties are directly accessible in the mail view. + +```php +public $users; + +public function toHtmlResponse() +{ + return $this->view('users.index'); +} +``` + +I stole this code from the [`Illuminate\Mail\Mailable`](https://github.com/laravel/framework/blob/master/src/Illuminate/Mail/Mailable.php#L223) class in the framework (I just refactored it to collections). + +```php +public function view($view, $overrides = []) +{ + return collect((new ReflectionClass($this))->getProperties(ReflectionProperty::IS_PUBLIC)) + ->reject(function($property) { + return $property->getDeclaringClass()->getName() == self::class; + }) + ->mapWithKeys(function($property) { + return [$property->getName(), $property->getValue($this)]; + }) + ->merge($overrides) + ->pipe(function($data) use($view) { + return view($view, $data); + }); +} +``` + +### Conclusion + +I think these few lines of code really improve the `Responsable` interface. I really like the `Mailable` reflection as it feels really natural to me. + +I may try to pull request the framework to add these features if people like them so don't hesitate to send me a message [on Twitter \@ThibaudDauce](https://twitter.com/ThibaudDauce) or [by mail (thibaud@dauce.fr)](mailto:thibaud@dauce.fr) to tell me what you think! diff --git a/content/posts/2019-01-24-what-to-learn-in-2019.md b/content/posts/2019-01-24-what-to-learn-in-2019.md new file mode 100644 index 0000000..9a50df0 --- /dev/null +++ b/content/posts/2019-01-24-what-to-learn-in-2019.md @@ -0,0 +1,56 @@ +--- +title: "What to learn in 2019?" +description: "In 2019, I want to challenge the way I build applications by exploring other interesting technologies." +lang: en +website: dev +--- + +Computer science is evolving at a rapid pace. There are new developers bringing new ideas. And there are many ancient discoveries forgotten or underused today. The fact is: there is a lot to learn in computer science in 2019. + +This year, I want to go out of my comfort zone and try new stuff. Don't get me wrong, I still love the PHP ecosystem, and Laravel is still an amazing framework to work with (I even [teach Laravel](https://www.formation-laravel.fr/) if you're interested). + +So, why switch? To begin with, I don't want to switch but only becoming productive in other areas of computed sciences. Secondly, PHP, as a language, is not that great and the recent features added are not really interesting. I have the feeling PHP is trying to copy Java or other mainstream languages without the correctness of the compilation. I don't consider my program crashing at runtime because of a type annotation is a real improvement over my program crashing at runtime because the method is called on the wrong object. + +### What are the goals? Productivity, correctness and performances. + +**Productivity** is the most meaningful one. I'm paid to deliver value to a customer and not to do research around programming languages. But productivity is also the easiest metric to improve, I'm sure you can be productive in any language if you practice enough. + +**Correctness** is about writing a program and have some guaranties that the result will work as expected. PHP is especially bad at this, but other languages can have different levels of verification with more or less strict type systems. + +And for **performances**, even though PHP 7 brought a significant speed boost, the language is still slow. The web is also a really slow platform, and I would like experimenting unfamiliar things like high performance CLI apps and native GUIs. + +### Who are the challengers? + +[Haskell](https://haskell-lang.org/) is a strictly typed, purely functional, "if it compiles, it works" kind of language. I'm afraid that the accent on absolute correctness and the bad documentation will slow me down on some manageable problems. ++★★☆☆ Productivity | +★★★★ Correctness | +★★☆☆ Performances + +[Elixir](https://elixir-lang.org/) is a functional language based on the Erlang VM with the Ruby syntax. I think I can become highly productive with this kind of language. The correctness is a little bit behind because the language is dynamically typed but the compilation can still identify some issues before going into production. And last but not least, the performance are amazing: less than a millisecond to render a simple HTML webpage with [Phoenix](https://phoenixframework.org/). +
+★★★☆ Productivity | +★★☆☆ Correctness | +★★★☆ Performances + +[Rust](https://www.rust-lang.org/) is a low-level programming language with C-like performances. Memory management lower the productivity, but the documentation is really good. And the type system can detect the majority of silly errors at compile-time. +
+★☆☆☆ Productivity | +★★★☆ Correctness | +★★★★ Performances + +[PHP](https://secure.php.net/), because this is the tool I provide the most value with. The ecosystem is amazing, but I will not discover anything new soon. And I don't like that. +
+★★★★ Productivity | +★☆☆☆ Correctness | +★☆☆☆ Performances + +### So? What will I learn in 2019? + +My first choice is Rust. It's the language where I have the most to learn. + +For a few weeks I tried building a text editor with Rust, and it was very hard. How to render a character on the screen? How to create a blinking cursor? How to add words in the middle of a large string? I think this project is overly complex for me now but it was a good first try. + +I also built a small utility (a few lines of code) to print statistics about my websites. I don't use standard analytics, so I just grabbed the last few days of Nginx's logs and printed the visits for each day and each URI. + +Thanks for reading, it's been a while (more than one year) between my previous post and this one, and my written english is a little bit Rusty, please forgive me :-) You can subscribe to my RSS feed to receive my future posts if you want. \ No newline at end of file diff --git a/content/posts/2019-07-01-I-dont-like-camel-case.md b/content/posts/2019-07-01-I-dont-like-camel-case.md new file mode 100644 index 0000000..c049ba4 --- /dev/null +++ b/content/posts/2019-07-01-I-dont-like-camel-case.md @@ -0,0 +1,22 @@ +--- +title: "I don't like camelCase" +description: "Snake case, camel case… Why different languages made different choices?" +lang: en +website: dev +--- + +Which one is the most readable? + +```php +function getFirstUserFrom(SiretNumber $siretNumber): User {} +``` + +```php +function get_first_user_from(Siret_Number $siret_number): User {} +``` + +I think the snake case version is much more readable than the camel case. + +How we name our functions is not a technical choice, it's a convention. Nobody can say that the snake case version is worse than the camel case one. The people from the PSR committee decided [a long time ago](https://www.php-fig.org/psr/psr-1/) that, in PHP, methods will be named in camel case and classes will be named in studly case. But in Rust, or in Python, a different choice was made: it's snake case for functions and methods. + +Don't let other people decide what works best for you. Recently, I started using snake case for all my functions, methods and variables. And I think I'll switch to the `Siret_Number` approach for all my classes. \ No newline at end of file diff --git a/content/posts/2020-10-07-taylor-otwell-a-propos-de-jetstream-et-ma-chaine-youtube.md b/content/posts/2020-10-07-taylor-otwell-a-propos-de-jetstream-et-ma-chaine-youtube.md new file mode 100644 index 0000000..f702bc5 --- /dev/null +++ b/content/posts/2020-10-07-taylor-otwell-a-propos-de-jetstream-et-ma-chaine-youtube.md @@ -0,0 +1,25 @@ +--- +title: "Taylor Otwell à propos de Jetstream. Le futur de ma chaîne YouTube." +description: "Taylor explique dans une récente vidéo la différence entre open-source et produits commerciaux ce qui me fait penser à mes prochains projets sur YouTube" +website: dev +--- + +Dans [une récente vidéo](https://www.youtube.com/watch?v=krn39HjxPTs), Taylor Otwell revient sur les critiques apportées à [Laravel Jetstream](https://jetstream.laravel.com/1.x/introduction.html). Il y explique que lorsqu'il développe des applications open-source, il le fait pour lui. C'est pour cela que Jetsream ne propose « que » deux options : Livewire ou Inertia. Taylor n'utilisant ni Bootstrap, ni Vue Router, ni Blade seul… c'est normal pour lui ne pas développer ces options. Mais il laisse libre la communauté de créer ses propres bibliothèques open-source si des personnes sont intéressées (d'après ce que j'en ai compris, [Laravel Fortify](https://github.com/laravel/fortify) est l'interface sans aucun visuel permettant de créer ses propres options). + +Il explique également que, contrairement à ses travaux open-source où il fait ce qu'il veut (et il a bien raison), lorsqu'il développe des produits commerciaux il se plie aux demandes de ses clients. Je comprends parfaitement cette réflexion pour en avoir un aperçu avec [la chaîne YouTube](https://www.youtube.com/user/tdauce/) lorsque des personnes me demandent pourquoi je ne fais pas une nouvelle série sur Laravel, pourquoi je n'ai pas terminé la série sur Nova, pourquoi je ne fais pas plus de VueJS, etc. Lorsque je fais des vidéos gratuitement sur Internet, je me permets de ne parler que des sujets qui m'intéressent, sans aucune autre obligation. Cela ne m'empêche pas de continuer à faire des formations et de l'accompagnement sur Laravel [pour mes clients](https://www.formation-laravel.fr/). + +Pour ceux qui l'avaient remarqué, ce blog était en anglais mais j'ai récemment décidé de reprendre l'écriture car ma situation actuelle m'empêche de faire des vidéos (le format écrit est plus simple à produire). Or, écrire en anglais me demande plus d'efforts, et ma communauté étant principale francophone, j'ai décidé de le reprendre en français. + +Pour ceux intéressés par la suite, voici les sujets dont j'aimerais parler dans le futur sur ce blog, mais aussi en vidéo quand ma situation sera plus calme : +- Des astuces que j'utilise sur mes applications Laravel +- La transformation de [ce site statique](https://github.com/ThibaudDauce/thibaud.dauce.fr) d'Hakyll vers Rust +- Un retour d'expérience sur le développement d'une SPA avec [Elm](https://elm-lang.org/) +- Un retour d'expérience sur le développement d'une application Android avec [Flutter](https://flutter.dev/) +- Intégration d'[AlpineJS](https://github.com/alpinejs/alpine/) dans mon projet [Têtes de Coton](https://www.youtube.com/playlist?list=PLMWEEzYqZ0em0jJa4LmQPjDqJNaApqKan) +- Développement d'un blog avec [Rust](https://www.rust-lang.org/) et [Rocket](https://rocket.rs/) (avec plus de choses que [ma précédente expérimentation](https://www.youtube.com/playlist?list=PLMWEEzYqZ0ekOG6_G4q_GXPpVHWrIH--x) : connexion admin, WYSIWYG, envoi de fichiers…) +- Développement d'un composant [DataTables](https://datatables.net/) en VueJS v3 +- Expérimentation d'une application native multiplateformec en C++ avec [WxWidgets](https://www.wxwidgets.org/) + +Et sans doute d'autres choses autour de la programmation mais pas que ! Si vous voulez commenter, discuter, n'hésitez pas à rejoindre [mon Discord](https://discordapp.com/invite/tPtVM9V). Si vous souhaitez être notifié des prochains articles de ce blog, le plus sûr est de s'abonner à [mon flux RSS](https://thibaud.dauce.fr/feed.xml), vous pouvez aussi me suivre [sur Twitter](https://twitter.com/ThibaudDauce/) même si j'y suis très peu actif ces derniers temps. + +PS : je reviendrai dans un futur article sur mon avis à propos Jetsream et autres… \ No newline at end of file diff --git a/content/posts/2020-10-13-projet-windows.md b/content/posts/2020-10-13-projet-windows.md new file mode 100644 index 0000000..5c9346f --- /dev/null +++ b/content/posts/2020-10-13-projet-windows.md @@ -0,0 +1,48 @@ +--- +title: "Projet Windows" +description: "Un développeur Linux depuis plus de 10 ans peut-il passer à Windows ?" +website: dev +--- + +J'ai reçu hier un Dell XPS 17 2020. Après avoir consulté quelques forums, je me suis rendu compte que [les pilotes Linux ne semblent pas tout à fait à jour](https://wiki.archlinux.org/index.php/Dell_XPS_17) pour cette machine et je risque fort d'avoir, au minimum, des problèmes de son. C'est l'occasion rêvée de faire une petite expérimentation : que donne Windows aujourd'hui pour développer ? + +Je n'ai personnellement jamais utilisé Windows pour développer, j'ai commencé avec un CD d'Ubuntu (envoyé gratuitement par la poste à l'époque !) il y une dizaine d'années, puis, il y a maintenant plus de 6 ans, je suis passé à ArchLinux pour bénéficier des dernières versions logicielles. + +## Objectifs lors de la réception + +Mon objectif est donc de tester Windows pendant quelques semaines/mois le temps que le noyau Linux se mette à jour et ensuite d'évaluer l'expérience. Je compte y aller à fond : Windows, mais aussi les applications Mail et Calendar intégrées, Edge en tant que navigateur principal, le nouveau Windows Terminal… + +Pour référence, voici les principaux points qui peuvent potentiellement m'embêter par ordre de priorité : + +1. Je ne sais pas du tout comment fonctionne les outils de développement du nouveau Edge (est-ce qu'il est compatible avec les extensions Chrome ? Est-ce que toutes les infos sont présentes dans l'explorateur ?) +1. Les bureaux multiples semblent simplistes sous Windows : j'utilise actuellement 4 bureaux virtuels en carré avec des raccourcis pour se déplacer dans l'espace (vers le haut, gauche, droite, bas…) et des catégories de programmes automatiquement ouvertes sur chaque bureau. +1. Des problèmes insolvables : sous Linux j'ai toujours la possibilité d'aller assez loin dans le fonctionnement du système en ligne de commande pour trouver une solution. +1. Un environnement de bureau plus lourd : difficile de faire moins lourd que mon [bspwm](https://wiki.archlinux.org/index.php/Bspwm) actuel. + +Mais je pense aussi que Windows va m'apporter quelques avantages : + +1. Une meilleure autonomie : en particulier via une meilleure gestion de la puce GPU intégrée d'Intel et de la carte graphique Nvidia dédiée. +1. Une meilleure gestion des périphériques USB (télépone Android, liseuse, imprimante…). +1. Moins de temps passé à configurer des choses, réparer des problèmes, installer des mises à jour et plus de temps à développer. +1. La possibilité d'utiliser Windows Hello et le capteur d'empreintes pour déverrouiller l'ordinateur. +1. La possibilité d'installer des jeux vidéos +1. Des meilleurs débuggeurs si je me lance vraiment dans le développement Rust/C++ + +## Première mise à jour suite à une journée de développement + +Après avoir installé mon ordinateur et développé une journée avec, voici mes premiers retours. + +Au niveau des problèmes rencontrés : +- Certains texte de Windows lors des redémarrages pour les mises à jour sont en anglais, incompréhensible… La date et l'heure étaient également en format anglais alors que ma configuration était en français. +- La configuration de mon clavier Bépo n'était pas la même que sous Linux, mais [j'ai pu corriger ce problème via quelques recherches](/posts/2020-10-14-bépo-sur-windows.html) +- Redis n'existe pas en version Windows (du moins pas depuis la version 3) +- Je n'ai pas trouvé d'alternative à `rsync` pour le moment +- L'application Mail n'arrive pas à se connecter à ProtonMail Bridge et ne propose visiblement pas d'identités multiples pour pouvoir envoyer des mails avec différentes adresses via le même compte SMTP. J'ai installé Thunderbird. +- Je n'ai pas encore trouvé d'alternative à `inotifywait` pour compiler mon code dès qu'il y a une modification (je peux utiliser `cargo watch` dans l'écosystème Rust, cela doit exister dans l'écosystème d'Elm mais je n'ai pas encore cherché). +- Beaucoup de logiciels inutiles pré-installés, dont certains néfastes. J'ai passé un certain temps à rechercher pourquoi mon micro enregistrait avec un écho avant de réaliser que le logiciel Maxx Audio Pro essayait de modifier le son en sortie de mon casque pour lui donner un effet 3D (personne n'a jamais dû tester ce logiciel avant de l'installer par défaut sur tous les ordinateurs Dell vu que ça ne fonctionne pas du tout…). + +Mais aussi des bonnes surprises : +- J'adore Windows Hello, c'est très agréable à utiliser et très efficace pour déverrouiller son ordinateur. +- Toutes mes applications à l'exception de Redis/`rsync` tournent sans problème sur Windows. Pour référence j'ai installé : PHP, Composer, Node/NPM, MariaDB, PostgreSQL, FFMPEG, youtube-dl, Git, Github Desktop, VS Code, OpenVPN, Flutter/Dart, Rust/Rustup/Cargo et Elm. Redis fonctionne sans problème via WSL. +- Les extensions PHP sont très faciles à installer, pas besoin de compiler l'extension SSH2 par exemple, il suffit de télécharger le DLL depuis [PECL](https://windows.php.net/downloads/pecl/releases/) et de le déplacer dans mon dossier PHP. +- Les extensions Google Chrome sont compatibles avec Microsoft Edge donc aucun problème à ce niveau là. Je n'ai pas encore eu à faire de l'inspecteur d'élément pour le moment. \ No newline at end of file diff --git a/content/posts/2020-10-14-bépo-sur-windows.md b/content/posts/2020-10-14-bépo-sur-windows.md new file mode 100644 index 0000000..7eafb86 --- /dev/null +++ b/content/posts/2020-10-14-bépo-sur-windows.md @@ -0,0 +1,36 @@ +--- +title: "Bépo sur Windows" +description: "Comment installer la disposition clavier spéciale français sur Windows ?" +website: dev +--- + +J'utilise depuis plusieurs années [Bépo](https://bepo.fr/wiki/Accueil) sur mes ordinateurs à la place du traditionnel Azerty. Bépo est une disposition spécialement conçue pour le français. Son principal avantage est que les touches sont placées de manière à faciliter l'écriture du français (lettres les plus communes sur la ligne de repos, alternance entre les lettres main gauche/main droite, lettres rares sur les doigts les plus faibles…). Les positions des touches sur un clavier Azerty ont été choisies afin d'éviter les contraintes mécaniques des machines à écrire, et ne sont donc pas du tout adaptées à l'écriture sur ordinateur. Bépo permet également d'utiliser facilement des caractères typographiques comme les espaces insécables fines, les guillemets français, les majuscules accentuées, etc. + +Je n'ai jamais eu aucun souci avec ma disposition sur Linux, mais après l'installation sur Windows je me suis rendu compte de deux problèmes : +- Sur Linux je tapais deux fois sur la touche accent grave afin d'écrire un « \` » (très utile pour le Markdown). Sur Windows cette technique affiche un caractère étrange « ̏` ». La seule technique que j'ai trouvée était de taper un accent grave puis une espace : beaucoup moins pratique en plus d'être une habitude difficile à changer. +- Deuxième problème, [le pilote Bépo Windows officiel](https://bepo.fr/wiki/Windows) remplace la touche « apostrophe » par des apostrophes typographiques « ’ ». C'est typographiquement le bon caractère pour de la rédaction en français mais inutilisable pour un développeur qui a besoin de l'apostrophe classique dans son code. + +J'ai donc décidé de modifier la disposition clavier classique via le logiciel [Microsoft Keyboard Layout Creator](https://www.microsoft.com/en-us/download/details.aspx?id=102134). Ce logiciel fonctionne très bien : j'ai pu importer la disposition officielle et résoudre mes deux problèmes. +- Retrait de l'option « Touche morte » sur la touche de l'accent grave. L'option « Touche morte », d'après ce que j'en ai compris, permet, en tapant une fois sur l'accent grave puis sur une lettre classique, de mettre cet accent sur la lettre. Je n'utilise jamais cette fonctionnalité car la disposition Bépo fournit déjà des touches pour toutes les lettres avec des accents graves. En retirant cette option, je n'ai maintenant qu'à appuyer une fois sur la touche pour voir s'afficher un accent grave seul. Ce changement va me demander un petit temps d'adaptation mais il sera à terme bien plus pratique que sur Linux. +- Remplacer l'apostrophe typographique par une apostrophe normale. + +Mais lors de l'export, le logiciel refuse de créer la disposition clavier. +``` +ERROR: 'VK_SPACE' in Shift State 'Ctl+Alt' must be made up of white space character(s), but is defined as '_' (U+005f) instead. +``` + +En Bépo, le « _ » est lié à la touche `Shift+Espace` et le logiciel est configuré pour lancer une erreur si un caractère autre qu'une espace est défini sur la touche espace. + +Je me suis donc demandé comment la version officielle de la disposition avait pu être compilée avec cette « erreur » et je suis tombé sur ce forum : « [Utiliser Microsoft Keyboard Layout Creator avec le fichier bepo.klc](https://forum.bepo.fr/viewtopic.php?id=1306) » expliquant comment modifier l'exécutable de Microsoft Keyboard Layout Creator pour supprimer l'erreur. + +Je recopie ici les explications au cas où le sujet du forum disparaîtrait : +- Faire une copie de l'exécutable par sécurité +- Ouvrir l'exécutable avec un éditeur hexadécimal (j'ai téléchargé [HxD](https://mh-nexus.de/en/hxd/)) +- Rechercher `2D 05 04 2D 02 17 2A 17 0A` (en faisant bien attention d'être en mode recherche hexadécimale) +- Remplacer `0A` par `2A` + +Je trouve ça incroyable qu'une modification aussi simple dans l'exécutable permette de corriger ce problème sans poser de plantage autre part. Je remercie les personnes qui ont décompilé le programme et trouvé cette solution à mon problème ! + +Il me reste encore un problème avec la touche accent circonflexe « ^ » qui, comme pour l'accent grave, m'affiche « ôô » lors d'une répétition, alors que sous Linux cela me permettait de créer le smiley « ^^ ». Mais vu que Windows possède un clavier de smiley accessible via `Windows+.` peut-être que je n'aurais pas trop à utiliser cette touche 😊. Je ne peux pas faire la même modification que pour l'accent circonflexe (retirer l'option « Touche morte ») car je l'utilise pour écrire « ô », « î » ou « û » (Bépo n'a pas de touche dédiée à ces lettres). + +Si cela vous intéresse, j'écrirai prochainement un article sur mon changement d'Azerty à Bépo, les techniques que j'ai utilisées, le temps que cela m'a pris mais ce que je peux déjà vous dire c'est qu'en 6 ans je n'ai jamais regretté le changement ! \ No newline at end of file diff --git a/content/posts/2020-10-27-j-ai-change-d-avis-sur-Firefox.md b/content/posts/2020-10-27-j-ai-change-d-avis-sur-Firefox.md new file mode 100644 index 0000000..c4c3fe2 --- /dev/null +++ b/content/posts/2020-10-27-j-ai-change-d-avis-sur-Firefox.md @@ -0,0 +1,15 @@ +--- +title: "J'ai changé d'avis sur Firefox" +description: "Pendant longtemps j'ai promu Firefox et débattu pour mettre fin au monopole de Chrome. J'avais tort." +website: dev +--- + +Pendant longtemps j'ai débattu pour mettre fin au monopole de Chrome et encourager les personnes autour de moi à utiliser un navigateur autre tel que Firefox : « Le web doit rester ouvert, si tout le monde utilise Chrome, les développeurs de Google auront la possibilité de contrôler les spécifications ». Cette affirmation reste correcte aujourd'hui mais je ne pense pas que ça soit une mauvaise chose. + +Beaucoup de personnes pensent que le web est le seul écosystème à permettre un développement multi-plateforme ce qui est complètement faux. Le contre-exemple le plus connu est Java, mais tous les langages basés sur une machine virtuelle qui elle-même est développée sur plusieurs plateformes le permette. Lorsque j'ai commencé à considérer le web comme une machine virtuelle, mon avis a changé. + +L'avantage d'une machine virtuelle est d'avoir des spécifications précises pour permettre justement un développement unique, aujourd'hui le web est sous-optimal car les spécifications sont mal respectées par les implémentations et ces dernières doivent être mises à jour individuellement. C'est comme si les développeurs Java devaient attendre que 4 JVM différentes implémentent la nouvelle spécification pour l'utiliser, ou encore qu'une méthode d'affichage GUI donne des résultats un peu différents en fonction de la JVM du client (oui je pense à toi le CSS…). + +En observant le web sous cet angle, il serait largement préférable d'avoir un seul moteur de rendu HTML/CSS et un seul interpréteur JavaScript utilisé par tous. Il serait préférable que ce moteur soit un moteur totalement open-source contrôlé par une fondation plutôt que par une entreprise mais ce n'est pas le cas aujourd'hui. Je pense que le web a déjà assez de problèmes (je pourrais en parler plus tard sur le blog…) pour rajouter en plus de ça une contrainte inutile supplémentaire. + +Cette réflexion est toute récente, j'ai peut-être manqué certains avantages de cette approche, n'hésitez pas à passer sur [mon Discord](https://discordapp.com/invite/tPtVM9V) si vous voulez discuter. Aussi, je ne connais pas d'autre machine virtuelle basée sur le même modèle que le web (avec plusieurs implémentations principales), si vous en connaissez, ça m'intéresse ! diff --git a/content/posts/3000-01-01-je-suis-accro.md b/content/posts/3000-01-01-je-suis-accro.md new file mode 100644 index 0000000..8255247 --- /dev/null +++ b/content/posts/3000-01-01-je-suis-accro.md @@ -0,0 +1,5 @@ +--- +title: "Je suis accro" +description: "La plupart des services gratuits que nous utilisons au quotidien sont développés pour nous rendre addicts, comment y rémédier ?" +website: dev +--- diff --git a/content/posts/3000-01-01-laravel-authentification.md b/content/posts/3000-01-01-laravel-authentification.md new file mode 100644 index 0000000..f2f961e --- /dev/null +++ b/content/posts/3000-01-01-laravel-authentification.md @@ -0,0 +1,15 @@ +--- +title: "Laravel autentification : Laravel UI, Jetsream, Fortify, Sanctum, Passport…" +description: "Pourquoi je n'utilise pas le système ou les systèmes d'authentification proposés par Laravel ?" +website: dev +--- + +Ces dernières années, les différents systèmes d'autentification ont émergé dans l'écosystème Laravel : que des bibliothèques officiellement supportées par le Framework ! + +Tout a commencé avec Laravel UI qui permettait via `php artisan make:auth` de créer les vues et les contrôleurs pour l'inscription, la connexion, la réinitialisation du mot de passe, etc. Je n'ai jamais utilisé ce système car il était conçu pour Bootstrap, lié à une classe `User` (et je vous rappelle que [votre application n'a pas d'utilisateurs](/posts/2017-07-18-your-app-doesnt-have-users.html)), etc. Vu que le code généré ne contenait que quelques classes et quelques bouts de HTML, il était aussi plus rapide pour moi de réécrire cette partie là afin de la maîtriser de A à Z. Je travaille rarement sur des projets courts, mon principal projet Laravel dure depuis des années et les quelques heures de gagnées en utilisant `php artisan make:auth` auraient été perdues 10 fois durant ces années de maintenance à rechercher comment personnaliser tel ou tel élément. + +Ensuite, nous avons eu Passport. Passport implémente le protocole OAuth 2 qui est un protocole extrêmement complexe, inutile dans la plupart des cas. Le protocol OAuth 2 est utile dans un ménage à trois : un visiteur qui veut s'authentifier (moi par exemple), un site qui ne veut pas gérer l'authentification (votre application Laravel) et un site connu où le visiteur a déjà un compte (Facebook). Attention, contrairement à ce que l'on pourrait croire, Passport ne permet pas de gérer la partie connexion avec Facebook (c'est le rôle d'une autre bibliothèque officielle : Socialite), Passport permet de créer le système d'authentification de Facebook. Ce qui, vous y conviendrez, n'est pas très utile. L'OAuth 2 fonctionne bien lorsque vous êtes un site connu mais pour des petites applications, il n'y a pas beaucoup d'intérêt. Je pense que la plupart des développeurs qui utilisent Passport l'utilise de manière détournée en étant le client et le serveur, dans ce cas là l'OAuth 2 ajoute une complexité énorme pour un gain nul. + +Avec Laravel 7, nous avons eu Sanctum qui est une version bien plus intéressante que Passport pour gérer ses API (application mobile, SPA…) mais encore trop complexe. Sanctum fonctionne avec des clés API à générer et à stocker en base de données avant de pouvoir les utiliser. Le principal problème c'est que ce système oblige l'utilisateur a générer ses clés sur son compte afin de les utiliser, quelque chose qui n'est pas adapté au commun des mortels. Gitub possède ce système mais c'est un site à destination des développeurs qui connaissent l'utilité d'une clé API et qui peuvent sans problème en créer une pour la renseigner à Composer par exemple. + +Avec Laravel 8 nous avons deux nouvelle bibliothèque : Fortify et Jetstream. \ No newline at end of file diff --git a/content/posts/3000-01-01-plusieurs-bureaux-virtuels-pour-travailler.md b/content/posts/3000-01-01-plusieurs-bureaux-virtuels-pour-travailler.md new file mode 100644 index 0000000..7272ecf --- /dev/null +++ b/content/posts/3000-01-01-plusieurs-bureaux-virtuels-pour-travailler.md @@ -0,0 +1,26 @@ +--- +title: "Plusieurs bureaux virtuels pour travailler ?" +description: "J'ai longtemps travaillé avec plusieurs bureaux virtuels, comment travailler avec un seul espace de travail ?" +website: dev +--- + +Je ne travaille jamais avec plusieurs écrans, j'utilisais donc la fonctionnalité des bureaux multiples. J'en utilisais 4, disposés en carré : + +``` +Firefox Thunderbird +Terminal Éditeur +``` + +L'avantage de ces 4 espaces de travail, c'est que je pouvais me rendre en deux touches de clavier, de façon déterministe vers n'importe quelle application. Mes raccourcis étaient configurés pour émuler le déplacement dans Vim, donc réduire les mouvements des mains sur le clavier : « Alt + h » pour aller à gauche, « Alt + j » pour aller en bas, « Alt + k » pour aller en haut et « Alt + l » pour aller à droite. Où que je sois, je savais que le raccourcis « Alt + h, Alt + k » m'emmenaient à Firefox, « Alt + h, Alt + j » au terminal, etc. + +Je pouvais également avoir une deuxième application sur chaque bureau en fonction des besoins (régulièrement Discord avec Firefox, et Github Desktop avec mon éditeur). Dans ce cas, j'utilisais « Alt + Tab » sur le bureau en question pour alterner les deux fenêtres. + +J'ai trouvé cette organisation très efficace pendant plusieurs années (avec [KDE](https://kde.org/), puis [bspwm](https://github.com/baskerville/bspwm)) jusqu'à récemment où j'ai dû passer à Windows à la place de mon ArchLinux. C'était d'ailleurs dans [mes problèmes possibles de mon premier article sur Windows](/posts/2020-10-13-projet-windows.html). + +Effectivement, comme je le pensais, Windows possède des bureaux virtuels limités en ligne horizontale, et même si j'aurais pu trouver une application tierce ou un menu dans les paramètres pour configurer tout ça, j'ai préféré expérimenter avec un seul bureau. + +Avec un seul bureau, j'utilise principalement « Alt + Tab » pour changer d'application. Le problème de cette méthode c'est qu'elle n'est pas déterministe. Lorsque vous avez deux applications ouvertes, vous pouvez être sûr de la prochaine application après un « Alt + Tab ». Avec 3 fenêtres, il faut retenir l'ordre dans lequel vous avez visité les applications la dernière fois pour savoir où un (ou deux) « Alt + Tab » vont vous mener. À partir de 4 applications ça me semble presque impossible de retenir où un, deux et trois « Alt + Tab » vont rediriger. + +Au quotidien, je trouve cette organisation peu efficace car elle me limite à 3 applications ouvertes mais c'est également un point très positif, si je dois choisir trois applications ça sera : Microsoft Edge, Windows Terminal et Visual Studio Code. Sous Windows, je n'ai donc pas la place d'ouvrir Discord ou Thunderbird et je me rends compte à la fin de la journée que je regarde beaucoup moins mes mails ou mes notifications en travaillant. + +Pour conclure, je suis assez satisfait de cette organisation avec 3 applications ouvertes, sous réserve qu'après plusieurs semaines de travail je devienne un peu plus conscient de mes déplacements via « Alt + Tab ». Aujourd'hui encore, il m'arrive de perdre un peu de temps lorsque je souhaite me rendre sur une application spécifique et que je ne sais plus trop où je me trouve de mon historique d'« Alt + Tab ». \ No newline at end of file diff --git a/content/talks/2015-02-20-bases-de-donnees-aujourdhui-et-bases-de-donnees-no-sql.md b/content/talks/2015-02-20-bases-de-donnees-aujourdhui-et-bases-de-donnees-no-sql.md new file mode 100644 index 0000000..10fd820 --- /dev/null +++ b/content/talks/2015-02-20-bases-de-donnees-aujourdhui-et-bases-de-donnees-no-sql.md @@ -0,0 +1,10 @@ +--- +title: Bases de données aujourd'hui et bases de données NoSQL +thumbnail: /images/insa/thumbnail-nosql.png +slides: /talks/insa-nosql/slides.pdf +video: https://www.youtube.com/watch?v=oIpjcqHyx2M +--- + +Cours d'1h30 devant les étudiants [ASI](http://asi.insa-rouen.fr/) de 3e année à l'[INSA de Rouen](http://www.insa-rouen.fr/) le 20 février 2015. Nous avons redonné la même présentation mise à jour le 4 mars 2016. + +La formation en bases de données de l'INSA est orientée bases de données relationnelles. Avec [Antoine Augusti](https://www.antoine-augusti.fr/), nous avons choisi un Projet Approfondissement et d'Ouverture (option encadrée par un professeur à l'INSA) sur le NoSQL. Nous avons travaillé un an sur un état de l'art des bases de données NoSQL et un prototype d'application. Pour clôturer notre projet, nous avons donné une introduction au NoSQL aux étudiants de 3e année lors de leur dernier cours de bases de données. L'intégralité de notre projet est disponible [sur Github](https://github.com/AntoineAugusti/NoSQL-etatart). diff --git a/content/talks/2015-11-26-injection-de-dependance-ou-comment-decoupler-ses-objets.md b/content/talks/2015-11-26-injection-de-dependance-ou-comment-decoupler-ses-objets.md new file mode 100644 index 0000000..0fa1eeb --- /dev/null +++ b/content/talks/2015-11-26-injection-de-dependance-ou-comment-decoupler-ses-objets.md @@ -0,0 +1,9 @@ +--- +title: L'injection de dépendance ou comment découpler ses objets +thumbnail: /images/codeurs-en-seine/thumbnail-injection-dependance.png +slides: /talks/codeurs-en-seine-injection-dependance/slides.pdf +--- + +Quickie de 15 minutes le 26 novembre 2015 à la fac de Rouen lors de [Codeurs en Seine](http://www.codeursenseine.com/). + +Ce petit quickie parlera de l'injection de dépendance : un mécanisme permettant de construire des objets totalement découplés les uns des autres mais facilement utilisable entre eux afin de créer des applications plus pérennes. Vos objets seront plus simples, les tester deviendra un vrai plaisir et la maintenance sera beaucoup plus facile. diff --git a/content/talks/2016-02-23-event-store.md b/content/talks/2016-02-23-event-store.md new file mode 100644 index 0000000..e474094 --- /dev/null +++ b/content/talks/2016-02-23-event-store.md @@ -0,0 +1,11 @@ +--- +title: Event Store +iframe: /talks/jug-event-store/index.html +slides: /talks/jug-event-store/index.html +--- + +Quickie de 15 minutes le 23 février 2016 à Seine Innopolis lors du [Normandy Java User Group](http://www.normandyjug.org/). + +Le CQRS tout le monde en parle, mais comment le mettre en place. L’event sourcing est une des solutions, et Event Store est une des bases de données NoSQL la plus intéressante dans ce domaine, voyons ce que l’on peut faire avec. + +Les slides sont également disponibles [sur Github](https://github.com/ThibaudDauce/jug-event-store). diff --git a/content/talks/2016-02-23-qu-est-ce-qu-internet.md b/content/talks/2016-02-23-qu-est-ce-qu-internet.md new file mode 100644 index 0000000..0aad44a --- /dev/null +++ b/content/talks/2016-02-23-qu-est-ce-qu-internet.md @@ -0,0 +1,11 @@ +--- +title: Qu'est-ce qu'Internet ? +iframe: /talks/jug-internet/index.html +slides: /talks/jug-internet/index.html +--- + +Quickie de 15 minutes le 23 février 2016 à Seine Innopolis lors du [Normandy Java User Group](http://www.normandyjug.org/). + +Vous l’utilisez tous les jours, toutes les heures, voir même chaque minute. Et pourtant, savez-vous vraiment ce qu’est Internet ? Comment fonctionne Internet ? + +Les slides sont également disponibles [sur Github](https://github.com/ThibaudDauce/jug-internet). diff --git a/content/talks/2017-01-31-l-event-sourcing-en-pratique-ca-donne-quoi.md b/content/talks/2017-01-31-l-event-sourcing-en-pratique-ca-donne-quoi.md new file mode 100644 index 0000000..09c8c2b --- /dev/null +++ b/content/talks/2017-01-31-l-event-sourcing-en-pratique-ca-donne-quoi.md @@ -0,0 +1,10 @@ +--- +title: L'Event Sourcing en pratique, ça donne quoi ? +iframe: /talks/orleans-tech-event-sourcing/index.html +slides: /talks/orleans-tech-event-sourcing/index.html +tweet: https://twitter.com/orleans_tech/status/826505597159890945 +--- + +Conférence d'une trentaine de minutes lors du meetup [Orléans Tech](https://orleans-tech.com/) le 31 janvier 2017. + +L'Event Sourcing en théorie c'est génial, on en parle partout, mais en pratique, l'important c'est de savoir quand l'utiliser et comment le mettre en place correctement. diff --git a/content/talks/2017-06-08-decouverte-de-laravel.md b/content/talks/2017-06-08-decouverte-de-laravel.md new file mode 100644 index 0000000..6c4b298 --- /dev/null +++ b/content/talks/2017-06-08-decouverte-de-laravel.md @@ -0,0 +1,10 @@ +--- +title: Découverte de Laravel +iframe: /talks/wild-code-school-decouverte-laravel/index.html +slides: /talks/wild-code-school-decouverte-laravel/index.html +tweet: https://twitter.com/WildSchool_Orls/status/872867406087106560 +--- + +Découverte de Laravel pendant une après-midi avec les élèves de la [Wild Code School](https://wildcodeschool.fr/) d'Orléans le 8 juin 2017. + +Présentation pendant une heure de quelques différences de développement et d'architecture entre Symfony (que les élèves étudient à temps plein) et Laravel. Puis accompagnement des élèves sur un exercice pratique de découverte de Laravel le reste de l'après midi. diff --git a/content/talks/2017-08-29-orleans-tech-programmation-fonctionnelle.md b/content/talks/2017-08-29-orleans-tech-programmation-fonctionnelle.md new file mode 100644 index 0000000..0727842 --- /dev/null +++ b/content/talks/2017-08-29-orleans-tech-programmation-fonctionnelle.md @@ -0,0 +1,10 @@ +--- +title: La programmation fonctionnelle pour les développeurs web +iframe: /talks/orleans-tech-programmation-fonctionnelle/index.html +slides: /talks/orleans-tech-programmation-fonctionnelle/index.html +tweet: https://twitter.com/orleans_tech/status/897084855112126465 +--- + +Conférence d'une trentaine de minutes lors du meetup [Orléans Tech](https://orleans-tech.com/) le 29 août 2017. + +Nous pensons tous faire de la programmation fonctionnelle lorsque nous écrivons nos fonctions PHP mais la programmation fonctionnelle c'est bien plus que ça ! Dans ce talk je montre comment en mettre en place de manière très simple et naturelle dans notre code de tous les jours. diff --git a/content/talks/2019-04-18-afup-tours-programmation-fonctionnelle.md b/content/talks/2019-04-18-afup-tours-programmation-fonctionnelle.md new file mode 100644 index 0000000..c9f4c6f --- /dev/null +++ b/content/talks/2019-04-18-afup-tours-programmation-fonctionnelle.md @@ -0,0 +1,10 @@ +--- +title: La programmation fonctionnelle pour les développeurs web v2 +iframe: /talks/afup-tours-programmation-fonctionnelle/index.html +slides: /talks/afup-tours-programmation-fonctionnelle/index.html +tweet: https://twitter.com/AFUP_Tours/status/1118932291458412546 +--- + +Conférence de 45 minutes lors du meetup de l'[AFUP Tours](https://tours.afup.org) le 18 avril 2019. + +Tous les développeurs savent ce qu'est une fonction, mais elles se font souvent voler la vedette par les objets en programmation moderne. Dans ce talk, je présente de nouveaux concepts faciles autour des fonctions permettant de simplifier votre code dans vos projets du quotidien. diff --git a/content/talks/2019-09-17-orleans-tech-conf-informatique-complexite-ecologie.md b/content/talks/2019-09-17-orleans-tech-conf-informatique-complexite-ecologie.md new file mode 100644 index 0000000..a5c1f90 --- /dev/null +++ b/content/talks/2019-09-17-orleans-tech-conf-informatique-complexite-ecologie.md @@ -0,0 +1,10 @@ +--- +title: Informatique, complexité et écologie +iframe: /talks/orleans-tech-conf-informatique-complexite-ecologie/index.html +slides: /talks/orleans-tech-conf-informatique-complexite-ecologie/index.html +tweet: https://twitter.com/orleans_tech/status/1173935000812736513 +--- + +Conférence de 30 minutes lors de la première conférence [Orléans Tech Conf](https://orleans-tech-conf.com/) le 17 septembre 2019. + +L’objectif de ce talk est de faire réfléchir les participants à l’augmentation de la complexité dans nos applications. Aujourd’hui, la moindre application web demande l’exécution de millions de lignes de code invisibles provenant de divers projets open-source pour fonctionner. Cette complexité fait que les développeurs ne sont plus aussi efficaces qu’ils le pourraient, elle entraîne également l’augmentation des bugs dans les logiciels et la diminution des performances avec un impact écologique certain. \ No newline at end of file diff --git a/content/talks/afup-tours-programmation-fonctionnelle/.gitignore b/content/talks/afup-tours-programmation-fonctionnelle/.gitignore new file mode 100644 index 0000000..6b7f95d --- /dev/null +++ b/content/talks/afup-tours-programmation-fonctionnelle/.gitignore @@ -0,0 +1,14 @@ +.idea/ +*.iml +*.iws +*.eml +out/ +.DS_Store +.svn +log/*.log +tmp/** +node_modules/ +.sass-cache +css/reveal.min.css +js/reveal.min.js +elm-stuff/ \ No newline at end of file diff --git a/content/talks/afup-tours-programmation-fonctionnelle/.travis.yml b/content/talks/afup-tours-programmation-fonctionnelle/.travis.yml new file mode 100644 index 0000000..e65e0df --- /dev/null +++ b/content/talks/afup-tours-programmation-fonctionnelle/.travis.yml @@ -0,0 +1,5 @@ +language: node_js +node_js: + - 11 +after_script: + - npm run build -- retire diff --git a/content/talks/afup-tours-programmation-fonctionnelle/CONTRIBUTING.md b/content/talks/afup-tours-programmation-fonctionnelle/CONTRIBUTING.md new file mode 100644 index 0000000..c2091e8 --- /dev/null +++ b/content/talks/afup-tours-programmation-fonctionnelle/CONTRIBUTING.md @@ -0,0 +1,23 @@ +## Contributing + +Please keep the [issue tracker](http://github.com/hakimel/reveal.js/issues) limited to **bug reports**, **feature requests** and **pull requests**. + + +### Personal Support +If you have personal support or setup questions the best place to ask those are [StackOverflow](http://stackoverflow.com/questions/tagged/reveal.js). + + +### Bug Reports +When reporting a bug make sure to include information about which browser and operating system you are on as well as the necessary steps to reproduce the issue. If possible please include a link to a sample presentation where the bug can be tested. + + +### Pull Requests +- Should follow the coding style of the file you work in, most importantly: + - Tabs to indent + - Single-quoted strings +- Should be made towards the **dev branch** +- Should be submitted from a feature/topic branch (not your master) + + +### Plugins +Please do not submit plugins as pull requests. They should be maintained in their own separate repository. More information here: https://github.com/hakimel/reveal.js/wiki/Plugin-Guidelines diff --git a/content/talks/afup-tours-programmation-fonctionnelle/LICENSE b/content/talks/afup-tours-programmation-fonctionnelle/LICENSE new file mode 100644 index 0000000..697d156 --- /dev/null +++ b/content/talks/afup-tours-programmation-fonctionnelle/LICENSE @@ -0,0 +1,19 @@ +Copyright (C) 2019 Hakim El Hattab, http://hakim.se, and reveal.js contributors + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. \ No newline at end of file diff --git a/content/talks/afup-tours-programmation-fonctionnelle/Main.elm b/content/talks/afup-tours-programmation-fonctionnelle/Main.elm new file mode 100644 index 0000000..9f09dd7 --- /dev/null +++ b/content/talks/afup-tours-programmation-fonctionnelle/Main.elm @@ -0,0 +1,26 @@ +import Browser +import Html exposing (Html, Attribute, button, div, text, input) +import Html.Attributes exposing (..) +import Html.Events exposing (onClick, onInput) + +main = + Browser.sandbox { init = init, update = update, view = view } + +type alias Model = String +type Event = NewName String-- | Reverse + +init : Model +init = "Thibaud" + +update : Event -> Model -> Model +update event oldName = case event of + NewName newName -> newName + -- Reverse -> String.reverse oldName + +view : Model -> Html Event +view name = + div [] + [ input [ placeholder "New Name", onInput NewName, value name ] [] + , button [ onClick Reverse ] [ text "Reverse Name" ] + , div [] [ text name ] + ] \ No newline at end of file diff --git a/content/talks/afup-tours-programmation-fonctionnelle/README.md b/content/talks/afup-tours-programmation-fonctionnelle/README.md new file mode 100644 index 0000000..e5a1911 --- /dev/null +++ b/content/talks/afup-tours-programmation-fonctionnelle/README.md @@ -0,0 +1,1388 @@ +# reveal.js [](https://travis-ci.org/hakimel/reveal.js)
+
+A framework for easily creating beautiful presentations using HTML. [Check out the live demo](http://revealjs.com/).
+
+reveal.js comes with a broad range of features including [nested slides](https://github.com/hakimel/reveal.js#markup), [Markdown contents](https://github.com/hakimel/reveal.js#markdown), [PDF export](https://github.com/hakimel/reveal.js#pdf-export), [speaker notes](https://github.com/hakimel/reveal.js#speaker-notes) and a [JavaScript API](https://github.com/hakimel/reveal.js#api). There's also a fully featured visual editor and platform for sharing reveal.js presentations at [slides.com](https://slides.com?ref=github).
+
+
+## Table of contents
+
+- [Online Editor](#online-editor)
+- [Installation](#installation)
+ - [Basic setup](#basic-setup)
+ - [Full setup](#full-setup)
+ - [Folder Structure](#folder-structure)
+- [Instructions](#instructions)
+ - [Markup](#markup)
+ - [Markdown](#markdown)
+ - [Element Attributes](#element-attributes)
+ - [Slide Attributes](#slide-attributes)
+- [Configuration](#configuration)
+- [Presentation Size](#presentation-size)
+- [Dependencies](#dependencies)
+- [Ready Event](#ready-event)
+- [Auto-sliding](#auto-sliding)
+- [Keyboard Bindings](#keyboard-bindings)
+- [Vertical Slide Navigation](#vertical-slide-navigation)
+- [Touch Navigation](#touch-navigation)
+- [Lazy Loading](#lazy-loading)
+- [API](#api)
+ - [Slide Changed Event](#slide-changed-event)
+ - [Presentation State](#presentation-state)
+ - [Slide States](#slide-states)
+ - [Slide Backgrounds](#slide-backgrounds)
+ - [Parallax Background](#parallax-background)
+ - [Slide Transitions](#slide-transitions)
+ - [Internal links](#internal-links)
+ - [Fragments](#fragments)
+ - [Fragment events](#fragment-events)
+ - [Code syntax highlighting](#code-syntax-highlighting)
+ - [Slide number](#slide-number)
+ - [Overview mode](#overview-mode)
+ - [Fullscreen mode](#fullscreen-mode)
+ - [Embedded media](#embedded-media)
+ - [Stretching elements](#stretching-elements)
+ - [Resize Event](#resize-event)
+ - [postMessage API](#postmessage-api)
+- [PDF Export](#pdf-export)
+- [Theming](#theming)
+- [Speaker Notes](#speaker-notes)
+ - [Share and Print Speaker Notes](#share-and-print-speaker-notes)
+ - [Server Side Speaker Notes](#server-side-speaker-notes)
+- [Multiplexing](#multiplexing)
+ - [Master presentation](#master-presentation)
+ - [Client presentation](#client-presentation)
+ - [Socket.io server](#socketio-server)
+- [MathJax](#mathjax)
+- [License](#license)
+
+#### More reading
+
+- [Changelog](https://github.com/hakimel/reveal.js/releases): Up-to-date version history.
+- [Examples](https://github.com/hakimel/reveal.js/wiki/Example-Presentations): Presentations created with reveal.js, add your own!
+- [Browser Support](https://github.com/hakimel/reveal.js/wiki/Browser-Support): Explanation of browser support and fallbacks.
+- [Plugins](https://github.com/hakimel/reveal.js/wiki/Plugins,-Tools-and-Hardware): A list of plugins that can be used to extend reveal.js.
+
+
+## Online Editor
+
+Presentations are written using HTML or Markdown but there's also an online editor for those of you who prefer a graphical interface. Give it a try at [https://slides.com](https://slides.com?ref=github).
+
+
+## Installation
+
+The **basic setup** is for authoring presentations only. The **full setup** gives you access to all reveal.js features and plugins such as speaker notes as well as the development tasks needed to make changes to the source.
+
+### Basic setup
+
+The core of reveal.js is very easy to install. You'll simply need to download a copy of this repository and open the index.html file directly in your browser.
+
+1. Download the latest version of reveal.js from
+
+
+
+
+
+
+```
+
+The presentation markup hierarchy needs to be `.reveal > .slides > section` where the `section` represents one slide and can be repeated indefinitely. If you place multiple `section` elements inside of another `section` they will be shown as vertical slides. The first of the vertical slides is the "root" of the others (at the top), and will be included in the horizontal sequence. For example:
+
+```html
+
+
+
+```
+
+### Markdown
+
+It's possible to write your slides using Markdown. To enable Markdown, add the `data-markdown` attribute to your ` elements
+ { src: 'plugin/highlight/highlight.js', async: true, callback: function() { hljs.initHighlightingOnLoad(); } },
+
+ // Zoom in and out with Alt+click
+ { src: 'plugin/zoom-js/zoom.js', async: true },
+
+ // Speaker notes
+ { src: 'plugin/notes/notes.js', async: true },
+
+ // MathJax
+ { src: 'plugin/math/math.js', async: true }
+ ]
+});
+```
+
+You can add your own extensions using the same syntax. The following properties are available for each dependency object:
+- **src**: Path to the script to load
+- **async**: [optional] Flags if the script should load after reveal.js has started, defaults to false
+- **callback**: [optional] Function to execute when the script has loaded
+- **condition**: [optional] Function which must return true for the script to be loaded
+
+### Ready Event
+
+A `ready` event is fired when reveal.js has loaded all non-async dependencies and is ready to start navigating. To check if reveal.js is already 'ready' you can call `Reveal.isReady()`.
+
+```javascript
+Reveal.addEventListener( 'ready', function( event ) {
+ // event.currentSlide, event.indexh, event.indexv
+} );
+```
+
+Note that we also add a `.ready` class to the `.reveal` element so that you can hook into this with CSS.
+
+### Auto-sliding
+
+Presentations can be configured to progress through slides automatically, without any user input. To enable this you will need to tell the framework how many milliseconds it should wait between slides:
+
+```javascript
+// Slide every five seconds
+Reveal.configure({
+ autoSlide: 5000
+});
+```
+
+When this is turned on a control element will appear that enables users to pause and resume auto-sliding. Alternatively, sliding can be paused or resumed by pressing »A« on the keyboard. Sliding is paused automatically as soon as the user starts navigating. You can disable these controls by specifying `autoSlideStoppable: false` in your reveal.js config.
+
+You can also override the slide duration for individual slides and fragments by using the `data-autoslide` attribute:
+
+```html
+
+ After 2 seconds the first fragment will be shown.
+ After 10 seconds the next fragment will be shown.
+ Now, the fragment is displayed for 2 seconds before the next slide is shown.
+
+```
+
+To override the method used for navigation when auto-sliding, you can specify the `autoSlideMethod` setting. To only navigate along the top layer and ignore vertical slides, set this to `Reveal.navigateRight`.
+
+Whenever the auto-slide mode is resumed or paused the `autoslideresumed` and `autoslidepaused` events are fired.
+
+### Keyboard Bindings
+
+If you're unhappy with any of the default keyboard bindings you can override them using the `keyboard` config option:
+
+```javascript
+Reveal.configure({
+ keyboard: {
+ 13: 'next', // go to the next slide when the ENTER key is pressed
+ 27: function() {}, // do something custom when ESC is pressed
+ 32: null // don't do anything when SPACE is pressed (i.e. disable a reveal.js default binding)
+ }
+});
+```
+
+### Vertical Slide Navigation
+
+Slides can be nested within other slides to create vertical stacks (see [Markup](#markup)). When presenting, you use the left/right arrows to step through the main (horizontal) slides. When you arrive at a vertical stack you can optionally press the up/down arrows to view the vertical slides or skip past them by pressing the right arrow. Here's an example showing a bird's-eye view of what this looks like in action:
+
+
+
+#### Navigation Mode
+You can finetune the reveal.js navigation behavior by using the `navigationMode` config option. Note that these options are only useful for presnetations that use a mix of horizontal and vertical slides. The following navigation modes are available:
+
+| Value | Description |
+| :--------------------------- | :---------- |
+| default | Left/right arrow keys step between horizontal slides. Up/down arrow keys step between vertical slides. Space key steps through all slides (both horizontal and vertical). |
+| linear | Removes the up/down arrows. Left/right arrows step through all slides (both horizontal and vertical). |
+| grid | When this is enabled, stepping left/right from a vertical stack to an adjacent vertical stack will land you at the same vertical index.
Consider a deck with six slides ordered in two vertical stacks:
`1.1` `2.1`
`1.2` `2.2`
`1.3` `2.3`
If you're on slide 1.3 and navigate right, you will normally move from 1.3 -> 2.1. With navigationMode set to "grid" the same navigation takes you from 1.3 -> 2.3. |
+
+### Touch Navigation
+
+You can swipe to navigate through a presentation on any touch-enabled device. Horizontal swipes change between horizontal slides, vertical swipes change between vertical slides. If you wish to disable this you can set the `touch` config option to false when initializing reveal.js.
+
+If there's some part of your content that needs to remain accessible to touch events you'll need to highlight this by adding a `data-prevent-swipe` attribute to the element. One common example where this is useful is elements that need to be scrolled.
+
+### Lazy Loading
+
+When working on presentation with a lot of media or iframe content it's important to load lazily. Lazy loading means that reveal.js will only load content for the few slides nearest to the current slide. The number of slides that are preloaded is determined by the `viewDistance` configuration option.
+
+To enable lazy loading all you need to do is change your `src` attributes to `data-src` as shown below. This is supported for image, video, audio and iframe elements.
+
+```html
+
+ ![]()
+
+
+
+```
+
+#### Lazy Loading Iframes
+
+Note that lazy loaded iframes ignore the `viewDistance` configuration and will only load when their containing slide becomes visible. Iframes are also unloaded as soon as the slide is hidden.
+
+When we lazy load a video or audio element, reveal.js won't start playing that content until the slide becomes visible. However there is no way to control this for an iframe since that could contain any kind of content. That means if we loaded an iframe before the slide is visible on screen it could begin playing media and sound in the background.
+
+You can override this behavior with the `data-preload` attribute. The iframe below will be loaded
+according to the `viewDistance`.
+
+```html
+
+
+
+```
+
+You can also change the default globally with the `preloadIframes` configuration option. If set to
+`true` ALL iframes with a `data-src` attribute will be preloaded when within the `viewDistance`
+regardless of individual `data-preload` attributes. If set to `false`, all iframes will only be
+loaded when they become visible.
+
+### API
+
+The `Reveal` object exposes a JavaScript API for controlling navigation and reading state:
+
+```javascript
+// Navigation
+Reveal.slide( indexh, indexv, indexf );
+Reveal.left();
+Reveal.right();
+Reveal.up();
+Reveal.down();
+Reveal.prev();
+Reveal.next();
+Reveal.prevFragment();
+Reveal.nextFragment();
+
+// Randomize the order of slides
+Reveal.shuffle();
+
+// Toggle presentation states, optionally pass true/false to force on/off
+Reveal.toggleOverview();
+Reveal.togglePause();
+Reveal.toggleAutoSlide();
+
+// Shows a help overlay with keyboard shortcuts, optionally pass true/false
+// to force on/off
+Reveal.toggleHelp();
+
+// Change a config value at runtime
+Reveal.configure({ controls: true });
+
+// Returns the present configuration options
+Reveal.getConfig();
+
+// Fetch the current scale of the presentation
+Reveal.getScale();
+
+// Retrieves the previous and current slide elements
+Reveal.getPreviousSlide();
+Reveal.getCurrentSlide();
+
+Reveal.getIndices(); // { h: 0, v: 0, f: 0 }
+Reveal.getSlidePastCount();
+Reveal.getProgress(); // (0 == first slide, 1 == last slide)
+Reveal.getSlides(); // Array of all slides
+Reveal.getTotalSlides(); // Total number of slides
+
+// Returns the speaker notes for the current slide
+Reveal.getSlideNotes();
+
+// State checks
+Reveal.isFirstSlide();
+Reveal.isLastSlide();
+Reveal.isOverview();
+Reveal.isPaused();
+Reveal.isAutoSliding();
+
+// Returns the top-level DOM element
+getRevealElement(); // ...
+```
+
+### Custom Key Bindings
+
+Custom key bindings can be added and removed using the following Javascript API. Custom key bindings will override the default keyboard bindings, but will in turn be overridden by the user defined bindings in the ``keyboard`` config option.
+
+```javascript
+Reveal.addKeyBinding( binding, callback );
+Reveal.removeKeyBinding( keyCode );
+```
+
+For example
+
+```javascript
+// The binding parameter provides the following properties
+// keyCode: the keycode for binding to the callback
+// key: the key label to show in the help overlay
+// description: the description of the action to show in the help overlay
+Reveal.addKeyBinding( { keyCode: 84, key: 'T', description: 'Start timer' }, function() {
+ // start timer
+} )
+
+// The binding parameter can also be a direct keycode without providing the help description
+Reveal.addKeyBinding( 82, function() {
+ // reset timer
+} )
+```
+
+This allows plugins to add key bindings directly to Reveal so they can
+
+* make use of Reveal's pre-processing logic for key handling (for example, ignoring key presses when paused); and
+* be included in the help overlay (optional)
+
+### Slide Changed Event
+
+A `slidechanged` event is fired each time the slide is changed (regardless of state). The event object holds the index values of the current slide as well as a reference to the previous and current slide HTML nodes.
+
+Some libraries, like MathJax (see [#226](https://github.com/hakimel/reveal.js/issues/226#issuecomment-10261609)), get confused by the transforms and display states of slides. Often times, this can be fixed by calling their update or render function from this callback.
+
+```javascript
+Reveal.addEventListener( 'slidechanged', function( event ) {
+ // event.previousSlide, event.currentSlide, event.indexh, event.indexv
+} );
+```
+
+### Presentation State
+
+The presentation's current state can be fetched by using the `getState` method. A state object contains all of the information required to put the presentation back as it was when `getState` was first called. Sort of like a snapshot. It's a simple object that can easily be stringified and persisted or sent over the wire.
+
+```javascript
+Reveal.slide( 1 );
+// we're on slide 1
+
+var state = Reveal.getState();
+
+Reveal.slide( 3 );
+// we're on slide 3
+
+Reveal.setState( state );
+// we're back on slide 1
+```
+
+### Slide States
+
+If you set `data-state="somestate"` on a slide ``, "somestate" will be applied as a class on the document element when that slide is opened. This allows you to apply broad style changes to the page based on the active slide.
+
+Furthermore you can also listen to these changes in state via JavaScript:
+
+```javascript
+Reveal.addEventListener( 'somestate', function() {
+ // TODO: Sprinkle magic
+}, false );
+```
+
+### Slide Backgrounds
+
+Slides are contained within a limited portion of the screen by default to allow them to fit any display and scale uniformly. You can apply full page backgrounds outside of the slide area by adding a `data-background` attribute to your `` elements. Four different types of backgrounds are supported: color, image, video and iframe.
+
+#### Color Backgrounds
+
+All CSS color formats are supported, including hex values, keywords, `rgba()` or `hsl()`.
+
+```html
+
+ Color
+
+```
+
+#### Image Backgrounds
+
+By default, background images are resized to cover the full page. Available options:
+
+| Attribute | Default | Description |
+| :------------------------------- | :--------- | :---------- |
+| data-background-image | | URL of the image to show. GIFs restart when the slide opens. |
+| data-background-size | cover | See [background-size](https://developer.mozilla.org/docs/Web/CSS/background-size) on MDN. |
+| data-background-position | center | See [background-position](https://developer.mozilla.org/docs/Web/CSS/background-position) on MDN. |
+| data-background-repeat | no-repeat | See [background-repeat](https://developer.mozilla.org/docs/Web/CSS/background-repeat) on MDN. |
+| data-background-opacity | 1 | Opacity of the background image on a 0-1 scale. 0 is transparent and 1 is fully opaque. |
+
+```html
+
+ Image
+
+
+ This background image will be sized to 100px and repeated
+
+```
+
+#### Video Backgrounds
+
+Automatically plays a full size video behind the slide.
+
+| Attribute | Default | Description |
+| :--------------------------- | :------ | :---------- |
+| data-background-video | | A single video source, or a comma separated list of video sources. |
+| data-background-video-loop | false | Flags if the video should play repeatedly. |
+| data-background-video-muted | false | Flags if the audio should be muted. |
+| data-background-size | cover | Use `cover` for full screen and some cropping or `contain` for letterboxing. |
+| data-background-opacity | 1 | Opacity of the background video on a 0-1 scale. 0 is transparent and 1 is fully opaque. |
+
+```html
+
+ Video
+
+```
+
+#### Iframe Backgrounds
+
+Embeds a web page as a slide background that covers 100% of the reveal.js width and height. The iframe is in the background layer, behind your slides, and as such it's not possible to interact with it by default. To make your background interactive, you can add the `data-background-interactive` attribute.
+
+```html
+
+ Iframe
+
+```
+
+#### Background Transitions
+
+Backgrounds transition using a fade animation by default. This can be changed to a linear sliding transition by passing `backgroundTransition: 'slide'` to the `Reveal.initialize()` call. Alternatively you can set `data-background-transition` on any section with a background to override that specific transition.
+
+
+### Parallax Background
+
+If you want to use a parallax scrolling background, set the first two properties below when initializing reveal.js (the other two are optional).
+
+```javascript
+Reveal.initialize({
+
+ // Parallax background image
+ parallaxBackgroundImage: '', // e.g. "https://s3.amazonaws.com/hakim-static/reveal-js/reveal-parallax-1.jpg"
+
+ // Parallax background size
+ parallaxBackgroundSize: '', // CSS syntax, e.g. "2100px 900px" - currently only pixels are supported (don't use % or auto)
+
+ // Number of pixels to move the parallax background per slide
+ // - Calculated automatically unless specified
+ // - Set to 0 to disable movement along an axis
+ parallaxBackgroundHorizontal: 200,
+ parallaxBackgroundVertical: 50
+
+});
+```
+
+Make sure that the background size is much bigger than screen size to allow for some scrolling. [View example](http://revealjs.com/?parallaxBackgroundImage=https%3A%2F%2Fs3.amazonaws.com%2Fhakim-static%2Freveal-js%2Freveal-parallax-1.jpg¶llaxBackgroundSize=2100px%20900px).
+
+### Slide Transitions
+
+The global presentation transition is set using the `transition` config value. You can override the global transition for a specific slide by using the `data-transition` attribute:
+
+```html
+
+ This slide will override the presentation transition and zoom!
+
+
+
+ Choose from three transition speeds: default, fast or slow!
+
+```
+
+You can also use different in and out transitions for the same slide:
+
+```html
+
+ The train goes on …
+
+
+ and on …
+
+
+ and stops.
+
+
+ (Passengers entering and leaving)
+
+
+ And it starts again.
+
+```
+You can choose from `none`, `fade`, `slide`, `convex`, `concave` and `zoom`.
+### Internal links
+
+It's easy to link between slides. The first example below targets the index of another slide whereas the second targets a slide with an ID attribute (``):
+
+```html
+Link
+Link
+```
+
+You can also add relative navigation links, similar to the built in reveal.js controls, by appending one of the following classes on any element. Note that each element is automatically given an `enabled` class when it's a valid navigation route based on the current slide.
+
+```html
+
+
+
+
+
+
+```
+
+### Fragments
+
+Fragments are used to highlight individual elements on a slide. Every element with the class `fragment` will be stepped through before moving on to the next slide. Here's an example: http://revealjs.com/#/fragments
+
+The default fragment style is to start out invisible and fade in. This style can be changed by appending a different class to the fragment:
+
+```html
+
+ grow
+ shrink
+ fade-out
+ fade-up (also down, left and right!)
+ fades in, then out when we move to the next step
+ fades in, then obfuscate when we move to the next step
+ blue only once
+ highlight-red
+ highlight-green
+ highlight-blue
+
+```
+
+Multiple fragments can be applied to the same element sequentially by wrapping it, this will fade in the text on the first step and fade it back out on the second.
+
+```html
+
+
+ I'll fade in, then out
+
+
+```
+
+The display order of fragments can be controlled using the `data-fragment-index` attribute.
+
+```html
+
+ Appears last
+ Appears first
+ Appears second
+
+```
+
+### Fragment events
+
+When a slide fragment is either shown or hidden reveal.js will dispatch an event.
+
+Some libraries, like MathJax (see #505), get confused by the initially hidden fragment elements. Often times this can be fixed by calling their update or render function from this callback.
+
+```javascript
+Reveal.addEventListener( 'fragmentshown', function( event ) {
+ // event.fragment = the fragment DOM element
+} );
+Reveal.addEventListener( 'fragmenthidden', function( event ) {
+ // event.fragment = the fragment DOM element
+} );
+```
+
+### Code syntax highlighting
+
+By default, Reveal is configured with [highlight.js](https://highlightjs.org/) for code syntax highlighting. To enable syntax highlighting, you'll have to load the highlight plugin ([plugin/highlight/highlight.js](plugin/highlight/highlight.js)) and a highlight.js CSS theme (Reveal comes packaged with the Monokai themes: [lib/css/monokai.css](lib/css/monokai.css)).
+
+```javascript
+Reveal.initialize({
+ // More info https://github.com/hakimel/reveal.js#dependencies
+ dependencies: [
+ { src: 'plugin/highlight/highlight.js', async: true, callback: function() { hljs.initHighlightingOnLoad(); } },
+ ]
+});
+```
+
+Below is an example with clojure code that will be syntax highlighted. When the `data-trim` attribute is present, surrounding whitespace is automatically removed. HTML will be escaped by default. To avoid this, for example if you are using `` to call out a line of code, add the `data-noescape` attribute to the `` element.
+
+```html
+
+
+(def lazy-fib
+ (concat
+ [0 1]
+ ((fn rfib [a b]
+ (lazy-cons (+ a b) (rfib b (+ a b)))) 0 1)))
+
+
+```
+
+### Slide number
+
+If you would like to display the page number of the current slide you can do so using the `slideNumber` and `showSlideNumber` configuration values.
+
+```javascript
+// Shows the slide number using default formatting
+Reveal.configure({ slideNumber: true });
+
+// Slide number formatting can be configured using these variables:
+// "h.v": horizontal . vertical slide number (default)
+// "h/v": horizontal / vertical slide number
+// "c": flattened slide number
+// "c/t": flattened slide number / total slides
+Reveal.configure({ slideNumber: 'c/t' });
+
+// You can provide a function to fully customize the number:
+Reveal.configure({ slideNumber: function() {
+ // Ignore numbering of vertical slides
+ return [ Reveal.getIndices().h ];
+}});
+
+// Control which views the slide number displays on using the "showSlideNumber" value:
+// "all": show on all views (default)
+// "speaker": only show slide numbers on speaker notes view
+// "print": only show slide numbers when printing to PDF
+Reveal.configure({ showSlideNumber: 'speaker' });
+```
+
+### Overview mode
+
+Press »ESC« or »O« keys to toggle the overview mode on and off. While you're in this mode, you can still navigate between slides,
+as if you were at 1,000 feet above your presentation. The overview mode comes with a few API hooks:
+
+```javascript
+Reveal.addEventListener( 'overviewshown', function( event ) { /* ... */ } );
+Reveal.addEventListener( 'overviewhidden', function( event ) { /* ... */ } );
+
+// Toggle the overview mode programmatically
+Reveal.toggleOverview();
+```
+
+### Fullscreen mode
+
+Just press »F« on your keyboard to show your presentation in fullscreen mode. Press the »ESC« key to exit fullscreen mode.
+
+### Embedded media
+
+Add `data-autoplay` to your media element if you want it to automatically start playing when the slide is shown:
+
+```html
+
+```
+
+If you want to enable or disable autoplay globally, for all embedded media, you can use the `autoPlayMedia` configuration option. If you set this to `true` ALL media will autoplay regardless of individual `data-autoplay` attributes. If you initialize with `autoPlayMedia: false` NO media will autoplay.
+
+Note that embedded HTML5 ` 
+
+
+