
**What is Javascript?**

JavaScript is a scripting or programming language that allows you to implement complex features on web pages — every time a web page does more than sit there and display static information for you to look at — displaying timely content updates, interactive maps, animated 2D/3D graphics, scrolling video jukeboxes, etc. — you can bet that JavaScript is probably involved.

**What are you going to work on?**

In this course, we will cover six big topic groups. Every section contains a lot of assignments and code exercises.

The final project is a web application to display products for users to buy. For the entire course length, you will work on one application. We will start simple with console application and finish with React JS, an excellent styled application.

You will see how your application evolves, what techniques are required, and how everything connects in the end. You will get a complete understanding of the programming process.

**1\. JS Basics**

In this part, you will learn the basics in the Javascript programming language, but you will also get programmatic thinking that can help you start with any programming language.

The focus of this section is to think like the programmers and not repeat code without understanding.

Some of the topics from this section are:

*   computing history, variables, primitive types, functions, parameters, 
*   objects, arrays, conditionals, logical operators, classes, inheritance, prototypes
*   debugging, scope, call stack

**2\. HTML Basics**

This part of the course covers the core part of HTML. You will learn and understand how to structurize HTML documents. 

This part covers:

*   dom (document object model), document object,
*   elements + functions

**3\. CSS Basics**

To make the website look professional, you need to apply "style." In this section, you will learn how to use stylings effectively.

You will now learn how to use the two most used stylings: flex and grid.

**4\. HTML + JS**

The central part of modern frameworks like Angular, Vue, or React is to create seamless interaction of JS with HTML without you even noticing.

This part will teach you how things work behind the scene. You will use javascript to render HTML elements dynamically.

The main topics of this section are:

*   HTML nodes, dynamic elements

*   "mini" JS framework, modularity, 

*   ES and Common modules

**5\. Web server  + Webpack**

In this part, we will first cover communication on the internet from the perspective of client->server. You will learn how your computer requests the remote server to display any website on the internet.

Then we will create our custom Web Server, which will serve our HTML project, which we created in the sections before.

Later in the section, we will dive into Webpack. Webpack is a  bundler, and we will use it to bundle our javascript code together. You will learn how to write a javascript, which was impossible to write before.

*   client->sever, servers
*   Node JS, Webpack, 

**6. React JS**

The final part of this course will cover React JS library. You will learn to use React JS to create web applications with ease. You will create a final version of your web app. In the end, everything will connect, and you will understand how React JS works.

*   React JS
*   Hooks, State
*   Reactivity

It will be a long journey, but you will become developers in the end.


Learn programming in JS language, HTML, and CSS. Create a Web Application made in React JS. The path to the final project includes many assignments, code exercises, and challenges.

Web Development & Code 101 - Full Guide [2022]


Next.js gives you the best developer experience with all the features you need for production: hybrid static & server rendering, TypeScript support, smart bundling, route pre-fetching, etc. No config is necessary.

Ethereum is a technology that lets you send cryptocurrency to anyone, but in the first place, It also powers applications that everyone can use and no one can takedown. It's the world's programmable blockchain.

Solidity is an object-oriented, high-level language for implementing smart contracts. Smart contracts are programs that govern the behavior of accounts within the Ethereum state.

Pinata is a pinning service that allows users to host files on the IPFS network. The InterPlanetary File System (IPFS) is a protocol and peer-to-peer network for storing and sharing data in a distributed file system.

**What is this course covering?**

The course covers everything you need for a decentralized NFT application according to the ERC721 standard. Students of this course will learn about NFTs by creating a real-world application.

Students will learn what ERC721 smart contract is and how to create one.

The frontend for dApps covered in the course is created with React JS library and Next JS framework. CSS and design are built with the Tailwind framework.

**NFT Marketplace Application:**

This central part of the course covers the creation of an interactive NFT marketplace. Clients of this platform will be able to purchase NFTs with Ether digital currency.

The application is created in the Next JS framework, built on top of the React JS.

The first part of the course covers the setup of the pages layouts, creation of the first pages, and components. The Tailwind CSS framework covers the styling part of the application.

Students will explore how to provide Web3 JS code into the application, code responsible for communication with a crypto wallet and, therefore, with the blockchain.

We will use the Provider/Consumer concept to provide this layer, which is very common in React JS. This will guarantee that all of the components and pages will be able to access functionalities responsible for communication to the blockchain.

