oil

Oils is our upgrade path from bash to a better language and runtime. It's also for Python and JavaScript users who avoid shell! (by oilshell)

Oil Alternatives

Similar projects and alternatives to oil

NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a better oil alternative or higher similarity.

oil reviews and mentions

Posts with mentions or reviews of oil. We have used some of these posts to build our list of alternatives and similar projects. The last one was on 2024-02-22.
  • Re2c
    4 projects | news.ycombinator.com | 22 Feb 2024
    This is sort of a category error...

    re2c is a lexer generator, and YAML and Python are recursive/nested formats.

    You can definitely use re2c to lex them, but it's not the whole solution.

    I use it for everything possible in https://www.oilshell.org, and it's amazing. It really reduces the amount of fiddly C code you need to parse languages, and it drops in anywhere.

  • Ask HN: Looking for a project to volunteer on? (February 2024)
    15 projects | news.ycombinator.com | 1 Feb 2024
    SEEKING VOLUNTEERS - https://www.oilshell.org/ - https://github.com/oilshell/oil/

    I'm looking for people to help fill out the "standard library" for Oils/YSH. We're implementing a shell for Python and JavaScript programmers who avoid shell!

    On the surface, this is writing some very simple functions in typed Python. But I've realized that the hardest parts are specifying, TESTING, and documenting what the functions do.

    ---

    The most recent release announcement also asks for help - https://www.oilshell.org/blog/2024/01/release-0.19.0.html (long)

    If you find all those details interesting (if maybe overwhelming), you might have a mind for language design, and could be a good person to help.

    Surveying what Python and JavaScript do is very helpful, e.g. for the recent Str.replace() function, which is nontrivial (takes a regex or string, replacement template or string)

    But there are also very simple methods to get started, like Dict.values() and List.indexOf(). Other people have already contributed code. Examples:

    https://github.com/oilshell/oil/commit/58d847008427dba2e60fe...

    https://github.com/oilshell/oil/commit/8f38ee36d01162593e935...

    This can also be useful to tell if you'll have fun working on the project - https://github.com/oilshell/oil/wiki/Where-Contributors-Have...

    More on #help-wanted on Zulip (requires login) - https://oilshell.zulipchat.com/#narrow/stream/417617-help-wa...

    Please send a message on Github or Zulip! Or e-mail me andy at oilshell dot org.

  • The rust project has a burnout problem
    3 projects | news.ycombinator.com | 17 Jan 2024
    This is true, but then the corrolary is that new PRs need to come with this higher and rigorous level of test coverage.

    And then that becomes a bit of a barrier to contribution -- that's a harness

    I often write entirely new test harnesses for features, e.g. for https://www.oilshell.org, many of them linked here . All of these run in the CI - https://www.oilshell.org/release/latest/quality.html

    The good thing is that it definitely helps me accept PRs faster. Current contributors are good at this kind of exhaustive testing, but many PRs aren't

  • Unix as IDE: Introduction (2012)
    3 projects | news.ycombinator.com | 27 Dec 2023
  • The bash book to rule them all
    5 projects | news.ycombinator.com | 25 Nov 2023
    No, I've been deep in the bash manual and source code during my work on https://www.oilshell.org, which basically reimplements a "cleaned up" spec-driven bash, as OSH.

    But I also used bash for 15 years before that, and I never really used the manual either. I got by with a minimal / sane dialect, and I read a few books about Unix and one about POSIX shell.

    The main recommendation I have for anyone who wants to learn bash is to learn Unix and C. Learning the underlying model explains many things, explains the bad error messages, and makes it easier to use.

    https://www.oilshell.org/blog/2020/04/comics.html - Three Comics For Understanding Unix Shell

    So yeah I don't think "learning shell" or "learning bash" is actually a great goal -- it's part of the operating SYSTEM, and you want to learn the OS, and its philosophy.

    related - https://www.oilshell.org/blog/2021/01/philosophy-design.html - Unix Shell: Philosophy, Design, and FAQs

  • I Accidentally a Scheme
    2 projects | news.ycombinator.com | 15 Nov 2023
    FWIW we also test the Oils GC with a X-to-Y to generator, where X is Python and not Scheme, and Y is C++ and not C :)

    For example here's some Python code to make various types of linked lists and traverse them, making sure the GC can follow all the pointers, with field inheritance, vtable pointers, etc.

    https://github.com/oilshell/oil/blob/master/mycpp/examples/c...

  • Servo announces grant from the NLnet Foundation
    3 projects | news.ycombinator.com | 9 Nov 2023
    Yes, my project https://www.oilshell.org/ has been funded by NLnet since 2022, and it's helped a lot. I needed some help to push through a few problems, and that happened :)

    It is very forward thinking since we happen to be mostly in North America, but the funding comes from the EU.

  • Making Hard Things Easy
    11 projects | news.ycombinator.com | 6 Oct 2023
    I have yet to find a proper replacement for bash. Especially for scripts.

    The two most common alternatives are 1) using some of the newer shells people have created, like Oil shell [0], or 2) using programming language like Python, JavaScript, or PHP.

    The problem with using a newer shell is that you'll have to install the new shell anywhere you want to use the script. Meanwhile bash is ubiquitous. Unless you're the only one maintaining the script, you're requiring others to learn the other shell to maintain the script.

    The problem with using another programming language is that they rarely have good ergonomics for doing what bash does: stringing together commands, command input, command output, and files. If you try to do that in another programming language, things suddenly get a lot more complicate or at least more verbose.

    So I still use bash, but I recognize that it's strength is in running other commands and dealing with I/O. If I'm doing complicated logic that doesn't involve that, then I'll offload my work to another language. Sometimes that just means calling a python script from bash, not avoiding bash completely.

    If people found that they work better by taking other approaches, the please share them.

    [0] https://www.oilshell.org

  • GitHub Actions could be so much better
    21 projects | news.ycombinator.com | 22 Sep 2023
    Exactly, I showed here how we just write plain shell scripts. It gives you "PHP-like productivity", iterating 50 times a minute. Not one iteration every 5 minutes or 50 minutes.

    https://lobste.rs/s/veoan6/github_actions_could_be_so_much_b...

    Also, seamlessly interleaving shell and declarative JSON-like data -- without YAML -- is a main point of http://www.oilshell.org, and Hay

    Hay Ain't YAML - https://www.oilshell.org/release/0.18.0/doc/hay.html

  • DSLs Are a Waste of Time
    2 projects | news.ycombinator.com | 4 Sep 2023
    FWIW this wiki page I started may help frame discussions like this:

    Survey of Config Languages - https://github.com/oilshell/oil/wiki/Survey-of-Config-Langua...

    It puts a bunch of languages in 5 cateogires.

    Terraform is at least not a YAML DSL, a very common pattern which I don't understand the appeal of. I guess the main appeal is that you can copy and paste, and pretend it's data in simple cases.

    But even Terraform suffers from the problem of "external" DSLs -- you end up needing a general purpose language. And yes this pattern has repeated itself so many times.

    Awk and Make both grew into general purpose languages, and in Make's case it's particularly bad.

    Most SQL dialects have also grown a pretty bad stored procedure language.

    So I do think making internal DSLs in general purpose languages is more promising. But they have to be designed for it. There have been many attempts to use Python as a DSL/config language, but it's missing a few things for that, and gets awkward pretty quickly.

    Ruby does a bit better, but it's not perfect either. It's fairly big and heavy if you just want a config file.

  • A note from our sponsor - Onboard AI
    app.getonboardai.com | 25 Feb 2024
    Onboard AI learns any GitHub repo in minutes and lets you chat with it to locate functionality, understand different parts, and generate new code. Use it for free at app.getonboardai.com. Learn more →

Stats

Basic oil repo stats
227
2,673
9.9
7 days ago

oilshell/oil is an open source project licensed under GNU General Public License v3.0 or later which is an OSI approved license.

The primary programming language of oil is Python.

ChatGPT with full context of any GitHub repo.
Onboard AI learns any GitHub repo in minutes and lets you chat with it to locate functionality, understand different parts, and generate new code. Use it for free at app.getonboardai.com.
app.getonboardai.com