You are so right. When I saw the link I thought: "That could be fun, lets take a look how it displays the data". But when I saw that it uses node.js I thought "Oh my god, who had this brilliant idea to write it with node"...

Hey guys, please use rust, golang, haskell or whatever you like, but please do not use nodejs to write CLI tools.

And I am not one of the guys who is against JS in general. In fact, I like building PWAs and other JS heavy apps/websites a lot. But there are so many tools do a better job at building cli programs.

I don't get the hate here, Node works great for CLI tools.

Easy and quick install, supports colors and icons in the terminal, has several easy and useful table libraries to choose from, and it runs plenty fast enough for it's use case.

What benefits would rust, golang, haskell, or whatever you like provide over node in this situation?

I wouldn't call it hate. It is more like 'wtf, please don't do that' ;-)

Actually, you can write cli tools with js, it's just that in most cases it is not a good choice. There are some reasonable cli tools which can be written in js e.g. js dev-tools like rollup, gulp, grunt, etc. But I would not consider Coinmon a js dev-tool ;-)

When you say 'Easy and quick install' thats not completely true. First of all it assumes that you have a js package manager installed already (npm/yarn), which is not preinstalled on most OS. So yes, nowadays thats not too much of a hassle. But from a package manager perspective npm itself is a disease as it does not integrate with the system package manager so your system is not completely up to date after you told your package manager to update all package. Instead you have to start npm to let it run its own updates. Sometimes even that is not as simple as it could be because frontend-devs tend to advise to install npm packages locally (within a project) instead of globally (once per system).

I think we could continue this discussion for a while as there are many more arguments to be evaluated (not everything about npm is bad), but ultimately we will find out, that other languages would be a better fit for such tools.

Again, my initial commment was meant as 'advice' and not as 'hate'. Yes I know, nobody asked for advice ;-)

Also a NodeJS fan in general, but prefer to install/develop cli's with golang instead of node just because you get a compiled, static binary that works cross-platform. Faster for users to install, less bloaty and works on all platforms without any dependencies.

I personally usually use Python, Bash, or C, but there is a utility for packaging NodeJS tools into executables. I think it does some tree-shaking as well. Disclaimer: I haven't used it, so I'm not sure of the results. But it is possible.

https://www.npmjs.com/package/pkg

edit: For the curious -- Just tried on a really simple script that just takes one argument and writes it with some text to STDOUT and it still came to 35MB. So it must package a bunch of Node with it. I won't be leaving my go-to's for it anytime soon unless usability and development speed necessitate it. Going to have to go with the, best to not use NodeJS for general cmd-line utils outside of the NodeJS environment. The one perk is that it will, by default, output executables for Linux, macOS, and Windows.

Source:

    (function() {
    'use strict';

      function main(_string) {
        console.log(`${_string} was read from STDIN.`);
      }

      main(process.argv[2]);

    }());

Output file:

    35088858 Nov 20 11:36 index-linux
    35717043 Nov 20 11:36 index-macos
    23137020 Nov 20 11:36 index-win.exe

Thats because PKG is including the Node runtime in the binaries, this way users don't have to install Node itself to run them.

I'm using it myself and besides the fat binaries and the fact that you have to write Javascript, it is really good. (Working on replacing this daemon with Go ASAP)

Edit: just read your last line, I'm kinda stating the obvious here.

I'm quite confident that "whatever you like" does not benefit versus NodeJS anyway.

And of course you should write cli tools with whatever you feel comfortable.

If you want them to be well-received by everyone, well that's a different topic.

Node is fine, and I don't agree with the hate, but Rust and Go would both give you a single binary that just runs everywhere. Not everyone already has Node installed.

I get what adtac said, but, "not use node for cli tools?" Come on, so if I only know JavaScript and I want to build a cli tool for personal use that can later open source, shouldn't do it because the language?