The application's state and data management are handled through the SWR(stale while revalidate) library. This will provide a reactive feel to the application and a reactive rendering of components upon receiving new data.

After all, necessary communication with blockchain is achieved, the students will start to work on smart contract implementation.

The course follows the recognized ERC721 token standard.

The smart contract is an essential part of the project. It serves as the blockchain "storage" of NFTs and provides functionality to verify ownership of an NFT and linkage to the media storage.

The last part of the course covers preparing and storing data related to NFT. So-called NFT Metadata.

NFT metadata data will be stored on Pinata (IPFS) based storage. Students will learn to gather data from the form and later submit them to the Pinata storage. The following important part is to link this metadata and create an NFT.


**The most mentionable topics covered in this application are:**

* Next JS Integration with Web3 and Blockchain

* Reactivity with Hooks and SWR

* Creation of NFT(ERC721) Smart Contract

* NFT data manipulation and storage on Pinata

* Typescript

Learn how to use React / Next JS, Solidity, and Pinata(IPFS) to create NFT marketplace on Ethereum. All In Typescript.

NFT Marketplace in React, Typescript & Solidity - Full Guide


__Advertisement :)__

- __[babelfish](https://github.com/nodeca/babelfish/)__ - developer friendly
  i18n with plurals support and easy syntax.

You will like those projects!

# h1 Heading 8-)
## h2 Heading
### h3 Heading
#### h4 Heading
##### h5 Heading
###### h6 Heading


## Horizontal Rules

___

---

***


## Typographic replacements

Enable typographer option to see result.

(c) (C) (r) (R) (tm) (TM) (p) (P) +-

test.. test... test..... test?..... test!....

!!!!!! ???? ,,  -- ---

"Smartypants, double quotes" and 'single quotes'


## Emphasis

**This is bold text**

__This is bold text__

*This is italic text*

_This is italic text_

~~Strikethrough~~


## Blockquotes


> Blockquotes can also be nested...
>> ...by using additional greater-than signs right next to each other...
> > > ...or with spaces between arrows.


## Lists

Unordered

+ Create a list by starting a line with `+`, `-`, or `*`
+ Sub-lists are made by indenting 2 spaces:
  - Marker character change forces new list start:
    * Ac tristique libero volutpat at
    + Facilisis in pretium nisl aliquet
    - Nulla volutpat aliquam velit
+ Very easy!

Ordered

1. Lorem ipsum dolor sit amet
2. Consectetur adipiscing elit
3. Integer molestie lorem at massa


1. You can use sequential numbers...
1. ...or keep all the numbers as `1.`

Start numbering with offset:

57. foo
1. bar


## Code

Inline `code`

Indented code

    // Some comments
    line 1 of code
    line 2 of code
    line 3 of code


Block code "fences"

```
Sample text here...
```

Syntax highlighting

``` js
var foo = function (bar) {
  return bar++;
};

console.log(foo(5));
```

## Tables

| Option | Description |
| ------ | ----------- |
| data   | path to data files to supply the data that will be passed into templates. |
| engine | engine to be used for processing templates. Handlebars is the default. |
| ext    | extension to be used for dest files. |

Right aligned columns

| Option | Description |
| ------:| -----------:|
| data   | path to data files to supply the data that will be passed into templates. |
| engine | engine to be used for processing templates. Handlebars is the default. |
| ext    | extension to be used for dest files. |

## Links

[link text](http://dev.nodeca.com)

[link with title](https://github.com/nodeca/babelfish/ "title text!")

Autoconverted link https://github.com/nodeca/babelfish (enable linkify to see)


## Images

![Minion](https://octodex.github.com/images/minion.png)
![Stormtroopocat](https://octodex.github.com/images/stormtroopocat.jpg "The Stormtroopocat")

Like links, Images also have a footnote style syntax

![Alt text][id]

With a reference later in the document defining the URL location:

[id]: https://octodex.github.com/images/dojocat.jpg  "The Dojocat"


Markdown Extensive Example updated


**What is Rust?**

Rust is a programing language. Rust is blazingly fast and memory-efficient: with no runtime or garbage collector, it can power performance-critical services, run on embedded devices, and easily integrate with other languages.

**What is WebAssembly?** 

WebAssembly is a new type of code that can be run in modern web browsers — it is a low-level assembly-like language with a compact binary format that runs with near-native performance and provides languages such as C/C++, C#, and Rust with a compilation target so that they can run on the web. It is also designed to run alongside JavaScript, allowing both to work together.

**Is this course right for you?**

If you plan to start your career as a developer or improve your programming skills, this course is right for you. Learn how to build a browser game with minimal JS and Rust code compiled into webAssembly instructions.

You will get the confidence and skills required to start your projects during this course. In addition, you will get the right mindset to apply for a developer career.

**What are you going to work on?**

You will build the Snake game from scratch. You will learn to write code in Rust language, static type, compiled language.

The course starts with an explanation and practical examples of the Rust language. You will learn Rust-specific features such as "moving" and "copying."

Rust doesn't have a garbage collector. Memory is cleared when the values are getting out of the scope. You will learn how to manage this concept with ease.

The next feature you will learn of is borrowing and references. Through references, you will be able to access values without owning them.

In the beginning lectures, we will also talk about memory management in Stack and the Heap structures, modularity, strings, and other essential topics.

After Rust's introduction lectures, you will start building your Snake game. You will learn how to structure the application modular and cleanly. 

You will build your own JS frontend, exposed through a simple Webpack development server. Later, you will transform JS implementation into TS (Typescript). This will specify types and be on the same page as Rust code.

Then, you will build your rust backend code, the backbone of our game. You will learn how to compile Rust code into WebAssembly code. WebAssembly is code that can run in the browser. It's faster (almost Native speed) and more efficient than JS.

At the end of the course, we will create a production server,  and deploy our game to Heroku, so anybody on the internet can play our game.


Learn how to code in Rust! Compile the code to WebAssembly, prepare JS/TS frontend and finish the course by creating the practical Snake game that can run in any browser.

Rust & WebAssembly with JS (TS) - The Practical Guide


**What is Unity?**

Unity is a cross-platform game engine. The Unity editor is supported on Windows, macOS, and the Linux platform. In contrast, the engine currently supports building games for over 25 platforms, including mobile, desktop, consoles, and virtual reality.

**What are we going to build?**

The course covers the development of one production-ready game. The type of game is 2D survival with a top-down view.

**Project - Undead Survival**

The main effort of this course is to show the viewer how to build a complete game from scratch. The game's goal is to survive as long as possible with infinite waves of enemies coming at the game protagonist.

The most important parts of the course are:

**Scriptable Objects**

Scriptable objects will be essential in creating the Statemachine, Ability system, and Action delegation. Scriptable objects make the project reusable and modular.

**State Machine**

Statemachine is the brain of the AI system. Every NPC can have different states (run, attack ...), while only one state can be active at a time. Every state can have multiple actions. Action is the behavior.

For example, the Enemy has a "Patrol" state. A patrol state can have two actions. One action is to provide movement to the enemy. Another action is to change the animation of the enemy to the walk.

The third component of the Statemachine is a condition. Condition is a boolean statement. When the statement or multiple statements are resolved as "true" the current state can be transited to the new one.

For example, if an enemy is in the "patrol" state and the "spot player condition" is resolved as "true", then an enemy can go to the "attack" state.

Enemies will have a straightforward state machine. More complex state machines will be applied to boss entities.

**Ability System**

A player and enemies can have different abilities. Each ability has stats, such as damage, cooldown, range, effect, and many others. Each ability is created as a scriptable object, which can be easily reused and changed to the required needs. There are two main types of abilities, passive and active ones. Passive ones are the abilities that are played automatically at a specific interval. Active ones need to be activated by some external input, such as a key-stroke of the player.

**Other Parts**

The course also covers other essential topics such as the spawning mechanism for the enemies, the UI system to display applied damage, game time, and other vital stats. There is also damage and health system. Next, the course covers the creation of the start/options menu with the options to navigate and choose different protagonists. The game is finished when the hero dies. When this happens, the score screen is displayed, and the game can be replayed infinitely.

Many other smaller topics will be covered in the course.

**Main Goal**

The main goal of the course is to teach how to create reusable systems that can be used in different games. The course focuses on the reusability of each component.


Create the complete 2D survival game in Unity with C#. Learn best practices and patterns.

All Blogs

Web Development & Code 101 - Full Guide [2022]

NFT Marketplace in React, Typescript & Solidity - Full Guide

Markdown Extensive Example updated

Rust & WebAssembly with JS (TS) - The Practical Guide

Unity 2D With C# - Complete Game Dev Course