Show HN: Jumpfiles – get more done with fewer keystrokes
github.com
github.com
This project looks like it is streamlining and organizing-per-project this kind of workflow / preference for short aliases, with helpful conventions like "?" that act sort of like a tab-completion hint.
In any folder, you put all your favorite One-liners for that folder into a file called “.ok”.
Then you can run them command with “ok 1” for the first command, or “ok 2” for the second command, etc. Use “ok” by itself to pretty-print all the available commands in that folder.
I started the project but my friend @doekeman took it waaay further than I ever dreamed.
It’s really helpful if you have a bunch of different projects that you work on, and need a way to remember all their different commands and incantations.
There’s a Powershell version too (ok-ps).
For there bit where I jump around from one project to another I use a system called markjump. It’s great too.
It’s lighter-weight. Not as cryptic. Can also hook it up to your makefile targets, make them easier to access.
The other thing people say is “isn’t that same as npm scripts?” — it can complement those as well.
I modify “cd” so that on entering any folder it shows me the available .ok commands, if any.
some-name:
some commandBut yeah, other than that Makefiles aren't cryptic :)
And yet, ok files are not a competitor to makefiles. Use both together.
The only additional “weight” in the Makefile would be the name of the target, where you leave it out and have it default to 1, 2, … n, which I would argue is more cryptic, as “make build” or “make deploy” is always doing that action, whereas “ok 2” could be deploy in one folder, and push in another.
As for easy access, most shells should offer you tab completion for the Makefile’s targets, and your development environment may also pick up the existence of the Makefile and offer a way to run the targets.
Additionally Makefiles allow to setup dependencies, for example in your ok file example you have ./build.sh and ./deploy.sh as two actions: Clearly build should be a dependency of deploy, so “make deploy” implies building, rather than having to always do “ok 1 && ok 2”.
Lastly there is the ability to do dry-runs with Makefiles, once you start to setup dependencies…
With ok you can also name the commands. It’s optional.
I would suggest using both, in a project that involves building, if you are already comfortable with makefiles. You may also have npm scripts, again I’d suggest both. You’ll probably find it quite comfortable and fun.
Makefiles have more features but bring with them more complexity and nuance, for example the dependency features, which are useful for making but a hindrance for a lot of other project tasks. When I show a “getting started with makefiles” guide to my documentation friend they look at me like I’m insane. It is truly cryptic to the uninitiated. But you already understand makefiles, so try using both.
I am still not going to add another tool that makes my project even more spaghetti than it already is.
Be sure to let me know when you put something out in the world. You’ll find that i come around and act in an encouraging manner and do not take pot shots at it without trying it out. Please do not be unkind.
What is it that ok files can do that Makefiles don’t?
I don’t buy your complexity argument, a Makefile can be as simple as:
1:
./build.sh
Although most people would name this “build” rather than “1”, so you “make build”.
And the equivalent ok file would be:
build: ./build.sh
Some of those have makefiles, some have cake, some have grunt, some have npm scripts. Many are pure documentation folders (books etc).
ok isn’t primarily a build system or a task runner, it’s a folder profile.
Asking “what can x do that y cannot do?” invokes the Turing tarpit. A better question is “why is it more pleasant to use x with or instead of y?” ...particularly since they can be used together.
* navigate to another folder/directory * set an environment variable
I use both make and ok. For me, if I want to "make" stuff, I use make (compile, sign, zip, deploy etc.). The ok-files, I use for ad-hoc stuff, like viewing log files). It's also a good command's I can't seem to remember. A bit less structured.
So I guess it's not only a technical difference, but also a slightly conceptual difference.
I must say I do have a lot of (rather) small git-repo's I work on. And not every day. So when I switch to some kind of project, it helps me work faster. But your situation might differ...
$ alias shortcut='common command'
$ r='/long/complicated/dir'
$ cd $r
$ pwd
/long/complicated/dir
$ a=echo
$ b=hello
$ $a $b
hello
Another nice thing is you environment bar secrets are only exposed during command execution when they are needed. (See how the .jumpfiles.secrets.sh is used) It's also largely an experimentation ground for some upcoming Hof features.
Jumpfiles got ephemeral VMs and k8s last night, so if you want to enable consistent dev envs and debugging, there are some options. Email me if you'd like to know more about what we are planning and some of the more leading edge capabilities.
- direnv (https://direnv.net) for project-specific environment variable management and more
- fzf (https://github.com/junegunn/fzf) for rifling through history and finding files quickly.
- z (https://github.com/agkozak/zsh-z) to partial-match on a frequency-weighted directory switch (eg, `z Proj <RET>` will move me to `$HOME/Code/Projects/`.
CDPATH The search path for the cd command. This is a colon-separated list of directories in which the shell looks for destination directories specified by the cd command. A sample value is ".:~:/usr".
This works with tab completion.
Take. A look at the Hof leap, there are some examples of jumping to a dir, found something, and then hopping back to where you were. Super useful for building tools you are working on but don't need the extra shell session