That's not the hacker mentality, you can write a cli tool with JavaScript, Python, Lua, etc., make it work and there's nothing wrong with it. If you want to go full deep into cli tooling, then you start to looking into other languages that can fit into your new requirements.

Thanks a lot for the comment. This is actually a practice work when I was reading this https://developer.atlassian.com/blog/2015/11/scripting-with-...

Which language (rust, golang, haskell) do you think it is more fitting? I am new to writing things running on command line @@

Very nice, thank you!

I'm not much into APIs or JS (CBA with auth tokens etc either) so I often forget the sheer power of jq.

I prefer to output the curl data 2>/dev/null so there's less noise and the data could be parsed further. I also want to default to eur, with the option of say usd. Finally, I want the currency to be shown as $2 and I want it uppercase.

I ended up with:

  coinmon() {
      local currency=$1
      case "$currency" in "") currency="eur";; esac
      data=`curl "https://api.coinmarketcap.com/v1/ticker/?convert=$currency" 2>/dev/null | jq ".[0] .price_$currency" | cut -d \" -f 2`
      echo "$data ${currency^^} "
  }

(Sorry for the scrollbar here on HN.)

One could also use tosheets [1] to put $data in spreadsheet or perhaps use something like gnuplot. One could also round $data to say 2 numbers behind the comma (or well, dot is being used in this case) to get a more human readable amount. This could also be implemented like df -h creates human readable output (see man df).

[1] https://news.ycombinator.com/item?id=15722108

That was my reaction to:

    npm install

Nah, i'm alright mate.

I prefer

    curl -s "https://api.coinmarketcap.com/v1/ticker/?convert=$1" |
	jq ".[0] .price_$1" | sed 's/\"//g'

for silent curl and no quotes in output. Unfortunately, this does add a third dependency to the script.

Indeed.. I'll probably write a Nim version as I prefer a single binary and not rely on having a JVM, Node, Python etc.. VM and associated libraries pre-installed.

I think its fair to rely on Python for Linux Distros. Ubuntu/Debian/Redhat all bundle python with the distro.

Where-as the JVM & Nodejs are generally seperate packages.

Java 9 though, allows you to ship zero-dep golang style binaries [1].

https://steveperkins.com/using-java-9-modularization-to-ship...

Nim beginner here. I wanted to see if I was capable of making an equivalent program in Nim. I'm still a bit confused about some of Nim's conventions and idioms, mostly revolving around when to use objects vs. ref objects, and how to properly construct an object. Care to take a look at my code and give me some pointers (heh)?

https://gist.github.com/anonymous/1e3d7045de67f59c676135fead...

>I don't know when/where nodejs development went wrong, but there's definitely something wrong.

Probably when they decided that every function and almost every statement and boolean check needed to be its own separate package with its own build system and test framework.

What's up with that API? Why is it a list of objects rather than an object of {"coin-id": {values}}? The way they return things, you have to walk the entire list to find the currency you're interested in.

Not necessarily the whole list though ;)

Here's a simple Python script with no dependencies other than the stdlib (adjust to taste):

https://www.pastery.net/jnscrh/

Now that's what I call a refactor! :D ty

and curl did not have dependencies?

The installation of coinmon and all its deps is faster, as i can your post.

But you are right, it uses incredible 33 MB of my disk space, so i now have only 300000 MB left. OMG doomed!

You're missing my point: nodejs is really not a suitable candidate for tiny CLI programs like this. If the author is just learning node, there's nothing wrong with it, of course.

In any case, the bash one-liner is just an alternative :)

Also, this kind of "it uses just 33 MB" culture is exactly what's wrong with node: 33 MB is small enough, but what about real programs? Would you still freely add trivial dependencies? This would get unwieldy very fast. There's also the security aspect that comes with relying on 61 dependencies. What if one of the dependencies is compromised (as it happened recently)?

And if we had exabyte drives, would there be nothing suspect about a CLI utility taking petabytes? Are we not engineers / programmers?