Hacker News Reader

Comment by donatj | Hacker News Reader

It's interesting that they're actively promoting using it with a shebang. I find it pretty appealing.

Go prior to modules worked really well this way and I believe Ubuntu was using it like this, but the Go authors came out against using it as a scripting language like this.

View on HN

The author's didn't come out against it; they came out in favor of using it as a programming language first and foremost. Tools like gorun https://github.com/erning/gorun have existing for almost as long as Go has, so if you want to use Go that way, it is easy to do. They recently added in support to do this: go run github.com/kardianos/json/cmd/jsondiff@v1.0.1 Which pulls a tag and runs it directly, which is also kinda cool.

I used to work for a .NET shop that randomly wrote some automation scripts in bash. The expertise to maintain them long term (and frankly, write them half-decently to begin with) simply wasn't there. Never understood why they didn't just write their tooling in C#.

Maybe this will make it seem like a more viable approach.

Or just use powershell. It has some idiosyncrasies but its a pretty nice platform for scripting

Especially for C# developers. You can use any CLR (e.g. C#) objects in powershell, for prototyping, automation, proof of concept, etc.,.

Here’s the really annoying thing with powershell: it doesn’t have a module distribution model. Like, at all. A csharp script, on the other hand, gets NuGet out of the box.

What is the PowerShellGet module[1] missing? It comes preinstalled in all versions post 5.1 (though 5.1 itself is limited).

[1]: https://learn.microsoft.com/en-us/powershell/module/powershe...

TFW where you're dead wrong and have to upvote everyone who told you so...

False: https://www.powershellgallery.com/

Not only it has modules, there are several NuGet like repos for Powershell.

It is reasonably unlikely that bash scripts are easily replaceable by powershell scripts.

Theres a fair argument that complex scripts require a complex scripting language, but you have to have a good reason to pick powershell.

Typically, on non-windows, there is not one.

Its the same “tier” as bash; the thing you use because its there and then reach past for hard things. The same reason as bash.

Theres no realistic situation I would (and Ive written a lot of powershell) go, “gee, this bash script/makefile is too big and complex, lets rewrite it in powershell!”

To this day, error handling in most Unix shells just sucks. Background commands, pipes, command substitutions, functions, if/while conditions, subshells, etc. are all "special cases" when errors are involved. You can make them suck less but the more you try to handle all the possible ways things can fail, the vastly more complex your code becomes, which the Bourne lineage languages just aren't ergonomically suitable for.

I think PowerShell was totally right to call this out and do it better, even though I don't particularly love the try-catch style of exception handling. False is not an error condition, exceptions are typed, exceptions have messages, etc.

The problem with PowerShell coming from bash etc. is that the authors took one look at Unix shells and ran away screaming. So features that were in the Bourne shell since the late 1970s are missing and the syntax is drastically different for anything non-trivial. Other problems like treating everything as UTF-16 and otherwise mishandling non-PowerShell commands have gotten better though.

Bash is the tool that’s already there; that is always a real good reason to use it.

Dotnet is a pig with its dependencies by comparison.

> Bash is the tool that’s already there; that is always a real good reason to use it.

If you are a dotnet dev shop, it is quite likely that dotnet is also a tool that is already there the places you need automation.

Plus, its also the tool that is already there in your team’s skillset.

I am an old hat. I've been in dotnet dev land for decades and still use bash (git bash).

Pros:

Syntax + access to familiar shell commands

Cons:

Bash scripts are not easy to maintain.

Not an old hat. in the dotnet world for 3 years, bash over a decade. Agree with bash not being easy to maintain.

Argument about bash being always there breaks down quickly. Even if you limit yourself to bash+awk+grep, they dont work consistently across different bash flavors or across platforms (mac/win/linuz).

My approach now is to have my programs, in the language most convenient to me, compiled to a bunch of archs and have that run across systems. One time pain, reduces over time.

> Argument about bash being always there breaks down quickly. Even if you limit yourself to bash+awk+grep, they dont work consistently across different bash flavors or across platforms

IMO this is why Perl was invented and you should just use Perl. Bash isn't portable and isn't very safe either. If you're only going to use a couple of commands, there's really no reason to use bash. The usecase, in my head, for bash is using a variety of unix utils. But then those utils aren't portable. Perl is really great here because it's available on pretty much every computer on Earth and is consistent.

Except Windows, of course. You can install it there but it's plainly obvious it's in a foreign environment.

