Sean Robertson

Sean Robertson

1659407186

Carbon Lang Tutorial for Beginners | Google's New C++ Successor

In this tutorial, we'll learn about Carbon Lang, Google's new C++ successor. Learn the basic syntax including variables, data types, arrays, tuples, classes, generics and more in Carbon Lang

💻 Carbon Main Repo: https://morioh.com/p/4f167436f17f 

Timestamps:
0:00 - Intro
1:37 - Carbon - What & Why?
7:26 - Setup With Homebrew
13:15 - Package Namespace
14:16 - Main() Function
16:40 - Print() Function
18:00 - Creating Functions
19:40 - Primitive Data Types
21:37 - Naming Conventions
22:14 - Variables
24:15 - let Keyword
26:22 - auto Type
27:06 - Global Variables & Scope
28:52 - Multi-Line Strings
29:27 - Function Arguments
31:49 - Arrays
35:10 - Tuples
37:42 - Structs
41:11 - Classes & Objects
43:32 - Class Methods
46:10 - Class Functions
47:52 - Pointers
52:35 - If Else Statements
54:55 - Match Statement
59:04 - While Loops
1:01:32 - Generics
1:05:22 - Outro

#carbonlang #carbon #cplusplus #cpp

Carbon Lang Tutorial for Beginners | Google's New C++ Successor
Joshua Yates

Joshua Yates

1658991882

wrapit: Automatization of C++--Julia Wapper Generation

Automatic generation of C++ -- Julia bindings

The goal of this project is the automatization of the generation of Julia bindings for C++ libraries.

The WrapIt! tool complements the CxxWrap.jl package. It generates automatically the c++ wrapper code needed by CxxWrap.jl from the c++ header files of the library to wrap.

Usage

wrapit [--force] [-v N] config.toml

The file config.toml contains the parameters for the generation, in particular the input header files specified by the input (list of file names) and input_dirs (list of directories where to look the files for) parameters. The different parameters are described in config.

Features

  • Generation of bindings for struct, class and enums;
  • Generation of bindinges for global and class functions (limited by design to public methods);
  • Map c++ class inheritance to Julia for type conversion, with support of Abstract type (*);
  • Map c++ [] operator to Julia setindex! and getindex functions.

(*) In case of a class inheriting from several classes, only one inheritance is mapped. Choice of the parent class is configurable, with a default that takes the first specified in the c++ class definition.

Build and installation

Dependencies:

Software to be present on the system before running cmake:

  • libclang: packages clang-11 and libclang-11-dev on Debian

Software will be downloaded by the cmake command:

Build

  • create a build directory
mkdir build
cd build
  • run cmake .. in the build directory
  • run make

The make command will produce the executable wrapit. Run make install if you'd like to copy it into the system bin directory.

A simple example

A simple example can be found in the example/ex001-Hello directory.

A more complex example

This project is being conducted in the contex of High energy physics (HEP) research, that used a large software ecosystem, with a lot of code written in C++. We will find in the directory examples/ex002-ROOT an example generating bindings for more than 1600 functions and 60 types from the ROOT Data analysis framework.

Mapping conventions

Mapping of non-static c++ class methods

Non-static c++ class methods are mapped to Julia methods with taking the class instance this pointer as first argument

Mapping of C++ ::

The :: C++ namespace separator is mapped to the ! character in julia. We have chosen a character allowed in Julia identifers but not in C++ ones. For instance, std::pair is mapped to std!pair. The ! is also used for class static methods. A static method f() of a class A, A::f() in C++ is mapped to A!f().

Export policy

When importing a Julia module with the using directive, the exported symbols land in the current namespace. Other symbols are accessed by prefixing them with the module name. See Julia documentation for more explanation.

The tool support different options for the list of exported symbol controlled by the export parameter are available: no export, only non-static class methods (the default), export of all functions, export of all functions and all types.

This list is defined in the generated Julia module and can be easily be edited for customization. It can be generated in a dedicated file (specified with the export_jl_fname parameter) that can be included with the include function in the module code, when not using the one produced by the tool.

Specification of the type and function to wrap

The tool selects the bindings to produce from the contents of c++ header files provided by the user. Although, the user can write dedicated header files, the tool is designed to allow usage of the existing header files of the library. For this purpose the selection is done based on a set of rules that follows.

  1. Binding are produced for all classes defined directly (*) in the header files of the list provided by the input parameter;
  2. The selection is recursive and binding are produced for all classes with public access of classes selected for binding;
  3. Binding are produced for all global functions defined directly (*) in these header files;
  4. Binding are produced for all class member functions with a public access including inherited one of the structs and classes defined above;
  5. Binding are produced for all return and argument types of the bound functions if they are classes;
  6. Structs are treated the same way as classes;
  7. Entities listed in the veto file (specified by the veto parameter) are excluded from the selection (**).

The tool needs the definitions of the types selected by Rule 5 to produce the wrapping code, while the header file may contain only a forward declaration. The tool look for the type definition in all the files of the input list and files provided for this purpose in the extra_header parameter after resolving the #include chains.

If the propagation_mode parameter is set to "methods", then the types selected in Rule 5 are treated as if they were present in one file of the input independently if it is the case or not. Bindings will be produced for the public members of these types. As this is recursive it can lead to an inflation of the entity selected for bindings.

For a complex header file tree, the rules may not be sufficient to define the entity to bind using only existing header files. A challenging example is the set of header files of g++ for the c++ standard library.

(*) Directly means here that the content of the #include files are ignored. (**) Note that an exact match of the entity signature is required for the veto to work. The signature can be found in comments above the wrap declaration in the generated c++ code before the entity is vetoed.

Debugging Tips

  1. In case of wrapping failure, error message when importing the module in Julia, can refer to types using mangled c++ identifier like St6vectorIdSaIdEE. To demangle, the name, use the Unix command c++filt with the -t option, in this example, c++-filt -t St6vectorIdSaIdEE which will reveal the actual type, std::vector<double, std::allocator<double> >.
  2. When a type if used by a function, its wrapping should appear before the function in the wrapping c++ code. The tool takes into account this constraint when generating the code. An error message when importing the module about missing type can be due to misordering, for instance after manual edition of the file.
  3. The wrapper can be compiled with the macro 'VERBOSE_IMPORT' to display the import progress. That should help debugging an error occuring when import the Julia module.

Status and limitations

The code is experimental, but can already produce ready-to-use code. It has several limitations:

  • Support of wrapping of template class is incomplete and typically require manual correction to the code;
  • Wrapping of variadic functions is not supported;
  • Global variables are not mapped, but access can be provided by defining accessor functions in an input header file;

Technology

The code uses Clang from the LLVM compiler infrastructure to interpret the C++ code. It uses mainly its high level C API libclang. The C++ clang AST library is accessed directly for the required features not exposed by libclang (see libclang-ex.h and libclang-ex.cpp files). These direct calls aim to be dropped whenever the corresponding features will be added to the libclang API.

Download Details: 
Author: grasph
Source Code: https://github.com/grasph/wrapit 
#julia #cplusplus #cpp

wrapit: Automatization of C++--Julia Wapper Generation

Generation of Julia Interface to a C++ Library with CxxWrap.jl

Automatization of the generation of Julia Bindings for C++ Libraries. Learn how the generation of a Julia interface to a C++ library can be automatized using CxxWrap.jl 

Interporability of Julia with C++ is essential for the use of the Julia programming language in fields with a large legacy of code written in this language. We will show how the generation of a Julia interface to a C++ library can be automatized using CxxWrap.jl and a tool that generates the required C++ glue code. The concept is demonstrated with a prototype called WrapIt!, based on clang and which is already well advanced.

#julia #cplusplus #cpp

Generation of Julia Interface to a C++ Library with CxxWrap.jl
Romolo  Morelli

Romolo Morelli

1658636220

Carbon Language: un successore sperimentale di C++

Carbon Programming Language di Google: un successore di C++

Carbon, l'ultimo linguaggio di programmazione creato all'interno di Google, è stato presentato oggi come un successore sperimentale di C++.

Nel corso degli anni, Google ha creato alcuni linguaggi di programmazione, alcuni dei quali sono diventati più popolari e importanti di altri. Ad esempio, Golang (o semplicemente Go) è stato creato con lo scopo di migliorare lo sviluppo di server e sistemi distribuiti e da allora è stato adottato dal pubblico. Nel frattempo, il linguaggio di programmazione Dart, originariamente inteso come una sorta di alternativa a JavaScript, non ha raggiunto la popolarità mainstream fino al rilascio di Flutter.

Oggi, alla convention Cpp North a Toronto, come condiviso da Conor Hoekstra che era presente e ha documentato le diapositive, il googler Chandler Carruth ha condiviso la visione di un nuovo linguaggio di programmazione chiamato Carbon . Per impostare la scena, Carruth ha mostrato come molti dei linguaggi di programmazione più popolari di oggi hanno successori che consentono agli sviluppatori di essere rapidamente produttivi e di sfruttare anche il design dei linguaggi moderni.

Gli sviluppatori Android sanno bene che Kotlin funge da successore di Java, proprio come gli sviluppatori iOS sanno che Swift è il successore di Objective-C. TypeScript, di Microsoft, ha completamente migliorato JavaScript, pur rimanendo comodo da usare e in grado di essere "traspilato" di nuovo in JavaScript. C++, che vede una quantità significativa di utilizzo all'interno di Google, è similmente una sorta di successore del linguaggio di programmazione C originale.

