DEV Community: HornGang

Relationship or ability, both of these criteria are used

HornGang — Sun, 06 Oct 2024 18:45:21 +0000

In society, when evaluating a person's ability and value, there are often two different criteria: one is "based on relationships" and the other is "based on ability". Both standards are embodied in different cultures, industries, and personal values, each with its own supporters and detractors.

Within programming languages, there are two kinds of standards that organize code in different ways, linking data structures to functions. This article will briefly discuss the application and principle of action of these two common standards.

class model

In the Javascript language, the class keyword is provided, which we can use to define classes. Importantly, classes are extensible, and when methods are called on an instance, they look up method definitions in the order of the prototype chain. For example:

class Animal {
    move() { return 'move' }
}
class Monkey extends Animal {
    jump() { return 'jump' }
}
class Human extends Monkey {
    write() { return 'write' }
}

extends Keywords can help us define a new class that extends from other classes. We can get the prototype chain like this:

let me = new Human()
let proto = me.__proto__
let r = []

while (proto !== null) {
    r.push(proto.constructor.name)
    proto = proto.__proto__
}

We'll get r like this: ['Human', 'Monkey', 'Animal', 'Object']. When we call a method, the success of the method call depends on whether there is a corresponding definition on the prototype chain. For example, if you call me.move(), it has a definition in the Animal class, and the call succeeds.

This is the class model, which I like to call as a "relational" model, which can be called as long as it is defined in the class of the instance itself, or in the parent class, grandparent class, and so on.

Competency-based model

Compared to the relationship-based model, the competency-based model is much simpler. As long as an instance satisfies a certain trait, the corresponding method can act on the instance regardless of the relationship of the instance.

let me = {
    moveable: true,
    freezable: false
}

function move(x) { return x.moveable ? 'move' : undefined }
function freeze(x) { return x.freezable ? 'freeze' : undefined }

In this model, data and methods are independent of each other. The advantage is that it is concise and straightforward, but the disadvantage is obvious, because of the independence of the method and the data, it is difficult to override the method definition.

summary

After introducing the two ways of connecting data structures and methods, we can think that when it is necessary to implement methods with different functions of the same name according to the class of the data, it is recommended to use the relational class model. When the method is usually relatively fixed, and the data is changeable, and the same method works on different data, the Competency-based model can be used.

It’s not that hard! To understand `Promise` in javascript

HornGang — Tue, 24 Sep 2024 16:35:45 +0000

The content of this article is very suitable for Javascript beginners. It will be described in simple and easy-to-understand language, so you don’t have to worry about not understanding it.

`Promise`, why do you exist?

Promise is an indispensable knowledge point when learning modern Javascript language. Many people feel confused when reading it. The main reason can be summarized in one sentence:

The code is no longer executed from top to bottom.

Normally, the code we write is executed sequentially, for example, we write a code that counts from 1 to 3.

console.log(1)
console.log(2)
console.log(3)

Press F12 to open the console of our browser, copy the above code into it, press Enter, and you can see that the numbers 1 to 3 are printed out in order.

1
2
3

Now, if we have a requirement that the order of the codes cannot be changed, but the order of the final printouts must be independent of the order of the codes, can we do this?

Let's imagine that if 1, 2, and 3 are printed by three people respectively, then it will be very simple. We just need to tell them the task of printing numbers at the same time, and the order of the printouts will only be related to the execution time of the tasks.

Promise, the magical effect

So, how do we assign the printing task to three people? This is where is used Promise. By creating a new Promise object, we can assign a section of code to a new "process" instead of executing it on the current "process". Note that the "process" here is not the same as the operating system process we often talk about, but is just an abstract concept, representing a virtual unit that executes code in sequence.

Promise, Assembly Instructions

As we said just now, Promise it can be regarded as a new "process", so if we want it to execute any code, we can wrap it in a function and give it to it. In this way, the code will not be executed immediately.