A lot of people focus on Perl's bad reputation as one of the first web languages instead of its actual purpose, a better sh/awk/sed. If you're writing shell scripts Perl's a godsend for anything complex.

I worked at a dotnet shop a few years ago back. We still used bash over powershell unless we required COM

There's still version/dependency hell (one thing wants 6, one thing wants 8, one thing wants 8.1, etc.).

This can be managed but you have to manage it.

(A fanatical commitment to backwards compatibility can make this a lot easier, but it doesn't seem to me that dotnet has that.)

Sure, but these days so is Python. And you've got a dozen other languages available after a single command. You wouldn't recommend using a kitchen knife instead of a chainsaw to cut down a tree just because it's already there, would you?

Bash has a huge number of footguns, and a rather unusual syntax. It's not a language where you can safely let a junior developer tweak something in a script and expect it to go well. Using a linter like ShellCheck is essentially a hard requirement.

If you're working in a team where 99.9% of the code you're maintaining is C#, having a handful of load-bearing Bash scripts lying around is probably a Really Bad Idea. Just convert it to C# as well and save everyone a lot of trouble.

> Bash has a huge number of footguns, and a rather unusual syntax. It's not a language where you can safely let a junior developer tweak something in a script and expect it to go well.

I'd say as someone who started with shell/bash in ~ 2000 to cater Linux systems, it's quote usual syntax and I believe that's true for many sysadmins.

No way I'd like to deal with opaque .Net or even Go stuff - incapable of doing "bash -x script.sh" while debugging production systems at 3AM. And non production as well - just loosing my time (and team time) on unusual syntax, getting familiar with nuget and ensuring internet access for that repos and pinging ITSec guys to open access to that repos.

> let a junior developer tweak something in a script and expect it to go well

let developers do their job, writing bash scripts is something extraordinary for dev team to do, just because - where they expected to apply it? I can imagine "lonely dev startups" situations only, where it may be reasonably needed

>Dotnet is a pig with its dependencies by comparison.

Dotnet with all dependencies you will get in how much time? In like 6 minutes including all the preparations? So the difference between "already there" and dotnet - is 6 minutes. It's hard to imagine a case where this difference matters.

Its trivial to install a consistent PowerShell environment on the major OSes. Not so for Bash.

If you write to POSIX it's a lot more portable. If you're doing something outside POSIX, it's probably best to use something else, like Perl.

...Or powershell!

Besides, the trick is knowing what is POSIX compliant and portable, and what isn't. A lot of things will almost work.

Knowing stuff is what we're paid for, otherwise we'd all be making minimum wage. Besides, there are plenty of non-bash shell scripting resources out there, which is good to learn if you want to work with the BSDs or proprietary UNIX systems.

Powershell on UNIX is like Perl on Windows. It works, but it's weird and alien. But the same can be said for .NET, really.

I wonder where the divide of "shebang" vs "hashbang" lands geographically and chronologically, During college and for many years in the early 90s and 2000s in the south it commonly called hashbang, didn't hear shebang until C# became a thing, I know it predates that, just never heard it before then.

I believe the dividing moment came with Ricky Martin circa 2000.

Lame joke aside, I only heard "shebang" prior to around that time, then "hashbang" and now I get a mix of it. Google trends indicates "shebang" always dominated.

It's kind of the same with the # symbol. I call it the pound sign but some people call it hash.

In my head I translate an old Swedish term: "timber yard" (from Brädgård). Everything to make interacting with other hard I guess. As a kid we also called it staket, which translates to "fence".

I can see the fence and timber yard imagery.

Interesting, I’ve never even heard it called “hashbang” until you just did.

California, 40yo fwiw

I was a Unix sysadmin back in the late 90’s in east coast US and we called it a shebang when writing shell or perl scripts

I always found it interesting as the sharp term including C# was odd because it isn't the sharp symbol, which is ♯. All of them use the # hash character, so calling it sharp always seemed odd to me, though C-Hash also doesn't roll of the tongue admittedly. It is also interesting how hash is correctly used in some places "Hash Tag" but not others.

It's supposed to be the sharp symbol; it's just that it was a hassle for them to use it consistently in paths etc, so they defaulted to # as a stand-in.

It's "sharp" (i.e. higher tone) because it's a higher-level language compared to C and C++.

In 2010 I met a person from India who pronounced it "C pound", and they were as confused by my reaction as I was by their pronunciation. I guess somehow that pronunciation became popular enough that it acquired momentum and everyone in their circle (or maybe all of India?) assumed it was correct. The # key on the phone is called the "pound key" in India, which is where it would've started from, and I guess they never heard any foreigner Youtube video etc pronouncing it.

I don't know if they still pronounce it that way or not.

I started using C# towards the end of the 1.0 beta or maybe just after RTM...I embarrassingly called it "C pound" for quite a while. Because, even as someone born and raised in the US, pretty much my only exposure to the symbol was in the context of phones. "Call me at blah, pound one-two-three" as in the extension is "#123".

Remember, it was originally release +20 years ago (goddamn, I feel old now); recorded video or even audio over the internet were much, much, MUCH rarer then, when "high-speed" speed internet for a lot of people meant a 56K modem.

Back then, most developer's first exposure to C# then was likely in either print form (books or maybe MSDN magazine).

Not alone, also got those CDs for MSFT partners only, with the draft documentation written in red, before it became know to the outside world?

Also got a few of those magazine CDs, in some box.

I was always partial to "C octothorpe".

https://en.m.wiktionary.org/wiki/octothorpe

The "#" key on the phone is called the "pound key" in the US and Canada.

https://en.wikipedia.org/wiki/Number_sign#Names

It still is, to this day: if you call an automated system such as voicemail, you may be prompted to "press 'pound'". This is really standardized, AFAICT, and no telephone system has told me to "press hash" or "press the 'number' key" [because that's ambiguous]

cks has a history of #! but not an etymology: https://utcc.utoronto.ca/~cks/space/blog/unix/ExecAndShebang...

He links to Wikipedia which documents a good history: https://en.wikipedia.org/wiki/Shebang_(Unix)#History

I was trying to recall what we called it. I used SVR3, so I would've been using "#!/bin/sh" as early as 1990, and even more on SunOS 4 and other Unix servers.

I can't recall having a name for it until "hash-bang" gained currency later. We knew it was activated by the magic(5) kernel interpretations. I often called "#" as "pound" from the telephone usage, and I recall being tempted to verbalize it in C64 BASIC programming, or shell comment characters, but knowing it was not the same.

"The whole shebang" is a Civil-War-era American idiom that survived with my grandparents, so I was familiar with that meaning. And not really paying attention to Ricky Martin's discography.

Wikipedia says that Larry Wall used it in 1989. I was a fervent follower of Larry Wall in the mid-90s and Perl was my #1 scripting language. If anyone would coin and/or popularize a term like that, it's Just Another Perl Hacker,

Likewise, "bang" came from the "bang path" of UUCP email addresses, or it stood for "not" in C programming, and so "#!/bin/sh" was ambiguously nameless for me, perhaps for a decade.

Come to think of it, vi and vim have a command "!" where you can filter your text through a shell command, or "shell out" from other programs. This is the semantic that makes sense for hash-bangs, but which came first?

> "bang" came from the "bang path" of UUCP email addresses

"Bang" was in common use by computer users around 1970 when I was working at Tymshare. On the SDS/XDS Sigma 7, there was a command you could use from a Teletype to send a message to the system operator on their Teletype in the computer room. I may have this detail wrong, but I seem to recall that it included your username as a prefix, maybe like this:

  GEARY: CAN YOU LOAD TAPE XYZ FOR ME?

What I do remember clearly is that there were also messages originated by the OS itself, and those began with "!!", which we pronounced "bang bang". Because who would ever want to say "exclamation point exclamation point"?

The reason this is vivid in my mind is that I eventually found the low-level system call to let me send "system" messages myself. So I used it to prank the operator once in a while with this message:

  !! UNDETECTABLE ERROR

I was proud of calling it an "undetectable" error. If it was undetectable, how did the OS detect it?

Indeed. I joked on slashdot that C# was pronounced “cash” back when it was first announced, which seemed appropriate given the company.

The joke didn’t land, sadly.

It lands for me, today :)

This can also be done with Rusts cargo. Though it's not yet stabilized: https://rust-lang.github.io/rfcs/3424-cargo-script.html

The builtin subcommand is unstable, but a long time ago a dev I knew at the time maintained an external subcommand for it. https://crates.io/crates/cargo-script

Although it's old and its dependencies are old, it doesn't have a dependency on cargo (it spawns cargo as a subprocess instead of via cargo API directly), so it might still work fine with latest toolchain. I haven't tried myself.

Reply on news.ycombinator.com