Improve BSP blog post intro

Author: adpi2

blog/_posts/2020-10-20-bsp-in-sbt.md renamed to blog/_posts/2020-10-27-bsp-in-sbt.md

@@ -5,13 +5,28 @@ by: Adrien Piquerez, Scala Center
 title: BSP Support in sbt 1.4
 ---
 
-The Build Server Protocol (BSP) is the result of a fruitful collaboration between the IntelliJ Scala team at JetBrains and the Scala Center at EPFL. It is a standard communication protocol that describes the interaction between IDEs and build tools. You can find its specification in the [BSP website][bsp-website].
+sbt is a prominent tool of the Scala ecosystem. Yet it is poorly integrated in our IDEs and code editors, which are used to relying on internals or third parties to perform operations like compiling, running and testing.
 
-The first version of BSP was released in June 2018. It has since been adopted by some major players of the Scala tooling ecosystem, among which IntelliJ Idea, Metals and Bloop.
+From this lack of integration derives a number of inconveniences:
+- Duplicated compilation times between sbt and the IDE
+- False compiler errors on the IDE
+- Outdated dependencies causing run-time failures
+- Conflicting Java versions
 
-Support of BSP in sbt is a [Scala Center Advisory Board Proposal][proposal], dated January 2020, initiated by [Justin Kaeser](https://github.com/jastice) from [JetBrains](https://www.jetbrains.com/) and submitted by [Bill Venners](https://github.com/bvenners) as a community representative.
+We, at the Scala Center, are dedicated to improving the tooling that benefits all Scala users. We collaborated with [JetBrains](https://www.jetbrains.com/) on designing the [Build Server Protocol][bsp-website] (BSP), a communication protocol between IDEs and build tools. It has since been adopted by some major players of the Scala tooling ecosystem, among which IntelliJ Idea, Metals and Bloop. Yet it was not supported by sbt until recently.
 
-We, at the Scala Center, had the chance to closely collaborate with [Eugene Yokota](http://eed3si9n.com/) on this proposal and we are now proud to announce that BSP is supported by [sbt 1.4.0][release-note]. In the present post we outline the motivation behind BSP in sbt and the following outcome.
+Today we are proud to announce that support of BSP has been shipped into [sbt 1.4.0][release-note].
+
+As we will see in more details, BSP in sbt improves the integration of sbt inside IDEs and code editors. It provides the user with a unified working environment that is:
+- Optimal in terms of compilation speed and reliability
+- Centralized around the sbt build definition
+- Highly customizable, by benefitting from the sbt task graph
+
+You can already try using sbt as the build server in IntelliJ Idea or Metals by following the instructions in this [Scala contributors post][instructions] or in the [sbt 1.4.0 release note][release-note]. _(Metals integration will soon become much smoother thanks to [this PR](https://github.com/scalameta/metals/pull/2154) by [Chris Kipp](https://github.com/ckipp01))_
+
+## Background
+
+Support of BSP in sbt is a [Scala Center Advisory Board Proposal][proposal], dated January 2020, initiated by [Justin Kaeser](https://github.com/jastice) from [JetBrains](https://www.jetbrains.com/) and submitted by [Bill Venners](https://github.com/bvenners) as a community representative. We, at the Scala Center, had the chance to closely collaborate with [Eugene Yokota](http://eed3si9n.com/) on this proposal.
 
 ## Motivation
 
@@ -33,7 +48,9 @@ IntelliJ Idea is also a build client, but it does not rely on a language server.
 
 With the recent built-in support of BSP in sbt, it is going to be possible for Metals and IntelliJ to connect to the sbt server and communicate with it directly. This solution is an alternative to the current status quo of using Bloop as a third-party BSP server.
 
-Bloop still offers many advantages compared to sbt server. It can serve several build clients, on different projects, and run the requests concurrently. It also supports DAP, the Debug Adapter Protocol, which provides code editors with the ability to debug applications and evaluate code at runtime.
+Bloop still offers some advantages compared to sbt server. It can serve several build clients, on different projects, and run the requests concurrently. It also supports DAP, the Debug Adapter Protocol, which provides code editors with the ability to debug applications and evaluate code at runtime.
+
+In contrast, by using sbt as the build server, you avoid potential inconsistencies, you spare duplicated compilation times, and you benefit from the customization of your build inside your IDE.
 
 Choosing Bloop or sbt as the build server depends on the project you are working on and the developer experience you are looking for. In the following paragraph we describe the main characteristics of using sbt as a build server.
 
@@ -133,11 +150,11 @@ The previous example gives us a glimpse at the possibilities opened by BSP in sb
 BSP support in sbt is a major milestone in the adoption of BSP in the Scala ecosystem. We hope that it will ease the integration of sbt for the teams working on IDEs and language servers.
 
 We also hope that it will improve the experience of the large group of all sbt users by offering them a unified working environment that meets their needs:
- - An optimal workflow for developing, compiling, testing and releasing their project.
- - A centralized source of configuration, that is the sbt build definition.
- - A high level of customization that is compatible with all environments.
+- An optimal workflow for developing, compiling, testing and releasing their project.
+- A centralized source of configuration, that is the sbt build definition.
+- A high level of customization that is compatible with all environments.
 
-The BSP implementation is very fresh in sbt 1.4.0. No doubt that the two main BSP clients, Metals and IntelliJ Idea, need some time to polish things around it. You are nonetheless very much encouraged to give it a try by following the instructions in this [Scala contributors post](https://contributors.scala-lang.org/t/build-server-protocol-in-sbt/4234/27) or in the [sbt 1.4.0 release note][release-note].
+The BSP implementation is very fresh in sbt 1.4.0. No doubt that we will need some time to round the corners. You are nonetheless very much encouraged to give it a try by following the instructions in this [Scala contributors post][instructions] or in the [sbt 1.4.0 release note][release-note].
 
 ## Links and Additional Resources
 
@@ -147,7 +164,7 @@ The BSP implementation is very fresh in sbt 1.4.0. No doubt that the two main BS
 - [The Scala Center Advisory Board proposal][proposal]
 - [The Scala Contributors thread](https://contributors.scala-lang.org/t/build-server-protocol-in-sbt/4234)
 
-
+[instructions]: https://contributors.scala-lang.org/t/build-server-protocol-in-sbt/4234/27
 [release-note]: https://eed3si9n.com/sbt-1.4.0
 [bsp-website]: https://build-server-protocol.github.io/
 [proposal]: https://github.com/scalacenter/advisoryboard/blob/master/proposals/023-bsp.md