Pluto.jl: Simple reactive notebooks for Julia

Pluto.jl

Writing a notebook is not just about writing the final document — Pluto empowers the experiments and discoveries that are essential to getting there.

Explore models and share results in a notebook that is

• reactive - when changing a function or variable, Pluto automatically updates all affected cells.
• lightweight - Pluto is written in pure Julia and is easy to install.
• simple - no hidden workspace state; friendly UI.

🎈 Pluto demo inside your browser 🎈

Input

A Pluto notebook is made up of small blocks of Julia code (cells) and together they form a reactive notebook. When you change a variable, Pluto automatically re-runs the cells that refer to it. Cells can even be placed in arbitrary order - intelligent syntax analysis figures out the dependencies between them and takes care of execution.

Cells can contain arbitrary Julia code, and you can use external libraries. There are no code rewrites or wrappers, Pluto just looks at your code once before evaluation.

Output

Your notebooks are saved as pure Julia files (sample), which you can then import as if you had been programming in a regular editor all along. You can also export your notebook with cell outputs as attractive HTML and PDF documents. By reordering cells and hiding code, you have full control over how you tell your story.

Dynamic environment

Pluto offers an environment where changed code takes effect instantly and where deleted code leaves no trace. Unlike Jupyter or Matlab, there is no mutable workspace, but rather, an important guarantee:

At any instant, the program state is completely described by the code you see.

No hidden state, no hidden bugs.

Interactivity

Your programming environment becomes interactive by splitting your code into multiple cells! Changing one cell instantly shows effects on all other cells, giving you a fast and fun way to experiment with your model.

In the example below, changing the parameter A and running the first cell will directly re-evaluate the second cell and display the new plot.

Built-in package manager

Pluto uses syntax analysis to understand which packages are being used in a notebook, and it automatically manages a package environment for your notebook. You no longer need to install packages, you can directly import any registered package like Plots or DataFrames and use it.

To ensure reproducibility, the information to exactly reproduce the package environment is stored in your notebook file. When someone else opens your notebook with Pluto, the exact same package environment will be used, and packages will work on their computer, automatically! more info

HTML interaction

Lastly, here's _one more feature_: Pluto notebooks have a @bind macro to create a live bond between an HTML object and a Julia variable. Combined with reactivity, this is a very powerful tool!

You don't need to know HTML to use it! The PlutoUI package contains basic inputs like sliders and buttons. Pluto's interactivity is very easy to use, you will learn more from the featured notebooks inside Pluto!

But for those who want to dive deeper - you can use HTML, JavaScript and CSS to write your own widgets! Custom update events can be fired by dispatching a new CustomEvent("input"), making it compatible with the viewof operator of observablehq. Have a look at the JavaScript featured notebook inside Pluto!

Pluto for teaching

Pluto was developed alongside the free online course Introduction to Computational Thinking at MIT, with the goal of creating a programming environment that is powerful, helpful and interactive, without being too intimidating for students and teachers.

Are you interested in using Pluto for your class? Here are some presentations by people who are using it already: the MIT team, Gerhard Dorn, Daniel Molina, Henki W. Ashadi and Max Köhler.

https://user-images.githubusercontent.com/6933510/134824521-7cefa38a-7102-4767-bee4-777caf30ba47.mp4

(video) Grant Sanderson (3Blue1Brown) using Pluto's interactivity to teach Computational Thinking at MIT!

Let's do it!

Ingredients

For one tasty notebook 🥞 you will need:

• Julia v1.6 or above
• Linux, MacOS or Windows, Linux and MacOS will work best
• Mozilla Firefox or Google Chrome

Installation

🎈 How to install Julia & Pluto (6 min) 🎈

Run Julia, enter ] to bring up Julia's package manager, and add the Pluto package:

julia> ]
(v1.7) pkg> add Pluto

Press Ctrl+C to return to the julia> prompt.

Usage

To run Pluto, run the following commands in your Julia REPL:

julia> import Pluto
julia> Pluto.run()

Pluto will open in your browser, and you can get started!

Questions and Help

Questions? Have a look at the FAQ. 


 

Interested in learning Julia, Pluto and applied mathematics? Join the open MIT course taught by Alan Edelman, David P. Sanders & Grant Sanderson (3blue1brown) (and a bit of me): Introduction to Computational Thinking, Spring 2021. 
 

