---
# System prepended metadata

title: Universal Intro to NEAR
tags: [overview]

---

---
title: Universal Intro to NEAR
tags: overview
---


# Universal Intro to NEAR

## What is NEAR?

NEAR is a developer platform and ecosystem.  Part of this platform is a smart contract blockchain protocol that is built to be sharded, scalable and really easy to use for developers and users.  There are more components that we provide to developers and a whole ecosystem that has been built around it.

## How is NEAR different?

### NEAR Prioritizes Developer Adoption

Developer adoption of web3 is a challenge.  The tooling is different.  The development, execution and deployment models are different. The adversarial economic environment is unfamiliar. The mindset is different.  NEAR set out to make that as easy as possible for existing blockchain developers as well as newcomers.

NEAR addresses the challenges of developer adoption in a few ways. First, we understood that developer experience it was matters so we chose to use standardized, widely adopted and familiar components for all the parts that a developer would interact with.  

### NEAR is Simple, Cost Effective and Familiar

From a developers perspective, the account model is clean and easy to integrate, fees are designed to remain low and building on NEAR involves familiar, modern web technologies

Generally speaking, blockchain applications have two surface areas for innovation: smart contracts and the platform API.  

Smart contracts are where developers put their backend application logic.  You can think of smart contracts as the API for your application data in the same way that web developers see Models and Controllers in the MVC architecture.  The "blockchain difference" (with all smart contract platforms, not just NEAR) is that the code and data are cryptographically guaranteed to be tamper-free for as long as the network remains economically viable and sufficiently decentralized.

The platform API is how developers communicate with the NEAR platform to get work done.  NEAR uses a remote procedure call (RPC) scheme to communicate using JSON over HTTP.  In other words developers send HTTP POST requests with JSON payloads to public endpoints and get JSON in response. This is a very familiar mental model for any modern web developer who uses RESTful interfaces, for example. Although RPC feels a little different from REST, it takes developers mere minutes to adjust.

#### Smart contracts

The core team at NEAR has worked very hard to keep the developer surface area (smart contracts and platform API) familiar, simple and based on open standards.

For smart contracts, NEAR chose a WebAssembly-compatible virtual machine as the execution target.  This means developers write smart contracts using widely available programming languages that compile to WebAssembly like Rust and AssemblyScript with others on the way.  These smart contracts are compiled to WebAssembly (a binary format with files like `contract.wasm`) and then deployed to the blockchain to be awoken and executed (like serverless functions) whenever they are called from the application.

#### Platform API

For the platform API, NEAR designed an RPC (remote procedure call) interface that accepts JSON over HTTP.  This means developers send and receive JSON (a widely adopted text-based format for structured data) using HTTP from their applications.  

To make this even easier, NEAR developed `near-api-js` which wraps the RPC interface so that developers can call a contract right from their JavaScript code with statements like `contract.buy({ nft: 123 })` which makes smart contract execution feel like magic.  

### NEAR Leverages Open Source

- we want new devs bc more devs means more first results
- even solidity devs can build bigger things by reusing code
    - support for devs who know solidity by running EVM on NEAR with ETH native token to be able to run their contracts faster and cheaper.  EVM is compiled into a smart contract on NEAR
    - interoperability is a key component
    - first trustless connection between two blockchains
    - like "wire transfer between two blockchains"
    - aurora let's you treat Ethereum apps like any other contract on another shard, the basic model of NEAR apps in an ecosystem


## Major Projects on NEAR

- two in financial space
    - ref.finance (uniswap-like AMM)
        - full decentralized settlement in one second
    - flux.market (prediction market)
        - rich interface for betting on outcomes
    - paras.id (nft market)
        - long tail of digital artists given low fees
        - composable "cards" designed with the intent of reuse and crossing over more traditional game boundaries like cards in games



---

:::success
OTHER CONTENT
:::

### Developers

As web developers learning a new technology stack we tend to look for familiar mental models like MVC (model-view-controller) and architectural layers like the frontend and backend.  NEAR Protocol brings these same models to blockchain development in several ways: 

- On the frontend, a clean and simple library for communicating with the backend from your NodeJS or JavaScript (also React, Vue, Angular, Svelte, etc) frontend.
- On the backend, two smart contract development languages with more on the way to make it as easy and accessible as possible for developers to build robust smart contracts
- With regards to testing, full featured testing and simulation tools using built-in language features (eg. with Rust) or well-documented third-party libraries (eg. with AssemblyScript and as-pect)

**The frontend**

A JavaScript / TypeScript library called `near-api-js` that makes communication between your application frontend and the blockchain backend as easy to understand as `contract.buy({nft: 123})` which automatically handles authentication and payment.

For any JavaScript developer familiar with using a third-party library, interacting with the blockchain is as easy as installing and using an npm package or calling a remote API -- there is basically nothing new on the frontend to think about with one exception: authentication -- and in this way blockchain applications are arguably much cleaner and simpler because all the user needs is a local private key and this is handled behind the scenes by `near-api-js` after calling  `wallet.requestSignIn()`

**The backend**

Two smart contract development languages (with more coming).  AssemblyScript which is designed to feel familiar to JavaScript developers and Rust which is a modern, robust systems programming language for writing contracts that manage high value and require the additional safety guarantees provided by the mature Rust compiler and the rest of the production-hardened Rust-to-Wasm toolchain.

**Testing**

A mature testing pipeline starting with unit tests for individual contract methods as well as simulation and integration tests for orchestrating cross-contract calls that involve more than one contract or when we need to model more sophisticated scenarios.

### Users

NEAR excels at connecting the web2 users to blockchain for several reasons:

- Named accounts by default: Users have dealt with email and web addresses for decades now. NEAR’s account system naturally continues this from web2 to web3 by offering named accounts. This means NEAR transactions look similar to familiar email and banking transactions. 

- Familiar authorization flow: The signup process using the NEAR wallet walks new users through setting up, securing, and funding their account. This, combined with named accounts, makes this the friendliest onboarding in the cryptocurrency space. Logging in to dapps shows the account name for confirmation and prompts the user to allow the connection.


---

notes above taken from this video
https://www.youtube.com/watch?v=94TA0Ksn3rE