Mentre alcuni potrebbero suggerire che Rust, originariamente un progetto Mozilla che da allora è cresciuto fino ad avere un seguito pubblico significativo, sia un successore di C++, Carruth si chiede se l'analogia segue ancora. Sebbene Rust sia innegabilmente un ottimo linguaggio per iniziare un nuovo progetto, non ha la stessa "interoperabilità bidirezionale" di qualcosa come Java e Kotlin, rendendo difficile la migrazione costante.

Se Rust funziona per te oggi, dovresti usarlo. Ma spostare un ecosistema C++ su Rust è difficile.

A tal fine, mentre Carbon ha molti degli stessi obiettivi di Rust, come aiutare gli sviluppatori a creare "software critici per le prestazioni", Carbon è anche concepito per essere completamente interoperabile con il codice C++ esistente. Inoltre, l'obiettivo è rendere la migrazione da C++ a Carbon il più semplice possibile, se lo si desidera.

Per quanto riguarda il motivo per cui uno sviluppatore C++ potrebbe voler prendere in considerazione l'introduzione di Carbon nella propria base di codice, Carruth ha condiviso alcuni punti salienti del linguaggio sul palco.

  • Parole chiave introduttive e una semplice grammatica
  • I parametri di ingresso della funzione sono valori di sola lettura
  • I puntatori forniscono accesso indiretto e mutazione
  • Usa le espressioni per nominare i tipi
  • Il pacchetto è lo spazio dei nomi radice
  • Importa le API tramite il nome del pacchetto
  • Il parametro oggetto esplicito dichiara un metodo
  • Unica eredità; le classi sono finali per impostazione predefinita
  • Generici potenti e con verifica della definizione
  • I tipi implementano in modo esplicito le interfacce

Al di là delle caratteristiche del linguaggio stesso, il team di Carbon ha richiamato l'attenzione sul processo di sviluppo che plasmerà il futuro di Carbon. Il codice del progetto è ospitato pubblicamente su GitHub ed è aperto alle richieste pull, mentre la cultura di Carbon è delineata per essere accessibile e inclusiva sia per i dipendenti delle aziende che per i privati.

Detto questo, un aspetto del linguaggio di programmazione Carbon che non è particolarmente ben delineato è il coinvolgimento di Google. Sebbene la presentazione di oggi sia stata condivisa da un googler e gli attuali leader del progetto per Carbon consistono principalmente, ma non interamente, in googler, altrimenti non si fa menzione del fatto che Carbon sia un progetto di Google.

Ciò è in realtà intenzionale, poiché mentre Carbon ha avuto inizio all'interno di Google, il team comprende e ha condiviso online che, per avere un successo futuro, Carbon deve essere "un progetto indipendente e guidato dalla comunità", non guidato esclusivamente dagli usi di Google . Nello stesso commento, Carruth sottolinea ulteriormente che il carbonio è attualmente solo un esperimento, anche se alcune aziende hanno già mostrato precocemente interesse.

Se sei interessato a iniziare con Carbon, puoi scaricare il codice sorgente e sperimentarlo sul tuo dispositivo. Oppure puoi avere un'idea del linguaggio di programmazione Carbon direttamente nel tuo browser grazie all'integrazione con l' app web gratuita Compiler Explorer .

Una versione precedente di questo articolo affermava erroneamente che tutti i lead di Carbon sono dipendenti di Google. Ci scusiamo per l'errore.

Fonte dell'articolo originale su https://9to5google.com

#carbonlang #cplusplus #cpp 

Carbon Language: un successore sperimentale di C++
许 志强

许 志强

1658625360

Carbon 語言:C++ 的實驗性繼承者

Google 的 Carbon 編程語言:C++ 的繼任者

Carbon 是谷歌內部構建的最新編程語言,今天作為 C++ 的實驗性繼任者亮相。

多年來,谷歌創造了一些編程語言,其中一些變得比其他更流行和突出。例如,Golang(或簡稱 Go)是為了改進服務器和分佈式系統的開發而創建的,並已被公眾採用。與此同時,Dart 編程語言,最初旨在作為 JavaScript 的替代品,直到 Flutter 發布才成為主流。

今天,在多倫多舉行的 Cpp North 大會上,出席會議並記錄幻燈片的 Conor Hoekstra分享了 Google 員工 Chandler Carruth 對名為Carbon的新編程語言的願景。為了設置場景,Carruth 展示了當今最流行的編程語言中有多少有後繼者,可以讓開發人員快速提高生產力並利用現代語言設計。

Android 開發者很清楚 Kotlin 是 Java 的繼承者,正如 iOS 開發者知道 Swift 是 Objective-C 的繼承者一樣。來自 Microsoft 的 TypeScript 徹底增強了 JavaScript,同時保持舒適的使用並能夠“轉譯”回 JavaScript。C++ 在 Google 中得到了大量使用,類似地是原始 C 編程語言的繼承者。

雖然有些人可能認為 Rust 最初是一個 Mozilla 項目,後來發展為擁有大量公眾追隨者,但它是 C++ 的繼承者,但 Carruth 想知道這個類比是否仍然存在。儘管不可否認,Rust 是一種很好的啟動新項目的語言,但它不像 Java 和 Kotlin 那樣具有“雙向互操作性”,因此很難穩定地遷移。

如果 Rust 今天適合你,你應該使用它。但是將 C++ 生態系統遷移到 Rust 是很困難的。

為此,雖然Carbon與 Rust 有許多相同的目標,例如幫助開發人員創建“性能關鍵軟件”,但 Carbon 還旨在與現有的 C++ 代碼完全互操作。此外,如果需要,目標是盡可能輕鬆地從 C++ 遷移到 Carbon。

至於為什麼 C++ 開發人員可能要考慮將 Carbon 引入他們的代碼庫,Carruth 在舞台上分享了該語言的許多亮點。

  • 介紹人關鍵字和簡單語法
  • 函數輸入參數是只讀值
  • 指針提供間接訪問和變異
  • 使用表達式來命名類型
  • 包是根命名空間
  • 通過包名導入 API
  • 顯式對象參數聲明一個方法
  • 單繼承;默認情況下,類是最終的
  • 強大的、經過定義檢查的泛型
  • 類型顯式實現接口

除了語言本身的特性之外,Carbon 團隊還關注將塑造 Carbon 未來的開發過程。該項目的代碼在 GitHub 上公開託管,並且對拉取請求開放,而 Carbon 的文化被概述為對公司員工和個人等的員工都可以訪問和包容。

也就是說,Carbon 編程語言的一個方面沒有特別清楚地概述是谷歌的參與。雖然今天的演示是由一位 Google 員工分享的,並且 Carbon 目前的項目負責人主要(但不完全)由 Google 員工組成,但沒有提到 Carbon 是一個 Google 項目。

這實際上是有意為之的,因為雖然 Carbon 是在 Google 內部起步的,但該團隊理解並在網上分享說,為了未來取得成功,Carbon 需要成為“一個獨立的社區驅動項目”,而不僅僅是由 Google 自己的用途驅動. 在同一評論中,Carruth 進一步強調 Carbon 目前只是一項實驗,儘管一些公司已經表現出早期的興趣。

如果您對開始使用 Carbon 感興趣,可以下載源代碼並在自己的設備上進行試驗。或者,由於與免費的Compiler Explorer Web 應用程序集成,您可以直接在瀏覽器中體驗 Carbon 編程語言。

本文的早期版本錯誤地指出,Carbon 的所有潛在客戶都是 Google 員工。我們為這個錯誤道歉。

原文來源https://9to5google.com

#carbonlang #cplusplus #cpp 

Carbon 語言:C++ 的實驗性繼承者

Carbon Language: Un sucesor experimental de C++

Lenguaje de programación Carbon de Google: un sucesor de C++

Carbon, el lenguaje de programación más reciente creado en Google, se presentó hoy como un sucesor experimental de C++.

A lo largo de los años, Google ha creado algunos lenguajes de programación, algunos de los cuales se han vuelto más populares y destacados que otros. Por ejemplo, Golang (o simplemente Go) se creó con el propósito de mejorar el desarrollo de servidores y sistemas distribuidos y desde entonces ha sido adoptado por el público. Mientras tanto, el lenguaje de programación Dart, originalmente pensado como una alternativa a JavaScript, no alcanzó la popularidad general hasta el lanzamiento de Flutter.

Hoy, en la convención Cpp North en Toronto, tal como lo compartió Conor Hoekstra , quien asistió y documentó las diapositivas, Googler Chandler Carruth compartió la visión de un nuevo lenguaje de programación llamado Carbon . Para preparar el escenario, Carruth mostró cuántos de los lenguajes de programación más populares de la actualidad tienen sucesores que permiten a los desarrolladores ser rápidamente productivos y también aprovechar el diseño de lenguaje moderno.

Los desarrolladores de Android saben muy bien que Kotlin sirve como sucesor de Java, al igual que los desarrolladores de iOS saben que Swift es el sucesor de Objective-C. TypeScript, de Microsoft, ha mejorado completamente JavaScript, sin dejar de ser cómodo de usar y capaz de "transpilarse" de nuevo a JavaScript. C ++, que ve una cantidad significativa de uso dentro de Google, es igualmente una especie de sucesor del lenguaje de programación C original.