Contribute to Pluto

Follow these instructions to start working on the package.

Featured notebooks

Unless otherwise specified, the included featured notebooks have a more permissive license: the Unlicense. This means that you can use them however you like - you do not need to credit us!

Your notebook files are yours, you also do not need to credit us. Have fun!

From the authors

The Pluto project is an ambition to rethink what a programming environment should be. We believe that scientific computing can be a lot simpler and more accessible. If you feel the same, give Pluto a try! We would love to hear what you think. 😊

You can chat with us

• talk with fellow Pluto users in the Zulip chat room (search for the pluto.jl stream)
• use Pluto's built-in feedback system:
• contact fons via email

Questions? Have a look at the FAQ.

🎈 Pluto – introduction (20 min) at Juliacon 2020 🎈
 

🌐 Pluto – one year later (25 min) at Juliacon 2021 🌐

Download Details:

Author: fonsp
Source Code: https://github.com/fonsp/Pluto.jl 
License: MIT license

#julia #visualization #education #reactivate #notebook 

ForgetMeNot: A Flashcard App For Android

ForgetMeNot

ForgetMeNot is an Android app for memorizing information via flashcards. Simplicity, usability, speed were taken into account in the process of developing this educational program. This app provides excellent conditions for achieving high efficiency of memorization.

Features

• Import/export of files.
• Support of CSV, Tab text or any other kind of Delimiter-Separated Values.
• Intervals (Spaced repetition). You can specified your own interval scheme for each deck.
• Several testing methods. There are 'Self testing', 'Testing with variants', 'Spell check'.
• Pronunciation of the text via TTS. You can choose languages for questions and answers, autospeaking of them.
• Hiding the text of a question to stimulate improvement of listening skills that is very useful in foreign language learning.
• Card inversion.
• Hints in the form of masking letters.
• 'Motivational timer' that will make you concentrate on your studies (optionally).
• Saving settings of deck as presets and reusing them in order to avoid routine work on settings.
• Editing and searching cards right in the exercise.
• 'Walking mode' that enables you do the exercise without looking at the screen.
• 'Autoplaying mode'. In this mode questions and answers are pronounced sequentially. You can combine your own activities and repetition of teaching material.
• Catalog of pre-made decks. The catalog contains many decks for language learning, which includes basic sets of words, thematic words and phrases, whole sentences.
• Grouping decks into separate lists
• Customizing the card appearance
• Dark theme

Video

Help translate

How to help translate

Architecture

See the dedicated page here.

Libraries Used

• kotlinx-coroutines
• kotlinx-serialization
• androidx.appcompat
• androidx.fragment
• androidx.constraintlayout
• androidx.navigation
• androidx.viewpager2
• material-components
• leakcanary
• sqldelight
• klock
• materialrangebar
• Brackeys-IDE
• Apache Commons CSV

Download

Download Details:

Author: Tema6120
Source Code: https://github.com/tema6120/ForgetMeNot 
License: GPL-3.0 license

#kotlin #android #learning #education 

How to Count Magical Bunnies with LibreOffice Calc

Follow along with this LibreOffice Calc tutorial to perform the Fibonacci Sequence calculation.

I love working with spreadsheets, and my favorite spreadsheet application is LibreOffice Calc. A spreadsheet is a grid of cells where each column is represented by letters and rows are numbered. You can perform all kinds of calculations using a spreadsheet. If you can perform a calculation based on other values, you can do that in a spreadsheet.

Here I illustrate how to use the LibreOffice Calc spreadsheet to perform a particular calculation called the Fibonacci Sequence. Fibonacci Sequence numbers pop up everywhere in mathematics and the sciences and are often used to model a simple population growth.

The magic bunny

Imagine a baby bunny who has moved into a new forest home. The forest is empty of all other bunnies; the bunny is alone. But this is a magic bunny — it is born pregnant, and all its children will also be born pregnant. Rabbits breed quickly, but especially so for this breed of magic bunny, which produces a new generation every year.

Let's call the year before the bunny arrived "year zero" or "iteration zero," when you had zero bunnies. A year later, you are at "year one" or "iteration one," with our first bunny.

The population of our magic bunny grows in this way: A baby bunny grows into an adult bunny after one year. An adult bunny will remain into the next generation but will produce another baby bunny. In other words, the rules for counting the bunny population are:

