diff --git a/README.md b/README.md index fa8ac00e6609..0d492ff16303 100644 --- a/README.md +++ b/README.md @@ -6,152 +6,123 @@ Exceptions. See /LICENSE for license information. SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception --> - +## **The Carbon Language project is an experiment exploring a future direction for the C++ programming language.** -## Table of contents +

+ Carbon goals | + Carbon and C++ | + Take a look | + Join us +

-- [Overview](#overview) -- [What about other languages?](#what-about-other-languages) -- [Project status](#project-status) -- [What will make Carbon a compelling future path for C++?](#what-will-make-carbon-a-compelling-future-path-for-c) -- [Contributing](#contributing) + +Quicksort code in Carbon. Follow the link to read more. + - + +
-## Overview +**Fast and works with C++**
-The Carbon Language project is an **_experiment_** to explore a possible, -distant future for the C++ programming language. It is designed around a -specific set of goals, priorities, and use cases: +- Performance matching C++ using LLVM, with low-level access to bits and + addresses +- Interoperate with your existing C++ code, from inheritance to templates +- Fast and scalable builds that work with your existing C++ build systems + +**Modern and evolving** + +- Solid language foundations that are easy to learn, especially if you have + used C++ +- Easy, tool-based upgrades between Carbon versions +- Safer fundamentals, and an incremental path towards a memory-safe subset + +**Welcoming open-source community** + +- Clear goals and priorities with robust governance +- Community that works to be welcoming, inclusive, and friendly +- Batteries-included approach: compiler, libraries, docs, tools, package + manager, and more + +## Carbon goals + +We believe Carbon must support: 1. Performance-critical software 2. Software and language evolution 3. Code that is easy to read, understand, and write -4. Practical safety guarantees and testing mechanisms +4. Practical safety and testing mechanisms 5. Fast and scalable development 6. Modern OS platforms, hardware architectures, and environments 7. Interoperability with and migration from existing C++ code -The first six of these represent a set of priorities for C++ shared by a -significant subset of the C++ community, industry, and ecosystem. However, C++ -is increasingly constrained by a diverse set of concerns and priorities -(including some that are irrelevant to or in opposition to these goals, such as -ABI stability), and carries a significant historical legacy that makes it -challenging to evolve effectively. The result is that these users struggle to -meet our goals using C++ today, and that is unlikely to change in the near -future. Carbon is an attempt to explore what it would look like to rapidly and -systematically re-engineer C++ into a near optimal future state along the top -six priorities, which nonetheless is still reachable through interoperability, -tooling, automation, and incremental large-scale migration efforts. +Many languages share these goals, and they can often be addressed independently +in a language's design. For the Carbon project, they are prioritized in that +order to help make clear what tradeoffs we intend to make. -For more information, see [our goals document](docs/project/goals.md). +Read the [language overview](docs/design/) for more on the language design +itself, and the [goals](docs/project/goals.md) for more on these values. -## What about other languages? +## Carbon and C++ -Other programming languages don't _currently_ address these needs effectively. -They present interoperability, migration, and performance challenges that make -it expensive and potentially impossible to migrate a large C++ code base. An -approach which requires rewriting an entire binary at once would be infeasible. -A large-scale migration must be incremental, meaning that interoperability and -tool-assisted code rewrites are critical. +If you're already a C++ developer, Carbon should have a short learning curve. It +is built out of a consistent set of language constructs that should feel +familiar. C++ code like this: -There are projects for several languages to reduce obstacles affecting migration -from C++. Some contributors to Carbon are also contributing to those efforts in -parallel in order to understand all of the options in this space. TODO: write up -a detailed analysis of these languages specifically through the lens of the -above goals. + +A snippet of C++ code. Follow the link to read it. + -One especially interesting aspect not addressed by the active and widely used -languages that might serve this purpose is that they have not been designed -specifically to enable migration from and interoperability with _today's_ C++. -They don't build on top of C++'s _existing_ ecosystem. There are only a few -significant examples of programming languages that center around incremental -migration of large existing codebases. They are specifically designed to not -require complete rewrites, new programming models, or building an entire new -stack/ecosystem. However, there is no comparable option for C++ today: +can be mechanically transformed to Carbon, like so: -- JavaScript → TypeScript -- Java → Kotlin -- C++ → **???** + +A snippet of converted Carbon code. Follow the link to read it. + -Carbon explores what it would look like to fill this gap and align it with the -above priorities. +without loss of performance or readability. Yet, translating C++ to Carbon isn't +necessary; you can call Carbon from C++ without overhead and the other way +around. You can port your library to Carbon, or write new Carbon on top of your +existing C++ investment. Carbon won't add a sea of dependencies or slow down +your performance-critical code. For example: -## Project status + +A snippet of mixed Carbon and C++ code. Follow the link to read it. + -**The project is just getting started.** Everything is at a very early stage. If -you are hoping to see lots of concrete ideas and plans, you'll probably want to -check back in 6 months to a year. At this stage, we're just beginning to lay the -foundations. +In terms of safety, any language that can seamlessly call C++ will not be +perfectly safe in every dimension. However, Carbon's design encourages you to +use safe constructs where possible. -It is important to understand that **this is a science experiment**, not a -production effort. There are several initial questions that we want to explore -and answer with this experiment: +Ultimately, C++ carries a significant historical legacy, including around ABI +stability, that constrains its evolution. Carbon is an attempt to set a new +direction for C++ developers that allows for fast development, flexibility, and +delight without sacrificing performance, interoperability, and familiarity. -- Can we deliver a design and implementation that is familiar and compelling - to C++ programmers and supports our goals? -- How seamless and effective can we make interoperability? -- How easy and scalable can we make migration? -- Will a significant segment of the ecosystem and industry adopt Carbon given - these tradeoffs? +Read more about +[C++ interop in Carbon](docs/design/interoperability/philosophy_and_goals.md). -We are committed to learning the answers to these questions, but that may well -not result in a production language. There is a very real chance that this -project will never leave the experimental phase. Anyone considering contributing -or using Carbon should be extremely mindful of that fact: **core contributors -may abandon the experiment**. +## Take a look -While we may sometimes refer to Carbon as a language, it is crucial to -understand that the goals of this science experiment are not about new -languages, but about how to move today's C++ forward effectively. For example, a -near optimal outcome would be to convince the C++ community to adopt this as its -official path forward. +Learn more about Carbon's design: -## What will make Carbon a compelling future path for C++? +- [Project goals](docs/project/goals.md) +- [Language overview](docs/design/) +- [Executable semantics](executable_semantics/) -We hope that eventually Carbon will provide **significant advantages compared to -today's C++**. Areas where we think we can most dramatically improve C++ for -both software systems and developers are: +## Join us -- A cohesive and principled language design, even when supporting advanced - features. -- Making common coding patterns safe by default whenever practical, with - affordable security mitigations available for any unsafety. - - We will provide static checks for as many safety issues as we can by - default. - - We will provide a spectrum of build modes with different trade-offs - between dynamic safety and performance. For example: - - The default build mode will include as many dynamic safety checks as - we can while keeping the software's performance reasonable for - normal development, testing, and debugging. - - Release builds will favor performance, with opt-in dynamic safety - checks and security mitigations for applications with higher - security requirements. - - Over time, we also expect to both track and drive research into - increasing the degree of safety available without compromising our other - goals. -- Keeping our core language implementation simple, fast, and easily extended - in ways that will make all of our language tools better. -- Providing an effective, open, and inclusive language evolution process - aligned with our goals and priorities. +Carbon is committed to a welcoming and inclusive environment where everyone can +contribute. -Carbon will also aim to allow a single layer of a legacy C++ library stack to be -migrated to Carbon, without migrating the code above or below. This will make it -easier for developers to start using Carbon. Key features underpin Carbon's -compatibility and interoperability with C++: - -- The memory, execution, and threading model will be compatible with C++. -- Access to existing C++ types, interfaces, and even templates will be - provided as part of the core language. -- Carbon will be able to export types, interfaces, and templates for - consumption by C++. - -**However, Carbon's approach still requires a nearly complete re-engineering of -the language as well as large-scale migration for users.** This is extremely -expensive, and so the bar for Carbon to be a compelling direction for C++ is -very high. - -## Contributing - -Please see our [contributing guidelines](CONTRIBUTING.md) for information about -Carbon development. +- To watch for major release announcements, subscribe to + [our Carbon release post on GitHub](https://github.com/carbon-language/carbon-lang/discussions/1020) + and [star carbon-lang](https://github.com/carbon-language/carbon-lang). +- To join the design discussion, join our + [our Github forum](https://github.com/carbon-language/carbon-lang/discussions). +- See our [code of conduct](CODE_OF_CONDUCT.md) and + [contributing guidelines](CONTRIBUTING.md) for information about the Carbon + development community. +- We discuss Carbon on Discord; a public link will be forthcoming. diff --git a/docs/images/bumper.png b/docs/images/bumper.png new file mode 100644 index 000000000000..633faab2590e Binary files /dev/null and b/docs/images/bumper.png differ diff --git a/docs/images/carbon_snippet.svg b/docs/images/carbon_snippet.svg new file mode 100644 index 000000000000..e489dd6255cf --- /dev/null +++ b/docs/images/carbon_snippet.svg @@ -0,0 +1,160 @@ + + + +
+ +
+import Console;
+// Carbon
+void PrintWithTotal(v: Vector(u64)) {
+  var sum: u64 = 0;
+  for (e: u64 in v) {
+    sum += e;
+    Console.Print(e, "\n");
+  }
+  Console.Print("Total: ", sum, "\n");
+}
+
+
+ +
+ + diff --git a/docs/images/cpp_snippet.svg b/docs/images/cpp_snippet.svg new file mode 100644 index 000000000000..6a048cd52d16 --- /dev/null +++ b/docs/images/cpp_snippet.svg @@ -0,0 +1,162 @@ + + + +
+ +
+#include <vector>
+#include <iostream>
+// C++
+void PrintWithTotal(const std::vector<uint64_t>& v) {
+  uint64_t sum = 0;
+  for (uint64_t e in v) {
+    sum += e;
+    cout << e << "\n";
+  }
+  cout << "Total: " <<  sum << "\n";
+}
+
+
+
+ +
+ + diff --git a/docs/images/mixed_snippet.svg b/docs/images/mixed_snippet.svg new file mode 100644 index 000000000000..42a18b2ea345 --- /dev/null +++ b/docs/images/mixed_snippet.svg @@ -0,0 +1,161 @@ + + + +
+ +
+import Console;
+import Cpp <vector>;
+// Carbon and C++ interop
+void PrintWithTotal(v: Cpp.std.vector(Cpp.uint64_t)) {
+  var sum: u64 = 0;
+  for (e: Cpp.uint64_t in v) {
+    sum += e;
+    Console.Print(e, "\n")
+  }
+  Console.Print("Total: ", sum, "\n");
+}
+
+
+ +
+ + diff --git a/docs/images/quicksort_snippet.svg b/docs/images/quicksort_snippet.svg new file mode 100644 index 000000000000..9a1d59054260 --- /dev/null +++ b/docs/images/quicksort_snippet.svg @@ -0,0 +1,168 @@ + + + +
+ + 
+fn Partition[T:! Comparable & Movable](s: Span(T))
+     -> i32 {
+  var i: i32 = -1;
+
+  for (j: i32 in s.Indices()) {
+    if (s[j] <= s.Last()) {
+      ++i;
+      Swap(&s[i], &s[j]);
+    }
+  }
+  return i;
+}
+
+fn QuickSort[T:! Comparable & Movable](s: Span(T)) {
+  if (s.Length() <= 1) { return; }
+  let p: i32 = Partition(s);
+  QuickSort(s.Sub(0, p - 1));
+  QuickSort(s.Sub(p + 1));
+}
+
+
+
+ + diff --git a/docs/images/snippets.md b/docs/images/snippets.md new file mode 100644 index 000000000000..a64b1b6a3920 --- /dev/null +++ b/docs/images/snippets.md @@ -0,0 +1,82 @@ +# Front page snippets for Carbon + + + +## Quicksort + +A sample of quicksort in Carbon. + +```cpp +fn Partition[T:! Comparable & Movable](s: Span(T)) + -> i32 { + var i: i32 = -1; + + for (j: i32 in s.Indices()) { + if (s[j] <= s.Last()) { + ++i; + Swap(&s[i], &s[j]); + } + } + return i; +} + +fn QuickSort[T:! Comparable & Movable](s: Span(T)) { + if (s.Length() <= 1) { return; } + let p: i32 = Partition(s); + QuickSort(s.Sub(0, p - 1)); + QuickSort(s.Sub(p + 1)); +} +``` + +## Carbon and C++ + +### C++ + +```cpp +#include +#include +// C++ +void PrintWithTotal(const std::vector& v) { + uint64_t sum = 0; + for (uint64_t e in v) { + sum += e; + cout << e << "\n"; + } + cout << "Total: " << sum << "\n"; +} +``` + +### Carbon + +```cpp +import Console; +// Carbon +void PrintWithTotal(v: Vector(u64)) { + var sum: u64 = 0; + for (e: u64 in v) { + sum += e; + Console.Print(e, "\n"); + } + Console.Print("Total: ", sum, "\n") +} +``` + +### Mixed + +```cpp +import Console; +import Cpp ; +// Carbon and C++ interop +void PrintWithTotal(v: Cpp.std.vector(Cpp.uint64_t)) { + var sum: u64 = 0; + for (e: Cpp.uint64_t in v) { + sum += e; + Console.Print(e, "\n"); + } + Console.Print("Total: ", sum, "\n"); +} +```