Si bien algunos pueden sugerir que Rust, originalmente un proyecto de Mozilla que desde entonces ha crecido hasta tener un seguimiento público significativo, es un sucesor de C ++, Carruth se pregunta si la analogía aún se mantiene. Si bien Rust es sin duda un gran lenguaje para comenzar un nuevo proyecto, no tiene la misma "interoperabilidad bidireccional" de algo como Java y Kotlin, lo que dificulta la migración constante.

Si Rust funciona para ti hoy, deberías usarlo. Pero mover un ecosistema C++ a Rust es difícil.

Con ese fin, mientras que Carbon tiene muchos de los mismos objetivos que Rust, como ayudar a los desarrolladores a crear "software crítico para el rendimiento", Carbon también pretende ser totalmente interoperable con el código C++ existente. Además, el objetivo es hacer que la migración de C++ a Carbon sea lo más fácil posible, si se desea.

En cuanto a por qué un desarrollador de C ++ puede querer considerar la introducción de Carbon en su base de código, Carruth compartió algunos aspectos destacados del lenguaje en el escenario.

  • Palabras clave de introducción y una gramática simple
  • Los parámetros de entrada de la función son valores de solo lectura
  • Los punteros proporcionan acceso indirecto y mutación
  • Usar expresiones para nombrar tipos
  • El paquete es el espacio de nombres raíz.
  • Importar API a través de su nombre de paquete
  • El parámetro de objeto explícito declara un método
  • herencia única; las clases son finales por defecto
  • Genéricos potentes y con definición comprobada
  • Los tipos implementan interfaces explícitamente

Más allá de las características del lenguaje en sí, el equipo de Carbon llamó la atención sobre el proceso de desarrollo que dará forma al futuro de Carbon. El código del proyecto está alojado públicamente en GitHub y está abierto para solicitudes de incorporación de cambios, mientras que la cultura de Carbon se describe como accesible e inclusiva para empleados de empresas y particulares por igual.

Dicho esto, un aspecto del lenguaje de programación Carbon que no está particularmente bien definido es la participación de Google. Si bien la presentación de hoy fue compartida por un Googler, y los líderes del proyecto actual para Carbon consisten principalmente, pero no en su totalidad, en Googlers, por lo demás, no se menciona que Carbon sea un proyecto de Google.

En realidad, esto es intencional, ya que si bien Carbon comenzó dentro de Google, el equipo entiende y ha compartido en línea que para que tenga éxito en el futuro, Carbon debe ser "un proyecto independiente e impulsado por la comunidad", no solo impulsado por los propios usos de Google. . En el mismo comentario, Carruth enfatiza además que Carbon es actualmente solo un experimento, aunque algunas empresas ya han mostrado un interés temprano.

Si está interesado en comenzar con Carbon, puede descargar el código fuente y experimentar con él en su propio dispositivo. O bien, puede familiarizarse con el lenguaje de programación Carbon directamente en su navegador gracias a la integración con la aplicación web gratuita Compiler Explorer .

Una versión anterior de este artículo afirmaba incorrectamente que todos los clientes potenciales de Carbon son empleados de Google. Pedimos disculpas por el error.

Fuente del artículo original en https://9to5google.com

#carbonlang #cplusplus #cpp 

Carbon Language: Un sucesor experimental de C++
Poppy Cooke

Poppy Cooke

1658607240

Carbon Language : un successeur expérimental du C++

Le langage de programmation Carbon de Google : un successeur du C++

Carbon, le dernier langage de programmation créé au sein de Google, a été dévoilé aujourd'hui en tant que successeur expérimental de C++.

Au fil des ans, Google a créé quelques langages de programmation, dont certains sont devenus plus populaires et importants que d'autres. Par exemple, Golang (ou simplement Go) a été créé dans le but d'améliorer le développement des serveurs et des systèmes distribués et a depuis été adopté par le public. Pendant ce temps, le langage de programmation Dart, initialement conçu comme une alternative à JavaScript, n'a pas atteint la popularité grand public avant la sortie de Flutter.

Aujourd'hui, lors de la convention Cpp North à Toronto, partagée par Conor Hoekstra qui était présent et a documenté les diapositives, Googler Chandler Carruth a partagé la vision d'un nouveau langage de programmation appelé Carbon . Pour planter le décor, Carruth a montré combien de langages de programmation parmi les plus populaires d'aujourd'hui ont des successeurs qui permettent aux développeurs d'être rapidement productifs et de tirer parti de la conception de langages modernes.

Les développeurs Android savent bien que Kotlin sert de successeur à Java, tout comme les développeurs iOS savent que Swift est le successeur d'Objective-C. TypeScript, de Microsoft, a considérablement amélioré JavaScript, tout en restant confortable à utiliser et capable d'être "transpilé" vers JavaScript. C ++, qui est largement utilisé au sein de Google, est également une sorte de successeur du langage de programmation C d'origine.

Alors que certains peuvent suggérer que Rust, à l'origine un projet Mozilla qui a depuis grandi pour avoir un public important, est un successeur de C++, Carruth se demande si l'analogie suit toujours. Bien que Rust soit indéniablement un excellent langage pour démarrer un nouveau projet, il n'a pas la même "interopérabilité bidirectionnelle" que quelque chose comme Java et Kotlin, ce qui rend difficile la migration régulière.

Si Rust fonctionne pour vous aujourd'hui, vous devriez l'utiliser. Mais déplacer un écosystème C++ vers Rust est difficile.

À cette fin, alors que Carbon a plusieurs des mêmes objectifs que Rust, comme aider les développeurs à créer des «logiciels critiques pour les performances», Carbon est également destiné à être entièrement interopérable avec le code C++ existant. De plus, l'objectif est de rendre la migration de C++ vers Carbon aussi simple que possible, si vous le souhaitez.

Quant à savoir pourquoi un développeur C++ peut envisager d'introduire Carbon dans sa base de code, Carruth a partagé quelques points forts du langage sur scène.

  • Des mots-clés d'introduction et une grammaire simple
  • Les paramètres d'entrée de la fonction sont des valeurs en lecture seule
  • Les pointeurs fournissent un accès indirect et une mutation
  • Utiliser des expressions pour nommer les types
  • Le package est l'espace de noms racine
  • Importer des API via leur nom de package
  • Le paramètre d'objet explicite déclare une méthode
  • Héritage unique; les classes sont finales par défaut
  • Des génériques puissants dont la définition a été vérifiée
  • Les types implémentent explicitement les interfaces

Au-delà des caractéristiques du langage lui-même, l'équipe Carbon a attiré l'attention sur le processus de développement qui façonnera l'avenir de Carbon. Le code du projet est hébergé publiquement sur GitHub et est ouvert aux demandes d'extraction, tandis que la culture de Carbon est décrite comme étant accessible et inclusive pour les employés des entreprises et les particuliers.

Cela dit, un aspect du langage de programmation Carbon qui n'est pas particulièrement bien décrit est l'implication de Google. Bien que la présentation d'aujourd'hui ait été partagée par un Googler et que les chefs de projet actuels pour Carbon se composent principalement - mais pas entièrement - de Googlers, il n'y a aucune mention du fait que Carbon soit un projet Google.

C'est en fait intentionnel, car alors que Carbon a fait ses débuts au sein de Google, l'équipe comprend et a partagé en ligne que pour qu'il ait un succès futur, Carbon doit être "un projet indépendant et axé sur la communauté", et pas uniquement motivé par les propres utilisations de Google. . Dans le même commentaire, Carruth souligne en outre que Carbon n'est actuellement qu'une expérience, même si certaines entreprises ont déjà manifesté un intérêt précoce.

Si vous souhaitez démarrer avec Carbon, vous pouvez télécharger le code source et l'expérimenter sur votre propre appareil. Ou, vous pouvez vous faire une idée du langage de programmation Carbon directement dans votre navigateur grâce à l'intégration avec l' application Web gratuite Compiler Explorer .

Une version antérieure de cet article indiquait à tort que tous les prospects de Carbon étaient des employés de Google. Nous nous excusons pour l'erreur.

Source de l'article d'origine sur https://9to5google.com

#carbonlang #cplusplus #cpp 

Carbon Language : un successeur expérimental du C++
田辺  明美

田辺 明美

1658599980

GoogleのCarbonプログラミング言語:C++の後継

Google内で構築される最新のプログラミング言語であるCarbonは、C++の後継として実験的に発表されました。

何年にもわたって、Googleはいくつかのプログラミング言語を作成してきましたが、そのうちのいくつかは他の言語よりも人気があり、目立つようになりました。たとえば、Golang(または単にGo)は、サーバーと分散システムの開発を改善する目的で作成され、その後、一般に採用されています。一方、元々JavaScriptの代替として意図されていたDartプログラミング言語は、Flutterがリリースされるまで主流の人気に達しませんでした。

今日、トロントで開催されたCpp Northコンベンションで、出席してスライドを文書化したConor Hoekstraが共有したように、Google社員のChandlerCarruthがCarbonと呼ばれる新しいプログラミング言語のビジョンを共有しました。シーンを設定するために、Carruthは、今日最も人気のあるプログラミング言語の多くに、開発者が迅速に生産性を高め、現代の言語設計を活用できるようにする後継言語があることを示しました。

Android開発者は、iOS開発者がSwiftがObjective-Cの後継者であることを知っているように、KotlinがJavaの後継者として機能することをよく知っています。MicrosoftのTypeScriptは、JavaScriptを徹底的に強化し、使い心地を維持し、JavaScriptに「トランスパイル」して戻すことができます。Google内でかなりの量の使用が見られるC++は、同様に元のCプログラミング言語の後継です。