baby bunny (b) → adult bunny (A)

adult bunny (A) → adult bunny (A) plus a baby bunny (b)

Over time, the bunny population grows like this:

As you can see, the bunny population grows very quickly. The forest will quickly be filled with magic bunnies.

Counting bunnies in a spreadsheet

How many bunnies will there be after five, ten, or 20 years? Looking at each iteration, the number of bunnies in any year is the sum of the previous two years. Fibonacci described this growth using this definition:

Fib(n) = Fib(n-1) + Fib(n-2)
and:
Fib(0) = 0
Fib(1) = 1

You can calculate this using LibreOffice Calc! Here's how.

Start with an empty spreadsheet and enter the first two iterations: 0 and 1. Label these with a column header called "n." To enter this into LibreOffice Calc, type "n" into cell A1, the value 0 in cell A2, and 1 in cell A3:

(Jim Hall, CC BY-SA 4.0)

Enter the first two iterations of the magic bunny. In year zero, there were zero bunnies. In year one, there was one bunny. You can write that mathematically as Fib(0) = 0 and Fib(1) = 1. You can label this with a column header called "Fib(n)." Enter this into LibreOffice Calc by typing "Fib(n)" into cell B1, the number 0 in cell B2, and 1 in cell B3:

(Jim Hall, CC BY-SA 4.0)

To calculate the bunny population in the next iteration, use a spreadsheet formula to calculate Fib(n) for year two. Since the count in any year is the sum of the counts of the previous two years, you can enter into cell B4 the spreadsheet formula =B3+B2. This is the sum of B3 and B2 using addition. LibreOffice Calc will perform the calculation and enter the final result into cell B4:

(Jim Hall, CC BY-SA 4.0)

Use AutoFill to calculate future generations

Having entered the first few "n" and "Fib(n)" values, and the calculation for the next iteration, you can let LibreOffice Calc do the rest of the calculations. Notice that when you click on each cell in the spreadsheet, the cell outline has a small box in the lower-right corner. You can grab this box with your mouse and "stretch" the box to fill other cells in the spreadsheet.

When you stretch a cell to fill other cells, LibreOffice Calc uses a feature called "AutoFill" to enter values into the new cells. If you stretch a cell with a single value, AutoFill will iterate the number by one until it reaches the end of the series. For example, you can stretch cell A3 to fill other cells below it, which will fill the range with 2, 3, 4, and so on:

(Jim Hall, CC BY-SA 4.0)

If you stretch a cell that has a calculation in it, LibreOffice Calc will try to extend the calculation for you. For example, if you stretch your calculation in B4 into cell B5, the new B5 will contain the formula =B4+B3. In other words, AutoFill translates the calculation. Each successive Fib(n) calculation will be the sum of the two cells above it:

(Jim Hall, CC BY-SA 4.0)

You can continue to stretch the cells down, and AutoFill will continue the calculations:

(Jim Hall, CC BY-SA 4.0)

So you learn that after 20 iterations, you will have 6,765 magic bunnies. That's a lot of bunnies! Over 6,000 bunnies in 20 years represent a very fast population growth, but it demonstrates how quickly the Fibonacci Sequence can add up to a forest full of magic bunnies. The calculation is relatively simple using LibreOffice Calc.

Original article source at: https://opensource.com/

#education #count #magic 

101-rs: A Rust University Course

Rust 101

Rust 101 is a university course for computer science students, introducing the Rust Programming Language, and is available for anyone who wants to teach Rust.

Currently highly in flux, and incomplete, but feedback is welcome!

High-level goals

1. Deep dive, intermediate level Rust skill
2. Know the problems Rust aims to solve
3. Get practical, hands-on experience
4. Know why Rust features are the way they are
5. Ability to write custom CLI/server applications using popular crates or to contribute to existing projects
6. Ability to judge whether Rust fits project requirements
7. Ability to teach Rust to other people

Suggested course schedule

The course is setup so that, after modules A1-A4, cherry-picking the modules that suit your purpose is possible.

When used in full 12-week format, the schedule is:

The course assumes intermediate C/C++ knowledge.

The course outline, along with more elaborate learning objectives, can be found here. You can find instructions on the installation of used tools here.

About the project

Rust 101 aims to provide an open-source course, lectures, tutorials and exercises, that can be used by any higher education institution. In its entirety or by using bits and pieces to create your custom course.

