Carbon is a new early-stage programming language from Google designed as a successor to C++ for low level systems development. It has full interoperability with Cpp, along with improved memory safety, generics, and a cleaner syntax. 

#programming #tech #TheCodeReport

🔗 Resources

Carbon on Github https://github.com/carbon-language/carbon-lang
Google Carbon Announcement https://9to5google.com/2022/07/19/carbon-programming-language-google-cpp/
C++ in 100 Seconds https://youtu.be/MNeX4EGtR5Y
Rust in 100 Seconds https://youtu.be/5C_HPTJg5ek

🔥 Get More Content - Upgrade to PRO

Upgrade to Fireship PRO at https://fireship.io/pro
Use code lORhwXd2 for 25% off your first payment. 

🎨 My Editor Settings

- Atom One Dark 
- vscode-icons
- Fira Code Font

🔖 Topics Covered

- What is carbon lang?
- Will carbon replace Cpp?
- Pros and cons of C plus plus
- How does carbon lang work?
- Why use Carbon instead of Rust?
- Carbon vs Go
- Rust vs C++
2024-02-04T13:34:35.851Z
nova-2
2-general-nova
2024-01-09.29447
30089e05-99d1-4376-b32e-c263170674af
2979465d-7b7a-4e58-b773-f5e97e35420f
6c1fcd4834bd6913387cb9ada79a3f2c2d52df52af9f28a444c896c7f0ce1a33
67875a7f-c9c4-48a0-aa55-5bdb8a91c34a
deprecated
It is July 22nd, 2022, and you're watching The Code Report.
The programming languages that people love to hate are disappearing quickly.
Microsoft JavaScript with TypeScript, Apple killed Objective C with Swift, JetBrains killed Java with Kotlin, and now Google is stepping up to the plate for the biggest challenge of all, C plus plus Plus.
It just announced a new experimental language called Carbon, which is designed to match the performance of C plus plus with LLVM, while being able to interop with existing C plus plus code bases.
That's a big deal, because c plus plus is by far the most prolific language when it comes to building high performance, low level systems.
C plus plus has been around since 1983, and has accumulated a lot of technical debt in the process.
The creator of C plus plus once said, quote, within C plus plus there is a much smaller and cleaner language struggling to get out.
Problem with making c plus plus better today is that it's such an important language for so many code bases, that it needs to focus more on standardization, as opposed to evolving the design to what modern developers want.
It's really hard to change and establish technology.
This sucks.
Change it.
Like when Python 2 into Python 3, the changes weren't that extreme, but it's still very painful for anybody wanting to migrate a codebase, and also all the content on the web and Stack Overflow becomes stale.
One could argue it's actually a good thing that c plus plus doesn't try to change too aggressively.
Carbon is designed to be a successor language for c plus plus which is no small undertaking, but Google is no stranger to creating programming languages.
It gave us Go and Dart, which are both very well liked in the industry.
At this point, Carbon doesn't have a good logo or mascot, but I'm sure it will get one eventually.
You might also be wondering, why not just use a modern memory safe language like Rust?
First of all, not all c plus plus developers actually like Rust.
But more importantly, Carbon is designed for easy adoption by existing C plus plus code bases and developers.
It has bidirectional interoperability with C plus plus which means you can use existing C plus plus libraries Carbon seamlessly or vice versa.
Now, I've only been coding for about 12 years, which isn't nearly enough time to learn c plus plus but let's take a look at some code anyway.
To run Carbon at this point, you'll need to install Google's build tool, Bazel, as well as LLVM to build it.
To say hello world, we have a main function that uses print with a string literal.
Looks pretty simple, but if you've never seen a c plus plus hello world that uses this character out bullshit, then it looks like a revolutionary improvement.
But a bigger feature is the fact that supports a modern generic system.
Generics allow you to pass types as parameters to classes and functions, a common pattern in statically typed languages.
But c plus plus takes a different approach that's often misused and abused called templates.
Carbon still supports templates, but generics will provide a bunch of advantages in most situations.
But, more importantly, Carbon looks to improve upon memory safety patterns.
In c plus plus, you can have uninitialized variables, which can sometimes be important for performance, but more often than not, they just result in bugs.
And memory access bugs can be very dangerous when hackers learn to exploit them.
Carbon has an entire dock on its safety strategy and basically it tries to be as safe as possible without hurting performance or interoperability with c plus plus and it can be run-in different modes like debug, performance, and hardened depending on how much you wanna prioritize memory safety.
Notably, it doesn't use mechanisms like borrow checking, reference counting, or garbage collection, like you might find in other languages.
Sounds pretty cool, so when can I start using it?
Well, at this point, it's experimental and it's an extremely ambitious project.
It'll likely be multiple years before this language is production ready.
Now, even though Google just implement hiring freeze.
Employers are already looking to hire Carbon developers.
You just need to have 10 years of Carbon experience to apply.
This has been the CodeReport.
Thanks for watching, and I will see you in the next