もともとはMozillaプロジェクトであり、その後多くの人々に支持されるようになったRustは、C ++の後継であると示唆する人もいるかもしれませんが、Carruthはその類似性がまだ続いているかどうか疑問に思います。Rustは間違いなく新しいプロジェクトを開始するのに最適な言語ですが、JavaやKotlinのような「双方向の相互運用性」を備えていないため、着実に移行することは困難です。

Rustが今日あなたのために働くならば、あなたはそれを使うべきです。しかし、C++エコシステムをRustに移行するのは困難です。

そのために、Carbonには、開発者が「パフォーマンスが重要なソフトウェア」を作成するのを支援するなど、Rustと同じ目標が多数ありますが、Carbonは既存のC++コードと完全に相互運用できることも目的としています。さらに、必要に応じて、C++からCarbonへの移行をできるだけ簡単にすることが目標です。

C ++開発者がCarbonをコードベースに導入することを検討したいと思う理由については、Carruthがステージ上で言語のかなりの数のハイライトを共有しました。

  • イントロデューサーのキーワードと簡単な文法
  • 関数入力パラメーターは読み取り専用値です
  • ポインタは間接的なアクセスと変更を提供します
  • 式を使用してタイプに名前を付ける
  • パッケージはルート名前空間です
  • パッケージ名を使用してAPIをインポートします
  • 明示的なオブジェクトパラメータはメソッドを宣言します
  • 単一継承; クラスはデフォルトで最終です
  • 強力な、定義がチェックされたジェネリック
  • タイプは明示的にインターフェースを実装します

Carbonチームは、言語自体の機能を超えて、Carbonの将来を形作る開発プロセスに注目しました。プロジェクトのコードはGitHubで公開されており、プルリクエストを受け付けています。一方、Carbonの文化は、企業の従業員と個人の両方がアクセスでき、包括的であると概説されています。

とは言うものの、Carbonプログラミング言語の特に十分に概説されていない側面の1つは、Googleの関与です。今日のプレゼンテーションはGoogle社員によって共有され、Carbonの現在のプロジェクトリードは主に(完全ではありませんが)Google社員で構成されていますが、それ以外の点では、CarbonがGoogleプロジェクトであることに言及していません。

これは実際には意図的なものです。CarbonはGoogle内で開始されましたが、チームは、将来の成功を収めるためには、CarbonがGoogle自身の使用だけで推進されるのではなく、「独立したコミュニティ主導のプロジェクト」である必要があることを理解し、オンラインで共有しています。 。同じコメントで、Carruthはさらに、Carbonは現在のところ単なる実験であると強調していますが、一部の企業はすでに初期の関心を示しています。

Carbonの使用を開始することに興味がある場合は、ソースコードをダウンロードして、自分のデバイスで試すことができます。または、無料のコンパイラエクスプローラーWebアプリとの統合により、ブラウザーで直接Carbonプログラミング言語の感触をつかむことができます。

この記事の以前のバージョンでは、CarbonのリードはすべてGoogleの従業員であると誤って記載されていました。私たちは間違いをお詫び申し上げます。

https://9to5google.comの元の記事のソース

#carbonlang #cplusplus #cpp 

GoogleのCarbonプログラミング言語:C++の後継
Zenon  Pruschke

Zenon Pruschke

1658567400

Carbon Language: Ein experimenteller Nachfolger von C++

Carbon Programming Language von Google: Ein Nachfolger von C++

Carbon, die neueste Programmiersprache von Google, wurde heute als experimenteller Nachfolger von C++ vorgestellt.

Im Laufe der Jahre hat Google einige Programmiersprachen entwickelt, von denen einige populärer und bekannter geworden sind als andere. Beispielsweise wurde Golang (oder einfach Go) mit dem Ziel entwickelt, die Entwicklung von Servern und verteilten Systemen zu verbessern, und wurde seitdem von der Öffentlichkeit angenommen. Unterdessen erreichte die Programmiersprache Dart, die ursprünglich als eine Art Alternative zu JavaScript gedacht war, erst mit der Veröffentlichung von Flutter allgemeine Popularität.

Heute teilte Googler Chandler Carruth auf der Cpp North Convention in Toronto, wie Conor Hoekstra , der anwesend war und die Folien dokumentierte, die Vision einer neuen Programmiersprache namens Carbon mit . Um den Rahmen zu schaffen, zeigte Carruth, wie viele der heute beliebtesten Programmiersprachen Nachfolger haben, die es Entwicklern ermöglichen, schnell produktiv zu sein und auch die Vorteile des modernen Sprachdesigns zu nutzen.

Android-Entwickler wissen sehr wohl, dass Kotlin als Nachfolger von Java dient, genauso wie iOS-Entwickler wissen, dass Swift der Nachfolger von Objective-C ist. TypeScript von Microsoft hat JavaScript gründlich verbessert, bleibt aber komfortabel zu verwenden und kann zurück in JavaScript „transpiliert“ werden. C++, das von Google stark genutzt wird, ist in ähnlicher Weise eine Art Nachfolger der ursprünglichen Programmiersprache C.

Während einige vermuten, dass Rust, ursprünglich ein Mozilla-Projekt, das inzwischen eine bedeutende öffentliche Anhängerschaft hat, ein Nachfolger von C++ ist, fragt sich Carruth, ob die Analogie immer noch folgt. Während Rust zweifellos eine großartige Sprache ist, um ein neues Projekt zu starten, hat es nicht die gleiche „bidirektionale Interoperabilität“ wie Java und Kotlin, was eine kontinuierliche Migration erschwert.

Wenn Rust heute für Sie funktioniert, sollten Sie es verwenden. Aber ein C++-Ökosystem nach Rust zu verschieben ist schwierig.

Zu diesem Zweck hat Carbon zwar viele der gleichen Ziele wie Rust, beispielsweise Entwicklern bei der Erstellung „leistungskritischer Software“ zu helfen, aber Carbon soll auch vollständig mit bestehendem C++-Code interoperabel sein. Darüber hinaus ist es das Ziel, die Migration von C++ zu Carbon so einfach wie möglich zu gestalten, falls gewünscht.

Warum ein C++-Entwickler vielleicht darüber nachdenken sollte, Carbon in seine Codebasis einzuführen, teilte Carruth auf der Bühne einige Highlights der Sprache mit.

  • Einführungsschlüsselwörter und eine einfache Grammatik
  • Funktionseingabeparameter sind schreibgeschützte Werte
  • Zeiger bieten indirekten Zugriff und Mutation
  • Verwenden Sie Ausdrücke, um Typen zu benennen
  • Das Paket ist der Root-Namespace
  • Importieren Sie APIs über ihren Paketnamen
  • Explizite Objektparameter deklarieren eine Methode
  • Einfache Vererbung; Klassen sind standardmäßig final
  • Leistungsstarke, definitionsgeprüfte Generika
  • Typen implementieren Schnittstellen explizit

Über die Funktionen der Sprache hinaus machte das Carbon-Team auf den Entwicklungsprozess aufmerksam, der die Zukunft von Carbon prägen wird. Der Code des Projekts wird öffentlich auf GitHub gehostet und ist offen für Pull-Requests, während die Kultur von Carbon so umrissen ist , dass sie für Mitarbeiter von Unternehmen und Privatpersonen gleichermaßen zugänglich und inklusiv ist.

Allerdings ist ein Aspekt der Carbon-Programmiersprache, der nicht besonders gut umrissen ist, die Beteiligung von Google. Während die heutige Präsentation von einem Google-Mitarbeiter geteilt wurde und die aktuellen Projektleiter für Carbon hauptsächlich – aber nicht ausschließlich – aus Google-Mitarbeitern bestehen, wird Carbon ansonsten nicht als Google-Projekt erwähnt.

Dies ist eigentlich beabsichtigt, denn während Carbon seinen Anfang bei Google hatte, versteht das Team und hat online mitgeteilt, dass Carbon „ein unabhängiges und von der Gemeinschaft angetriebenes Projekt“ sein muss, um zukünftig erfolgreich zu sein, und nicht nur von Googles eigenen Nutzungen angetrieben wird . Im selben Kommentar betont Carruth weiter, dass Carbon derzeit nur ein Experiment sei, an dem allerdings einige Unternehmen schon früh Interesse gezeigt hätten.

Wenn Sie daran interessiert sind, mit Carbon zu beginnen, können Sie den Quellcode herunterladen und auf Ihrem eigenen Gerät damit experimentieren. Oder Sie können dank der Integration mit der kostenlosen Web-App Compiler Explorer direkt in Ihrem Browser ein Gefühl für die Programmiersprache Carbon bekommen .

In einer früheren Version dieses Artikels wurde fälschlicherweise angegeben, dass alle Leads von Carbon Google-Mitarbeiter sind. Wir entschuldigen uns für den Fehler.

Quelle des ursprünglichen Artikels unter https://9to5google.com

#carbonlang #cplusplus #cpp 

Carbon Language: Ein experimenteller Nachfolger von C++

Carbon Language: Um sucessor experimental para C++

Linguagem de programação carbono do Google: um sucessor do C++

Carbon, a mais recente linguagem de programação a ser construída no Google, foi apresentada hoje como um sucessor experimental do C++.

Ao longo dos anos, o Google criou algumas linguagens de programação, algumas das quais se tornaram mais populares e proeminentes do que outras. Por exemplo, Golang (ou simplesmente Go) foi criado com o propósito de melhorar o desenvolvimento de servidores e sistemas distribuídos e desde então tem sido adotado pelo público. Enquanto isso, a linguagem de programação Dart, originalmente concebida como uma alternativa ao JavaScript, não alcançou popularidade até o lançamento do Flutter.