The project is executed by Henk Oordt and others at Tweede golf. It is a not-for-profit project, where the only requirement is that the cost of our work is covered.

Other contributors

We're very happy with the support in developing the course material, by:

• Bernard van Gastel, Radboud University
• Florian Gilcher, Ferrous Systems
• Jonathan Donszelmann, TU Delft

Our sponsors

The initial sponsor of the project is the Faculty of Informatics and Information Technologies (FIIT) of the Slovak University of Technology (STU) in Bratislava, Slovakia. FIIT's contribution has enabled us to layout the groundwork for the course.

We are in search of further funding for our project. Contact us if your interested, or sponsor our work.

Why? Have a look at our blog post introducing the course.

This repo will contain everything that's needed to organize the course: slides, exercises, tools, setup instructions and more.

The rendered exercises, including installation instructions, can be found at https://101-rs.tweede.golf

Download Details:

Author: Tweedegolf
Source Code: https://github.com/tweedegolf/101-rs 
License: CC-BY-SA-4.0 license

#rust #education 

101-rs: A Rust University Course

Rust 101

Rust 101 is a university course for computer science students, introducing the Rust Programming Language, and is available for anyone who wants to teach Rust.

High-level goals

1. Deep dive, intermediate level Rust skill
2. Know the problems Rust aims to solve
3. Get practical, hands-on experience
4. Know why Rust features are the way they are
5. Ability to write custom CLI/server applications using popular crates or to contribute to existing projects
6. Ability to judge whether Rust fits project requirements
7. Ability to teach Rust to other people

Suggested course schedule

The course is setup so that, after modules A1-A4, cherry-picking the modules that suit your purpose is possible.

When used in full 12-week format, the schedule is:

The course assumes intermediate C/C++ knowledge.

The course outline, along with more elaborate learning objectives, can be found here. You can find instructions on the installation of used tools here.

About the project

Rust 101 aims to provide an open-source course, lectures, tutorials and exercises, that can be used by any higher education institution. In its entirety or by using bits and pieces to create your custom course.

The project is executed by Henk Oordt and others at Tweede golf. It is a not-for-profit project, where the only requirement is that the cost of our work is covered.

Other contributors

We're very happy with the support in developing the course material, by:

• Bernard van Gastel, Radboud University
• Florian Gilcher, Ferrous Systems
• Jonathan Donszelmann, TU Delft

Our sponsors

The initial sponsor of the project is the Faculty of Informatics and Information Technologies (FIIT) of the Slovak University of Technology (STU) in Bratislava, Slovakia. FIIT's contribution has enabled us to layout the groundwork for the course.

We are in search of further funding for our project. Contact us if your interested, or sponsor our work.

Why? Have a look at our blog post introducing the course.

This repo will contain everything that's needed to organize the course: slides, exercises, tools, setup instructions and more.

The rendered exercises, including installation instructions, can be found at https://101-rs.tweede.golf

Currently highly in flux, and incomplete, but feedback is welcome!

Download Details:

Author: tweedegolf
Source Code: https://github.com/tweedegolf/101-rs 
License: CC-BY-SA-4.0 license

#rust #education 

Best 9 Resources About Open Source for Educators and Students

Open source helps educators, scholars, students, and lifelong learners explore new horizons.

Open source provides fertile ground for innovation, not only in the cloud but in the classroom. Whether you are homeschooled, in a traditional K-12, university, someone looking to learn new skills, open source provides rich opportunities for personal and professional development. This year, Opensource.com writers provided readers with a considerable list of opportunities for continuing education regardless of where you are on the continuum.

Lack of computer science classes

Did you know that only 51% of the high schools in the United States offer courses in computer science? Only 4.7% of students are enrolled in the courses available. This statistic is telling at a time when the US News and World Report recently ranked software development as one of the best jobs in America in 2022. Candace Sheremeta provided us with a list of three open source efforts to reverse that trend in her article about open source tools to introduce students to computer science.

As computer science grows, it's important to have an understanding of what it means to be "cloud native." It's also necessary to understand the nuance of cloud native architecture. Anita Ihuman provides a beginner's guide to cloud native open source communities. This comprehensive article provides you with everything you need to know about cloud native and cloud native architecture.

Ada Lovelace day crowdsourcing