Promise also provides us with two functions, one is resolve and the other is reject, which we can call when the task is completed and failed respectively. These two functions are passed to Promise's internal of as parameters. So, we can assemble one like this:

Promise(
  (resolve, _reject) => {
    setTimeout(() => {
      console.log(1)
      resolve()
    }, 300)
  }
)

Here we use setTimeout to simulate a time-consuming task. In real scenarios, this task may be reading a file, requesting a network interface, or waiting for user input. When the task is completed, we call resolvethe function to indicate that the task has been completed.

Complete code

Then, we follow the same method, and Promise when we assemble the other two, we only need to provide them with different print numbers and the time required for the task. Finally, the complete code is like this, you can try to copy it into the console and give it a try.

Promise(
  (resolve, _reject) => {
    setTimeout(() => {
      console.log(1)
      resolve()
    }, 300)
  }
)
new Promise(
  (resolve, _reject) => {
    setTimeout(() => {
      console.log(2)
      resolve()
    }, 200)
  }
)
new Promise(
  (resolve, _reject) => {
    setTimeout(() => {
      console.log(3)
      resolve()
    }, 100)
  }
)

Finally, the order in which the numbers are printed is related to the execution time of the tasks:

3
2
1

Promise, Concurrency Model

Concurrent programming is about how to simulate the execution of a large number of tasks simultaneously on a limited number of CPU cores. Promise in Javascript provides a convenient and fast way of concurrent programming, as well as a set of specifications for handling return values and error values. After understanding and becoming familiar with this specification, we can greatly improve the efficiency of handling concurrent tasks.

Deploy a BitcoinSV node with docker

HornGang — Fri, 08 May 2020 11:28:53 +0000

BitcoinSV is an original bitcoin protocol implementation. We can use it as a reliable money transfer process, or secure data storage.

For normal users, run a BitcoinSV node is not very convenient or cheap. It needs a large disk space to store the block data. But the node is the most secure way to communicate with blockchain for enterprise users nowadays. Because the node will check the Merkel tree of transactions and validate the transaction script. And detected the longest chain for you.

N-chain has distributed a docker image of the BitcoinSV node. So we can easily deploy it in our development or production environment. First, make sure you have installed docker. Then pull the image.

docker pull bitcoinsv/bitcoin-sv

This is the start command for bitcoins 1.0.3 .

docker run -d \
-p 8332:8332 \
-v $(pwd)/data:/data \
--name bitcoind bitcoinsv/bitcoin-sv bitcoind \
-server \
-rpcuser=user \
-rpcpassword=password \
-prune=25000 \
-excessiveblocksize=2000000000 \
-maxstackmemoryusageconsensus=200000000

You can set a more secure RPC username and password. The exact meaning of the last two settings can be viewed on bitcoinsv.io.

After running the command above, the BitcoinSV node will be running in the background. Run docker ps to check.

Now you can use the RPC interface via localhost:8332.

curl --user user --data-binary '{"jsonrpc": "1.0", "id": "curltest", "method": "getblockchaininfo", "params": []}' -H 'content-type: text/plain;' http://localhost:8332

To check the latest 100 lines of logs:

docker logs --tail 100 bitcoind

To stop the node:

docker stop bitcoind

To delete the container:

docker rm /bitcoind

Make learning JS basic methods as game tasks

HornGang — Sat, 27 Jul 2019 15:54:49 +0000

When I begin to learn JavaScript, I often feeling tired with searching document. I spent a lot of time in looking for a simple function in standard lib. Till one day, I can't stand wasting time in this anymore. Why not remember all of them in my head, I thought.

But remember the functions in std lib is a boring job. To add some fun in doing that, I worte a simple script, that will generate a todo list, with js methods name and the link to that method's MDN document.

const FundamentalObjects = [
    Object,
    Function,
    Boolean,
    Symbol,
    Error
]