Hoje, na convenção Cpp North em Toronto, conforme compartilhado por Conor Hoekstra , que esteve presente e documentou os slides, o Googler Chandler Carruth compartilhou a visão de uma nova linguagem de programação chamada Carbon . Para definir o cenário, Carruth mostrou quantas das linguagens de programação mais populares de hoje têm sucessores que permitem que os desenvolvedores sejam rapidamente produtivos e também aproveitem o design de linguagem moderna.

Os desenvolvedores do Android sabem bem que o Kotlin serve como sucessor do Java, assim como os desenvolvedores do iOS sabem que o Swift é o sucessor do Objective-C. O TypeScript, da Microsoft, aprimorou completamente o JavaScript, mantendo-se confortável de usar e capaz de ser “transpilado” de volta para o JavaScript. C++, que vê uma quantidade significativa de uso no Google, é similarmente uma espécie de sucessor da linguagem de programação C original.

Enquanto alguns podem sugerir que Rust, originalmente um projeto da Mozilla que desde então cresceu para ter um público significativo, é um sucessor do C++, Carruth se pergunta se a analogia ainda segue. Embora o Rust seja inegavelmente uma ótima linguagem para iniciar um novo projeto, ele não tem a mesma “interoperabilidade bidirecional” de algo como Java e Kotlin, dificultando a migração constante.

Se Rust funciona para você hoje, você deve usá-lo. Mas mover um ecossistema C++ para Rust é difícil.

Para esse fim, embora o Carbon tenha muitos dos mesmos objetivos do Rust, como ajudar os desenvolvedores a criar “software de desempenho crítico”, o Carbon também deve ser totalmente interoperável com o código C++ existente. Além disso, o objetivo é tornar a migração de C++ para Carbon o mais fácil possível, se desejado.

Quanto ao motivo pelo qual um desenvolvedor C++ pode querer considerar a introdução do Carbon em sua base de código, Carruth compartilhou alguns destaques da linguagem no palco.

  • Palavras-chave do introdutor e uma gramática simples
  • Os parâmetros de entrada da função são valores somente leitura
  • Ponteiros fornecem acesso indireto e mutação
  • Use expressões para nomear tipos
  • O pacote é o namespace raiz
  • Importar APIs por meio do nome do pacote
  • O parâmetro de objeto explícito declara um método
  • Herança única; as classes são finais por padrão
  • Genéricos poderosos e verificados por definição
  • Tipos implementam interfaces explicitamente

Além dos recursos da linguagem em si, a equipe do Carbon chamou a atenção para o processo de desenvolvimento que moldará o futuro do Carbon. O código do projeto é hospedado publicamente no GitHub e está aberto para pull requests, enquanto a cultura da Carbon é definida para ser acessível e inclusiva para funcionários de empresas e indivíduos.

Dito isso, um aspecto da linguagem de programação Carbon que não é particularmente bem delineado é o envolvimento do Google. Embora a apresentação de hoje tenha sido compartilhada por um Googler, e os líderes atuais do projeto para Carbon consistam principalmente – mas não inteiramente – de Googlers, não há menção de que Carbon seja um projeto do Google.

Na verdade, isso é intencional, pois enquanto o Carbon começou no Google, a equipe entende e compartilhou on-line que, para ter sucesso no futuro, o Carbon precisa ser “um projeto independente e orientado pela comunidade”, não apenas impulsionado pelos próprios usos do Google. . No mesmo comentário, Carruth enfatiza ainda que o Carbon é atualmente apenas um experimento, embora algumas empresas já tenham demonstrado interesse precoce.

Se estiver interessado em começar com o Carbon, você pode baixar o código-fonte e experimentá-lo em seu próprio dispositivo. Ou você pode ter uma ideia da linguagem de programação Carbon diretamente no seu navegador, graças à integração com o aplicativo web gratuito do Compiler Explorer .

Uma versão anterior deste artigo afirmava incorretamente que todos os leads da Carbon são funcionários do Google. Pedimos desculpas pelo erro.

Fonte do artigo original em https://9to5google.com

#carbonlang #cplusplus #cpp 

Carbon Language: Um sucessor experimental para C++

لغة الكربون: خليفة تجريبي لـ C ++

تم الكشف اليوم عن Carbon ، أحدث لغة برمجة يتم إنشاؤها داخل Google ، كخلف تجريبي لـ C ++.

على مر السنين ، أنشأت Google عددًا قليلاً من لغات البرمجة ، أصبح بعضها أكثر شهرة وبروزًا من غيرها. على سبيل المثال ، تم إنشاء Golang (أو ببساطة Go) لغرض تحسين تطوير الخوادم والأنظمة الموزعة ومنذ ذلك الحين تم تبنيها من قبل الجمهور. وفي الوقت نفسه ، فإن لغة برمجة Dart ، التي كان يُقصد منها في الأصل أن تكون بديلاً لجافا سكريبت ، لم تصل إلى الشعبية السائدة حتى إصدار Flutter.

اليوم ، في مؤتمر Cpp North في تورنتو ، كما شاركه Conor Hoekstra الذي كان حاضرًا ووثق الشرائح ، شارك Googler Chandler Carruth في رؤية لغة برمجة جديدة تسمى Carbon . لتهيئة المشهد ، أظهر كاروث كيف أن العديد من لغات البرمجة الأكثر شيوعًا اليوم لها خلفاء يسمحون للمطورين أن يكونوا منتجين بسرعة ويستفيدون أيضًا من تصميم اللغة الحديثة.

يعرف مطورو Android جيدًا أن Kotlin تعمل كخلف لـ Java ، تمامًا كما يعرف مطورو iOS أن Swift هي خليفة Objective-C. قامت TypeScript ، من Microsoft ، بتحسين JavaScript تمامًا ، مع الحفاظ على راحة الاستخدام والقدرة على "التحويل" مرة أخرى إلى JavaScript. C ++ ، التي ترى قدرًا كبيرًا من الاستخدام داخل Google ، هي أيضًا خليفة من نوع ما للغة برمجة C الأصلية.

في حين قد يقترح البعض أن Rust ، وهو في الأصل مشروع Mozilla الذي نما منذ ذلك الحين ليكون له جمهور كبير من المتابعين ، هو خليفة لـ C ++ ، يتساءل كاروث إذا كان التشبيه لا يزال يتبع. على الرغم من أن لغة Rust هي بلا شك لغة رائعة لبدء مشروع جديد ، إلا أنها لا تتمتع بنفس "قابلية التشغيل البيني ثنائية الاتجاه" لشيء مثل Java & Kotlin ، مما يجعل من الصعب الهجرة بشكل ثابت.

إذا كان Rust مناسبًا لك اليوم ، فيجب عليك استخدامه. لكن نقل نظام C ++ إلى Rust أمر صعب.

تحقيقا لهذه الغاية ، بينما لدى Carbon العديد من نفس الأهداف مثل Rust ، مثل مساعدة المطورين على إنشاء "برامج حاسمة للأداء" ، فإن Carbon مصمم أيضًا ليكون قابلاً للتشغيل البيني بالكامل مع كود C ++ الحالي. بالإضافة إلى ذلك ، الهدف هو جعل الانتقال من C ++ إلى Carbon أسهل ما يمكن ، إذا رغبت في ذلك.

بالنسبة إلى سبب رغبة مطور C ++ في التفكير في إدخال Carbon إلى قاعدة الرموز الخاصة به ، شارك Carruth في بعض النقاط البارزة في اللغة على خشبة المسرح.

  • مقدمة كلمات أساسية وقواعد نحوية بسيطة
  • معلمات إدخال الوظيفة هي قيم للقراءة فقط
  • توفر المؤشرات وصولاً غير مباشر وطفرة
  • استخدم التعبيرات لتسمية الأنواع
  • الحزمة هي مساحة اسم الجذر
  • استيراد واجهات برمجة التطبيقات من خلال اسم الحزمة الخاصة بهم
  • معلمة الكائن الصريحة تعلن عن طريقة
  • ميراث واحد الفصول نهائية بشكل افتراضي
  • الأدوية الجنيسة القوية التي تم فحصها بدقة
  • الأنواع تنفذ صراحة الواجهات

إلى جانب ميزات اللغة نفسها ، لفت فريق Carbon الانتباه إلى عملية التطوير التي ستشكل مستقبل الكربون. يتم استضافة رمز المشروع علنًا على GitHub وهو مفتوح لطلبات السحب ، في حين تم تحديد ثقافة Carbon لتكون سهلة الوصول وشاملة لموظفي الشركات والأفراد على حد سواء.

ومع ذلك ، فإن أحد جوانب لغة برمجة Carbon التي لم يتم توضيحها بشكل جيد هو مشاركة Google. بينما تمت مشاركة العرض التقديمي اليوم من قِبل موظف Google ، ويتألف رواد المشروع الحالي لـ Carbon بشكل أساسي - ولكن ليس بالكامل - من موظفي Google ، إلا أنه لا يوجد أي ذكر لكون الكربون أحد مشاريع Google.