Managing editor Lauren Pritchett, invited us to celebrate Ada Lovelace day with a crowdsourced list of hands-on programming tutorials to fictional adventure novels. Opensource.com contributors shared their favorite books for programmers who are just starting out. You can start from Scratch and add to that a complete list of programming books available from NoStarch Press.  This includes my favorite book, Teach Your Kids to Code by Bryson Payne. There's also a list of three books for very young children to read about coding pioneer Ada Lovelace.

Security and interoperability

Concerns for security and interoperability have provided universities the impetus to move toward Rocket.chat for collaboration. Sara Cemazar has six compelling reasons why academia has adopted Rocket.chat. At the top of the list is how it improves hybrid and remote learning which have become mainstays of higher education. In addition it ensures complete data privacy and compliance with both FERPA in the United States, and GDPR in the EU.

Publishing in academia

Publishing is the life blood of academics and yet it's largely siloed and inordinately expensive to do. That's changing and Joshua Pearce has written about how the paradigm is changing and why open source is leading the way. Joshua writes, “Academics routinely give away their work to companies for free — and then they buy it back." Academics like Joshua have been trapped for decades in a scheme where they give away their work freely in exchange for job security. Then they pay millions of dollars a year to read our own writing. Now academics can read free, publish free, and stay on track for professional success.

Google

Google Summer of Code (GSoC) can benefit anyone at various stages of their career, including people changing careers, those who are self-taught, those returning to the workforce, and more. You might be one of those people! Stefan Miklosovic provides the details of how you can get involved in GSOC by contributing to Apache Cassandra. Start the new year by getting involved.

Open source hardware

The open source hardware field is growing exponentially with the growth of the internet of things that includes wearables, single board computers, cameras, and robotics. This year Joshua Pearce introduced readers to an amazing opportunity created by the confluence of open hardware in academia and the Sloan Foundation. Supported by fellowships worth up to $100,000 individuals will be able to tackle some of the latest issues for integrating open hardware deep into academia. If you are in the U.S. and interested in one of the eight Fellowships, check out the Request for Proposals here!

Education and open source

It is stunning how many opportunities open source projects give people to learn and improve themselves. Education can be costly but it does not have to be if one takes advantage of the myriad open source resources available on the web. You don't have to look too hard to find something free to learn! Try finding an open source learning resource now. You will not regret it.

Original article source at: https://opensource.com/

#opensource #education #students 

Collection Of Various Algorithms Implemented in R

The Algorithms - R

R is a programming language and free software environment for statistical computing and graphics supported by the R Foundation for Statistical Computing. The R language is widely used among statisticians and data miners for developing statistical software and data analysis. Polls, data mining surveys and studies of scholarly literature databases show substantial increases in popularity in recent years. As of November 2019, R ranks 16th in the TIOBE index, a measure of popularity of programming languages. (Wikipedia)

All algorithms can be found in the DIRECTORY.md file ordered by folder.

Contribution Guidelines

Please ensure to follow the points stated below if you would like to contribute:

• If your proposing a new algorithm or making changes to an existing one, make sure your code works. Reviewers or the general user must be able to directly emplace it in an R environment and get the desired output.
• Add an example to showcase the use of an algorithm proposed. It can be commented.
• Follow proper naming convention for variables (use . or _ to seperate terms, such as results.df for a data frame containing some results) and filenames (follow the convention that has been followed for files under the directory your committing to).
• Feel free to add links here to the newly added file(s), but ensure that they do not result in a merge conflict with different versions of this readme under previous pull requests.

Download Details:

Author: TheAlgorithms
Source Code: https://github.com/TheAlgorithms/R 
License: MIT license

#r #learning #education #machinelearning 

Datascience-box: Data Science Course in A Box

Data Science Course in a Box

Data Science in a Box contains the materials required to teach (or learn from) an introductory data science course using R, all of which are freely-available and open-source. They include course materials such as slide decks, homework assignments, guided labs, sample exams, a final project assignment, as well as materials for instructors such as pedagogical tips, information on computing infrastructure, technology stack, and course logistics.

See datasciencebox.org for everything you need to know about the project!

Note that all materials are released with Creative Commons Attribution Share Alike 4.0 International license.

Questions, bugs, feature requests

You can file an issue to get help, report a bug, or make a feature request.

