teleren/devto huggingface dataset:
Review Pintu Aplikasi Crypto Terbaik Dan Termudah Untuk Pemula
Tags: aplikasipintu, crypto, pintu, reviewpintu
Published: 2022-01-09 03:26:04


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/fngjp9jys1c24ugqjcfq.jpg)

Artikel ini aku akan memberikan review aplikasi kripto yaitu mengenai Pintu. Pintu ialah aplikasi yang bisa digunakan jual dan beli aset crypto di Indonesia yang diliris tahun 2020 lalu. Saat ini sendiri jumlah aset kripto didalam aplikasi Pintu berjumlah 36 berikut daftarnya:

Bitcoin, Ethereum, Tether, Binance Coin, Compound, Chainlik, Synthetix, Yearn.Finance, Uniswap, Maker, AAVE, SushiSwap, The Graph, REN, Balancer, Curve Finance, Polygon, Ocean, 1inch, Axie Infinity, The Sandbox, USD Coin, Wrapped Bitcoin, FTX Token, Dogecoin, Polkadot, Cardano, Ripple, Solana, Tezos, My NeighbourAlice, Pintu Token, BitDAO, Terra, Decentraland.

Bukan itu saja, pada aplikasi Pintu juga ada berbagai fitur menarik seperti alarm harga, Pintu Academy, Referral, Komunitas, dan baru ini ada juga Pintu Earn, serta terdapat juga keunggulan lainnya. Untuk informasi lebih lanjut kamu bisa simak dibawah ini.

## **Fitur-Fitur Aplikasi Pintu**

**1. Alarm Harga**
Fitur yang pertama adalah Price Alert atau alarm harga. Nah fitur sendiri ini dapat kamu gunakan untuk pengingat atau alarm harga yang bisa diatur sendiri. Jadi ketika harga kripto mencapai titik yang telah kamu atur sebelumnya, maka fitur price alert ini akan langsung bekerja dan memberikan notifikasi.

**2. Pintu Academy**
Pintu Academy adalah fitur yang memberikan informasi atau edukasi mengenai kripto. Jadi kalau kamu belum terlalu tau atau faham tentang kripto bisa di Pintu Academy.

**3. Referral**
Referral merupakan program dari Pintu jadi kalau kalian mengundang teman untuk menggunakan Pintu dan memakai kode undangan punya kamu, maka kamu dan juga temanmu akan mendapat keuntungan.

**4.Komunitas**
Pengen bergabung komunitas crypto tapi bingung dimana gabungnya? tenang saja Kamu bisa kok gabung di komunitas Pintu dan terhubung sama pengguna aplikasi Pintu lainnya lewat komunitas yang ada di Discord dan juga di Telegram Official (pintuindonesia), dengan tujuan untuk berbagi pengetahuan atau informasi yang telah kamu ketahui dan berdiskusi mengenai kripto.

**5.Pintu Earn**
Pintu Earn adalah sebuah fitur di aplikasi Pintu yang terbaru. Kamu dapat menyimpan aset kripto yang kamu miliki di Pintu Earn dan mendapat bunga. Menariknya tanpa dikunci jadi bisa kok ditarik kapan saja.

## **Kelebihan Aplikasi Pintu**
1. Proses Mendaftar mudah dan cepat.
2. Investasi bisa dimulai dari Rp 11.000.
3. Tampilan aplikasi simple sehingga mudah digunakan pemula.
4. Terdapat keamanan akun.
5. Penjualan dan pembelian kripto gak ada biaya.
6. Jumlah aset kripto yang tersedia beragam.
7. Telah resmi Terdaftar dan diawasi oleh BAPPEBTI dan juga KOMINFO.