هذا مقصود في الواقع ، فبينما بدأ Carbon داخل Google ، أدرك الفريق وشارك عبر الإنترنت أنه من أجل تحقيق أي نجاح في المستقبل ، يجب أن يكون Carbon "مشروعًا مستقلاً ومدفوعًا بالمجتمع" ، وليس مدفوعًا فقط باستخدامات Google الخاصة . في التعليق نفسه ، أكد كاروث أيضًا على أن الكربون هو مجرد تجربة في الوقت الحالي ، وإن كانت بعض الشركات قد أبدت بالفعل اهتمامًا مبكرًا بها.

إذا كنت مهتمًا بالبدء في استخدام Carbon ، فيمكنك تنزيل شفرة المصدر وتجربتها على جهازك الخاص. أو يمكنك التعود على لغة برمجة Carbon مباشرة في متصفحك بفضل التكامل مع تطبيق الويب Compiler Explorer المجاني.

ذكرت نسخة سابقة من هذه المقالة بشكل غير صحيح أن جميع العملاء المحتملين لـ Carbon هم موظفون في Google. نعتذر عن الخطأ.

مصدر المقال الأصلي على https://9to5google.com

# carbonlang #cplusplus #cpp 

لغة الكربون: خليفة تجريبي لـ C ++
Hoang  Kim

Hoang Kim

1658549160

Ngôn ngữ Carbon: Một sự kế thừa thử nghiệm cho C ++ từ Google

Carbon, ngôn ngữ lập trình mới nhất được xây dựng trong Google, đã được công bố hôm nay như một phiên bản thử nghiệm kế thừa cho C ++.

Trong những năm qua, Google đã tạo ra một số ngôn ngữ lập trình, một số ngôn ngữ trong số đó đã trở nên phổ biến và nổi bật hơn những ngôn ngữ khác. Ví dụ, Golang (hay đơn giản là Go) được tạo ra với mục đích cải thiện sự phát triển của các máy chủ và hệ thống phân tán và kể từ đó đã được công chúng chấp nhận. Trong khi đó, ngôn ngữ lập trình Dart, ban đầu được dự định là một thứ gì đó thay thế cho JavaScript, đã không trở nên phổ biến cho đến khi phát hành Flutter.

Hôm nay, tại hội nghị Cpp North ở Toronto, như chia sẻ của Conor Hoekstra , người đã tham dự và ghi lại các slide, Googler Chandler Carruth đã chia sẻ tầm nhìn về một ngôn ngữ lập trình mới có tên là Carbon . Để thiết lập bối cảnh, Carruth đã chỉ ra có bao nhiêu ngôn ngữ lập trình phổ biến nhất hiện nay có người kế nhiệm cho phép các nhà phát triển nhanh chóng làm việc hiệu quả và cũng tận dụng lợi thế của thiết kế ngôn ngữ hiện đại.

Các nhà phát triển Android đều biết rằng Kotlin đóng vai trò là người kế nhiệm cho Java, cũng như các nhà phát triển iOS biết Swift là người kế nhiệm cho Objective-C. TypeScript, của Microsoft, đã cải tiến triệt để JavaScript, trong khi vẫn sử dụng thoải mái và có thể được “chuyển đổi” trở lại JavaScript. C ++, được sử dụng nhiều trong Google, tương tự như một sự kế thừa của các loại ngôn ngữ lập trình C gốc.

Trong khi một số người có thể cho rằng Rust, ban đầu là một dự án của Mozilla, kể từ đó đã phát triển để có một lượng người theo dõi công chúng đáng kể, là sự kế thừa của C ++, Carruth tự hỏi liệu điều tương tự có còn tiếp theo hay không. Mặc dù không thể phủ nhận Rust là một ngôn ngữ tuyệt vời để bắt đầu một dự án mới, nhưng nó không có “khả năng tương tác hai chiều” giống như Java & Kotlin, khiến việc di chuyển trở nên khó khăn.

Nếu Rust phù hợp với bạn ngày hôm nay, bạn nên sử dụng nó. Nhưng việc chuyển một hệ sinh thái C ++ sang Rust rất khó.

Vì vậy, mặc dù Carbon có nhiều mục tiêu giống như Rust, chẳng hạn như giúp các nhà phát triển tạo ra “phần mềm quan trọng về hiệu suất”, Carbon cũng được dự định là có thể tương tác hoàn toàn với mã C ++ hiện có. Ngoài ra, mục tiêu là làm cho việc di chuyển từ C ++ sang Carbon dễ dàng nhất có thể, nếu muốn.

Về lý do tại sao một nhà phát triển C ++ có thể muốn xem xét giới thiệu Carbon vào cơ sở mã của họ, Carruth đã chia sẻ khá nhiều điểm nổi bật của ngôn ngữ này trên sân khấu.

  • Từ khóa giới thiệu và ngữ pháp đơn giản
  • Các tham số đầu vào của hàm là các giá trị chỉ đọc
  • Con trỏ cung cấp truy cập gián tiếp & đột biến
  • Sử dụng các biểu thức để đặt tên cho các loại
  • Gói là không gian tên gốc
  • Nhập các API thông qua tên gói của chúng
  • Tham số đối tượng rõ ràng khai báo một phương thức
  • Thừa kế đơn lẻ; các lớp là cuối cùng theo mặc định
  • Thuốc generic mạnh mẽ, được kiểm tra độ nét
  • Các loại giao diện triển khai rõ ràng

Ngoài các tính năng của chính ngôn ngữ, nhóm Carbon đã thu hút sự chú ý đến quá trình phát triển sẽ định hình tương lai của Carbon. Mã của dự án được lưu trữ công khai trên GitHub và mở cho các yêu cầu kéo, trong khi văn hóa của Carbon được phác thảo để có thể truy cập và toàn diện cho nhân viên của các công ty và cá nhân như nhau.

Điều đó nói rằng, một khía cạnh của ngôn ngữ lập trình Carbon không được phác thảo rõ ràng là sự tham gia của Google. Mặc dù bài thuyết trình hôm nay được chia sẻ bởi một nhân viên Google và các dự án hiện tại dẫn đầu cho Carbon chủ yếu bao gồm - nhưng không hoàn toàn - của nhân viên Google, thì không có đề cập nào đến việc Carbon là một dự án của Google.

Điều này thực sự có chủ đích, vì trong khi Carbon bắt đầu thành lập trong Google, nhóm đã hiểu và đã chia sẻ trực tuyến rằng để có được bất kỳ thành công nào trong tương lai, Carbon cần phải là “một dự án độc lập và do cộng đồng thúc đẩy”, không chỉ dựa trên mục đích sử dụng của chính Google . Trong cùng một nhận xét, Carruth nhấn mạnh thêm rằng Carbon hiện chỉ là một thử nghiệm, mặc dù một số công ty đã sớm tỏ ra quan tâm.

Nếu bạn quan tâm đến việc bắt đầu với Carbon, bạn có thể tải xuống mã nguồn và thử nghiệm với nó trên thiết bị của riêng bạn. Hoặc, bạn có thể cảm nhận ngôn ngữ lập trình Carbon trực tiếp trong trình duyệt của mình nhờ tích hợp với ứng dụng web Compiler Explorer miễn phí.

Phiên bản trước của bài viết này đã tuyên bố không chính xác rằng tất cả các khách hàng tiềm năng của Carbon đều là nhân viên của Google. Chúng tôi xin lỗi vì sai lầm.

Nguồn bài viết gốc tại https://9to5google.com

#carbonlang #cplusplus #cpp 

Ngôn ngữ Carbon: Một sự kế thừa thử nghiệm cho C ++ từ Google

Carbon Programming Language from Google: A Successor to C++

Carbon, the latest programming language to be built within Google, was unveiled today as an experimental successor to C++.

Over the years, Google has created a few programming languages, some of which have become more popular and prominent than others. For example, Golang (or simply Go) was created for the purpose of improving the development of servers and distributed systems and has since been adopted by the public. Meanwhile, the Dart programming language, originally intended as something of an alternative to JavaScript, didn’t reach mainstream popularity until the release of Flutter.

Today, at the Cpp North convention in Toronto, as shared by Conor Hoekstra who was in attendance and documented the slides, Googler Chandler Carruth shared the vision for a new programming language called Carbon. To set the scene, Carruth showed how many of today’s most popular programming languages have successors that allow developers to be rapidly productive and also take advantage of modern language design.

Android developers well know that Kotlin serves as a successor to Java, just as iOS developers know Swift is the successor to Objective-C. TypeScript, from Microsoft, has thoroughly enhanced JavaScript, while remaining comfortable to use and able to be “transpiled” back to JavaScript. C++, which sees a significant amount of use within Google, is similarly a successor of sorts to the original C programming language.

While some may suggest that Rust, originally a Mozilla project that has since grown to have a significant public following, is a successor to C++, Carruth wonders if the analogy still follows. While Rust is undeniably a great language to start a new project in, it doesn’t have the same “bi-directional interoperability” of something like Java & Kotlin, making it difficult to steadily migrate.

If Rust works for you today, you should use it. But moving a C++ ecosystem to Rust is hard.

To that end, while Carbon has many of the same goals as Rust, such as helping developers to create “performance-critical software,” Carbon is also intended to be fully interoperable with existing C++ code. Additionally, the goal is to make migrating from C++ to Carbon as easy as possible, if desired.

As for why a C++ developer may want to consider introducing Carbon to their codebase, Carruth shared quite a few highlights of the language on stage.

  • Introducer keywords and a simple grammar
  • Function input parameters are readonly values
  • Pointers provide indirect access & mutation
  • Use expressions to name types
  • The package is the root namespace
  • Import APIs through their package name
  • Explicit object parameter declares a method
  • Single inheritance; classes are final by default
  • Powerful, definition-checked generics
  • Types explicitly implement interfaces