Speaker 0: It is July 22nd, 2022, and you're watching The Code Report. The programming languages that people love to hate are disappearing quickly. Microsoft JavaScript with TypeScript, Apple killed Objective C with Swift, JetBrains killed Java with Kotlin, and now Google is stepping up to the plate for the biggest challenge of all, C plus plus Plus. It just announced a new experimental language called Carbon, which is designed to match the performance of C plus plus with LLVM, while being able to interop with existing C plus plus code bases. That's a big deal, because c plus plus is by far the most prolific language when it comes to building high performance, low level systems.

C plus plus has been around since 1983, and has accumulated a lot of technical debt in the process. The creator of C plus plus once said, quote, within C plus plus there is a much smaller and cleaner language struggling to get out. Problem with making c plus plus better today is that it's such an important language for so many code bases, that it needs to focus more on standardization, as opposed to evolving the design to what modern developers want. It's really hard to change and establish technology. This sucks.

Change it. Like when Python 2 into Python 3, the changes weren't that extreme, but it's still very painful for anybody wanting to migrate a codebase, and also all the content on the web and Stack Overflow becomes stale. One could argue it's actually a good thing that c plus plus doesn't try to change too aggressively. Carbon is designed to be a successor language for c plus plus which is no small undertaking, but Google is no stranger to creating programming languages. It gave us Go and Dart, which are both very well liked in the industry.

At this point, Carbon doesn't have a good logo or mascot, but I'm sure it will get one eventually. You might also be wondering, why not just use a modern memory safe language like Rust? First of all, not all c plus plus developers actually like Rust. But more importantly, Carbon is designed for easy adoption by existing C plus plus code bases and developers. It has bidirectional interoperability with C plus plus which means you can use existing C plus plus libraries Carbon seamlessly or vice versa.

Now, I've only been coding for about 12 years, which isn't nearly enough time to learn c plus plus but let's take a look at some code anyway. To run Carbon at this point, you'll need to install Google's build tool, Bazel, as well as LLVM to build it. To say hello world, we have a main function that uses print with a string literal. Looks pretty simple, but if you've never seen a c plus plus hello world that uses this character out bullshit, then it looks like a revolutionary improvement. But a bigger feature is the fact that supports a modern generic system.

Generics allow you to pass types as parameters to classes and functions, a common pattern in statically typed languages. But c plus plus takes a different approach that's often misused and abused called templates. Carbon still supports templates, but generics will provide a bunch of advantages in most situations. But, more importantly, Carbon looks to improve upon memory safety patterns. In c plus plus, you can have uninitialized variables, which can sometimes be important for performance, but more often than not, they just result in bugs.

And memory access bugs can be very dangerous when hackers learn to exploit them. Carbon has an entire dock on its safety strategy and basically it tries to be as safe as possible without hurting performance or interoperability with c plus plus and it can be run-in different modes like debug, performance, and hardened depending on how much you wanna prioritize memory safety. Notably, it doesn't use mechanisms like borrow checking, reference counting, or garbage collection, like you might find in other languages. Sounds pretty cool, so when can I start using it? Well, at this point, it's experimental and it's an extremely ambitious project.

It'll likely be multiple years before this language is production ready. Now, even though Google just implement hiring freeze. Employers are already looking to hire Carbon developers. You just need to have 10 years of Carbon experience to apply. This has been the CodeReport.