const NumbersAndDates = [
    Number,
    BigInt,
    Math,
    Date
]

const TextProcessing = [
    String,
    RegExp
]

const IndexedCollections = [
    Array,
    Int8Array,
    Uint8Array,
    Uint8ClampedArray,
    Int16Array,
    Uint16Array,
    Int32Array,
    Uint32Array,
    Float32Array,
    Float64Array,
    BigInt64Array,
    BigUint64Array
]

const KeyedCollections = [
    Map,
    Set,
    WeakMap,
    WeakSet
]

const StructuredData = [
    ArrayBuffer,
    SharedArrayBuffer,
    Atomics,
    DataView,
    JSON
]

const ControlAbstractionObjects = [
    Promise,
    // Generator,
    // GeneratorFunction,
    // AsyncFunction 
]

const Reflection = [
    Reflect,
    Proxy
]

const Internationalization = [
    Intl,
    Intl.Collator,
    Intl.DateTimeFormat,
    Intl.ListFormat,
    Intl.NumberFormat,
    Intl.PluralRules,
    Intl.RelativeTimeFormat,
    Intl.Locale
]

const WASM = [
    WebAssembly,
    WebAssembly.Module,
    WebAssembly.Instance,
    WebAssembly.Memory,
    WebAssembly.Table,
    WebAssembly.CompileError,
    WebAssembly.LinkError,
    WebAssembly.RuntimeError
]


const ObjectsToLearn =
    FundamentalObjects
    .concat(NumbersAndDates)
    .concat(TextProcessing)
    .concat(IndexedCollections)
    .concat(KeyedCollections)
    .concat(StructuredData)
    .concat(ControlAbstractionObjects)
    .concat(Internationalization)
    .concat(WASM)

const listMethodsOf = (object) => {
    try {
        return Object.getOwnPropertyNames(object.prototype)
            .filter(f => !['caller', 'callee', 'arguments'].includes(f))
            .filter(f => {
                try {
                    let bool = typeof(object['prototype'][f]) == 'function'
                    return bool
                } catch (e) {
                    return false
                }
            })
    } catch (e) {
        return []
    }
}


let r =
    ObjectsToLearn
    .filter(o => o.name)
    .map(o => '# ' + o.name + '\n' +
        listMethodsOf(o)
        .map(f => '- [ ] [' + f + '](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/' + o.name + '/' + f + ')')
        .join('\n')
    )
    .join('\n')

console.log(r)

Then copy the content in console, and paste in your gist, you just got a clickable todo list of all methods of main objects in JavaScript (Browser). You can visit the result here: https://gist.github.com/Ljzn/d93dae3de64660e66be598ee88fa57be .

Happy Coding!

2019.08.06 Update:

I changed the code into two functions: "listOfJSObjectsDoc" and "listOfWebAPIDoc".

const listMethodsOf = (object) => {
    try {
        return Object.getOwnPropertyNames(object.prototype)
            .filter(f => !['caller', 'callee', 'arguments'].includes(f))
            .filter(f => {
                try {
                    let bool = typeof(object['prototype'][f]) == 'function'
                    return true
                } catch (e) {
                    return false
                }
            })
    } catch (e) {
        return []
    }
}


const listOfWebAPIDoc = modules =>
    toDoc(modules, 'https://developer.mozilla.org/en-US/docs/Web/API/')

const listOfJSObjectDoc = modules =>
    toDoc(modules, 'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/')

const toDoc = (modules, baseURL) =>
    modules
    .filter(o => o.name)
    .map(o => '# ' + o.name + '\n' +
        listMethodsOf(o)
        .map(f => `- [ ] [${f}](${baseURL}${o.name}/${f})`)
        .join('\n')
    )
    .join('\n')

Example:

let modules = [MediaStream, MediaStreamTrack]

console.log(listOfWebAPIDoc(modules))

You can try this in https://jsbin.com/dujeril/1/edit?js,console .