Beyond the features of the language itself, the Carbon team drew attention to the development process that will shape Carbon’s future. The project’s code is hosted publicly on GitHub and is open for pull requests, while Carbon’s culture is outlined to be accessible and inclusive for employees of companies and private individuals, alike.

That said, one aspect of the Carbon programming language that’s not particularly well outlined is Google’s involvement. While today’s presentation was shared by a Googler, and the current project leads for Carbon consist primarily — but not entirely — of Googlers, there’s otherwise no mention of Carbon being a Google project.

This is actually intentional, as while Carbon got its start within Google, the team understands and has shared online that for it to have any future success, Carbon needs to be “an independent and community driven project,” not solely driven by Google’s own uses. In the same comment, Carruth further emphasizes that Carbon is currently just an experiment, albeit one that some companies have already shown early interest in.

If you’re interested in getting started with Carbon, you can download the source code and experiment with it on your own device. Or, you can get a feel for the Carbon programming language directly in your browser thanks to integration with the free Compiler Explorer web app.

An earlier version of this article incorrectly stated that all of Carbon’s leads are Google employees. We apologize for the mistake.

Original article source at https://9to5google.com

#carbonlang #cplusplus #cpp 

Carbon Programming Language from Google: A Successor to C++
Samuel Tucker

Samuel Tucker

1658543330

Carbon Language: An Experimental Successor to C++

Carbon is a new early-stage programming language from Google designed as a successor to C++ for low level systems development.

Quicksort code in Carbon. Follow the link to read more.

Fast and works with C++

  • 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

Why build Carbon?

C++ remains the dominant programming language for performance-critical software, with massive and growing codebases and investments. However, it is struggling to improve and meet developers' needs outlined above, in no small part due to accumulating decades of technical debt. Incrementally improving C++ is extremely difficult, both due to the technical debt itself and challenges with its evolution process. The best way to address these problems is to avoid inheriting the legacy of C or C++ directly, and instead start with solid language foundations like a modern generics system, modular code organization, and consistent, simple syntax.

Existing modern languages already provide an excellent developer experience: Go, Swift, Kotlin, Rust, and many more. Developers that can use one of these existing languages should. Unfortunately, the designs of these languages present significant barriers to adoption and migration from C++. These barriers range from changes in the idiomatic design of software to performance overhead.

Carbon is fundamentally a successor language approach, rather than an attempt to incrementally evolve C++. It is designed around interoperability with C++ as well as large-scale adoption and migration for existing C++ codebases and developers. A successor language for C++ requires:

  • Performance matching C++, an essential property for our developers.
  • Seamless, bidirectional interoperability with C++, such that a library anywhere in an existing C++ stack can adopt Carbon without porting the rest.
  • A gentle learning curve with reasonable familiarity for C++ developers.
  • Comparable expressivity and support for existing software's design and architecture.
  • Scalable migration, with some level of source-to-source translation for idiomatic C++ code.

With this approach, we can build on top of C++'s existing ecosystem, and bring along existing investments, codebases, and developer populations. There are a few languages that have followed this model for other ecosystems, and Carbon aims to fill an analogous role for C++:

  • JavaScript → TypeScript
  • Java → Kotlin
  • C++ → Carbon

Language Goals

We are designing Carbon to support:

  • Performance-critical software
  • Software and language evolution
  • Code that is easy to read, understand, and write
  • Practical safety and testing mechanisms
  • Fast and scalable development
  • Modern OS platforms, hardware architectures, and environments
  • Interoperability with and migration from existing C++ code

While many languages share subsets of these goals, what distinguishes Carbon is their combination.

We also have explicit non-goals for Carbon, notably including:

  • A stable ABI for the entire language and library
  • Perfect backwards or forwards compatibility

Our detailed goals document fleshes out these ideas and provides a deeper view into our goals for the Carbon project and language.

Project status

Carbon is currently an experimental project. We want to better understand whether we can build a language that meets our successor language criteria, and whether the resulting language can gather a critical mass of interest within the larger C++ industry and community.

Currently, we have fleshed out several core aspects of both Carbon the project and the language:

  • The strategy of the Carbon Language and project.
  • An open-source project structure, governance model, and evolution process.
  • Critical and foundational aspects of the language design informed by our experience with C++ and the most difficult challenges we anticipate. This includes designs for:
    • Generics
    • Class types
    • Inheritance
    • Operator overloading
    • Lexical and syntactic structure
    • Code organization and modular structure
  • A prototype interpreter demo that can both run isolated examples and gives a detailed analysis of the specific semantic model and abstract machine of Carbon. We call this the Carbon Explorer.

We are currently focused on getting more broad feedback and participation from the C++ community, completing the 0.1 language design, and completing the Carbon Explorer implementation of this design. Beyond that, we plan to prioritize C++ interoperability and a realistic toolchain that implements the 0.1 language and can be used to evaluate Carbon in more detail.

You can see our full roadmap for more details.

Carbon and C++

If you're already a C++ developer, Carbon should have a gentle learning curve. It is built out of a consistent set of language constructs that should feel familiar and be easy to read and understand.

C++ code like this:

A snippet of C++ code. Follow the link to read it.

A snippet of C++ code. Follow the link to read it.corresponds to this Carbon code:

A snippet of converted Carbon code. Follow the link to read it.

You can call Carbon from C++ without overhead and the other way around. This means you migrate a single C++ library to Carbon within an application, or write new Carbon on top of your existing C++ investment. For example:

A snippet of mixed Carbon and C++ code. Follow the link to read it.

Read more about C++ interop in Carbon.

Beyond interoperability between Carbon and C++, we're also planning to support migration tools that will mechanically translate idiomatic C++ code into Carbon code to help you switch an existing C++ codebase to Carbon.

Generics

Carbon provides a modern generics system with checked definitions, while still supporting opt-in templates for seamless C++ interop. Checked generics provide several advantages compared to C++ templates:

  • Generic definitions are fully type checked, removing the need to instantiate to check for errors and giving greater confidence in code.
    • Avoids compile time cost of re-checking the definition for every instantiation.
    • When using a definition-checked generic, usage error messages are clearer, directly showing which requirements are not met.
  • Enables automatic, opt-in type erasure and dynamic dispatch without a separate implementation. This can reduce binary size and enables constructs like heterogeneous containers.
  • Strong, checked interfaces mean fewer accidental dependencies on implementation details and a clearer contract for consumers.

Without sacrificing these advantages, Carbon generics support specialization, ensuring it can fully address performance-critical use cases of C++ templates. For more details about Carbon's generics, see their design.

In addition to easy and powerful interop with C++, Carbon templates can be constrained and incrementally migrated to checked generics at a fine granularity and with a smooth evolutionary path.

Memory safety

Safety, and especially memory safety, remain key challenges for C++ and something a successor language needs to address. Our initial priority and focus is on immediately addressing important, low-hanging fruit in the safety space:

  • Tracking uninitialized states better, increased enforcement of initialization, and systematically providing hardening against initialization bugs when desired.
  • Designing fundamental APIs and idioms to support dynamic bounds checks in debug and hardened builds.
  • Having a default debug build mode that is both cheaper and more comprehensive than existing C++ build modes even when combined with Address Sanitizer.

Once we can migrate code into Carbon, we will have a simplified language with room in the design space to add any necessary annotations or features, and infrastructure like generics to support safer design patterns. Longer term, we will build on this to introduce a safe Carbon subset. This will be a large and complex undertaking, and won't be in the 0.1 design. Meanwhile, we are closely watching and learning from efforts to add memory safe semantics onto C++ such as Rust-inspired lifetime annotations.

Getting started

You can get started playing with Carbon by checking out the codebase and using the Carbon explorer:

# Install bazelisk using Homebrew.
$ brew install bazelisk

# Install Clang/LLVM using Homebrew.
# Many Clang/LLVM releases aren't built with options we rely on.
$ brew install llvm
$ export PATH="$(brew --prefix llvm)/bin:${PATH}"

# Download Carbon's code.
$ git clone https://github.com/carbon-language/carbon-lang
$ cd carbon-lang

# Build and run the explorer.
$ bazel run //explorer -- ./explorer/testdata/print/format_only.carbon

These instructions assume Homebrew; see our contribution tools documentation for more extensive tooling instructions.

Learn more about the Carbon project:

Download Details: 
Author: carbon-language
Source Code: https://github.com/carbon-language/carbon-lang 

#cplusplus #cpp #carbon #carbonlang

Carbon Language: An Experimental Successor to C++

¿Cuál Es La Diferencia Entre C Y C++?

Los lenguajes de programación C y C++ impulsan una gran parte de los productos, aplicaciones y sitios web del mundo.

Cada uno ayudó a sentar las bases para la creación de muchos lenguajes de programación populares, como Java. También admiten muchos lenguajes que puede usar regularmente para sus proyectos de programación, como Python.

En este artículo encontrará una descripción general y amigable para principiantes de los dos idiomas junto con sus principales similitudes y diferencias.

Los orígenes de C y C++

Una historia del lenguaje de programación C

Ken Thompson y Dennis Ritchie habían estado trabajando durante bastantes años en el proyecto MULTICS (Multiplexed Information and Computing Service) en AT&T Bell Laboratories.

Después de que el proyecto se detuviera, en 1969 Ken Thompson comenzó a trabajar en su juego Space Travel en una máquina PDP-7 poco usada.

