From 0aaee03d20d7dbeb622f8f1425e197def4c8dc6e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Doeraene?= Date: Wed, 11 Oct 2023 15:30:39 +0200 Subject: [PATCH 1/2] Add the activity report for Q3 2023. --- records/2023-Q3-activity-report.md | 237 +++++++++++++++++++++++++++++ 1 file changed, 237 insertions(+) create mode 100644 records/2023-Q3-activity-report.md diff --git a/records/2023-Q3-activity-report.md b/records/2023-Q3-activity-report.md new file mode 100644 index 0000000..5d068be --- /dev/null +++ b/records/2023-Q3-activity-report.md @@ -0,0 +1,237 @@ +--- +layout: contact +title: Scala Center Activity Report for 2023 Q3 +--- + +Scala Center team: +Darja Jovanovic, 100%; +Anatolii Kmetiuk, 100%; +Adrien Piquerez, 80%; +Jamie Thompson, 100%; +Sébastien Doeraene, 100%; +Guillaume Martres, 100% until August 31, 20% since; +Julien Richard-Foy, 80% until August 31; +Johanna Reichen: 80% until August 14; +Lucas Nouguier: 100% until August 31; +Sylvie Buchard: 30% until August 31; +Valérie Meillaud: 30% since September 1; +Shiv Verkaran: 80% since September 15. +VirtusLab team: Jędrzej Rochala, 100%. + +## At a Glance +{: .no_toc} + +* Table of Contents +{:toc} + + +## Language, Compiler, Standard Library + +### Maintaining and Evolving the Scala 3 Compiler + +For Scala 3. + +Every month, about 100 new issues are opened on [the Scala 3 repository](https://github.com/lampepfl/dotty/). +The project welcomes any help it can get in triaging, bug-fixing, PR reviewing, etc. + +Our goal is to solve long-standing issues while keeping up with new ones. +We also aim to get more people involved in working on the compiler to ensure the sustainability of the project. + +We contributed PRs in various areas, but want to highlight our work on compiler performance. + +While before the compiler could depend upon the latest Zinc 1.9 API, it only called the methods that were available in Zinc 1.3 and earlier. +Using this old API added a performance hit which we removed. +This also allowed us to fully support Zinc VirtualFiles in Scala 3. +See [lampepfl/dotty#18137](https://github.com/lampepfl/dotty/pull/18137) for details. + +We improved both speed and allocation rate of the dependency extraction phase (used in incremental compilation). +We removed a performance bottleneck in code performing file IO, and massively reduced allocation rate by using more efficient caching. +When compiling the compiler itself, compared to Scala 3.3.0, we were able to reduce allocations in the phase by 80% (translating to a 6% reduction across the whole compiler pipeline) and improve the speed of the phase. +These improvements were delivered in [lampepfl/dotty#18266](https://github.com/lampepfl/dotty/pull/18266) and [lampepfl/dotty#18403](https://github.com/lampepfl/dotty/pull/18403). + +Other important compiler contributions include: + +* Soundness of the type system and of TASTy: + * [Fix #17467: Limit isNullable widening to stable TermRefs; remove under explicit nulls.](https://github.com/lampepfl/dotty/pull/17470) + * [Fix #18649: Use loBound of param types when materializing a context function.](https://github.com/lampepfl/dotty/pull/18651) +* Match types: + * [Fix #17115: Try to normalize while computing typeSize.](https://github.com/lampepfl/dotty/pull/18386) +* Optimizations of the generated code: + * [Get rid of the LiftTry phase; instead handle things in the back-end.](https://github.com/lampepfl/dotty/pull/18619) (could be backported to Scala 2) +* Tooling integration: + * [Improve SemanticDB generation by tracking symbol occurrences for class primary constructors](https://github.com/lampepfl/dotty/pull/18325) + +### Scala Improvement Process + +For Scala 3. + +The [Scala Improvement Process](https://docs.scala-lang.org/sips/) coordinates the evolution of the language. +It ensures that the decisions are made by taking into account the needs of all the stakeholders of the language. + +We organized two SIP meetings, on July 21 and September 11, 2023. + +### Better Foundations for Match Types + +For Scala 3. + +Currently, the behavior of match types is neither well specified nor implemented in a resilient way. +They cannot be explained without relying on the compiler's `TypeComparer` blackbox. +The actual behavior is inherently implementation-specific. +This is at odds with the requirement for TASTy to have a stable elaboration, and undermines the compatibility guarantees provided by TASTy. + +The lack of a good specification also has immediate practical concerns. +Questions about the expected or appropriate behavior of match types are a recurring theme, and it is sometimes hard to answer them. +Developers have a hard time knowing what they can or cannot rely on in terms of match types. + +In order to solve these problems, we analyzed the actual use cases of match types in the entire open source library ecosystem. +We then designed a new specification for match types reduction, which [we submitted as a SIP](https://github.com/scala/improvement-proposals/pull/65). +We also implemented that new specification to validate it. + +The last remaining step is for the SIP committee to review and accept it, after which we will be able to merge the new implementation. + +### Scala 3 Language Specification + +For Scala 3. + +We continued our work on writing a full specification for Scala 3, notably in the area of `enum`s and `opaque type` aliases. + +We published our work-in-progress [Scala 3 specification](https://scala-lang.org/files/archive/spec/3.4/), and [wrote a blog post](https://www.scala-lang.org/blog/2023/09/25/work-in-progress-scala-3-specification.html) about it. +We already received some feedback on it, which we partially addressed. + +Further work is still needed to complete the set of Scala 3 features. +However, this work-in-progress specification can already be used as a good foundation to evaluate new SIP proposals, and to answer some core questions. + +### Scala.js maintenance + +For Scala 2 and 3. + +We released [Scala.js 1.14.0](https://www.scala-js.org/news/2023/09/25/announcing-scalajs-1.14.0/) during this quarter. + +Other than bugfixes, the main highlights of this release come from external contributors: + +* Further improvements to the performance of the linker. +* Better ergonomics for `js.UndefOr` as seen from Scala 3 (bringing it on par with Scala 2). +* New ECMAScript core types. + +We continue to receive very positive feedback about the linker performance improvements from 1.13.1 and now this release. + +## Documentation and Education + +### Scala 3 Migration + +For migration from Scala 2 to 3. + +We released [version 0.6.2](https://github.com/scalacenter/scala3-migrate/releases/tag/v0.6.2) of sbt-scala3-migrate, the Scala 3 migration assistant plugin for sbt, on the latest Scala 3 LTS version, with up-to-date scalac options conversion. +We revamped the output messages of the plugin to improve their clarity and readability, and updated the [Scala 3 migration tutorial](https://docs.scala-lang.org/scala3/guides/migration/scala3-migrate.html) accordingly. + +We created the [scala3-migration-course](https://github.com/scalacenter/scala3-migration-course), a step-by-step course about the migration to Scala 3. +Based on the [Course Management Tools](https://github.com/eloots/course-management-tools), it guides the learner through the migration of a tailored Scala 2.13 project. +It demonstrates a number of migration issues and teaches how to solve them. +The course is self-contained and freely available online. +We used it the first time at Scala Days, during the "Moving from Scala 2 to Scala 3" workshop, to train about 10 professional programmers. + +### Scala Documentation Website + +For Scala 2 and Scala 3. + +We continued our work on migrating the website to support Scala 2 and Scala 3 syntaxes. +The purpose of this project is to provide documentation across the website that reflects the reality of mixed Scala 2.13 and Scala 3 usage. +In each page, we either mark the whole page as specific to one version version; or when describing a broader topic, for each code example, we provide tabs that show equivalent examples in either Scala 2.13 or 3. + +This quarter we added further clarifications, tabs and more to guides across the scala documentation. +Relevant PRs include: [scala/docs.scala-lang#2863](https://github.com/scala/docs.scala-lang/pull/2863), [scala/docs.scala-lang#2864](https://github.com/scala/docs.scala-lang/pull/2864), [scala/docs.scala-lang#2865](https://github.com/scala/docs.scala-lang/pull/2865), [scala/docs.scala-lang#2866](https://github.com/scala/docs.scala-lang/pull/2866), [scala/docs.scala-lang#2867](https://github.com/scala/docs.scala-lang/pull/2867), [scala/docs.scala-lang#2872](https://github.com/scala/docs.scala-lang/pull/2872), and [scala/docs.scala-lang#2873](https://github.com/scala/docs.scala-lang/pull/2873). + +## Developer Experience + +### Stable API for the Scala 3 Presentation Compiler + +For Scala 3. + +Last quarter, we had published and integrated a stable interface and implementation for the presentation compiler -- a module responsible for providing interactive features to IDEs. +Since then, we have been improving its stability, reliability and adding missing cases. + +### sbt + +For Scala 2 and Scala 3. + +We fixed the Apache Ivy External Entity Reference vulnerability ([CVE-2022-46751](https://github.com/advisories/GHSA-2jc4-r94c-rp7h)) in [sbt/ivy#46](https://github.com/sbt/ivy/pull/46) and [coursier/coursier#2823](https://github.com/coursier/coursier/pull/2823). + +We announced the ownership transfer of sbt from Lightbend to the Scala Center in a [scala-lang.org blog post](https://scala-lang.org/news/2023/08/25/sbt-license-transfer.html). + +Following the ["sbt 2 ideas" blog post](https://eed3si9n.com/sbt-2.0-ideas) and [discussion](https://github.com/sbt/sbt/discussions/7174) initiated by Eugene Yokota, we collected all the ideas and started shaping a roadmap for sbt 2. +The roadmap was presented and discussed at the Scala Days co-located Tooling Summit. +We also started the review of sbt in Scala 3 ([sbt/sbt#](https://github.com/sbt/sbt/pull/6746)) opened by Eugene Yokota earlier this year. + +### Migration of the last packages published to the JFrog artifactory + +For Scala 2 and Scala 3. + +Since the JFrog artifactory incident on April 7, 2023, we have implemented several measures to mitigate such accidents in future. +Most of the work is now finished, and we migrated all crucial packages away from the JFrog repository. +The last remaining packages are sbt native binaries. +We implemented a new repository which will serve the remaining packages to complete this project, although that is not released. + +### Debugger in Metals + +For Scala 2 and 3. + +We continued working on the stack trace view of the debugger, to print the Scala signatures of methods instead of the erased Java ones. +To do so, we are building a binary to TASTy decoder of all the classes and methods produced by the compiler. +The work-in-progress PR is [scalacenter/scala-debug-adapter#599](https://github.com/scalacenter/scala-debug-adapter/pull/599). +We tested this decoder on the class files of the Scala 3 compiler itself and we managed to decode all the classes and about 85% of the methods. +We are confident about reaching 99% coverage in the next few weeks. +We will then release the better stack traces in the debugger, and the binary to TASTy decoder as a separate library. + +## Community and Contributor Experience + +For Scala 2 and Scala 3 throughout. + +### Scastie + +The highlight of this quarter for Scastie is that it now supports autocompletion. +We improved the logic so that it works more reliably. + +Another major update is the new syntax highlighting based on tree-sitter, which is currently under review. +It is a major improvement from the previous `lezer`-based parser. + +We also improved the stability of Scastie and fixed several issues with the Metals integration ([scastie#856](https://github.com/scalacenter/scastie/pull/856), [scastie#885](https://github.com/scalacenter/scastie/pull/885), [scastie#894](https://github.com/scalacenter/scastie/pull/894), [scastie#895](https://github.com/scalacenter/scastie/pull/895), [scastie#896](https://github.com/scalacenter/scastie/pull/896), [scastie#898](https://github.com/scalacenter/scastie/pull/898), [scastie#899](https://github.com/scalacenter/scastie/pull/899)). + +### Improving the Getting Started Experience for OSS Contibutors + +We want to make contributing to Scala a more friendly and welcoming experience. +Building on our work in 2022 to improve the getting started steps for contributors [described on docs.scala-lang.org](https://docs.scala-lang.org/contribute/), we added more visible links, including to join the Scala Sprees, co-hosted with events such as Scala Days. +Relevant PRs: [scala/docs.scala-lang#2894](https://github.com/scala/docs.scala-lang/pull/2894) and [scala/docs.scala-lang#2896](https://github.com/scala/docs.scala-lang/pull/2896) + +### Scala Days and Co-Located Events + +In collaboration with Xebia Functional, we organized the Scala Days conference in Madrid and a number of co-located events around it: + +* [Scala Bridge](https://scaladays.org/madrid-2023/scala-bridge), lead by Zainab Ali and Noel Welsh - a Scala workshop for beginners to attract more newcomers without programming background to the Scala community. +* [Scala Spree](https://github.com/scalacenter/sprees), lead by Jamie Thompson - a hackathon for the Scala developers to hack on OSS projects together with the maintainers of those projects. +* Tooling Summit, lead by Chris Kipp - a meeting of the Scala tooling stakeholders to get to the same page on the future of the Scala tooling ecosystem. +* In-person [SIP](https://docs.scala-lang.org/sips/process-specification.html) meeting, lead by Anatolii Kmetiuk, where the SIP committee members got a chance to speak to each other in person and otherwise do an ordinary SIP meeting. + +In addition, we held a booth, focused on our fundraising campain (see below), and gave a few talks during the main conference: + +* "Choose your own Scala Center Roadmap": an interactive talk by the whole team where attendees selected what topics of our roadmap they wanted to hear about. +* "10 years of Scala.js", by Sébastien Doeraene +* "Polymorphic function types in Scala 3", by Guillaume Martres + +### Scala Center Fundraising Initiative + +For the first time since its inception in 2016, the Scala Center is organizing a [fundraising campaign](https://www.scala-lang.org/blog/2023/09/11/scala-center-fundraising.html). +The campaign involves attracting new [corporate sponsors](https://scala.epfl.ch/corporate-membership.html) as well as individual donors to ensure we keep [serving Scala and its ecosystem](https://scala.epfl.ch/records/first-five-years/). +Our participation to Scala Days with our booth and roadmap talk was a significant part of spreading the word and speaking to people from the community and industry who might be interested in joining the Advisory Board. + +### Governance + +We made a second iteration of the Governance page for the scala-lang.org website, and added navigation links to it in the page footer. +The changes include addition of further links, clarifications of the roles of various organisations, and more precise descriptions of various elements. +These changes were delivered in PRs [scala/scala-lang#1547](https://github.com/scala/scala-lang/pull/1547), [scala/scala-lang#1548](https://github.com/scala/scala-lang/pull/1548), [scala/docs.scala-lang#2902](https://github.com/scala/docs.scala-lang/pull/2902), and [scala/scala-lang#1553](https://github.com/scala/scala-lang/pull/1553). + +### Sustainability and Responsibility in the Scala Open Source Ecosystem + +During the last quarter, we had published [introductory blog post](https://www.scala-lang.org/blog-detail/2023/03/02/sustainability.html) about a series of interviews related the sustainability in the Scala Open Source ecosystem. + +We now published the first [interview in the series, with Goldman Sachs](https://www.scala-lang.org/blog/2023/08/23/goldman-sachs-leader-open-source-contributions.html). +We finalized several more interviews, whose releases will roll out in the coming weeks and months. From 52426904641475eb8487cdc6ffbdd5d386eaba9e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?S=C3=A9bastien=20Doeraene?= Date: Thu, 12 Oct 2023 17:46:53 +0200 Subject: [PATCH 2/2] Add the 2023 Q4 roadmap. --- records/2023-Q4-roadmap.md | 201 +++++++++++++++++++++++++++++++++++++ 1 file changed, 201 insertions(+) create mode 100644 records/2023-Q4-roadmap.md diff --git a/records/2023-Q4-roadmap.md b/records/2023-Q4-roadmap.md new file mode 100644 index 0000000..05860a1 --- /dev/null +++ b/records/2023-Q4-roadmap.md @@ -0,0 +1,201 @@ +--- +layout: contact +title: Scala Center Roadmap for 2023 Q4 +--- + +This page lists the projects that the Scala Center plans to work on during 2023 Q4. +We also post regular updates about our projects on the [Scala Contributors forum](https://contributors.scala-lang.org/c/scala-center/25). + +To have more information about our _completed_ projects, please see the [quarterly activity reports]({% link records.md %}). + +## Roadmap for 2023 Q4 +{: .no_toc} + +The following sections present our plan for the current quarter. +Every project description is followed by the concrete results we will deliver and their expected outcome on the Scala community. + +* Table of Contents +{:toc} + +### Language, Compiler, Standard Library + +Our mission is to reduce the number of bugs in the compiler implementation, to help the community to contribute to these tools, and to make sure they evolve in a way that takes into account the needs of the community. + +#### Evolve the Standard Library + +The standard library has not changed (except for bug fixes or some performance improvements) since Scala 2.13, which was released almost four years ago. +The compatibility policy of the standard library forbids the addition of new features (new classes or methods). +Furthermore, some bug fixes or performance improvements can not be applied because those compatibility guarantees. + +[Dropping the forwards binary compatibility requirement](https://github.com/scala/improvement-proposals/pull/54) is a first step to allow the introduction of new classes or the addition of new members to the existing classes. + +We will implement the technical changes in build tools and in Scala.js to make this possible: + +* in build tools, make sure that we get the most recent `scala-library` among the library dependencies, like any other library, instead of the one matching the version number of the compiler, and +* in Scala.js, rearrange the distribution mechanism of the `scalalib`, so that we can back-publish newer versions of it for existing versions of Scala.js. + +#### Scala Improvement Process + +The [Scala Improvement Process](https://docs.scala-lang.org/sips/index.html) is a process for submitting changes to the Scala language. +It aims to evolve Scala openly and collaboratively. + +We hold regular committee meetings, which we both coordinate and participate in. + +#### Compiler Performance + +In this quarter, we will continue the work we have been doing to improve compiler performance. +In particular, we expect to polish our work on pipelining, and further optimize large areas in CPU and memory profiles. + +#### Better Compilation Error Messages + +The compiler should help developers write correct code instead of "just complaining" about incorrect code. +The compiler should also guide you to write maintainable code, i.e., it should provide linting features. + +We started [a request for feedback on compile error messages](https://contributors.scala-lang.org/t/feedback-wanted-confusing-unhelpful-error-messages/6346). +We will then address, to the extent possible, the reported confusing messages, in order to make them better help the developer. + +#### Global property renaming for Scala.js + +Currently, global property renaming is delegated to GCC -- the Google Closure Compiler. +However, relying on GCC has become increasingly problematic, as they have no intention to support ECMAScript modules the way we need them to. +This means that when emitting ES modules, we deactivate GCC, resulting in larger bundle sizes. + +Local and global variable renaming can be performed by other front-end tooling, such as Rollup through Vite. +For property renaming, however, working at the JavaScript semantics level is not enough. +We have to leverage the type information and the closed world assumptions of Scala.js to achieve a similar effect. + +We will implement global property renaming in the Scala.js linker, when emitting for `fullLinkJS`, to address those issues. + +### Documentation and Education + +Our mission is to simplify the structure and content of the website, to create and maintain high-quality online educational content (including online courses), and to help the community to contribute to the website. + +#### Scala Website + +During this quarter, we will complete the consolidation of the Scala 2 and Scala 3 documentations as a single, unified one. +We are going to provide documentation across the website that reflects the reality of mixed Scala 2.13 and Scala 3 usage. +In each page, we either mark the whole page as specific to either version; or when describing a broader topic, for each code example, we provide tabs that show equivalent examples in either Scala 2.13 or 3. + +#### Language Specification + +In the past two quarters, we developed and published a first iteration of a [specification for Scala 3](https://scala-lang.org/files/archive/spec/3.4/). +Although the fundamentals are ready (notably a complete rewrite of the type system, compared to Scala 2), there are still a number of Scala 3-only features that we need to integrate. + +In this quarter, we plan to integrate the following remaining pieces: + +* `extension` methods +* `given` and `using` contextual abstractions +* behavior of structural types based on `Selectable` + +Stretch goals include type class derivation with `derives` and meta-programming with `inline def`s and quotes. + +### Developer Experience + +Our mission is to make sure the tools Scala developers use to edit, analyze, navigate through, transform, compile, run, and debug Scala programs are as easy to use as possible, that they work reliably for everyone, and deliver a great developer experience. + +#### Better Stack Traces + +The stack traces we get from the JVM are not ideal for Scala developers. +The contain a lot of compiler-generated helpers, and only display the JVM erased types of parameters and result. +These issues make them hard to read and correlate to the source code. + +With the help of tasty-query, we are developing a library that links run-time JVM classes and methods to the original TASTy symbols, corresponding to the source code, which we will release during this quarter. +This allows to build better stack traces, where compiler-generated helpers (synthetic methods) are hidden, and where types are the full, original Scala types. + +#### Scastie + +[Scastie](https://scastie.scala-lang.org) is an online Scala playground that allows everyone to write, run, and share Scala programs from their web browser. +We are continuously improving it. + +First, we are going to refactor some aspects of Scastie to build on new foundations that came out of the Tooling Summits. +We will adapt Scastie to use the new stable API for the Presentation Compiler. +We will also coordinate with the other projects that provide worksheets to use a common implementation. + +We are going to improve the rendering of types in the Scastie output. +Instead of systematically printing fully qualified types, we will minify them to match the source code for better readability. + +We will also finish and ship the support of scala-cli-based snippets, including with multiple files. + +Finally, we will keep improving the stability of the integration with Metals and the compiler. + +#### sbt 2.x + +By design, sbt 1.x uses Scala 2.12.x as for its build scripts. +As Scala 3 matures, we will eventually want a new version of sbt that leverages Scala 3. +The jump will require a new, binary incompatible version of sbt, which will be 2.x. +This is the opportunity to revisit and simplify some of sbt's design to improve the developer experience. + +Eugene Yokota wrote a post with [ideas of sbt 2.x](https://eed3si9n.com/sbt-2.0-ideas) about six months ago, and wrote [an initial PR that switches to Scala 3](https://github.com/sbt/sbt/pull/6746). +Those ideas, and others from the community, have also been [discussed on GitHub](https://github.com/sbt/sbt/discussions/7174). + +We have started coordinating and evaluating all those ideas at the Scala Center. +We are going to categorize them according to various criteria, in order to effectively prioritize them. +We will also start working on some internal simplifications of the codebase after the switch the Scala 3. + +We do not intend to work on all the ideas that are listed, but we plan to create enough favorable conditions for contributors to effectively work on them. +In particular, we will work towards merging that initial PR to switch to Scala 3, as it is impractical for any work to be done before that. + +As a stretch goal for this quarter, we will look into the ideas that would contribute to making loading sbt builds faster and lighter, from profile-based optimizations to reducing the number of settings and tasks to resolve and compute. + +#### Unblock Scala Steward support for Scala CLI projects + +[Scala Steward](https://github.com/scala-steward-org/scala-steward) is a widely used bot that automatically sends PRs to upgrade dependencies in Scala projects. +Currently, its support for scala-cli-based projects is limited. +For example, it is currently not complete enough to be adopted within the Scala Toolkit repository. + +We will make sure that support for scala-cli in Scala Steward is complete, in order to improve the developer experience of scala-cli-based projects. + +#### Twirl support in Metals + +An EPFL student drafted [support for Twirl in Metals](https://github.com/scalacenter/student-projects/issues/7) last semester. +We will polish their work and get it to a state where it can be fully reviewed and merged. + +### Community and Contributor Experience + +Our mission is to create the best environment for the emergence of a strong Scala ecosystem made of high-quality, reliable, libraries that bring simple solutions to complex problems. + +#### Ambassador Program + +We are going to develop a set of supportive tools to empower Scala enthusiasts who want to promote Scala better in their workplace and communities. + +#### Communication + +We will conduct actions aiming at communicating a positive image of Scala, and making people excited about it. + +- We will regularly share our achievements and engage the community on our projects _via_ our [LinkedIn](https://www.linkedin.com/company/scala-center/) page, +- We will create an online shop where individuals will be able to give donations to the Scala Center in exchange for goodies, +- We will speak at tech conferences and local meetups to encourage people to contribute to the Scala ecosystem, and to let non-Scala programmers know about Scala, +- We will publish two new videos (already recorded) in the series [Let’s talk about Scala 3](https://www.youtube.com/playlist?list=PLTx-VKTe8yLxYQfX_eGHCxaTuWvvG28Ml) to highlight the strengths of Scala 3. + +#### Scala Advent of Code + +As in the past two years, we will steward the participation to [Advent of Code](https://adventofcode.com/) for Scala developers. +We will keep [our Scala Advent of Code](https://scalacenter.github.io/scala-advent-of-code/) website updated and encourage community members to submit articles with their solutions. +If necessary, we will also contribute our own. + +Our objective is to provide the community with short articles that showcase Scala for the kind of problem-solving proposed by Advent of Code. +In addition, it is a fun way to build a sense of belonging to the Scala community. + +#### Fundraising Campaign + +We are continuing the fundraising campaing that we started last quarter, and widely announced around Scala Days Madrid. + +### Maintenance Work + +We will also spend a small part of our time reviewing pull requests, triaging issues, and fix issues for the following projects, to make sure important points are addressed: + +- Scala 3 compiler +- Scala 2 TASTy reader +- Scala.js +- Scaladex +- Scastie +- Coursier +- sbt +- scala-debug-adapter +- tasty-query +- tasty-mima + +## Advisory Board Proposals +{: .no_toc} + +For reference, you can see [here](https://github.com/scalacenter/advisoryboard/tree/master/proposals) the list of Advisory Board proposals and their respective status.