G1N
arch -x86_64 sh -c "$(curl -fsSL https://raw.githubusercontent.com/ezpieco/gethooky/master/tools/install.sh)"
mv: fastcopy: open() failed (to): /usr/bin/hooky: Operation not permitted
six (84%)
Close enough I suppose
As an aside, is it just me or do a lot of these new project management apps coopt Linear's style? Not saying that this is completely derivative, the website just gave me those vibes (and I won't sign up to try out the demo so maybe some screenshots on the front page would be nice :P)
(() => {
const logEvent = event => console.log({
coords: [event.screenX, event.screenY],
type: event.type
});
const input = document.querySelector("textarea");
// use "keydown" instead of "keypress" to detect all keyboard input instead of just character producing input
input.addEventListener("keydown", logEvent);
input.addEventListener("click", logEvent);
})();
const isInvokedByMouse = event =>
event.type === 'click' && (event.screenX !== 0 || event.screenY !== 0);
Copilot has definitely helped me speed up via not having to type a lot of boilerplate and line completion, but I'd say that would be at most ~50% speed up when it comes to greenfield development and half that when it comes to maintenance work (and even these figures are probably generous). A 4x speed up sounds ridiculous; expectations like this are how your codebases get filled with GPT generated garbage that is connected together with GPT generated glue and then wrapped with GPT duct tape and a bow
The more I do this software engineering thing the more I feel like this “advice” bites me in the butt. Understanding when you should duplicate code versus when you should consolidate (or if you should just write a TODO saying “determine if this should be split up by [some set in stone timeline]”) is simply just a HARD problem (sometimes at least), and we should treat it as such.
DRY/ WET or whatever shouldn’t be a maxim (let alone a habit! lol), it should at best be a hand-wavey 2-bit dismissal you give an annoyingly persistent junior software dev who you don’t want to actually help!
Relevant npm packages: - @jest/globals (I use these to import `describe`, `test`, `expect` and other test-related functions) - ts-jest
My tsconfig.json:
{
"buildOptions": {},
"compilerOptions": {
"target": "ES6",
"module": "ESNext",
"lib": [
"ES6",
"DOM",
"ES2017",
"DOM.Iterable"
],
"moduleResolution": "Bundler",
"jsx": "react-jsx",
"declaration": true,
"strict": true,
"esModuleInterop": true,
"skipLibCheck": true,
"forceConsistentCasingInFileNames": true,
"outDir": "./dist"
},
"include": [
"src",
"__tests__",
"*.config.ts",
"sandbox.ts",
"sandbox-ui.js"
]
}
import type { Config } from "jest";
export default {
preset: "ts-jest",
testEnvironment: "jsdom",
testMatch: ["\*/__tests__/\*/*.test.ts"],
globals: {
fetch: global.fetch,
},
} as Config;
> While we can not infer what the root cause of the change in traffic patterns on the 16th can be attributed to, it does warrant the foundational question of “Is there any correlation between the observations on the 16th and the outage on the 19th?”. As more details from the event emerge, Bitsight will continue investigating the data.
Interested to know how they're capturing sample data for IPs accessing Crowdstrike Falcon APIs and the corresponding packet data.
EDIT: Not to mention that they're able to distill their dataset to group IPs by their representative organization. Would love to poke around the original dataset if it is for whatever reason out in the wild somewhere.
A sample response takes this form: `{ type: 'data', nodes: [ { type: 'data', data: [Array], uses: [Object] }, ... ] }`
Things get a little strange (for me at least!) when I start poking around in the data array. At index 0 in this array is an object with some information on what I think is mostly just paging and the length of the data array (sans this first element). At index 1 is an array filled with numbers that correspond to array indices in the initial data array, and the objects at those specified indices are the actual data sources. While the keys in those objects are actual descriptors of relevant information, the VALUES for those keys are also array indices. Essentially the incoming data structure is a super flattened array with some objects/ additional arrays that just point to other indices in the data array.[1]
Is there a name for this type of pattern? Is it just an artifact of using some query library to handle data fetching? Apologies for the naivety, I still consider myself a fairly new dev (especially when I see something like this!).
[1] More complete example (not sure if I explained this well):
{
type: 'data',
data: [
{ endpoints: 1, count: 3971, currentPage: 5 },
[2,221,355,...], // at array index 2 we should expect an object
{ id: 3, commentsRatio: 4, owaspIssues: 6, ... }, // array index 2: object with values that are all indices in the original data array that hold the actual values!
...
]
}MaxRewards is an Atlanta-based financial technology company that enriches people's lives by creating extraordinary benefits from everyday spend. The average American household can earn over $2,000 in tax-free rewards and savings every year! However, few do, since it takes so much time and effort. We build technology that automates savings. Today, we help consumers maximize credit card rewards and cashback by proactively activating offers and benefits, providing personalized recommendations for card usage and aggregating bills, spend, savings and more.
We just finished raising our seed round, and are looking to quickly grow our engineering org. All of our postings can be found here: