rekwah

I would recommend looking into something like Gator[0] that allows you to send messages that delay delivery until the recipients morning the following workday.

[0] https://slack.com/apps/ANPGHD2F8-gator

I find https://leaddev.com/ has some good content, unsure if there's an associated Slack/Discord server for it.

Tangentially related to graph dbs, but if you're looking for more hierarchical support, SQLite does has a transitive closure extension[0] that might be of some assistance. I leveraged this back in 2014 to write our framework-agnostic result storage on AWS Device Farm.

[0] - https://www.sqlite.org/cgi/src/artifact/636024302cde41b2bf0c...

[1] - https://charlesleifer.com/blog/querying-tree-structures-in-s...

There are a few other sister sites, shown here https://github.com/lobsters/lobsters/wiki

Bootstrapped.fm community at https://discuss.bootstrapped.fm/

Additional approaches in this space:

* https://hashids.org/

* https://github.com/ulid/spec

A nice complement to this would be tooling that treats file revisions as time series data, e.g. plot the fire contained percentage over time.

Any existing tools out there?

Disagree. What happens if you have an emergency? Then you end up withdrawing from the 401k + penalty.

Google, Amazon, Facebook, or Apple.

https://en.wikipedia.org/wiki/Big_Four_tech_companies

Anecdotally, I feel it's less common than merge commits. There are plenty of places driven by the "Merge Pull Request" button in GitHub and that's the default functionality.

In personal projects or those with fewer developers, I prefer rebase + FF merge for a clean history. I don't really feel the need to see the merge commit in the master branch history.

You rebase your feature/topic branches on top of master and then merge the feature/topic branch back onto master, enabling a fast-forward merge.

If you happen to use Probot, there's a plugin that supports automatic issue creation.

* https://probot.github.io/

* https://github.com/JasonEtco/todo

More of a DAO than an ORM.

These exist.

* https://aws.amazon.com/device-farm/

* https://www.xamarin.com/test-cloud

* https://bitbar.com/testing/

* https://saucelabs.com/devices

Guessing you're talking about Screenhero.

https://screenhero.com/

Maybe something like Common Workflow Language[0]?

[0] http://www.commonwl.org/v1.0/UserGuide.html

I wrote a pretty significant process wrapper in python at $PREVIOUS_JOB. The problem I have with these loose wrappers around subprocess is that they're, imho, solving the wrong problem. Or, maybe better put, not solving _enough_ of the problem.

Imagine writing a wrapper for "grep". It may work in one environment, but if you need portability, you're going to quickly realize that there are nuances in implementation and the actual calling interface. Now you're handling branching logic in your application code based on platform, version, etc.

Interfacing with a command line tool shouldn't be thought of much different than a remote HTTP/ReST API talking text/plain instead of application/json. You're looking for your "client wrapper" to handle argument validation, parsing, versioning, etc.

It's a reference to https://news.ycombinator.com/item?id=9695102

Reminds me of osquery [0].

[0] - https://github.com/facebook/osquery

I would recommend https://hackernoon.com/

I've created a goodreads list[0] for top-level comment recommendations. However, it appears a user may only vote for a max of 100 books per list[1]. So, additional contributors welcome!

[0] - https://www.goodreads.com/list/show/106689.Ask_HN_Books_you_...

[1] - https://www.goodreads.com/topic/show/1060933-listopia-list-l...

I like the color bomb when you switch away from the tab for a bit and come back to an onslaught of events get processed by the UI.

Although, not feature parity with this project, Pybreaker[0] for the circuit breaker patterns in Python.

[0] - https://github.com/danielfm/pybreaker

I've love to see this integrated with a TV/Movie scrobbler such as trakt.tv.

I'm curious if this is easier to handle with non-liquid assets?

Imagine he has a $100k fishing boat instead of $100k stuffed in a mattress. Is the spouse more willing to sign a prenup if it's easier to make the mental separation between "mine" and "theirs" when it's a physical asset?

If they were to lose and lose all future appeals and Apple still didn't wish to comply, what would it take to get around such a request?

Would Apple have to re-incorporate outside of the U.S.A?

I've been known to put fake skills in my LinkedIn profile in hopes of catching scripted recruiter emails that include these amusing keywords.

>>> "With your underwater basket-weaving chops, the Cloud Fabric Services team will surpass its goal of exceeding 100M users by 2015."

Are you actually slower than coworkers in an apples to apples comparison? Normally when I see things like this, it's usually comparing developers having a different definition of "complete". One will write the code, the unit tests, the e2e tests, and the documentation before saying the task it complete. The other, trumpets completion once the code is done.

If you're actually slower, I'd start keeping track of where my time is going. Are you spending too long imagining all possible scenarios of a feature? Taking two hour lunches and coffee breaks every hour? Many hours spent in meetings? Wasting time building a "super generic" solution that isn't necessary? Spending three days writing tests for a feature that took 5 hours?

If you don't feel like you're actually slow, it's just a problem of perception. I'd take some higher visibility features and crank them out, working the extra hours if necessary. I'd rather kick the stigma than deal with that anchor around my neck. Tread carefully with this strategy as it can be a double-edged sword and increase expectations and workload.

I've also noticed that Linkedin profile scraping has become more prevalent over the years. I've countered this by adding a few fake skills to my profile.

> "With your underwater basket-weaving chops, the <redacted> team will surpass its goal of exceeding 100M users by 2015."

These, usually more subtle markers, are helpful to scan for when glancing through any recruiter emails.