Mientras lo hacía, terminó escribiendo un sistema operativo casi completo, Unix, desde cero en lenguaje ensamblador.

Mientras trabajaban en MULTICS, tanto Thompson como Ritchie habían estado escribiendo software de sistema y utilidades de programación utilizando lenguajes de alto nivel. Y habían visto cuánto más fácil era todo el proceso, en comparación con el lenguaje ensamblador críptico y difícil de descifrar.

Ritchie se unió a Thompson para ayudar a migrar Unix a una máquina más nueva: la PDP-11.

Durante ese período, experimentaron con varios lenguajes de alto nivel que podrían ayudar a realizar el trabajo.

Usaron BCPL (Lenguaje de programación combinado básico), que se usó mucho durante la era MULTICS. Después de probarlo, Thompson terminó escribiendo un nuevo lenguaje: el lenguaje de programación B.

El lenguaje B era similar a BCPL pero era una versión más simple y simplificada.

Pero B no era lo suficientemente potente y no aprovechó al máximo las nuevas funciones y la potencia del PDP-11.

Ken_Thompson_-sentado-_y_Dennis_Ritchie_en_PDP-11_-2876612463-Thompson (sentado) y Ritchie trabajando juntos en un PDP-11. Crédito de imagen y texto de Wikipedia

Dennis Ritchie comenzó a mejorar el lenguaje B y terminó creando el lenguaje de programación C.

C es un lenguaje portátil, lo que significa que los programas escritos en él pueden transferirse y usarse en una variedad de arquitecturas de máquinas. Es muy rápido y fácil de compilar y tiene un mapeo directo al código de la máquina, lo que le da al programador acceso a funcionalidades de bajo nivel.

Terminaron reescribiendo el sistema operativo Unix en C en 1972.

Dado que C era portátil y era el lenguaje en el que se implementó Unix, los desarrolladores comenzaron a adoptarlo y usarlo ampliamente. Esto condujo al éxito del sistema operativo Unix y, a su vez, el lenguaje C se hizo popular.

Dennis Ritchie y Brian Kernighan fueron coautores del libro 'Lenguaje de programación C' en 1977, que creó un estándar sobre cómo se supone que debe usarse el lenguaje. Este libro popularizó aún más el idioma.

C es muy importante en la historia de la informática y su creación condujo a la creación de muchos otros lenguajes de programación. Por eso, a menudo se le llama la ' madre ' de todos los lenguajes de programación.

Historia de C++

En 1979, el investigador Bjarne Stroustrup fue contratado por AT&T Bell Laboratories.

Durante la década de 1970, la complejidad y el poder computacional de las computadoras aumentaron y comenzaron a surgir limitaciones en el lenguaje de programación C.

A principios de la década de 1980, Bjarne Stroustrup creó un nuevo lenguaje influenciado por dos cosas:

  • Las capacidades de programación orientada a objetos de otro lenguaje, Simula, que ofrecía un enfoque diferente a la programación en comparación con C. El código podía abstraerse y organizarse mejor y cualquier cosa podía representarse usando clases.
  • El lenguaje de programación de sistemas, C, que ofrecía la capacidad de acercarse mucho al hardware de la máquina y realizar tareas computacionales exigentes de bajo nivel.

Esas dos ideas combinadas permitieron una abstracción de mayor nivel sin perder la eficiencia de bajo nivel de C. Entonces, se creó el lenguaje ' C con clases '.

En 1984, 'C con clases' pasó a llamarse C++.

Entonces, C++ es un superconjunto de C, lo que significa que era una extensión de C y se basa en él. C++ solo proporciona capacidades adicionales al lenguaje C.

Similitudes entre C y C++

A continuación se muestran algunas de las similitudes entre C y C++.

Sintaxis y estructura del código

La sintaxis general de los dos lenguajes es muy similar. Los operadores y las palabras clave que se usan en C también se usan en C++ para lograr lo mismo. Pero C++ tiene más palabras clave que C y tiene una gramática extendida.

Los comentarios en línea //y los comentarios en bloque */ */tienen el mismo aspecto.

Además, cada declaración termina con un punto y coma, ;.

Condicionales, bucles, inicialización y declaración de variables: todos se ven similares entre los dos idiomas.

Tanto C como C++ tienen un main()método, que inicia todos los programas, y ambos incluyen archivos de encabezado en la parte superior de los archivos respectivos, con extensión #include.

Lenguajes de programación compilados

Tanto C como C++ son lenguajes de programación compilados.

Un compilador es un programa de software de computadora.

Toma el código fuente que un programador escribió en un lenguaje de programación de nivel superior y lo traduce a otro lenguaje que la computadora pueda entender.

Este formulario es el primer código de ensamblaje que se traduce nuevamente a código de máquina, el idioma nativo de todas las computadoras.

El lenguaje máquina es un conjunto de instrucciones que son entendidas directamente por la CPU (Unidad Central de Procesamiento) de una computadora.

Una vez que el código fuente se ha traducido a código de máquina a.out, se crea un archivo ejecutable binario.

Diferencias entre C y C++

Ahora veamos algunas de las diferencias entre los dos idiomas.

Métodos de entrada y salida

C y C++ usan diferentes formas de enviar información a la consola y recibir información del usuario.

En C, scanf()se usa para la entrada del usuario, mientras que printf()se usa para generar datos.

En C ++, std::cin >>se usa para obtener la entrada del usuario y std::cout <<se usa para generar datos.

El paradigma de la programación

La diferencia más importante entre los dos lenguajes es el diferente enfoque de programación que utiliza cada uno.

C es un lenguaje orientado al procedimiento y su énfasis está en las funciones.

Los programas se dividen en un conjunto de funciones y consisten en instrucciones paso a paso, o comandos, para ser ejecutados en orden secuencial.

Este estilo de programación especifica cómo hacer algo, dando pasos estructurados sobre cómo se llevarán a cabo las tareas computacionales, siguiendo un enfoque de arriba hacia abajo.

Este estilo de programación puede volverse bastante complicado y propenso a errores cuando los programas aumentan de tamaño. Conduce a una gran cantidad de copiar y pegar a lo largo del archivo y actualizar muchas funciones cuando hay un cambio.

Además de ser un lenguaje de procedimiento, C++ también es un lenguaje de programación orientado a objetos , que se basa en el concepto de sumergir un programa en objetos.

Todo está organizado y dividido en grupos más pequeños de partes u objetos relacionados , que son una instancia de una clase , siguiendo un enfoque de abajo hacia arriba.

La Programación Orientada a Objetos se basa en cuatro principios: encapsulación, abstracción, herencia y polimorfismo .

Este estilo de programación crea un código más legible y utilizable que es más fácil de mantener, al tiempo que proporciona una mejor seguridad de los datos.

el STL

C++ ofrece STL (Biblioteca de plantillas estándar) y C no.

Proporciona clases de plantilla para estructuras de datos y componentes de uso común para implementar funciones integradas adicionales.

Uno de esos componentes son los contenedores como Vectores , que almacenan colecciones de objetos.

Espacios de nombres

Los espacios de nombres son una característica disponible en C++ y no en C.

Son contenedores que se utilizan para organizar el código en grupos lógicos de identificadores y objetos similares bajo un nombre, dentro de un ámbito.

Evitan colisiones de nombres cuando hay varias bibliotecas presentes y evitan conflictos con nombres de otros espacios de nombres dentro de un programa.

Un ejemplo de un espacio de nombres es std::.

Una forma de usar un espacio de nombres e introducirlo en un ámbito es usando la usingpalabra clave, por ejemplo using namespace std;.

Manejo de excepciones

C no ofrece una forma de manejar excepciones en programas que ayuden a prevenir errores.

C ++, por otro lado, admite el manejo de excepciones al introducir tryy catchbloques.

Extensión de archivo

La extensión de archivo para un archivo que contiene código C es .c, mientras que la extensión de archivo para archivos C++ es .cpp.

¿Dónde se usan C y C++?

C se usa comúnmente para tareas computacionales de bajo nivel muy exigentes donde la velocidad, la eficiencia y el acceso cercano a la máquina son imprescindibles.

C asume que los programadores saben lo que están haciendo y les da libertad.

Por lo tanto, es el lenguaje elegido para sistemas operativos, dispositivos integrados, programación de sistemas, núcleos y controladores, desarrollo de compiladores y la creciente industria de aplicaciones IoT (Internet de las cosas).

C++ nuevamente le permite al programador un acceso cercano y la manipulación de la máquina, al tiempo que brinda eficiencia y alto rendimiento para sistemas a gran escala. Al mismo tiempo, es de nivel superior con suficiente abstracción lejos de la máquina.

C ++ es un lenguaje popular elegido para crear motores de juegos y gráficos y aplicaciones de computadora, aplicaciones de realidad virtual, navegadores web como Google Chrome, Mozilla Firefox y Safari, y extensiones de navegador web. El motor de búsqueda de Google también está construido en C++.

Conclusión

Gracias por llegar hasta el final, y espero que este artículo te haya resultado útil.

Aprendió sobre los orígenes de C y C++ y sus antecedentes históricos. Luego vio algunas de sus similitudes y diferencias, cómo se usa cada idioma y algunos recursos para que pueda comenzar a aprender los idiomas.

¡Feliz codificación!

Fuente: https://www.freecodecamp.org/news/c-vs-cpp-whats-the-difference/

#cpp #csharp #cpluplus 

¿Cuál Es La Diferencia Entre C Y C++?