Before opening a new issue, be sure to search issues and pull requests to make sure the bug hasn't been reported and/or already fixed in the development version. By default, the search will be pre-populated with is:issue is:open. You can edit the qualifiers (e.g. is:pr, is:closed) as needed. For example, you'd simply remove is:open to search all issues in the repo, open or closed.

If your issue involves R code, please make a minimal reproducible example using the reprex package. If you haven't heard of or used reprex before, you're in for a treat! Seriously, reprex will make all of your R-question-asking endeavors easier (which is a pretty insane ROI for the five to ten minutes it'll take you to learn what it's all about). For additional reprex pointers, check out the Get help! section of the tidyverse site.

Code of Conduct

Please note that the datascience-box project is released with a Contributor Code of Conduct. By contributing to this project, you agree to abide by its terms.

Download Details:

Author: rstudio-education
Source Code: https://github.com/rstudio-education/datascience-box 
License: View license

#r #education #datascience #rstats 

Geocompr: Open Source Book: Geocomputation with R

Geocomputation with R

Introduction

This repository hosts the code underlying Geocomputation with R, a book by Robin Lovelace, Jakub Nowosad, and Jannes Muenchow. If you find the contents useful, please cite it as follows:

Lovelace, Robin, Jakub Nowosad and Jannes Muenchow (2019). Geocomputation with R. The R Series. CRC Press.

The first version of the book has been published by CRC Press in the R Series and can be viewed online at bookdown.org. Read the latest version at geocompr.robinlovelace.net.

Note: we are actively working on the Second Edition 🏗

Since commencing work on the Second Edition in September 2021 much has changed, including:

