hv42

Exactly my experience as well. OSMAnd is a lot better for hiking as it has 3d views, hiking routes, topo maps and better routing in general. Comaps is great for city navigation or casual usage

https://github.com/CyberTimon/RapidRAW is rapidly going to be a nice cross-platform alternative to Lightroom

They seem to have less marketing for sure. If you are migrating from webpack or create-react-app, rspack/rsbuild is a no brainer. (at least worth a try IMO)

I am wondering what vite+ will have that will really make it worth it compared to the "rstack" (i.e. rspack, rsbuild, rstest, rslint, etc.) rsbuild is already excellent and things like remote cache are on their roadmap?

With GitLab, I have found https://github.com/firecow/gitlab-ci-local to be an incredible time-saver when working with GitLab pipelines (similar to https://github.com/nektos/act for GitHub)

I wish GitLab/GitHub would provide a way to do this by default, though.

One of the goal of hk is to be used with mise (https://mise.jdx.dev/dev-tools/)

mise supports an experimental bootstrapping feature: it can download itself and install the tools required for the project.

See https://mise.jdx.dev/cli/generate/bootstrap.html and https://mise.jdx.dev/continuous-integration.html#bootstrappi...

You will be able to use mise to set up any tools required for the linters. See https://mise.jdx.dev/dev-tools/

You can use this trick with mise (mise-en-place) for small tasks: https://mise.jdx.dev/tasks/toml-tasks.html#shell-shebang

  [tools]
  uv = 'latest'

  [tasks.python_uv_task]
  run = """
  #!/usr/bin/env -S uv run --script
  # /// script
  # dependencies = ["requests<3", "rich"]
  # ///

  import requests
  # your code here 
  """

I think you should give `mise` a chance. I believe it can help improve your workflow.

It's better at managing tools than `asdf`, very close to `direnv` and superior to `make` as a task runner (more verbose but much easier to understand). One of the advantages is that `mise` tasks can be standalone files (you can even write file tasks in python if you prefer, see https://mise.jdx.dev/tasks/file-tasks.html)

There is a plugin that works well to automatically configure some of the SDKs https://plugins.jetbrains.com/plugin/24904-mise

mise tasks (https://mise.jdx.dev/tasks/) are great!

IMO, mise tasks are much better than `just`. A few things that make mise superior:

— solid environment variables support

— can run tasks in parallel, has a watch task feature, support for skipping tasks,…

— mise supports file tasks (i.e., running shell scripts, as many comments are suggesting here - https://mise.jdx.dev/tasks/file-tasks.html)

— mise tasks are defined using `toml`, and not a custom syntax

Have a look at https://httptoolkit.com/ which works with a lot tools (even cli)

yeah... https://github.com/firecow/gitlab-ci-local is a good workaround but should be built-in. How do developers at GitLab/Github debug their workflows?

In case someone is wondering how to search local repositories with sourcegraph, see https://docs.sourcegraph.com/admin/external_service/src_serv... and https://docs.sourcegraph.com/admin/deploy/docker-single-cont...

  docker run --add-host=host.docker.internal:host-gateway --publish 7080:7080 --publish 127.0.0.1:3370:3370 --rm --volume ~/.sourcegraph/config:/etc/sourcegraph --volume ~/.sourcegraph/data:/var/opt/sourcegraph sourcegraph/server:5.1.2


  docker run --rm=true --publish 3434:3434 --volume $PWD:/data/repos:ro sourcegraph/src-cli:latest serve-git /data/repos

I found it really to be the perfect shell script replacement. People usually will use python for more complicated shell scripts but deno is just awesome at this. Just run the file and eventually cache the dependencies for the next run. No node modules or pip install etc Also, you can use typescript without any pre-bundling.

The security model works well for this use case also. If your shell script is only supposed to read a few environment variables and not make network calls, you are covered.

Gradle is a good make replacement as well. The kotlin DSL is much more readable and easier to follow than makefiles and has a lot of additional features.

People on this issue[1] have been asking themselves the same questions. New very specific features are added with every new releases. However, the Git/shelf experience is lacking the ability to commit specific lines.

[1] See this highly voted issue: https://youtrack.jetbrains.com/issue/IDEA-186988 (opened since more than 3 years already)

I would suggest to not use brew for anything that depends on python, ruby etc. Most of the time you can use e.g. asdf to manage all your dev dependencies. Also, most softwares allow you to install them without hombrew. (e. g. https://postgresapp.com/ for postgres). I have seen so many installations screwed up because hombrew upgraded some packages without requiring a confirmation from the user. It's a bit unfortunate given that so many packages are on hombrew.

You should be able to do this with IntelliJ e.g. where you can inject a language into a string. This is quite handy as you can reformat and open the string in a separate editor if needed.

The caveat is that it does not work well if you are composing the SQL queries from multiple small parts.

see https://www.jetbrains.com/help/idea/running-injected-sql-sta...

I suppose that other editors or IDE can do similar things.

That's really cool!

What's the process around adding new apps? Would one be able to integrate easily?

I built Quest https://github.com/hverlin/Quest during the lockdown to search content across several apps (Gmail, Jira, Confluence...) as I could not find one that would allow me to do this.

I think you have to watch someone writing a great novel or writing good code. Not just read it.

I believe that just reading without understanding the thought process only helps a little.

The previous version was not really good on the accessibility side of things.

See this article for example: https://darekkay.com/blog/accessible-ui-frameworks/

Maybe it has improved now?

Buying non-open source software is quite risky. Buying non-open source software or using third party services is only valuable in the case that if it fails you can replace it easily.

Once you start relying on it a bit too much, it can hurt really badly if you are not able to fix issues by yourself, or if they decide to change the price later on. The worse is when a company that you were paying a software for goes out of business. You just have to start again.

you can always copy the code and install locally if you don't trust the publisher. That's the full benefit of open source. If it breaks in the future, just inspect and copy the new version again?

Definitely a great course, started learning JS using that one.

After watching that I would recommend https://github.com/getify/You-Dont-Know-JS and that should give one a solid base.

While some of the features in Kotlin are slowly coming to Java, that also means that one has to update Java (while you can use all the new kotlin while still targeting Java 8).

Some features like named parameters or null checking might probably never make it to Java.

There is a nice talk about this that compares Kotlin to what will be in Java 19:

https://youtu.be/te3OU9fxC8U

I was going to suggest to use rclone to download everything, but it seems that they are a couple of limitations: https://rclone.org/googlephotos/#downloading-images

Seems that using Google takeout is your best bet.

The UI is heavily inspired by the one from Trifacta/Cloud Dataprep. (i.e. histograms when selecting columns, brushing to start a transformation...)

I guess that makes it easy to get started with pandas (and learn about the pandas api). I wonder how some advanced transforms such as join/union/pivot will look like?

Firefox has better tooling for CSS (really good flexbox for e.g.) but it lacks on the JS side.

One basic feature that is missing for e.g. is that one cannot open a file using the syntax filename:line:column in the source editor. You will need to navigate the line number manually after opening the file.

> Going to the reference guides to learn an API is like reading a dictionary to learn English. There's not a lot of context.

Exactly! Examples are usually the most useful thing in the documentation.

Based on my experience, people go first to the examples and then read the description.

I guess that's also why stackoverflow is working so well as it is basically a large library of examples.