Search for a command to run...
Hi everyone, This is Mani. Excited to join this community. I am currently working on my blog for tipseason.com for simple tutorials and interview preparation tips . Looking forward to collaborate with you all. Feel free to DM me if you need any insights about website/blog development or just to say hi 🙂 . Thanks. My website: https://tipseason.com/
Cool introduction to Carbon Mani Gopal.
I still don't quite get the need for Carbon. I we need a language with a syntax like that - there's Rust. If we need a better C successor, there D in which Google could just have invested. Is it Google's NIH syndrome or is there actual niche for something like Carbon? ;)
Google designed Carbon to handle its own issues: be able to better manage its gazillions of lines of C code.
But because it's Google, everybody and their neighbors think it's the next best thing since sliced bread... I mean until the next craze.
Engineering doesn't deserve its name. It's all about shiny experimental things and not about reliable but boring ones.
Every language has its own pros and cons. That is the reason believe it or not there are almost 20,000 programming languages in this world (Source: https://tipseason.com/top-10-most-loved-programming-languages-2022/) :-) . Carbon has it's own way to solve some of the problems encountered in C++. Let's wait and see how things evolve.
What do you think the future of carbon is ?
Mani Gopal Your argument about the number of programming language is irrelevant. I guess you're not using Malboge or Brainfuck, are you?
Because Carbon is labeled Google, you became interested. Fine. But on the opposite side, because I understand that It's all about context, I'm not. Carbon has its use-case, inside of Google. Outside, it doesn't mean squat.
Engineering is the art of choosing the right tool in one's toolbox according to the context. Choosing the most popular tool, or the one that somebody else uses just because of that, is not engineering: it's CV-driven programming (the post dates back to 2009). Nothing new under the sun, but still disappointing to see the sad state of our industry.
Chill! Not trying to support any specific language. Just exploring new things. Number of languages reference is just an anecdote :) Interesting read about CV driven programming. Thanks for sharing that.
What do you think the future of carbon is ?
I have no idea, honestly. It is from Google, so definitely some people will try to jump aboard the hype train. But probably C++ die-hards won't. I doubt it will get enough resources for newbie-programmers to learn it as a first language. So either it will get some traction as "C++ but Rust and form Google" or will join Google's cemetery of failed projects. Probably the latter.
Ya let’s wait and see how the evolution happens.
Thanks Paul. Do you plan to try Carbon lang ?
A full series for carbon programming language covering basics , syntax, working examples and detailed concepts.
Google introduced Carbon programming language with a modern language syntax to become a successor to C++. One of the challenges many beginner developers are facing is to run basic examples since the language is in a very early stage without even havi...
One of the major advancements in search engine world is the ability to provide straight forward answer to the user queries instead of giving a list of links in the search results. Take a look at this example. If you are wondering what these are, t...
The moment Google announced Carbon programming language with a goal to become a successor to C++, it brought a huge attention among Rust language communities with some of the questions like What's the comparison between Carbon language vs Rust ? Why...
Google introduced Carbon programming language with a modern language syntax to become a successor to C++. One of the challenges many beginner developers are facing is to run basic examples since the language is in a very early stage without even havi...
An ultimate case study to combine dbt data transformation at scale
Google introduced Carbon language as the next generation programming language with a goal to replace C++ as a successor. It's an open source project still in experimental phase. Originally demonstrated by Chandler Carruth in CppNorth conference, Carbon language looks like a great alternative to C++.
In this tutorial we will learn about various aspects of Carbon language and jump into carbon language basic syntax along with examples code that you can use to try the language after reading through the end of this documentation.
Let's dive in.
Carbon language can replace C++ as things evolve. C++ is already a great language to work with. It can give high performance and widely used in many production systems. It can run with multiple platforms, hardware architecture and many operating systems. However some of the problems with C++ are
So C++ is falling short of some of it's goals like Performance critical software; Software and language evolution; Code that is easy to understand and write; Fast and scalable development and so on.
Since solving these problems with C++ is really hard, after a deep research and evaluation across multiple languages by Google engineers, Carbon programming language is introduced. So it is like a successor to C++ similar to
where the left part of arrow is the original language and right part is the replacing language.
Some of the key aspects of successor languages include - Building on top of existing ecosystem, Bi-directional interoperability, Optimize learning curve , Modern tooling systems like package manager etc.
Carbon language is not inherited from legacy C or C++. It's built from scratch with modern language fundamentals such as Generics, Modular code, Consistent, Simple syntax.
As part of the Carbon language evolution, lot of factors are considered. Some of them include taking a look at garbage collected languages (like Java), more modern language such as Rust , swift , Kotlin and so on.
Rust is thoroughly evaluated as a replacement to C++. Infact Carbon language insists to use Rust and ignore Carbon if possible as Rust is technically and economically more viable language.
However for organizations that are already using C++ , it's very difficult to migrate to Rust. Software written in Rust has properties and modules that non of the languages like C++ or Carbon has. Adapting to Rust for large C++ codebases is almost not practical given that there is no inter-operability. We will talk in depth about this in a separate article soon. If you are still curious, you can learn more about it here on why Rust is not a replacement for C++.
Now that we know what Carbon language is and why we need to use it, let's dive into the actual setup/installation, syntax, examples.
Getting started with Carbon language involves installation of
For the purpose of this tutorial, we will use MacOS to install. However instructions for other operations can be similar. If you have any questions on installation you can drop a comment on this post.
To install carbon lang, run these commands in your terminal.
To install Bazel you can run
$ brew install bazelisk
This should automatically install and setup Bazel that is ready to use. If you have any errors related to permissions, the error message from Bazel will have useful command to run. Try to run that command using sudo
LLVM is the core virtual machine on which carbon language is run on. To install it
$ brew install llvm
$ export PATH="$(brew --prefix llvm)/bin:${PATH}"
One thing to note is MacOS has a default llvm . So using brew install llvm may give message like llvm is keg-only, which means it was not symlinked .... To solve this problem go to Carbon language Installation errors troubleshooting section at the end of this article to solve this problem.
This step is to download carbon lang code which also has some examples.
$ git clone https://github.com/carbon-language/carbon-lang
$ cd carbon-lang
Now that we have setup Carbon language, let's do a quick run for Hello world. To do that we will use Carbon explorer to run. To run your first code in Carbon, make sure you are in the carbon-lang directory that you cloned from git and then run below command.
$ bazel run //explorer -- ./explorer/testdata/print/format_only.carbon
What this line is doing is to invoke Bazel build tool to trigger explorer code that in turns runs the actual code present in the ./explorer/testdata/print/format_only.carbon file.
Once you run this you should see a Hello world in Carbon output like this
tipseason$ bazel run //explorer -- ./explorer/testdata/print/format_only.carbon
INFO: Invocation ID: aa36a266-cb55-4433-9bed-907e393c0605
WARNING: .....
.
.
INFO: Build completed successfully, 390 total actions
.
.
Hello world!
result: 0
As you can see "Hello World!" is printed and return type of main is int32 resulting to 0. The code that is behind this hello world program is
FileName: format_only.carbon
package ExplorerTest api;
fn Main() -> i32 {
var s: auto = "Hello world!";
Print(s);
return 0;
}
The file extension for Carbon language code is .carbon . So if you write new carbon language file you need to have a file which ends with extension of .carbon. Example: demo.carbon .
Now that we have carbon language setup, let's look at the some of the basic syntax that can be used in day to day basis for Carbon language.
Carbon language is still in experimental phases. While most of the design choices are made already, some of the syntax and usage might change as things evolve. So keep that in mind while working with Carbon-lang. One great thing about Carbon is that the syntax should be C/C++ developer friendly and easy to understand. Let's get started on how to use carbon language.
All source code is UTF-8 encoded text. Comments, identifiers, and strings are allowed to have non-ASCII characters.
You can run the below examples using Carbon language explorer that you installed in the previous step or by using online carbon explorer . Just copy paste below examples in the online IDE and you can see live results.
fn keyword. var keyword. : followed by space eg: var x:let keyword. package keyword. // auto can be used to automatically infer the variable type. It can be used in combination of let or var or as function return types. Example/ Demo code:
package ExplorerTest api;
//fn is function declaration
//return type is i32 i.e. int.
fn Main() -> i32 {
//I am a comment.
var s: auto = "Hello world!"; // Auto Variable
let x: i64 = 20; // Constant
var y: i32 = 3; // Integer variable
Print(s); // Print
return 0; //Return value
}
Functions can be declared using fn keyword. The syntax is fn MethodName(var param: type ... ) -> return type . For void or empty return types , you can ignore the part after ->
Example:
package ExplorerTest api;
//Integer return type
fn Sum(var a: i32, var b: i32) -> i32 {
return a + b;
}
//Empty or void return type.
fn PrintCount(var count: i32) {
Print("The count is {0}", count);
}
fn Main() -> i32 {
Print("Sum is {0}", Sum(4, 6));
PrintCount(10);
return 0;
}
Variables in carbon language can be
bool for boolean true or falsei8, i16, i32, i64, i128, i256 for integer types. u8, u16, u32, u128, u256 for unsigned integer types. f16, f32, f64, and f128 for float types. _ can be used for digit separators. Eg: 1_000_000 is still an integer if declared without quotes. Example:
package ExplorerTest api;
fn Main() -> i32 {
var a: i32 = 1;
var b: i32 = 2;
Print(a + b);
return 0;
}
Strings can be declared using
String for byte sequence StringView as a read only reference for utf-8 byte sequence. Strings literals can be declared in two ways.
") for single line. """) Example:
fn Main() -> i32 {
var singleLine: String = "Hello world!";
var multiLine: String = """hello line 1
TipSeason demo line 2
TipSeason demo line 3
"""; //End of multi block
return 0;
}
Tuples represent values with multiple coordinates. They can be declared using parenthesis ( )
Example / Sample code
package ExplorerTest api;
fn Main() -> i32 {
var x: auto = (0, 1);
Print("{0}", x[1]);
return x[0];
}
Here (x,y,z) is a tuple with multiple coordinates. They can be accessed using the index.
There are no null pointers in Carbon. To represent a pointer that may not refer to a valid object, use the type Optional(T*) where T is the type.
* represents value.
& represents address.
Example:
package ExplorerTest api;
fn Main() -> i32 {
var x: i32 = 5;
// changes x to 10
x = 10;
Print("---");
Print("x = {0}", x);
var y: i32* = &x;
// changes x to 7
*y = 7;
Print("---");
Print("x = {0}", x);
Print("y = {0}", *y);
var z: i32* = &*y;
// changes x to 0
*z = 0;
Print("---");
Print("x = {0}", x);
Print("y = {0}", *y);
Print("z = {0}", *z);
var w: i32 = *y;
return w;
}
Arrays are declared using array type and the size. Syntax is [type; size]
Eg: var xarray: [i32; 4] = (1,2,3,4);
Example
package ExplorerTest api;
fn Main() -> i32 {
var xarray: [i32; 4] = (0, 1, 5, 6); // Integer array
var index: i32 = 1;
xarray[index] = 0;
Print("{0}", xarray[0]);
Print("{1}", xarray[0]);
return xarray[0] + xarray[1];
}
Combination of if , else can be used to control the conditional flow in Carbon.
if-else:
if(condition) {
//doSomething
} else {
//doSomething
}
if-else-if
if(condition) {
//doSomething
} else if (condition) {
//doSomething
} else {
//doSomething
}
Example:
package ExplorerTest api;
fn Main() -> i32 {
var x: i32 = 5;
if(x == 5) {
Print("{0} to word is FIVE", x);
} else {
Print("{0} is not known ", x);
}
return 0;
Standards looping statements are supported.
While loop can be declared using while(condition){ }
Example:
package ExplorerTest api;
fn Main() -> i32 {
var x: auto = 5;
while (not (x == 0)) {
x = x - 1;
Print("{0} ", x);
}
return x;
}
For loop can be declared using for (loop conditions) { } . At the time of writing this article didn't get full working example. But here is the proposed syntax.
package ExplorerTest api;
fn Main() -> i32 {
var names: [String; 4] = ("a", "b");
for (var name: String in names) {
Console.Print(name);
}
return x;
}
Carbon has match keyword which is similar to switch in C/C++. Syntax for match is
match(condition) {
case (condition) => {
//doSomething;
}
default => {
//doSomething;
}
}
Example:
package ExplorerTest api;
fn Matcher(var num: i32) -> i32 {
var number: auto = 10;
match (number) {
case 5 => {
Print("Got 5");
return number;
}
case 10 => {
Print("Got 10");
return number;
}
default => {
Print("Default");
return number;
}
}
}
fn Main() -> i32 {
Matcher(5);
Matcher(10);
Matcher(2);
return 0;
}
Class in carbon language can be declared using class keyword.
Class can have members and methods. Here is an example class implementation.
package ExplorerTest api;
class Sum {
var a: i32;
fn Add[me: Self](var num: i32) -> i32 {
var total: i32 = me.a + num;
return total;
}
}
fn Main() -> i32 {
var p1: Sum = {.a = 5};
var total: i32 = p1.Add(5);
Print("Total sum {0}" , total);
return 0;
}
Structural types help you identify members using the name instead of their index/position. They are declared within curly braces var name: auto = {.name1 = value1, .name2 = value2, ... } and can be accessed using name.name1 etc.
Example:
package ExplorerTest api;
fn Main() -> i32 {
var point: auto = {.x_axis = 0, .y_axis = 1};
point = {.x_axis = 5, .y_axis = -5};
var result: i32 = point.x_axis * point.x_axis + point.y_axis * point.y_axis;
Print("Result : {0}", result);
return 0;
}
Generics can be seen in many modern languages. They define a way to induce compile time type checks and helps define cleaner type variables. They can be declared using T paramter types are shown below.
Example:
package ExplorerTest api;
fn GenericExample[T:! Type](x: T) -> T {
return x;
}
fn Main() -> i32 {
Print("Integer generic type {0}", GenericExample(0));
Print(GenericExample("This is a string generic"));
return 0;
}
llvm is keg-only, which means it was not symlinked into /usr/local,
because macOS already provides this software and installing another version in
parallel can cause all kinds of trouble.
If you need to have llvm first in your PATH, run:
echo 'export PATH="/usr/local/opt/llvm/bin:$PATH"' >> /Users/pramodnanduri/.bash_profile
For compilers to find llvm you may need to set:
export LDFLAGS="-L/usr/local/opt/llvm/lib"
export CPPFLAGS="-I/usr/local/opt/llvm/include"
To solve this problem configure your ~/.bash_profile file to have following variables
export PATH="/usr/local/opt/llvm/bin:$PATH"
export LDFLAGS="-L/usr/local/opt/llvm/lib"
export CPPFLAGS="-I/usr/local/opt/llvm/include"
export CC=$(which clang)
Once you save it make sure to run
source ~/.bash_profile
If you have other errors , drop a comment below . Will check and respond back.
While carbon language is still experimental phase , it is still unclear when it will be available for public usage. Lot of basic usage examples are still not supported. Hope to have this coming soon to get started.
Hope this tutorial helps you to play around and understand the basic concepts, syntax examples with google carbon language . While this is not the full list of supported syntax, while we experiment more with features of Carbon, we will cover it as part of the future articles. For any kind of questions or comments drop a note below.
What's next?
Top 10 most loved programming languages of 2022 and which companies use them
dbt (data build tool) in a real world scenario, Beginner dbt tutorial