• Replacement of raster with terra in Chapters 1 to 7 (see commits related to this update here)
• Update of Chapter 7 to include mention alternative ways or reading-in OSM data in #656
• Refactor build settings so the book builds on Docker images in the geocompr/docker repo
• Improve the experience of using the book in Binder (ideal for trying out the code before installing or updating the necessary R packages), as documented in issue #691 (thanks to yuvipanda)
• Improved communication of binary spatial predicates in Chapter 4 (see #675)
• New section on the links between subsetting and clipping (see #698) in Chapter 5
• New section on the dimensionally extended 9 intersection model (DE-9IM)
• New chapter on raster-vector interactions split out from Chapter 5
• New section on the sfheaders package
• New section in Chapter 2 on spherical geometry engines and the s2 package
• Replacement of code based on the old mlr package with code based on the new mlr3 package, as described in a huge pull request

See https://github.com/Robinlovelace/geocompr/compare/1.9…main for a continuously updated summary of the changes to date. At the time of writing (April 2022) there have been more than 10k lines of code/prose added, lots of refactoring!

Contributions at this stage are very welcome.

Contributing

We encourage contributions on any part of the book, including:

• improvements to the text, e.g. clarifying unclear sentences, fixing typos (see guidance from Yihui Xie);
• changes to the code, e.g. to do things in a more efficient way;
• suggestions on content (see the project’s issue tracker);
• improvements to and alternative approaches in the Geocompr solutions booklet hosted at geocompr.github.io/solutions (see a blog post on how to update solutions in files such as _01-ex.Rmd here)

See our-style.md for the book’s style.

Many thanks to all contributors to the book so far via GitHub (this list will update automatically): prosoitos, florisvdh, katygregg, Lvulis, rsbivand, iod-ine, KiranmayiV, babayoshihiko, cuixueqin, defuneste, zmbc, erstearns, FlorentBedecarratsNM, dcooley, marcosci, appelmar, MikeJohnPage, eyesofbambi, darrellcarvalho, nickbearman, tyluRp, giocomai, KHwong12, LaurieLBaker, MarHer90, mdsumner, pat-s, e-clin, gisma, ateucher, annakrystalli, andtheWings, kant, gavinsimpson, Himanshuteli, yutannihilation, jimr1603, jbixon13, olyerickson, yvkschaefer, katiejolly, kwhkim, layik, mpaulacaldas, mtennekes, mvl22, ganes1410, richfitz, wdearden, yihui, adambhouston, chihinl, cshancock, ec-nebi, gregor-d, jasongrahn, p-kono, pokyah, schuetzingit, sdesabbata, tim-salabim, tszberkowitz.

During the project we aim to contribute ‘upstream’ to the packages that make geocomputation with R possible. This impact is recorded in our-impact.csv.

Downloading the source code

The recommended way to get the source code underlying Geocomputation with R on your computer is by cloning the repo. You can can that on any computer with Git installed with the following command:

git clone https://github.com/Robinlovelace/geocompr.git

An alternative approach, which we recommend for people who want to contribute to open source projects hosted on GitHub, is to install the gh CLI tool. From there cloning a fork of the source code, that you can change and share (including with Pull Requests to improve the book), can be done with the following command:

git fork robinlovelace/geocompr # (gh repo clone robinlovelace/geocompr # also works)

Both of those methods require you to have Git installed. If not, you can download the book’s source code from the URL https://github.com/Robinlovelace/geocompr/archive/refs/heads/main.zip . Download/unzip the source code from the R command line to increase reproducibility and reduce time spent clicking around:

u = "https://github.com/Robinlovelace/geocompr/archive/refs/heads/main.zip"
f = basename(u)
download.file(u, f)        # download the file
unzip(f)                   # unzip it
file.rename(f, "geocompr") # rename the directory
rstudioapi::openProject("geococompr") # or open the folder in vscode / other IDE

Reproducing the book in R/RStudio/VS Code

To ease reproducibility, we created the geocompkg package. Install it with the following commands:

install.packages("remotes")
# To reproduce the first Part (chapters 1 to 8):
remotes::install_github("geocompr/geocompkg")

Installing geocompkg will also install core packages required for reproducing Part 1 of the book (chapters 1 to 8). Note: you may also need to install system dependencies if you’re running Linux (recommended) or Mac operating systems. You also need to have the remotes package installed:

To reproduce book in its entirety, run the following command (which installs additional ‘Suggests’ packages, this may take some time to run!):

# To reproduce all chapters (install lots of packages, may take some time!)
remotes::install_github("geocompr/geocompkg", dependencies = TRUE)

You need a recent version of the GDAL, GEOS, PROJ and udunits libraries installed for this to work on Mac and Linux. See the sf package’s README for information on that. After the dependencies have been installed you should be able to build and view a local version the book with:

# Change this depending on where you have the book code stored:
rstudioapi::openProject("~/Downloads/geocompr")
 # or code /location/of/geocompr in the system terminal
 # or cd /location/of/geocompr then R in the system terminal, then:
bookdown::render_book("index.Rmd") # to build the book
browseURL("_book/index.html")      # to view it

Geocompr in a devcontainer

A great feature of VS Code is devcontainers, which allow you to develop in an isolated Docker container. If you have VS Code and the necessary dependencies installed on your computer, you can build Geocomputation with R in a devcontainer as shown below (see #873 for details):

Geocompr in Binder

For many people the quickest way to get started with Geocomputation with R is in your web browser via Binder. To see an interactive RStudio Server instance click on the following button, which will open mybinder.org with an R installation that has all the dependencies needed to reproduce the book:

You can also have a play with the repo in RStudio Cloud by clicking on this link (requires log-in):

Geocomputation with R in a Docker container

To ease reproducibility we have made Docker images available, at geocompr/geocompr on DockerHub. These images allow you to explore Geocomputation with R in a virtual machine that has up-to-date dependencies.

After you have installed docker and set-it up on your computer you can start RStudio Server without a password (see the Rocker project for info on how to add a password and other security steps for public-facing servers):

docker run -p 8787:8787 -e DISABLE_AUTH=TRUE geocompr/geocompr

If it worked you should be able to open-up RStudio server by opening a browser and navigating to http://localhost:8787/ resulting in an up-to-date version of R and RStudio running in a container.

Start a plain R session running:

docker run -it geocompr/geocompr R

If you see something like this after following the steps above, congratulations: it worked! See github.com/rocker-org for more info.

If you want to call QGIS from R, you can use the qgis tag, by running the following command for example (which also shows how to set a password and use a different port on localhost):

docker run -d -p 8799:8787 -e USERID=$UID -e PASSWORD=strongpass -v $(pwd):/home/rstudio/geocompr robinlovelace/geocompr:qgis

From this point to build the book you can open projects in the geocompr directory from the project box in the top-right hand corner, and knit index.Rmd with the little knit button above the the RStudio script panel (Ctl+Shift+B should do the same job).

See the geocompr/docker repo for details, including how to share volumes between your computer and the Docker image, for using geographic R packages on your own data and for information on available tags.

Reproducing this README

To reduce the book’s dependencies, scripts to be run infrequently to generate input for the book are run on creation of this README.

The additional packages required for this can be installed as follows:

source("code/extra-pkgs.R")

With these additional dependencies installed, you should be able to run the following scripts, which create content for the book, that we’ve removed from the main book build to reduce package dependencies and the book’s build time:

source("code/01-cranlogs.R")
source("code/sf-revdep.R")
source("code/09-urban-animation.R")
source("code/09-map-pkgs.R")

Note: the .Rproj file is configured to build a website not a single page. To reproduce this README use the following command:

rmarkdown::render("README.Rmd", output_format = "github_document", output_file = "README.md")

Citations

To cite packages used in this book we use code from Efficient R Programming:

# geocompkg:::generate_citations()

This generates .bib and .csv files containing the packages. The current of packages used can be read-in as follows:

pkg_df = readr::read_csv("extdata/package_list.csv")

Other citations are stored online using Zotero.

If you would like to add to the references, please use Zotero, join the open group add your citation to the open geocompr library.

We use the following citation key format:

[auth:lower]_[veryshorttitle:lower]_[year]

This can be set from inside Zotero desktop with the Better Bibtex plugin installed (see github.com/retorquere/zotero-better-bibtex) by selecting the following menu options (with the shortcut Alt+E followed by N), and as illustrated in the figure below:

Edit > Preferences > Better Bibtex

Zotero settings: these are useful if you want to add references.

We use Zotero because it is a powerful open source reference manager that integrates well with the citr package. As described in the GitHub repo Robinlovelace/rmarkdown-citr-demo.

Download Details:

Author: Robinlovelace
Source Code: https://github.com/Robinlovelace/geocompr 
License: View license

#r #education #book #maps #vector 

Physics Wallah and Its Aim to Provide Quality Education to the Masses

Physics Wallah: The revolutionizer of Indian #education. In this era when education is more of a business. #Physics Wallah is continuously raising the bar of competitiveness and providing the best support to the #students at a very cost-effective price.

https://www.stridepost.com/physics-wallah-and-its-aim-to-provide-quality-education-to-the-masses/

#neet  #physics  #neet2022 

What is Interconversion of Matter Class 9 Notes by Physics Wallah

The phenomenon of change of matter form one state to another state and back to original state, by altering the conditions of temperature and pressure, is called the interconversion of matter.
https://www.pw.live/chapter-matter-is-our-surrounding-class-9/interconversion-of-states-of-matter

 #physics  #newton  #solid  #science  #class   #scientist #study #education 

WRITE THE MERITS OF BOHR’S THEORY

WRITE THE MERITS OF BOHR’S THEORY
The experimental value of radii and energies in hydrogen atoms are in good agreement with that calculated on the basis of Bohr’s theory.

Continue Reading: https://www.pw.live/question-answer/write-the-merits-of-bohrs-theory-32886

#physics #science  #newton  #atom  #education 

How CBSE is Different from NCERT?

Have you ever wondered why NCERT textbooks are recommended in CBSE schools? Here you will find all your answers.

https://www.pw.live/blogs/what-is-the-difference-between-ncert-and-cbse

#CBSE #ncert #jeemains #education #books #ncertsolutions #ncerttextbooks #cbseresults #ncertsolutionforclass6maths #iitjee 

PHYSICS FORMULAS CLASS 11 FOR IIT JEE & NEET CHAPTER-FLUID MECHANICS

Fluid is the name given to a substance, which begins to flow when an external force is applied to it. Get the detailed formulas of the class11 fluid mechanics chapter for students preparing for IITJee, Neet, and their semester exams. All Formulas are explained effectively to avoid confusion. These solutions are prepared by expert faculties of Physics who have 10+years of experience in this field.

https://www.pw.live/physics-formula/class-11-fluid-mechanics-formulas

#physicsformulas #physics  #chemistry #biology #astronomy #neet #space  #astrophysics #nasa #universe #maths #quantumphysics #engineering #physicsfun #math #mathematics #cosmos #scientist  #education  #cosmology #facts 
 

An example of colonial alga is

Colonial Alga is an Example of 
The Chlorella is an example of unicellular algae.While Spirogyra and Ulothrix are filamentous. Volvox is an example of colonial algae.

https://www.pw.live/question-answer/an-example-of-colonial-alga-is-51413

#botany  #environment  #physics  #education