Hacker News Reader

It was weird for me at first, but actually Rust provides a great solution here.

With https://github.com/DanielKeep/cargo-script you can have single file Rust "scripts" with ecosystem dependencies.

When executing the file (via the cargo-script wrapper), dependencies are fetched and a binary is compiled on demand (and cached for re-runs).

It's pretty awesome for scripts where type safety is important.

    #!/usr/bin/env run-cargo-script
    //! This is a regular crate doc comment, but it also contains a partial
    //! Cargo manifest.  Note the use of a *fenced* code block, and the
    //! `cargo` "language".
    //!
    //! ```cargo
    //! [dependencies]
    //! time = "0.1.25"
    //! ```
    extern crate time;
    fn main() {
        println!("{}", time::now().rfc822z());
    }

Then you can just execute it with ./my-script, which will download dependencies, compile and execute.

Likewise with Apache Groovy, which has optional typing:

    #!/usr/bin/env groovy
    // @Grab annotation won't work in scripts
    import static groovy.grape.Grape.grab
    grab(group: 'org.apache.commons', module: 'commons-csv', version: '1.5')
    
    println "Starting to parse CSV"

Kotlin can do it, too: https://github.com/holgerbrandl/kscript

Thanks for sharing that, I had no idea. You just improved my day.

Have a look at https://nim-lang.org .. you might like it

Author here. That's roughly what I was shooting for. Python was a big inspiration early on in the design, and later on some functional concepts were put into the mix. I found them and liked them too much to pass up on.

One advantage of Lily not mentioned (with regard to typing), is that the type-checking is very fast. One of the reasons I made Lily interpreted and homebrewed all the parts was because as much as I like static typing, it's often slow. Slow static typing, I think, diminishes some of the value of it since you're still waiting but in a different way.

Linters should catch most typos; failing that, Python's type hints are a pain to use, but you can address a lot of low-hanging fruit for free.

I think for your use case though, Go would be perfect. Everything is statically compiled, so you don't need to mess with virtualenvs, and everything is statically typed ahead of time. I'm a professional Python developer, but I often do my prototyping in Go because the type system is more ergonomic than Python/mypy.

If you're writing a lot of command line scripts and want some of the safety offered by types, but still want the flexibilty of python (+ more flexibility), you should check out perl6.

Gradual typing: https://perl6.party/post/Perl-6-Types--Made-for-Humans Command line arguments: https://perl6advent.wordpress.com/2010/12/02/day-2-interacti...

And at the end of the day it's perl, so it's the king of command line scripts.

Take a look at kscript, which is a single-file wrapper around Kotlin that includes dependency specification in the script file: https://github.com/holgerbrandl/kscript

Example:

    #!/usr/bin/env kscript
    // Declare dependencies
    @file:DependsOn(“com.offbytwo:docopt:0.6.0.20150202“)
    import org.docopt.Docopt
    val usage = “...”
    val doArgs = Docopt(usage).parse(args.toList())

    println("Hello from Kotlin!")
    println("Parsed script arguments are: \n" + doArgs)

> I took a look at Scala but instead of virtualenv style dependency management it's more like maven projects.

You could do virtualenv style by setting the CLASSPATH environment variable if you really want. The ecosystem tends to prefer using explicit dependencies though.

> It has Ammonite where you can declare dependencies at the top of files but that seems kind of hacky.

Sort of, but I don't think you'll do better anywhere else. Lots of other replies are suggesting various languages that do essentially the same thing - a magic comment at the top of the file that declares your dependencies.

HN reads as: "Hey everyone, get in here and post your favorite language!"

Nim lang. Nothing would beat it if you like python

I'm currently learning shelly haskell library. I tried to write a function in a haskell-emacs module and calling it as a elisp function in a eshell buffer and it worked flawlessly first try.

Depending what you want, using

go run source.go

gives you the compile time checks, while still giving you the source code visibility and simplicity of scripts

I took a look at Go but it seems to be more of a systems language than a scripting language and I assume that means it's less amendable to "This guy across the country needs this information in 2 hours max".

People say that about Go while I don’t have an opinion. I don’t understand what you mean by your example

The point of my example is that my main priority is coding speed, and other things are an issue only if processing takes a long time. A systems language typically has a much slower coding speed than say, python, which is what I mainly use now.

I suppose that print statement was just a silly example, but just in case this may be of use to anyone, note that you can pass multiple arguments to print and they will be printed space-separated, each converted to a str, so you will (practically) never run into type errors.

print(str, int)

True, that's a problem I don't have anymore but it's a quick and understandable example of a mistake that I think lots of people had made before.

Instead of a comma I would actually recommend f-strings, which are python's string interpolation. The only downside is that the code within the f-strings I think have even less prechecking.

https://www.python.org/dev/peps/pep-0498/

Example: print(f"There are {len(lights)} lights!")

I absolutely agree that f-strings are excellent for formatting, but I don't quite understand why you would use formatting in a regular print statement, when you could just stick to the commas and let the concatenation happen naturally in the output buffer?

print("There are", len(lights), "lights!")

You can look at https://nim-lang.org/