Sekian artikel mengenai **Review Aplikasi Pintu**. Setelah kita tau dari fitur dan kelebihannya bisa disebut [**Pintu Aplikasi Crypto Terbaik dan Termudah di Indonesia**](https://www.septiyanmedia.com/2021/12/pintu-aplikasi-crypto-terbaik-dan-termudah-di-indonesia.html). Semoga artikel ini dapat bermanfaat bagi kita semua.
How to Become a Blockchain Developer
Tags: blockchain, programming, beginners, tutorial
Published: 2022-01-09 02:49:24


This article is for professional software developers interested in steering their careers towards blockchain.

Are you interested in blockchain development but don’t know where to start? Here are my steps to becoming a blockchain developer in 2022 and beyond.

{%youtube F-39z_QS2d8%}

## Step 1. Assess Your Skill Set
As a software developer, you’ll likely have your preferred stack. You might have worked with a few different technologies, but you’re currently working on a small range of tech. If this is the case, you’re already in good stead.

Full-stack development experience is a huge advantage but not critical at this point. It could be that you’ve focussed solely on the back end but haven’t touched web design. Your main job could be creating React components, but you get skittish when someone mentions microservices.

The most important thing is that you know where your strengths and weaknesses lie in a full-stack. For me, my back-end skills (and interests) outweighed my propensity for using front-end frameworks.

## Step 2. Target the Required Skill Set
Now that you know where your strengths and weaknesses lie, it’s time to target what you need to learn next.

Ethereum is the best entry point into blockchain development. It has the second-highest market cap of any cryptocurrency. It has held that position for the majority of its lifetime, (XRP overtook for a short time during the 2017 boom), meaning it’s a very popular project. Ethereum has a large developer community so that most issues can be solved with a quick Google search, and the Ethereum Foundation provides great documentation.

First on your list of things to learn is the Ethereum smart contract language: Solidity. This is the backbone of any decentralised application on the Ethereum network.

Next up is Node and React, very popular for front-end development and the tools of choice for most DApp creators. (Bonus points for Redux, too).

The Truffle Suite is an essential tool that helps combine your Solidity code with your front end. Using Solidity, Node, web3js, and React, you can create, test, and deploy DApps from the Truffle suite.

Originally Published at Epic Programmer:- https://www.epicprogrammer.com/2022/01/how-to-become-blockchain-developer.html
PostCSS: Input and other modules source code walk-through
Tags: postcss, underthehood, sourcecode
Published: 2022-01-09 02:40:59

---
series: Reverse Engineer PostCSS
title: PostCSS: Input and other modules source code walk-through
tags: postcss, underthehood, sourcecode
published: true
---

## Terminal Highlight
Purpose of this module is to enable syntax highlight while printing the stringified CSS (after transformation) to the terminal. `picocolors` is used for this (similar to `chalk` npm package). For each token, a specific color is defined as a map.

#### getTokenType
When the type is `word`, it is very generic and we need to classify them as `hash` or `class`. Using `Tokenizer`, forward lookup is done to detect `bracket` or `parentheses`.

#### terminalHighlight
Get `Processor` instance from `Tokenizer` initialization and until `EOF` is reached, wrap all the tokens using `picocolors` by splitting them by newline character.



## Input
This takes in CSS as `String` type as first argument. The main purpose of this entity is to store CSS, origin, sourcemap and to provide associated functionalities listed below. The steps to initialize are:
- Error handling
- [BOM](https://www.w3.org/International/questions/qa-byte-order-mark) check and handling
- When `from` is specified, it is check if value is a network path or absolute path. Else it is resolved using `path`.
- When `from` is not specified, `id` is generated using `nanoid`
- Source map added if available, generated from compilation step before PostCSS kicks in.

#### fromOffset
Purpose of this method is to return line and column number when offset is provided.
- CSS string is split by `\n` and stored as `Array<string>`.
- The no of characters in each line is counted incrementally (including the newline), say, if there are 10 lines with each line having 20 characters. The corresponding array created is:
```js
lineToIndex = [20, 40, 60, ... 200]
```
- This is stored as cache with `Symbol('fromOffsetCache')`. Using this the line number and column number is determined in `O(log n)` complexity similar to searching sorted Array.

#### error
Returns `CssSyntaxError`
Parameters are:
- error message (`string`)
- any one of:
  - both line and column as `{offset?:number; line:number; col:number}`
  - line (`number`) and column (`null`)
- opts (`{plugins: any}`)
- If `offset` is present, `FilePosition` is determined using `fromOffset()`.

Steps:
- generate the start and end line-column numbers from parameters (which is `FilePosition`) and pass to `CssSyntaxError` to get `result`.
- Add `{...FilePosition, source, url}` to `result`

#### origin
- return `false` if
  - not having map, or 
  - map not having source
- get sourcemap consumer to get the original `FilePosition` data before previous stage compilation
- Add `url`, `source` (`sourceContent`) from consumer to `FilePosition`

#### mapResolve
Takes in file path and checks if it has protocol like `file://` or `http://`. Else, it resolves path from map source.

#### from (getter)
Returns `file` or `nanoid` generated `id` 

#### toJSON
Adds the following keys:
- hasBOM
- css
- file
- id
- map
and remove the map.consumerCache
PostCSS: Architecture overview
Tags: postcss, underthehood, architecture
Published: 2022-01-09 02:40:32

---
series: Reverse Engineer PostCSS
title: PostCSS: Architecture overview
tags: postcss, underthehood, architecture
published: true
---

I am a big fan of `PostCSS` and this is my attempt to understand this package to become an active contributor. I am planning to write a series involving architecture, code walk-through for this amazing package and its top plugins. 

Before diving into very low level details, reading this [architecture](https://github.com/postcss/postcss/blob/main/docs/architecture.md) is a must. Almost all of the low level detailed info are available in [API page](https://postcss.org/api/) with multiple theoretical example, generated from static typing `jsDoc`. The intention of this series is to provide them in digestible and pragmatic way.  For that many references from `PostCSS` plugins will be drawn. This will get extended by diving deep into the codebase as well. As mentioned in the arch doc, the AST conversion is split into. two parts: tokenization and parsing for performance reasons. Lets get started with the basics:

Everything is a `Node` here. The statement is too generic but what it means is the CSS is converted into a tree structure. Which means that many tokens in stylesheet are converted into `Node` to form the hierarchical structure. To illustrate this, lets take an example:

```css
.active {
  transform: scale(1.1);
}
```
Here, this stylesheet is stored as a series of characters. They are read character by character and converted into tokens. The tokens are then parsed by the parser and converted into the AST structure, which sets the stage for all the plugins to work their magic. So, this is a 2-stage process.

Lets understand the above code structure after tokenization:

```log
.active
{
transform
:
scale(1.1)
;
}
```
It is converted into 7 tokens. These tokens are consumed by `Parser` using `nextToken()` in `Tokenizer`.
Something about server side.
Published: 2022-01-08 19:36:55

CRUD Operations:
Within computer programming, the acronym CRUD stands for create, read, update and delete. These are the four basic functions of persistent storage. Also, each letter in the acronym can refer to all functions executed in relational database applications and mapped to a standard HTTP method, SQL statement or DDS operation.
It can also describe user-interface conventions that allow viewing, searching and modifying information through computer-based forms and reports. In essence, entities are read, created, updated and deleted. Those same entities can be modified by taking the data from a service and changing the setting properties before sending the data back to the service for an update. Plus, CRUD is data-oriented and the standardized use of HTTP action verbs.
JWT:
JSON Web Token.
What is JSON Web Token?
JSON Web Token (JWT) is an open standard (RFC 7519) that defines a compact and self-contained way for securely transmitting information between parties as a JSON object. This information can be verified and trusted because it is digitally signed. JWTs can be signed using a secret (with the HMAC algorithm) or a public/private key pair using RSA or ECDSA.
Although JWTs can be encrypted to also provide secrecy between parties, we will focus on signed tokens. Signed tokens can verify the integrity of the claims contained within it, while encrypted tokens hide those claims from other parties. When tokens are signed using public/private key pairs, the signature also certifies that only the party holding the private key is the one that signed it.
When should you use JSON Web Tokens?
Here are some scenarios where JSON Web Tokens are useful:
Authorization: This is the most common scenario for using JWT. Once the user is logged in, each subsequent request will include the JWT, allowing the user to access routes, services, and resources that are permitted with that token. Single Sign On is a feature that widely uses JWT nowadays, because of its small overhead and its ability to be easily used across different domains.
Information Exchange: JSON Web Tokens are a good way of securely transmitting information between parties. Because JWTs can be signed—for example, using public/private key pairs—you can be sure the senders are who they say they are. Additionally, as the signature is calculated using the header and the payload, you can also verify that the content hasn't been tampered with.
3// Relational database (MySql)
What is a Relational Database?
A relational database defines database relationships in the form of tables. The tables are related to each other - based on data common to each.
Look at the following three tables "Customers", "Orders", and "Shippers" from the Northwind database.
Creating CLI Application with Laravel Zero
Tags: laravel, cli, php
Published: 2022-01-09 02:11:59

You might come across, you need a simple CLI application for your system / solution / process, a separate application written in PHP.

I've been using [Laravel Zero](https://laravel-zero.com/) for quite sometimes, mostly writing simple application to do the ETL, migration purpose related - from one database type to another. 

Why CLI application? Why Laravel Zero? Why Laravel? Why PHP? Why not any other ETL tools? 

Because I'm used to PHP, Laravel ecosystem. It's easy and fast, less learning curve with Laravel Zero and CLI application used with non-interaction with end users. Hence, simple CLI application written in PHP, is the best fit for me. Quick and easy.

Anyway, I've create a public template that already configured with necessary packages - [Arc8 CLI](https://github.com/nasrulhazim/arc8-cli) (pronounced as Arcade CLI). Just click on Use This Template to start write your own CLI Application.

[Arc8 CLI](https://github.com/nasrulhazim/arc8-cli) is a pre-configured CLI Application code based on Laravel Zero that help developers to jumpstart quickly on CLI application development.

You may want to rename the [`arc`](https://github.com/nasrulhazim/arc8-cli/blob/master/arc) command to the one that you preferred. Do update the [`composer.json`](https://github.com/nasrulhazim/arc8-cli/blob/5f2defbe70533b337d9e15d3a28ce8823289ae53/composer.json#L49) file too if change the name.

The usage, quiet straightforward - you may refer to [Laravel Zero](https://laravel-zero.com/docs/commands) documentation for the details.

Photo by <a href="https://unsplash.com/@lukash?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Lukas</a> on <a href="https://unsplash.com/s/photos/terminal-linux?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
Why React Freeze Children in DEV mode?
Tags: react, javascript, createelement, freeze
Published: 2022-01-09 02:06:43

I've been reading react code base and understood react freeze children if it is on dev mode.
```
export function createElement(type, config, children) {
  let propName;

  // Reserved names are extracted
  const props = {};

  let key = null;
  let ref = null;
  let self = null;
  let source = null;

  if (config != null) {
    if (hasValidRef(config)) {
      ref = config.ref;

      if (__DEV__) {
        warnIfStringRefCannotBeAutoConverted(config);
      }
    }
    if (hasValidKey(config)) {
      if (__DEV__) {
        checkKeyStringCoercion(config.key);
      }
      key = '' + config.key;
    }

    self = config.__self === undefined ? null : config.__self;
    source = config.__source === undefined ? null : config.__source;
    // Remaining properties are added to a new props object
    for (propName in config) {
      if (
        hasOwnProperty.call(config, propName) &&
        !RESERVED_PROPS.hasOwnProperty(propName)
      ) {
        props[propName] = config[propName];
      }
    }
  }

  // Children can be more than one argument, and those are transferred onto
  // the newly allocated props object.
  const childrenLength = arguments.length - 2;
  if (childrenLength === 1) {
    props.children = children;
  } else if (childrenLength > 1) {
    const childArray = Array(childrenLength);
    for (let i = 0; i < childrenLength; i++) {
      childArray[i] = arguments[i + 2];
    }
    if (__DEV__) {
      if (Object.freeze) {
        Object.freeze(childArray);
      }
    }
    props.children = childArray;
  }

  // Resolve default props
  if (type && type.defaultProps) {
    const defaultProps = type.defaultProps;
    for (propName in defaultProps) {
      if (props[propName] === undefined) {
        props[propName] = defaultProps[propName];
      }
    }
  }
  if (__DEV__) {
    if (key || ref) {
      const displayName =
        typeof type === 'function'
          ? type.displayName || type.name || 'Unknown'
          : type;
      if (key) {
        defineKeyPropWarningGetter(props, displayName);
      }
      if (ref) {
        defineRefPropWarningGetter(props, displayName);
      }
    }
  }
  return ReactElement(
    type,
    key,
    ref,
    self,
    source,
    ReactCurrentOwner.current,
    props,
  );
}

```
in fact I'm not able to understand why react use freeze method for childArray if it's environment been on the dev mode.
can anybody explain it to me?
thanks.
Coin Change Mock Interview
Tags: career, programming, interview, dsa
Published: 2022-01-09 01:16:16

I recently conducted a coding mock interview in VR with an aspiring FAANG dev and I gave him the coin change problem.

The candidate passed this interview because of their ability to work through the problem, and even though their were hiccups throughout, there wasn't anything that would sink the interview. 
This candidate passed with a 4/5

[Check it out here](https://www.youtube.com/watch?v=05lZOCN292I&t=10s)
Oh now we're talkin'
Tags: codenewbie, javascript, beginners, programming
Published: 2022-01-09 00:49:45

##JavaScript 

I've made it through both The Odin Project and Colt Steele's Web Developer Course- HTML and CSS portions. I just started JavaScript and now I see. Now we are talking. I am nervous but excited. I've found a few Discord communities I can hop in to ask questions or just network! 

##Web Dev or Bust? 
I am really glad I started here. While I'm enjoying building single page websites, I know that's not what I'm going to want to do forever. I want to be more on the "backend" of things. I plan to finish The Odin Project Fundamentals Course and really reflect on my journey up to that point. I've found myself drawn to Network Security and protocols. But hey.. right now everything is shiny and new and I want to learn it. I know this chapter of my life is just beginning.
Do you enjoy finding bugs?
Tags: qa, codereview
Published: 2022-06-01 09:40:42

---
title: Do you enjoy finding bugs?
published: true
date: 2022-01-09 00:00:00 UTC
tags: qa,codereview
canonical_url: https://jhall.io/archive/2022/01/09/do-you-enjoy-finding-bugs/
---

If you’re like me, you experience a small sense of elation when you spot a bug during a code review. Or maybe when you find a way to trigger a bug in some software a colleague wrote.

I recently heard a professional tester say “I love finding bugs!”

I do, too! Well, as long as they don’t get in the way of accomplishing a task or playing a game (I’m looking at you, Bethesda!)

But is this really a healthy attitude?

I once had a new joiner tell me “I’m looking forward to the day when I pass one of your code reviews on the first try!”

This got me thinking.

I never saw code review as a stage to “pass”. Clearly some do. And I don’t think that’s a good thing.

There are [many reasons for code review](https://jhall.io/posts/why-code-review/), but I think we can roughly summarize in: Code review exists to improve the quality of the product we produce.

“Gatekeeping” (via code review or QA testing) may appear to serve this purpose in the short term, but it also poses the significant risk of pitting reviewee against reviewer, or developer against tester. Such rivalaries invariably undermine product quality, by encouraging the producer of the work to hide defects, or take fewer risks.

Now far be it from me to chide you for experiencing joy from finding a needle in a haystack. I get that. Finding a bug can feel a bit like finding Waldo!

 ![](https://jhall.io/images/waldo_hu5a4690d078655fd1e7e846229f0042df_67369_350x0_resize_q85_box.jpg)

But maybe we can channel that energy in a more productive direction.

Rather than allowing a sense of Schadenfreude when we find fault, let’s celebrate the opportunity to improve the product’s quality.

* * *
_If you enjoyed this message, [subscribe](https://jhall.io/daily) to <u>The Daily Commit</u> to get future messages to your inbox._
How to use JavaScript Comments
Tags: javascript, webdev, beginners, tutorial
Published: 2022-01-08 23:33:45

## Fun Facts About Javascript
Brendan Eich created JavaScript in 1995, and it became an ECMA standard in 1997. The standard's official name is ECMA-262. The language's official name is ECMAScript. 

In this post, I will be looking at comments and how they are used in javascript. Lets get started!

## What are comments in javaScript
In JavaScript, comments are used to provide annotations to your code to help anyone trying to read it understand it. They can also be used to deactivate sections of code without deleting them. 

Comments are made by putting // before a single line or /* before and */ after several lines of codes.A variety of computer languages include the ability to comment on code as a standard feature. 

## Single Line Comment
Single-line comments in javascript are used to comment a portion of a line or a whole line of code. You can use it to either explain or debug the code (commenting out to stop the browser from reading the executing the line of code).  I've provided an example of a before and after commenting out a line of code below:


![Before comment](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/kpk0iqsk9y1t2pdoxzw1.png)

![After comment](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ggj7wvv0wxsajk7o8qia.png)


To comment out a line of code on Mac: 
Select the line of code
On your keyboard, press the command and / keys together 
Its the same on windows, the only difference is instead of command button it will be control on windows.

## Multi-Line Comment
Comments that span multiple lines begin with /* and conclude with /. JavaScript will ignore any text between /* and */. To clarify the code, the example below uses a multi-line remark: 

![Multi-Line comment](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ybfab8ti116m7uuit0z1.png)

Thanks for reading!