profile
viewpoint
Fernando Tapia Rico fertapric Amsterdam, Netherlands @elixir-lang core team member

fertapric/async_with 147

The asynchronous version of Elixir's "with", resolving the dependency graph and executing the clauses in the most performant way possible!

fertapric/files 15

A service to upload files to AWS S3, in around 200 LOC of NGINX configuration!

moliware/pyunitex 5

Minimalist Python ctypes wrapper for Unitex

fertapric/xmap 3

XML to Map converter

fertapric/cldr_dates_times 0

Date & times formatting functions for the Common Locale Data Repository (CLDR) package https://github.com/elixir-cldr/cldr

fertapric/ecto 0

A toolkit for data mapping and language integrated query

fertapric/ecto_sql 0

SQL-based adapters for Ecto and database migrations

fertapric/elixir 0

Elixir is a dynamic, functional language designed for building scalable and maintainable applications

PullRequestReviewEvent

Pull request review commentelixir-lang/elixir-lang.github.com

Add v1.13 release announceent

+---+layout: post+title: Elixir v1.13 released+author: José Valim+category: Releases+excerpt: Elixir v1.13 is out with a focus on developer tooling+---++Elixir v1.13 has just been released!++Generally speaking, new Elixir versions include improvements to its primary API, the one Elixir developers use every day, and also to the foundation that powers its tooling. In this release, however, it coincided that most new functionality centers around Elixir tooling. The result is a series of quality of life improvements that will impact Elixir developers immediately as well as in the long term.++Let's check them out!++Note: this announcement contains [asciinema](https://asciinema.org) snippets. You may need to enable 3rd-party JavaScript on this site in order to see them. If JavaScript is disabled, `noscript` tags with the proper links will be shown.++## Semantic recompilation++The feature that will most and immediately benefit all Elixir developers is the series of improvements we have made to how the compiler tracks file contents.++Generally speaking, once a file changes, it may lead to other files in your codebase to be recompiled. In previous versions, however, Elixir made no effort to understand which parts of the file changed. This meant the smallest of changes to certain files, such as configuration files, could trigger a full project recompilation.++This release comes with a series of improvements that better understand how your files change. In particular:++  * An Elixir file is no longer considered as changed if its size and its digest stay the same. This avoids recompiling many files when switching or rebasing branches.++  * Changing your `mix.exs` will no longer trigger a full project recompilation, unless you specifically change the configurations used by the Elixir compiler (`:elixirc_paths` and `:elixirc_options`).++  * Changing compile-time configuration files (`config/config.exs` and any other files imported from it) now only recompiles the project files that depend on the reconfigured applications, instead of a full project recompilation. However, if you change the configuration of your application itself, the whole project is still recompiled.++  * Adding, updating or removing a dependency now only recompiles the project files that depend on the modified dependency.++  * If your project has both Erlang and Elixir files, changing an Erlang file will now recompile only the Elixir files that depend on it.++In a nutshell, Elixir went from triggering full recompilations whenever any of `mix.exs`, `config/config.exs`, `src/*`, and `mix.lock` changed on disk to semantic recompilations. Now it only fully recompiles when:++  * you change the compilation options in `mix.exs`+  * you change the configuration for the current project in `config/config.exs`++To give a more practical example, take a regular [Phoenix project](https://phoenixframework.org/). It is most likely divided in two main directories: `my_app` and `my_app_web`. Most of your usage of Phoenix' APIs will happen within the files in the `my_app_web` directory. However, if you bumped your Phoenix version or changed its configuration in previous Elixir versions, it would cause all files, in both directories, to be recompiled. With these changes, the recompilation should affect mostly the files in `my_app_web`.++> To futher clarify, the Elixir compiler is not tracking directories. It is just a consequence of how Phoenix projects are organized that most dependencies to Phoenix are within `my_app_web`.++## Code fragments++The [`Code`](https://hexdocs.pm/elixir/Code.html) module got a companion module called [`Code.Fragment`](https://hexdocs.pm/elixir/Code.Fragment.html).++The `Code` module works with complete code. For example, its functions will consider the snippet `123 +` as invalid, since the right-hand side of `+` is missing. However, our tooling, such as editors, REPLs, and code notebooks must still parse and understand such snippets, in order to provide code completion, argument suggestion, etc.++That's the goal of the `Code.Fragment` module. It contains different heuristics to analyze and return context informational of code fragments, which are code snippets that may be incomplete.++To better show the benefits of said improvements, let's talk about IEx, Elixir's interactive shell. IEx has been rewritten to use `Code.Fragment` and, in the process, it gained new functionality as part of its autocompletion system (available by hitting TAB). For example, it can now autocomplete sigils, used to [create regexes](https://hexdocs.pm/elixir/Kernel.html#sigil_r/2) or [lists of words](https://hexdocs.pm/elixir/Kernel.html#sigil_w/2), and their terminators:++<script id="asciicast-By0cGpu9xSUgflc24cVlLgPgY" src="https://asciinema.org/a/By0cGpu9xSUgflc24cVlLgPgY.js" async></script><noscript><p><a href="https://asciinema.org/a/By0cGpu9xSUgflc24cVlLgPgY">See the example in asciinema</a></p></noscript>++Similarly, you can now autocomplete struct names and their fields:++<script id="asciicast-A44auZ00saSud3l7DbOL4IMYn" src="https://asciinema.org/a/A44auZ00saSud3l7DbOL4IMYn.js" async></script><noscript><p><a href="https://asciinema.org/a/A44auZ00saSud3l7DbOL4IMYn">See the example in asciinema</a></p></noscript>++Overall, we hope the `Code.Fragment` module will become the shared foundation to power many of the tools in the ecosystem. We have also added new reflection APIs to [`Module`](https://hexdocs.pm/elixir/Module.html), which can then be used to power code intelligence features.++## mix xref++[`mix xref`](https://hexdocs.pm/mix/Mix.Tasks.Xref.html) is a tool that analyzes relationships between files. By analyzing the compile-time and runtime dependencies between them, it allows developers to understand what has to be recompiled whenever a file changes.++Elixir v1.13 comes with many improvements to `mix xref`, such as:++  * `mix xref graph` now supports `--label` to be set to "compile-connected", which returns all compile-time dependencies that lead to additional transitive dependencies.++  * A new `mix xref trace FILE` subcommand receives a file and returns all dependencies in said file, including the line and what caused said dependency (a function/macro call, an alias, a struct, etc).++  * All `mix xref` subcommands support the `--fail-above` flag, which allows you to enforce your project has at most a certain number of compile-time cycles, transitive compile-time dependencies, etc. This can be useful on Continuous Integration (CI) servers.++  * `mix xref graph` now supports multiple `--sink` and `--source` to be given.++If you haven't used `mix xref` before, it may be hard to visualize what those changes mean. If you want to learn more, you can [watch the relevant section of my ElixirConf 2021 keynote](https://youtu.be/ydjx2kKHzrM?t=772) that includes a short introduction to `mix xref`.++Those improvements came from direct feedback from the community. A special shout out to Marc-André Lafortune for the contributions and testing.++## Extended code formatting++Thanks to its sigils, Elixir provides the ability of embedding snippets in other languages inside its source code. One could use it to embed XML:++    ~X"""+    <?xml version="1.0" encoding="UTF-8"?>+    <text><![CDATA[Hello World]]></text>+    """++Or even [Zig](https://ziglang.org/), [via the Zigler project](https://github.com/ityonemo/zigler):++    ~Z"""+    /// nif: example_fun/2+    fn example_fun(value1: f64, value2: f64) bool {+      return value1 > value2;+    }+    """++However, while you can format Elixir source code with [`mix format`](https://hexdocs.pm/mix/Mix.Tasks.Format.html), you could not format the code inside snippets.++Elixir v1.13 solves this by adding plugins to `mix format`. Plugins can teach the formatter how to format new files and how to format sigils, via the `Mix.Tasks.Format` behaviour.++For example, imagine that your project uses Markdown in two distinct ways: via a custom `~M` sigil and via files with the `.md` and `.markdown` extensions. A custom plugin would look like this:++```elixir+defmodule MixMarkdownFormatter do+  @behaviour Mix.Tasks.Format++  def features(_opts) do+    [sigils: [:M], extensions: [".md", ".markdown"]]+  end++  def format(contents, opts) do+    # logic that formats markdown+  end+end+```++Now any application can use your formatter as follows:++```elixir+# .formatter.exs+[+  # Define the desired plugins+  plugins: [MixMarkdownFormatter],+  # Remember to update the inputs list to include the new extensions+  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}", "posts/*.{md,markdown}"]+]+```++We are looking forward to see how this new functionality will be used by community, especially projects like [Surface](https://github.com/surface-ui/surface) and [Phoenix LiveView](https://github.com/phoenixframework/phoenix_live_view), which provide a templating language on top of the HTML markup.++## Other bits and bytes++`SyntaxError` and `TokenMissingError` were improved to show a code snippet whenever possible:++    $ elixir -e "hello + * world"+    ** (SyntaxError) nofile:1:9: syntax error before: '*'+        |+      1 | hello + * world+        |         ^++The `Code` module has also been augmented with two functions: [`Code.string_to_quoted_with_comments/2`](https://hexdocs.pm/Code.html#string_to_quoted_with_comments/2) and [`Code.quoted_to_algebra/2`](https://hexdocs.pm/Code.html#quoted_to_algebra/2). Those functions allow someone to retrieve the Elixir AST with their original source code comments, and then convert this AST to formatted code. In other words, those functions provide a wrapper around the Elixir Code Formatter, supporting developers who wish to create tools that directly manipulate and custom format Elixir source code.++`elixir --short-version` has been added to quickly get the Elixir version, without booting the Erlang VM. The `Task` module includes performance optimizations and [new](https://hexdocs.pm/Task.html#ignore/1) [functions](https://hexdocs.pm/Task.html#completed/1). Finally, `mix test --profile-require=time` has been added to debug loading times of test suites and the recently added [`Mix.install/2`](https://hexdocs.pm/mix/Mix.html#install#2) has been improved with new options and environment variables.
`elixir --short-version` has been added to quickly get the Elixir version, without booting the Erlang VM. The `Task` module includes performance optimizations and [new](https://hexdocs.pm/elixir/Task.html#ignore/1) [functions](https://hexdocs.pm/elixir/Task.html#completed/1). Finally, `mix test --profile-require=time` has been added to debug loading times of test suites and the recently added [`Mix.install/2`](https://hexdocs.pm/mix/Mix.html#install#2) has been improved with new options and environment variables.
josevalim

comment created time in 6 days

PullRequestReviewEvent

Pull request review commentelixir-lang/elixir-lang.github.com

Add v1.13 release announceent

+---+layout: post+title: Elixir v1.13 released+author: José Valim+category: Releases+excerpt: Elixir v1.13 is out with a focus on developer tooling+---++Elixir v1.13 has just been released!++Generally speaking, new Elixir versions include improvements to its primary API, the one Elixir developers use every day, and also to the foundation that powers its tooling. In this release, however, it coincided that most new functionality centers around Elixir tooling. The result is a series of quality of life improvements that will impact Elixir developers immediately as well as in the long term.++Let's check them out!++Note: this announcement contains [asciinema](https://asciinema.org) snippets. You may need to enable 3rd-party JavaScript on this site in order to see them. If JavaScript is disabled, `noscript` tags with the proper links will be shown.++## Semantic recompilation++The feature that will most and immediately benefit all Elixir developers is the series of improvements we have made to how the compiler tracks file contents.++Generally speaking, once a a file changes, it may lead to other files in your codebase to be recompiled. In previous versions, however, Elixir made no effort to understand which parts of the file changed. This means the smallest of changes to certain files, such as configuration files, could trigger a full project recompilation.++This release comes with a series of improvements that better understand how your files change. In particular:++  * An Elixir file is no longer considered as changed if its size and its digest stay the same. This avoids recompiling many files when switching or rebasing branches.++  * Changing your `mix.exs` will no longer trigger a full project recompilation, unless you specifically change the configurations used by the Elixir compiler (`:elixirc_paths` and `:elixirc_options`).++  * Changing compile-time configuration files (`config/config.exs` and any other files imported from it) now only recompiles the project files that depend on the reconfigured applications, instead of a full project recompilation. However, if you change the configuration of your application itself, the whole project is still recompiled.++  * Adding, updating or removing a dependency now only recompiles the project files that depend on the modified dependency.++  * If your project has both Erlang and Elixir files, changing an Erlang file will now recompile only the Elixir files that depend on it.++In a nutshell, Elixir went from triggering full recompilations whenever any of `mix.exs`, `config/config.exs`, `src/*`, and `mix.lock` changed on disk to semantic recompilations. Now it only fully recompiles when:++  * you change the compilation options in `mix.exs`+  * you change the configuration for the current project in `config/config.exs`++To give a more practical example, take a regular [Phoenix project](https://phoenixframework.org/). It is most likely divided in two main directories: `my_app` and `my_app_web`. Most of your usage of Phoenix' APIs will happen within the files in the `my_app_web` diretory. However, if you bumped your Phoenix version or changed its configuration in previous Elixir versions, it would cause all files, in both directories, to recompile. With these changes, the recompilation should affect mostly the files in `my_app_web`.++> To futher clarify, the Elixir compiler is not tracking directories. It is just a consequence of how Phoenix projects are organized that most dependencies to Phoenix are within `my_app_web`.++## Code fragments++The [`Code`](https://hexdocs.pm/elixir/Code.html) module got a companion module called [`Code.Fragment`](https://hexdocs.pm/elixir/Code.Fragment.html).++The `Code` module works with complete code. For example, its functions will consider the snippet `123 +` as invalid, since the right-hand side of `+` is missing. However, our tooling, such as editors, REPLs, and code notebooks must still parse and understand such snippets, in order to provide code completion, argument suggestion, etc.++That's the goal of the `Code.Fragment` module. It contains different heuristics to analyze and return context informational of code fragments, which are code snippets that may be incomplete.++To better show the benefits of said improvements, let's talk about IEx, Elixir's interactive shell. IEx has been rewritten to use `Code.Fragment` and, in the process, it gained new functionality as part of its autocompletion system (available by hitting TAB). For example, it can now autocomplete sigils, used to [create regexes](https://hexdocs.pm/elixir/Kernel.html#sigil_r/2) or [lists of words](https://hexdocs.pm/elixir/Kernel.html#sigil_w/2), and their terminators:++<script id="asciicast-By0cGpu9xSUgflc24cVlLgPgY" src="https://asciinema.org/a/By0cGpu9xSUgflc24cVlLgPgY.js" async></script><noscript><p><a href="https://asciinema.org/a/By0cGpu9xSUgflc24cVlLgPgY">See the example in asciinema</a></p></noscript>++Similarly, you can now autocomplete struct names and their fields:++<script id="asciicast-A44auZ00saSud3l7DbOL4IMYn" src="https://asciinema.org/a/A44auZ00saSud3l7DbOL4IMYn.js" async></script><noscript><p><a href="https://asciinema.org/a/A44auZ00saSud3l7DbOL4IMYn">See the example in asciinema</a></p></noscript>++Overall, we hope the `Code.Fragment` module will become the shared foundation to power many of the tools in the ecosystem. We have also added new reflection APIs to [`Module`](https://hexdocs.pm/elixir/Module.html), which can then be used to power code intelligence features.++## mix xref++[`mix xref`](https://hexdocs.pm/mix/Mix.Tasks.Xref.html) is a tool that analyzes relationships between files. By analyzing the compile-time and runtime dependencies between them, it allows developers to understand what has to be recompiled whenever a file changes.++Elixir v1.13 comes with many improvements to `mix xref`, such as:++  * `mix xref graph` now supports `--label` to be set to "compile-connected", which returns all compile-time dependencies that lead to additional transitive dependencies.++  * A new `mix xref trace FILE` subcommand receives a file and returns all dependencies in said file, including the line and what caused said dependency (a function/macro call, an alias, a struct, etc).++  * All `mix xref` subcommands support the `--fail-above` flag, which allows you to enforce your project has at most a certain number of compile-time cycles, transitive compile-time dependencies, etc. This can be useful on Continuous Integration (CI) servers.++  * `mix xref graph` now supports multiple `--sink` and `--source` to be given.++If you haven't used `mix xref` before, it may be hard to visualize what those changes mean. If you want to learn more, you can [watch the relevant section of my ElixirConf 2021 keynote](https://youtu.be/ydjx2kKHzrM?t=772) that includes a short introduction to `mix xref`.++Those improvements came from direct feedback from the community. A special shout out to Marc-André Lafortune for the contributions and testing.++## Extended code formatting++Thanks to its sigils, Elixir provides the ability of embedding snippets in other languages inside its source code. One could use it to embed XML:++    ~X"""+    <?xml version="1.0" encoding="UTF-8"?>+    <text><![CDATA[Hello World]]></text>+    """++Or even [Zig](https://ziglang.org/), [via the Zigler project](https://github.com/ityonemo/zigler):++    ~Z"""+    /// nif: example_fun/2+    fn example_fun(value1: f64, value2: f64) bool {+      return value1 > value2;+    }+    """++However, while you can format Elixir source code with [`mix format`](https://hexdocs.pm/mix/Mix.Tasks.Format.html), you could not format the code inside snippets.++Elixir v1.13 solves this by adding plugins to `mix format`. Plugins can teach the formatter how to format new files and how to format sigils, via the `Mix.Tasks.Format` behaviour.++For example, imagine that your project uses Markdown in two distinct ways: via a custom `~M` sigil and via files with the `.md` and `.markdown` extensions. A custom plugin would look like this:++```elixir+defmodule MixMarkdownFormatter do+  @behaviour Mix.Tasks.Format++  def features(_opts) do+    [sigils: [:M], extensions: [".md", ".markdown"]]+  end++  def format(contents, opts) do+    # logic that formats markdown+  end+end+```++Now any application can use your formatter as follows:++```elixir+# .formatter.exs+[+  # Define the desired plugins+  plugins: [MixMarkdownFormatter],+  # Remember to update the inputs list to include the new extensions+  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}", "posts/*.{md,markdown}"]+]+```++We are looking forward to see how this new functionality will be used by community, especially projects like [Surface](https://github.com/surface-ui/surface) and [Phoenix LiveView](https://github.com/phoenixframework/phoenix_live_view), which provide a templating language on top of the HTML markup.++## Other bits and bytes++`SyntaxError` and `TokenMissingError` were improved to show a code snippet whenever possible:++    $ elixir -e "hello + * world"+    ** (SyntaxError) nofile:1:9: syntax error before: '*'+        |+      1 | hello + * world+        |         ^++The `Code` module has also been augmented with two functions: [`Code.string_to_quoted_with_comments/2`](https://hexdocs.pm/Code.html#string_to_quoted_with_comments/2) and [`Code.quoted_to_algebra/2`](https://hexdocs.pm/Code.html#quoted_to_algebra/2). Those functions allow someone to retrieve the Elixir AST with their original source code comments, and then convert this AST to formatted code. In other words, those functions provide a wrapper around the Elixir Code Formatter, supporting developers who wish to create tools that directly manipulate and custom format Elixir source code.
The `Code` module has also been augmented with two functions: [`Code.string_to_quoted_with_comments/2`](https://hexdocs.pm/elixir/Code.html#string_to_quoted_with_comments/2) and [`Code.quoted_to_algebra/2`](https://hexdocs.pm/elixir/Code.html#quoted_to_algebra/2). Those functions allow someone to retrieve the Elixir AST with their original source code comments, and then convert this AST to formatted code. In other words, those functions provide a wrapper around the Elixir Code Formatter, supporting developers who wish to create tools that directly manipulate and custom format Elixir source code.
josevalim

comment created time in 6 days

PullRequestReviewEvent

Pull request review commentelixir-lang/elixir-lang.github.com

Add v1.13 release announceent

+---+layout: post+title: Elixir v1.13 released+author: José Valim+category: Releases+excerpt: Elixir v1.13 is out with a focus on developer tooling+---++Elixir v1.13 has just been released!++Generally speaking, new Elixir versions include improvements to its primary API, the one Elixir developers use every day, and also to the foundation that powers its tooling. In this release, however, it coincided that most new functionality centers around Elixir tooling. The result is a series of quality of life improvements that will impact Elixir developers immediately as well as in the long term.++Let's check them out!++Note: this announcement contains [asciinema](https://asciinema.org) snippets. You may need to enable 3rd-party JavaScript on this site in order to see them. If JavaScript is disabled, `noscript` tags with the proper links will be shown.++## Semantic recompilation++The feature that will most and immediately benefit all Elixir developers is the series of improvements we have made to how the compiler tracks file contents.++Generally speaking, once a a file changes, it may lead to other files in your codebase to be recompiled. In previous versions, however, Elixir made no effort to understand which parts of the file changed. This means the smallest of changes to certain files, such as configuration files, could trigger a full project recompilation.++This release comes with a series of improvements that better understand how your files change. In particular:++  * An Elixir file is no longer considered as changed if its size and its digest stay the same. This avoids recompiling many files when switching or rebasing branches.++  * Changing your `mix.exs` will no longer trigger a full project recompilation, unless you specifically change the configurations used by the Elixir compiler (`:elixirc_paths` and `:elixirc_options`).++  * Changing compile-time configuration files (`config/config.exs` and any other files imported from it) now only recompiles the project files that depend on the reconfigured applications, instead of a full project recompilation. However, if you change the configuration of your application itself, the whole project is still recompiled.++  * Adding, updating or removing a dependency now only recompiles the project files that depend on the modified dependency.++  * If your project has both Erlang and Elixir files, changing an Erlang file will now recompile only the Elixir files that depend on it.++In a nutshell, Elixir went from triggering full recompilations whenever any of `mix.exs`, `config/config.exs`, `src/*`, and `mix.lock` changed on disk to semantic recompilations. Now it only fully recompiles when:++  * you change the compilation options in `mix.exs`+  * you change the configuration for the current project in `config/config.exs`++To give a more practical example, take a regular [Phoenix project](https://phoenixframework.org/). It is most likely divided in two main directories: `my_app` and `my_app_web`. Most of your usage of Phoenix' APIs will happen within the files in the `my_app_web` diretory. However, if you bumped your Phoenix version or changed its configuration in previous Elixir versions, it would cause all files, in both directories, to recompile. With these changes, the recompilation should affect mostly the files in `my_app_web`.
To give a more practical example, take a regular [Phoenix project](https://phoenixframework.org/). It is most likely divided in two main directories: `my_app` and `my_app_web`. Most of your usage of Phoenix' APIs will happen within the files in the `my_app_web` directory. However, if you bumped your Phoenix version or changed its configuration in previous Elixir versions, it would cause all files, in both directories, to be recompiled. With these changes, the recompilation should affect mostly the files in `my_app_web`.
josevalim

comment created time in 6 days

PullRequestReviewEvent

Pull request review commentelixir-lang/elixir-lang.github.com

Add v1.13 release announceent

+---+layout: post+title: Elixir v1.13 released+author: José Valim+category: Releases+excerpt: Elixir v1.13 is out with a focus on developer tooling+---++Elixir v1.13 has just been released!++Generally speaking, new Elixir versions include improvements to its primary API, the one Elixir developers use every day, and also to the foundation that powers its tooling. In this release, however, it coincided that most new functionality centers around Elixir tooling. The result is a series of quality of life improvements that will impact Elixir developers immediately as well as in the long term.++Let's check them out!++Note: this announcement contains [asciinema](https://asciinema.org) snippets. You may need to enable 3rd-party JavaScript on this site in order to see them. If JavaScript is disabled, `noscript` tags with the proper links will be shown.++## Semantic recompilation++The feature that will most and immediately benefit all Elixir developers is the series of improvements we have made to how the compiler tracks file contents.++Generally speaking, once a a file changes, it may lead to other files in your codebase to be recompiled. In previous versions, however, Elixir made no effort to understand which parts of the file changed. This means the smallest of changes to certain files, such as configuration files, could trigger a full project recompilation.

Minor change, but since we are talking about previous versions I would use past tense

Generally speaking, once a a file changes, it may lead to other files in your codebase to be recompiled. In previous versions, however, Elixir made no effort to understand which parts of the file changed. This meant the smallest of changes to certain files, such as configuration files, could trigger a full project recompilation.
josevalim

comment created time in 6 days

PullRequestReviewEvent

Pull request review commentelixir-lang/elixir-lang.github.com

Add v1.13 release announceent

+---+layout: post+title: Elixir v1.13 released+author: José Valim+category: Releases+excerpt: Elixir v1.13 is out with a focus on developer tooling+---++Elixir v1.13 has just been released!++Generally speaking, new Elixir versions include improvements to its primary API, the one Elixir developers use every day, and also to the foundation that powers its tooling. In this release, however, it coincided that most new functionality centers around Elixir tooling. The result is a series of quality of life improvements that will impact Elixir developers immediately as well as in the long term.++Let's check them out!++Note: this announcement contains [asciinema](https://asciinema.org) snippets. You may need to enable 3rd-party JavaScript on this site in order to see them. If JavaScript is disabled, `noscript` tags with the proper links will be shown.++## Semantic recompilation++The feature that will most and immediately benefit all Elixir developers is the series of improvements we have made to how the compiler tracks file contents.++Generally speaking, once a a file changes, it may lead to other files in your codebase to be recompiled. In previous versions, however, Elixir made no effort to understand which parts of the file changed. This means the smallest of changes to certain files, such as configuration files, could trigger a full project recompilation.
Generally speaking, once a file changes, it may lead to other files in your codebase to be recompiled. In previous versions, however, Elixir made no effort to understand which parts of the file changed. This means the smallest of changes to certain files, such as configuration files, could trigger a full project recompilation.
josevalim

comment created time in 6 days

PullRequestReviewEvent

startedlyft/cartography

started time in 11 days

pull request commentelixir-lang/elixir

Reject bidirectional formatting characters

What do you think about warning on homoglyphs/confusables?

https://www.unicode.org/Public/security/10.0.0/confusables.txt https://github.com/rust-lang/rust/blob/master/compiler/rustc_parse/src/lexer/unicode_chars.rs

josevalim

comment created time in 24 days

Pull request review commentelixir-lang/elixir-lang.github.com

transport.data.gouv.fr case

+---+layout: post+title: Embracing open data with Elixir at the Ministry of Ecological Transition in France+author: José Valim+category: Elixir in Production+excerpt: A case study of how Elixir is being used at the Ministry of Ecological Transition in France.+logo: /images/cases/logos/met-france.png+tags: open-data gov phoenix+---++*Welcome to our series of case studies about companies using Elixir in production. [See all cases](/cases.html) we have published so far.*++A group of initiatives towards innovation and open data has given the opportunity for Elixir to play a central role in exploring, validating, and visualizing transportation data across all of France. This article will show how Elixir came to power [the National Access Point for transport data in France](https://transport.data.gouv.fr/) and explore why it continues to be an excellent fit thanks to its real-time libraries, educational tooling, and orchestration capabilities.++![Sample map of transports](/images/cases/bg/met-france.png)++## State startups++In 2013, the French Government launched a Digital Services incubator, called [beta.gouv.fr](https://beta.gouv.fr), to spread the culture of digital innovation throughout the administration. They do this through State startups.++State startups are a match between a team and a mission. They help "intrapreneurs" - public servants who identify frictions and opportunities to improve the lives of their fellow citizens - tackle real-world challenges alongside a team of experts. This team of 2 to 4 people has six months to build a proof of concept ([see official website](https://beta.gouv.fr/en/)).++The insight is: instead of trying to convince other stakeholders to work towards specific goals, it is better to empower innovation and those who want to drive change. Those individuals are given a budget and the autonomy to choose the technology and assemble their team. In exchange, they must open-source and publicly document all code, costs, metrics, and statistics.++The first State Startup was [data.gouv.fr](https://www.data.gouv.fr/en), which transformed France's open data efforts from a catalog of spreadsheets into a social platform that closed the gap between the citizens consuming the data and the institutions providing them. The tool is fully [open-source](https://github.com/opendatateam/udata), allowing other countries to use it in production too.++At the time of writing, [261 State Startups](https://beta.gouv.fr/startups/) have been launched and are in various states of development.+++## Elixir drives by++In 2017, a team was assembled to begin a new state startup focused on transportation data. A European delegated regulation making it mandatory for institutions and corporations to make transportation data public was in the making. The State startup aimed at preparing the ecosystem actors for this incoming regulatory change.++To address this, the team decided to build a web application to search and visualize the existing transportation data available in [data.gouv.fr](https://www.data.gouv.fr). They initially targeted public transportation information provided by cities about buses, subways, and trams, all available in a static format called General Transit Feed Specification ([GTFS](https://gtfs.org/)) ([live example](https://transport.data.gouv.fr/resources/50471#visualization)).++The two developers of the team, Vincent Lara and Mauko Quiroga, had heard about Elixir and were interested in learning more. They understood it could provide a robust but flexible and fun platform to explore the problem space. So [they bootstrapped the application](https://github.com/etalab/transport-site/commit/837a048c37ac31151b51ac09432dbcbff3917de5) with the [Phoenix web framework](https://phoenixframework.org/).++As they developed the system, they spotted gaps and errors in the data available. So they began validating the data and reaching out to the institutions publishing them, providing direct feedback and value to the open data platform. The incubator saw the benefits from their contributions and, after a few months, they had a successful state startup in their hands alongside the approval to continue working on their mission.++Between 2017 and 2021, the multi-disciplinary team (one public servant, “business developers”, and technical staff)  worked to increase the coverage of published transportation data and helped cities and operators to reach their technical and regulatory goals.+++## Current challenges++In 2021, the State Startup has "graduated" from its “beta gouv” incubator and is now part of France's Ministry of Ecological Transition. Now composed by Francis Chabouis,Thibaut Barrère and Antoine Augusti, the technical part of the team is tackling new use cases and challenges as the platform grows in terms of needs and versatility.++Many of those are driven by the adoption of new data formats by governments and corporations. For example, [GTFS](https://github.com/google/transit/tree/master/gtfs/spec/en) provides a static (theoretical) itinerary: if a bus is currently delayed, this information would not be available in the feed. Enter the [GTFS-RT](https://github.com/google/transit/tree/master/gtfs-realtime/spec/en) format, where RT stands for real-time, to address those gaps. The General Bikeshare Feed Specification ([GBFS](https://nabsa.net/resources/gbfs/)) ([live example](https://transport.data.gouv.fr/datasets/velos-libre-service-creteil-cristolib-disponibilite-en-temps-reel/)) tracks bicycles, scooters, carpooling, etc. Plus the [SIRI](https://en.wikipedia.org/wiki/Service_Interface_for_Real_Time_Information) (Service Interface for Real-time Information) and [NeTEx](https://en.wikipedia.org/wiki/NeTEx) families of protocols.++Some of those formats have supporting technologies (validators, converters) written in other languages (Java, Rust, etc), which would be beneficial to integrate with. The team then realized the way forward is to adapt their Elixir system to orchestrate and coordinate those subsystems. Luckily, Elixir has shown to be exceptionally well suited to this task, thanks to the underlying Erlang Virtual Machine, designed for communication systems. Francis Chabouis expands: "We currently need to integrate with internal and external services in a variety of formats. Some are static, some require periodic pulls, and others keep open connections to push data. Elixir allows us to experiment, iterate, and scale those ideas quickly".++Overall, the data catalog now includes:++++* Timetables for buses, subways, and trains, including trips and operators, as real-time updates

💅

Overall, the data catalog now includes:

* Timetables for buses, subways, and trains, including trips and operators, as real-time updates
josevalim

comment created time in a month

PullRequestReviewEvent
PullRequestReviewEvent

Pull request review commentelixir-lang/elixir-lang.github.com

transport.data.gouv.fr case

+---+layout: post+title: Embracing open data with Elixir at the Ministry of Ecological Transition in France+author: José Valim+category: Elixir in Production+excerpt: A case study of how Elixir is being used at the Ministry of Ecological Transition in France.+logo: /images/cases/logos/met-france.png+tags: open-data gov phoenix+---++*Welcome to our series of case studies about companies using Elixir in production. [See all cases](/cases.html) we have published so far.*++A group of initiatives towards innovation and open data has given the opportunity for Elixir to play a central role in exploring, validating, and visualizing transportation data across all of France. This article will show how Elixir came to power [the National Access Point for transport data in France](https://transport.data.gouv.fr/) and explore why it continues to be an excellent fit thanks to its real-time libraries, educational tooling, and orchestration capabilities.++![Sample map of transports](/images/cases/bg/met-france.png)++## State startups++In 2013, the French Government launched a Digital Services incubator, called [beta.gouv.fr](https://beta.gouv.fr), to spread the culture of digital innovation throughout the administration. They do this through State startups.++State startups are a match between a team and a mission. They help "intrapreneurs" - public servants who identify frictions and opportunities to improve the lives of their fellow citizens - tackle real-world challenges alongside a team of experts. This team of 2 to 4 people has six months to build a proof of concept ([see official website](https://beta.gouv.fr/en/)).++The insight is: instead of trying to convince other stakeholders to work towards specific goals, it is better to empower innovation and those who want to drive change. Those individuals are given a budget and the autonomy to choose the technology and assemble their team. In exchange, they must open-source and publicly document all code, costs, metrics, and statistics.++The first State Startup was [data.gouv.fr](https://www.data.gouv.fr/en), which transformed France's open data efforts from a catalog of spreadsheets into a social platform that closed the gap between the citizens consuming the data and the institutions providing them. The tool is fully [open-source](https://github.com/opendatateam/udata), allowing other countries to use it in production too.++At the time of writing, [261 State Startups](https://beta.gouv.fr/startups/) have been launched and are in various states of development.+++## Elixir drives by++In 2017, a team was assembled to begin a new state startup focused on transportation data. A European delegated regulation making it mandatory for institutions and corporations to make transportation data public was in the making. The State startup aimed at preparing the ecosystem actors for this incoming regulatory change.++To address this, the team decided to build a web application to search and visualize the existing transportation data available in [data.gouv.fr](https://www.data.gouv.fr). They initially targeted public transportation information provided by cities about buses, subways, and trams, all available in a static format called General Transit Feed Specification ([GTFS](https://gtfs.org/)) ([live example](https://transport.data.gouv.fr/resources/50471#visualization)).++The two developers of the team, Vincent Lara and Mauko Quiroga, had heard about Elixir and were interested in learning more. They understood it could provide a robust but flexible and fun platform to explore the problem space. So [they bootstrapped the application](https://github.com/etalab/transport-site/commit/837a048c37ac31151b51ac09432dbcbff3917de5) with the [Phoenix web framework](https://phoenixframework.org/).++As they developed the system, they spotted gaps and errors in the data available. So they began validating the data and reaching out to the institutions publishing them, providing direct feedback and value to the open data platform. The incubator saw the benefits from their contributions and, after a few months, they had a successful state startup in their hands alongside the approval to continue working on their mission.++Between 2017 and 2021, the multi-disciplinary team (one public servant, “business developers”, and technical staff)  worked to increase the coverage of published transportation data and helped cities and operators to reach their technical and regulatory goals.
Between 2017 and 2021, the multi-disciplinary team (one public servant, “business developers”, and technical staff) worked to increase the coverage of published transportation data and helped cities and operators to reach their technical and regulatory goals.
josevalim

comment created time in a month

Pull request review commentelixir-lang/elixir-lang.github.com

transport.data.gouv.fr case

+---+layout: post+title: Embracing open data with Elixir at the Ministry of Ecological Transition in France+author: José Valim+category: Elixir in Production+excerpt: A case study of how Elixir is being used at the Ministry of Ecological Transition in France.+logo: /images/cases/logos/met-france.png+tags: open-data gov phoenix+---++*Welcome to our series of case studies about companies using Elixir in production. [See all cases](/cases.html) we have published so far.*++A group of initiatives towards innovation and open data has given the opportunity for Elixir to play a central role in exploring, validating, and visualizing transportation data across all of France. This article will show how Elixir came to power [the National Access Point for transport data in France](https://transport.data.gouv.fr/) and explore why it continues to be an excellent fit thanks to its real-time libraries, educational tooling, and orchestration capabilities.++![Sample map of transports](/images/cases/bg/met-france.png)++## State startups++In 2013, the French Government launched a Digital Services incubator, called [beta.gouv.fr](https://beta.gouv.fr), to spread the culture of digital innovation throughout the administration. They do this through State startups.++State startups are a match between a team and a mission. They help "intrapreneurs" - public servants who identify frictions and opportunities to improve the lives of their fellow citizens - tackle real-world challenges alongside a team of experts. This team of 2 to 4 people has six months to build a proof of concept ([see official website](https://beta.gouv.fr/en/)).++The insight is: instead of trying to convince other stakeholders to work towards specific goals, it is better to empower innovation and those who want to drive change. Those individuals are given a budget and the autonomy to choose the technology and assemble their team. In exchange, they must open-source and publicly document all code, costs, metrics, and statistics.++The first State Startup was [data.gouv.fr](https://www.data.gouv.fr/en), which transformed France's open data efforts from a catalog of spreadsheets into a social platform that closed the gap between the citizens consuming the data and the institutions providing them. The tool is fully [open-source](https://github.com/opendatateam/udata), allowing other countries to use it in production too.++At the time of writing, [261 State Startups](https://beta.gouv.fr/startups/) have been launched and are in various states of development.+++## Elixir drives by++In 2017, a team was assembled to begin a new state startup focused on transportation data. A European delegated regulation making it mandatory for institutions and corporations to make transportation data public was in the making. The State startup aimed at preparing the ecosystem actors for this incoming regulatory change.
In 2017, a team was assembled to begin a new state startup focused on transportation data. An European delegated regulation making it mandatory for institutions and corporations to make transportation data public was in the making. The State startup aimed at preparing the ecosystem actors for this incoming regulatory change.

And I would probably rephrase:

An European delegated regulation making it mandatory for institutions and corporations to make transportation data public was in the making

Maybe something like:

Institutions and corporations were going to make transportation data public due to an European delegated regulation that was in the making

josevalim

comment created time in a month

PullRequestReviewEvent

Pull request review commentelixir-lang/elixir-lang.github.com

transport.data.gouv.fr case

+---+layout: post+title: Embracing open data with Elixir at the Ministry of Ecological Transition in France+author: José Valim+category: Elixir in Production+excerpt: A case study of how Elixir is being used at the Ministry of Ecological Transition in France.+logo: /images/cases/logos/met-france.png+tags: open-data gov phoenix+---++*Welcome to our series of case studies about companies using Elixir in production. [See all cases](/cases.html) we have published so far.*++A group of initiatives towards innovation and open data has given the opportunity for Elixir to play a central role in exploring, validating, and visualizing transportation data across all of France. This article will show how Elixir came to power [the National Access Point for transport data in France](https://transport.data.gouv.fr/) and explore why it continues to be an excellent fit thanks to its real-time libraries, educational tooling, and orchestration capabilities.++![Sample map of transports](/images/cases/bg/met-france.png)++## State startups++In 2013, the French Government launched a Digital Services incubator, called [beta.gouv.fr](https://beta.gouv.fr), to spread the culture of digital innovation throughout the administration. They do this through State startups.++State startups are a match between a team and a mission. They help "intrapreneurs" - public servants who identify frictions and opportunities to improve the lives of their fellow citizens - tackle real-world challenges alongside a team of experts. This team of 2 to 4 people has six months to build a proof of concept ([see official website](https://beta.gouv.fr/en/)).++The insight is: instead of trying to convince other stakeholders to work towards specific goals, it is better to empower innovation and those who want to drive change. Those individuals are given a budget and the autonomy to choose the technology and assemble their team. In exchange, they must open-source and publicly document all code, costs, metrics, and statistics.++The first State Startup was [data.gouv.fr](https://www.data.gouv.fr/en), which transformed France's open data efforts from a catalog of spreadsheets into a social platform that closed the gap between the citizens consuming the data and the institutions providing them. The tool is fully [open-source](https://github.com/opendatateam/udata), allowing other countries to use it in production too.

Is it "State Startup" a proper noun? If it is, then we should change "State startups" in the paragraphs above, if not, then just write "state startups" :)

josevalim

comment created time in a month

startedburrito-elixir/burrito

started time in a month

startedelixir-desktop/desktop

started time in a month

Pull request review commentelixir-lang/elixir

Add URI.new/1 and URI.new!/1

 defmodule URI do     merge(parse(base), parse(rel))   end -  defp merge_paths(nil, rel_path), do: merge_paths("/", rel_path)

Should nil in path be handled for backwards compatibility (similar to what happened with ranges)?

josevalim

comment created time in a month

PullRequestReviewEvent

Pull request review commentelixir-lang/elixir

Add URI.new/1 and URI.new!/1

 defmodule URI do   defp hex_to_dec(_n), do: nil    @doc """-  Parses a well-formed URI into its components.+  Creates a new URI struct from a URI or a string.++  If a `%URI{}` struct is given, it returns `{:ok, uri}`. If a string is+  given, it will parse it and returns `{:ok, uri}`. If the string is+  invalid, it returns `{:error, part}` instead, with the invalid part of the URI.    This function can parse both absolute and relative URLs. You can check   if a URI is absolute or relative by checking if the `scheme` field is-  nil or not. Furthermore, this function expects both absolute and-  relative URIs to be well-formed and does not perform any validation.-  See the "Examples" section below.--  When a URI is given without a port, the value returned by-  `URI.default_port/1` for the URI's scheme is used for the `:port` field.+  `nil` or not. All fields may be `nil`, except for the `path`. -  When a URI hostname is an IPv6 literal, it has the `[]` unwrapped before-  being stored in the `:host` field. Note this doesn't match the formal-  grammar for hostnames, which preserves the `[]` around the IP. You can-  parse the IP address by calling `:inet.parse_address/1` (remember to-  call `String.to_charlist/1` to convert the host to a charlist before-  calling `:inet`).--  If a `%URI{}` struct is given to this function, this function returns it-  unmodified.+  When a URI is given without a port, the value returned by `URI.default_port/1`+  for the URI's scheme is used for the `:port` field. The scheme is also+  normalized to lowercase.    ## Examples -      iex> URI.parse("https://elixir-lang.org/")-      %URI{-        authority: "elixir-lang.org",+      iex> URI.new("https://elixir-lang.org/")+      {:ok, %URI{         fragment: nil,         host: "elixir-lang.org",         path: "/",         port: 443,         query: nil,         scheme: "https",         userinfo: nil-      }+      }} -      iex> URI.parse("//elixir-lang.org/")-      %URI{-        authority: "elixir-lang.org",+      iex> URI.new("//elixir-lang.org/")+      {:ok, %URI{         fragment: nil,         host: "elixir-lang.org",         path: "/",         port: nil,         query: nil,         scheme: nil,         userinfo: nil-      }+      }} -      iex> URI.parse("/foo/bar")-      %URI{-        authority: nil,+      iex> URI.new("/foo/bar")+      {:ok, %URI{         fragment: nil,         host: nil,         path: "/foo/bar",         port: nil,         query: nil,         scheme: nil,         userinfo: nil-      }+      }} -      iex> URI.parse("foo/bar")-      %URI{-        authority: nil,+      iex> URI.new("foo/bar")+      {:ok, %URI{         fragment: nil,         host: nil,         path: "foo/bar",         port: nil,         query: nil,         scheme: nil,         userinfo: nil-      }+      }} -      iex> URI.parse("//[fe80::]/")-      %URI{-        authority: "[fe80::]",+      iex> URI.new("//[fe80::]/")+      {:ok, %URI{         fragment: nil,         host: "fe80::",         path: "/",         port: nil,         query: nil,         scheme: nil,         userinfo: nil+      }}++      iex> URI.new("https:?query")+      {:ok, %URI{+        fragment: nil,+        host: nil,+        path: "",+        port: 443,+        query: "query",+        scheme: "https",+        userinfo: nil+      }}++      iex> URI.new("/invalid_greater_than_in_path/>")+      {:error, ">"}++  Giving an existing URI simply returns it wrapped in a tuple:++      iex> {:ok, uri} = URI.new("https://elixir-lang.org/")+      iex> URI.new(uri)+      {:ok, %URI{+        fragment: nil,+        host: "elixir-lang.org",+        path: "/",+        port: 443,+        query: nil,+        scheme: "https",+        userinfo: nil+      }}+  """+  def new(%URI{} = uri), do: {:ok, uri}++  def new(binary) when is_binary(binary) do+    case :uri_string.parse(binary) do+      %{} = map -> {:ok, uri_from_map(map)}+      {:error, :invalid_uri, term} -> {:error, Kernel.to_string(term)}+    end+  end++  @doc """+  Similar to `new/0` but raises `URI.Error` if an invalid string is given.++  ## Examples++      iex> URI.new!("https://elixir-lang.org/")+      %URI{+        fragment: nil,+        host: "elixir-lang.org",+        path: "/",+        port: 443,+        query: nil,+        scheme: "https",+        userinfo: nil+      }++      iex> URI.new!("/invalid_greater_than_in_path/>")+      ** (URI.Error) cannot parse due to reason invalid_uri: ">"++  Giving an existing URI simply returns it:++      iex> uri = URI.new!("https://elixir-lang.org/")+      iex> URI.new!(uri)+      %URI{+        fragment: nil,+        host: "elixir-lang.org",+        path: "/",+        port: 443,+        query: nil,+        scheme: "https",+        userinfo: nil       }   """+  def new!(%URI{} = uri), do: uri
  """
  @doc since: "1.13.0"
  @spec new!(t() | String.t()) :: t()
  def new!(%URI{} = uri), do: uri
josevalim

comment created time in a month

PullRequestReviewEvent

Pull request review commentelixir-lang/elixir

Add URI.new/1 and URI.new!/1

 defmodule URI do   defp hex_to_dec(_n), do: nil    @doc """-  Parses a well-formed URI into its components.+  Creates a new URI struct from a URI or a string.++  If a `%URI{}` struct is given, it returns `{:ok, uri}`. If a string is+  given, it will parse it and returns `{:ok, uri}`. If the string is+  invalid, it returns `{:error, part}` instead, with the invalid part of the URI.    This function can parse both absolute and relative URLs. You can check   if a URI is absolute or relative by checking if the `scheme` field is-  nil or not. Furthermore, this function expects both absolute and-  relative URIs to be well-formed and does not perform any validation.-  See the "Examples" section below.--  When a URI is given without a port, the value returned by-  `URI.default_port/1` for the URI's scheme is used for the `:port` field.+  `nil` or not. All fields may be `nil`, except for the `path`. -  When a URI hostname is an IPv6 literal, it has the `[]` unwrapped before-  being stored in the `:host` field. Note this doesn't match the formal-  grammar for hostnames, which preserves the `[]` around the IP. You can-  parse the IP address by calling `:inet.parse_address/1` (remember to-  call `String.to_charlist/1` to convert the host to a charlist before-  calling `:inet`).--  If a `%URI{}` struct is given to this function, this function returns it-  unmodified.+  When a URI is given without a port, the value returned by `URI.default_port/1`+  for the URI's scheme is used for the `:port` field. The scheme is also+  normalized to lowercase.    ## Examples -      iex> URI.parse("https://elixir-lang.org/")-      %URI{-        authority: "elixir-lang.org",+      iex> URI.new("https://elixir-lang.org/")+      {:ok, %URI{         fragment: nil,         host: "elixir-lang.org",         path: "/",         port: 443,         query: nil,         scheme: "https",         userinfo: nil-      }+      }} -      iex> URI.parse("//elixir-lang.org/")-      %URI{-        authority: "elixir-lang.org",+      iex> URI.new("//elixir-lang.org/")+      {:ok, %URI{         fragment: nil,         host: "elixir-lang.org",         path: "/",         port: nil,         query: nil,         scheme: nil,         userinfo: nil-      }+      }} -      iex> URI.parse("/foo/bar")-      %URI{-        authority: nil,+      iex> URI.new("/foo/bar")+      {:ok, %URI{         fragment: nil,         host: nil,         path: "/foo/bar",         port: nil,         query: nil,         scheme: nil,         userinfo: nil-      }+      }} -      iex> URI.parse("foo/bar")-      %URI{-        authority: nil,+      iex> URI.new("foo/bar")+      {:ok, %URI{         fragment: nil,         host: nil,         path: "foo/bar",         port: nil,         query: nil,         scheme: nil,         userinfo: nil-      }+      }} -      iex> URI.parse("//[fe80::]/")-      %URI{-        authority: "[fe80::]",+      iex> URI.new("//[fe80::]/")+      {:ok, %URI{         fragment: nil,         host: "fe80::",         path: "/",         port: nil,         query: nil,         scheme: nil,         userinfo: nil+      }}++      iex> URI.new("https:?query")+      {:ok, %URI{+        fragment: nil,+        host: nil,+        path: "",+        port: 443,+        query: "query",+        scheme: "https",+        userinfo: nil+      }}++      iex> URI.new("/invalid_greater_than_in_path/>")+      {:error, ">"}++  Giving an existing URI simply returns it wrapped in a tuple:++      iex> {:ok, uri} = URI.new("https://elixir-lang.org/")+      iex> URI.new(uri)+      {:ok, %URI{+        fragment: nil,+        host: "elixir-lang.org",+        path: "/",+        port: 443,+        query: nil,+        scheme: "https",+        userinfo: nil+      }}+  """+  def new(%URI{} = uri), do: {:ok, uri}
  """
  @doc since: "1.13.0"
  @spec new(t() | String.t()) :: {:ok, t()} | {:error, String.t()}
  def new(%URI{} = uri), do: {:ok, uri}
josevalim

comment created time in a month

PullRequestReviewEvent

Pull request review commentelixir-lang/elixir

Formatter plugins

 defmodule Mix.Tasks.Deps.Loadpaths do     end      unless "--no-load-deps" in args do-      load_paths =-        for dep <- all,-            path <- Mix.Dep.load_paths(dep) do-          _ = Code.prepend_path(path)-          path-        end--      prune_deps(config, load_paths, "--no-deps-check" in args)

Why are deps no longer pruned? Performance?

josevalim

comment created time in 3 months

PullRequestReviewEvent
more