Thanks for watching, and I will see you in the next
It is July 22nd, 2022, and you're watching The Code Report. The programming languages that people love to hate are disappearing quickly. Microsoft JavaScript with TypeScript, Apple killed Objective C with Swift, JetBrains killed Java with Kotlin, and now Google is stepping up to the plate for the biggest challenge of all, C plus plus Plus.
It just announced a new experimental language called Carbon, which is designed to match the performance of C plus plus with LLVM, while being able to interop with existing C plus plus code bases. That's a big deal, because c plus plus is by far the most prolific language when it comes to building high performance, low level systems.
computer science
C plus plus has been around since 1983, and has accumulated a lot of technical debt in the process. The creator of C plus plus once said, quote, within C plus plus there is a much smaller and cleaner language struggling to get out.
Problem with making c plus plus better today is that it's such an important language for so many code bases, that it needs to focus more on standardization, as opposed to evolving the design to what modern developers want. It's really hard to change and establish technology. This sucks. Change it.
software development
Like when Python 2 into Python 3, the changes weren't that extreme, but it's still very painful for anybody wanting to migrate a codebase, and also all the content on the web and Stack Overflow becomes stale. One could argue it's actually a good thing that c plus plus doesn't try to change too aggressively. Carbon is designed to be a successor language for c plus plus which is no small undertaking, but Google is no stranger to creating programming languages. It gave us Go and Dart, which are both very well liked in the industry. At this point, Carbon doesn't have a good logo or mascot, but I'm sure it will get one eventually. You might also be wondering, why not just use a modern memory safe language like Rust? First of all, not all c plus plus developers actually like Rust. But more importantly, Carbon is designed for easy adoption by existing C plus plus code bases and developers. It has bidirectional interoperability with C plus plus which means you can use existing C plus plus libraries Carbon seamlessly or vice versa. Now, I've only been coding for about 12 years, which isn't nearly enough time to learn c plus plus but let's take a look at some code anyway. To run Carbon at this point, you'll need to install Google's build tool, Bazel, as well as LLVM to build it. To say hello world, we have a main function that uses print with a string literal. Looks pretty simple, but if you've never seen a c plus plus hello world that uses this character out bullshit, then it looks like a revolutionary improvement. But a bigger feature is the fact that supports a modern generic system. Generics allow you to pass types as parameters to classes and functions, a common pattern in statically typed languages. But c plus plus takes a different approach that's often misused and abused called templates. Carbon still supports templates, but generics will provide a bunch of advantages in most situations. But, more importantly, Carbon looks to improve upon memory safety patterns. In c plus plus, you can have uninitialized variables, which can sometimes be important for performance, but more often than not, they just result in bugs. And memory access bugs can be very dangerous when hackers learn to exploit them. Carbon has an entire dock on its safety strategy and basically it tries to be as safe as possible without hurting performance or interoperability with c plus plus and it can be run-in different modes like debug, performance, and hardened depending on how much you wanna prioritize memory safety.
Notably, it doesn't use mechanisms like borrow checking, reference counting, or garbage collection, like you might find in other languages. Sounds pretty cool, so when can I start using it? Well, at this point, it's experimental and it's an extremely ambitious project. It'll likely be multiple years before this language is production ready.
languages
Now, even though Google just implement hiring freeze. Employers are already looking to hire Carbon developers. You just need to have 10 years of Carbon experience to apply. This has been the CodeReport. Thanks for watching, and I will see you in the next
It is July 22nd, 2022, and you're watching The Code Report. The programming languages that people love to hate are disappearing quickly. Microsoft JavaScript with TypeScript, Apple killed Objective C with Swift, JetBrains killed Java with Kotlin, and now Google is stepping up to the plate for the biggest challenge of all, C plus plus Plus. It just announced a new experimental language called Carbon, which is designed to match the performance of C plus plus with LLVM, while being able to interop with existing C plus plus code bases. That's a big deal, because c plus plus is by far the most prolific language when it comes to building high performance, low level systems. C plus plus has been around since 1983, and has accumulated a lot of technical debt in the process. The creator of C plus plus once said, quote, within C plus plus there is a much smaller and cleaner language struggling to get out. Problem with making c plus plus better today is that it's such an important language for so many code bases, that it needs to focus more on standardization, as opposed to evolving the design to what modern developers want. It's really hard to change and establish technology. This sucks. Change it. Like when Python 2 into Python 3, the changes weren't that extreme, but it's still very painful for anybody wanting to migrate a codebase, and also all the content on the web and Stack Overflow becomes stale. One could argue it's actually a good thing that c plus plus doesn't try to change too aggressively. Carbon is designed to be a successor language for c plus plus which is no small undertaking, but Google is no stranger to creating programming languages. It gave us Go and Dart, which are both very well liked in the industry. At this point, Carbon doesn't have a good logo or mascot, but I'm sure it will get one eventually. You might also be wondering, why not just use a modern memory safe language like Rust? First of all, not all c plus plus developers actually like Rust. But more importantly, Carbon is designed for easy adoption by existing C plus plus code bases and developers. It has bidirectional interoperability with C plus plus which means you can use existing C plus plus libraries Carbon seamlessly or vice versa. Now, I've only been coding for about 12 years, which isn't nearly enough time to learn c plus plus but let's take a look at some code anyway. To run Carbon at this point, you'll need to install Google's build tool, Bazel, as well as LLVM to build it. To say hello world, we have a main function that uses print with a string literal. Looks pretty simple, but if you've never seen a c plus plus hello world that uses this character out bullshit, then it looks like a revolutionary improvement. But a bigger feature is the fact that supports a modern generic system. Generics allow you to pass types as parameters to classes and functions, a common pattern in statically typed languages. But c plus plus takes a different approach that's often misused and abused called templates. Carbon still supports templates, but generics will provide a bunch of advantages in most situations. But, more importantly, Carbon looks to improve upon memory safety patterns. In c plus plus, you can have uninitialized variables, which can sometimes be important for performance, but more often than not, they just result in bugs. And memory access bugs can be very dangerous when hackers learn to exploit them. Carbon has an entire dock on its safety strategy and basically it tries to be as safe as possible without hurting performance or interoperability with c plus plus and it can be run-in different modes like debug, performance, and hardened depending on how much you wanna prioritize memory safety. Notably, it doesn't use mechanisms like borrow checking, reference counting, or garbage collection, like you might find in other languages. Sounds pretty cool, so when can I start using it? Well, at this point, it's experimental and it's an extremely ambitious project. It'll likely be multiple years before this language is production ready. Now, even though Google just implement hiring freeze. Employers are already looking to hire Carbon developers. You just need to have 10 years of Carbon experience to apply. This has been the CodeReport. Thanks for watching, and I will see you in the next
It
it
is
is
July
july
22nd,
22nd
2022,
2022
and
and
you're
you're
watching
watching
The
the
Code
code
Report.
report
The
the
programming
programming
languages
languages
that
that
people
people
love
love
to
to
hate
hate
are
are
disappearing
disappearing
quickly.
quickly
Microsoft
microsoft
JavaScript
javascript
with
with
TypeScript,
typescript
Apple
apple
killed
killed
Objective
objective
C
c
with
with
Swift,
swift
JetBrains
jetbrains
killed
killed
Java
java
with
with
Kotlin,
kotlin
and
and
now
now
Google
google
is
is
stepping
stepping
up
up
to
to
the
the
plate
plate
for
for
the
the
biggest
biggest
challenge
challenge
of
of
all,
all
C
c
plus
plus
plus
plus
Plus.
plus
It
it
just
just
announced
announced
a
a
new
new
experimental
experimental
language
language
called
called
Carbon,
carbon
which
which
is
is
designed
designed
to
to
match
match
the
the
performance
performance
of
of
C
c
plus
plus
plus
plus
with
with
LLVM,
llvm
while
while
being
being
able
able
to
to
interop
interop
with
with
existing
existing
C
c
plus
plus
plus
plus
code
code
bases.
bases
That's
that's
a
a
big
big
deal,
deal
because
because
c
c
plus
plus
plus
plus
is
is
by
by
far
far
the
the
most
most
prolific
prolific
language
language
when
when
it
it
comes
comes
to
to
building
building
high
high
performance,
performance
low
low
level
level
systems.
systems
C
c
plus
plus
plus
plus
has
has
been
been
around
around
since
since
1983,
1983
and
and
has
has
accumulated
accumulated
a
a
lot
lot
of
of
technical
technical
debt
debt
in
in
the
the
process.
process
The
the
creator
creator
of
of
C
c
plus
plus
plus
plus
once
once
said,
said
quote,
quote
within
within
C
c
plus
plus
plus
plus
there
there
is
is
a
a
much
much
smaller
smaller
and
and
cleaner
cleaner
language
language
struggling
struggling
to
to
get
get
out.
out
Problem
problem
with
with
making
making
c
c
plus
plus
plus
plus
better
better
today
today
is
is
that
that
it's
it's
such
such
an
an
important
important
language
language
for
for
so
so
many
many
code
code
bases,
bases
that
that
it
it
needs
needs
to
to
focus
focus
more
more
on
on
standardization,
standardization
as
as
opposed
opposed
to
to
evolving
evolving
the
the
design
design
to
to
what
what
modern
modern
developers
developers
want.
want
It's
it's
really
really
hard
hard
to
to
change
change
and
and
establish
establish
technology.
technology
This
this
sucks.
sucks
Change
change
it.
it
Like
like
when
when
Python
python
2
2
into
into
Python
python
3,
3
the
the
changes
changes
weren't
weren't
that
that
extreme,
extreme
but
but
it's
it's
still
still
very
very
painful
painful
for
for
anybody
anybody
wanting
wanting
to
to
migrate
migrate
a
a
codebase,
codebase
and
and
also
also
all
all
the
the
content
content
on
on
the
the
web
web
and
and
Stack
stack
Overflow
overflow
becomes
becomes
stale.
stale
One
one
could
could
argue
argue
it's
it's
actually
actually
a
a
good
good
thing
thing
that
that
c
c
plus
plus
plus
plus
doesn't
doesn't
try
try
to
to
change
change
too
too
aggressively.
aggressively
Carbon
carbon
is
is
designed
designed
to
to
be
be
a
a
successor
successor
language
language
for
for
c
c
plus
plus
plus
plus
which
which
is
is
no
no
small
small
undertaking,
undertaking
but
but
Google
google
is
is
no
no
stranger
stranger
to
to
creating
creating
programming
programming
languages.
languages
It
it
gave
gave
us
us
Go
go
and
and
Dart,
dart
which
which
are
are
both
both
very
very
well
well
liked
liked
in
in
the
the
industry.
industry
At
at
this
this
point,
point
Carbon
carbon
doesn't
doesn't
have
have
a
a
good
good
logo
logo
or
or
mascot,
mascot
but
but
I'm
i'm
sure
sure
it
it
will
will
get
get
one
one
eventually.
eventually
You
you
might
might
also
also
be
be
wondering,
wondering
why
why
not
not
just
just
use
use
a
a
modern
modern
memory
memory
safe
safe
language
language
like
like
Rust?
rust
First
first
of
of
all,
all
not
not
all
all
c
c
plus
plus
plus
plus
developers
developers
actually
actually
like
like
Rust.
rust
But
but
more
more
importantly,
importantly
Carbon
carbon
is
is
designed
designed
for
for
easy
easy
adoption
adoption
by
by
existing
existing
C
c
plus
plus
plus
plus
code
code
bases
bases
and
and
developers.
developers
It
it
has
has
bidirectional
bidirectional
interoperability
interoperability
with
with
C
c
plus
plus
plus
plus
which
which
means
means
you
you
can
can
use
use
existing
existing
C
c
plus
plus
plus
plus
libraries
libraries
Carbon
carbon
seamlessly
seamlessly
or
or
vice
vice
versa.
versa
Now,
now
I've
i've
only
only
been
been
coding
coding
for
for
about
about
12
12
years,
years
which
which
isn't
isn't
nearly
nearly
enough
enough
time
time
to
to
learn
learn
c
c
plus
plus
plus
plus
but
but
let's
let's
take
take
a
a
look
look
at
at
some
some
code
code
anyway.
anyway
To
to
run
run
Carbon
carbon
at
at
this
this
point,
point
you'll
you'll
need
need
to
to
install
install
Google's
google's
build
build
tool,
tool
Bazel,
bazel
as
as
well
well
as
as
LLVM
llvm
to
to
build
build
it.
it
To
to
say
say
hello
hello
world,
world
we
we
have
have
a
a
main
main
function
function
that
that
uses
uses
print
print
with
with
a
a
string
string
literal.
literal
Looks
looks
pretty
pretty
simple,
simple
but
but
if
if
you've
you've
never
never
seen
seen
a
a
c
c
plus
plus
plus
plus
hello
hello
world
world
that
that
uses
uses
this
this
character
character
out
out
bullshit,
bullshit
then
then
it
it
looks
looks
like
like
a
a
revolutionary
revolutionary
improvement.
improvement
But
but
a
a
bigger
bigger
feature
feature
is
is
the
the
fact
fact
that
that
supports
supports
a
a
modern
modern
generic
generic
system.
system
Generics
generics
allow
allow
you
you
to
to
pass
pass
types
types
as
as
parameters
parameters
to
to
classes
classes
and
and
functions,
functions
a
a
common
common
pattern
pattern
in
in
statically
statically
typed
typed
languages.
languages
But
but
c
c
plus
plus
plus
plus
takes
takes
a
a
different
different
approach
approach
that's
that's
often
often
misused
misused
and
and
abused
abused
called
called
templates.
templates
Carbon
carbon
still
still
supports
supports
templates,
templates
but
but
generics
generics
will
will
provide
provide
a
a
bunch
bunch
of
of
advantages
advantages
in
in
most
most
situations.
situations
But,
but
more
more
importantly,
importantly
Carbon
carbon
looks
looks
to
to
improve
improve
upon
upon
memory
memory
safety
safety
patterns.
patterns
In
in
c
c
plus
plus
plus,
plus
you
you
can
can
have
have
uninitialized
uninitialized
variables,
variables
which
which
can
can
sometimes
sometimes
be
be
important
important
for
for
performance,
performance
but
but
more
more
often
often
than
than
not,
not
they
they
just
just
result
result
in
in
bugs.
bugs
And
and
memory
memory
access
access
bugs
bugs
can
can
be
be
very
very
dangerous
dangerous
when
when
hackers
hackers
learn
learn
to
to
exploit
exploit
them.
them
Carbon
carbon
has
has
an
an
entire
entire
dock
dock
on
on
its
its
safety
safety
strategy
strategy
and
and
basically
basically
it
it
tries
tries
to
to
be
be
as
as
safe
safe
as
as
possible
possible
without
without
hurting
hurting
performance
performance
or
or
interoperability
interoperability
with
with
c
c
plus
plus
plus
plus
and
and
it
it
can
can
be
be
run-in
run-in
different
different
modes
modes
like
like
debug,
debug
performance,
performance
and
and
hardened
hardened
depending
depending
on
on
how
how
much
much
you
you
wanna
wanna
prioritize
prioritize
memory
memory
safety.
safety
Notably,
notably
it
it
doesn't
doesn't
use
use
mechanisms
mechanisms
like
like
borrow
borrow
checking,
checking
reference
reference
counting,
counting
or
or
garbage
garbage
collection,
collection
like
like
you
you
might
might
find
find
in
in
other
other
languages.
languages
Sounds
sounds
pretty
pretty
cool,
cool
so
so
when
when
can
can
I
i
start
start
using
using
it?
it
Well,
well
at
at
this
this
point,
point
it's
it's
experimental
experimental
and
and
it's
it's
an
an
extremely
extremely
ambitious
ambitious
project.
project
It'll
it'll
likely
likely
be
be
multiple
multiple
years
years
before
before
this
this
language
language
is
is
production
production
ready.
ready
Now,
now
even
even
though
though
Google
google
just
just
implement
implement
hiring
hiring
freeze.
freeze
Employers
employers
are
are
already
already
looking
looking
to
to
hire
hire
Carbon
carbon
developers.
developers
You
you
just
just
need
need
to
to
have
have
10
10
years
years
of
of
Carbon
carbon
experience
experience
to
to
apply.
apply
This
this
has
has
been
been
the
the
CodeReport.
codereport
Thanks
thanks
for
for
watching,
watching
and
and
I
i
will
will
see
see
you
you
in
in
the
the
next
next
success
The transcript discusses the challenges of creating high-performance, low-latency C plus plus code bases, and the need for standardization and evolution of design. It also mentions the benefits of using Carbon, including its ability to be a successor language for c plus plus, interoperability with existing C plus plus code bases, and its ability to create templates and memory safety. The project is an experimental and ambitious, and it will likely be several years before it is production ready.
Carbon Lang… The C++ killer?
It is July 22nd, 2022, and you're watching The Code Report. The programming languages that people love to hate are disappearing quickly. Microsoft JavaScript with TypeScript, Apple killed Objective C with Swift, JetBrains killed Java with Kotlin, and now Google is stepping up to the plate for the biggest challenge of all, C plus plus Plus. It just announced a new experimental language called Carbon, which is designed to match the performance of C plus plus with LLVM, while being able to interop with existing C plus plus code bases. That's a big deal, because c plus plus is by far the most prolific language when it comes to building high performance, low level systems. C plus plus has been around since 1983, and has accumulated a lot of technical debt in the process. The creator of C plus plus once said, quote, within C plus plus there is a much smaller and cleaner language struggling to get out. Problem with making c plus plus better today is that it's such an important language for so many code bases, that it needs to focus more on standardization, as opposed to evolving the design to what modern developers want. It's really hard to change and establish technology. This sucks. Change it. Like when Python 2 into Python 3, the changes weren't that extreme, but it's still very painful for anybody wanting to migrate a codebase, and also all the content on the web and Stack Overflow becomes stale. One could argue it's actually a good thing that c plus plus doesn't try to change too aggressively. Carbon is designed to be a successor language for c plus plus which is no small undertaking, but Google is no stranger to creating programming languages. It gave us Go and Dart, which are both very well liked in the industry. At this point, Carbon doesn't have a good logo or mascot, but I'm sure it will get one eventually. You might also be wondering, why not just use a modern memory safe language like Rust? First of all, not all c plus plus developers actually like Rust. But more importantly, Carbon is designed for easy adoption by existing C plus plus code bases and developers. It has bidirectional interoperability with C plus plus which means you can use existing C plus plus libraries Carbon seamlessly or vice versa. Now, I've only been coding for about 12 years, which isn't nearly enough time to learn c plus plus but let's take a look at some code anyway. To run Carbon at this point, you'll need to install Google's build tool, Bazel, as well as LLVM to build it. To say hello world, we have a main function that uses print with a string literal. Looks pretty simple, but if you've never seen a c plus plus hello world that uses this character out bullshit, then it looks like a revolutionary improvement. But a bigger feature is the fact that supports a modern generic system. Generics allow you to pass types as parameters to classes and functions, a common pattern in statically typed languages. But c plus plus takes a different approach that's often misused and abused called templates. Carbon still supports templates, but generics will provide a bunch of advantages in most situations. But, more importantly, Carbon looks to improve upon memory safety patterns. In c plus plus, you can have uninitialized variables, which can sometimes be important for performance, but more often than not, they just result in bugs. And memory access bugs can be very dangerous when hackers learn to exploit them. Carbon has an entire dock on its safety strategy and basically it tries to be as safe as possible without hurting performance or interoperability with c plus plus and it can be run-in different modes like debug, performance, and hardened depending on how much you wanna prioritize memory safety. Notably, it doesn't use mechanisms like borrow checking, reference counting, or garbage collection, like you might find in other languages. Sounds pretty cool, so when can I start using it? Well, at this point, it's experimental and it's an extremely ambitious project. It'll likely be multiple years before this language is production ready. Now, even though Google just implement hiring freeze. Employers are already looking to hire Carbon developers. You just need to have 10 years of Carbon experience to apply. This has been the CodeReport. Thanks for watching, and I will see you in the next
The transcript discusses the challenges of creating high-performance, low-latency C plus plus code bases, and the need for standardization and evolution of design. It also mentions the benefits of using Carbon, including its ability to be a successor language for c plus plus, interoperability with existing C plus plus code bases, and its ability to create templates and memory safety. The project is an experimental and ambitious, and it will likely be several years before it is production ready.

        [INST]
        You are youtuber called Fireship you make engaging high-intensity and entertaining coding tutorials and tech news. 
        you covers a wide range of topics relevant to programmers, aiming to help them learn and improve their skills quickly.
        
        Given the title of the video : Carbon Lang… The C++ killer? 
        and a small summary : The transcript discusses the challenges of creating high-performance, low-latency C plus plus code bases, and the need for standardization and evolution of design. It also mentions the benefits of using Carbon, including its ability to be a successor language for c plus plus, interoperability with existing C plus plus code bases, and its ability to create templates and memory safety. The project is an experimental and ambitious, and it will likely be several years before it is production ready.
        [/INST]
        
        Generate the video : It is July 22nd, 2022, and you're watching The Code Report. The programming languages that people love to hate are disappearing quickly. Microsoft JavaScript with TypeScript, Apple killed Objective C with Swift, JetBrains killed Java with Kotlin, and now Google is stepping up to the plate for the biggest challenge of all, C plus plus Plus. It just announced a new experimental language called Carbon, which is designed to match the performance of C plus plus with LLVM, while being able to interop with existing C plus plus code bases. That's a big deal, because c plus plus is by far the most prolific language when it comes to building high performance, low level systems. C plus plus has been around since 1983, and has accumulated a lot of technical debt in the process. The creator of C plus plus once said, quote, within C plus plus there is a much smaller and cleaner language struggling to get out. Problem with making c plus plus better today is that it's such an important language for so many code bases, that it needs to focus more on standardization, as opposed to evolving the design to what modern developers want. It's really hard to change and establish technology. This sucks. Change it. Like when Python 2 into Python 3, the changes weren't that extreme, but it's still very painful for anybody wanting to migrate a codebase, and also all the content on the web and Stack Overflow becomes stale. One could argue it's actually a good thing that c plus plus doesn't try to change too aggressively. Carbon is designed to be a successor language for c plus plus which is no small undertaking, but Google is no stranger to creating programming languages. It gave us Go and Dart, which are both very well liked in the industry. At this point, Carbon doesn't have a good logo or mascot, but I'm sure it will get one eventually. You might also be wondering, why not just use a modern memory safe language like Rust? First of all, not all c plus plus developers actually like Rust. But more importantly, Carbon is designed for easy adoption by existing C plus plus code bases and developers. It has bidirectional interoperability with C plus plus which means you can use existing C plus plus libraries Carbon seamlessly or vice versa. Now, I've only been coding for about 12 years, which isn't nearly enough time to learn c plus plus but let's take a look at some code anyway. To run Carbon at this point, you'll need to install Google's build tool, Bazel, as well as LLVM to build it. To say hello world, we have a main function that uses print with a string literal. Looks pretty simple, but if you've never seen a c plus plus hello world that uses this character out bullshit, then it looks like a revolutionary improvement. But a bigger feature is the fact that supports a modern generic system. Generics allow you to pass types as parameters to classes and functions, a common pattern in statically typed languages. But c plus plus takes a different approach that's often misused and abused called templates. Carbon still supports templates, but generics will provide a bunch of advantages in most situations. But, more importantly, Carbon looks to improve upon memory safety patterns. In c plus plus, you can have uninitialized variables, which can sometimes be important for performance, but more often than not, they just result in bugs. And memory access bugs can be very dangerous when hackers learn to exploit them. Carbon has an entire dock on its safety strategy and basically it tries to be as safe as possible without hurting performance or interoperability with c plus plus and it can be run-in different modes like debug, performance, and hardened depending on how much you wanna prioritize memory safety. Notably, it doesn't use mechanisms like borrow checking, reference counting, or garbage collection, like you might find in other languages. Sounds pretty cool, so when can I start using it? Well, at this point, it's experimental and it's an extremely ambitious project. It'll likely be multiple years before this language is production ready. Now, even though Google just implement hiring freeze. Employers are already looking to hire Carbon developers. You just need to have 10 years of Carbon experience to apply. This has been the CodeReport. Thanks for watching, and I will see you in the next
        