_cfl0

I built haystack - natural language search engine for workplace technical knowledge.

I've been a software engineer for a few years now,

A few weeks ago I was scrolling through confluence pages trying to find ssh connection details to our jenkins second integration machine for 40 minutes straight, later I discovered my co-worker slack'ed me the ssh connection string *two months ago*.

A week later I started working on haystack - a search engine for workplace apps.. It enables you to search slack, confluence, jira, teams, sharepoint, github, and email in one place.

It supports natural language queries so a query like: "how to connect to integ2 machine?" yields:

  ssh -i private.pem ubuntu@ec2-integration2.eu-est-1.compute.amazonaws.com

haystack is self hosted and stores user data locally, it has a completely client-side version, and a a self-hosted docker container version - only you have access to internal docs, I didn't want to deal with security compliance headaches caused from storing user data in the cloud + I don’t want your internal docs/messages.

Rolled it out to my co-workers a week ago and they thought it's a hit, so I'm planning on releasing it publicly on March 2023.

*Early access*

More technical details are available on github, code released on March 23’:

<https://github.com/haystackoss/haystack>

If you want to try it out before March 2023 - Available here <https://haystack.it>

Sure, read docs.nabaz.io (CI solution w/ storage over mongodb)

You aren't interrupted, you choose when to alt+tab to see your test results.

Main difference is that crystalball still runs all the tests, but runs the recently failed ones first.

Nabaz selects a small subset of affected tests, reducing CPU usage, and more importantly improving speed drastically!

10.

Nx is even clealry different. It isn’t run on every code change, but on commits.

You can’t use it live, And also the analysis granularity is just way too wide compared to this.

Right.. Because out of a 100 tests it will run close to that number. when you change code most of the time only a handful of tests or less need to run.

Had what since forever? Does jest analyze the changes you make and compare them to code coverage? (hint: no)

The key innovation piece here is the speed that the extreme selectively enables you.

I also have a CI solution I’m launching soon.

Other than that, most of this tech was forgotten in the late 90s early 2000s

Not bulletproof, but a-ok if your running a full run just before the commit.

Toda ;)

The second part is the aim here.

This is more of a code watcher than a test watcher specifically.

collab w/ me ;)

Not only the time to boot, but also if you don’t run tests selectively, you’re already too slow.

Furthermore, it will still display the build error + the previous failure list.

So you can always rely on that background terminal for actual test failure reasons.

Problem being is “make && make check” take way too much time normally.

The ordering feature is actually being built as we speak. analyzing liklihood can still be beneficial to cut down time even more.

If I would get a break from hn comments I could finish it today lol ;)

1. No, if build fails hypertest will just discard the result. autosave is even prefered.

2. The first run and every subsequent one collects code coverage which is saved in an sqlite db. Every file change is compared to the code coverage.

Although this approach isnt perfect, The idea here is being fast. I always rerun the entire suite just before committing the code.

Love that mantra! Dont really agree, it’s not intended for that.

I use it as I would run tests through a terminal normally. Built this because I hate running tests.

Bazel is awesome, it just runs way too many tests to be fast enough

Well, I would say the biggest difference is while the watch mode you described runs all the tests for every change.

hypertest only runs the tests the were impacted by the changed code. Resulting is blazing fast performance.

I’d say it’s even fast than apples alt+tab animation most of the time.

Appreciated! Would love to hear you’re feedback after you ran it also :)

Well, I wouldn't say i'm being selfless here, I benefit as a user lol :)

Some background, I was diagnosed with ADHD when I was 5, moved in and out of schools through elementry/middleschool, ultimatly dropped out of highschool, I'm familiar with ADHD ;)

If you have any suggestions/feature-requests., or maybe have some ADHD experiences to share. this is for sure the place.

We love gta! A few key differences though: 1. We analyze the effect of code changed on code coverage, which means we only compare changed code to runtime information (code that actually ran). gta analyzes statically.

Let's assume you have a function:

  func myFunction(a int) {

      if(a > 10) {  

          func1()  

      } else if (a < 4) {  

          func2()  

      } else {  

          func3()

      }  
  }

The test will be skipped because no change could of affected it's result. NOT in gta.

Thanks guys for all your feedback!

We took all notes to heart, the main problem we identified that currently (at this stage of the product cycle we don't yet support all edge cases)

And this hurts usability and value, will figure out a way to deliver this kind of tech in a way that is still valuable at this early stage :)

THIS point though, Im inclined to share our edge case doc with HN and let people add stuff.

Basically all of them as long as their used.

Would love to know more about your use case, email is somewhere in the comments

Wow! Seems like a challenge to test, would love to see what we can do.

Regarding side effects, completely fine as long as they're mapped out. Would love to hear more, nothing pitchy or salesy.

java is scheduled next, would absolutely love to hear about your use-case?