You are viewing a plain text version of this content. The canonical link for it is here.
Posted to github@arrow.apache.org by "oliviermeslin (via GitHub)" <gi...@apache.org> on 2024/04/03 16:01:50 UTC
[PR] GH-40547: [R][Docs] Add a non-technical introductory R vignette to the functioning of arrow [arrow]
oliviermeslin opened a new pull request, #40982:
URL: https://github.com/apache/arrow/pull/40982
I propose a rough first draft of a non-technical introductory R vignette to the functioning of arrow.
As explained in [this issue](https://github.com/apache/arrow/issues/40547), this vignette provides an overview of how Arrow works in a plain, non-technical language. It aims at giving some simple and useful intuitions, before diving deeper in the documentation. It is specifically intended for newcomers with a limited background in computer science and hence avoids most technical terms.
Feel free to modify in any way you think is appropriate. I will try to add a few elements on how to deal with functions unsupported by acero.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
Re: [PR] GH-40547: [R][Docs] Add a non-technical introductory R vignette to the functioning of arrow [arrow]
Posted by "thisisnic (via GitHub)" <gi...@apache.org>.
thisisnic commented on PR #40982:
URL: https://github.com/apache/arrow/pull/40982#issuecomment-2041616763
I really like this! I need to find the time to properly review this in detail, so might be a bit delayed looking at it thoroughly, but I'm already a +1 on incorporating this into our docs once we've refined a few of the details.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
Re: [PR] GH-40547: [R][Docs] Add a non-technical introductory R vignette to the functioning of arrow [arrow]
Posted by "oliviermeslin (via GitHub)" <gi...@apache.org>.
oliviermeslin commented on code in PR #40982:
URL: https://github.com/apache/arrow/pull/40982#discussion_r1567018761
##########
r/vignettes/informal_introduction.Rmd:
##########
@@ -0,0 +1,297 @@
+---
+title: Getting started with Apache Arrow and R
+description: >
+ An informal introduction of the functioning of Apache Arrow for R users
+output: rmarkdown::html_vignette
+---
+
+
+## What is this vignette and is it for you?
+
+This vignette provides an overview of how Arrow works in a plain, non-technical language. It aims at giving some simple and useful intuitions, before diving deeper in the documentation. It is specifically intended for newcomers with a limited background in computer science and hence avoids most technical terms. This vignette assumes that you have some experience with R, that you are familiar with the `dplyr` syntax and that you know how to use a Parquet file.
+
+Some technical points are deliberately simplified to keep things simple, so in case you find an apparent contradiction between this vignette and the rest of the documentation, please trust the documentation rather than this vignette.
+
+## Introducing Apache Arrow
+
+This section introduces the Apache Arrow project.
+
+### What is Apache Arrow?
+
+[Apache `Arrow`](https://arrow.apache.org/) is an *open-source* project that offers two things:
+
+- Apache Arrow defines a standardized way to organize data in memory (called _Apache Arrow Columnar Format_). You do not need to know much about this _Columnar Format_ to use Arrow with R, except that it is very efficient (processing is fast) and interoperable (meaning for instance that both R and Python can access the same data, without converting the data from one format to another).
+- Apache Arrow offers a `C++` implementation of this _Columnar Format_: the `C++` library called `libarrow`.
+
+What about the Arrow R package then? This package simply makes it possible to use the `libarrow` library within `R`. Keep in mind that there are other similar interfaces for using `libarrow` with other programming languages: in Python, Java, Javascript, Julia, and so on. But __no matter what programming language you choose for using Arrow, remember that under the hood you are using exactly the same tool: the C++ libarrow library__.
+
+### What's so special about Arrow?
+
+Arrow has five distinctive features:
+
+- __Columnar Memory Format__: in Arrow, data is organized in columns rather than in rows (hence the "columnar format"). In practice, it means that all values of the first column are stored contiguously in memory, followed by all values of the second column, and so on. This columnar format speeds up data processing. Imagine that you want to calculate the mean of a variable: you can directly access the block of memory containing the entire column and get the result, no matter how many columns you have in your dataset.
+
+- __Easy use with Parquet files__: Arrow is optimized to work well with data stored in Parquet files.
+
+- __Ability to process very large datasets__: Arrow is able to process very large amounts of data, even datasets that are too large to fit in the memory of your computer.
+
+- __Interoperability__: Arrow is designed to be interoperable between several programming languages such as `R`, Python, Java, C++, etc. This means that data can be exchanged between different programming languages without converting the data from one format to another, resulting in significant performance gains.
+
+- __*Lazy Evaluation*__: when you give instructions to Arrow, Arrow stores them but does not run them, unless you explicitly ask it to do so (more on this below).
Review Comment:
@eitsupi : you are right. This vignette reflects my own, imperfect understanding of how arrow works, and clearly I do not completely understand how all components interact. I tried to reformulate. Let me know if you want reformulate yourself.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
Re: [PR] GH-40547: [R][Docs] Add a non-technical introductory R vignette to the functioning of arrow [arrow]
Posted by "thisisnic (via GitHub)" <gi...@apache.org>.
thisisnic closed pull request #40982: GH-40547: [R][Docs] Add a non-technical introductory R vignette to the functioning of arrow
URL: https://github.com/apache/arrow/pull/40982
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
Re: [PR] GH-40547: [R][Docs] Add a non-technical introductory R vignette to the functioning of arrow [arrow]
Posted by "thisisnic (via GitHub)" <gi...@apache.org>.
thisisnic commented on PR #40982:
URL: https://github.com/apache/arrow/pull/40982#issuecomment-2353259911
Sorry, life got busy - was discussing this with @amoeba earlier today and I think we could incorporate this by taking some of the key elements and making an FAQ actually. Not sure if I'll get round to it or if someone else wants to, but it's a thought!
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
Re: [PR] GH-40547: [R][Docs] Add a non-technical introductory R vignette to the functioning of arrow [arrow]
Posted by "eitsupi (via GitHub)" <gi...@apache.org>.
eitsupi commented on code in PR #40982:
URL: https://github.com/apache/arrow/pull/40982#discussion_r1567344555
##########
r/vignettes/informal_introduction.Rmd:
##########
@@ -0,0 +1,297 @@
+---
+title: Getting started with Apache Arrow and R
+description: >
+ An informal introduction of the functioning of Apache Arrow for R users
+output: rmarkdown::html_vignette
+---
+
+
+## What is this vignette and is it for you?
+
+This vignette provides an overview of how Arrow works in a plain, non-technical language. It aims at giving some simple and useful intuitions, before diving deeper in the documentation. It is specifically intended for newcomers with a limited background in computer science and hence avoids most technical terms. This vignette assumes that you have some experience with R, that you are familiar with the `dplyr` syntax and that you know how to use a Parquet file.
+
+Some technical points are deliberately simplified to keep things simple, so in case you find an apparent contradiction between this vignette and the rest of the documentation, please trust the documentation rather than this vignette.
+
+## Introducing Apache Arrow
+
+This section introduces the Apache Arrow project.
+
+### What is Apache Arrow?
+
+[Apache `Arrow`](https://arrow.apache.org/) is an *open-source* project that offers two things:
+
+- Apache Arrow defines a standardized way to organize data in memory (called _Apache Arrow Columnar Format_). You do not need to know much about this _Columnar Format_ to use Arrow with R, except that it is very efficient (processing is fast) and interoperable (meaning for instance that both R and Python can access the same data, without converting the data from one format to another).
+- Apache Arrow offers a `C++` implementation of this _Columnar Format_: the `C++` library called `libarrow`.
+
+What about the Arrow R package then? This package simply makes it possible to use the `libarrow` library within `R`. Keep in mind that there are other similar interfaces for using `libarrow` with other programming languages: in Python, Java, Javascript, Julia, and so on. But __no matter what programming language you choose for using Arrow, remember that under the hood you are using exactly the same tool: the C++ libarrow library__.
Review Comment:
I think "Keep in mind that there are other similar interfaces for using `libarrow` with other programming languages" is not correct.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
Re: [PR] GH-40547: [R][Docs] Add a non-technical introductory R vignette to the functioning of arrow [arrow]
Posted by "oliviermeslin (via GitHub)" <gi...@apache.org>.
oliviermeslin commented on code in PR #40982:
URL: https://github.com/apache/arrow/pull/40982#discussion_r1567005314
##########
r/vignettes/informal_introduction.Rmd:
##########
@@ -0,0 +1,297 @@
+---
+title: Getting started with Apache Arrow and R
+description: >
+ An informal introduction of the functioning of Apache Arrow for R users
+output: rmarkdown::html_vignette
+---
+
+
+## What is this vignette and is it for you?
+
+This vignette provides an overview of how Arrow works in a plain, non-technical language. It aims at giving some simple and useful intuitions, before diving deeper in the documentation. It is specifically intended for newcomers with a limited background in computer science and hence avoids most technical terms. This vignette assumes that you have some experience with R, that you are familiar with the `dplyr` syntax and that you know how to use a Parquet file.
+
+Some technical points are deliberately simplified to keep things simple, so in case you find an apparent contradiction between this vignette and the rest of the documentation, please trust the documentation rather than this vignette.
+
+## Introducing Apache Arrow
+
+This section introduces the Apache Arrow project.
+
+### What is Apache Arrow?
+
+[Apache `Arrow`](https://arrow.apache.org/) is an *open-source* project that offers two things:
+
+- Apache Arrow defines a standardized way to organize data in memory (called _Apache Arrow Columnar Format_). You do not need to know much about this _Columnar Format_ to use Arrow with R, except that it is very efficient (processing is fast) and interoperable (meaning for instance that both R and Python can access the same data, without converting the data from one format to another).
+- Apache Arrow offers a `C++` implementation of this _Columnar Format_: the `C++` library called `libarrow`.
+
+What about the Arrow R package then? This package simply makes it possible to use the `libarrow` library within `R`. Keep in mind that there are other similar interfaces for using `libarrow` with other programming languages: in Python, Java, Javascript, Julia, and so on. But __no matter what programming language you choose for using Arrow, remember that under the hood you are using exactly the same tool: the C++ libarrow library__.
Review Comment:
thanks @eitsupi. I reformulated this part, tell me if the new wording is alright.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
Re: [PR] GH-40547: [R][Docs] Add a non-technical introductory R vignette to the functioning of arrow [arrow]
Posted by "oliviermeslin (via GitHub)" <gi...@apache.org>.
oliviermeslin commented on PR #40982:
URL: https://github.com/apache/arrow/pull/40982#issuecomment-2094943296
@thisisnic Sorry for the delay, I'm very busy these days. I think the easiest way to proceed if that you rework the content in the way you consider appropriate.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
Re: [PR] GH-40547: [R][Docs] Add a non-technical introductory R vignette to the functioning of arrow [arrow]
Posted by "thisisnic (via GitHub)" <gi...@apache.org>.
thisisnic commented on PR #40982:
URL: https://github.com/apache/arrow/pull/40982#issuecomment-3547176790
There's a lot to do here and I'm bogged down with maintenance so unlikely to find the time. I think this is great materials though, so if anyone wants to reopen this some time and move it forwards, then fantastic.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
Re: [PR] GH-40547: [R][Docs] Add a non-technical introductory R vignette to the functioning of arrow [arrow]
Posted by "github-actions[bot] (via GitHub)" <gi...@apache.org>.
github-actions[bot] commented on PR #40982:
URL: https://github.com/apache/arrow/pull/40982#issuecomment-2035007022
:warning: GitHub issue #40547 **has been automatically assigned in GitHub** to PR creator.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
Re: [PR] GH-40547: [R][Docs] Add a non-technical introductory R vignette to the functioning of arrow [arrow]
Posted by "eitsupi (via GitHub)" <gi...@apache.org>.
eitsupi commented on code in PR #40982:
URL: https://github.com/apache/arrow/pull/40982#discussion_r1554640879
##########
r/vignettes/informal_introduction.Rmd:
##########
@@ -0,0 +1,297 @@
+---
+title: Getting started with Apache Arrow and R
+description: >
+ An informal introduction of the functioning of Apache Arrow for R users
+output: rmarkdown::html_vignette
+---
+
+
+## What is this vignette and is it for you?
+
+This vignette provides an overview of how Arrow works in a plain, non-technical language. It aims at giving some simple and useful intuitions, before diving deeper in the documentation. It is specifically intended for newcomers with a limited background in computer science and hence avoids most technical terms. This vignette assumes that you have some experience with R, that you are familiar with the `dplyr` syntax and that you know how to use a Parquet file.
+
+Some technical points are deliberately simplified to keep things simple, so in case you find an apparent contradiction between this vignette and the rest of the documentation, please trust the documentation rather than this vignette.
+
+## Introducing Apache Arrow
+
+This section introduces the Apache Arrow project.
+
+### What is Apache Arrow?
+
+[Apache `Arrow`](https://arrow.apache.org/) is an *open-source* project that offers two things:
+
+- Apache Arrow defines a standardized way to organize data in memory (called _Apache Arrow Columnar Format_). You do not need to know much about this _Columnar Format_ to use Arrow with R, except that it is very efficient (processing is fast) and interoperable (meaning for instance that both R and Python can access the same data, without converting the data from one format to another).
+- Apache Arrow offers a `C++` implementation of this _Columnar Format_: the `C++` library called `libarrow`.
+
+What about the Arrow R package then? This package simply makes it possible to use the `libarrow` library within `R`. Keep in mind that there are other similar interfaces for using `libarrow` with other programming languages: in Python, Java, Javascript, Julia, and so on. But __no matter what programming language you choose for using Arrow, remember that under the hood you are using exactly the same tool: the C++ libarrow library__.
Review Comment:
Of these, only R and Python are based on libarrow, while Java, JavaScript, and Julia are all independent implementations that are completely different from C++.
Please check <https://arrow.apache.org/docs/status.html>.
##########
r/vignettes/informal_introduction.Rmd:
##########
@@ -0,0 +1,297 @@
+---
+title: Getting started with Apache Arrow and R
+description: >
+ An informal introduction of the functioning of Apache Arrow for R users
+output: rmarkdown::html_vignette
+---
+
+
+## What is this vignette and is it for you?
+
+This vignette provides an overview of how Arrow works in a plain, non-technical language. It aims at giving some simple and useful intuitions, before diving deeper in the documentation. It is specifically intended for newcomers with a limited background in computer science and hence avoids most technical terms. This vignette assumes that you have some experience with R, that you are familiar with the `dplyr` syntax and that you know how to use a Parquet file.
+
+Some technical points are deliberately simplified to keep things simple, so in case you find an apparent contradiction between this vignette and the rest of the documentation, please trust the documentation rather than this vignette.
+
+## Introducing Apache Arrow
+
+This section introduces the Apache Arrow project.
+
+### What is Apache Arrow?
+
+[Apache `Arrow`](https://arrow.apache.org/) is an *open-source* project that offers two things:
+
+- Apache Arrow defines a standardized way to organize data in memory (called _Apache Arrow Columnar Format_). You do not need to know much about this _Columnar Format_ to use Arrow with R, except that it is very efficient (processing is fast) and interoperable (meaning for instance that both R and Python can access the same data, without converting the data from one format to another).
+- Apache Arrow offers a `C++` implementation of this _Columnar Format_: the `C++` library called `libarrow`.
+
+What about the Arrow R package then? This package simply makes it possible to use the `libarrow` library within `R`. Keep in mind that there are other similar interfaces for using `libarrow` with other programming languages: in Python, Java, Javascript, Julia, and so on. But __no matter what programming language you choose for using Arrow, remember that under the hood you are using exactly the same tool: the C++ libarrow library__.
+
+### What's so special about Arrow?
+
+Arrow has five distinctive features:
+
+- __Columnar Memory Format__: in Arrow, data is organized in columns rather than in rows (hence the "columnar format"). In practice, it means that all values of the first column are stored contiguously in memory, followed by all values of the second column, and so on. This columnar format speeds up data processing. Imagine that you want to calculate the mean of a variable: you can directly access the block of memory containing the entire column and get the result, no matter how many columns you have in your dataset.
+
+- __Easy use with Parquet files__: Arrow is optimized to work well with data stored in Parquet files.
+
+- __Ability to process very large datasets__: Arrow is able to process very large amounts of data, even datasets that are too large to fit in the memory of your computer.
+
+- __Interoperability__: Arrow is designed to be interoperable between several programming languages such as `R`, Python, Java, C++, etc. This means that data can be exchanged between different programming languages without converting the data from one format to another, resulting in significant performance gains.
+
+- __*Lazy Evaluation*__: when you give instructions to Arrow, Arrow stores them but does not run them, unless you explicitly ask it to do so (more on this below).
Review Comment:
I felt there was some confusion between acero's description and Apache Arrow's description.
Given the presence of the acero explanation in the next paragraph (and the presence of the acero explanation in dplyr's README), it might be better to explain acero separately.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
Re: [PR] GH-40547: [R][Docs] Add a non-technical introductory R vignette to the functioning of arrow [arrow]
Posted by "eitsupi (via GitHub)" <gi...@apache.org>.
eitsupi commented on code in PR #40982:
URL: https://github.com/apache/arrow/pull/40982#discussion_r1554641571
##########
r/vignettes/informal_introduction.Rmd:
##########
@@ -0,0 +1,297 @@
+---
+title: Getting started with Apache Arrow and R
+description: >
+ An informal introduction of the functioning of Apache Arrow for R users
+output: rmarkdown::html_vignette
+---
+
+
+## What is this vignette and is it for you?
+
+This vignette provides an overview of how Arrow works in a plain, non-technical language. It aims at giving some simple and useful intuitions, before diving deeper in the documentation. It is specifically intended for newcomers with a limited background in computer science and hence avoids most technical terms. This vignette assumes that you have some experience with R, that you are familiar with the `dplyr` syntax and that you know how to use a Parquet file.
+
+Some technical points are deliberately simplified to keep things simple, so in case you find an apparent contradiction between this vignette and the rest of the documentation, please trust the documentation rather than this vignette.
+
+## Introducing Apache Arrow
+
+This section introduces the Apache Arrow project.
+
+### What is Apache Arrow?
+
+[Apache `Arrow`](https://arrow.apache.org/) is an *open-source* project that offers two things:
+
+- Apache Arrow defines a standardized way to organize data in memory (called _Apache Arrow Columnar Format_). You do not need to know much about this _Columnar Format_ to use Arrow with R, except that it is very efficient (processing is fast) and interoperable (meaning for instance that both R and Python can access the same data, without converting the data from one format to another).
+- Apache Arrow offers a `C++` implementation of this _Columnar Format_: the `C++` library called `libarrow`.
+
+What about the Arrow R package then? This package simply makes it possible to use the `libarrow` library within `R`. Keep in mind that there are other similar interfaces for using `libarrow` with other programming languages: in Python, Java, Javascript, Julia, and so on. But __no matter what programming language you choose for using Arrow, remember that under the hood you are using exactly the same tool: the C++ libarrow library__.
+
+### What's so special about Arrow?
+
+Arrow has five distinctive features:
+
+- __Columnar Memory Format__: in Arrow, data is organized in columns rather than in rows (hence the "columnar format"). In practice, it means that all values of the first column are stored contiguously in memory, followed by all values of the second column, and so on. This columnar format speeds up data processing. Imagine that you want to calculate the mean of a variable: you can directly access the block of memory containing the entire column and get the result, no matter how many columns you have in your dataset.
+
+- __Easy use with Parquet files__: Arrow is optimized to work well with data stored in Parquet files.
+
+- __Ability to process very large datasets__: Arrow is able to process very large amounts of data, even datasets that are too large to fit in the memory of your computer.
+
+- __Interoperability__: Arrow is designed to be interoperable between several programming languages such as `R`, Python, Java, C++, etc. This means that data can be exchanged between different programming languages without converting the data from one format to another, resulting in significant performance gains.
+
+- __*Lazy Evaluation*__: when you give instructions to Arrow, Arrow stores them but does not run them, unless you explicitly ask it to do so (more on this below).
Review Comment:
I felt there was some confusion between acero's description and Apache Arrow format's description.
Given the presence of the acero explanation in the next paragraph (and the presence of the acero explanation in dplyr's README), it might be better to explain acero separately.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
Re: [PR] GH-40547: [R][Docs] Add a non-technical introductory R vignette to the functioning of arrow [arrow]
Posted by "thisisnic (via GitHub)" <gi...@apache.org>.
thisisnic commented on PR #40982:
URL: https://github.com/apache/arrow/pull/40982#issuecomment-2059785036
Thanks for your patience @oliviermeslin.
What I propose is taking everything from, "### What's so special about Arrow?" up to but not including "### Overcoming the limitations of lazy evaluation" and paste this into the existing "get started with arrow vignette" before the "## Package conventions" section. I think there are a few tweaks and changes we need to make, but it'll be easier to have this in the right place before feeding back on those.
If you're happy with me reworking what you have here with the existing content, then I'm happy to merge things in, or alternatively, I can provide feedback and walk through the changes to make (though I'm suggesting the former as there are lots of changes I'd like to make to the existing content).
Let me know what you think! :)
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
Re: [PR] GH-40547: [R][Docs] Add a non-technical introductory R vignette to the functioning of arrow [arrow]
Posted by "oliviermeslin (via GitHub)" <gi...@apache.org>.
oliviermeslin commented on code in PR #40982:
URL: https://github.com/apache/arrow/pull/40982#discussion_r1568429659
##########
r/vignettes/informal_introduction.Rmd:
##########
@@ -0,0 +1,297 @@
+---
+title: Getting started with Apache Arrow and R
+description: >
+ An informal introduction of the functioning of Apache Arrow for R users
+output: rmarkdown::html_vignette
+---
+
+
+## What is this vignette and is it for you?
+
+This vignette provides an overview of how Arrow works in a plain, non-technical language. It aims at giving some simple and useful intuitions, before diving deeper in the documentation. It is specifically intended for newcomers with a limited background in computer science and hence avoids most technical terms. This vignette assumes that you have some experience with R, that you are familiar with the `dplyr` syntax and that you know how to use a Parquet file.
+
+Some technical points are deliberately simplified to keep things simple, so in case you find an apparent contradiction between this vignette and the rest of the documentation, please trust the documentation rather than this vignette.
+
+## Introducing Apache Arrow
+
+This section introduces the Apache Arrow project.
+
+### What is Apache Arrow?
+
+[Apache `Arrow`](https://arrow.apache.org/) is an *open-source* project that offers two things:
+
+- Apache Arrow defines a standardized way to organize data in memory (called _Apache Arrow Columnar Format_). You do not need to know much about this _Columnar Format_ to use Arrow with R, except that it is very efficient (processing is fast) and interoperable (meaning for instance that both R and Python can access the same data, without converting the data from one format to another).
+- Apache Arrow offers a `C++` implementation of this _Columnar Format_: the `C++` library called `libarrow`.
+
+What about the Arrow R package then? This package simply makes it possible to use the `libarrow` library within `R`. Keep in mind that there are other similar interfaces for using `libarrow` with other programming languages: in Python, Java, Javascript, Julia, and so on. But __no matter what programming language you choose for using Arrow, remember that under the hood you are using exactly the same tool: the C++ libarrow library__.
Review Comment:
I reformulated again (thanks for the link to the documentation, I now understand better the various Arrow implementations). Tell me if this is OK for you.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
Re: [PR] GH-40547: [R][Docs] Add a non-technical introductory R vignette to the functioning of arrow [arrow]
Posted by "thisisnic (via GitHub)" <gi...@apache.org>.
thisisnic commented on PR #40982:
URL: https://github.com/apache/arrow/pull/40982#issuecomment-2048211806
I've given this a look over at a high level, and I think that there's some really great stuff in here. I'm not sure this needs to be a separate vignette, and what I think might work well is reworking the ["Getting Started" vignette](https://arrow.apache.org/docs/r/articles/arrow.html), which is a bit repetitive in places and could be shortened and linked out to the other vignettes, and then incorporating some of this content in there.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscribe@arrow.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org